io.ktor.server.servlet / AsyncServletApplicationResponse

AsyncServletApplicationResponse

open class AsyncServletApplicationResponse : 
    ServletApplicationResponse,
    CoroutineScope

Constructors

<init>
AsyncServletApplicationResponse(
    call: AsyncServletApplicationCall,
    servletRequest: HttpServletRequest,
    servletResponse: HttpServletResponse,
    engineContext: <ERROR CLASS>,
    userContext: <ERROR CLASS>,
    servletUpgradeImpl: ServletUpgrade,
    coroutineContext: <ERROR CLASS>)

Properties

coroutineContext
open val coroutineContext: <ERROR CLASS>

servletRequest
val servletRequest: HttpServletRequest

Inherited Properties

completed
var completed: Boolean

headers
open val headers: ResponseHeaders

Headers for this response

servletResponse
val servletResponse: HttpServletResponse

Functions

createResponseJob
open fun createResponseJob(): ReaderJob

push
open fun push(builder: ResponsePushBuilder): Unit

Produces HTTP/2 push from server to client or sets HTTP/1.x hint header or does nothing. Exact behaviour is up to engine implementation.

respondUpgrade
suspend fun respondUpgrade(upgrade: ProtocolUpgrade): Unit

Process upgrade response

Inherited Functions

responseChannel
suspend fun responseChannel(): ByteWriteChannel

Get response output channel

setStatus
open fun setStatus(statusCode: HttpStatusCode): Unit

Set underlying engine’s response status

Extension Functions

cacheControl
fun ApplicationResponse.cacheControl(
    value: CacheControl
): Unit

Append response Cache-Control HTTP header value

contentRange
fun ApplicationResponse.contentRange(
    range: LongRange?,
    fullLength: Long? = null,
    unit: RangeUnits
): Unit
fun ApplicationResponse.contentRange(
    range: LongRange?,
    fullLength: Long? = null,
    unit: String = RangeUnits.Bytes.unitToken
): Unit

Append response Content-Range header with specified range and fullLength

decodeChunked
fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): DecoderJob
fun CoroutineScope.decodeChunked(
    input: ByteReadChannel,
    contentLength: Long
): DecoderJob

Start a chunked stream decoder coroutine

embeddedServer
fun <TEngine : ApplicationEngine, TConfiguration : Configuration> CoroutineScope.embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    port: Int = 80,
    host: String = "0.0.0.0",
    watchPaths: List<String> = emptyList(),
    parentCoroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit
): TEngine

Creates an embedded server with the given factory, listening on host:port

etag
fun ApplicationResponse.etag(value: String): Unit

Append response E-Tag HTTP header value

expires
fun ApplicationResponse.expires(value: LocalDateTime): Unit

Append response Expires HTTP header value

header
fun ApplicationResponse.header(
    name: String,
    value: String
): Unit

Append HTTP response header with string value

fun ApplicationResponse.header(
    name: String,
    value: Int
): Unit

Append HTTP response header with integer numeric value

fun ApplicationResponse.header(
    name: String,
    value: Long
): Unit

Append HTTP response header with long integer numeric value

fun ApplicationResponse.header(
    name: String,
    date: Temporal
): Unit

Append HTTP response header with temporal date (date, time and so on)

httpServer
fun CoroutineScope.httpServer(
    settings: HttpServerSettings,
    handler: HttpRequestHandler
): HttpServer

Start an http server with settings invoking handler for every request

lastModified
fun ApplicationResponse.lastModified(
    dateTime: ZonedDateTime
): Unit

Append response Last-Modified HTTP header value from dateTime

link
fun ApplicationResponse.link(header: LinkHeader): Unit

Append Link header to HTTP response

fun ApplicationResponse.link(
    uri: String,
    vararg rel: String
): Unit

Append Link header to HTTP response with specified uri and rel

parseMultipart
fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    headers: HttpHeadersMap
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    contentType: CharSequence,
    contentLength: Long?
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    boundaryPrefixed: ByteBuffer,
    input: ByteReadChannel,
    totalLength: Long?
): ReceiveChannel<MultipartEvent>

Starts a multipart parser coroutine producing multipart events

pinger
fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: Duration,
    timeout: Duration,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    periodMillis: Long,
    timeoutMillis: Long,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified periodMillis to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeoutMillis and sending timeout close frame

pinger
fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: <ERROR CLASS>,
    timeout: <ERROR CLASS>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

ponger
fun CoroutineScope.ponger(
    outgoing: SendChannel<Pong>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Ping>

Launch a ponger actor job on the CoroutineScope sending pongs to outgoing channel. It is acting for every client’s ping frame and replying with corresponding pong

reader
fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend ReaderScope.() -> Unit
): ReaderJob
fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend ReaderScope.() -> Unit
): ReaderJob

startConnectionPipeline
fun CoroutineScope.startConnectionPipeline(
    input: ByteReadChannel,
    output: ByteWriteChannel,
    timeout: WeakTimeoutQueue,
    handler: HttpRequestHandler
): Job

Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature

writeMultipleRanges
fun CoroutineScope.writeMultipleRanges(
    channelProducer: (LongRange) -> ByteReadChannel,
    ranges: List<LongRange>,
    fullLength: Long?,
    boundary: String,
    contentType: String
): ByteReadChannel

Start multirange response writer coroutine

writer
fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend WriterScope.() -> Unit
): WriterJob
fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend WriterScope.() -> Unit
): WriterJob

Inheritors

JettyApplicationResponse
class JettyApplicationResponse : 
    AsyncServletApplicationResponse