ktor-server-core/io.ktor.server.routing

Package-level declarations

Types

AndRouteSelector

data class AndRouteSelector(val first: RouteSelector, val second: RouteSelector) : RouteSelector

Evaluates a route as a result of the AND operation using two other selectors.

ConstantParameterRouteSelector

data class ConstantParameterRouteSelector(val name: String, val value: String) : RouteSelector

Evaluates a route against a constant query parameter value.

HostRouteSelector

data class HostRouteSelector(val hostList: List<String>, val hostPatterns: List<Regex>, val portsList: List<Int>) : RouteSelector

Evaluates a route against a request's host and port.

HttpAcceptRouteSelector

data class HttpAcceptRouteSelector(val contentType: ContentType) : RouteSelector

Evaluates a route against a Content-Type in the HttpHeaders.Accept request header.

HttpHeaderRouteSelector

data class HttpHeaderRouteSelector(val name: String, val value: String) : RouteSelector

Evaluates a route against a header in the request.

HttpMethodRouteSelector

data class HttpMethodRouteSelector(val method: HttpMethod) : RouteSelector

Evaluates a route against an HttpMethod.

HttpMultiAcceptRouteSelector

data class HttpMultiAcceptRouteSelector(val contentTypes: List<ContentType>) : RouteSelector

Evaluates a route against a Content-Type in the HttpHeaders.Accept request header.

LocalPortRouteSelector

data class LocalPortRouteSelector(val port: Int) : RouteSelector

Evaluates a route against the port on which a call is received.

OptionalParameterRouteSelector

data class OptionalParameterRouteSelector(val name: String) : RouteSelector

Evaluates a route against an optional query parameter value and captures its value, if found.

OrRouteSelector

data class OrRouteSelector(val first: RouteSelector, val second: RouteSelector) : RouteSelector

Evaluates a route as a result of the OR operation using two other selectors.

ParameterRouteSelector

data class ParameterRouteSelector(val name: String) : RouteSelector

Evaluates a route against a query parameter value and captures its value.

PathSegmentConstantRouteSelector

data class PathSegmentConstantRouteSelector(val value: String) : RouteSelector

Evaluates a route against a constant path segment.

PathSegmentOptionalParameterRouteSelector

data class PathSegmentOptionalParameterRouteSelector(val name: String, val prefix: String? = null, val suffix: String? = null) : RouteSelector

Evaluates a route against an optional parameter path segment and captures its value, if any.

PathSegmentParameterRouteSelector

data class PathSegmentParameterRouteSelector(val name: String, val prefix: String? = null, val suffix: String? = null) : RouteSelector

Evaluates a route against a parameter path segment and captures its value.

PathSegmentRegexRouteSelector

class PathSegmentRegexRouteSelector(regex: Regex) : RouteSelector

PathSegmentSelectorBuilder

object PathSegmentSelectorBuilder

A helper object for building instances of RouteSelector from path segments.

PathSegmentTailcardRouteSelector

data class PathSegmentTailcardRouteSelector(val name: String = "", val prefix: String = "") : RouteSelector

Evaluates a route against any number of trailing path segments, and captures their values.

PathSegmentWildcardRouteSelector

object PathSegmentWildcardRouteSelector : RouteSelector

Evaluates a route against any single path segment.

RootRouteSelector

class RootRouteSelector(rootPath: String = "") : RouteSelector

A selector for a routing root.

RootRouting

interface RootRouting : Routing

A builder for a routing tree root.

RouteSelector

abstract class RouteSelector

Serves as the base type for routing selectors.

RouteSelectorEvaluation

sealed class RouteSelectorEvaluation

A result of a route evaluation against a call.

Routing

interface Routing

A builder for a routing tree.

RoutingCall

class RoutingCall : ApplicationCall

A single act of communication between a client and server that is handled in RoutingRoot.

RoutingContext

class RoutingContext(val call: RoutingCall)

The context of a RoutingHandler that is used to handle a RoutingCall.

RoutingHandler

typealias RoutingHandler = suspend RoutingContext.() -> Unit

A function that handles a RoutingCall.

RoutingNode

open class RoutingNode(val parent: RoutingNode?, val selector: RouteSelector, val developmentMode: Boolean = false, val environment: ApplicationEnvironment) : ApplicationCallPipeline, Routing

Describes a node in a routing tree.

RoutingPath

class RoutingPath

A parsed routing path. Consist of number of segments parts.

RoutingPathSegment

data class RoutingPathSegment(val value: String, val kind: RoutingPathSegmentKind)

A single routing path segment.

RoutingPathSegmentKind

enum RoutingPathSegmentKind : Enum<RoutingPathSegmentKind>

Possible routing path segment kinds.

RoutingPipelineCall

class RoutingPipelineCall(val engineCall: PipelineCall, val route: RoutingNode, val coroutineContext: CoroutineContext, receivePipeline: ApplicationReceivePipeline, responsePipeline: ApplicationSendPipeline, val pathParameters: Parameters) : PipelineCall, CoroutineScope

An application call handled by RoutingRoot.

RoutingPipelineRequest

class RoutingPipelineRequest(val call: RoutingPipelineCall, val pipeline: ApplicationReceivePipeline, val engineRequest: PipelineRequest) : PipelineRequest

An application request handled by RoutingRoot.

RoutingPipelineResponse

class RoutingPipelineResponse(val call: RoutingPipelineCall, val pipeline: ApplicationSendPipeline, val engineResponse: PipelineResponse) : PipelineResponse

An application response handled by RoutingRoot.

RoutingRequest

class RoutingRequest : ApplicationRequest

A client's request that can be handled in RoutingRoot. To learn how to handle incoming requests, see Handling requests.

RoutingResolveContext

class RoutingResolveContext(val routing: RoutingNode, val call: PipelineCall, tracers: List<(RoutingResolveTrace) -> Unit>)

Represents a context in which routing resolution is being performed

RoutingResolveResult

sealed class RoutingResolveResult

Represents a result of routing resolution.

RoutingResolveTrace

class RoutingResolveTrace(val call: PipelineCall, val segments: List<String>)

Represents the trace of routing resolution process for diagnostics.

RoutingResolveTraceEntry

open class RoutingResolveTraceEntry(val route: RoutingNode, val segmentIndex: Int, var result: RoutingResolveResult? = null)

Represents a single entry in the RoutingResolveTrace.

RoutingResponse

class RoutingResponse : ApplicationResponse

A server's response that can be used to respond in RoutingRoot. To learn how to send responses inside route handlers, see Sending responses.

RoutingRoot

class RoutingRoot(val application: Application) : RoutingNode, RootRouting

A root routing node of an Application. You can learn more about routing in Ktor from Routing.

TrailingSlashRouteSelector

object TrailingSlashRouteSelector : RouteSelector

Evaluates a route against a single trailing slash.

Properties

application

val Routing.application: Application

Gets an Application for this RoutingNode by scanning the hierarchy to the root.

IgnoreTrailingSlash

val IgnoreTrailingSlash: ApplicationPlugin<Unit>

A plugin that enables ignoring a trailing slash when resolving URLs.

RoutingFailureStatusCode

val RoutingFailureStatusCode: AttributeKey<HttpStatusCode>

Functions

fun Routing.accept(vararg contentTypes: ContentType, build: Routing.() -> Unit): Routing

Builds a route to match requests with the HttpHeaders.Accept header matching any of the specified contentTypes.

contentType

fun Routing.contentType(contentType: ContentType, build: Routing.() -> Unit): Routing

Builds a route to match requests with the HttpHeaders.ContentType header matching the specified contentType.

createRouteFromPath

fun Routing.createRouteFromPath(path: String): Routing

Creates a routing entry for the specified path.

delete

fun Routing.delete(body: RoutingHandler): Routing

Builds a route to match DELETE requests.

fun Routing.delete(path: String, body: RoutingHandler): Routing

Builds a route to match DELETE requests with the specified path.

fun Routing.delete(path: Regex, body: RoutingHandler): Routing

Builds a route to match DELETE requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

get

fun Routing.get(body: RoutingHandler): Routing

Builds a route to match GET requests.

fun Routing.get(path: String, body: RoutingHandler): Routing

Builds a route to match GET requests with the specified path.

fun Routing.get(path: Regex, body: RoutingHandler): Routing

Builds a route to match GET requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

getAllRoutes

fun RoutingNode.getAllRoutes(): List<RoutingNode>

Return list of endpoints with handlers under this route.

head

fun Routing.head(body: RoutingHandler): Routing

Builds a route to match HEAD requests.

fun Routing.head(path: String, body: RoutingHandler): Routing

Builds a route to match HEAD requests with the specified path.

fun Routing.head(path: Regex, body: RoutingHandler): Routing

Builds a route to match HEAD requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

header

fun Routing.header(name: String, value: String, build: Routing.() -> Unit): Routing

Builds a route to match a header with the specified name and value.

host

fun Routing.host(host: String, port: Int = 0, build: Routing.() -> Unit): Routing

Creates a route to match a request's host and port. There are no any host resolutions/transformations applied to a host: a request host is treated as a string.

fun Routing.host(hosts: List<String>, ports: List<Int> = emptyList(), build: Routing.() -> Unit): Routing

fun Routing.host(hostPattern: Regex, port: Int = 0, build: Routing.() -> Unit): Routing

Creates a route to match a request host and port. There are no any host resolutions/transformations applied to a host: a request host is treated as a string.

fun Routing.host(hosts: List<String>, hostPatterns: List<Regex>, ports: List<Int> = emptyList(), build: Routing.() -> Unit): Routing

Creates a route to match s request host and port. There are no any host resolutions/transformations applied to a host: a request host is treated as a string.

insertPhaseAfter

fun Routing.~~insertPhaseAfter~~(reference: PipelinePhase, phase: PipelinePhase)

insertPhaseBefore

fun Routing.~~insertPhaseBefore~~(reference: PipelinePhase, phase: PipelinePhase)

intercept

fun Routing.~~intercept~~(phase: PipelinePhase, block: suspend PipelineContext<Unit, PipelineCall>.(Unit) -> Unit)

localPort

fun Routing.localPort(port: Int, build: Routing.() -> Unit): Routing

Creates a route to match a port on which a call was received.

method

fun Routing.method(method: HttpMethod, body: Routing.() -> Unit): Routing

Builds a route to match the specified HTTP method.

optionalParam

fun Routing.optionalParam(name: String, build: Routing.() -> Unit): Routing

Builds a route to capture an optional parameter with specified name, if it exists.

options

fun Routing.options(body: RoutingHandler): Routing

Builds a route to match OPTIONS requests.

fun Routing.options(path: String, body: RoutingHandler): Routing

Builds a route to match OPTIONS requests with the specified path.

fun Routing.options(path: Regex, body: RoutingHandler): Routing

Builds a route to match OPTIONS requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

param

fun Routing.param(name: String, build: Routing.() -> Unit): Routing

Builds a route to match a parameter with the specified name and captures its value.

fun Routing.param(name: String, value: String, build: Routing.() -> Unit): Routing

Builds a route to match a parameter with the specified name and value.

patch

fun Routing.patch(body: RoutingHandler): Routing

Builds a route to match PATCH requests.

@JvmName(name = "patchTyped")

inline fun <R : Any> Routing.patch(crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PATCH requests receiving a request body as content of the R type.

fun Routing.patch(path: String, body: RoutingHandler): Routing

Builds a route to match PATCH requests with the specified path.

@JvmName(name = "patchTypedPath")

inline fun <R : Any> Routing.patch(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PATCH requests with the specified path receiving a request body as content of the R type.

fun Routing.patch(path: Regex, body: RoutingHandler): Routing

Builds a route to match PATCH requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

@JvmName(name = "patchTypedPath")

inline fun <R : Any> Routing.patch(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PATCH requests with the specified regex path receiving a request body as content of the R type. Named parameters from regex can be accessed via ApplicationCall.parameters.

port

fun Routing.port(vararg ports: Int, build: Routing.() -> Unit): Routing

Creates a route to match a request port.

post

fun Routing.post(body: RoutingHandler): Routing

Builds a route to match POST requests.

@JvmName(name = "postTyped")

inline fun <R : Any> Routing.post(crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match POST requests receiving a request body as content of the R type.

fun Routing.post(path: String, body: RoutingHandler): Routing

Builds a route to match POST requests with the specified path.

@JvmName(name = "postTypedPath")

inline fun <R : Any> Routing.post(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match POST requests with the specified path receiving a request body as content of the R type.

fun Routing.post(path: Regex, body: RoutingHandler): Routing

Builds a route to match POST requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

@JvmName(name = "postTypedPath")

inline fun <R : Any> Routing.post(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match POST requests with the specified regex path receiving a request body as content of the R type. Named parameters from regex can be accessed via ApplicationCall.parameters.

put

fun Routing.put(body: RoutingHandler): Routing

Builds a route to match PUT requests.

@JvmName(name = "putTyped")

inline fun <R : Any> Routing.put(crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PUT requests receiving a request body as content of the R type.

fun Routing.put(path: String, body: RoutingHandler): Routing

Builds a route to match PUT requests with the specified path.

@JvmName(name = "putTypedPath")

inline fun <R : Any> Routing.put(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PUT requests with the specified path receiving a request body as content of the R type.

fun Routing.put(path: Regex, body: RoutingHandler): Routing

Builds a route to match PUT requests with the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

@JvmName(name = "putTypedPath")

inline fun <R : Any> Routing.put(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Routing

Builds a route to match PUT requests with the specified regex path receiving a request body as content of the R type. Named parameters from regex can be accessed via ApplicationCall.parameters.

route

fun Routing.route(path: String, build: Routing.() -> Unit): Routing

Builds a route to match the specified path.

fun Routing.route(path: Regex, build: Routing.() -> Unit): Routing

Builds a route to match the specified regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

fun Routing.route(path: String, method: HttpMethod, build: Routing.() -> Unit): Routing

Builds a route to match the specified HTTP method and path.

fun Routing.route(path: Regex, method: HttpMethod, build: Routing.() -> Unit): Routing

Builds a route to match the specified HTTP method and regex path. Named parameters from regex can be accessed via ApplicationCall.parameters.

routing

fun Application.routing(configuration: RootRouting.() -> Unit): RoutingRoot

Installs a RoutingRoot plugin for the this Application and runs a configuration script on it. You can learn more about routing in Ktor from Routing.