All Types
|
Represents a bound socket |
|
|
Represent a connected socket |
|
|
Represent a readable socket |
|
|
Base type for all async sockets |
|
|
Represents a writable socket |
|
|
The default abstract base class implementing Input interface. |
|
|
The default Output implementation. |
|
|
CookiesStorage that stores all the cookies in an in-memory map. |
|
|
Functional type for accepted content types contributor |
|
|
Represents a socket source, for example server socket |
|
|
Default CIO selector manager implementation |
|
|
Stub implementation that always fails. Will be removed so no public signatures should rely on it |
|
|
Evaluates a route as a result of the AND operation using two other selectors |
|
|
HttpClientEngineFactory using a UrlConnection based backend implementation without additional dependencies with the the associated configuration AndroidEngineConfig. |
|
|
Android client engine |
|
|
Configuration for Android client engine. |
|
|
org.objectweb.asm.tree.AnnotationNode (extensions in package io.ktor.validator) |
|
|
HttpClientEngineFactory using |
|
|
Configuration for Apache implementation of HttpClientEngineFactory. |
|
|
Represents configured and running web application, capable of handling requests. It is also the application coroutine scope that is cancelled immediately at application stop so useful for launching background coroutines. |
|
|
Represents a single act of communication between client and server. |
|
|
Pipeline configuration for executing ApplicationCall instances |
|
|
Predicate function that accepts an application call and returns |
|
|
Represents an application config node |
|
|
Represents an application config value |
|
|
Thrown when an application is misconfigured |
|
|
Engine which runs an application |
|
|
Represents an environment in which engine runs |
|
|
Engine environment configuration builder |
|
|
Implements ApplicationEngineEnvironment by loading an Application from a folder or jar. |
|
|
Factory interface for creating ApplicationEngine instances |
|
|
Represents an environment in which Application runs |
|
|
Provides events for Application lifecycle |
|
|
Defines an installable Application Feature |
|
|
Pipeline for processing incoming content |
|
|
Represents a subject for ApplicationReceivePipeline |
|
|
Represents client’s request |
|
|
Represents server’s response |
|
|
Server response send pipeline |
|
|
Specifies a key for an attribute in Attributes |
|
|
Map of attributes accessible by AttributeKey in a typed manner |
|
|
Client authentication feature. providers - list of auth providers to use. |
|
|
Authentication provider interface. |
|
|
Contains the standard auth schemes. |
|
|
Authentication feature supports pluggable mechanisms for checking and challenging a client to provide credentials |
|
|
Represents an authentication context for the call |
|
|
Represents a cause for authentication challenge request |
|
|
Authentication function that accepts and verifies credentials and returns a principal when verification successful. |
|
|
Represents authentication Pipeline for checking and requesting authentication |
|
|
Represents authentication challenging procedure requested by authentication mechanism |
|
|
Represents an authentication provider with the given name |
|
|
An authentication route node that is used by Authentication feature and usually created by Route.authenticate DSL function so generally there is no need to instantiate it directly unless you are writing an extension |
|
|
A feature that automatically respond to HEAD requests |
|
|
Exception thrown when a content type string is malformed. |
|
|
Base exception to indicate that the request is not correct due to wrong/missing request parameters, body content or header values. Throwing this exception in a handler will lead to 400 Bad Request response unless a custom io.ktor.features.StatusPages handler registered. |
|
|
Base class for implementing an ApplicationCall. |
|
|
Base class for implementing ApplicationEngine |
|
|
Base class for implementing ApplicationRequest |
|
|
Base class for implementing an ApplicationResponse |
|
|
HttpClient feature that sets an |
|
|
BasicAuthProvider configuration. |
|
|
Client basic authentication provider. |
|
|
Represents a Basic authentication provider |
|
|
Represents a bound datagram socket |
|
|
Represents a buffer with read and write positions. |
|
|
kotlin.ByteArray (extensions in package io.ktor.utils.io.bits) |
|
|
kotlin.ByteArray (extensions in package io.ktor.util) |
|
|
Implementation of the OutgoingContent.ByteArrayContent for sending array of bytes |
|
|
java.nio.ByteBuffer (extensions in package io.ktor.utils.io.bits) |
|
|
java.nio.ByteBuffer (extensions in package io.ktor.utils.io.charsets) |
|
|
java.nio.ByteBuffer (extensions in package io.ktor.util) |
|
|
Channel for asynchronous reading and writing of sequences of bytes. This is a buffered single-reader single-writer channel. |
|
|
Sequential (non-concurrent) byte channel implementation |
|
|
A builder that provides ability to build byte packets with no knowledge of it’s size. Unlike Java’s ByteArrayOutputStream it doesn’t copy the whole content every time it’s internal buffer overflows but chunks buffers instead. Packet building via build function is O(1) operation and only does instantiate a new ByteReadPacket. Once a byte packet has been built via build function call, the builder could be reused again. You also can discard all written bytes via reset or release. Please note that an instance of builder need to be terminated either via build function invocation or via release call otherwise it will cause byte buffer leak so that may have performance impact. |
|
|
Channel for asynchronous reading of sequences of bytes. This is a single-reader channel. |
|
|
Read-only immutable byte packet. Could be consumed only once however it does support copy that doesn’t copy every byte but creates a new view instead. Once packet created it should be either completely read (consumed) or released via release. |
|
|
Channel for asynchronous writing of sequences of bytes. This is a single-writer channel. |
|
|
HttpClientEngineFactory using a Coroutine based I/O implementation without additional dependencies with the the associated configuration CIOEngineConfig. |
|
|
An ApplicationEngineFactory providing a CIO-based ApplicationEngine |
|
|
Engine that based on CIO backend |
|
|
CIO cipher suites collection https://www.ietf.org/rfc/rfc5289.txt https://tools.ietf.org/html/rfc5288#section-3 |
|
|
Configuration for CIO client engine. |
|
|
An adapter from CIO low-level headers map to ktor Headers interface |
|
|
Represents a multipart data object that does parse and convert parts to ktor’s PartData |
|
|
CORS feature. Please read http://ktor.io/servers/features/cors.html first before using it. |
|
|
List of CacheControl known values. |
|
|
Represents a value for a |
|
|
Represents a cached transformation result from a previous ApplicationCall.receive invocation. |
|
|
Feature that set CachingOptions headers for every response. It invokes optionsProviders for every response and use first non null caching options |
|
|
Specifies caching properties for an OutgoingContent such as Cache-Control or Expires |
|
|
java.util.Calendar (extensions in package io.ktor.util.date) |
|
|
Response exception handler method. |
|
|
Retrieves and generates if necessary a call id. A call id (or correlation id) could be retrieved_ from a call via CallId.Configuration.retrieve function. Multiple retrieve functions could be configured that will be invoked one by one until one of them return non-null value. If no value has been provided by retrievers then a generator could be applied to generate a new call id. Generators could be provided via CallId.Configuration.generate function. Similar to retrieve, multiple generators could be configured so they will be invoked one by one. Usually call id is passed via io.ktor.http.HttpHeaders.XRequestId so one could use CallId.Configuration.retrieveFromHeader function to retrieve call id from a header. |
|
|
A function that retrieves or generates call id using provided call |
|
|
A function that verifies retrieved or generated call id. Should return |
|
|
Logs application lifecycle and call events. |
|
|
A map with case insensitive String keys |
|
|
Client certificate chain with private key. |
|
|
Builder for certificate |
|
|
An exception thrown when an IO error occurred during reading or writing to/from the underlying channel. The typical error is “connection reset” and so on. |
|
|
An exception that is thrown when an IO error occurred during reading from the request channel. Usually it happens when a remote client closed the connection. |
|
|
An exception that is thrown when an IO error occurred during writing to the destination channel. Usually it happens when a remote client closed the connection. |
|
|
kotlin.Char (extensions in package io.ktor.util) |
|
|
java.nio.charset.Charset (extensions in package io.ktor.utils.io.charsets) |
|
|
java.nio.charset.CharsetDecoder (extensions in package io.ktor.utils.io.charsets) |
|
|
java.nio.charset.CharsetEncoder (extensions in package io.ktor.utils.io.charsets) |
|
|
Represents a TLS cipher suite |
|
|
Cipher type. |
|
|
org.objectweb.asm.tree.ClassNode (extensions in package io.ktor.validator) |
|
|
Exception that indicates that client engine is already closed. |
|
|
Helper interface to test client. |
|
|
Bad client request exception. |
|
|
Client specific WebSocketSession. |
|
|
Websocket close reason |
|
|
Indicates attempt to write on isClosedForWrite channel that was closed without a cause. A failed channel rethrows the original close cause exception on send attempts. |
|
|
Feature to compress a response based on conditions and ability of client to decompress it |
|
|
Represents a Compression encoder |
|
|
Builder for compression encoder configuration |
|
|
Configuration for an encoder |
|
|
Compression feature configuration |
|
|
Feature to check modified/match conditional headers and avoid sending contents if it was not changed |
|
|
Represents a builder for conditions |
|
|
com.typesafe.config.Config (extensions in package io.ktor.config) |
|
|
Represent a configurable socket |
|
|
This exception is thrown in case connect timeout exceeded. |
|
|
Represents a connected datagram socket. |
|
|
Represents a parsed |
|
|
Represents a type of a connector, e.g HTTP or HTTPS. |
|
|
CookiesStorage that ignores addCookie and returns a list of specified cookies when constructed. |
|
|
Evaluates a route against a constant query parameter value |
|
|
A custom content converted that could be registered in ContentNegotiation feature for any particular content type Could provide bi-directional conversion implementation. One of the most typical examples of content converter is a json content converter that provides both serialization and deserialization |
|
|
Represents |
|
|
Client content encoder. |
|
|
Content-Encoding header support. |
|
|
This feature provides automatic content conversion according to Content-Type and Accept headers |
|
|
Represents a |
|
|
Thrown when content cannot be transformed to the desired type. It is not defined which status code will be replied when an exception of this type is thrown and not caught. Depending on child type it could be 4xx or 5xx status code. By default it will be 500 Internal Server Error. |
|
|
Thrown when content cannot be transformed to the desired type. |
|
|
Represents a value for a |
|
|
Pair of ContentType and quality usually parsed from HttpHeaders.Accept headers. |
|
|
DslMarker for pipeline execution context |
|
|
Data conversion service that does serialization and deserialization to/from list of strings |
|
|
Represents a cookie with name, content and a set of settings such as expiration, visibility and security. A cookie with neither expires nor maxAge is a session cookie. |
|
|
Cookie configuration being used to send sessions |
|
|
Cooke encoding strategy |
|
|
Cookie session configuration builder |
|
|
Cookie session configuration builder |
|
|
Storage for Cookie. |
|
|
This is an internal implementation for copy-on-write concurrent map. It is very limited since it is not intended as general purpose implementation. |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.network.sockets) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.http.cio.websocket) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.websocket) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.http.cio) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.server.cio.backend) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.utils.io) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.server.cio) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.features) |
|
|
kotlinx.coroutines.CoroutineScope (extensions in package io.ktor.server.engine) |
|
|
Marker interface indicating that a class represents credentials for authentication |
|
|
Represents a container for all session instances |
|
|
API marked with this annotation is internal and extremely fragile and not intended to be used by library users. Such API could be changed without notice including rename, removal and behaviour change. Also using API marked with this annotation could cause data loss or any other damage. |
|
|
Data conversion feature to serialize and deserialize types using converters registry |
|
|
Thrown when failed to convert value |
|
|
A channel for receiving datagrams |
|
|
A channel for sending and receiving datagrams |
|
|
A channel for sending datagrams |
|
|
java.util.Date (extensions in package io.ktor.util) |
|
|
Decoder job type |
|
|
io.ktor.client.features.websocket.DefaultClientWebSocketSession |
ClientSpecific DefaultWebSocketSession. |
|
The default conversion service that supports only basic types and enums |
|
|
Adds standard HTTP headers |
|
|
Default HttpRequest implementation. |
|
|
The default state provider that does generate random nonce and don’t keep them |
|
|
Default object pool implementation. |
|
|
Feature is used to set request default parameters. |
|
|
HTTP/2 push builder |
|
|
The default servlet upgrade implementation using Servlet API. Please note that some servlet containers may not support it or it may be broken. |
|
|
Handles all uncaught exceptions and logs errors with the specified logger ignoring CancellationException and IOException. |
|
|
Represents a server-side web socket session with all default implementations |
|
|
Default websocket session with ping-pong and timeout processing and built-in closeReason population |
|
|
Default web socket session implementation that handles ping-pongs, close sequence and frame fragmentation |
|
|
Implementation of the deflate encoder |
|
|
Custom convertor builder |
|
|
Stateful digest class specified to calculate digest. |
|
|
DigestAuthProvider configuration. |
|
|
Client digest AuthProvider. |
|
|
Represents a Digest authentication provider |
|
|
Represents Digest credentials |
|
|
Provides message digest for the specified username and realm or returns |
|
|
Specialized dispatcher useful for graceful shutdown |
|
|
kotlinx.coroutines.Dispatchers (extensions in package io.ktor.client.utils) |
|
|
kotlin.Double (extensions in package io.ktor.utils.io.bits) |
|
|
This feature provides ability to invoke ApplicationCall.receive several times.
Please note that not every type could be received twice. For example, even with this feature installed you can’t
receive a channel twice (unless Configuration.receiveEntireContent is enabled).
Types that always can be received twice or more: |
|
|
Exception representing that the response payload has already been received. |
|
|
Dropwizard metrics support feature. See https://ktor.io/servers/features/metrics.html for details. |
|
|
Thrown when Application Feature has been attempted to be installed with the same key as already installed Feature |
|
|
Concrete OutgoingContent without a payload. |
|
|
Content encoder. |
|
|
Encoder job type |
|
|
Endpoint settings. |
|
|
API marked with this annotation is not intended to be used by end users unless a custom server engine implementation is required |
|
|
Mutable implementation of EngineConnectorConfig for building connectors programmatically |
|
|
Represents a connector configuration. |
|
|
Default engine with main function that starts CIO engine using application.conf |
|
|
Jetty engine |
|
|
Netty engine |
|
|
Tomcat engine |
|
|
Application engine pipeline. One usually don’t need to install interceptors here unless your are writing your own engine implementation |
|
|
Mutable implementation of EngineSSLConnectorConfig for building connectors programmatically |
|
|
Represents an SSL connector configuration. |
|
|
This version checks etag value and pass it through conditions supplied by the remote client. Depending on conditions it produces return value of enum type VersionCheckResult |
|
|
Definition of an event. Event is used as a key so both hashCode and equals need to be implemented properly. Inheriting of this class is an experimental feature. Instantiate directly if inheritance not necessary. |
|
|
Specifies signature for the event handler |
|
|
Transparently allows for the creation of EventLoopGroup’s utilising the optimal implementation for a given operating system, subject to availability, or falling back to NioEventLoopGroup if none is available. |
|
|
API marked with this annotation is experimental and could be changed |
|
|
org.objectweb.asm.tree.FieldNode (extensions in package io.ktor.validator) |
|
|
java.io.File (extensions in package io.ktor.util) |
|
|
java.io.File (extensions in package io.ktor.util.cio) |
|
|
kotlin.Float (extensions in package io.ktor.utils.io.bits) |
|
|
Response content with |
|
|
Specifies what to send back if form authentication fails. |
|
|
Specifies what to send back if form authentication fails. |
|
|
Represents a form-based authentication provider |
|
|
Form builder type used in formData builder function. |
|
|
OutgoingContent with for application/x-www-form-urlencoded formatted request. |
|
|
Multipart form item. Use it to build form in client. |
|
|
Forwarded header support. See RFC 7239 https://tools.ietf.org/html/rfc7239 |
|
|
A frame received or ready to be sent. It is not reusable and not thread-safe |
|
|
Frame types enum |
|
|
Freemarker support feature. Provides ability to respond with FreeMarkerContent |
|
|
Represents a content handled by FreeMarker feature. |
|
|
io.netty.util.concurrent.Future (extensions in package io.ktor.server.netty) |
|
|
Date in GMT timezone |
|
|
This implementation does only generate nonce values but doesn’t validate them. This is recommended for testing only. |
|
|
GSON converter for ContentNegotiation feature |
|
|
JsonSerializer using Gson as backend. |
|
|
Implementation of the gzip encoder |
|
|
HSTS feature that appends |
|
|
Hash algorithms |
|
|
Hash and signature algorithm pair |
|
|
Header session configuration builder |
|
|
Header session configuration builder |
|
|
Represents a header value. Similar to HeaderValueWithParameters |
|
|
Describes how a header should be encoded. |
|
|
Represents a single value parameter |
|
|
Represents a header value that consist of content followed by parameters.
Useful for headers such as |
|
|
Represents HTTP headers as a map from case-insensitive names to collection of String values |
|
|
This HTTP generator produces huge amount of requests however it doesn’t validate responses and doesn’t measure any time characteristics. |
|
|
Implements ApplicationConfig by loading configuration from HOCON data structures |
|
|
Evaluates a route against a request’s host and port |
|
|
Represents an OutgoingContent using |
|
|
Evaluates a route against a content-type in the HttpHeaders.Accept header in the request |
|
|
Describes an authentication header with a mandatory authScheme that usually is a standard AuthScheme. |
|
|
This feature allow to use HTTP cache. |
|
|
Cache storage interface. |
|
|
Response validator feature is used for validate response and handle response exceptions. |
|
|
Asynchronous client to perform HTTP requests. |
|
|
A class that represents a single pair of request and response for a specific HttpClient. |
|
|
Mutable configuration used by HttpClient. |
|
|
Dsl marker for HttpClient dsl. |
|
|
Base interface use to define engines for HttpClient. |
|
|
Abstract implementation of HttpClientEngine responsible for lifecycle control of dispatcher and coroutineContext as well as proper call context management. Should be considered as the best parent class for custom HttpClientEngine implementations. |
|
|
Capability required by request to be supported by HttpClientEngine with T representing type of the capability configuration. |
|
|
Base configuration for HttpClientEngine. |
|
|
A container is searched across dependencies using ServiceLoader to find client implementations. An implementation of this interface provides HTTP client factory and only used to find the default client engine when HttpClient function is called with no particular client implementation specified |
|
|
Factory of HttpClientEngine with a specific T of HttpClientEngineConfig. |
|
|
Base interface representing a HttpClient feature. |
|
|
Base jvm implementation for HttpClientEngine |
|
|
HttpClient feature that handles sent |
|
|
Raw http call produced by engine. |
|
|
Evaluates a route against a header in the request |
|
|
A headers map data structure used in CIO |
|
|
A message either from the client or the server, that has headers associated. |
|
|
Represents a base HTTP message type for request and response |
|
|
A builder message either for the client or the server, that has a headers builder associated. |
|
|
Represents an HTTP method (verb) |
|
|
Evaluates a route against an HttpMethod |
|
|
HttpClient feature that encodes String request bodies to TextContent and processes the response body as String. |
|
|
Represents an HTTP protocol version. |
|
|
HttpClient Pipeline used for receiving HttpResponse without any processing. |
|
|
HttpClient feature that handles http redirect |
|
|
A request for HttpClient, first part of HttpClientCall. |
|
|
Class for building HttpRequestData. |
|
|
Actual data of the HttpRequest, including url, method, headers, body and executionContext. Built by HttpRequestBuilder. |
|
|
HTTP request handler function |
|
|
HttpClient Pipeline used for executing HttpRequest. |
|
|
This exception is thrown in case request timeout exceeded. |
|
|
A response for HttpClient, second part of HttpClientCall. |
|
|
Class representing a typed response with an attached expectedType. |
|
|
Data prepared for HttpResponse. |
|
|
HttpClient Pipeline used for executing HttpResponse. |
|
|
This is internal feature that is always installed. |
|
|
HttpSend pipeline interceptor function |
|
|
io.ktor.client.features.HttpSendInterceptorBackwardCompatible |
HttpSend pipeline interceptor function backward compatible with previous implementation. |
|
HttpClient Pipeline used for sending HttpRequest to remote server. |
|
|
Represents a server instance |
|
|
HTTP server connector settings |
|
|
Prepared statement for http client request. This statement doesn’t perform any network requests until execute method call. |
|
|
Represents an HTTP status code and description. |
|
|
Represents a simple status code response with no content |
|
|
Client HTTP timeout feature. There are no default values, so default timeouts will be taken from engine configuration or considered as infinite time if engine doesn’t provide them. |
|
|
Redirect non-secure requests to HTTPS |
|
|
Default ktor fixed size dispatcher for doing non-blocking I/O operations and selection |
|
|
Empty Encoder |
|
|
Implementation of the identity encoder |
|
|
Thrown when an illegal header name was used.
A header name should only consist from visible characters
without delimiters “double quote” and the following characters: |
|
|
Thrown when an illegal header value was used. A header value should only consist from visible characters, spaces and/or HTAB (0x09). |
|
|
Usually shouldn’t be implemented directly. Inherit AbstractInput instead. |
|
|
Reusable Input form entry. |
|
|
java.io.InputStream (extensions in package io.ktor.utils.io.jvm.javaio) |
|
|
java.io.InputStream (extensions in package io.ktor.utils.io.streams) |
|
|
java.io.InputStream (extensions in package io.ktor.util.cio) |
|
|
java.time.Instant (extensions in package io.ktor.util.date) |
|
|
kotlin.Int (extensions in package io.ktor.utils.io.bits) |
|
|
API marked with this annotation is ktor internal and it is not intended to be used outside. It could be modified or removed without any notice. Using it outside of ktor could cause undefined behaviour and/or any strange effects. |
|
|
Thrown when the date string doesn’t the string pattern. |
|
|
An exception about misconfigured phases in a pipeline |
|
|
A read-write facade to actual buffer of fixed size. Multiple views could share the same actual buffer. Concurrent unsafe. The only concurrent-safe operation is release. In most cases ByteReadPacket and BytePacketBuilder should be used instead. |
|
|
it function receiver object |
|
|
kotlin.collections.Iterable (extensions in package io.ktor.http) |
|
|
Specifies what to send back if session authentication fails. |
|
|
JWT authentication provider that will be registered with the specified name |
|
|
JWT verifier configuration function. It is applied on the verifier builder. |
|
|
Represents a JWT credential consist of the specified payload |
|
|
Represents a JWT principal consist of the specified payload |
|
install(ContentNegotiation) {
register(ContentType.Application.Json, JacksonConverter())
}
to be able to modify the objectMapper (eg. using specific modules and/or serializers and/or
configuration options, you could use the following (as seen in the ktor-samples):
install(ContentNegotiation) {
jackson {
configure(SerializationFeature.INDENT_OUTPUT, true)
registerModule(JavaTimeModule())
|
|
|
java.util.jar.JarFile (extensions in package io.ktor.validator) |
|
|
Represents an OutgoingContent for a resource inside a Jar file |
|
|
HttpClientEngineFactory using |
|
|
An ApplicationEngineFactory providing a Jetty-based ApplicationEngine |
|
|
ApplicationEngine implementation for running in a standalone Jetty |
|
|
ApplicationEngine base type for running in a standalone Jetty |
|
|
Configuration for Jetty implementation of HttpClientEngineFactory. |
|
|
kotlinx.coroutines.Job (extensions in package io.ktor.util) |
|
|
kotlinx.coroutines.Job (extensions in package io.ktor.server.engine) |
|
|
HttpClient feature that serializes/de-serializes as JSON custom objects to request and from response bodies using a serializer. |
|
|
Client json serializer. |
|
|
Base class for JSON tests. |
|
|
java.security.KeyStore (extensions in package io.ktor.network.tls.certificates) |
|
|
Builder for key store |
|
|
kotlinx.metadata.jvm.KotlinClassMetadata (extensions in package io.ktor.validator) |
|
|
A JsonSerializer implemented for kotlinx Serializable classes. |
|
|
API marked with this annotation is experimental and is not guaranteed to be stable. |
|
|
API marked with this annotation is experimental and is not guaranteed to be stable. |
|
|
A base class for servlet engine implementations |
|
|
This version passes the given lastModified date through the client provided http conditional headers If-Modified-Since and If-Unmodified-Since. |
|
|
Represents a |
|
|
kotlin.collections.List (extensions in package io.ktor.validator) |
|
|
kotlin.collections.List (extensions in package io.ktor.client.features.cookies) |
|
|
kotlin.collections.List (extensions in package io.ktor.client.tests.utils) |
|
|
kotlin.collections.List (extensions in package io.ktor.sessions) |
|
|
kotlin.collections.List (extensions in package io.ktor.http) |
|
|
kotlin.collections.List (extensions in package io.ktor.features) |
|
|
kotlin.collections.List (extensions in package io.ktor.util) |
|
|
OutgoingContent representing a local file with a specified contentType, expires date and caching |
|
|
OutgoingContent representing a local file with a specified contentType, expires date and caching |
|
|
Evaluate a route against the port on which the call was received. |
|
|
Annotation for classes that will act as typed routes. |
|
|
Implements LocationRouteService by extracting routing information from a Location annotation. |
|
|
Provides services for extracting routing information from a location class. |
|
|
Exception indicating that route parameters in curly brackets do not match class properties. |
|
|
EXPERIMENTAL Ktor feature that allows to handle and construct routes in a typed way. |
|
|
Logging log level. |
|
|
HttpClient Logger. |
|
|
org.slf4j.Logger (extensions in package io.ktor.util) |
|
|
HttpClient logging feature. |
|
|
kotlin.Long (extensions in package io.ktor.http) |
|
|
kotlin.Long (extensions in package io.ktor.utils.io.bits) |
|
|
kotlin.ranges.LongRange (extensions in package io.ktor.util) |
|
|
Mutable application config backed by a hash map |
|
|
Represents a linear range of bytes. All operations are guarded by range-checks by default however at some platforms they could be disabled in release builds. |
|
|
A Logger that breaks up log messages into multiple logs no longer than maxLength |
|
|
org.objectweb.asm.tree.MethodNode (extensions in package io.ktor.validator) |
|
|
Dropwizard metrics feature. Use DropwizardMetrics or instead. |
|
|
Enables Micrometer support when installed. Exposes the following metrics: |
|
|
Thrown when Application Feature has been attempted to be accessed but has not been installed before |
|
|
This exception is thrown when a required parameter with name parameterName is missing |
|
|
HttpClientEngine for writing tests without network. |
|
|
Scope for MockRequestHandler. |
|
|
Single HttpClientCall to HttpResponse mapper. |
|
|
Month value is 3 letter shortcut |
|
|
Represents a multipart data stream that could be received from a call |
|
|
OutgoingContent for multipart/form-data formatted request. |
|
|
Represents a multipart content starting event. Every part need to be completely consumed or released via release |
|
|
Feature for providing Mustache templates as MustacheContent |
|
|
Response content which could be used to respond ApplicationCalls like `call.respond(MustacheContent(…)) |
|
|
Represents a RequestConnectionPoint. Every it’s component is mutable so application features could provide them |
|
|
Represents a text range with mutable bounds |
|
|
Named curves for Elliptic Curves. |
|
|
An ApplicationEngineFactory providing a Netty-based ApplicationEngine |
|
|
ApplicationEngine implementation for running in a standalone Netty |
|
|
A ChannelInitializer implementation that does setup the default ktor channel pipeline |
|
|
A pool implementation of zero capacity that always creates new instances |
|
|
Throws if failed to find PrivateKey for any alias in KeyStore. |
|
|
Exception representing the no transformation was found. It includes the received type and the expected type as part of the message. |
|
|
Represents a nonce manager. It’s responsibility is to produce nonce values and verify nonce values from untrusted sources that they are provided by this manager. This is usually required in web environment to mitigate CSRF attacks. Depending on it’s underlying implementation it could be stateful or stateless. Note that there is usually some timeout for nonce values to reduce memory usage and to avoid replay attacks. Nonce length is unspecified. |
|
|
This exception means that the requested resource is not found. HTTP status 404 Not found will be replied when this exception is thrown and not caught. 404 status page could be configured by registering a custom io.ktor.features.StatusPages handler. |
|
|
Represents an OAuth1a server error |
|
|
Represents a error during communicating to OAuth2 server |
|
|
List of OAuth2 request parameters for both peers |
|
|
List of OAuth2 server response parameters |
|
|
Provides states for OAuth2. State could be just a random number (nonce) or could contain additional form fields or a signature. It is important that it should be a way to verify state. So all states need to be saved somehow or a state need to be a signed set of parameters that could be verified later |
|
|
OAuth access token acquired from the server |
|
|
Represents an OAuth provider for Authentication feature |
|
|
OAauth callback parameters |
|
|
OAuth grant types constants |
|
|
Represents OAuth server settings |
|
|
OAuth versions used in configuration |
|
|
HttpClientEngineFactory using a OkHttp based backend implementation with the the associated configuration OkHttpConfig. |
|
|
Configuration for OkHttp client engine. |
|
|
on function receiver object |
|
|
Evaluates a route against an optional query parameter value and captures its value, if found |
|
|
Evaluates a route as a result of the OR operation using two other selectors |
|
|
Information about the content to be sent to the peer, recognized by a client or server engine |
|
|
This shouldn’t be implemented directly. Inherit AbstractOutput instead. |
|
|
java.io.OutputStream (extensions in package io.ktor.utils.io.streams) |
|
|
OutgoingContent to respond with OutputStream. The stream would be automatically closed after body finish. |
|
|
This exception is thrown when a required parameter with name parameterName couldn’t be converted to the type |
|
|
Evaluates a route against a query parameter value and captures its value |
|
|
Represents HTTP parameters as a map from case-insensitive names to collection of String values |
|
|
An HTTP parser exception |
|
|
Represents a multipart/form-data entry. Could be a FormItem or FileItem |
|
|
Feature to support requests to specific content ranges. |
|
|
java.nio.file.Path (extensions in package io.ktor.util) |
|
|
java.nio.file.Path (extensions in package io.ktor.util.cio) |
|
|
Evaluates a route against a constant path segment |
|
|
Evaluates a route against an optional parameter path segment and captures its value, if any |
|
|
Evaluates a route against a parameter path segment and captures its value |
|
|
Helper object for building instances of RouteSelector from path segments |
|
|
Evaluates a route against any number of trailing path segments, and captures their values |
|
|
Evaluates a route against any single path segment |
|
|
Feature for providing Pebble templates as PebbleContent |
|
|
Response content which could be used to respond ApplicationCalls like `call.respond(PebbleContent(…)) |
|
|
java.nio.channels.Pipe (extensions in package io.ktor.utils.io.jvm.nio) |
|
|
Represents an execution pipeline for asynchronous extensible computations |
|
|
Represents running execution of a pipeline |
|
|
Represent an object that launches pipeline execution |
|
|
Represents an interceptor type which is a suspend extension function for context |
|
|
Represents a phase in a pipeline |
|
|
A placeholder that is inserted inside TOuter |
|
|
Item of a placeholder list when it is expanded |
|
|
Placeholder that can appear multiple times |
|
|
Elliptic curve point format |
|
|
Marker interface indicating that a class represents an authenticated principal |
|
|
ProxyConfig factory. |
|
|
Possible content range units: bytes and none |
|
|
Range specifier for partial content requests (RFC 2616 sec 14.35.1) |
|
|
Represents a RAW web socket session |
|
|
Represents both readable and writable socket |
|
|
java.nio.channels.ReadableByteChannel (extensions in package io.ktor.utils.io.jvm.nio) |
|
|
java.nio.channels.ReadableByteChannel (extensions in package io.ktor.utils.io.nio) |
|
|
java.nio.channels.ReadableByteChannel (extensions in package io.ktor.util) |
|
|
A coroutine job that is reading from a byte channel |
|
|
Exception representing fail of the response pipeline cause contains origin pipeline exception |
|
|
Unhandled redirect exception. |
|
|
An exception that could be thrown to reject a call due to illegal call id |
|
|
Represents an HTTP request |
|
|
Thrown when a request body has been already received. Usually it is caused by double ApplicationCall.receive invocation. |
|
|
Represents request address information is used to make a call. There are at least two possible instances: “local” is how we see request at the server application and “actual” is what we can recover from proxy provided headers. |
|
|
Server request’s cookies |
|
|
Thrown when a request receive was failed during the previous ApplicationCall.receive invocation so this receive attempt is simply replaying the previous exception cause. |
|
|
Builds an HTTP request or response |
|
|
Represents an HTTP response |
|
|
Server’s response cookies |
|
|
Base for default response exceptions. |
|
|
ResponseObserver callback. |
|
|
Server’s response headers |
|
|
Observe response feature. |
|
|
HTTP/2 push builder interface |
|
|
Response validator method. |
|
|
The selector for routing root. |
|
|
Describes a node in a routing tree |
|
|
Base type for all routing selectors |
|
|
Represents a result of a route evaluation against a call |
|
|
Root routing node for an Application |
|
|
Represents an application call being handled by Routing |
|
|
Represents an application request being handled by Routing |
|
|
Represents an application response being handled by Routing |
|
|
Represents a parsed routing path. Consist of number of segments parts |
|
|
Represent a single routing path segment |
|
|
Possible routing path segment kinds |
|
|
Represents a context in which routing resolution is being performed |
|
|
Represents a result of routing resolution. |
|
|
Represents the trace of routing resolution process for diagnostics. |
|
|
Represents a single entry in the RoutingResolveTrace. |
|
|
TLS secret key exchange type. |
|
|
Select interest kind |
|
|
A selectable entity with selectable NIO channel, interestedOps subscriptions |
|
|
Selector manager is a service that manages NIO selectors and selection threads |
|
|
Base class for NIO selector managers |
|
|
Asynchronous Semaphore. |
|
|
Thrown when too many actual requests were sent during a client call. It could be caused by infinite or too long redirect sequence. Maximum number of requests is limited by HttpSend.maxSendCount |
|
|
This interface represents a request send pipeline interceptor chain |
|
|
kotlin.sequences.Sequence (extensions in package io.ktor.validator) |
|
|
Json ContentConverter with kotlinx.serialization. |
|
|
Represents a server incoming connection. Usually it is a TCP connection but potentially could be other transport. |
|
|
Server key exchange type with it’s code |
|
|
Represents a request scope. |
|
|
Server error exception. |
|
|
Represents a server bound socket ready for accepting connections |
|
|
This servlet need to be installed into a servlet container |
|
|
Servlet upgrade processing |
|
|
Specifies what to send back if authentication fails. |
|
|
Specifies what to send back if session authentication fails. |
|
|
Represents a session-based authentication provider |
|
|
This exception is thrown when a session is asked too early before the Sessions feature had chance to configure it. For example, in a phase before ApplicationCallPipeline.Features or in a feature installed before Sessions into the same phase. |
|
|
Specifies a provider for a session with the specific name and type |
|
|
Serializes session from and to String |
|
|
Default reflection-based session serializer that does it via reflection. Serialized format is textual and optimized for size as it is could be transferred via HTTP headers or cookies |
|
|
Represents a way to write, read and invalidate session bits. |
|
|
SessionStorage that stores session contents into memory. |
|
|
SessionTracker provides ability to track and extract session from the call context. |
|
|
SessionTracker that transfers a Session Id generated by a sessionIdProvider in HTTP Headers/Cookies. It uses a storage and a serializer to store/load serialized/deserialized session content of a specific type. |
|
|
SessionTracker that stores the contents of the session as part of HTTP Cookies/Headers. It uses a specific serializer to serialize and deserialize objects of type type. |
|
|
SessionTransport receive, send or clear a session from/to an ApplicationCall. |
|
|
SessionTransport that adds a Set-Cookie header and reads Cookie header for the specified cookie name, and a specific cookie configuration after applying/un-applying the specified transforms defined by transformers. |
|
|
SessionTransport that sets or gets the specific header name, applying/un-applying the specified transforms defined by transformers. |
|
|
Represents a session cookie transformation. Useful for such things like signing and encryption |
|
|
Session transformer that appends an algorithm hash of the input. Where the input is either a session contents or a previous transformation. It prepends a salt when computing the hash. |
|
|
Session transformer that encrypts/decrypts the input. |
|
|
io.ktor.sessions.SessionTransportTransformerMessageAuthentication |
Session transformer that appends an algorithm MAC (Message Authentication Code) hash of the input. Where the input is either a session contents or a previous transformation. It uses a specified keySpec when generating the Mac hash. |
|
Sessions feature that provides a mechanism to persist information between requests. |
|
|
kotlin.collections.Set (extensions in package io.ktor.util) |
|
|
kotlin.Short (extensions in package io.ktor.utils.io.bits) |
|
|
Shutdown URL feature. It stops application when requested particular url |
|
|
Signature algorithms |
|
|
A pool that produces at most one instance |
|
|
Represents a connected socket |
|
|
Socket builder |
|
|
Socket options builder |
|
|
This exception is thrown in case socket timeout (read or write) exceeded. |
|
|
Stateless nonce manager implementation with HMAC verification and timeout. Every nonce provided by this manager consist of a random part, timestamp and HMAC. |
|
|
Status pages feature that handles exceptions and status codes. Useful to configure default error pages. |
|
|
kotlin.String (extensions in package io.ktor.http) |
|
|
kotlin.String (extensions in package io.ktor.utils.io.core) |
|
|
kotlin.String (extensions in package io.ktor.util) |
|
|
Provides data structure for associating a String with a List of Strings |
|
|
TLS alert level |
|
|
TLS alert types with codes |
|
|
TLS configuration. |
|
|
TLSConfig builder. |
|
|
TLS handshake record type |
|
|
TLS record type with it’s numeric code |
|
|
TLS version |
|
|
TCP socket builder |
|
|
A template that expands inside TOuter |
|
|
A placeholder that is also a template |
|
|
java.time.temporal.Temporal (extensions in package io.ktor.http) |
|
|
Represents a test application call that is used in withTestApplication and handleRequest |
|
|
ktor test engine that provides way to simulate application calls to existing application module(s) without actual HTTP connection |
|
|
Represents a test application request |
|
|
Represents test call response received from server |
|
|
An ApplicationEngineFactory providing a CIO-based ApplicationEngine |
|
|
Represents a text content that could be sent |
|
|
kotlin.Throwable (extensions in package io.ktor.util) |
|
|
Thymeleaf support feature. Provides ability to respond with Thymeleaf |
|
|
Represents a content handled by Thymeleaf feature. |
|
|
An ApplicationEngineFactory providing a Tomcat-based ApplicationEngine |
|
|
Tomcat application engine that runs it in embedded mode |
|
|
This exception is thrown when HTTP response has been already sent but an attempt to modify session is made |
|
|
Information about type. |
|
|
Ktor type information. |
|
|
An inline class to hold a IP ToS value |
|
|
UDP socket builder |
|
|
Represents a content that is served from the specified uri |
|
|
A URL builder with all mutable components |
|
|
URL decoder exception |
|
|
Thrown when failed to parse URL |
|
|
Represents URL protocol |
|
|
Response content with |
|
|
Thrown when an attempt to set unsafe header detected. A header is unsafe if listed in HttpHeaders.UnsafeHeadersList. |
|
|
io.ktor.client.features.compression.UnsupportedContentEncodingException |
|
|
Thrown when there is no conversion for a content type configured. HTTP status 415 Unsupported Media Type will be replied when this exception is thrown and not caught. |
|
|
Represents an immutable URL |
|
|
Default user-agent feature for HttpClient. |
|
|
Simple in-memory table that keeps user names and password hashes |
|
|
Represents a simple user’s principal identified by name |
|
|
Velocity ktor feature. Provides ability to respond with VelocityContent and respondTemplate. |
|
|
Represents a response content that could be used to respond with |
|
|
Represents content version |
|
|
Represent result of the version comparison between content being sent and HTTP request. |
|
|
It provides ability to cancel jobs and schedule coroutine with timeout. Unlike regular withTimeout this implementation is never scheduling timer tasks but only checks for current time. This makes timeout measurement much cheaper and doesn’t require any watchdog thread. |
|
|
Web resources serve configuration |
|
|
API marked with this annotation is internal and not intended to be used outside of ktor It is not recommended to use it as it may be changed in the future without notice or it may be too low-level so could damage your data. |
|
|
Class that continuously reads a byteChannel and converts into Websocket Frame exposing them in incoming. |
|
|
Represents a server-side web socket session |
|
|
Represents a web socket session between two peers |
|
|
An OutgoingContent response object that could be used to |
|
|
Class that processes written outgoing Websocket Frame, serializes them and writes the bits into the writeChannel. |
|
|
Client WebSocket feature. |
|
|
WebSockets support feature. It is required to be installed first before binding any websocket endpoints |
|
|
Day of week value is 3 letter shortcut |
|
|
java.nio.channels.WritableByteChannel (extensions in package io.ktor.utils.io.nio) |
|
|
java.nio.channels.WritableByteChannel (extensions in package io.ktor.util) |
|
|
Represents a content that is produced by body function |
|
|
A coroutine job that is writing to a byte channel |
|
|
|
|
|
java.time.ZonedDateTime (extensions in package io.ktor.util.date) |