bend-kube-runtime

Search uses release 0.2.0.0 · 1,124 definitions

Releases (2)

0.2.0.0 indexed
0.1.1.0 unindexed

Definitions (1,124)

LAWS.bend

law watch_gone_relistsA watch that answers 410 Gone relists from scratch, at once.
law watch_request_gone_relistsSo does a watch request the server refuses with 410.
law list_gone_relistsAn expired continue token restarts the list from its first page.
law watch_error_backs_offA failed watch request (not 410) retries from the same version after a backoff, counting the failure.
law watch_end_resumesA watch that ends (the server's timeout) resumes from the same version, with no backoff and no events.
law bookmark_advancesA bookmark moves the resume version and emits nothing.
law last_page_watchesThe last page of a list (no continue token) emits its objects, closes the relist with InitDone, and starts watching from the list's version.
law first_page_initsThe first page of a relist opens it with Init.
law watch_backoff_cappedThe watcher's backoff never exceeds 30s, however many failures.
law init_clears_bufferA relist starts from an empty buffer, whatever the store held.
law init_done_swapsInitDone swaps the relisted buffer in whole: objects absent from the relist leave the store, and the store is ready.
law add_running_marks_dirtyAdding a key that is running does not queue it a second time: it is marked dirty, to run again when the current run ends.
law add_waiting_dedupsAdding a key that already waits changes nothing but its timer.
law pop_respects_limitNo key starts while every worker slot is taken.
law retry_backoff_cappedA failing key backs off for at most 1000s.
law done_idle_noopFinishing a key that is not running changes nothing and arms no timer.
law forget_running_keepsForgetting never disturbs a key that is running.
law fin_live_appliesA live object that carries our finalizer is applied.
law fin_gone_doneA deleted object that no longer carries it needs nothing more.
law fin_cleanup_testsA deleted object that still carries it is cleaned up, and the finalizer is removed only through a patch that tests it is still ours, at its index.
law eof_before_response_is_lostA connection that ends before any byte of a response is lost, not broken: only then may a request on a reused connection be retried.
law eof_mid_response_is_brokenBytes of a response make an early end a broken response, never retried.
law proxy_skips_localhostlocalhost and loopback addresses never go through a proxy, whatever HTTPS_PROXY and NO_PROXY say.
law proxy_skips_loopback
law no_proxy_star_bypassesNO_PROXY=* sends every host around the proxy.
law no_proxy_url_is_directWithout HTTPS_PROXY, connections are direct.
law unsupported_proxy_failsA proxy bend-kube cannot speak fails the connection: it never falls back to connecting directly.
law no_proxy_dot_is_subdomains_only".corp" bypasses the subdomains of corp, not corp itself.
law no_proxy_respects_labels"corp" bypasses corp and its subdomains, never a name that merely ends in the same letters.
law no_proxy_port_narrowsAn entry with a port bypasses only that port.
law tunnel_needs_200Only a 200 opens the tunnel; any other answer fails it, quoted.
law tunnel_rejects_early_bytesBytes after the proxy's answer, before we spoke TLS, fail the tunnel: nothing the proxy says may become part of the TLS stream.
law tunnel_end_before_answerA proxy that hangs up before its answer is whole fails the tunnel.

PROOF.bend

def Proof.pop_fullWith no free slot, pop.go answers None whatever the front holds.
def Proof.forget_busyA busy key leaves any queue as it is.

src/base64.bend

type B64
def B64.val.go
def B64.valThe 6-bit value of a char: 64 for skipped chars, 65 for bad ones.
def B64.next.go
def B64.nextThe state after a char's value v.
def B64.emit.go
def B64.emitThe byte a char completes, pushed onto out (reversed).
def B64.go
def B64.decode.fin
def B64.decodeThe bytes a base64 text spells; None if a char is outside the alphabet.
def B64.chr.go
def B64.chr
def B64.encodeEncodes bytes, three at a time, with '=' padding.

src/client.bend

def Res
type KErr
type Reply
def KErr.show
def KErr.retryableWhether a failed call is worth retrying: the network, 429 (API priority and fairness), and 5xx.
def KErr.code
def Fs.close_with
def Fs.read.got
def Fs.read.sized.go
def Fs.read.sized
def Fs.read.opened
def Fs.readA whole file as UTF-8 text.
def Src.load.fin
def Strs.own
def Exec.token.got
def Exec.token.json
def Exec.tokenA credential plugin's answer (client-go's exec ExecCredential): its status.token.
def Src.load
type Creds
def Creds.load.k
def Creds.load.c
def Creds.load.b
def Creds.load.a
def Creds.loadReads every secret a Config names; token files are read afresh each time.
def Conn.auth.go
def Conn.auth
def Conn.user_agent
def Conn.keep
def Conn.connection
def Conn.renderThe request's text, with the path under the server's base, our headers, and Connection: keep-alive (pooled) or close, unless the request names its own (an Upgrade).
def Conn.host_header.go
def Conn.host_header
def Conn.open.sentOpens a connection and sends req: the socket, ready to read the answer.
def Conn.open.go
def Conn.open.creds
def Conn.open
type ReadEvWhat the read loop just saw: bytes (or a failure) from a recv, or the decoder's state after feeding them.
def ReadEv.got
def Http.has_err
def Http.fail
def Http.lostA failed recv: lost when no byte of a response came, else broken.
def Conn.readReads until the response is whole, the stream ends, or fuel runs out; ms bounds each recv.
def Reply.of
def Call.read.fin
def Call.read
def Conn.send_on.credsSends req on an open (pooled) connection.
def Conn.send_on
def Http.got_any
def Http.closes
def Req.idempotent.go
def Req.idempotent
def Pool.put.done