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
MessageDescriptor
U
Method
U
MethodDescriptor
U
PbError
U
PbReader
U
PbWriter
U
Pushback
U
ReflectionRequest
U
ReflectionResponse
U
ReflectionService
U
Retry
U
RpcContext
U
ServiceDescriptor
U
ServingStatus
U
SrvStream
U
Status
U
Stream
U
StreamError
U
StreamEvent
U
StreamInterceptor
U
StreamState
U
SubConn
U
Throttle
U
Throttling
U
UnaryInterceptor
U
WireType
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
split_messages
V
stream_id_valid_for_initiator
V
stream_is_client_initiated
V
stream_is_server_initiated

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

Install

Download zip

Real gRPC for MoonBit over HTTP/2: all four call kinds, metadata, deadlines, rich errors, health checking, server reflection, retries, hedging and load balancing, with pure client and server engines that run on every backend.

grpcrpcprotobufhttp2moonbit

moonbitstack

Apache-2.0

github.com/moonbitstack/moonrpc

Updated 2 hours ago

549 downloads

Dependencies

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