rpc

Documentation

Index

• Constants
• func IsGRPCOutbound(config transport.ClientConfig) bool
• func ListenIP() (net.IP, error)
• type ClientPartitionConfigMiddleware
  • func (m *ClientPartitionConfigMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, ...) error
• type Factory
  • 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
  • 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, ...) error
• type HeaderForwardingMiddleware
  • func (m *HeaderForwardingMiddleware) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error)
• type InboundMetricsMiddleware
  • func (m *InboundMetricsMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, ...) error
• type OutboundsBuilder
  • 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
  • func NewParams(serviceName string, config *config.Config, dc *dynamicconfig.Collection) (Params, error)
• type PeerChooserFactory
  • func NewDNSPeerChooserFactory(interval time.Duration, logger log.Logger) PeerChooserFactory
• type PinotComparatorMiddleware
  • func (m *PinotComparatorMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, ...) error
• type ResponseInfo
  • func ContextWithResponseInfo(parent context.Context) (context.Context, *ResponseInfo)
• type ResponseInfoMiddleware
  • func (m *ResponseInfoMiddleware) Call(ctx context.Context, request *transport.Request, out transport.UnaryOutbound) (*transport.Response, error)

Constants

const ComparatorYarpcKey = "cadence-visibility-override"

ComparatorYarpcKey is the const for yarpc key

const (
	// OutboundPublicClient is the name of configured public client outbound
	OutboundPublicClient = "public-client"
)

Functions

func IsGRPCOutbound

func IsGRPCOutbound(config transport.ClientConfig) bool

func ListenIP

func ListenIP() (net.IP, error)

ListenIP returns the IP to bind to in Listen. It tries to find an IP that can be used by other machines to reach this machine.

Types

type ClientPartitionConfigMiddleware

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 (*ClientPartitionConfigMiddleware) Handle

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

type Factory

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

Factory is an implementation of common.RPCFactory interface

func NewFactory

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

NewFactory builds a new rpc.Factory

func (*Factory) GetChannel

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

GetChannel returns Tchannel Channel used by Ringpop

func (*Factory) GetDispatcher

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

GetDispatcher return a cached dispatcher

func (*Factory) GetMaxMessageSize

func (d *Factory) GetMaxMessageSize() int

type ForwardPartitionConfigMiddleware

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 (*ForwardPartitionConfigMiddleware) Call

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

func (*ForwardPartitionConfigMiddleware) Handle

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

type HeaderForwardingMiddleware

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 (*HeaderForwardingMiddleware) Call

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

type InboundMetricsMiddleware

type InboundMetricsMiddleware struct{}

InboundMetricsMiddleware tags context with additional metric tags from incoming request.

func (*InboundMetricsMiddleware) Handle

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

type OutboundsBuilder

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

OutboundsBuilder allows defining outbounds for the dispatcher

func CombineOutbounds

func CombineOutbounds(builders ...OutboundsBuilder) OutboundsBuilder

CombineOutbounds takes multiple outbound builders and combines them

func NewCrossDCOutbounds

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

func NewDirectOutbound

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

type Params

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

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

NewParams creates parameters for rpc.Factory from the given config

type PeerChooserFactory

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

func NewDNSPeerChooserFactory

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

type PinotComparatorMiddleware

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 (*PinotComparatorMiddleware) Handle

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

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

ContextWithResponseInfo will create a child context that has ResponseInfo set as value. This value will get filled after the call is made and can be used later to retrieve some info of interest.

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 (*ResponseInfoMiddleware) Call

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