grpcurl

package
v0.0.0-...-e9f0680 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 18, 2022 License: AGPL-3.0 Imports: 36 Imported by: 0

Documentation

Overview

Package grpcurl provides the core functionality exposed by the grpcurl command, for dynamically connecting to a server, using the reflection service to inspect the server, and invoking RPCs. The grpcurl command-line tool constructs a DescriptorSource, based on the command-line parameters, and supplies an InvocationEventHandler to supply request data (which can come from command-line args or the process's stdin) and to log the events (to the process's stdout).

Index

Constants

View Source 
const (
	FormatJSON = Format("json")
	FormatText = Format("text")
)

Variables

View Source 
var ErrReflectionNotSupported = errors.New("server does not support the reflection API")

ErrReflectionNotSupported is returned by DescriptorSource operations that rely on interacting with the reflection service when the source does not actually expose the reflection service. When this occurs, an alternate source (like file descriptor sets) must be used.

Functions

func Accessor 

func Accessor(filename string) (io.ReadCloser, error)

TODO: support custom

func AnyResolverFromDescriptorSource 

func AnyResolverFromDescriptorSource(source DescriptorSource) jsonpb.AnyResolver

AnyResolverFromDescriptorSource returns an AnyResolver that will search for types using the given descriptor source.

func AnyResolverFromDescriptorSourceWithFallback 

func AnyResolverFromDescriptorSourceWithFallback(source DescriptorSource) jsonpb.AnyResolver

AnyResolverFromDescriptorSourceWithFallback returns an AnyResolver that will search for types using the given descriptor source and then fallback to a special message if the type is not found. The fallback type will render to JSON with a "@type" property, just like an Any message, but also with a custom "@value" property that includes the binary encoded payload.

func BlockingDial 

func BlockingDial(ctx context.Context, network, address string, creds credentials.TransportCredentials, opts ...grpc.DialOption) (*grpc.ClientConn, error)

BlockingDial is a helper method to dial the given address, using optional TLS credentials, and blocking until the returned connection is ready. If the given credentials are nil, the connection will be insecure (plain-text).

func ClientTransportCredentials 

func ClientTransportCredentials(insecureSkipVerify bool, cacertFile, clientCertFile, clientKeyFile string) (credentials.TransportCredentials, error)

ClientTransportCredentials builds transport credentials for a gRPC client using the given properties. If cacertFile is blank, only standard trusted certs are used to verify the server certs. If clientCertFile is blank, the client will not use a client certificate. If clientCertFile is not blank then clientKeyFile must not be blank.

func EnsureExtensions 

func EnsureExtensions(source DescriptorSource, msg proto.Message) proto.Message

EnsureExtensions uses the given descriptor source to download extensions for the given message. It returns a copy of the given message, but as a dynamic message that knows about all extensions known to the given descriptor source.

func ExpandHeaders 

func ExpandHeaders(headers []string) ([]string, error)

ExpandHeaders expands environment variables contained in the header string. If no corresponding environment variable is found an error is returned. TODO: Add escaping for `${`

func GetAllFiles 

func GetAllFiles(source DescriptorSource) ([]*desc.FileDescriptor, error)

GetAllFiles uses the given descriptor source to return a list of file descriptors.

func GetDescriptorText 

func GetDescriptorText(dsc desc.Descriptor, _ DescriptorSource) (string, error)

GetDescriptorText returns a string representation of the given descriptor. This returns a snippet of proto source that describes the given element.

func InvokeRPC 

func InvokeRPC(ctx context.Context, source DescriptorSource, ch grpcdynamic.Channel, methodName string,
	headers []string, handler InvocationEventHandler, requestData RequestSupplier) error

InvokeRPC uses the given gRPC channel to invoke the given method. The given descriptor source is used to determine the type of method and the type of request and response message. The given headers are sent as request metadata. Methods on the given event handler are called as the invocation proceeds.

The given requestData function supplies the actual data to send. It should return io.EOF when there is no more request data. If the method being invoked is a unary or server-streaming RPC (e.g. exactly one request message) and there is no request data (e.g. the first invocation of the function returns io.EOF), then an empty request message is sent.

If the requestData function and the given event handler coordinate or share any state, they should be thread-safe. This is because the requestData function may be called from a different goroutine than the one invoking event callbacks. (This only happens for bi-directional streaming RPCs, where one goroutine sends request messages and another consumes the response messages).

func InvokeRpc deprecated 

func InvokeRpc(ctx context.Context, source DescriptorSource, cc *grpc.ClientConn, methodName string,
	headers []string, handler InvocationEventHandler, requestData RequestMessageSupplier) error

InvokeRpc uses the given gRPC connection to invoke the given method. This function is deprecated and will be removed in a future release. It just delegates to the similarly named InvokeRPC method, whose signature is only slightly different.

Deprecated: use InvokeRPC instead.

func ListMethods 

func ListMethods(source DescriptorSource, serviceName string) ([]string, error)

ListMethods uses the given descriptor source to return a sorted list of method names for the specified fully-qualified service name.

func ListServices 

func ListServices(source DescriptorSource) ([]string, error)

ListServices uses the given descriptor source to return a sorted list of fully-qualified service names.

func MakeTemplate 

func MakeTemplate(md *desc.MessageDescriptor) proto.Message

MakeTemplate returns a message instance for the given descriptor that is a suitable template for creating an instance of that message in JSON. In particular, it ensures that any repeated fields (which include map fields) are not empty, so they will render with a single element (to show the types and optionally nested fields). It also ensures that nested messages are not nil by setting them to a message that is also fleshed out as a template message.

func MetadataFromHeaders 

func MetadataFromHeaders(headers []string) metadata.MD

MetadataFromHeaders converts a list of header strings (each string in "Header-Name: Header-Value" form) into metadata. If a string has a header name without a value (e.g. does not contain a colon), the value is assumed to be blank. Binary headers (those whose names end in "-bin") should be base64-encoded. But if they cannot be base64-decoded, they will be assumed to be in raw form and used as is.

func MetadataToString 

func MetadataToString(md metadata.MD) string

MetadataToString returns a string representation of the given metadata, for displaying to users.

func PrintStatus 

func PrintStatus(w io.Writer, stat *status.Status, formatter Formatter)

PrintStatus prints details about the given status to the given writer. The given formatter is used to print any detail messages that may be included in the status. If the given status has a code of OK, "OK" is printed and that is all. Otherwise, "ERROR:" is printed along with a line showing the code, one showing the message string, and each detail message if any are present. The detail messages will be printed as proto text format or JSON, depending on the given formatter.

func RequestParserAndFormatter 

func RequestParserAndFormatter(format Format, descSource DescriptorSource, in io.Reader, opts FormatOptions) (RequestParser, Formatter, error)

RequestParserAndFormatter returns a request parser and formatter for the given format. The given descriptor source may be used for parsing message data (if needed by the format). It accepts a set of options. The field EmitJSONDefaultFields and IncludeTextSeparator are options for JSON and protobuf text formats, respectively. The AllowUnknownFields field is a JSON-only format flag. Requests will be parsed from the given in.

func RequestParserAndFormatterFor 

func RequestParserAndFormatterFor(format Format, descSource DescriptorSource, emitJSONDefaultFields, includeTextSeparator bool, in io.Reader) (RequestParser, Formatter, error)

RequestParserAndFormatterFor returns a request parser and formatter for the given format. The given descriptor source may be used for parsing message data (if needed by the format). The flags emitJSONDefaultFields and includeTextSeparator are options for JSON and protobuf text formats, respectively. Requests will be parsed from the given in. This function is deprecated. Please use RequestParserAndFormatter instead. DEPRECATED

func ServerTransportCredentials 

func ServerTransportCredentials(cacertFile, serverCertFile, serverKeyFile string, requireClientCerts bool) (credentials.TransportCredentials, error)

ServerTransportCredentials builds transport credentials for a gRPC server using the given properties. If cacertFile is blank, the server will not request client certs unless requireClientCerts is true. When requireClientCerts is false and cacertFile is not blank, the server will verify client certs when presented, but will not require client certs. The serverCertFile and serverKeyFile must both not be blank.

func WriteProtoset 

func WriteProtoset(out io.Writer, descSource DescriptorSource, symbols ...string) error

WriteProtoset will use the given descriptor source to resolve all of the given symbols and write a proto file descriptor set with their definitions to the given output. The output will include descriptors for all files in which the symbols are defined as well as their transitive dependencies.

Types

type DefaultEventHandler 

type DefaultEventHandler struct {
	Out       io.Writer
	Debug     io.Writer
	Formatter Formatter
	// 0 = default
	// 1 = verbose
	// 2 = very verbose
	VerbosityLevel int

	// NumResponses is the number of responses that have been received.
	NumResponses int
	// Status is the status that was received at the end of an RPC. It is
	// nil if the RPC is still in progress.
	Status *status.Status
}

DefaultEventHandler logs events to a writer. This is not thread-safe, but is safe for use with InvokeRPC as long as NumResponses and Status are not read until the call to InvokeRPC completes.

func NewDefaultEventHandler deprecated 

func NewDefaultEventHandler(out io.Writer, descSource DescriptorSource, formatter Formatter, verbose bool) *DefaultEventHandler

NewDefaultEventHandler returns an InvocationEventHandler that logs events to the given output. If verbose is true, all events are logged. Otherwise, only response messages are logged.

Deprecated: NewDefaultEventHandler exists for compatability. It doesn't allow fine control over the `VerbosityLevel` and provides only 0 and 1 options (which corresponds to the `verbose` argument). Use DefaultEventHandler{} initializer directly.

func (*DefaultEventHandler) OnReceiveHeaders 

func (h *DefaultEventHandler) OnReceiveHeaders(md metadata.MD)

func (*DefaultEventHandler) OnReceiveResponse 

func (h *DefaultEventHandler) OnReceiveResponse(resp proto.Message)

func (*DefaultEventHandler) OnReceiveTrailers 

func (h *DefaultEventHandler) OnReceiveTrailers(stat *status.Status, md metadata.MD)

func (*DefaultEventHandler) OnResolveMethod 

func (h *DefaultEventHandler) OnResolveMethod(md *desc.MethodDescriptor)

func (*DefaultEventHandler) OnSendHeaders 

func (h *DefaultEventHandler) OnSendHeaders(md metadata.MD)

type DescriptorSource 

type DescriptorSource interface {
	// ListServices returns a list of fully-qualified service names. It will be all services in a set of
	// descriptor files or the set of all services exposed by a gRPC server.
	ListServices() ([]string, error)
	// FindSymbol returns a descriptor for the given fully-qualified symbol name.
	FindSymbol(fullyQualifiedName string) (desc.Descriptor, error)
	// AllExtensionsForType returns all known extension fields that extend the given message type name.
	AllExtensionsForType(typeName string) ([]*desc.FieldDescriptor, error)
}

DescriptorSource is a source of protobuf descriptor information. It can be backed by a FileDescriptorSet proto (like a file generated by protoc) or a remote server that supports the reflection API.

func DescriptorSourceFromFileDescriptorSet 

func DescriptorSourceFromFileDescriptorSet(files *descpb.FileDescriptorSet) (DescriptorSource, error)

DescriptorSourceFromFileDescriptorSet creates a DescriptorSource that is backed by the FileDescriptorSet.

func DescriptorSourceFromFileDescriptors 

func DescriptorSourceFromFileDescriptors(files ...*desc.FileDescriptor) (DescriptorSource, error)

DescriptorSourceFromFileDescriptors creates a DescriptorSource that is backed by the given file descriptors

func DescriptorSourceFromProtoFiles 

func DescriptorSourceFromProtoFiles(importPaths []string, fileNames ...string) (DescriptorSource, error)

DescriptorSourceFromProtoFiles creates a DescriptorSource that is backed by the named files, whose contents are Protocol Buffer source files. The given importPaths are used to locate any imported files.

func DescriptorSourceFromProtoSets 

func DescriptorSourceFromProtoSets(fileNames ...string) (DescriptorSource, error)

DescriptorSourceFromProtoSets creates a DescriptorSource that is backed by the named files, whose contents are encoded FileDescriptorSet protos.

func DescriptorSourceFromServer 

func DescriptorSourceFromServer(_ context.Context, refClient *grpcreflect.Client) DescriptorSource

DescriptorSourceFromServer creates a DescriptorSource that uses the given gRPC reflection client to interrogate a server for descriptor information. If the server does not support the reflection API then the various DescriptorSource methods will return ErrReflectionNotSupported

type Format 

type Format string

type FormatOptions 

type FormatOptions struct {
	// EmitJSONDefaultFields flag, when true, includes empty/default values in the output.
	// FormatJSON only flag.
	EmitJSONDefaultFields bool

	// AllowUnknownFields is an option for the parser. When true,
	// it accepts input which includes unknown fields. These unknown fields
	// are skipped instead of returning an error.
	// FormatJSON only flag.
	AllowUnknownFields bool

	// IncludeTextSeparator is true then, when invoked to format multiple messages,
	// all messages after the first one will be prefixed with the
	// ASCII 'Record Separator' character (0x1E).
	// It might be useful when the output is piped to another grpcurl process.
	// FormatText only flag.
	IncludeTextSeparator bool
}

FormatOptions is a set of flags that are passed to a JSON or text formatter.

type Formatter 

type Formatter func(proto.Message) (string, error)

Formatter translates messages into string representations.

func NewJSONFormatter 

func NewJSONFormatter(emitDefaults bool, resolver jsonpb.AnyResolver) Formatter

NewJSONFormatter returns a formatter that returns JSON strings. The JSON will include empty/default values (instead of just omitted them) if emitDefaults is true. The given resolver is used to assist with encoding of google.protobuf.Any messages.

func NewTextFormatter 

func NewTextFormatter(includeSeparator bool) Formatter

NewTextFormatter returns a formatter that returns strings in the protobuf text format. If includeSeparator is true then, when invoked to format multiple messages, all messages after the first one will be prefixed with the ASCII 'Record Separator' character (0x1E).

type InvocationEventHandler 

type InvocationEventHandler interface {
	// OnResolveMethod is called with a descriptor of the method that is being invoked.
	OnResolveMethod(*desc.MethodDescriptor)
	// OnSendHeaders is called with the request metadata that is being sent.
	OnSendHeaders(metadata.MD)
	// OnReceiveHeaders is called when response headers have been received.
	OnReceiveHeaders(metadata.MD)
	// OnReceiveResponse is called for each response message received.
	OnReceiveResponse(proto.Message)
	// OnReceiveTrailers is called when response trailers and final RPC status have been received.
	OnReceiveTrailers(*status.Status, metadata.MD)
}

InvocationEventHandler is a bag of callbacks for handling events that occur in the course of invoking an RPC. The handler also provides request data that is sent. The callbacks are generally called in the order they are listed below.

type RequestMessageSupplier deprecated 

type RequestMessageSupplier func() ([]byte, error)

RequestMessageSupplier is a function that is called to retrieve request messages for a GRPC operation. This type is deprecated and will be removed in a future release.

Deprecated: This is only used with the deprecated InvokeRpc. Instead, use RequestSupplier with InvokeRPC.

type RequestParser 

type RequestParser interface {
	// Next parses input data into the given request message. If called after
	// input is exhausted, it returns io.EOF. If the caller re-uses the same
	// instance in multiple calls to Next, it should call msg.Reset() in between
	// each call.
	Next(msg proto.Message) error
	// NumRequests returns the number of messages that have been parsed and
	// returned by a call to Next.
	NumRequests() int
}

RequestParser processes input into messages.

func NewJSONRequestParser 

func NewJSONRequestParser(in io.Reader, resolver jsonpb.AnyResolver) RequestParser

NewJSONRequestParser returns a RequestParser that reads data in JSON format from the given reader. The given resolver is used to assist with decoding of google.protobuf.Any messages.

Input data that contains more than one message should just include all messages concatenated (though whitespace is necessary to separate some kinds of values in JSON).

If the given reader has no data, the returned parser will return io.EOF on the very first call.

func NewJSONRequestParserWithUnmarshaler 

func NewJSONRequestParserWithUnmarshaler(in io.Reader, unmarshaler jsonpb.Unmarshaler) RequestParser

NewJSONRequestParserWithUnmarshaler is like NewJSONRequestParser but accepts a protobuf jsonpb.Unmarshaler instead of jsonpb.AnyResolver.

func NewTextRequestParser 

func NewTextRequestParser(in io.Reader) RequestParser

NewTextRequestParser returns a RequestParser that reads data in the protobuf text format from the given reader.

Input data that contains more than one message should include an ASCII 'Record Separator' character (0x1E) between each message.

Empty text is a valid text format and represents an empty message. So if the given reader has no data, the returned parser will yield an empty message for the first call to Next and then return io.EOF thereafter. This also means that if the input data ends with a record separator, then a final empty message will be parsed *after* the separator.

type RequestSupplier 

type RequestSupplier func(proto.Message) error

RequestSupplier is a function that is called to populate messages for a gRPC operation. The function should populate the given message or return a non-nil error. If the supplier has no more messages, it should return io.EOF. When it returns io.EOF, it should not in any way modify the given message argument.

Source Files

View all Source files

Directories

Path Synopsis
ext
ggrpcurl
Command grpcurl makes gRPC requests (a la cURL, but HTTP/2).
 Command grpcurl makes gRPC requests (a la cURL, but HTTP/2).

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.