Title: | A Simple Router for HTTP and WebSocket Requests |
---|---|
Description: | In order to make sure that web request ends up in the correct handler function a router is often used. 'routr' is a package implementing a simple but powerful routing functionality for R based servers. It is a fully functional 'fiery' plugin, but can also be used with other 'httpuv' based servers. |
Authors: | Thomas Lin Pedersen [cre, aut]
|
Maintainer: | Thomas Lin Pedersen <[email protected]> |
License: | MIT + file LICENSE |
Version: | 0.4.1.9000 |
Built: | 2025-03-10 22:21:48 UTC |
Source: | https://github.com/thomasp85/routr |
An asset_route()
is fundamentally different than the other routes provided
by routr. Conceptually it is akin to ressource_route()
in that it is used
for serving static file content, but this route circumvents the standard
dispatch entirely (the request never enters the R process). This makes it
extremely fast but also somewhat limited as you can't pass the request
through any middleware. The choice between asset_route()
and
ressource_route()
thus depends on your needs.
asset_route( at, path, use_index = TRUE, fallthrough = FALSE, html_charset = "utf-8", headers = list(), validation = NULL, except = NULL )
asset_route( at, path, use_index = TRUE, fallthrough = FALSE, html_charset = "utf-8", headers = list(), validation = NULL, except = NULL )
at |
The url path to listen to requests on |
path |
The path to the file or directory on the file system |
use_index |
Should an |
fallthrough |
Should requests that doesn't match a file enter the request loop or have a 404 response send directly |
html_charset |
The charset to report when serving html files |
headers |
A list of headers to add to the response. Will be combined with the global headers of the app |
validation |
An optional validation pattern. Presently, the only type of
validation supported is an exact string match of a header. For example, if
|
except |
One or more url paths that should be excluded from the route.
Requests matching these will enter the standard router dispatch. The paths
are interpreted as subpaths to |
An AssetRoute object
Other Route constructors:
openapi_route()
,
ressource_route()
,
shared_secret_route()
,
sizelimit_route()
asset_route("/wd", "./", except = "/private")
asset_route("/wd", "./", except = "/private")
A class for serving files from the server directly. The AssetRoute
is
fundamentally different than the other routes provided by routr. It is
specific to httpuv and circumvents the standard dispatch entirely (the
request never enters the R process). This makes it extremely fast but also
somewhat limited as you can't pass the request through any middleware.
at
The url path to serve the assets on
path
The path to the file or directory to serve
use_index
Should an index.html
file be served if present when a client requests the folder
fallthrough
Should requests that doesn't match a file enter the request loop or have a 404 response send directly
html_charset
The charset to report when serving html files
headers
A list of headers to add to the response.
validation
An optional validation pattern to compare to the request headers
except
One or more url paths that should be excluded from this route
name
An autogenerated name for the asset route
new()
Create a new AssetRoute
AssetRoute$new( at, path, use_index = TRUE, fallthrough = FALSE, html_charset = "utf-8", headers = list(), validation = NULL, except = NULL )
at
The url path to listen to requests on
path
The path to the file or directory on the file system
use_index
Should an index.html
file be served if present when a
client requests the folder
fallthrough
Should requests that doesn't match a file enter the request loop or have a 404 response send directly
html_charset
The charset to report when serving html files
headers
A list of headers to add to the response. Will be combined with the global headers of the app
validation
A string for validating incoming requests. See httpuv::staticPath
except
One or more url paths that should be excluded from the
route. Requests matching these will enter the standard router dispatch.
The paths are interpreted as subpaths to at
, e.g. the final path to
exclude will be at
+exclude
print()
Pretty printing of the object
AssetRoute$print(...)
...
Ignored
on_attach()
Method for use by fiery
when attached as a plugin. Should
not be called directly. This method creates a RouteStack with the asset
route as the single route and then mounts that to the app. For more
flexibility create the RouteStack manually
AssetRoute$on_attach(app, on_error = NULL, ...)
app
The Fire object to attach the router to
on_error
A function for error handling
...
Ignored
clone()
The objects of this class are cloneable with this method.
AssetRoute$clone(deep = FALSE)
deep
Whether to make a deep clone.
This route facilitates serving the OpenAPI specs for your server, using either RapiDoc, Redoc or Swagger as a UI for it. This function does not help you describe your API - you have to provide the description for it yourself.
openapi_route( spec, root = "__docs__", ui = c("rapidoc", "redoc", "swagger"), ... )
openapi_route( spec, root = "__docs__", ui = c("rapidoc", "redoc", "swagger"), ... )
spec |
The path to the json or yaml file describing your OpenAPI spec |
root |
The point from which you want to serve your UI from |
ui |
Either |
... |
Further arguments passed on to the ui functions (e.g. rapidoc::rapidoc_spec()) |
A Route object
Other Route constructors:
asset_route()
,
ressource_route()
,
shared_secret_route()
,
sizelimit_route()
This function creates a route mapping different paths to files on the server
filesystem. Different subpaths can be mapped to different locations on the
server so that e.g. /data/
maps to /path/to/data/
and /assets/
maps to
/a/completely/different/path/
. The route support automatic expansion of
paths to a default extension or file, using compressed versions of files if
the request permits it, and setting the correct headers so that results are
cached.
ressource_route( ..., default_file = "index.html", default_ext = "html", finalize = NULL, continue = FALSE )
ressource_route( ..., default_file = "index.html", default_ext = "html", finalize = NULL, continue = FALSE )
... |
Named arguments mapping a subpath in the URL to a location on the file system. These mappings will be checked in sequence |
default_file |
The default file to look for if the path does not map to a file directly (see Details) |
default_ext |
The default file extension to add to the file if a file cannot be found at the provided path and the path does not have an extension (see Details) |
finalize |
An optional function to run if a file is found. The function
will receive the request as the first argument, the response as the second,
and anything passed on through |
continue |
A logical that should be returned if a file is found.
Defaults to |
The way paths are resolved to a file is, for every mounted location,
Check if the path contains the mount point. If not, continue to the next mount point
substitute the mount point for the local location in the path
if the path ends with /
add the default_file
(defaults to index.html
)
see if the file exists along with compressed versions (versions with
.gz
, .zip
, .br
, .zz
appended)
if any version exists, chose the prefered encoding based on the
Accept-Encoding
header in the request, and return.
if none exists and the path does not specify a file extension, add
default_ext
to the path and repeat 3-4
if none exists still and the path does not specify a file extension, add
default_file
to the path and repeat 3-4
if none exists still, continue to the next mount point
This means that for the path /data/mtcars
, the following locations will be
tested (assuming the /data/
-> /path/to/data/
mapping):
/path/to/data/mtcars
, /path/to/data/mtcars.gz
,
/path/to/data/mtcars.zip
, /path/to/data/mtcars.br
,
/path/to/data/mtcars.zz
/path/to/data/mtcars.html
, /path/to/data/mtcars.html.gz
,
/path/to/data/mtcars.html.zip
, /path/to/data/mtcars.html.br
,
/path/to/data/mtcars.html.zz
/path/to/data/mtcars/index.html
, /path/to/data/mtcars/index.html.gz
,
/path/to/data/mtcars/index.html.zip
, /path/to/data/mtcars/index.html.br
,
/path/to/data/mtcars/index.html.zz
Assuming the default values of default_file
and default_ext
If a file is not found, the route will simply return TRUE
to hand of
control to subsequent routes in the stack, otherwise it will return the
logical value in the continue
argument (defaults to FALSE
, thus
shortcutting any additional routes in the stack).
If a file is found the request headers If-Modified-Since
and
If-None-Match
, will be fetched and, if exist, will be used to determine
whether a 304 - Not Modified
response should be send instead of the file.
If the file should be send, it will be added to the response along with the
following headers:
Content-Type
based on the extension of the file (without any encoding
extensions)
Content-Encoding
based on the negotiated file encoding
ETag
based on rlang::hash()
of the last modified date
Cache-Control
set to max-age=3600
Furthermore Content-Length
will be set automatically by httpuv
Lastly, if found, the finalize function will be called, forwarding the
request
, response
and ...
from the dispatch
method.
A Route object
Other Route constructors:
asset_route()
,
openapi_route()
,
shared_secret_route()
,
sizelimit_route()
# Map package files res_route <- ressource_route( '/package_files/' = system.file(package = 'routr') ) rook <- fiery::fake_request('http://example.com/package_files/DESCRIPTION') req <- reqres::Request$new(rook) res_route$dispatch(req) req$response$as_list()
# Map package files res_route <- ressource_route( '/package_files/' = system.file(package = 'routr') ) rook <- fiery::fake_request('http://example.com/package_files/DESCRIPTION') req <- reqres::Request$new(rook) res_route$dispatch(req) req$response$as_list()
This function constructs a new Route, optionally with a set of handlers already attached.
route(..., root = "")
route(..., root = "")
... |
Handlers to add up front. Must be in the form of named lists where the names corresponds to paths and the elements are the handlers. The name of the argument itself defines the method to listen on (see examples) |
root |
The root of the route. Will be removed from the path of any request before matching a handler |
A Route object
# An empty route route <- route() route # Prepopulating it at construction route <- route(all = list( '/*' = function(request, response, keys, ...) { message('Request received') TRUE } )) route
# An empty route route <- route() route # Prepopulating it at construction route <- route(all = list( '/*' = function(request, response, keys, ...) { message('Request received') TRUE } )) route
Class for handling a single route dispatch
The Route
class is used to encapsulate a single URL dispatch, that is,
chose a single handler from a range based on a URL path. A handler will be
called with a request, response, and keys argument as well as any additional
arguments passed on to dispatch()
.
The path will strip the query string prior to assignment of the handler, can
contain wildcards, and can be parameterised using the :
prefix. If there
are multiple matches of the request path the most specific will be chosen.
Specificity is based on number of elements (most), number of parameters
(least), and number of wildcards (least), in that order. Parameter
values will be available in the keys argument passed to the handler, e.g. a
path of /user/:user_id
will provide list(user_id = 123)
for a dispatch on
/user/123
in the keys
argument.
Handlers are only called for their side-effects and are expected to return
either TRUE
or FALSE
indicating whether additional routes in a
RouteStack
should be called, e.g. if a handler is returning FALSE
all
further processing of the request will be terminated and the response will be
passed along in its current state. Thus, the intend of the handlers is to
modify the request and response objects, in place. All calls to handlers will
be wrapped in try()
and if an exception is raised the response code will be
set to 500
with the body of the response being the error message. Further
processing of the request will be terminated. If a different error handling
scheme is wanted it must be implemented within the handler (the standard
approach is chosen to avoid handler errors resulting in a server crash).
A handler is referencing a specific HTTP method (get
, post
, etc.) but can
also reference all
to indicate that it should match all types of requests.
Handlers referencing all
have lower precedence than those referencing
specific methods, so will only be called if a match is not found within the
handlers of the specific method.
A new 'Route'-object is initialized using the new()
method on the
generator or alternatively by using route()
:
Usage
route <- Route$new(...)
|
route <- route(...)
|
root
The root of the route. Will be removed from the path of any request before matching a handler
name
An autogenerated name for the route
empty
Is the route empty
new()
Create a new Route
Route$new(..., ignore_trailing_slash = FALSE)
...
Handlers to add up front. Must be in the form of named lists where the names corresponds to paths and the elements are the handlers. The name of the argument itself defines the method to listen on (see examples)
ignore_trailing_slash
Logical. Should the trailing slash of a path
be ignored when adding handlers and handling requests. Setting this will
not change the request or the path associated with but just ensure that
both path/to/ressource
and path/to/ressource/
ends up in the same
handler. Because the request is left untouched, setting this to TRUE
will not affect further processing by other routes
print()
Pretty printing of the object
Route$print(...)
...
Ignored
add_handler()
Add a handler to the specified method and path. The special
method 'all'
will allow the handler to match all http request methods.
The path is a URL path consisting of strings, parameters (strings
prefixed with :
), and wildcards (*
), separated by /
. A wildcard
will match anything and is thus not restricted to a single path element
(i.e. it will span multiple /
if possible). The handler must be a
function containing the arguments request
, response
, keys
, and
...
, and must return either TRUE
or FALSE
. The request
argument
will be a reqres::Request object and the response
argument will be a
reqres::Response object matching the current exchange. The keys
argument will be a named list with the value of all matched parameters
from the path. Any additional argument passed on to the dispatch
method
will be avaiable as well. This method will override an existing handler
with the same method and path.
Route$add_handler(method, path, handler, reject_missing_methods = FALSE)
method
The http method to match the handler to
path
The URL path to match to
handler
A handler function
reject_missing_methods
Should requests to this path that doesn't
have a handler for the specific method automatically be rejected with a
405 Method Not Allowed response with the correct Allow header informing
the client of the implemented methods. Assigning a handler to "all"
for
the same path at a later point will overwrite this functionality. Be
aware that setting this to TRUE
will prevent the request from falling
through to other routes that might have a matching method and path.
remove_handler()
Removes the handler assigned to the specified method and path. If no handler have been assigned it will throw a warning.
Route$remove_handler(method, path)
method
The http method of the handler to remove
path
The URL path of the handler to remove
get_handler()
Returns a handler already assigned to the specified method and path. If no handler have been assigned it will throw a warning.
Route$get_handler(method, path)
method
The http method of the handler to find
path
The URL path of the handler to find
remap_handlers()
Allows you to loop through all added handlers and reassings
them at will. A function with the parameters method
, path
, and
handler
must be provided which is responsible for reassigning the
handler given in the arguments. If the function does not reassign the
handler, then the handler is removed.
Route$remap_handlers(.f)
.f
A function performing the remapping of each handler
merge_route()
Merge another route into this one, adopting all its handlers. The other route will be empty after the merge.
Route$merge_route(route, use_root = TRUE)
route
A Route object
use_root
Should the root of route
be prepended to all paths from
the route before adding them
dispatch()
Based on a reqres::Request object the route will find the
correct handler and call it with the correct arguments. Anything passed
in with ...
will be passed along to the handler.
Route$dispatch(request, ...)
request
The request to route
...
Additional arguments to the handlers
on_attach()
Method for use by fiery
when attached as a plugin. Should
not be called directly. This method creates a RouteStack with the route
as the single route and then mounts that to the app. For more flexibility
create the RouteStack manually
Route$on_attach(app, on_error = NULL, ...)
app
The Fire object to attach the router to
on_error
A function for error handling
...
Ignored
clone()
The objects of this class are cloneable with this method.
Route$clone(deep = FALSE)
deep
Whether to make a deep clone.
RouteStack for binding multiple routes sequentially
# Initialise an empty route route <- Route$new() # Initialise a route with handlers assigned route <- Route$new( all = list( '/*' = function(request, response, keys, ...) { message('Request received') TRUE } ) ) # Remove it again route$remove_handler('all', '/*')
# Initialise an empty route route <- Route$new() # Initialise a route with handlers assigned route <- Route$new( all = list( '/*' = function(request, response, keys, ...) { message('Request received') TRUE } ) ) # Remove it again route$remove_handler('all', '/*')
These functions helps you to add, remove, and retrieve route handlers. They
all (except for route_get()
) returns the route for easy chaining.
route_add(x, method, path, handler) route_remove(x, method, path) route_get(x, method, path)
route_add(x, method, path, handler) route_remove(x, method, path) route_get(x, method, path)
x |
A Route object |
method |
A request method for the handler. The special method |
path |
A URL path for the handler. See Paths for more on path semantics |
handler |
A handler function. See Handlers for more about the semantics of handlers |
x
, modified. route_get()
returns the requested handler
The path is a URL path consisting of strings, parameters (strings prefixed
with :
), and wildcards (*
), separated by /
. A wildcard will match
anything and is thus not restricted to a single path element (i.e. it will
span multiple /
if possible). When serving a request only a single handler
is selected based on the path match that is most specific. Specificity is
based on number of path parts (ie. number of elements separated by /
), the
more the better; number of wildcards, the fewer the better; and number of
keys, the fewer the better. When printing the route you can see the priority
of all the paths in the route as they are sorted by that
The handler is a function. At the very least it should have a ...
argument
and it must return eiter TRUE
or FALSE
. Returning TRUE
means that the
request is allowed to continue processing and can be passed on to the next
route in the stack. Returning FALSE
stops the processing of the request by
the stack.
While any arguments besides ...
are optional, there are a few that will get
passed in named:
request
will hold the request as a reqres::Request object
response
will hold the request as a reqres::Response object
keys
will be a named list containing the values of the matched path keys
(see example)
Further, if routr is used as a fiery plugin, the handler will receive:
server
is the fiery::Fire
object defining the app
id
is the id of the client sending the request, as provided by fiery
arg_list
is a list of values as calculated by the servers before-request
event handlers
Any and all of the above can be ignored by your handler, but accepting the
server
is often paramount to more powerful features such as delayed
execution or logging.
# Add a handler route <- route() |> route_add("get", "/:what", function(request, response, keys, ...) { message("Requesting", keys$what) TRUE }) route # Retrieve the handler route |> route_get("get", "/:what") # Remove the handler route |> route_remove("get", "/:what")
# Add a handler route <- route() |> route_add("get", "/:what", function(request, response, keys, ...) { message("Requesting", keys$what) TRUE }) route # Retrieve the handler route |> route_get("get", "/:what") # Remove the handler route |> route_remove("get", "/:what")
This function allows you to combine two separate routes into one. This is
different from combining them in a routestack, because a request is only
matched to one handler in each route (thus combining them with
route_merge()
will ensure only one handler is called).
route_merge(x, route, use_root = TRUE)
route_merge(x, route, use_root = TRUE)
x , route
|
Route objects to merge. |
use_root |
Should the root of |
x
with route
merged into it
route() |> route_add("HEAD", "*", function(...) { message("Someone's looking") TRUE }) |> route_merge( sizelimit_route() )
route() |> route_add("HEAD", "*", function(...) { message("Someone's looking") TRUE }) |> route_merge( sizelimit_route() )
This function allows you to combine multiple routes into a stack in order to
dispatch on them until one of them returns FALSE
. This allows you to have a
router that can pass a request through multiple handlers before sending it
along to the client or other middleware
route_stack(x, ...) ## Default S3 method: route_stack(x, ...) ## S3 method for class 'Route' route_stack(x, ...) ## S3 method for class 'AssetRoute' route_stack(x, ...) ## S3 method for class 'RouteStack' route_stack(x, ..., .after = NULL)
route_stack(x, ...) ## Default S3 method: route_stack(x, ...) ## S3 method for class 'Route' route_stack(x, ...) ## S3 method for class 'AssetRoute' route_stack(x, ...) ## S3 method for class 'RouteStack' route_stack(x, ..., .after = NULL)
x |
A Route or RouteStack object |
... |
one or more named Route objects |
.after |
Where in the stack should the new routes be placed. |
A RouteStack object. If x
is a RouteStack then this will be
returned, modified.
# Create an empty route stack route_stack() # Stack a route with another, returning a RouteStack route(all = list("*" = function(...) TRUE)) |> route_stack( limit = sizelimit_route() )
# Create an empty route stack route_stack() # Stack a route with another, returning a RouteStack route(all = list("*" = function(...) TRUE)) |> route_stack( limit = sizelimit_route() )
Combine multiple routes for sequential routing
Combine multiple routes for sequential routing
The RouteStack
class encapsulate multiple Routes and lets a request be
passed through each sequentially. If a route is returning FALSE
upon
dispatch further dispatching is cancelled.
A new 'RouteStack'-object is initialized using the new()
method on the
generator:
Usage
route <- RouteStack$new(..., path_extractor = function(msg, bin) '/')
|
A RouteStack
object is a valid fiery
plugin and can thus be passed in to
the attach()
method of a Fire
object. When used as a fiery plugin it is
important to be concious for what event it is attached to. By default it will
be attached to the request
event and thus be used to handle HTTP request
messaging. An alternative is to attach it to the header
event that is fired
when all headers have been received but before the body is. This allows you
to short-circuit request handling and e.g. reject requests above a certain
size. When the router is attached to the header
event any handler returning
FALSE
will signal that further handling of the request should be stopped
and the response in its current form should be returned without fetching the
request body.
One last possibility is to attach it to the message
event and thus use it
to handle WebSocket messages. This use case is a bit different from that of
request
and header
. As routr
uses Request
objects as a vessel between
routes and WebSocket messages are not HTTP requests, some modification is
needed. The way routr
achieves this is be modifying the HTTP request that
established the WebSocket connection and send this through the routes. Using
the path_extractor
function provided in the RouteStack
constructor it
will extract a path to dispatch on and assign it to the request. Furthermore
it assigns the message to the body of the request and sets the Content-Type
header based on whether the message is binary application/octet-stream
or
not text/plain
. As WebSocket communication is asynchronous the response is
ignored when attached to the message
event. If communication should be send
back, use server$send()
inside the handler(s).
How a RouteStack
is attached is defined by the attach_to
field which must
be either 'request'
, 'header'
, or 'message'
.
When attaching the RouteStack
it is possible to modify how errors are
handled, using the on_error
argument, which will change the error handler
set on the RouteStack
. By default the error handler will be changed to
using the fiery
logging system if the Fire
object supports it.
attach_to
The event this routr should respond to
name
An autogenerated name for the route stack
routes
Gices the name of all routes in the stack
empty
Is the route stack empty
new()
Create a new RouteStack
RouteStack$new(..., path_extractor = function(msg, bin) "/")
...
Routes to add up front. Must be in the form of named arguments
containing Route
objects.
path_extractor
A function that returns a path to dispatch on from
a WebSocket message. Will only be used if attach_to == 'message'
.
Defaults to a function returning '/'
print()
Pretty printing of the object
RouteStack$print(...)
...
Ignored
add_route()
Adds a new route to the stack. route
must be a Route
object, name
must be a string. If after
is given the route will be
inserted after the given index, if not (or NULL
) it will be inserted in
the end of the stack.
RouteStack$add_route(route, name, after = NULL)
route
A Route
object
name
The name of the route
after
The location in the stack to put the route
get_route()
Get the route with a given name
RouteStack$get_route(name)
name
The name of the route to retrieve
has_route()
Test if the routestack contains a route with the given name.
RouteStack$has_route(name)
name
The name of the route to look for
remove_route()
Removes the route with the given name from the stack.
RouteStack$remove_route(name)
name
The name of the route to remove
dispatch()
asses a reqres::Request through the stack of routes in s
equence until one of the routes return FALSE
or every route have been
passed through. ...
will be passed on to the dispatch of each Route
on the stack.
RouteStack$dispatch(request, ...)
request
The request to route
...
Additional arguments to pass on to the handlers
on_attach()
Method for use by fiery
when attached as a plugin. Should
not be called directly.
RouteStack$on_attach(app, on_error = deprecated(), ...)
merge_stack()
Merge two route stacks together adding all routes from the other route to this. The other route stack will be empty after this.
RouteStack$merge_stack(stack)
stack
Another RouteStack object to merge into this one
on_error()
Set the error handling function. This must be a function
that accepts an error
, request
, and reponse
argument. The error
handler will be called if any of the route handlers throws an error and
can be used to modify the 500
response before it is send back. By
default, the error will be signaled using message
RouteStack$on_error(fun)
fun
The function to use for error handling
clone()
The objects of this class are cloneable with this method.
RouteStack$clone(deep = FALSE)
deep
Whether to make a deep clone.
Route for defining single routes
# Create a new stack routes <- RouteStack$new() # Populate it wih routes first <- Route$new() first$add_handler('all', '*', function(request, response, keys, ...) { message('This will always get called first') TRUE }) second <- Route$new() second$add_handler('get', '/demo/', function(request, response, keys, ...) { message('This will get called next if the request asks for /demo/') TRUE }) routes$add_route(first, 'first') routes$add_route(second, 'second') # Send a request through rook <- fiery::fake_request('http://example.com/demo/', method = 'get') req <- reqres::Request$new(rook) routes$dispatch(req)
# Create a new stack routes <- RouteStack$new() # Populate it wih routes first <- Route$new() first$add_handler('all', '*', function(request, response, keys, ...) { message('This will always get called first') TRUE }) second <- Route$new() second$add_handler('get', '/demo/', function(request, response, keys, ...) { message('This will get called next if the request asks for /demo/') TRUE }) routes$add_route(first, 'first') routes$add_route(second, 'second') # Send a request through rook <- fiery::fake_request('http://example.com/demo/', method = 'get') req <- reqres::Request$new(rook) routes$dispatch(req)
This route is meant for being called prior to retrieving of the request body.
It inspects the Content-Length
header and determines if the request should
be allowed to proceed. The limit can be made variable by supplying a function
to the limit
argument returning a numeric. If the Content-Length
header
is missing and the limit is not Inf
the response will be set to
411 - Length Required
, If the header exists but exceeds the limit the
response will be set to 413 - Request Entity Too Large
. Otherwise the route
will return TRUE
and leave the response unchanged.
sizelimit_route(limit = 5 * 1024^2, method = "all", path = "*")
sizelimit_route(limit = 5 * 1024^2, method = "all", path = "*")
limit |
Either a numeric or a function returning a numeric when called with the request |
method |
The method this route should respond to. Defaults to |
path |
The URL path this route should respond to. Defaults to |
A Route object
Other Route constructors:
asset_route()
,
openapi_route()
,
ressource_route()
,
shared_secret_route()
limit_route <- sizelimit_route() # Default 5Mb limit rook <- fiery::fake_request('http://www.example.com', 'post', headers = list(Content_Length = 30*1024^2)) req <- reqres::Request$new(rook) limit_route$dispatch(req) req$respond()
limit_route <- sizelimit_route() # Default 5Mb limit rook <- fiery::fake_request('http://www.example.com', 'post', headers = list(Content_Length = 30*1024^2)) req <- reqres::Request$new(rook) limit_route$dispatch(req) req$respond()