rpc

type ClientPartitionConfigMiddleware ¶ added in v1.2.1

type ClientPartitionConfigMiddleware struct{}

ClientPartitionConfigMiddleware stores the partition config and isolation group of the request into the context It reads a header from client request and uses it as the isolation group

func (m *ClientPartitionConfigMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error

type Factory ¶ added in v0.24.0

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

Factory is an implementation of common.RPCFactory interface

func NewFactory(logger log.Logger, p Params) *Factory

func (d *Factory) GetChannel() tchannel.Channel

func (d *Factory) GetDispatcher() *yarpc.Dispatcher

func (d *Factory) GetMaxMessageSize() int

type ForwardPartitionConfigMiddleware ¶ added in v1.2.1

type ForwardPartitionConfigMiddleware struct{}

ForwardPartitionConfigMiddleware forwards the partition config to remote cluster The middleware should always be applied after any other middleware that inject partition config into the context so that it can overwrites the partition config into the context The purpose of this middleware is to make sure the partition config doesn't change when a request is forwarded from passive cluster to the active cluster

func (m *ForwardPartitionConfigMiddleware) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error)

func (m *ForwardPartitionConfigMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error

type HeaderForwardingMiddleware ¶ added in v0.24.0

type HeaderForwardingMiddleware struct {
	// Rules are applied in order to add or remove headers by regex.
	//
	// There are no default rules, so by default no headers are copied.
	// To include headers by default, Add with a permissive regex and then remove specific ones.
	Rules []config.HeaderRule
}

HeaderForwardingMiddleware forwards headers from current inbound RPC call that is being handled to new outbound calls being made. As this does NOT differentiate between transports or purposes, it generally assumes we are not acting as a true proxy, so things like content lengths and encodings should not be forwarded - they will be provided by the outbound RPC library as needed.

Duplicated headers retain the first value only, matching how browsers and Go (afaict) generally behave.

This uses overly-simplified rules for choosing which headers are forwarded and which are not, intended to be lightly configurable. For a more in-depth logic review if it becomes needed, check:

• How Go's ReverseProxy deals with headers, e.g. per-protocol and a list of exclusions: https://cs.opensource.google/go/go/+/refs/tags/go1.20.1:src/net/http/httputil/reverseproxy.go;l=332
• HTTP's spec for headers, namely how duplicates and Connection work: https://www.rfc-editor.org/rfc/rfc9110.html#name-header-fields
• Many browsers prefer first-value-wins for unexpected duplicates: https://bugzilla.mozilla.org/show_bug.cgi?id=376756
• But there are MANY map-like implementations that choose last-value wins, and this mismatch is a source of frequent security problems.
• YARPC's `With` only retains the last call's value: https://github.com/yarpc/yarpc-go/blob/8ccd79a2ca696150213faac1d35011c5be52e5fb/api/transport/header.go#L69-L77
• Go's MIMEHeader's Get (used by YARPC) only returns the first value, and does not join duplicates: https://pkg.go.dev/net/textproto#MIMEHeader.Get

There is likely no correct choice, as it depends on the recipients' behavior. If we need to support more complex logic, it's likely worth jumping to a fully-controllable thing. Middle-grounds will probably just need to be changed again later.

func (m *HeaderForwardingMiddleware) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error)

type InboundMetricsMiddleware ¶ added in v0.24.0

type InboundMetricsMiddleware struct{}

InboundMetricsMiddleware tags context with additional metric tags from incoming request.

func (m *InboundMetricsMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error

type OutboundsBuilder ¶ added in v0.24.0

type OutboundsBuilder interface {
	Build(*grpc.Transport, *tchannel.Transport) (yarpc.Outbounds, error)
}

OutboundsBuilder allows defining outbounds for the dispatcher

func CombineOutbounds(builders ...OutboundsBuilder) OutboundsBuilder

func NewCrossDCOutbounds(clusterGroup map[string]config.ClusterInformation, pcf PeerChooserFactory) OutboundsBuilder

func NewDirectOutbound(serviceName string, grpcEnabled bool, tlsConfig *tls.Config) OutboundsBuilder

type Params ¶ added in v0.24.0

type Params struct {
	ServiceName     string
	TChannelAddress string
	GRPCAddress     string
	GRPCMaxMsgSize  int
	HTTP            *httpParams

	InboundTLS  *tls.Config
	OutboundTLS map[string]*tls.Config

	InboundMiddleware  yarpc.InboundMiddleware
	OutboundMiddleware yarpc.OutboundMiddleware

	OutboundsBuilder OutboundsBuilder
}

Params allows to configure rpc.Factory

func NewParams(serviceName string, config *config.Config, dc *dynamicconfig.Collection) (Params, error)

type PeerChooserFactory ¶ added in v0.24.0

type PeerChooserFactory interface {
	CreatePeerChooser(transport peer.Transport, address string) (peer.Chooser, error)
}

func NewDNSPeerChooserFactory(interval time.Duration, logger log.Logger) PeerChooserFactory

type PinotComparatorMiddleware ¶ added in v1.2.8

type PinotComparatorMiddleware struct{}

PinotComparatorMiddleware checks the header of a grpc request, and then override the context accordingly note: for Pinot Migration only (Jan. 2024)

func (m *PinotComparatorMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error

type ResponseInfo ¶

type ResponseInfo struct {
	Size int
}

ResponseInfo structure is filled with data after the RPC call. It can be obtained with rpc.ContextWithResponseInfo function.

func ContextWithResponseInfo(parent context.Context) (context.Context, *ResponseInfo)

type ResponseInfoMiddleware ¶

type ResponseInfoMiddleware struct{}

ResponseInfoMiddleware populates context with ResponseInfo structure which contains info about response that was received. In particular, it counts the size of the response in bytes. Such information can be useful down the line, where payload are deserialized and no longer have their size.

func (m *ResponseInfoMiddleware) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error)