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)

src/utf8.bend

def Utf8.fresh.stThe fresh-byte case: the state and the chars a lead byte makes.
def Utf8.fresh.out
def Utf8.fresh.mid
def Utf8.next.cont.if
def Utf8.next.cont
def Utf8.next.goThe state after byte b.
def Utf8.next
def Utf8.emit.cont
def Utf8.emit.goThe chars byte b completes, pushed onto acc (reversed).
def Utf8.emit
def Utf8.goDecodes bytes onto the front of acc (reversed), carrying the state.
def Utf8.decode.fin
def Utf8.decodeDecodes a cut of bytes; returns the carried state and the text.
def Utf8.decode_all.tail
def Utf8.decode_all.fin
def Utf8.decode_allDecodes a whole buffer.
def Utf8.put.go
def Utf8.put
def Utf8.encode
def Utf8.size.of
def Utf8.sizeThe UTF-8 length of a string, in bytes.

src/watcher.bend

type PhaseWhat to do next: list (from a continue token, "" for the first page) or watch from a version.
type WStatefails counts failures since the last success; first says the next page starts a fresh list.
type Input
type OutWhat the store and controller see (kube-runtime's watcher::Event).
type StepA step's result: the next state, its outputs in order, and whether the driver must back off before the next action.
def WState.init
def Backoff.delay.go
def Backoff.delayThe delay before the next try after fails failures: 800ms doubling, at most 30s.
def Watcher.page_outs
def Watcher.init_out
def Watcher.done_out
def Watcher.page_phase
def Watcher.page.go
def Watcher.pageA page of the list: the first page opens a relist (Init), the last one (no continue token) closes it (InitDone) and starts the watch.
def Watcher.is_gone
def Watcher.relist
def Watcher.retry
def Watcher.list_errA failed list: an expired continue token relists; else the same page is retried after a backoff.
def Watcher.watch_err
def Watcher.eventOne watch event while watching from rv.
def Watcher.stepThe state machine.
def Watcher.merge.go
def Watcher.mergeFeeds a run of inputs (the events of one recv), joining the outputs.
def Watcher.steps

src/ws.bend

type Frame
type WStWhere the decoder is.
type Stepped
type Fed
def Ws.textOpcodes.
def Ws.binary
def Ws.close
def Ws.ping
def Ws.pong
def Ws.maxThe largest payload the decoder accepts.
def Ws.byteThe nth byte of x, counting from the low end.
def Ws.len.go
def Ws.lenThe header from the second byte on: the mask bit (always set, as a client must) and the length, in 7, 16 or 64 bits.
def Ws.maskXORs bytes with the key a, b, c, d, rotating.
def Ws.frameOne final frame of op carrying data, masked with key.
def Ws.unmask
def Ws.rotate
def Ws.payload
def Ws.begin.go
def Ws.beginThe header is whole: the key follows if masked, then the payload.
def Ws.len7
def Ws.ext
def Ws.key
def Ws.pay
def Ws.stepOne byte into the decoder.
def Ws.add
def Ws.feed.go
def Ws.feedFeeds bytes to the decoder: its next state and the frames they finished.
def Ws.error

src/yaml.bend

type Line
type YFrameAn open container: a mapping (members reversed, and the key whose value is still to come) or a sequence (items reversed, and, after a bare "- ", the anchor of the item whose block is still to come).
type Flowmode: 0 between tokens, 1 in "..", 2 in '..', 3 in a plain scalar; buf: the plain scalar so far (reversed); out: JSON text (reversed).
type BlkA block scalar being read: its key line's indent and text before the indicator, literal (|) or folded (>), chomping (0 clip, 1 strip -, 2 keep +), the content's indent (0 until its first line), and its lines so far (reversed, the content indent removed).
type BH
type LSThe line fold: lines out (reversed), and the block scalar, if inside one.
type AVA value with its anchor (&name) split off.
type YR
def Yaml.indent
def Yaml.quote.go
def Yaml.quoteEntering or leaving a quote of kind k (1 single, 2 double).
def Yaml.nqThe quote state after char c.
def Yaml.cut_atWhether a comment starts at the head of s: a '#' after a space, outside quotes.
def Yaml.uncommentDrops a comment, to the end of the line.
def Yaml.keep
def Yaml.lines.put.go
def Yaml.lines.put
def Yaml.head.goA block scalar's header ("key: |", "- >-", ...): the text before the indicator, its style and chomping.
def Yaml.head
def Yaml.clean
def Yaml.blanksTrailing blank lines (of a reversed list): how many, and the rest.
def Yaml.unblank
def Yaml.fold.sep
def Yaml.foldFolded lines: a line break between two text lines becomes a space; blank lines stay line breaks.
def Yaml.block.body
def Yaml.block.tail.go