bend-kit-http
Search uses release 0.38.4.0 · 1,026 definitions
Definitions (1,026)
- def stream.init.pool
- def stream.start
- def stream.only
- def pool.stream.only
- def stream.unpooledA one-off pool ends with the open; it closes any idle socket a redirect gave back.
- def pool.open.raw.howopen.raw.how on a pool: each hop takes an idle socket to its origin when the pool has one.
- def open.raw.howA raw stream with every choice of fetch: mode for redirects, cert and ca for the first origin and each same-origin hop ("" trusts the default store), and a jar that gives cookies to every hop and takes them from every response.
- def open.raw.withOpen a raw stream.
- def open.raw
- def pool.open.how.enc
- def pool.open.howopen.how on a pool.
- def pool.open.with
- def pool.openopen on a pool: an idle socket to the origin when the pool has one, else a new one.
- def open.how.enc
- def open.howopen.raw.how, then each body piece decoded by Content-Encoding (see codings).
- def open.withFollow redirects, then decode each body piece by Content-Encoding.
- def open
- type UpUpload: the request body sent in chunks (RFC 9112 §7.1).
- def hex.digit
- def hex.go
- def hex.trim
- def hex
- def up.sent
- def up.conn
- def up.head
- def up.route
- def up.origin.choice
- def up.origin
- def up.url
- def upload.howcert and ca as in open.how.
- def upload.with
- def upload
- def up.wrote
- def up.putOne write per chunk, so the size line and the data do not wait on each other (Nagle).
- def up.chunk
- def upload.writeOne chunk.
- def upload.finishEnds the body and returns the response as a stream.
- type ServerConfig
- type LimitsShared framing settings; all live readers reserve admission before allocation.
- def limits.representableBytes.words rounds with len+3 in U32.
- def limits.validate.ok
- def limits.validate
- def limits
- def limits.config
- type PhaseOne absolute deadline, never replenished by progress.
- def phase.new
- def phase.remaining
- def bounded.sent
- def bounded.send.ready
- def bounded.send
- def reply.bytes
- def reply.fail.bytes
- def reply.drain.of
- def reply.drainponytail: cap drain at 32 MiB and 2.55 s; use socket half-close if larger peers need guaranteed delivery.
- def reply.sent.close
- def reply.sent.observe
- def reply_fail
- type SvThe head is parsed once, when it is whole.
- type InputOperation
- type TurnMore: read on, first answering 100 Continue when cont is set.
- def serve.max
- def sv.none
- def sv.body
- def sv.len.cut
- def sv.len.have
- def sv.len
- def sv.chunk.of
- def sv.chunk.parts.cons
- def sv.chunk.parts
- def sv.chunk.cap
- def sv.chunk.counted
- def sv.chunk.decoded
- def sv.chunk
- def sv.contRFC 9110 §10.1.1: answer 100 Continue only when the body is still to come.
- def sv.cl.k
- def sv.cl
- def sv.frame
- def sv.expects
- def sv.got.head
- def sv.parsed
- def sv.split
- def sv.hit.none
- def sv.hit.some
- def sv.hitRFC 6585 §5: refuse a head over the configured byte limit.
- def sv.seek.of
- def sv.seek
- def sv.head.atOnly the new bytes, and the 3 before them, can finish the blank line.
- def sv.head
- def sv.closed.pick
- def sv.closed.head
- def sv.stepA close mid-request is a request cut short (RFC 9112 §8).
- def sv.frame.req
- def sv.frame.go
- def serve.frameThe body and the bytes after it, once the pieces make a whole request; None otherwise.
- def talk.piece
- def talk.next
- def talk.after.pick
- def talk.after.rest
- def talk.after.keep
- def talk.after