App is a robust, production-ready HTTP server.

HTTPS is enabled by default if host matchers with qualifying names are used in any of routes; certificates are automatically provisioned and renewed. Additionally, automatic HTTPS will also enable HTTPS for servers that listen only on the HTTPS port but which do not have any TLS connection policies defined by adding a good, default TLS connection policy.

In HTTP routes, additional placeholders are available (replace any *):

Placeholder | Description ------------|--------------- {http.request.body} | The request body (⚠️ inefficient; use only for debugging) {http.request.cookie.*} | HTTP request cookie {http.request.duration} | Time up to now spent handling the request (after decoding headers from client) {http.request.duration_ms} | Same as 'duration', but in milliseconds. {http.request.uuid} | The request unique identifier {http.request.header.*} | Specific request header field {http.request.host} | The host part of the request's Host header {http.request.host.labels.*} | Request host labels (0-based from right); e.g. for foo.example.com: 0=com, 1=example, 2=foo {http.request.hostport} | The host and port from the request's Host header {http.request.method} | The request method {http.request.orig_method} | The request's original method {http.request.orig_uri} | The request's original URI {http.request.orig_uri.path} | The request's original path {http.request.orig_uri.path.*} | Parts of the original path, split by / (0-based from left) {http.request.orig_uri.path.dir} | The request's original directory {http.request.orig_uri.path.file} | The request's original filename {http.request.orig_uri.query} | The request's original query string (without ?) {http.request.port} | The port part of the request's Host header {http.request.proto} | The protocol of the request {http.request.local.host} | The host (IP) part of the local address the connection arrived on {http.request.local.port} | The port part of the local address the connection arrived on {http.request.local} | The local address the connection arrived on {http.request.remote.host} | The host (IP) part of the remote client's address, if available (not known with HTTP/3 early data) {http.request.remote.port} | The port part of the remote client's address {http.request.remote} | The address of the remote client {http.request.scheme} | The request scheme, typically http or https {http.request.tls.version} | The TLS version name {http.request.tls.cipher_suite} | The TLS cipher suite {http.request.tls.resumed} | The TLS connection resumed a previous connection {http.request.tls.proto} | The negotiated next protocol {http.request.tls.proto_mutual} | The negotiated next protocol was advertised by the server {http.request.tls.server_name} | The server name requested by the client, if any {http.request.tls.client.fingerprint} | The SHA256 checksum of the client certificate {http.request.tls.client.public_key} | The public key of the client certificate. {http.request.tls.client.public_key_sha256} | The SHA256 checksum of the client's public key. {http.request.tls.client.certificate_pem} | The PEM-encoded value of the certificate. {http.request.tls.client.certificate_der_base64} | The base64-encoded value of the certificate. {http.request.tls.client.issuer} | The issuer DN of the client certificate {http.request.tls.client.serial} | The serial number of the client certificate {http.request.tls.client.subject} | The subject DN of the client certificate {http.request.tls.client.san.dns_names.*} | SAN DNS names(index optional) {http.request.tls.client.san.emails.*} | SAN email addresses (index optional) {http.request.tls.client.san.ips.*} | SAN IP addresses (index optional) {http.request.tls.client.san.uris.*} | SAN URIs (index optional) {http.request.uri} | The full request URI {http.request.uri.path} | The path component of the request URI {http.request.uri.path.*} | Parts of the path, split by / (0-based from left) {http.request.uri.path.dir} | The directory, excluding leaf filename {http.request.uri.path.file} | The filename of the path, excluding directory {http.request.uri.query} | The query string (without ?) {http.request.uri.query.*} | Individual query string value {http.response.header.*} | Specific response header field {http.vars.*} | Custom variables in the HTTP handler chain {http.shutting_down} | True if the HTTP app is shutting down {http.time_until_shutdown} | Time until HTTP server shutdown, if scheduled

AutoHTTPSConfig is used to disable automatic HTTPS or certain aspects of it for a specific server. HTTPS is enabled automatically and by default when qualifying hostnames are available from the config.

CELLibraryProducer provide CEL libraries that expose a Matcher implementation as a first class function within the CEL expression matcher.

CELMatcherFactory converts a constant CEL value into a RequestMatcher. Deprecated: Use CELMatcherWithErrorFactory instead.

CELMatcherWithErrorFactory converts a constant CEL value into a RequestMatcherWithError.

ExtraLogFields is a list of extra fields to log with every request.

HTTPErrorConfig determines how to handle errors from the HTTP handlers.

HTTPRedirectListenerWrapper provides HTTP->HTTPS redirects for connections that come on the TLS port as an HTTP request, by detecting using the first few bytes that it's not a TLS handshake, but instead an HTTP request.

This is especially useful when using a non-standard HTTPS port. A user may simply type the address in their browser without the https:// scheme, which would cause the browser to attempt the connection over HTTP, but this would cause a "Client sent an HTTP request to an HTTPS server" error response.

This listener wrapper must be placed BEFORE the "tls" listener wrapper, for it to work properly.

Handler is like http.Handler except ServeHTTP may return an error.

If any handler encounters an error, it should be returned for proper handling. Return values should be propagated down the middleware chain by returning it unchanged. Returned errors should not be re-wrapped if they are already HandlerError values.

HandlerError is a serializable representation of an error from within an HTTP handler.

HandlerFunc is a convenience type like http.HandlerFunc.

IPRangeSource gets a list of IP ranges.

The request is passed as an argument to allow plugin implementations to have more flexibility. But, a plugin MUST NOT modify the request. The caller will have read the r.RemoteAddr before getting IP ranges.

This should be a very fast function -- instant if possible. The list of IP ranges should be sourced as soon as possible if loaded from an external source (i.e. initially loaded during Provisioning), so that it's ready to be used when requests start getting handled. A read lock should probably be used to get the cached value if the ranges can change at runtime (e.g. periodically refreshed). Using a caddy.UsagePool may be a good idea to avoid having refetch the values when a config reload occurs, which would waste time.

If the list of IP ranges cannot be sourced, then provisioning SHOULD fail. Getting the IP ranges at runtime MUST NOT fail, because it would cancel incoming requests. If refreshing the list fails, then the previous list of IP ranges should continue to be returned so that the server can continue to operate normally.

Invoke implements a handler that compiles and executes a named route that was defined on the server.

EXPERIMENTAL: Subject to change or removal.

LoggableHTTPHeader makes an HTTP header loggable with zap.Object(). Headers with potentially sensitive information (Cookie, Set-Cookie, Authorization, and Proxy-Authorization) are logged with empty values.

LoggableHTTPRequest makes an HTTP request loggable with zap.Object().

LoggableStringArray makes a slice of strings marshalable for logging.

LoggableTLSConnState makes a TLS connection state loggable with zap.Object().

MatchClientIP matches requests by the client IP address, i.e. the resolved address, considering trusted proxies.

MatchExpression matches requests by evaluating a CEL expression. This enables complex logic to be expressed using a comfortable, familiar syntax. Please refer to the standard definitions of CEL functions and operators.

This matcher's JSON interface is actually a string, not a struct. The generated docs are not correct because this type has custom marshaling logic.

COMPATIBILITY NOTE: This module is still experimental and is not subject to Caddy's compatibility guarantee.

MatchRegexp is an embedable type for matching using regular expressions. It adds placeholders to the request's replacer.

MatchRemoteIP matches requests by the remote IP address, i.e. the IP address of the direct connection to Caddy.

MatchVarsRE matches the value of the context variables by a given regular expression.

Upon a match, it adds placeholders to the request: {http.regexp.name.capture_group} where name is the regular expression's name, and capture_group is either the named or positional capture group from the expression itself. If no name is given, then the placeholder omits the name: {http.regexp.capture_group} (potentially leading to collisions).

MatcherSet is a set of matchers which must all match in order for the request to be matched successfully.

MatcherSets is a group of matcher sets capable of checking whether a request matches any of the sets.

Metrics configures metrics observations. EXPERIMENTAL and subject to change or removal.

Middleware chains one Handler to the next by being passed the next Handler in the chain.

MiddlewareHandler is like Handler except it takes as a third argument the next handler in the chain. The next handler will never be nil, but may be a no-op handler if this is the last handler in the chain. Handlers which act as middleware should call the next handler's ServeHTTP method so as to propagate the request down the chain properly. Handlers which act as responders (content origins) need not invoke the next handler, since the last handler in the chain should be the first to write the response.

RawMatcherSets is a group of matcher sets in their raw, JSON form.

RequestMatcher is a type that can match to a request. A route matcher MUST NOT modify the request, with the only exception being its context.

Deprecated: Matchers should now implement RequestMatcherWithError. You may remove any interface guards for RequestMatcher but keep your Match() methods for backwards compatibility.

RequestMatcherWithError is like RequestMatcher but can return an error. An error during matching will abort the request middleware chain and invoke the error middleware chain.

This will eventually replace RequestMatcher. Matcher modules should implement both interfaces, and once all modules have been updated to use RequestMatcherWithError, the RequestMatcher interface may eventually be dropped.

ResponseHandler pairs a response matcher with custom handling logic. Either the status code can be changed to something else while using the original response body, or, if a status code is not set, it can execute a custom route list; this is useful for executing handler routes based on the properties of an HTTP response that has not been written out to the client yet.

To use this type, provision it at module load time, then when ready to use, match the response against its matcher; if it matches (or doesn't have a matcher), change the status code on the response if configured; otherwise invoke the routes by calling rh.Routes.Compile(next).ServeHTTP(rw, req) (or similar).

ResponseMatcher is a type which can determine if an HTTP response matches some criteria.

ResponseRecorder is a http.ResponseWriter that records responses instead of writing them to the client. See docs for NewResponseRecorder for proper usage.

ResponseWriterWrapper wraps an underlying ResponseWriter and promotes its Pusher method as well. To use this type, embed a pointer to it within your own struct type that implements the http.ResponseWriter interface, then call methods on the embedded value.

Route consists of a set of rules for matching HTTP requests, a list of handlers to execute, and optional flow control parameters which customize the handling of HTTP requests in a highly flexible and performant manner.

[
    {"handler": "encode"},
    {"handler": "templates"},
    {"handler": "file_server"}
]

RouteList is a list of server routes that can create a middleware chain.

Server describes an HTTP server.

ServerLogConfig describes a server's logging configuration. If enabled without customization, all requests to this server are logged to the default logger; logger destinations may be customized per-request-host.

ShouldBufferFunc is a function that returns true if the response should be buffered, given the pending HTTP status code and response headers.

StaticError implements a simple handler that returns an error. This handler returns an error value, but does not write a response. This is useful when you want the server to act as if an error occurred; for example, to invoke your custom error handling logic.

Since this handler does not write a response, the error information is for use by the server to know how to handle the error.

StaticIPRange provides a static range of IP address prefixes (CIDRs).

StaticResponse implements a simple responder for static responses.

StringArray is a slices of strings, but also accepts a single string as a value when JSON unmarshaling, converting it to a slice of one string.

Subroute implements a handler that compiles and executes routes. This is useful for a batch of routes that all inherit the same matchers, or for multiple routes that should be treated as a single route.

You can also use subroutes to handle errors from its handlers. First the primary routes will be executed, and if they return an error, the errors routes will be executed; in that case, an error is only returned to the entry point at the server if there is an additional error returned from the errors routes.

VarsMatcher is an HTTP request matcher which can match requests based on variables in the context or placeholder values. The key is the placeholder or name of the variable, and the values are possible values the variable can be in order to match (logical OR'ed).

If the key is surrounded by { } it is assumed to be a placeholder. Otherwise, it will be considered a variable name.

Placeholders in the keys are not expanded, but placeholders in the values are.

VarsMiddleware is an HTTP middleware which sets variables to have values that can be used in the HTTP request handler chain. The primary way to access variables is with placeholders, which have the form: {http.vars.variable_name}, or with the vars and vars_regexp request matchers.

The key is the variable name, and the value is the value of the variable. Both the name and value may use or contain placeholders.

WeakString is a type that unmarshals any JSON value as a string literal, with the following exceptions:

1. actual string values are decoded as strings; and
2. null is decoded as empty string;

and provides methods for getting the value as various primitive types. However, using this type removes any type safety as far as deserializing JSON is concerned.

This type doesn't have documentation.

This type doesn't have documentation.

celHTTPRequest wraps an http.Request with ref.Val interface methods.

This type also implements the interpreter.Activation interface which drops allocation costs for CEL expression evaluations by roughly half.

celPkixName wraps an pkix.Name with methods to satisfy the ref.Val interface.

celTypeAdapter can adapt our custom types to a CEL value.

This type doesn't have documentation.

used to track the size of hijacked response writers

http2Listener wraps the listener to solve the following problems:

1. server h2 natively without using h2c hack when listener handles tls connection but don't return *tls.Conn
2. graceful shutdown. the shutdown logic is copied from stdlib http.Server, it's an extra maintenance burden but whatever, the shutdown logic maybe extracted to be used with h2c graceful shutdown. http2.Server supports graceful shutdown sending GO_AWAY frame to connected clients, but doesn't track connection status. It requires explicit call of http2.ConfigureServer

This type doesn't have documentation.

This type doesn't have documentation.

httpRedirectListener is listener that checks the first few bytes of the request when the server is intended to accept HTTPS requests, to respond to an HTTP request with a redirect.

lengthReader is an io.ReadCloser that keeps track of the number of bytes read from the request body.

matcherCELLibrary is a simplistic configurable cel.Library implementation.

This type doesn't have documentation.

This type doesn't have documentation.

This type doesn't have documentation.

tlsPlaceholderWrapper is a no-op listener wrapper that marks where the TLS listener should be in a chain of listener wrappers. It should only be used if another listener wrapper must be placed in front of the TLS handshake.

CELMatcherDecorator matches a call overload generated by a CEL macro that takes a single argument, and optimizes the implementation to precompile the matcher and return a function that references the precompiled and provisioned matcher.

CELMatcherImpl creates a new cel.Library based on the following pieces of data:

• macroName: the function name to be used within CEL. This will be a macro and not a function proper.
• funcName: the function overload name generated by the CEL macro used to represent the matcher.
• matcherDataTypes: the argument types to the macro.
• fac: a matcherFactory implementation which converts from CEL constant values to a Matcher instance.

Note, macro names and function names must not collide with other macros or functions exposed within CEL expressions, or an error will be produced during the expression matcher plan time.

The existing CELMatcherImpl support methods are configured to support a limited set of function signatures. For strong type validation you may need to provide a custom macro which does a more detailed analysis of the CEL literal provided to the macro as an argument.

CELMatcherRuntimeFunction creates a function binding for when the input to the matcher is dynamically resolved rather than a set of static constant values.

CELValueToMapStrList converts a CEL value to a map[string][]string

Earlier validation stages should guarantee that the value has this type at compile time, and that the runtime value type is map[string]any. The reason for the slight difference in value type is that CEL allows for map literals containing heterogeneous values, in this case string and list of string.

CIDRExpressionToPrefix takes a string which could be either a CIDR expression or a single IP address, and returns a netip.Prefix.

CleanPath cleans path p according to path.Clean(), but only merges repeated slashes if collapseSlashes is true, and always preserves trailing slashes.

Error is a convenient way for a Handler to populate the essential fields of a HandlerError. If err is itself a HandlerError, then any essential fields that are not set will be populated.

GetVar gets a value out of the context's variable table by key. If the key does not exist, the return value will be nil.

NewMatcherCELLibrary creates a matcherLibrary from option setes.

NewResponseRecorder returns a new ResponseRecorder that can be used instead of a standard http.ResponseWriter. The recorder is useful for middlewares which need to buffer a response and potentially process its entire body before actually writing the response to the underlying writer. Of course, buffering the entire body has a memory overhead, but sometimes there is no way to avoid buffering the whole response, hence the existence of this type. Still, if at all practical, handlers should strive to stream responses by wrapping Write and WriteHeader methods instead of buffering whole response bodies.

Buffering is actually optional. The shouldBuffer function will be called just before the headers are written. If it returns true, the headers and body will be buffered by this recorder and not written to the underlying writer; if false, the headers will be written immediately and the body will be streamed out directly to the underlying writer. If shouldBuffer is nil, the response will never be buffered and will always be streamed directly to the writer.

You can know if shouldBuffer returned true by calling Buffered().

The provided buffer buf should be obtained from a pool for best performance (see the sync.Pool type).

Proper usage of a recorder looks like this:

rec := caddyhttp.NewResponseRecorder(w, buf, shouldBuffer)
err := next.ServeHTTP(rec, req)
if err != nil {
    return err
}
if !rec.Buffered() {
    return nil
}
// process the buffered response here

The header map is not buffered; i.e. the ResponseRecorder's Header() method returns the same header map of the underlying ResponseWriter. This is a crucial design decision to allow HTTP trailers to be flushed properly (https://github.com/caddyserver/caddy/issues/3236).

Once you are ready to write the response, there are two ways you can do it. The easier way is to have the recorder do it:

rec.WriteResponse()

This writes the recorded response headers as well as the buffered body. Or, you may wish to do it yourself, especially if you manipulated the buffered body. First you will need to write the headers with the recorded status code, then write the body (this example writes the recorder's body buffer, but you might have your own body to write instead):

w.WriteHeader(rec.Status())
io.Copy(w, rec.Buffer())

As a special case, 1xx responses are not buffered nor recorded because they are not the final response; they are passed through directly to the underlying ResponseWriter.

NewTestReplacer creates a replacer for an http.Request for use in tests that are not in this package

ParseCaddyfileNestedMatcher parses the Caddyfile tokens for a nested matcher set, and returns its raw module map value.

ParseNamedResponseMatcher parses the tokens of a named response matcher.

@name {
    header <field> [<value>]
    status <code...>
}

Or, single line syntax:

@name [header <field> [<value>]] | [status <code...>]

PrepareRequest fills the request r for use in a Caddy HTTP handler chain. w and s can be nil, but the handlers will lose response placeholders and access to the server.

PrivateRangesCIDR returns a list of private CIDR range strings, which can be used as a configuration shortcut. Note: this function is used at least by mholt/caddy-l4.

RegisterNetworkHTTP3 registers a mapping from non-HTTP/3 network to HTTP/3 network. This should be called during init() and will panic if the network type is standard, reserved, or already registered.

EXPERIMENTAL: Subject to change.

SanitizedPathJoin performs filepath.Join(root, reqPath) that is safe against directory traversal attacks. It uses logic similar to that in the Go standard library, specifically in the implementation of http.Dir. The root is assumed to be a trusted path, but reqPath is not; and the output will never be outside of root. The resulting path can be used with the local file system. If root is empty, the current directory is assumed. If the cleaned request path is deemed not local according to lexical processing (i.e. ignoring links), it will be rejected as unsafe and only the root will be returned.

SetVar sets a value in the context's variable table with the given key. It overwrites any previous value with the same key.

If the value is nil (note: non-nil interface with nil underlying value does not count) and the key exists in the table, the key+value will be deleted from the table.

StatusCodeMatches returns true if a real HTTP status code matches the configured status code, which may be either a real HTTP status code or an integer representing a class of codes (e.g. 4 for all 4xx statuses).

Provision sets up the app.

Start runs the app. It finishes automatic HTTPS if enabled, including management of certificates.

Stop gracefully shuts down the HTTP server.

Validate ensures the app's configuration is valid.

Add adds a field to the list of extra fields to log.

Set sets a field in the list of extra fields to log. If the field already exists, it is replaced.

WithError makes a shallow copy of r to add the error to its context, and sets placeholders on the request's replacer related to err. It returns the modified request which has the error information in its context and replacer. It overwrites any existing error values that are stored.

Provision parses m's IP ranges, either from IP or CIDR expressions.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

Provision sets ups m.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalJSON unmarshals m's expression.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

Provision loads the matcher modules to be negated.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalJSON satisfies json.Unmarshaler. It puts the JSON bytes directly into m's MatcherSetsRaw field.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

Match returns true if input matches the compiled regular expression in mre. It sets values on the replacer repl associated with capture groups, using the given scope (namespace).

Provision compiles the regular expression.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

Validate ensures mre is set up correctly.

Provision parses m's IP ranges, either from IP or CIDR expressions.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile parses Caddyfile tokens for this matcher. Syntax:

... tls [early_data]

EXPERIMENTAL SYNTAX: Subject to change.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

FromInterface fills ms from an 'any' value obtained from LoadModule.

Provision sets up the routes in rh.

Push implements http.Pusher. It simply calls the underlying ResponseWriter's Push method if there is one, or returns ErrNotImplemented otherwise.

ReadFrom implements io.ReaderFrom. It retries to use io.ReaderFrom if available, then fallback to io.Copy. see: https://github.com/caddyserver/caddy/issues/6546

Unwrap returns the underlying ResponseWriter, necessary for http.ResponseController to work correctly.

Provision sets up both the matchers and handlers in the route.

ProvisionHandlers sets up all the handlers by loading the handler modules. Only call this method directly if you need to set up matchers and handlers separately without having to provision a second time; otherwise use Provision instead.

ProvisionMatchers sets up all the matchers by loading the matcher modules. Only call this method directly if you need to set up matchers and handlers separately without having to provision a second time; otherwise use Provision instead.

Listeners returns the server's listeners. These are active listeners, so calling Accept() or Close() on them will probably break things. They are made available here for read-only purposes (e.g. Addr()) and for type-asserting for purposes where you know what you're doing.

EXPERIMENTAL: Subject to change or removal.

Name returns the server's name.

RegisterConnContext registers f to be invoked as part of s.ConnContext.

RegisterConnState registers f to be invoked on s.ConnState.

RegisterOnShutdown registers f to be invoked when the server begins to shut down.

RegisterOnStop registers f to be invoked after the server has shut down completely.

EXPERIMENTAL: Subject to change or removal.

ServeHTTP is the entry point for all HTTP requests.

UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:

error [<matcher>] <status>|<message> [<status>] {
    message <text>
}

If there is just one argument (other than the matcher), it is considered to be a status code if it's a valid positive integer of 3 digits.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:

respond [<matcher>] <status>|<body> [<status>] {
    body <text>
    close
}

If there is just one argument (other than the matcher), it is considered to be a status code if it's a valid positive integer of 3 digits.

UnmarshalJSON satisfies json.Unmarshaler.

Provision sets up subrouting.

UnmarshalCaddyfile implements caddyfile.Unmarshaler.

UnmarshalCaddyfile implements caddyfile.Unmarshaler. Syntax:

vars [<name> <val>] {
    <name> <val>
    ...
}

UnmarshalJSON satisfies json.Unmarshaler according to this type's documentation.

Read tries to peek at the first few bytes of the request, and if we get an error reading the headers, and that error was due to the bytes looking like an HTTP request, then we perform a HTTP->HTTPS redirect on the same port as the original connection.

Accept waits for and returns the next connection to the listener, wrapping it with a httpRedirectConn.

Lazy generates UUID string or return cached value if present

Buffer returns the body buffer that rr was created with. You should still have your original pointer, though.

Buffered returns whether rr has decided to buffer the response.

FlushError will suppress actual flushing if the response is buffered. See: https://github.com/caddyserver/caddy/issues/6144

Size returns the number of bytes written, not including the response headers.

Status returns the status code that was written, if any.

WriteHeader writes the headers with statusCode to the wrapped ResponseWriter unless the response is to be buffered instead. 1xx responses are never buffered.

CaddyModule returns the Caddy module information.

Unwrap returns the underlying error value. See the errors package for info.

ServeHTTP implements the Handler interface.

CaddyModule returns the Caddy module information.

MarshalLogObject satisfies the zapcore.ObjectMarshaler interface.

MarshalLogObject satisfies the zapcore.ObjectMarshaler interface.

MarshalLogArray satisfies the zapcore.ArrayMarshaler interface.

MarshalLogObject satisfies the zapcore.ObjectMarshaler interface.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression client_ip('192.168.0.0/16', '172.16.0.0/12', '10.0.0.0/8')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CaddyModule returns the Caddy module information.

MarshalJSON marshals m's expression.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression header({'content-type': 'image/png'})
expression header({'foo': ['bar', 'baz']}) // match bar or baz

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression header_regexp('foo', 'Field', 'fo+')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

Provision compiles m's regular expressions.

Validate validates m's regular expressions.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression host('localhost')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

Provision sets up and validates m, including making it more efficient for large lists.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression method('PUT', 'POST')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CaddyModule returns the Caddy module information.

MarshalJSON satisfies json.Marshaler by marshaling m's raw matcher sets.

Match returns true if r matches m. Since this matcher negates the embedded matchers, false is returned if any of its matcher sets return true.

MatchWithError returns true if r matches m. Since this matcher negates the embedded matchers, false is returned if any of its matcher sets return true.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression path('*substring*', '*suffix')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

Provision lower-cases the paths in m to ensure case-insensitive matching.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression path_regexp('^/bar')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression protocol('https')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression query({'sort': 'asc'}) || query({'foo': ['*bar*', 'baz']})

CaddyModule returns the Caddy module information.

Match returns true if r matches m. An empty m matches an empty query string.

MatchWithError returns true if r matches m. An empty m matches an empty query string.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression remote_ip('192.168.0.0/16', '172.16.0.0/12', '10.0.0.0/8')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression vars_regexp('foo', '{magic_number}', '[0-9]+')
expression vars_regexp('{magic_number}', '[0-9]+')

CaddyModule returns the Caddy module information.

Match returns true if r matches m.

MatchWithError returns true if r matches m.

Provision compiles m's regular expressions.

Validate validates m's regular expressions.

Match returns true if the request matches all matchers in mset or if there are no matchers.

MatchWithError returns true if r matches m.

AnyMatch returns true if req matches any of the matcher sets in ms or if there are no matchers, in which case the request always matches.

Deprecated: Use AnyMatchWithError instead.

AnyMatchWithError returns true if req matches any of the matcher sets in ms or if there are no matchers, in which case the request always matches. If any matcher returns an error, we cut short and return the error.

TODO: Is this used?

Match returns true if the given statusCode and hdr match rm.

Compile prepares a middleware chain from the route list. This should only be done once during the request, just before the middleware chain is executed.

Empty returns true if the route has all zero/default values.

Compile prepares a middleware chain from the route list. This should only be done either once during provisioning for top-level routes, or on each request just before the middleware chain is executed for subroutes.

Provision sets up both the matchers and handlers in the routes.

ProvisionHandlers sets up all the handlers by loading the handler modules. Only call this method directly if you need to set up matchers and handlers separately without having to provision a second time; otherwise use Provision instead.

ProvisionMatchers sets up all the matchers by loading the matcher modules. Only call this method directly if you need to set up matchers and handlers separately without having to provision a second time; otherwise use Provision instead.

CaddyModule returns the Caddy module information.

CaddyModule returns the Caddy module information.

CaddyModule returns the Caddy module information.

CaddyModule returns the Caddy module information.

CELLibrary produces options that expose this matcher for use in CEL expression matchers.

Example:

expression vars({'{magic_number}': ['3', '5']})
expression vars({'{foo}': 'single_value'})

CaddyModule returns the Caddy module information.

Match matches a request based on variables in the context, or placeholders if the key is not a variable.

MatchWithError returns true if r matches m.

CaddyModule returns the Caddy module information.

Bool returns ws as a boolean. If ws is not a boolean, false is returned.

Float64 returns ws as a float64. If ws is not a float value, the zero value is returned.

Int returns ws as an integer. If ws is not an integer, 0 is returned.

MarshalJSON marshals was a boolean if true or false, a number if an integer, or a string otherwise.

String returns ws as a string.

a barebones http.ResponseWriter mock

This type doesn't have documentation.

This type doesn't have documentation.

an http.ResponseWriter mock that supports ReadFrom

This type doesn't have documentation.

This type doesn't have documentation.