moonbitstack/moonrpc/balance

README
U
Attempts
U
BidiHandler
U
CallReply
U
ClientCall
U
ConnectionPool
U
ConnectivityState
U
DnsRecord
U
DnsResponse
U
FieldDescriptor
U
FieldLabel
U
FieldType
U
FileDescriptor
U
H2Client
U
H2Server
U
Handler
U
HealthService
U
Hedging
U
Keepalive
U
LbPolicy
U
LoadBalancer
U
Message
U
MessageDescriptor
U
Method
U
MethodDescriptor
U
PbError
U
PbReader
U
PbWriter
U
Pushback
U
ReflectionRequest
U
ReflectionResponse
U
ReflectionService
U
Registrar
U
Retry
U
RpcContext
U
ServiceDescriptor
U
ServingStatus
U
SrvStream
U
Status
U
StatusError
U
Stream
U
StreamError
U
StreamEvent
U
StreamInterceptor
U
StreamState
U
SubConn
U
Throttle
U
Throttling
U
UnaryInterceptor
U
WireType
V
client_streaming
V
decode_file_descriptor_set
V
decode_health_request
V
decode_health_response
V
decode_message
V
decode_reflection_request
V
decode_reflection_response
V
default_max_frame_size
V
default_max_streams
V
default_window_size
V
dns_decode_response
V
dns_encode_query
V
dns_type_a
V
dns_type_aaaa
V
encode_file_descriptor_set
V
encode_grpc_timeout
V
encode_health_request
V
encode_health_response
V
encode_message
V
encode_reflection_request
V
health_check_path
V
health_watch_path
V
hedging
V
is_binary_metadata
V
limit
V
max_header_list_size
V
max_message_size
V
message_len
V
metadata_value_from_wire
V
metadata_value_to_wire
V
parse_grpc_timeout
V
percent_decode
V
reflection_v1_path
V
reflection_v1alpha_path
V
retry
V
server_streaming
V
split_messages
V
stream_id_valid_for_initiator
V
stream_is_client_initiated
V
stream_is_server_initiated
V
unary

moonbitstack/moonrpc/balance does not have a README file

Attempts

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[@moonbitstack/moonhttp/header.Header
Header], committed? : Bool, unprocessed? : Bool, roll? : Double) -> @moonbitstack/moondate.Span
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.

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::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, @moonbitlang/core/debug.Debug
Debug)

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

ConnectivityState::equal

source

fn ConnectivityState::equal(ConnectivityState, ConnectivityState) -> Bool

ConnectivityState::not_equal

source

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

ConnectivityState::to_repr

source

fn ConnectivityState::to_repr(ConnectivityState) -> @moonbitlang/core/debug.Repr
Repr

DnsRecord

source

pub(all) struct DnsRecord {
  name : String
  rtype : Int
  ttl : Int
  address : String
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn DnsRecord::to_repr(DnsRecord) -> @moonbitlang/core/debug.Repr
Repr

DnsResponse

source

pub(all) struct DnsResponse {
  id : Int
  rcode : Int
  answers : Array[DnsRecord]
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn DnsResponse::to_repr(DnsResponse) -> @moonbitlang/core/debug.Repr
Repr

Hedging

source

pub(all) struct Hedging {
  attempts : Int
  delay : @moonbitstack/moondate.Span
Span
  codes : Array[@moonbitstack/moonrpc/wire.Status
Status]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

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

fn Hedging::new(attempts? : Int, delay? : @moonbitstack/moondate.Span
Span, codes? : Array[@moonbitstack/moonrpc/wire.Status
Status]) -> Hedging

A policy by A6's field names.

Hedging::not_equal

source

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

Hedging::to_repr

source

fn Hedging::to_repr(Hedging) -> @moonbitlang/core/debug.Repr
Repr

LbPolicy

source

pub(all) enum LbPolicy {
  PickFirst
  RoundRobin
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn LbPolicy::to_repr(LbPolicy) -> @moonbitlang/core/debug.Repr
Repr

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.

Pushback

source

pub(all) enum Pushback {
  Absent
  After(@moonbitstack/moondate.Span
Span)
  Stop
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn Pushback::read(trailers : ArrayView[@moonbitstack/moonhttp/header.Header
Header]) -> Pushback

The pushback a reply's trailers carry.

Pushback::to_repr

source

fn Pushback::to_repr(Pushback) -> @moonbitlang/core/debug.Repr
Repr

Retry

source

pub(all) struct Retry {
  backoff : @moonbitstack/moonward.Backoff
Backoff
  codes : Array[@moonbitstack/moonrpc/wire.Status
Status]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

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? : @moonbitstack/moondate.Span
Span, cap? : @moonbitstack/moondate.Span
Span, factor? : Double, codes? : Array[@moonbitstack/moonrpc/wire.Status
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

fn Retry::to_repr(Retry) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Throttling::to_repr(Throttling) -> @moonbitlang/core/debug.Repr
Repr

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.

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

Site source Report issue Packages Build queue Skills Statistics

#Attempts

#Attempts::made

#Attempts::new

#Attempts::next

#ConnectionPool

#ConnectionPool::new

#ConnectionPool::pick

#ConnectionPool::ready_addresses

#ConnectionPool::subconn

#ConnectivityState

#ConnectivityState::equal

#ConnectivityState::not_equal

#ConnectivityState::to_repr

#DnsRecord

#DnsRecord::equal

#DnsRecord::not_equal

#DnsRecord::to_repr

#DnsResponse

#DnsResponse::addresses

#DnsResponse::equal

#DnsResponse::not_equal

#DnsResponse::to_repr

#Hedging

#Hedging::commits

#Hedging::equal

#Hedging::more

#Hedging::new

#Hedging::not_equal

#Hedging::to_repr

#LbPolicy

#LbPolicy::equal

#LbPolicy::not_equal

#LbPolicy::to_repr

#LoadBalancer

#LoadBalancer::new

#LoadBalancer::pick

#LoadBalancer::size

#Pushback

#Pushback::equal

#Pushback::not_equal

#Pushback::read

#Pushback::to_repr

#Retry

#Retry::equal

#Retry::new

#Retry::not_equal

#Retry::to_repr

#SubConn

#SubConn::connect

#SubConn::is_ready

#SubConn::new

#SubConn::on_connected

#SubConn::on_failure

#SubConn::on_idle

#SubConn::shutdown

#Throttle

#Throttle::allows

#Throttle::fail

#Throttle::new

#Throttle::pass

#Throttle::tokens

#Throttling

#Throttling::equal

#Throttling::new

#Throttling::not_equal

#Throttling::to_repr

#dns_decode_response

#dns_encode_query

#dns_type_a

#dns_type_aaaa

#hedging

#limit

#retry

Source Files

Attempts

Attempts::made

Attempts::new

Attempts::next

ConnectionPool

ConnectionPool::new

ConnectionPool::pick

ConnectionPool::ready_addresses

ConnectionPool::subconn

ConnectivityState

ConnectivityState::equal

ConnectivityState::not_equal

ConnectivityState::to_repr

DnsRecord

DnsRecord::equal

DnsRecord::not_equal

DnsRecord::to_repr

DnsResponse

DnsResponse::addresses

DnsResponse::equal

DnsResponse::not_equal

DnsResponse::to_repr

Hedging

Hedging::commits

Hedging::equal

Hedging::more

Hedging::new

Hedging::not_equal

Hedging::to_repr

LbPolicy

LbPolicy::equal

LbPolicy::not_equal

LbPolicy::to_repr

LoadBalancer

LoadBalancer::new

LoadBalancer::pick

LoadBalancer::size

Pushback

Pushback::equal

Pushback::not_equal

Pushback::read

Pushback::to_repr

Retry

Retry::equal

Retry::new

Retry::not_equal

Retry::to_repr

SubConn

SubConn::connect

SubConn::is_ready

SubConn::new

SubConn::on_connected

SubConn::on_failure

SubConn::on_idle

SubConn::shutdown

Throttle

Throttle::allows

Throttle::fail

Throttle::new

Throttle::pass

Throttle::tokens

Throttling

Throttling::equal

Throttling::new

Throttling::not_equal

Throttling::to_repr

dns_decode_response

dns_encode_query

dns_type_a

dns_type_aaaa

hedging

limit

retry