🥮 mooncakes.io

    moonbitstack/moonrpc/balance does not have a README file

    Attempts

    source
    pub struct Attempts {
      // private fields
    }

    One call's retry state across its attempts.

    Attempts::made

    source
    fn Attempts::made(self : Attempts) -> Int

    Attempts sent under the policy so far, the first being 1. Transparent retries are not counted.

    Attempts::new

    source
    fn Attempts::new(retry? : Retry, throttle? : Throttle, limit? : Int) -> Attempts

    The state before the first attempt. Without retry the call is still retried transparently, as A6 asks of every call.

    Attempts::next

    source
    fn Attempts::next(self : Attempts, status : Int, trailers : ArrayView[
    Header    ], committed? : Bool, unprocessed? : Bool, roll? : Double) -> 
    Span    ?

    What to do after an attempt ended with status and trailers: None hands this result to the caller, Some(wait) sends another attempt after wait.

    committed is a call whose response headers arrived, which A6 never retries; unprocessed is one the server refused or a GOAWAY says it never handled, which is retried once at once without counting. roll draws the jitter, from [0, 1). The order of the checks is grpc-go's.

    Backoff

    source
    pub(all) struct Backoff {
      initial : 
    Span
      max : 
    Span
      factor : Double
      jitter : Double
    }

    A backoff schedule: the first wait, the factor each failure multiplies it by, the cap, and how much of the wait is jitter.

    Backoff::delay

    source
    fn Backoff::delay(self : Backoff, attempt : Int, roll? : Double) -> 
    Span

    How long to wait before the attempt-th dial (the first being 1): the initial wait times the factor once per earlier failure, capped, then spread by the jitter — roll draws from [0, 1) and 0.5 is no spread at all.

    Backoff::new

    source
    fn Backoff::new(initial? : 
    Span    , max? : 
    Span    , factor? : Double, jitter? : Double) -> Backoff

    A schedule by its four numbers.

    ConnectionPool

    source
    pub struct ConnectionPool {
      order : Array[String]
      subconns : Map[String, SubConn]
      policy : LbPolicy
      cursor : Int
    }

    A pool of sub-connections, one per resolved address (in resolver order), that picks a READY one per an LbPolicy.

    ConnectionPool::add

    source
    fn ConnectionPool::add(self : ConnectionPool, address : String) -> Bool

    Add a sub-connection for address — a name that resolved to it after the pool was built — and return whether it was new. Re-resolution feeds the pool this way, so a backend that appeared since the channel started can be dialled without rebuilding the pool and losing what the others' states are.

    ConnectionPool::new

    source
    fn ConnectionPool::new(addresses : Array[String], policy? : LbPolicy) -> ConnectionPool

    A pool over addresses (each a host:port), each sub-connection starting IDLE, choosing among the READY ones with policy (default PickFirst).

    ConnectionPool::pick

    source
    fn ConnectionPool::pick(self : ConnectionPool) -> String?

    Pick a READY sub-connection's address for the next call, applying the LB policy over just the ready ones (← gRPC picker). None when no sub-connection is ready.

    ConnectionPool::ready_addresses

    source
    fn ConnectionPool::ready_addresses(self : ConnectionPool) -> Array[String]

    The addresses of every READY sub-connection, in resolver order.

    ConnectionPool::subconn

    source
    fn ConnectionPool::subconn(self : ConnectionPool, address : String) -> SubConn?

    The sub-connection for address, if the pool has one — the handle the Channel drives.

    ConnectivityState

    source
    pub(all) enum ConnectivityState {
      Idle
      Connecting
      Ready
      TransientFailure
      Shutdown
    } derive(Eq, 
    Debug    )

    A sub-connection's connectivity state (← gRPC connectivity.State).

    ConnectivityState::equal

    source

    ConnectivityState::not_equal

    source
    fn ConnectivityState::not_equal(x : ConnectivityState, y : ConnectivityState) -> Bool

    ConnectivityState::to_repr

    source

    DnsRecord

    source
    pub(all) struct DnsRecord {
      name : String
      rtype : Int
      ttl : Int
      address : String
    } derive(Eq, 
    Debug    )

    One answer resource record, carrying the textual address for A/AAAA records (empty for other types).

    DnsRecord::equal

    source
    fn DnsRecord::equal(DnsRecord, DnsRecord) -> Bool

    DnsRecord::not_equal

    source
    fn DnsRecord::not_equal(x : DnsRecord, y : DnsRecord) -> Bool

    DnsRecord::to_repr

    source

    DnsResponse

    source
    pub(all) struct DnsResponse {
      id : Int
      rcode : Int
      answers : Array[DnsRecord]
    } derive(Eq, 
    Debug    )

    A decoded DNS response: the transaction id echoed back, the response code (0 = NOERROR), and the answer records.

    DnsResponse::addresses

    source
    fn DnsResponse::addresses(self : DnsResponse) -> Array[String]

    Every resolved A/AAAA address in the response, in record order.

    DnsResponse::equal

    source
    fn DnsResponse::equal(DnsResponse, DnsResponse) -> Bool

    DnsResponse::not_equal

    source
    fn DnsResponse::not_equal(x : DnsResponse, y : DnsResponse) -> Bool

    DnsResponse::to_repr

    source

    Hedging

    source

    A method's hedging policy (A6 hedgingPolicy): attempts is maxAttempts, delay is hedgingDelay, codes is nonFatalStatusCodes.

    Hedging::commits

    source
    fn Hedging::commits(self : Hedging, status : Int) -> Bool

    Whether an attempt ending with status settles the call: OK does, and so does any status outside codes. A non-fatal one sends the next attempt at once instead.

    Hedging::equal

    source
    fn Hedging::equal(Hedging, Hedging) -> Bool

    Hedging::more

    source
    fn Hedging::more(self : Hedging, started : Int, limit? : Int) -> Bool

    Whether another attempt may start when started have, under the policy and the client's limit.

    Hedging::new

    source

    A policy by A6's field names.

    Hedging::not_equal

    source
    fn Hedging::not_equal(x : Hedging, y : Hedging) -> Bool

    Hedging::to_repr

    source

    LbPolicy

    source
    pub(all) enum LbPolicy {
      PickFirst
      RoundRobin
    } derive(Eq, 
    Debug    )

    A client-side load-balancing policy (← gRPC loadBalancingConfig).

    LbPolicy::equal

    source
    fn LbPolicy::equal(LbPolicy, LbPolicy) -> Bool

    LbPolicy::not_equal

    source
    fn LbPolicy::not_equal(x : LbPolicy, y : LbPolicy) -> Bool

    LbPolicy::to_repr

    source

    LoadBalancer

    source
    pub struct LoadBalancer {
      addresses : Array[String]
      policy : LbPolicy
      cursor : Int
    }

    A load balancer over a resolver's addresses, applying an LbPolicy to choose the next one.

    LoadBalancer::new

    source
    fn LoadBalancer::new(addresses : Array[String], policy? : LbPolicy) -> LoadBalancer

    A balancer over addresses (each a host:port) using policy (default PickFirst).

    LoadBalancer::pick

    source
    fn LoadBalancer::pick(self : LoadBalancer) -> String?

    The address the next call should use, or None when the resolver produced none. PickFirst always returns the first address; RoundRobin returns each in turn, wrapping around.

    LoadBalancer::size

    source
    fn LoadBalancer::size(self : LoadBalancer) -> Int

    The number of addresses the balancer is choosing among.

    MethodConfig

    source
    pub(all) struct MethodConfig {
      service : String?
      name : String?
      retry : Retry?
      hedging : Hedging?
      timeout : 
    Span    ?
      wait_for_ready : Bool?
    }

    One method's configuration. service and name are the two halves of a method name; either may be left out to match every method of that service or of every service.

    MethodConfig::timeout_millis

    source
    fn MethodConfig::timeout_millis(self : MethodConfig) -> Int?

    The timeout in whole milliseconds, for the attempting loop.

    Pushback

    source
    pub(all) enum Pushback {
      Absent
      After(
    Span    )
      Stop
    } derive(Eq, 
    Debug    )

    What the server said about trying again, in grpc-retry-pushback-ms.

    Pushback::equal

    source
    fn Pushback::equal(Pushback, Pushback) -> Bool

    Pushback::not_equal

    source
    fn Pushback::not_equal(x : Pushback, y : Pushback) -> Bool

    Pushback::read

    source

    The pushback a reply's trailers carry.

    Pushback::to_repr

    source

    Reconnect

    source
    pub(all) struct Reconnect {
      backoff : Backoff
      failures : Int
      next_at : Int64
    }

    One backend's reconnect clock: how many dials have failed in a row, and when the next one may happen.

    Reconnect::due

    source
    fn Reconnect::due(self : Reconnect, now : Int64) -> Bool

    Whether a dial may be made now.

    Reconnect::failed

    source
    fn Reconnect::failed(self : Reconnect, now : Int64, roll? : Double) -> Unit

    Record a failed dial at now and schedule the next one. roll draws the jitter.

    Reconnect::new

    source
    fn Reconnect::new(backoff? : Backoff, now? : Int64) -> Reconnect

    A reconnect clock that dials at once.

    Reconnect::succeeded

    source
    fn Reconnect::succeeded(self : Reconnect) -> Unit

    Record a dial that worked: the next failure starts the schedule over.

    Reconnect::wait_millis

    source
    fn Reconnect::wait_millis(self : Reconnect, now : Int64) -> Int64

    Whether a dial may be made now, or how long is left before it may (0 when it may).

    Retry

    source

    A method's retry policy (A6 retryPolicy). backoff carries maxAttempts as attempts, initialBackoff as base, maxBackoff as cap and backoffMultiplier as factor; codes is retryableStatusCodes.

    Retry::equal

    source
    fn Retry::equal(Retry, Retry) -> Bool

    Retry::new

    source
    fn Retry::new(attempts? : Int, base? : 
    Span    , cap? : 
    Span    , factor? : Double, codes? : Array[
    Status    ]) -> Retry

    A policy by A6's field names, the jitter the preset's.

    Retry::not_equal

    source
    fn Retry::not_equal(x : Retry, y : Retry) -> Bool

    Retry::to_repr

    source

    ServiceConfig

    source
    pub(all) struct ServiceConfig {
      methods : Array[MethodConfig]
      load_balancing : LbPolicy?
      throttling : Throttling?
    }

    A parsed service config: the per-method entries in the order they were written (first match wins), the channel-wide load-balancing policy and retry throttling.

    ServiceConfig::empty

    source

    An empty config: no method overrides, no policy.

    ServiceConfig::for_method

    source
    fn ServiceConfig::for_method(self : ServiceConfig, path : String) -> MethodConfig?

    The entry that governs path (/pkg.Service/Method), the first whose service and method both match (an omitted half matches anything).

    ServiceConfig::parse

    source

    Parse a service config document, as grpc-go's encoding/json does.

    SubConn

    source
    pub struct SubConn {
      address : String
      state : ConnectivityState
    }

    One address the Channel dials, tracking its connectivity state.

    SubConn::connect

    source
    fn SubConn::connect(self : SubConn) -> Unit

    Begin connecting (IDLE or TRANSIENT_FAILURE → CONNECTING). A no-op once SHUTDOWN or already connecting/ready.

    SubConn::is_ready

    source
    fn SubConn::is_ready(self : SubConn) -> Bool

    Whether this sub-connection can carry RPCs right now.

    SubConn::new

    source
    fn SubConn::new(address : String) -> SubConn

    A fresh sub-connection to address, starting IDLE.

    SubConn::on_connected

    source
    fn SubConn::on_connected(self : SubConn) -> Unit

    The connection attempt succeeded (CONNECTING → READY).

    SubConn::on_failure

    source
    fn SubConn::on_failure(self : SubConn) -> Unit

    A connection attempt or an established connection failed (→ TRANSIENT_FAILURE), unless shut down.

    SubConn::on_idle

    source
    fn SubConn::on_idle(self : SubConn) -> Unit

    A READY connection went idle (READY → IDLE).

    SubConn::shutdown

    source
    fn SubConn::shutdown(self : SubConn) -> Unit

    Shut the sub-connection down permanently (→ SHUTDOWN, a terminal state).

    Throttle

    source
    pub struct Throttle {
      // private fields
    }

    The token count one server name shares across every call to it. A failure takes a token, a success gives back ratio, and at or below half the maximum no call is retried or hedged. Kept in thousandths of a token as gRPC core keeps it, so a ratio is read to three decimal places and nothing drifts.

    Throttle::allows

    source
    fn Throttle::allows(self : Throttle) -> Bool

    Whether a retry or a further hedge may go out.

    Throttle::fail

    source
    fn Throttle::fail(self : Throttle) -> Unit

    A call that failed with a retryable status, or that the server pushed back.

    Throttle::new

    source
    fn Throttle::new(throttling : Throttling) -> Throttle

    A throttle starting full.

    Throttle::pass

    source
    fn Throttle::pass(self : Throttle) -> Unit

    A call that succeeded.

    Throttle::tokens

    source
    fn Throttle::tokens(self : Throttle) -> Double

    The tokens left.

    Throttling

    source
    pub(all) struct Throttling {
      tokens : Int
      ratio : Double
    } derive(Eq, 
    Debug    )

    Retry throttling (A6 retryThrottling): tokens is maxTokens, ratio is tokenRatio. There is no preset, because a channel without one does not throttle.

    Throttling::equal

    source
    fn Throttling::equal(Throttling, Throttling) -> Bool

    Throttling::new

    source
    fn Throttling::new(tokens~ : Int, ratio~ : Double) -> Throttling

    Throttling by name.

    Throttling::not_equal

    source
    fn Throttling::not_equal(x : Throttling, y : Throttling) -> Bool

    Throttling::to_repr

    source

    backoff

    source
    let backoff : Backoff

    The schedule the gRPC document specifies: one second, times 1.6 each time, capped at two minutes, with the wait drawn from ±20% of it.

    dns_decode_response

    source
    fn dns_decode_response(msg : Bytes) -> DnsResponse

    Decode a DNS response: echoed id, response code, and every answer record (A/AAAA records carry their textual address). Questions are skipped; authority and additional sections are ignored.

    dns_encode_query

    source
    fn dns_encode_query(id : Int, name : String, qtype : Int) -> Bytes

    Encode a standard recursion-desired query for name of type qtype (dns_type_a or dns_type_aaaa) in class IN, with transaction id id.

    dns_type_a

    source
    let dns_type_a : Int

    The DNS record type for an IPv4 address.

    dns_type_aaaa

    source
    let dns_type_aaaa : Int

    The DNS record type for an IPv6 address.

    hedging

    source
    let hedging : Hedging

    A6's example policy: four attempts half a second apart, UNAVAILABLE, INTERNAL and ABORTED letting the others carry on.

    limit

    source
    let limit : Int

    The most attempts a client makes whatever a policy asks for. A6 puts it on the client because a service config can arrive over DNS.

    min_connect_timeout

    source
    let min_connect_timeout : 
    Span

    The shortest time a connection attempt may be given before it counts as failed, however short the backoff has become. The document's minConnectTimeout.

    retry

    source
    let retry : Retry

    A6's example policy: four attempts, a hundred milliseconds doubling to a second with a fifth either way, retrying UNAVAILABLE.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io