Module roadrunner

proto_opts() = #{dispatch := dispatch(), middlewares := roadrunner_middleware:middleware_list(), max_content_length := non_neg_integer(), ws_max_frame_size := non_neg_integer(), ws_max_message_size := non_neg_integer(), request_timeout := non_neg_integer(), keep_alive_timeout := non_neg_integer(), max_keep_alive_requests := pos_integer(), max_clients := pos_integer(), client_counter := counters:counters_ref(), requests_counter := atomics:atomics_ref(), rejected_counter := atomics:atomics_ref(), max_concurrent_requests := infinity | pos_integer(), inflight_counter := counters:counters_ref(), throttled_counter := atomics:atomics_ref(), min_bytes_per_second := non_neg_integer(), body_buffering := auto | manual, listener_name => atom(), graceful_drain => boolean(), protocols => [http1 | http2 | http3, ...], http2_conn_window => 1..2147483647, http2_stream_window => 1..2147483647, http2_window_refill_threshold => 1..2147483647, http2_max_concurrent_streams => 1..2147483647, http2_max_header_block => 1..2147483647, http3_listeners => 1..1024, http3_max_header_block => 1..2147483647, http1_max_request_line => 1..2147483647, http1_max_header_line => 1..2147483647, http1_max_header_block => 1..2147483647, http1_max_header_count => 1..2147483647, hibernate_after => pos_integer(), rate_check_interval => pos_integer(), handler_spawn_opts => [proc_lib:start_spawn_option()], handler_start_timeout => timeout()}

Function Index

Function Details

body_framing/1

body_framing(Req::roadrunner_req:request()) -> none | chunked | {content_length, non_neg_integer()} | {error, bad_content_length | bad_transfer_encoding}

consume_body_reader/2

consume_body_reader(BS::roadrunner_req:body_reader(), Mode::all | next_chunk | {length, non_neg_integer()}) -> {ok, iodata(), roadrunner_req:body_reader()} | {more, iodata(), roadrunner_req:body_reader()} | {error, term()}

drain_body/1

drain_body(X1::roadrunner_req:request()) -> {ok, binary()} | {error, term()}

drain_oversized_body/3

drain_oversized_body(Buffered::binary(), Socket::roadrunner_transport:socket(), MaxCL::non_neg_integer()) -> ok

generate_request_id/1

generate_request_id(Empty::binary()) -> {binary(), binary()}

head_response/2

head_response(Response::roadrunner_handler:response(), Method::binary()) -> roadrunner_handler:response()

join_drain_group/2

join_drain_group(Name::atom(), X2::boolean()) -> ok

join_drain_group_for/2

join_drain_group_for(Pid::pid(), Name::atom()) -> ok

keep_alive_decision/2

keep_alive_decision(Req::roadrunner_req:request(), RespHeaders::roadrunner_http:headers()) -> keep_alive | close

make_body_reader/5

make_body_reader(Framing::none | chunked | {content_length, non_neg_integer()}, Buffered::binary(), Recv::fun(() -> {ok, binary()} | {error, term()}), Max::non_neg_integer(), TrailerLimits::{pos_integer(), pos_integer(), pos_integer()}) -> roadrunner_req:body_reader()

make_recv/3

make_recv(Socket::roadrunner_transport:socket(), Deadline::integer(), MinRate::non_neg_integer()) -> fun(() -> {ok, binary()} | {error, request_timeout | slow_client | term()})

maybe_send_continue/3

maybe_send_continue(Socket::roadrunner_transport:socket(), Req::roadrunner_req:request(), Buffered::binary()) -> ok

parse_error_status/1

parse_error_status(X1::atom()) -> roadrunner_http:status()

parse_loop/2

parse_loop(Buf::binary(), RecvFun::fun(() -> {ok, binary()} | {error, term()})) -> {ok, roadrunner_req:request(), binary()} | {error, term()}

peer/1

peer(Socket::roadrunner_transport:socket()) -> {inet:ip_address(), inet:port_number()} | undefined

rate_ok/3

rate_ok(ElapsedMs::integer(), Total::non_neg_integer(), MinRate::non_neg_integer()) -> boolean()

read_body/5

read_body(Req::roadrunner_req:request(), Buffered::binary(), RecvFun::fun(() -> {ok, binary()} | {error, term()}), MaxCL::non_neg_integer(), TrailerLimits::{pos_integer(), pos_integer(), pos_integer()}) -> {ok, Body::iodata(), Leftover::binary()} | {error, content_length_too_large | bad_content_length | bad_transfer_encoding | term()}

refine_conn_label/2

refine_conn_label(ProtoOpts::proto_opts(), Peer::{inet:ip_address(), inet:port_number()} | undefined) -> ok

release_request_slot/1

release_request_slot(X1::proto_opts()) -> ok

release_request_slots/2

release_request_slots(ProtoOpts::proto_opts(), N::non_neg_integer()) -> ok

release_slot/1

release_slot(X1::proto_opts()) -> ok

resolve_handler/2

resolve_handler(X1::dispatch(), Req::roadrunner_req:request()) -> {ok, module(), roadrunner_router:bindings(), roadrunner_middleware:next(), term()} | not_found

response_kind/1

response_kind(X1::roadrunner_handler:response()) -> buffered | stream | loop | sendfile | websocket

response_status/1

response_status(X1::roadrunner_handler:response()) -> roadrunner_http:status()

scheme/1

scheme(X1::roadrunner_transport:socket()) -> http | https

send_bad_request/1

send_bad_request(Socket::roadrunner_transport:socket()) -> ok | {error, term()}

send_internal_error/1

send_internal_error(Socket::roadrunner_transport:socket()) -> ok | {error, term()}

send_not_found/1

send_not_found(Socket::roadrunner_transport:socket()) -> ok | {error, term()}

send_payload_too_large/1

send_payload_too_large(Socket::roadrunner_transport:socket()) -> ok | {error, term()}

send_request_timeout/1

send_request_timeout(Socket::roadrunner_transport:socket()) -> ok | {error, term()}

send_status/2

send_status(Socket::roadrunner_transport:socket(), Status::roadrunner_http:status()) -> ok | {error, term()}

set_request_logger_metadata/1

set_request_logger_metadata(X1::roadrunner_req:request()) -> ok

start/2

start(Socket::roadrunner_transport:socket(), ProtoOpts::proto_opts()) -> {ok, pid()}

try_acquire_request_slot/1

try_acquire_request_slot(X1::proto_opts()) -> boolean()

try_acquire_slot/1

try_acquire_slot(X1::proto_opts()) -> boolean()

Module roadrunner_conn