proxy

Documentation

Index

• Constants
• func RegisterService(server *grpc.Server, director StreamDirector, getPolicyFn getPolicyFn, ...)
• func TransparentHandler(director StreamDirector, getPolicyFn getPolicyFn, ...) grpc.StreamHandler
• type DirectorConnectionFactory
• type ProxyTarget
• type StreamDirector

Constants

const StreamMetadataKey = "dapr-stream"

Metadata header used to indicate if the call should be handled as a gRPC stream.

Functions

func RegisterService

func RegisterService(server *grpc.Server, director StreamDirector, getPolicyFn getPolicyFn, serviceName string, methodNames ...string)

RegisterService sets up a proxy handler for a particular gRPC service and method. The behaviour is the same as if you were registering a handler method, e.g. from a codegenerated pb.go file.

This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.

func TransparentHandler

func TransparentHandler(director StreamDirector, getPolicyFn getPolicyFn, connFactory DirectorConnectionFactory) grpc.StreamHandler

TransparentHandler returns a handler that attempts to proxy all requests that are not registered in the server. The indented use here is as a transparent proxy, where the server doesn't know about the services implemented by the backends. It should be used as a `grpc.UnknownServiceHandler`.

This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.

Types

type DirectorConnectionFactory

type DirectorConnectionFactory func(ctx context.Context, address string, id string, namespace string, customOpts ...grpc.DialOption) (*grpc.ClientConn, func(destroy bool), error)

DirectorConnectionFactory is a method signature for a gRPC connection establisher method used for client/server streams

type ProxyTarget

type ProxyTarget struct {
	ID        string
	Address   string
	Namespace string
}

ProxyTarget is an object that describes the network and service identification of a remote Dapr process

type StreamDirector

type StreamDirector func(ctx context.Context, fullMethodName string) (context.Context, *grpc.ClientConn, *ProxyTarget, func(destroy bool), error)

StreamDirector returns a gRPC ClientConn to be used to forward the call to.

The presence of the `Context` allows for rich filtering, e.g. based on Metadata (headers). If no handling is meant to be done, a `codes.NotImplemented` gRPC error should be returned.

The context returned from this function should be the context for the *outgoing* (to backend) call. In case you want to forward any Metadata between the inbound request and outbound requests, you should do it manually. However, you *must* propagate the cancel function (`context.WithCancel`) of the inbound context to the one returned.

It is worth noting that the StreamDirector will be fired *after* all server-side stream interceptors are invoked. So decisions around authorization, monitoring etc. are better to be handled there.

See the rather rich example.