All Classes

Class	Description
Action<T>	A generic type for an object that does some work with a thing.
Action.ConditionalSpec<I>	A spec for adding conditions to a conditional action.
ApplicationUnderTest	A Ratpack application that is being tested, or used at test time.
AttemptRetryPolicy	An attempt based implementation of RetryPolicy.
AttemptRetryPolicyBuilder	Builds an AttemptRetryPolicy.
AutoCloseWebSocketHandler<T extends AutoCloseable>
BaseDir
BaseDirRequiredException	Thrown when the base directory of the application has not been set but is required.
Batch<T>	A batch of promises to be processed.
BiAction<T,U>	A generic type for an object that does some work with 2 input things.
BiFunction<I1,I2,O>
BindingsImposition	An imposition of additional and overridden Guice bindings, used by Guice.registry(Action) and similar methods.
BindingsSpec	A buildable specification of Guice bindings.
Block	A block of code.
Blocking	Facilitates working with code that blocks (e.g.
BlockingExecTimingInterceptor
Blocks
ByContentSpec	A specification of how to respond to a request, based on the requested content type (i.e.
ByMethodSpec	A specification of how to respond to a request, based on the requested method.
ByteBufAllocatorConfig	Configuration for collecting metrics about ByteBufAllocator.
ByteBufRef	A byte buf that is backed by another, but has its own ref count lifecycle.
ByteBufStreams	Utilities for dealing with streams of ByteBuf.
Chain	A chain is a write only builder for composing handlers.
ClientErrorException	Indicates that this exception represents a client error.
ClientErrorHandler	The client error handler deals with errors that are due to the client doing something wrong.
ClientSideSessionConfig	Client side session configuration.
ClientSideSessionModule	An extension module that provides a client side session store - cookie based.
CloseableApplicationUnderTest	An ApplicationUnderTest that is able to be shut down.
ConfigData	Configuration data for the application, potentially built from many sources.
ConfigDataBuilder	Configures how configuration data will be loaded and bound to objects.
ConfigObject<T>	An object deserialized from config.
ConfigSource	Allows providing custom sources of configuration data.
ConfigurableModule<T>	Provides a standard approach for modules that require some parametrization / configuration.
ConnectionClosedException	Thrown when an operation is attempted against a connection that is closed.
ConsoleConfig
Context	The context of an individual Handler invocation.
Crypto
CsvConfig
DecodingErrorLevel	Specifies how messages related to request decoding are handled in the log output.
DefaultGroovyByContentSpec
Delay	A strategy object to model delays between retries.
DependsOn	Declares the other service types that services of the annotated type depend on.
DirectChannelAccess	Provides direct access to the underlying Netty Channel.
Downstream<T>	A consumer of a single asynchronous value.
DropwizardMetricsConfig	The configuration object for DropwizardMetricsModule.
DropwizardMetricsModule	An extension module that provides support for Dropwizard Metrics.
DurationRetryPolicy	A duration based implementation of RetryPolicy.
DurationRetryPolicyBuilder	Builds a DurationRetryPolicy.
EmbeddedApp	An application created and used at runtime, useful for functionally testing subsets of functionality.
EnableRatpack
Environment
EnvironmentParser	Strategy for parsing a set of environment variables into a form appropriate for use in a ConfigSource.
EphemeralBaseDir	A helper for creating a base dir programmatically, typically at test time.
Exceptions	Utility methods for dealing with exceptions.
ExecController	The exec controller manages the execution of operations.
ExecControllerSpec	An additive specification of an execution controller.
ExecControllerSpec.BlockingSpec	A specification for defining the default blocking executor.
ExecControllerSpec.ComputeSpec	A specification for defining the default computation executor.
ExecControllerSpec.EventLoopSpec	A specification for building Netty event loop groups.
ExecControllerSpec.ExecutorServiceSpec	A specification for building executor services
ExecHarness	A utility for testing asynchronous support/service code.
ExecInitializer
ExecInterceptor	Intercepts execution segments of an execution, primarily for traceability and recording metrics.
ExecInterceptor.ExecType	The execution type (i.e.
ExecResult<T>	The result of an execution.
ExecSpec	A specification for an Execution.
ExecStarter	Starts a new Execution.
Execution	A logical operation, such as servicing a request, that may be comprised of non contiguous units of work.
ExecutionException	Thrown when an execution sequence is invalid.
ExecutionRef	A reference to an Execution that is usable from outside of it.
ExecutionScoped
Factory<T>	An object that creates another.
FileHandlerSpec	A specification for a handler that serves files from the file system.
FileIo	Utilities for streaming to and from files.
FileSystemBinding	A file system binding represents a file system location that is used to resolve relative paths.
FixedDelay	A fixed duration based implementation of Delay.
ForceDevelopmentImposition	Forces whether to start the application in ServerConfig.isDevelopment() mode or not.
ForceServerListenPortImposition	Forces the port that the server should use to listen for requests.
Form	An uploaded form.
FormParseOpts	Options for parsing a Form.
Function<I,O>	A single argument function.
Function.ConditionalSpec<I,O>	A spec for adding conditions to a conditional function.
GraphiteConfig	A Configuration implementation to setup GraphiteReporter instances.
Groovy	Static methods for specialized Groovy integration.
Groovy.Ratpack	The definition of a Groovy Ratpack application.
Groovy.Script	Methods for working with Groovy scripts as application components.
GroovyByContentSpec	A Groovy oriented content negotiation handler builder.
GroovyByMethodSpec	A Groovy oriented multi-method handler builder.
GroovyChain	A Groovy oriented handler chain builder DSL.
GroovyChainAction	A convenience super class for a standalone implementation of a Action<GroovyChain>.
GroovyContext	Subclass of Context that adds Groovy friendly variants of methods.
GroovyEmbeddedApp	A more Groovy version of EmbeddedApp.
GroovyHandler	A handler subclass that makes a GroovyContext available.
GroovyRatpackMain	A boilerplate entry point, which combines RatpackServer.start(Action) and Groovy.Script.app().
GroovyRatpackMainApplicationUnderTest
GroovyRatpackServerSpec
GroovyRendererSupport<T>	A specialisation of RendererSupport that makes a GroovyContext available.
GroovyRequestFixture	A more Groovy friendly version of RequestFixture.
Gson	Support for rendering and parsing JSON using Google's Gson library.
GsonModule	Registers JSON parsing and rendering support using Google's Gson library.
GsonParseOpts	Parsing configuration for Google's Gson library.
GsonRender	A renderable object wrapper for rendering as JSON.
Guice	Static utility methods for creating Google Guice based Ratpack infrastructure.
H2Module
HandlebarsModule	An extension module that provides support for Handlebars.java templating engine.
HandlebarsModule.Config	The configuration object for HandlebarsModule.
Handler	A handler participates in the processing of a request/response pair, operating on a Context.
HandlerDecorator	Decorates a handler, effectively wrapping it.
HandlerExceptionNotThrownException	Exception thrown when the HandlingResult.exception(type) is called but no exception was thrown.
HandlerFactory	An interface for creating a Ratpack Handler based on the contents of the received Request.
Handlers	Factory methods for handler decorations.
HandlerTimeoutException	Thrown when a handler under test takes too long to produce a result.
HandlingResult	Represents the result of testing one or more handlers.
Headers	An immutable set of HTTP headers.
HealthCheck	Reports on the health of some aspect of the system.
HealthCheck.Result	The result of a health check.
HealthCheckHandler	A handler that executes health checks and renders the results.
HealthCheckResults	A value type representing the result of running multiple health checks.
HikariHealthCheck	Reports on the health of HikariCP JDBC connection pool.
HikariModule	An extension module that provides a DataSource from a HikariCP JDBC connection pool.
HikariService
HttpClient	An asynchronous HTTP client.
HttpClientConfig
HttpClientReadTimeoutException	Thrown when the read timeout duration for a request is reached.
HttpClientSpec	An additive specification of a HTTP client.
HttpMethod	The method of a HTTP request.
HttpResponse	Base type of responses from HttpClient regardless of if the request is streaming or not.
HttpUrlBuilder	Builds a HTTP URL, safely.
Imposition	A marker interface for all types used as an imposition.
Impositions	A mechanism for imposing things on an application from the outside and typically during testing.
ImpositionsSpec	Used to specify a set of impositions.
IndexedDelay	A index based implementation of Delay.
InjectionHandler	A super class that removes the boiler plate of retrieving objects from the context registry by injecting them based on a method signature.
InjectionHandler.NoSuitableHandleMethodException	Exception thrown if the subclass doesn't provide a valid handle method.
InvalidPathEncodingException	Thrown when a request is made for a path that is not correctly encoded.
Jackson	Provides key integration points with the Jackson support for dealing with JSON.
JavaSessionSerializer	Marker interface for serializers that can serialize anything that is Serializable.
JmxConfig
JsonParseOpts
JsonRender	A renderable object wrapper for rendering as JSON.
KryoSessionSerializer	A Kryo based session data serialization implementation.
MainClassApplicationUnderTest	An application under test fixture that can be used to test a server started by a “main” method.
Markup
MarkupTemplate
MarkupTemplateModule	An extension module that provides support for the Groovy markup template engine.
MarkupTemplateModule.Config
MDCInterceptor	An execution interceptor that adds support for SLF4J's Mapped Diagnostic Context (MDC) feature.
MediaType	A structured value for a Content-Type header value.
MetricsPrometheusHandler	A Handler that exposes metric reports in Prometheus format.
MetricsWebsocketBroadcastHandler	A Handler that broadcasts metric reports via web sockets.
MimeTypes	A registry for mime types.
MockApi	A test harness for simulating behavior of remote APIs by starting an EmbeddedApp that will handle requests based on the content of the received request.
MultipartFileSpec
MultipartFormSpec
MultiValueMap<K,V>	A map that may contain multiple values for a given key, but typically only one value.
MutableHeaders	A set of HTTP headers that can be changed.
MutableRegistry	A Registry that is also mutable.
NamedHelper<T>	Implementations of this interface bound with Guice will be automatically registered as handlebars helpers.
NewRelicModule
NewRelicTransaction
NoBaseDirException	Thrown when a request is made for the base directory of the application in an application launch config where no base directory has been set.
NonAllowedSessionTypeException	Thrown when attempting to read or write a type to a session that is not allowed.
NonBlocking	Declares that a method or function-like method parameter is non-blocking and can freely use Promise and other async constructs.
NoOptParserSupport	A convenience base for parsers that don't require options.
NoSuchParserException	Thrown when a request is made to parse the request, but no suitable parser was found that matched the content type and parse object.
NoSuchRendererException	Thrown when a request is made to render an object, but no suitable renderer can be found.
NotInRegistryException	Thrown when a request is made for an object that a registry cannot provide.
Nullable	Denotes that something may be null.
NullParseOpts	A generic parse type that can be used when parsers do not need any extra information from parse objects other than type.
Operation	A logical operation.
OverlappingExecutionException	An instance of this exception will be logged when execution overlaps.
Pair<L,R>	A generic pair implementation that can be used to cumulatively aggregate a data structure during a promise pipeline.
ParallelBatch<T>	A batch of promises to be processed, in parallel.
Parse<T,O>	The specification of a particular parse.
ParseException	A generic super type for exceptions indicate something when wrong for a parse operation.
Parser<O>	A parser converts a request body into an object.
ParserException	Wraps an exception thrown by a parser while parsing.
ParserSupport<O>	A convenience superclass for Parser implementations.
PathBinder	A path binder binds to a request path, extracting information from it.
PathBinderBuilder	A builder to generate a PathBinder from a list of tokens and literals.
PathBinding	A path binding represents some kind of "match" on the path of a request.
PathResolver
Paths2
PathTokens	A marker interface for the contextual object that represents the tokens extracted from the request path.
Predicate<T>	A function that returns true or false for a value.
Promise<T>	A promise for a single value.
Promised<T>	A logical value that will be available later, that promises can be created for.
Promised.AlreadySuppliedException	Thrown if an attempt is made to supply the value/result after it has already been supplied.
PropertiesUtil
Proxy	Configuration data for an HTTP proxy to utilize for outbound requests using HttpClient.
ProxySpec	Class for specifying configuration for an HTTP proxy to utilize for outgoing requests using HttpClient.
PublicAddress	The advertised public address.
RatpackConfiguration
RatpackConfiguration.ServerConfigConfiguration
RatpackConfiguration.ServerConfiguration
RatpackConsulConfig	Integration for retrieving values from a Consul Key-Value store as ByteSource to be used with the existing ServerConfigBuilder parsing options.
RatpackProperties
RatpackRetrofit	Builder for providing integration of Retrofit2 with Ratpack's HttpClient.
RatpackRetrofit.Builder
RatpackRetrofitCallException	Exception throw from Retrofit clients when using simple types instead of Response and the request is not successful.
RatpackServer	The entry point for creating and starting a Ratpack application.
RatpackServerCustomizer
RatpackServerCustomizerAdapter
RatpackServerSpec	A buildable specification of a Ratpack server.
RatpackVersion	Provides the version of the Ratpack core at runtime.
ReactorRatpack	Provides integration with Project Reactor.
ReadWriteAccess	Provides read/write serialization, analogous to ReadWriteLock.
ReadWriteAccess.TimeoutException	Thrown if access could not be acquired within the given timeout value.
ReceivedResponse
Redirector	Interprets objects as a Location header value, and issues the redirect response.
RedisSessionModule	An extension module that provides a redis backed session store.
RedisSessionModule.Config	Configuration for Redis Session Storage.
Registry	An object registry.
RegistryBacking	Provides instances to the Registry implementation which uses an implementation of this interface for backing the instances that the Registry contains or returns.
RegistryBuilder	A builder of registries.
RegistrySpec	An additive specification of a registry.
ReloadInformant	Informs when the server should be reloaded, during development.
Renderable	A renderable object, that can be given to Context.render(Object).
RenderableDecorator<T>	Decorates an object before it is rendered.
RenderableDecoratorSupport<T>	A convenience base class for RenderableDecorator implementations.
Renderer<T>	A renderer is responsible for rendering an object to the response.
RendererException	Wraps an exception thrown by a renderer while rendering.
RendererSupport<T>	A Renderer super class that provides a RendererSupport.getType() implementation based on the generic type of the impl.
RenderException	A generic super type for exceptions indicate something when wrong for a render operation.
ReporterConfigSupport<T extends ReporterConfigSupport<T>>	A common base for reporter config classes.
Request	A request to be handled.
RequestBodyAlreadyReadException	Thrown when an attempt is made to read the request body when it has already been read.
RequestBodyTooLargeException
RequestFixture	A contrived request environment, suitable for unit testing Handler implementations.
RequestId	An opaque identifier for the request.
RequestId.Generator	Generates, or assigns, an ID for requests.
RequestLogger	A handler that logs information about the request.
RequestOutcome	The outcome of processing a request.
RequestScoped
RequestSpec
RequestSpec.Body	The request body.
RequestTimingHandler
Response	A response to a request.
ResponseChunks	A renderable object for streaming data with HTTP chunked transfer-encoding.
ResponseTimer	A handler, that adds a "X-Response-Time" header to all requests indicating how long it took to start sending a response in milliseconds.
Result<T>	The result of an asynchronous operation, which may be an error.
RetryPolicy	A strategy object to govern retry behaviours.
RockerModule	A guice module that binds RockerRenderer.
RockerRenderer	A renderer for Rocker templates.
RxRatpack	Provides integration with RxJava2.
ScheduledReporterConfigSupport<T extends ReporterConfigSupport<T>>	A common base for scheduled reporter config classes.
ScriptNotFoundException
SentResponse	Represents a response that has been committed.
SerialBatch<T>	A batch of promises to be processed, serially.
ServerBackedApplicationUnderTest	An ApplicationUnderTest implementation that manages a RatpackServer.
ServerConfig	The configuration of the server.
ServerConfigBuilder	Builds a ServerConfig.
ServerConfigImposition	An override object for imposing server configuration.
ServerErrorHandler	An object that can deal with errors that occur during the processing of an exchange.
ServerSentEvent	A server sent event.
ServerSentEventBuilder	A server sent event builder.
ServerSentEventClient	A client for request Server Sent Event streams.
ServerSentEventResponse	A response for a server sent event stream.
ServerSentEvents	A renderable object for streaming server side events.
ServerSentEventsBuilder	Creates a builder for a server sent event stream.
Service	A service participates in the application lifecycle.
ServiceDependencies	Specifies dependencies between services.
ServiceDependenciesSpec	Allows declaring which services depend on which services.
Session	A mechanism for associating semi persistent data with an individual user/client.
SessionCookieConfig	Basic configuration for cookies related to session management.
SessionData	The data associated with the user session.
SessionId	A handle to the session ID.
SessionIdGenerator	Strategy interface for generating unique session ids.
SessionKey<T>	A key for an object in the session.
SessionModule	Provides support for HTTP sessions.
SessionSerializer	A serializer converts objects to bytes and vice versa.
SessionStore	A persistent store of session data.
SessionTypeFilter	A filter that determines whether a type is safe for session usage.
SessionTypeFilterPlugin	A marker interface for type filter implementations that should be composed into the type filter.
Signer
Slf4jConfig
Spring	Methods to facilitate integrating Spring Boot with Ratpack.
SqlModule
SqlProvider
StartEvent	A start event.
StartupFailureException	Thrown when a server fails to start.
Status	A status line of a HTTP response.
StopEvent	A stop event.
Stopper	The mechanism for stopping the application from within the application.
StreamedResponse	A received response to a http client request with streamed response content.
StreamEvent<T>	Represents an event emitted by a publisher.
StreamMapper<U,D>	Fundamentally transforms a stream.
Streams	Some lightweight utilities for working with reactive streams.
Template
Template
TestHttpClient	A Http Client focused on testing Ratpack applications.
TextTemplate
TextTemplateModel
TextTemplateModule
TextTemplateModule.Config
TextTemplateScript	The API available in template files.
Throttle	Limits the concurrency of operations, typically access to an external resource.
ThymeleafModule	An extension module that provides support for Thymeleaf templating engine.
ThymeleafModule.Config	The configuration object for ThymeleafModule.
Transaction	A JDBC transaction coordinator.
TransactionException	Thrown by Transaction.
TransformablePublisher<T>	A wrapper over a Publisher that makes it more convenient to chain transformations of different kinds.
TypeCoercingMap<K>	A string valued map that can do simple type conversions from the string values to primitive types.
TypeCoercingProperties	A delegate for Properties that can coerce values to various types.
TypedData	Data that potentially has a content type.
Types	Static utility methods for dealing with types.
UncheckedException	Used to wrap a checked exception to be thrown where a checked exception cannot be thrown.
UnexpectedHandlerException	Exception throw when a handler throws an exception that is different from the expected type in HandlingResult.exception(class) or when an exception was thrown when trying to access the results of a completed handler.
UnmanagedThreadException	Thrown when something is attempted outside of a Ratpack execution, that can only succeed during a Ratpack execution.
UploadedFile	A file that was uploaded via a form.
Upstream<T>	An upstream asynchronous data source.
UserId	An opaque identifier for the “user” that initiated the request.
UserRegistryImposition	Imposes an extra registry to be joined with the user registry when starting an application.
Utils
WebSocket
WebSocketClose<T>
WebsocketConfig
WebSocketConnector<T>
WebSocketHandler<T>
WebSocketMessage<T>
WebSockets	WebSockets support for Ratpack.
WebSocketSpec<T>
WriteStream<T>	The write end of a data stream.
YieldRequest