call

type Balancer interface {
	// Update updates the current set of endpoints from which the Balancer can
	// pick. Before Update is called for the first time, the set of endpoints
	// is empty.
	Update(endpoints []Endpoint)

	// Pick picks an endpoint. Pick is guaranteed to return an endpoint that
	// was passed to the most recent call of Update. If there are no endpoints,
	// then Pick returns an error that includes Unreachable.
	Pick(CallOptions) (Endpoint, error)
}

type CallOptions struct {
	// ShardKey, if not 0, is the shard key that a Balancer can use to route a
	// call. A Balancer can always choose to ignore the ShardKey.
	//
	// TODO(mwhittaker): Figure out a way to have 0 be a valid shard key. Could
	// change to *uint64 for example.
	ShardKey uint64

	// Balancer, if not nil, is the Balancer to use for a call, instead of the
	// Balancer that the client was constructed with (provided in
	// ClientOptions).
	Balancer Balancer
}

type ClientOptions struct {
	// Load balancer. Defaults to RoundRobin() if nil.
	Balancer Balancer

	// Logger. Defaults to a logger that logs to stderr.
	Logger logtype.Logger

	// If non-zero, each call will optimistically spin for a given duration
	// before blocking, waiting for the results.
	OptimisticSpinDuration time.Duration

	// If non-zero, all writes smaller than this limit are flattened into
	// a single buffer before being written on the connection.
	WriteFlattenLimit int
}

type Connection interface {
	// Call makes an RPC over a Connection.
	Call(context.Context, MethodKey, []byte, CallOptions) ([]byte, error)

	// Close closes a connection. Pending invocations of Call are cancelled and
	// return an error. All future invocations of Call fail and return an error
	// immediately. Close can be called more than once.
	Close()
}

type Endpoint interface {
	// Dial returns an network connection to the endpoint.
	Dial(ctx context.Context) (net.Conn, error)

	// Address returns the address of the endpoint. If two endpoints have the
	// same address, then they are guaranteed to represent the same endpoint.
	// But, two endpoints with different addresses may also represent the same
	// endpoint (e.g., TCP("golang.org:http") and TCP("golang.org:80")).
	Address() string
}

type Handler func(ctx context.Context, args []byte) ([]byte, error)

type HandlerMap struct {
	// contains filtered or unexported fields
}

type MethodKey [16]byte

type NetEndpoint struct {
	Net  string // e.g., "tcp", "udp", "unix"
	Addr string // e.g., "localhost:8000", "/tmp/unix.sock"
}

type NetworkAddress string

type Resolver interface {
	// IsConstant returns whether a resolver is constant. A constant resolver
	// returns a fixed set of endpoints that doesn't change over time. A
	// non-constant resolver manages a set of endpoints that does change over
	// time.
	IsConstant() bool

	// Resolve returns a resolver's set of dialable endpoints. For non-constant
	// resolvers, this set of endpoints may change over time. Every snapshot of
	// the set of endpoints is assigned a unique version. If you call the
	// Resolve method with a nil version, Resolve returns the current set of
	// endpoints and its version. If you call the Resolve method with a non-nil
	// version, then a Resolver either:
	//    1. Blocks until the latest set of endpoints has a version newer than
	//       the one provided, returning the new set of endpoints and a new
	//       version.
	//    2. Returns the same version, indicating that the Resolve should
	//       be called again after an appropriate delay.
	//
	// Example:
	//     if !resolver.IsConstant() {
	//         // Perform an unversioned, non-blocking Resolve to get the the
	//         // latest set of endpoints and its version.
	//         endpoints, version, err := resolver.Resolve(ctx, nil)
	//
	//         // Peform a versioned Resolve that either (1) blocks until a set
	//         // of endpoints exists with a version newer than `version`, or
	//         // (2) returns `version`, indicating that the Resolve should be
	//         // called again after an appropriate delay.
	//         newEndpoints, newVersion, err := resolver.Resolve(ctx, version)
	//     }
	//
	// If the resolver is constant, then Resolve only needs to be called once
	// with a nil version. The returned set of endpoints will never change, and
	// the returned version is nil.
	//
	//     if resolver.IsConstant() {
	//         // endpoints1 == endpoints2, and version1 == version2 == nil.
	//         endpoints1, version1, err := resolver.Resolve(ctx, nil)
	//         endpoints2, version2, err := resolver.Resolve(ctx, nil)
	//     }
	Resolve(ctx context.Context, version *Version) ([]Endpoint, *Version, error)
}

type ServerOptions struct {
	// Logger. Defaults to a logger that logs to stderr.
	Logger logtype.Logger

	// Tracer. Defaults to a discarding tracer.
	Tracer trace.Tracer

	// If non-zero, calls on the server are inlined and a new goroutine is
	// launched only if the call takes longer than the provided duration.
	InlineHandlerDuration time.Duration

	// If non-zero, all writes smaller than this limit are flattened into
	// a single buffer before being written on the connection.
	WriteFlattenLimit int
}

type Version struct {
	Opaque string
}