grpc-gateway: github.com/grpc-ecosystem/grpc-gateway/runtime Index | Files

package runtime

import "github.com/grpc-ecosystem/grpc-gateway/runtime"

Package runtime contains runtime helper functions used by servers which protoc-gen-grpc-gateway generates.

Index

Package Files

context.go convert.go doc.go errors.go fieldmask.go handler.go marshal_httpbodyproto.go marshal_json.go marshal_jsonpb.go marshal_proto.go marshaler.go marshaler_registry.go mux.go pattern.go proto2_convert.go proto_errors.go query.go

Constants

const MIMEWildcard = "*"

MIMEWildcard is the fallback MIME type used for requests which do not match a registered MIME type.

const MetadataHeaderPrefix = "Grpc-Metadata-"

MetadataHeaderPrefix is the http prefix that represents custom metadata parameters to or from a gRPC call.

const MetadataPrefix = "grpcgateway-"

MetadataPrefix is prepended to permanent HTTP header keys (as specified by the IANA) when added to the gRPC context.

const MetadataTrailerPrefix = "Grpc-Trailer-"

MetadataTrailerPrefix is prepended to gRPC metadata as it is converted to HTTP headers in a response handled by grpc-gateway

Variables

var (
    // HTTPError replies to the request with the error.
    // You can set a custom function to this variable to customize error format.
    HTTPError = DefaultHTTPError
    // OtherErrorHandler handles the following error used by the gateway: StatusMethodNotAllowed StatusNotFound and StatusBadRequest
    OtherErrorHandler = DefaultOtherErrorHandler
)
var (
    // ErrNotMatch indicates that the given HTTP request path does not match to the pattern.
    ErrNotMatch = errors.New("not match to the path pattern")
    // ErrInvalidPattern indicates that the given definition of Pattern is not valid.
    ErrInvalidPattern = errors.New("invalid pattern")
)
var (
    // DefaultContextTimeout is used for gRPC call context.WithTimeout whenever a Grpc-Timeout inbound
    // header isn't present. If the value is 0 the sent `context` will not have a timeout.
    DefaultContextTimeout = 0 * time.Second
)
var ErrUnknownURI = status.Error(codes.Unimplemented, http.StatusText(http.StatusNotImplemented))

ErrUnknownURI is the error supplied to a custom ProtoErrorHandlerFunc when a request is received with a URI path that does not match any registered service method.

Since gRPC servers return an "Unimplemented" code for requests with an unrecognized URI path, this error also has a gRPC "Unimplemented" code.

func AnnotateContext Uses

func AnnotateContext(ctx context.Context, mux *ServeMux, req *http.Request) (context.Context, error)

AnnotateContext adds context information such as metadata from the request.

At a minimum, the RemoteAddr is included in the fashion of "X-Forwarded-For", except that the forwarded destination is not another HTTP service but rather a gRPC service.

func AnnotateIncomingContext Uses

func AnnotateIncomingContext(ctx context.Context, mux *ServeMux, req *http.Request) (context.Context, error)

AnnotateIncomingContext adds context information such as metadata from the request. Attach metadata as incoming context.

func Bool Uses

func Bool(val string) (bool, error)

Bool converts the given string representation of a boolean value into bool.

func BoolP Uses

func BoolP(val string) (*bool, error)

BoolP parses the given string representation of a boolean value, and returns a pointer to a bool whose value is same as the parsed value.

func BoolSlice Uses

func BoolSlice(val, sep string) ([]bool, error)

BoolSlice converts 'val' where individual booleans are separated by 'sep' into a bool slice.

func BoolValue Uses

func BoolValue(val string) (*wrappers.BoolValue, error)

BoolValue well-known type support as wrapper around bool type

func Bytes Uses

func Bytes(val string) ([]byte, error)

Bytes converts the given string representation of a byte sequence into a slice of bytes A bytes sequence is encoded in URL-safe base64 without padding

func BytesSlice Uses

func BytesSlice(val, sep string) ([][]byte, error)

BytesSlice converts 'val' where individual bytes sequences, encoded in URL-safe base64 without padding, are separated by 'sep' into a slice of bytes slices slice.

func BytesValue Uses

func BytesValue(val string) (*wrappers.BytesValue, error)

BytesValue well-known type support as wrapper around bytes[] type

func DefaultHTTPError Uses

func DefaultHTTPError(ctx context.Context, mux *ServeMux, marshaler Marshaler, w http.ResponseWriter, _ *http.Request, err error)

DefaultHTTPError is the default implementation of HTTPError. If "err" is an error from gRPC system, the function replies with the status code mapped by HTTPStatusFromCode. If otherwise, it replies with http.StatusInternalServerError.

The response body returned by this function is a JSON object, which contains a member whose key is "error" and whose value is err.Error().

func DefaultHTTPProtoErrorHandler Uses

func DefaultHTTPProtoErrorHandler(ctx context.Context, mux *ServeMux, marshaler Marshaler, w http.ResponseWriter, _ *http.Request, err error)

DefaultHTTPProtoErrorHandler is an implementation of HTTPError. If "err" is an error from gRPC system, the function replies with the status code mapped by HTTPStatusFromCode. If otherwise, it replies with http.StatusInternalServerError.

The response body returned by this function is a Status message marshaled by a Marshaler.

Do not set this function to HTTPError variable directly, use WithProtoErrorHandler option instead.

func DefaultHeaderMatcher Uses

func DefaultHeaderMatcher(key string) (string, bool)

DefaultHeaderMatcher is used to pass http request headers to/from gRPC context. This adds permanent HTTP header keys (as specified by the IANA) to gRPC context with grpcgateway- prefix. HTTP headers that start with 'Grpc-Metadata-' are mapped to gRPC metadata after removing prefix 'Grpc-Metadata-'.

func DefaultOtherErrorHandler Uses

func DefaultOtherErrorHandler(w http.ResponseWriter, _ *http.Request, msg string, code int)

DefaultOtherErrorHandler is the default implementation of OtherErrorHandler. It simply writes a string representation of the given error into "w".

func DisallowUnknownFields Uses

func DisallowUnknownFields()

DisallowUnknownFields enables option in decoder (unmarshaller) to return an error when it finds an unknown field. This function must be called before using the JSON marshaller.

func DoubleValue Uses

func DoubleValue(val string) (*wrappers.DoubleValue, error)

DoubleValue well-known type support as wrapper around float64 type

func Duration Uses

func Duration(val string) (*duration.Duration, error)

Duration converts the given string into a timestamp.Duration.

func Enum Uses

func Enum(val string, enumValMap map[string]int32) (int32, error)

Enum converts the given string into an int32 that should be type casted into the correct enum proto type.

func EnumSlice Uses

func EnumSlice(val, sep string, enumValMap map[string]int32) ([]int32, error)

EnumSlice converts 'val' where individual enums are separated by 'sep' into a int32 slice. Each individual int32 should be type casted into the correct enum proto type.

func FieldMaskFromRequestBody Uses

func FieldMaskFromRequestBody(r io.Reader, md *descriptor.DescriptorProto) (*field_mask.FieldMask, error)

FieldMaskFromRequestBody creates a FieldMask printing all complete paths from the JSON body.

func Float32 Uses

func Float32(val string) (float32, error)

Float32 converts the given string representation of a floating point number into float32.

func Float32P Uses

func Float32P(val string) (*float32, error)

Float32P parses the given string representation of a floating point number, and returns a pointer to a float32 whose value is same as the parsed number.

func Float32Slice Uses

func Float32Slice(val, sep string) ([]float32, error)

Float32Slice converts 'val' where individual floating point numbers are separated by 'sep' into a float32 slice.

func Float64 Uses

func Float64(val string) (float64, error)

Float64 converts the given string representation into representation of a floating point number into float64.

func Float64P Uses

func Float64P(val string) (*float64, error)

Float64P parses the given string representation of a floating point number, and returns a pointer to a float64 whose value is same as the parsed number.

func Float64Slice Uses

func Float64Slice(val, sep string) ([]float64, error)

Float64Slice converts 'val' where individual floating point numbers are separated by 'sep' into a float64 slice.

func FloatValue Uses

func FloatValue(val string) (*wrappers.FloatValue, error)

FloatValue well-known type support as wrapper around float32 type

func ForwardResponseMessage Uses

func ForwardResponseMessage(ctx context.Context, mux *ServeMux, marshaler Marshaler, w http.ResponseWriter, req *http.Request, resp proto.Message, opts ...func(context.Context, http.ResponseWriter, proto.Message) error)

ForwardResponseMessage forwards the message "resp" from gRPC server to REST client.

func ForwardResponseStream Uses

func ForwardResponseStream(ctx context.Context, mux *ServeMux, marshaler Marshaler, w http.ResponseWriter, req *http.Request, recv func() (proto.Message, error), opts ...func(context.Context, http.ResponseWriter, proto.Message) error)

ForwardResponseStream forwards the stream from gRPC server to REST client.

func HTTPStatusFromCode Uses

func HTTPStatusFromCode(code codes.Code) int

HTTPStatusFromCode converts a gRPC error code into the corresponding HTTP response status. See: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto

func Int32 Uses

func Int32(val string) (int32, error)

Int32 converts the given string representation of an integer into int32.

func Int32P Uses

func Int32P(val string) (*int32, error)

Int32P parses the given string representation of an integer and returns a pointer to a int32 whose value is same as the parsed integer.

func Int32Slice Uses

func Int32Slice(val, sep string) ([]int32, error)

Int32Slice converts 'val' where individual integers are separated by 'sep' into a int32 slice.

func Int32Value Uses

func Int32Value(val string) (*wrappers.Int32Value, error)

Int32Value well-known type support as wrapper around int32 type

func Int64 Uses

func Int64(val string) (int64, error)

Int64 converts the given string representation of an integer into int64.

func Int64P Uses

func Int64P(val string) (*int64, error)

Int64P parses the given string representation of an integer and returns a pointer to a int64 whose value is same as the parsed integer.

func Int64Slice Uses

func Int64Slice(val, sep string) ([]int64, error)

Int64Slice converts 'val' where individual integers are separated by 'sep' into a int64 slice.

func Int64Value Uses

func Int64Value(val string) (*wrappers.Int64Value, error)

Int64Value well-known type support as wrapper around int64 type

func MarshalerForRequest Uses

func MarshalerForRequest(mux *ServeMux, r *http.Request) (inbound Marshaler, outbound Marshaler)

MarshalerForRequest returns the inbound/outbound marshalers for this request. It checks the registry on the ServeMux for the MIME type set by the Content-Type header. If it isn't set (or the request Content-Type is empty), checks for "*". If there are multiple Content-Type headers set, choose the first one that it can exactly match in the registry. Otherwise, it follows the above logic for "*"/InboundMarshaler/OutboundMarshaler.

func NewServerMetadataContext Uses

func NewServerMetadataContext(ctx context.Context, md ServerMetadata) context.Context

NewServerMetadataContext creates a new context with ServerMetadata

func PopulateFieldFromPath Uses

func PopulateFieldFromPath(msg proto.Message, fieldPathString string, value string) error

PopulateFieldFromPath sets a value in a nested Protobuf structure. It instantiates missing protobuf fields as it goes.

func PopulateQueryParameters Uses

func PopulateQueryParameters(msg proto.Message, values url.Values, filter *utilities.DoubleArray) error

PopulateQueryParameters populates "values" into "msg". A value is ignored if its key starts with one of the elements in "filter".

func SetHTTPBodyMarshaler Uses

func SetHTTPBodyMarshaler(serveMux *ServeMux)

SetHTTPBodyMarshaler overwrite the default marshaler with the HTTPBodyMarshaler

func String Uses

func String(val string) (string, error)

String just returns the given string. It is just for compatibility to other types.

func StringP Uses

func StringP(val string) (*string, error)

StringP returns a pointer to a string whose pointee is same as the given string value.

func StringSlice Uses

func StringSlice(val, sep string) ([]string, error)

StringSlice converts 'val' where individual strings are separated by 'sep' into a string slice.

func StringValue Uses

func StringValue(val string) (*wrappers.StringValue, error)

StringValue well-known type support as wrapper around string type

func Timestamp Uses

func Timestamp(val string) (*timestamp.Timestamp, error)

Timestamp converts the given RFC3339 formatted string into a timestamp.Timestamp.

func UInt32Value Uses

func UInt32Value(val string) (*wrappers.UInt32Value, error)

UInt32Value well-known type support as wrapper around uint32 type

func UInt64Value Uses

func UInt64Value(val string) (*wrappers.UInt64Value, error)

UInt64Value well-known type support as wrapper around uint64 type

func Uint32 Uses

func Uint32(val string) (uint32, error)

Uint32 converts the given string representation of an integer into uint32.

func Uint32P Uses

func Uint32P(val string) (*uint32, error)

Uint32P parses the given string representation of an integer and returns a pointer to a uint32 whose value is same as the parsed integer.

func Uint32Slice Uses

func Uint32Slice(val, sep string) ([]uint32, error)

Uint32Slice converts 'val' where individual integers are separated by 'sep' into a uint32 slice.

func Uint64 Uses

func Uint64(val string) (uint64, error)

Uint64 converts the given string representation of an integer into uint64.

func Uint64P Uses

func Uint64P(val string) (*uint64, error)

Uint64P parses the given string representation of an integer and returns a pointer to a uint64 whose value is same as the parsed integer.

func Uint64Slice Uses

func Uint64Slice(val, sep string) ([]uint64, error)

Uint64Slice converts 'val' where individual integers are separated by 'sep' into a uint64 slice.

type Decoder Uses

type Decoder interface {
    Decode(v interface{}) error
}

Decoder decodes a byte sequence

type DecoderFunc Uses

type DecoderFunc func(v interface{}) error

DecoderFunc adapts an decoder function into Decoder.

func (DecoderFunc) Decode Uses

func (f DecoderFunc) Decode(v interface{}) error

Decode delegates invocations to the underlying function itself.

type DecoderWrapper Uses

type DecoderWrapper struct {
    *json.Decoder
}

DecoderWrapper is a wrapper around a *json.Decoder that adds support for protos to the Decode method.

func (DecoderWrapper) Decode Uses

func (d DecoderWrapper) Decode(v interface{}) error

Decode wraps the embedded decoder's Decode method to support protos using a jsonpb.Unmarshaler.

type Delimited Uses

type Delimited interface {
    // Delimiter returns the record seperator for the stream.
    Delimiter() []byte
}

Delimited defines the streaming delimiter.

type Encoder Uses

type Encoder interface {
    Encode(v interface{}) error
}

Encoder encodes gRPC payloads / fields into byte sequence.

type EncoderFunc Uses

type EncoderFunc func(v interface{}) error

EncoderFunc adapts an encoder function into Encoder

func (EncoderFunc) Encode Uses

func (f EncoderFunc) Encode(v interface{}) error

Encode delegates invocations to the underlying function itself.

type HTTPBodyMarshaler Uses

type HTTPBodyMarshaler struct {
    Marshaler
}

HTTPBodyMarshaler is a Marshaler which supports marshaling of a google.api.HttpBody message as the full response body if it is the actual message used as the response. If not, then this will simply fallback to the Marshaler specified as its default Marshaler.

func (*HTTPBodyMarshaler) ContentType Uses

func (h *HTTPBodyMarshaler) ContentType() string

ContentType implementation to keep backwards compatability with marshal interface

func (*HTTPBodyMarshaler) ContentTypeFromMessage Uses

func (h *HTTPBodyMarshaler) ContentTypeFromMessage(v interface{}) string

ContentTypeFromMessage in case v is a google.api.HttpBody message it returns its specified content type otherwise fall back to the default Marshaler.

func (*HTTPBodyMarshaler) Marshal Uses

func (h *HTTPBodyMarshaler) Marshal(v interface{}) ([]byte, error)

Marshal marshals "v" by returning the body bytes if v is a google.api.HttpBody message, otherwise it falls back to the default Marshaler.

type HandlerFunc Uses

type HandlerFunc func(w http.ResponseWriter, r *http.Request, pathParams map[string]string)

A HandlerFunc handles a specific pair of path pattern and HTTP method.

type HeaderMatcherFunc Uses

type HeaderMatcherFunc func(string) (string, bool)

HeaderMatcherFunc checks whether a header key should be forwarded to/from gRPC context.

type JSONBuiltin Uses

type JSONBuiltin struct{}

JSONBuiltin is a Marshaler which marshals/unmarshals into/from JSON with the standard "encoding/json" package of Golang. Although it is generally faster for simple proto messages than JSONPb, it does not support advanced features of protobuf, e.g. map, oneof, ....

The NewEncoder and NewDecoder types return *json.Encoder and *json.Decoder respectively.

func (*JSONBuiltin) ContentType Uses

func (*JSONBuiltin) ContentType() string

ContentType always Returns "application/json".

func (*JSONBuiltin) Delimiter Uses

func (j *JSONBuiltin) Delimiter() []byte

Delimiter for newline encoded JSON streams.

func (*JSONBuiltin) Marshal Uses

func (j *JSONBuiltin) Marshal(v interface{}) ([]byte, error)

Marshal marshals "v" into JSON

func (*JSONBuiltin) NewDecoder Uses

func (j *JSONBuiltin) NewDecoder(r io.Reader) Decoder

NewDecoder returns a Decoder which reads JSON stream from "r".

func (*JSONBuiltin) NewEncoder Uses

func (j *JSONBuiltin) NewEncoder(w io.Writer) Encoder

NewEncoder returns an Encoder which writes JSON stream into "w".

func (*JSONBuiltin) Unmarshal Uses

func (j *JSONBuiltin) Unmarshal(data []byte, v interface{}) error

Unmarshal unmarshals JSON data into "v".

type JSONPb Uses

type JSONPb jsonpb.Marshaler

JSONPb is a Marshaler which marshals/unmarshals into/from JSON with the "github.com/golang/protobuf/jsonpb". It supports fully functionality of protobuf unlike JSONBuiltin.

The NewDecoder method returns a DecoderWrapper, so the underlying *json.Decoder methods can be used.

func (*JSONPb) ContentType Uses

func (*JSONPb) ContentType() string

ContentType always returns "application/json".

func (*JSONPb) Delimiter Uses

func (j *JSONPb) Delimiter() []byte

Delimiter for newline encoded JSON streams.

func (*JSONPb) Marshal Uses

func (j *JSONPb) Marshal(v interface{}) ([]byte, error)

Marshal marshals "v" into JSON.

func (*JSONPb) NewDecoder Uses

func (j *JSONPb) NewDecoder(r io.Reader) Decoder

NewDecoder returns a Decoder which reads JSON stream from "r".

func (*JSONPb) NewEncoder Uses

func (j *JSONPb) NewEncoder(w io.Writer) Encoder

NewEncoder returns an Encoder which writes JSON stream into "w".

func (*JSONPb) Unmarshal Uses

func (j *JSONPb) Unmarshal(data []byte, v interface{}) error

Unmarshal unmarshals JSON "data" into "v"

type Marshaler Uses

type Marshaler interface {
    // Marshal marshals "v" into byte sequence.
    Marshal(v interface{}) ([]byte, error)
    // Unmarshal unmarshals "data" into "v".
    // "v" must be a pointer value.
    Unmarshal(data []byte, v interface{}) error
    // NewDecoder returns a Decoder which reads byte sequence from "r".
    NewDecoder(r io.Reader) Decoder
    // NewEncoder returns an Encoder which writes bytes sequence into "w".
    NewEncoder(w io.Writer) Encoder
    // ContentType returns the Content-Type which this marshaler is responsible for.
    ContentType() string
}

Marshaler defines a conversion between byte sequence and gRPC payloads / fields.

type Pattern Uses

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

Pattern is a template pattern of http request paths defined in github.com/googleapis/googleapis/google/api/http.proto.

func MustPattern Uses

func MustPattern(p Pattern, err error) Pattern

MustPattern is a helper function which makes it easier to call NewPattern in variable initialization.

func NewPattern Uses

func NewPattern(version int, ops []int, pool []string, verb string, opts ...PatternOpt) (Pattern, error)

NewPattern returns a new Pattern from the given definition values. "ops" is a sequence of op codes. "pool" is a constant pool. "verb" is the verb part of the pattern. It is empty if the pattern does not have the part. "version" must be 1 for now. It returns an error if the given definition is invalid.

func (Pattern) Match Uses

func (p Pattern) Match(components []string, verb string) (map[string]string, error)

Match examines components if it matches to the Pattern. If it matches, the function returns a mapping from field paths to their captured values. If otherwise, the function returns an error.

func (Pattern) String Uses

func (p Pattern) String() string

func (Pattern) Verb Uses

func (p Pattern) Verb() string

Verb returns the verb part of the Pattern.

type PatternOpt Uses

type PatternOpt func(*patternOptions)

PatternOpt is an option for creating Patterns.

func AssumeColonVerbOpt Uses

func AssumeColonVerbOpt(val bool) PatternOpt

AssumeColonVerbOpt indicates whether a path suffix after a final colon may only be interpreted as a verb.

type ProtoErrorHandlerFunc Uses

type ProtoErrorHandlerFunc func(context.Context, *ServeMux, Marshaler, http.ResponseWriter, *http.Request, error)

ProtoErrorHandlerFunc handles the error as a gRPC error generated via status package and replies to the request.

type ProtoMarshaller Uses

type ProtoMarshaller struct{}

ProtoMarshaller is a Marshaller which marshals/unmarshals into/from serialize proto bytes

func (*ProtoMarshaller) ContentType Uses

func (*ProtoMarshaller) ContentType() string

ContentType always returns "application/octet-stream".

func (*ProtoMarshaller) Marshal Uses

func (*ProtoMarshaller) Marshal(value interface{}) ([]byte, error)

Marshal marshals "value" into Proto

func (*ProtoMarshaller) NewDecoder Uses

func (marshaller *ProtoMarshaller) NewDecoder(reader io.Reader) Decoder

NewDecoder returns a Decoder which reads proto stream from "reader".

func (*ProtoMarshaller) NewEncoder Uses

func (marshaller *ProtoMarshaller) NewEncoder(writer io.Writer) Encoder

NewEncoder returns an Encoder which writes proto stream into "writer".

func (*ProtoMarshaller) Unmarshal Uses

func (*ProtoMarshaller) Unmarshal(data []byte, value interface{}) error

Unmarshal unmarshals proto "data" into "value"

type ServeMux Uses

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

ServeMux is a request multiplexer for grpc-gateway. It matches http requests to patterns and invokes the corresponding handler.

func NewServeMux Uses

func NewServeMux(opts ...ServeMuxOption) *ServeMux

NewServeMux returns a new ServeMux whose internal mapping is empty.

func (*ServeMux) GetForwardResponseOptions Uses

func (s *ServeMux) GetForwardResponseOptions() []func(context.Context, http.ResponseWriter, proto.Message) error

GetForwardResponseOptions returns the ForwardResponseOptions associated with this ServeMux.

func (*ServeMux) Handle Uses

func (s *ServeMux) Handle(meth string, pat Pattern, h HandlerFunc)

Handle associates "h" to the pair of HTTP method and path pattern.

func (*ServeMux) ServeHTTP Uses

func (s *ServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP dispatches the request to the first handler whose pattern matches to r.Method and r.Path.

type ServeMuxOption Uses

type ServeMuxOption func(*ServeMux)

ServeMuxOption is an option that can be given to a ServeMux on construction.

func WithDisablePathLengthFallback Uses

func WithDisablePathLengthFallback() ServeMuxOption

WithDisablePathLengthFallback returns a ServeMuxOption for disable path length fallback.

func WithForwardResponseOption Uses

func WithForwardResponseOption(forwardResponseOption func(context.Context, http.ResponseWriter, proto.Message) error) ServeMuxOption

WithForwardResponseOption returns a ServeMuxOption representing the forwardResponseOption.

forwardResponseOption is an option that will be called on the relevant context.Context, http.ResponseWriter, and proto.Message before every forwarded response.

The message may be nil in the case where just a header is being sent.

func WithIncomingHeaderMatcher Uses

func WithIncomingHeaderMatcher(fn HeaderMatcherFunc) ServeMuxOption

WithIncomingHeaderMatcher returns a ServeMuxOption representing a headerMatcher for incoming request to gateway.

This matcher will be called with each header in http.Request. If matcher returns true, that header will be passed to gRPC context. To transform the header before passing to gRPC context, matcher should return modified header.

func WithLastMatchWins Uses

func WithLastMatchWins() ServeMuxOption

WithLastMatchWins returns a ServeMuxOption that will enable "last match wins" behavior, where if multiple path patterns match a request path, the last one defined in the .proto file will be used.

func WithMarshalerOption Uses

func WithMarshalerOption(mime string, marshaler Marshaler) ServeMuxOption

WithMarshalerOption returns a ServeMuxOption which associates inbound and outbound Marshalers to a MIME type in mux.

func WithMetadata Uses

func WithMetadata(annotator func(context.Context, *http.Request) metadata.MD) ServeMuxOption

WithMetadata returns a ServeMuxOption for passing metadata to a gRPC context.

This can be used by services that need to read from http.Request and modify gRPC context. A common use case is reading token from cookie and adding it in gRPC context.

func WithOutgoingHeaderMatcher Uses

func WithOutgoingHeaderMatcher(fn HeaderMatcherFunc) ServeMuxOption

WithOutgoingHeaderMatcher returns a ServeMuxOption representing a headerMatcher for outgoing response from gateway.

This matcher will be called with each header in response header metadata. If matcher returns true, that header will be passed to http response returned from gateway. To transform the header before passing to response, matcher should return modified header.

func WithProtoErrorHandler Uses

func WithProtoErrorHandler(fn ProtoErrorHandlerFunc) ServeMuxOption

WithProtoErrorHandler returns a ServeMuxOption for passing metadata to a gRPC context.

This can be used to handle an error as general proto message defined by gRPC. The response including body and status is not backward compatible with the default error handler. When this option is used, HTTPError and OtherErrorHandler are overwritten on initialization.

func WithStreamErrorHandler Uses

func WithStreamErrorHandler(fn StreamErrorHandlerFunc) ServeMuxOption

WithStreamErrorHandler returns a ServeMuxOption that will use the given custom stream error handler, which allows for customizing the error trailer for server-streaming calls.

For stream errors that occur before any response has been written, the mux's ProtoErrorHandler will be invoked. However, once data has been written, the errors must be handled differently: they must be included in the response body. The response body's final message will include the error details returned by the stream error handler.

type ServerMetadata Uses

type ServerMetadata struct {
    HeaderMD  metadata.MD
    TrailerMD metadata.MD
}

ServerMetadata consists of metadata sent from gRPC server.

func ServerMetadataFromContext Uses

func ServerMetadataFromContext(ctx context.Context) (md ServerMetadata, ok bool)

ServerMetadataFromContext returns the ServerMetadata in ctx

type StreamError Uses

type StreamError internal.StreamError

StreamError is the payload for the final message in a server stream in the event that the server returns an error after a response message has already been sent.

func DefaultHTTPStreamErrorHandler Uses

func DefaultHTTPStreamErrorHandler(_ context.Context, err error) *StreamError

DefaultHTTPStreamErrorHandler converts the given err into a *StreamError via default logic.

It extracts the gRPC status from err if possible. The fields of the status are used to populate the returned StreamError, and the HTTP status code is derived from the gRPC code via HTTPStatusFromCode. If the given err does not contain a gRPC status, an "Unknown" gRPC code is used and "Internal Server Error" HTTP code.

type StreamErrorHandlerFunc Uses

type StreamErrorHandlerFunc func(context.Context, error) *StreamError

StreamErrorHandlerFunc accepts an error as a gRPC error generated via status package and translates it into a a proto struct used to represent error at the end of a stream.

Package runtime imports 33 packages (graph) and is imported by 1028 packages. Updated 2019-09-30. Refresh now. Tools for package owners.