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

Route

interface Route

A builder for a routing tree.

Inheritors

Properties

Link copied to clipboard
val Route.application: Application

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

Link copied to clipboard
abstract val attributes: Attributes
Link copied to clipboard
Link copied to clipboard
abstract val parent: Route?
Link copied to clipboard
var Route.staticBasePackage: String?

Base package for relative resources calculations for static content

Link copied to clipboard
var Route.staticRootFolder: File?

Base folder for relative files calculations for static content

Functions

Link copied to clipboard
fun Route.accept(vararg contentTypes: ContentType, build: Route.() -> Unit): Route

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

Link copied to clipboard
fun Route.contentType(contentType: ContentType, build: Route.() -> Unit): Route

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

Link copied to clipboard
abstract fun createChild(selector: RouteSelector): Route

Creates a child node in this node with a given selector or returns an existing one with the same selector.

Link copied to clipboard
fun Route.createRouteFromPath(path: String): Route

Creates a routing entry for the specified path.

Link copied to clipboard
fun Route.default(localPath: File)
fun Route.default(localPath: String)

Specifies localPath as a default file to serve when folder is requested

Link copied to clipboard
fun Route.defaultResource(resource: String, resourcePackage: String? = null)

Specifies resource as a default resources to serve when folder is requested

Link copied to clipboard
fun Route.delete(body: RoutingHandler): Route

Builds a route to match DELETE requests.

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

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

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

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

Link copied to clipboard
fun Route.file(remotePath: String, localPath: File)
fun Route.file(remotePath: String, localPath: String = remotePath)

Sets up routing to serve localPath file as remotePath

Link copied to clipboard
fun Route.files(folder: File)
fun Route.files(folder: String)

Sets up routing to serve all files from folder

Link copied to clipboard
fun Route.get(body: RoutingHandler): Route

Builds a route to match GET requests.

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

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

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

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

Link copied to clipboard
abstract fun handle(body: RoutingHandler)

Installs a handler into this route which is called when the route is selected for a call.

Link copied to clipboard
fun Route.head(body: RoutingHandler): Route

Builds a route to match HEAD requests.

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

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

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

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

Link copied to clipboard
fun Route.header(name: String, value: String, build: Route.() -> Unit): Route

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

Link copied to clipboard
fun Route.host(host: String, port: Int = 0, build: Route.() -> Unit): Route

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 Route.host(hosts: List<String>, ports: List<Int> = emptyList(), build: Route.() -> Unit): Route
fun Route.host(hostPattern: Regex, port: Int = 0, build: Route.() -> Unit): Route

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 Route.host(hosts: List<String>, hostPatterns: List<Regex>, ports: List<Int> = emptyList(), build: Route.() -> Unit): Route

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.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
abstract fun <B : Any, F : Any> install(plugin: Plugin<ApplicationCallPipeline, B, F>, configure: B.() -> Unit = {}): F

Installs a plugin into this route, if it is not yet installed.

Link copied to clipboard
fun Route.intercept(phase: PipelinePhase, block: suspend PipelineContext<Unit, PipelineCall>.(Unit) -> Unit)
Link copied to clipboard
fun Route.localPort(port: Int, build: Route.() -> Unit): Route

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

Link copied to clipboard
fun Route.method(method: HttpMethod, body: Route.() -> Unit): Route

Builds a route to match the specified HTTP method.

Link copied to clipboard
fun Route.optionalParam(name: String, build: Route.() -> Unit): Route

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

Link copied to clipboard
fun Route.options(body: RoutingHandler): Route

Builds a route to match OPTIONS requests.

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

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

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

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

Link copied to clipboard
fun Route.param(name: String, build: Route.() -> Unit): Route

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

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

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

Link copied to clipboard
fun Route.patch(body: RoutingHandler): Route

Builds a route to match PATCH requests.

@JvmName(name = "patchTyped")
inline fun <R : Any> Route.patch(crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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

@JvmName(name = "patchTypedPath")
inline fun <R : Any> Route.patch(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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> Route.patch(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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.

Link copied to clipboard
abstract fun <F : Any> plugin(plugin: Plugin<*, *, F>): F

Gets a plugin instance for this pipeline, or fails with MissingApplicationPluginException if the plugin is not installed.

Link copied to clipboard
fun Route.port(vararg ports: Int, build: Route.() -> Unit): Route

Creates a route to match a request port.

Link copied to clipboard
fun Route.post(body: RoutingHandler): Route

Builds a route to match POST requests.

@JvmName(name = "postTyped")
inline fun <R : Any> Route.post(crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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

@JvmName(name = "postTypedPath")
inline fun <R : Any> Route.post(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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> Route.post(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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.

Link copied to clipboard
fun Route.preCompressed(vararg types: CompressedFileType = CompressedFileType.entries.toTypedArray(), configure: Route.() -> Unit)

Support pre-compressed files and resources

Link copied to clipboard
fun Route.put(body: RoutingHandler): Route

Builds a route to match PUT requests.

@JvmName(name = "putTyped")
inline fun <R : Any> Route.put(crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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

@JvmName(name = "putTypedPath")
inline fun <R : Any> Route.put(path: String, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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

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

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> Route.put(path: Regex, crossinline body: suspend RoutingContext.(R) -> Unit): Route

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.

Link copied to clipboard
fun Route.resource(remotePath: String, resource: String = remotePath, resourcePackage: String? = null)

Sets up routing to serve resource as remotePath in resourcePackage

Link copied to clipboard
fun Route.resources(resourcePackage: String? = null)

Sets up routing to serve all resources in resourcePackage

Link copied to clipboard
fun Route.route(path: String, build: Route.() -> Unit): Route

Builds a route to match the specified path.

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

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

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

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

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

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

Link copied to clipboard
fun Route.singlePageApplication(configBuilder: SPAConfig.() -> Unit = {})

Serves a single-page application. You can learn more from Serving single-page applications.

Link copied to clipboard
fun Route.static(configure: Route.() -> Unit): Route

Create a block for static content

fun Route.static(remotePath: String, configure: Route.() -> Unit): Route

Create a block for static content at specified remotePath

Link copied to clipboard
fun Route.staticFiles(remotePath: String, dir: File, index: String? = "index.html", block: StaticContentConfig<File>.() -> Unit = {}): Route

Sets up RoutingRoot to serve static files. All files inside dir will be accessible recursively at "remotePath/path/to/file". If the requested file is a directory and index is not null, then response will be index file in the requested directory.

Link copied to clipboard
fun Route.staticFileSystem(remotePath: String, basePath: String?, index: String? = "index.html", fileSystem: FileSystemPaths = FileSystems.getDefault().paths(), block: StaticContentConfig<Path>.() -> Unit = {}): Route

Sets up RoutingRoot to serve fileSystem as static content. All paths inside basePath will be accessible recursively at "remotePath/path/to/resource". If requested path doesn't exist and index is not null, then response will be index path in the requested package.

Link copied to clipboard
fun Route.staticResources(remotePath: String, basePackage: String?, index: String? = "index.html", block: StaticContentConfig<URL>.() -> Unit = {}): Route

Sets up RoutingRoot to serve resources as static content. All resources inside basePackage will be accessible recursively at "remotePath/path/to/resource". If requested resource doesn't exist and index is not null, then response will be index resource in the requested package.

Link copied to clipboard
fun Route.staticZip(remotePath: String, basePath: String?, zip: Path, index: String? = "index.html", block: StaticContentConfig<Path>.() -> Unit = {}): Route

Sets up RoutingRoot to serve contents of zip as static content. All paths inside basePath will be accessible recursively at "remotePath/path/to/resource". If requested path doesn't exist and index is not null, then response will be index path in the requested package.