io.ktor.server.servlet / AsyncServletApplicationRequest

AsyncServletApplicationRequest

class AsyncServletApplicationRequest : 
    ServletApplicationRequest, 
    CoroutineScope

Constructors

<init>

AsyncServletApplicationRequest(
    call: ApplicationCall, 
    servletRequest: HttpServletRequest, 
    coroutineContext: <ERROR CLASS>)

Properties

coroutineContext

val coroutineContext: <ERROR CLASS>

Inherited Properties

cookies	`open val cookies: RequestCookies` Cookies for this request
headers	`open val headers: Headers` Headers for this request
local	`open val local: RequestConnectionPoint` Contains http request and connection details such as a host name used to connect, port, scheme and so on. No proxy headers could affect it. Use ApplicationRequest.origin if you need override headers support
queryParameters	`open val queryParameters: Parameters` Parameters provided in an URL
servletRequest	`val servletRequest: HttpServletRequest`

Functions

receiveChannel

fun receiveChannel(): ByteReadChannel

Request’s body channel (for content only)

Extension Properties

httpMethod	`val ApplicationRequest.httpMethod: HttpMethod` Returns request HTTP method possibly overridden via header X-Http-Method-Override
httpVersion	`val ApplicationRequest.httpVersion: String` Request’s HTTP version
javaSecurityPrincipal	`val ApplicationRequest.javaSecurityPrincipal: Principal?` Returns Java’s JAAS Principal
origin	`val ApplicationRequest.origin: RequestConnectionPoint` Represents request and connection parameters possibly overridden via https headers. By default it fallbacks to ApplicationRequest.local
uri	`val ApplicationRequest.uri: String` Request’s URI (including query string)

Extension Functions

accept	`fun ApplicationRequest.accept(): String?` Request’s `Accept` header value
acceptCharset	`fun ApplicationRequest.acceptCharset(): String?` Request’s `Accept-Charset` header value
acceptCharsetItems	`fun ApplicationRequest.acceptCharsetItems(): List<HeaderValue>` Parsed and sorted request’s `Accept-Charset` header value
acceptEncoding	`fun ApplicationRequest.acceptEncoding(): String?` Request’s `Accept-Encoding` header value
acceptEncodingItems	`fun ApplicationRequest.acceptEncodingItems(): List<HeaderValue>` Parsed and sorted request’s `Accept-Encoding` header value
acceptItems	`fun ApplicationRequest.acceptItems(): List<HeaderValue>` Parsed request’s `Accept` header and sorted according to quality
acceptLanguage	`fun ApplicationRequest.acceptLanguage(): String?` Request’s `Accept-Language` header value
acceptLanguageItems	`fun ApplicationRequest.acceptLanguageItems(): List<HeaderValue>` Parsed and sorted request’s `Accept-Language` header value
authorization	`fun ApplicationRequest.authorization(): String?` Request authorization header value
basicAuthenticationCredentials	`fun ApplicationRequest.basicAuthenticationCredentials( charset: Charset? = null ): UserPasswordCredential?` Retrieves Basic authentication credentials for this ApplicationRequest
cacheControl	`fun ApplicationRequest.cacheControl(): String?` Request’s `Cache-Control` header value
contentCharset	`fun ApplicationRequest.contentCharset(): Charset?` Request’s charset
contentType	`fun ApplicationRequest.contentType(): ContentType` Request’s content type or `ContentType.Any`
decodeChunked	`fun CoroutineScope.decodeChunked( input: ByteReadChannel ): DecoderJob` `fun CoroutineScope.decodeChunked( input: ByteReadChannel, contentLength: Long ): DecoderJob` Start a chunked stream decoder coroutine
document	`fun ApplicationRequest.document(): String` Request’s document name (substring after the last slash but before query string)
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
header	`fun ApplicationRequest.header(name: String): String?` First header value for header with name or `null` if missing
host	`fun ApplicationRequest.host(): String` Request’s host without port
httpServer	`fun CoroutineScope.httpServer( settings: HttpServerSettings, handler: HttpRequestHandler ): HttpServer` Start an http server with settings invoking handler for every request
httpServer	`fun CoroutineScope.httpServer( settings: HttpServerSettings, handler: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit ): HttpServer` Start an http server with settings invoking handler for every request
isChunked	`fun ApplicationRequest.isChunked(): Boolean` Check if request’s body is chunk-encoded
isMultipart	`fun ApplicationRequest.isMultipart(): Boolean` Check if request body is multipart-encoded
location	`fun ApplicationRequest.location(): String?` Request’s `Location` header value
mapEngineExceptions	`fun CoroutineScope.mapEngineExceptions( input: ByteReadChannel, request: HttpRequestData ): ByteReadChannel` Returns ByteReadChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException. `fun CoroutineScope.mapEngineExceptions( input: ByteWriteChannel, request: HttpRequestData ): ByteWriteChannel` Returns ByteWriteChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException.
parseAuthorizationHeader	`fun ApplicationRequest.parseAuthorizationHeader(): HttpAuthHeader?` Parses an authorization header from a ApplicationRequest returning a HttpAuthHeader.
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
path	`fun ApplicationRequest.path(): String` Request’s path without query string
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
port	`fun ApplicationRequest.port(): Int` Request’s port extracted from `Host` header value
queryString	`fun ApplicationRequest.queryString(): String` Request’s query string or empty string if missing
ranges	`fun ApplicationRequest.ranges(): RangesSpecifier?` Parsed request’s `Range` header value
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: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit ): Job` Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature
startServerConnectionPipeline	`fun CoroutineScope.startServerConnectionPipeline( connection: ServerIncomingConnection, 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
toLogString	`fun ApplicationRequest.toLogString(): String` Generates a string representing this ApplicationRequest suitable for logging
userAgent	`fun ApplicationRequest.userAgent(): String?` Request’s `User-Agent` header value
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`