moonbitstack/moonrpc/balance

README
U
Attempts
U
Backoff
U
BidiHandler
U
Call
U
CallInfo
U
CallReply
U
Caller
U
ClientCall
U
ConnectionPool
U
ConnectivityState
U
DnsRecord
U
DnsResponse
U
Encoding
U
Enum
U
EnumDescriptor
U
EnumValueDescriptor
U
FieldDescriptor
U
FieldLabel
U
FieldType
U
FileDescriptor
U
H2Client
U
H2Server
U
Handler
U
Header
U
HealthService
U
Hedging
U
Invocation
U
Keepalive
U
LbPolicy
U
LoadBalancer
U
Message
U
MessageDescriptor
U
Method
U
MethodDescriptor
U
PbError
U
PbReader
U
PbWriter
U
Pushback
U
Reconnect
U
ReflectionRequest
U
ReflectionResponse
U
ReflectionService
U
Registrar
U
Responder
U
Retry
U
RpcContext
U
ServiceDescriptor
U
ServingStatus
U
SrvStream
U
Status
U
StatusDetails
U
StatusError
U
Stream
U
StreamError
U
StreamEvent
U
StreamInterceptor
U
StreamState
U
SubConn
U
Throttle
U
Throttling
U
UnaryInterceptor
U
WireType
V
accept_encodings
V
backoff
V
bidi
V
bidi_each
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
decode_status_details
V
default_max_frame_size
V
default_max_streams
V
default_window_size
V
detail_body
V
detail_type_url
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
negotiated
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.

Backoff

source

pub(all) struct Backoff {
  initial : @moonbitstack/moondate.Span
Span
  max : @moonbitstack/moondate.Span
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) -> @moonbitstack/moondate.Span
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? : @moonbitstack/moondate.Span
Span, max? : @moonbitstack/moondate.Span
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, @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

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

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

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 : @moonbitstack/moondate.Span
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

Install

Download zip

gRPC for MoonBit.

grpcrpcprotobufhttp2moonbit

moonbitstack

Apache-2.0

github.com/moonbitstack/moonrpc

Updated 12 hours ago

867 downloads

Site source Report issue Modules Skills Build queue Statistics

#Attempts

#Attempts::made

#Attempts::new

#Attempts::next

#Backoff

#Backoff::delay

#Backoff::new

#ConnectionPool

#ConnectionPool::add

#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

#Reconnect

#Reconnect::due

#Reconnect::failed

#Reconnect::new

#Reconnect::succeeded

#Reconnect::wait_millis

#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

#backoff

#dns_decode_response

#dns_encode_query

#dns_type_a

Attempts

Attempts::made

Attempts::new

Attempts::next

Backoff

Backoff::delay

Backoff::new

ConnectionPool

ConnectionPool::add

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

Reconnect

Reconnect::due

Reconnect::failed

Reconnect::new

Reconnect::succeeded

Reconnect::wait_millis

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

backoff

dns_decode_response

dns_encode_query

dns_type_a