EngineStressSuite

abstract class EngineStressSuite<TEngine : ApplicationEngine, TConfiguration : Configuration> : 
    EngineTestBase<TEngine, TConfiguration>

Constructors

<init>

EngineStressSuite(
    hostFactory: ApplicationEngineFactory<TEngine, TConfiguration>)

Properties

timeout

open val timeout: PublishedTimeout

Inherited Properties

applicationEngineFactory

val applicationEngineFactory: ApplicationEngineFactory<TEngine, TConfiguration>

callGroupSize

var callGroupSize: Int

coroutineContext

open val coroutineContext: <ERROR CLASS>

enableHttp2

var enableHttp2: Boolean

enableSsl

var enableSsl: Boolean

exceptions

val exceptions: ArrayList<Throwable>

isUnderDebugger

val isUnderDebugger: Boolean

port

var port: Int

server

var server: TEngine?

socketReadTimeout

val socketReadTimeout: Int

sslPort

var sslPort: Int

test

val test: TestName

testDispatcher

val testDispatcher: ExecutorCoroutineDispatcher

testLog

val testLog: Logger

Functions

high load stress test

fun high load stress test(): Unit

multiple connections high pressure

fun multiple connections high pressure(): Unit

single connection high pressure

fun single connection high pressure(): Unit

single connection single thread no pipelining

fun single connection single thread no pipelining(): Unit

single connection single thread with pipelining

fun single connection single thread with pipelining(): Unit

test http upgrade

fun test http upgrade(): Unit

test respond write

fun test respond write(): Unit

test404

fun test404(): Unit

testLongResponse

fun testLongResponse(): Unit

Inherited Functions

configure

open fun configure(configuration: TConfiguration): Unit

createAndStartServer

fun createAndStartServer(
    log: Logger? = null,
    parent: <ERROR CLASS> = EmptyCoroutineContext,
    routingConfigurer: Routing.() -> Unit
): TEngine

createServer

open fun createServer(
    log: Logger?,
    parent: <ERROR CLASS> = EmptyCoroutineContext,
    module: Application.() -> Unit
): TEngine

features

open fun features(
    application: Application,
    routingConfigurer: Routing.() -> Unit
): Unit

findFreePort

fun findFreePort(): Int

setUpBase

fun setUpBase(): Unit

socket

fun socket(block: Socket.() -> Unit): Unit

tearDownBase

fun tearDownBase(): Unit

withUrl

fun withUrl(
    path: String,
    builder: suspend HttpRequestBuilder.() -> Unit = {},
    block: suspend HttpResponse.(Int) -> Unit
): Unit

Extension Functions

decodeChunked

fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): 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

httpServer

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

Start an http server with settings invoking handler for every request

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

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

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