proxy

Documentation

Overview

Package proxy provides a reverse proxy handler for gRPC.

The implementation allows a `grpc.Server` to pass a received ServerStream to a ClientStream without understanding the semantics of the messages exchanged. It basically provides a transparent reverse-proxy.

This package is intentionally generic, exposing a `StreamDirector` function that allows users of this package to implement whatever logic of backend-picking, dialing and service verification to perform.

See examples on documented functions.

Index

• Variables
• func Codec() grpc.Codec
• func CodecWithParent(fallback grpc.Codec) grpc.Codec
• func RegisterService(server *grpc.Server, director StreamDirector, serviceName string, ...)
• func TransparentHandler(director StreamDirector) grpc.StreamHandler
• type StreamDirector
• type StreamModifier
• type StreamParameters
  • func NewStreamParameters(ctx context.Context, conn *grpc.ClientConn, reqFinalizer func(), ...) *StreamParameters
  • func (s *StreamParameters) CallOptions() []grpc.CallOption
  • func (s *StreamParameters) Conn() *grpc.ClientConn
  • func (s *StreamParameters) Context() context.Context
  • func (s *StreamParameters) RequestFinalizer()

Examples

• RegisterService
• StreamDirector
• TransparentHandler

Variables

var ErrInvalidPeekCount = errors.New("peek count must be greater than zero")

ErrInvalidPeekCount indicates the director function requested an invalid peek quanity

Functions

func Codec

func Codec() grpc.Codec

Codec returns a proxying grpc.Codec with the default protobuf codec as parent.

See CodecWithParent.

func CodecWithParent

func CodecWithParent(fallback grpc.Codec) grpc.Codec

CodecWithParent returns a proxying grpc.Codec with a user provided codec as parent.

This codec is *crucial* to the functioning of the proxy. It allows the proxy server to be oblivious to the schema of the forwarded messages. It basically treats a gRPC message frame as raw bytes. However, if the server handler, or the client caller are not proxy-internal functions it will fall back to trying to decode the message using a fallback codec.

func RegisterService

func RegisterService(server *grpc.Server, director StreamDirector, 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.

Example

package main

import (
	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
	"google.golang.org/grpc"
)

var director proxy.StreamDirector

func main() {
	// A gRPC server with the proxying codec enabled.
	server := grpc.NewServer(grpc.CustomCodec(proxy.Codec()))
	// Register a TestService with 4 of its methods explicitly.
	proxy.RegisterService(server, director,
		"mwitkow.testproto.TestService",
		"PingEmpty", "Ping", "PingError", "PingList")
}

func TransparentHandler

func TransparentHandler(director StreamDirector) 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.

Example

package main

import (
	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
	"google.golang.org/grpc"
)

var director proxy.StreamDirector

func main() {
	grpc.NewServer(
		grpc.CustomCodec(proxy.Codec()),
		grpc.UnknownServiceHandler(proxy.TransparentHandler(director)))
}

Types

type StreamDirector

type StreamDirector func(ctx context.Context, fullMethodName string, peeker StreamModifier) (*StreamParameters, 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.

Example

Provide sa simple example of a director that shields internal services and dials a staging or production backend. This is a *very naive* implementation that creates a new connection on every request. Consider using pooling.

package main

import (
	"strings"

	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
)

var director proxy.StreamDirector

func main() {
	director = func(ctx context.Context, fullMethodName string, _ proxy.StreamModifier) (*proxy.StreamParameters, error) {
		// Make sure we never forward internal services.
		if strings.HasPrefix(fullMethodName, "/com.example.internal.") {
			return nil, grpc.Errorf(codes.Unimplemented, "Unknown method")
		}
		md, ok := metadata.FromIncomingContext(ctx)
		if ok {
			// Decide on which backend to dial
			if val, exists := md[":authority"]; exists && val[0] == "staging.api.example.com" {
				// Make sure we use DialContext so the dialing can be cancelled/time out together with the context.
				conn, err := grpc.DialContext(ctx, "api-service.staging.svc.local", grpc.WithCodec(proxy.Codec()))
				return proxy.NewStreamParameters(ctx, conn, nil, nil), err
			} else if val, exists := md[":authority"]; exists && val[0] == "api.example.com" {
				conn, err := grpc.DialContext(ctx, "api-service.prod.svc.local", grpc.WithCodec(proxy.Codec()))
				return proxy.NewStreamParameters(ctx, conn, nil, nil), err
			}
		}
		return nil, grpc.Errorf(codes.Unimplemented, "Unknown method")
	}
}

type StreamModifier

type StreamModifier interface {
	// Peek allows a director to peek one message into the request stream without
	// removing those messages from the stream that will be forwarded to
	// the backend server.
	Peek() (frame []byte, _ error)

	// Modify replaces the peeked payload in the stream with the provided frame.
	// If no payload was peeked, an error will be returned.
	// Note: Modify cannot be called after the director returns.
	Modify(payload []byte) error
}

StreamModifier abstracts away the gRPC stream being forwarded so that it can be inspected and modified.

type StreamParameters

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

StreamParameters encapsulates streaming parameters the praefect coordinator returns to the proxy handler

func NewStreamParameters

func NewStreamParameters(ctx context.Context, conn *grpc.ClientConn, reqFinalizer func(), callOpts []grpc.CallOption) *StreamParameters

NewStreamParameters returns a new instance of StreamParameters

func (*StreamParameters) CallOptions

func (s *StreamParameters) CallOptions() []grpc.CallOption

CallOptions returns call options

func (*StreamParameters) Conn

func (s *StreamParameters) Conn() *grpc.ClientConn

Conn returns a grpc client connection

func (*StreamParameters) Context

func (s *StreamParameters) Context() context.Context

Context returns the outgoing context

func (*StreamParameters) RequestFinalizer

func (s *StreamParameters) RequestFinalizer()

RequestFinalizer calls the request finalizer