tunnelpb

package
v0.3.0 Latest Latest
Warning

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

 Go to latest Published: Oct 23, 2023 License: Apache-2.0 Imports: 10 Imported by: 3

Documentation

Overview

Package tunnelpb contains generated code corresponding to the Protocol Buffer definition of the tunneling protocol.

Index

Constants

View Source 
const (
	TunnelService_OpenTunnel_FullMethodName        = "/grpctunnel.v1.TunnelService/OpenTunnel"
	TunnelService_OpenReverseTunnel_FullMethodName = "/grpctunnel.v1.TunnelService/OpenReverseTunnel"
)

Variables

View Source 
var (
	ProtocolRevision_name = map[int32]string{
		0: "REVISION_ZERO",
		1: "REVISION_ONE",
	}
	ProtocolRevision_value = map[string]int32{
		"REVISION_ZERO": 0,
		"REVISION_ONE":  1,
	}
)

Enum value maps for ProtocolRevision.

View Source 
var File_grpctunnel_v1_tunnel_proto protoreflect.FileDescriptor
View Source 
var TunnelService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpctunnel.v1.TunnelService",
	HandlerType: (*TunnelServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "OpenTunnel",
			Handler:       _TunnelService_OpenTunnel_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "OpenReverseTunnel",
			Handler:       _TunnelService_OpenReverseTunnel_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "grpctunnel/v1/tunnel.proto",
}

TunnelService_ServiceDesc is the grpc.ServiceDesc for TunnelService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterTunnelServiceServer 

func RegisterTunnelServiceServer(s grpc.ServiceRegistrar, srv TunnelServiceServer)

Types

type ClientToServer 

type ClientToServer struct {

	// The ID of the stream. Stream IDs must be used in increasing order and
	// cannot be re-used. Unlike in the HTTP/2 protocol, the stream ID is 64-bit
	// so overflow in a long-lived channel is excessively unlikely. (If the
	// channel were used for a new stream every nanosecond, it would take close
	// to 300 years to exhaust every ID and reach an overflow situation.)
	StreamId int64 `protobuf:"varint,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
	// Types that are assignable to Frame:
	//
	//	*ClientToServer_NewStream
	//	*ClientToServer_RequestMessage
	//	*ClientToServer_MoreRequestData
	//	*ClientToServer_HalfClose
	//	*ClientToServer_Cancel
	//	*ClientToServer_WindowUpdate
	Frame isClientToServer_Frame `protobuf_oneof:"frame"`
	// contains filtered or unexported fields
}

ClientToServer is the message a client sends to a server.

For a single stream ID, the first such message must include the new_stream field. After that, there can be any number of requests sent, via the request_message field and additional messages thereafter that use the more_request_data field (for requests that are larger than 16kb). And finally, the RPC ends with either the half_close or cancel fields. If the half_close field is used, the RPC stream remains active so the server may continue to send response data. But, if the cancel field is used, the RPC stream is aborted and thus closed on both client and server ends. If a stream has been half-closed, the only allowed message from the client for that stream ID is one with the cancel field, to abort the remainder of the operation.

func (*ClientToServer) Descriptor deprecated 

func (*ClientToServer) Descriptor() ([]byte, []int)

Deprecated: Use ClientToServer.ProtoReflect.Descriptor instead.

func (*ClientToServer) GetCancel 

func (x *ClientToServer) GetCancel() *emptypb.Empty

func (*ClientToServer) GetFrame 

func (m *ClientToServer) GetFrame() isClientToServer_Frame

func (*ClientToServer) GetHalfClose 

func (x *ClientToServer) GetHalfClose() *emptypb.Empty

func (*ClientToServer) GetMoreRequestData 

func (x *ClientToServer) GetMoreRequestData() []byte

func (*ClientToServer) GetNewStream 

func (x *ClientToServer) GetNewStream() *NewStream

func (*ClientToServer) GetRequestMessage 

func (x *ClientToServer) GetRequestMessage() *MessageData

func (*ClientToServer) GetStreamId 

func (x *ClientToServer) GetStreamId() int64

func (*ClientToServer) GetWindowUpdate added in v0.3.0 

func (x *ClientToServer) GetWindowUpdate() uint32

func (*ClientToServer) ProtoMessage 

func (*ClientToServer) ProtoMessage()

func (*ClientToServer) ProtoReflect 

func (x *ClientToServer) ProtoReflect() protoreflect.Message

func (*ClientToServer) Reset 

func (x *ClientToServer) Reset()

func (*ClientToServer) String 

func (x *ClientToServer) String() string

type ClientToServerFrame 

type ClientToServerFrame = isClientToServer_Frame

ClientToServerFrame is the type that is assignable to ClientToServer.Frame.

type ClientToServer_Cancel 

type ClientToServer_Cancel struct {
	// Aborts the stream. No other messages should be sent for this stream
	// (unless the ID is being re-used after the stream is terminated on the
	// server side).
	Cancel *emptypb.Empty `protobuf:"bytes,6,opt,name=cancel,proto3,oneof"`
}

type ClientToServer_HalfClose 

type ClientToServer_HalfClose struct {
	// Half-closes the stream, signaling that no more request messages will
	// be sent. No other messages, other than one with the cancel field set,
	// should be sent for this stream (at least not until it is terminated
	// by the server, after which the ID can be re-used).
	HalfClose *emptypb.Empty `protobuf:"bytes,5,opt,name=half_close,json=halfClose,proto3,oneof"`
}

type ClientToServer_MoreRequestData 

type ClientToServer_MoreRequestData struct {
	// Sends a chunk of request data, for a request message that could not
	// wholly fit in a request_message field (e.g. > 16kb).
	MoreRequestData []byte `protobuf:"bytes,4,opt,name=more_request_data,json=moreRequestData,proto3,oneof"`
}

type ClientToServer_NewStream 

type ClientToServer_NewStream struct {
	// Creates a new RPC stream, which includes request header metadata. The
	// stream ID must be greater than all previously-used stream IDs for this
	// tunnel. It is expected to start at zero for the first stream on the
	// tunnel and then one for the next, and so on.
	NewStream *NewStream `protobuf:"bytes,2,opt,name=new_stream,json=newStream,proto3,oneof"`
}

type ClientToServer_RequestMessage 

type ClientToServer_RequestMessage struct {
	// Sends a message on the RPC stream. If the message is larger than 16k,
	// the rest of the message should be sent in chunks using the
	// more_request_data field (up to 16kb of data in each chunk).
	RequestMessage *MessageData `protobuf:"bytes,3,opt,name=request_message,json=requestMessage,proto3,oneof"`
}

type ClientToServer_WindowUpdate added in v0.3.0 

type ClientToServer_WindowUpdate struct {
	// Lets the peer know that data has been consumed, so it may be able
	// to send more data, based on flow control window sizes. This is only
	// used in revision one of the protocol.
	WindowUpdate uint32 `protobuf:"varint,7,opt,name=window_update,json=windowUpdate,proto3,oneof"`
}

type CloseStream 

type CloseStream struct {
	ResponseTrailers *Metadata      `protobuf:"bytes,1,opt,name=response_trailers,json=responseTrailers,proto3" json:"response_trailers,omitempty"`
	Status           *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*CloseStream) Descriptor deprecated 

func (*CloseStream) Descriptor() ([]byte, []int)

Deprecated: Use CloseStream.ProtoReflect.Descriptor instead.

func (*CloseStream) GetResponseTrailers 

func (x *CloseStream) GetResponseTrailers() *Metadata

func (*CloseStream) GetStatus 

func (x *CloseStream) GetStatus() *status.Status

func (*CloseStream) ProtoMessage 

func (*CloseStream) ProtoMessage()

func (*CloseStream) ProtoReflect 

func (x *CloseStream) ProtoReflect() protoreflect.Message

func (*CloseStream) Reset 

func (x *CloseStream) Reset()

func (*CloseStream) String 

func (x *CloseStream) String() string

type MessageData 

type MessageData struct {

	// The full size of the message.
	Size uint32 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	// The message data. This field should not be longer than 16kb (16,384
	// bytes). If the full size of the message is larger then it should be
	// split into multiple chunks. The chunking is done to allow multiple
	// access to the underlying gRPC stream by concurrent tunneled streams.
	// If very large messages were sent via a single chunk, it could cause
	// head-of-line blocking and starvation when multiple streams need to send
	// data on the one underlying gRPC stream.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

func (*MessageData) Descriptor deprecated 

func (*MessageData) Descriptor() ([]byte, []int)

Deprecated: Use MessageData.ProtoReflect.Descriptor instead.

func (*MessageData) GetData 

func (x *MessageData) GetData() []byte

func (*MessageData) GetSize 

func (x *MessageData) GetSize() uint32

func (*MessageData) ProtoMessage 

func (*MessageData) ProtoMessage()

func (*MessageData) ProtoReflect 

func (x *MessageData) ProtoReflect() protoreflect.Message

func (*MessageData) Reset 

func (x *MessageData) Reset()

func (*MessageData) String 

func (x *MessageData) String() string

type Metadata 

type Metadata struct {
	Md map[string]*Metadata_Values `` /* 145-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*Metadata) Descriptor deprecated 

func (*Metadata) Descriptor() ([]byte, []int)

Deprecated: Use Metadata.ProtoReflect.Descriptor instead.

func (*Metadata) GetMd 

func (x *Metadata) GetMd() map[string]*Metadata_Values

func (*Metadata) ProtoMessage 

func (*Metadata) ProtoMessage()

func (*Metadata) ProtoReflect 

func (x *Metadata) ProtoReflect() protoreflect.Message

func (*Metadata) Reset 

func (x *Metadata) Reset()

func (*Metadata) String 

func (x *Metadata) String() string

type Metadata_Values 

type Metadata_Values struct {
	Val []string `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty"`
	// contains filtered or unexported fields
}

func (*Metadata_Values) Descriptor deprecated 

func (*Metadata_Values) Descriptor() ([]byte, []int)

Deprecated: Use Metadata_Values.ProtoReflect.Descriptor instead.

func (*Metadata_Values) GetVal 

func (x *Metadata_Values) GetVal() []string

func (*Metadata_Values) ProtoMessage 

func (*Metadata_Values) ProtoMessage()

func (*Metadata_Values) ProtoReflect 

func (x *Metadata_Values) ProtoReflect() protoreflect.Message

func (*Metadata_Values) Reset 

func (x *Metadata_Values) Reset()

func (*Metadata_Values) String 

func (x *Metadata_Values) String() string

type NewStream 

type NewStream struct {

	// The name of the method being invoked.
	MethodName string `protobuf:"bytes,1,opt,name=method_name,json=methodName,proto3" json:"method_name,omitempty"`
	// Header metadata for this request.
	RequestHeaders *Metadata `protobuf:"bytes,2,opt,name=request_headers,json=requestHeaders,proto3" json:"request_headers,omitempty"`
	// The client's initial window size, for receiving data from the
	// server. This will be zero if protocol_revision is zero.
	InitialWindowSize uint32 `protobuf:"varint,3,opt,name=initial_window_size,json=initialWindowSize,proto3" json:"initial_window_size,omitempty"`
	// The protocol revision that the client will use for this stream.
	// If this revision is not supported by the server, the server will
	// immediately close the stream with an error code.
	ProtocolRevision ProtocolRevision `` // TODO: codec/compressor options?
	/* 146-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*NewStream) Descriptor deprecated 

func (*NewStream) Descriptor() ([]byte, []int)

Deprecated: Use NewStream.ProtoReflect.Descriptor instead.

func (*NewStream) GetInitialWindowSize added in v0.3.0 

func (x *NewStream) GetInitialWindowSize() uint32

func (*NewStream) GetMethodName 

func (x *NewStream) GetMethodName() string

func (*NewStream) GetProtocolRevision added in v0.3.0 

func (x *NewStream) GetProtocolRevision() ProtocolRevision

func (*NewStream) GetRequestHeaders 

func (x *NewStream) GetRequestHeaders() *Metadata

func (*NewStream) ProtoMessage 

func (*NewStream) ProtoMessage()

func (*NewStream) ProtoReflect 

func (x *NewStream) ProtoReflect() protoreflect.Message

func (*NewStream) Reset 

func (x *NewStream) Reset()

func (*NewStream) String 

func (x *NewStream) String() string

type ProtocolRevision added in v0.3.0 

type ProtocolRevision int32
const (
	// Indicates revision zero. This revision of the protocol did not support
	// server settings messages or window update messages. Flow control was not
	// enforced. This version of the protocol did not even know about protocol
	// revisions, so by default any ProtocolRevision field will be absent (and
	// thus default to REVISION_ZERO). A server can identify a revision zero client
	// because it will not send a "grpctunnel-negotiate" request header, and thus
	// the server knows to not send a settings message and to not use flow control.
	// A client can identify a revision zero server because it will not send a
	// "grpctunnel-negotiate" response header, and thus the client knows not to
	// expect a settings message and to not use flow control.
	ProtocolRevision_REVISION_ZERO ProtocolRevision = 0
	// Indicates revision one, which requires server-supplied settings before the
	// tunnel can be used and also supports flow control. This flow control support
	// eliminates chances of deadlock in streaming-heavy tunnel usage.
	//
	// This value will be provided via messages on the tunnel, even though it is
	// technically redundant with the use of the "grpctunnel-negotiation" header.
	// It will be used in the future to distinguish between this protocol revision
	// and later protocol revisions.
	ProtocolRevision_REVISION_ONE ProtocolRevision = 1
)

func (ProtocolRevision) Descriptor added in v0.3.0 

func (ProtocolRevision) Descriptor() protoreflect.EnumDescriptor

func (ProtocolRevision) Enum added in v0.3.0 

func (x ProtocolRevision) Enum() *ProtocolRevision

func (ProtocolRevision) EnumDescriptor deprecated added in v0.3.0 

func (ProtocolRevision) EnumDescriptor() ([]byte, []int)

Deprecated: Use ProtocolRevision.Descriptor instead.

func (ProtocolRevision) Number added in v0.3.0 

func (x ProtocolRevision) Number() protoreflect.EnumNumber

func (ProtocolRevision) String added in v0.3.0 

func (x ProtocolRevision) String() string

func (ProtocolRevision) Type added in v0.3.0 

func (ProtocolRevision) Type() protoreflect.EnumType

type ServerToClient 

type ServerToClient struct {

	// The ID of the stream. Stream IDs are defined by the client and should be
	// used in monotonically increasing order. They cannot be re-used. Unlike
	// HTTP/2, the ID is 64-bit, so overflow/re-use should not be an issue. (If
	// the channel were used for a new stream every nanosecond, it would take
	// close to 300 years to exhaust every ID and reach an overflow situation.)
	//
	// The stream ID will be -1 for messages that do not correspond to a single
	// stream, but to the whole tunnel. Currently, only a Settings message will
	// be sent this way.
	StreamId int64 `protobuf:"varint,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
	// Types that are assignable to Frame:
	//
	//	*ServerToClient_Settings
	//	*ServerToClient_ResponseHeaders
	//	*ServerToClient_ResponseMessage
	//	*ServerToClient_MoreResponseData
	//	*ServerToClient_CloseStream
	//	*ServerToClient_WindowUpdate
	Frame isServerToClient_Frame `protobuf_oneof:"frame"`
	// contains filtered or unexported fields
}

ServerToClient is the message a server sends to a client.

For a single stream ID, the first such message should include the response_headers field unless no headers are to be sent. After the headers, the server can send any number of responses, via the response_message field and additional messages thereafter that use the more_response_data field (for responses that are larger than 16kb). A message with the close_stream field concludes the stream, whether it terminates successfully or with an error.

func (*ServerToClient) Descriptor deprecated 

func (*ServerToClient) Descriptor() ([]byte, []int)

Deprecated: Use ServerToClient.ProtoReflect.Descriptor instead.

func (*ServerToClient) GetCloseStream 

func (x *ServerToClient) GetCloseStream() *CloseStream

func (*ServerToClient) GetFrame 

func (m *ServerToClient) GetFrame() isServerToClient_Frame

func (*ServerToClient) GetMoreResponseData 

func (x *ServerToClient) GetMoreResponseData() []byte

func (*ServerToClient) GetResponseHeaders 

func (x *ServerToClient) GetResponseHeaders() *Metadata

func (*ServerToClient) GetResponseMessage 

func (x *ServerToClient) GetResponseMessage() *MessageData

func (*ServerToClient) GetSettings added in v0.3.0 

func (x *ServerToClient) GetSettings() *Settings

func (*ServerToClient) GetStreamId 

func (x *ServerToClient) GetStreamId() int64

func (*ServerToClient) GetWindowUpdate added in v0.3.0 

func (x *ServerToClient) GetWindowUpdate() uint32

func (*ServerToClient) ProtoMessage 

func (*ServerToClient) ProtoMessage()

func (*ServerToClient) ProtoReflect 

func (x *ServerToClient) ProtoReflect() protoreflect.Message

func (*ServerToClient) Reset 

func (x *ServerToClient) Reset()

func (*ServerToClient) String 

func (x *ServerToClient) String() string

type ServerToClientFrame 

type ServerToClientFrame = isServerToClient_Frame

ServerToClientFrame is the type that is assignable to ServerToClient.Frame.

type ServerToClient_CloseStream 

type ServerToClient_CloseStream struct {
	// Terminates the stream and communicates the final disposition to the
	// client. After the stream is closed, no other messages should use the
	// given stream ID until the ID is re-used (e.g. a NewStream message is
	// received that creates another stream with the same ID).
	CloseStream *CloseStream `protobuf:"bytes,5,opt,name=close_stream,json=closeStream,proto3,oneof"`
}

type ServerToClient_MoreResponseData 

type ServerToClient_MoreResponseData struct {
	// Sends a chunk of response data, for a response message that could not
	// wholly fit in a response_message field (e.g. > 16kb).
	MoreResponseData []byte `protobuf:"bytes,4,opt,name=more_response_data,json=moreResponseData,proto3,oneof"`
}

type ServerToClient_ResponseHeaders 

type ServerToClient_ResponseHeaders struct {
	// Sends response headers for this stream. If headers are sent at all,
	// they must be sent before any response message data.
	ResponseHeaders *Metadata `protobuf:"bytes,2,opt,name=response_headers,json=responseHeaders,proto3,oneof"`
}

type ServerToClient_ResponseMessage 

type ServerToClient_ResponseMessage struct {
	// Sends a message on the RPC stream. If the message is larger than 16k,
	// the rest of the message should be sent in chunks using the
	// more_response_data field (up to 16kb of data in each chunk).
	ResponseMessage *MessageData `protobuf:"bytes,3,opt,name=response_message,json=responseMessage,proto3,oneof"`
}

type ServerToClient_Settings added in v0.3.0 

type ServerToClient_Settings struct {
	// This is the very first message sent on a response stream. The tunnel
	// client should await this before sending any data as it will contain
	// information about the server's initial flow control window size for
	// each new stream. This is only used in revision one of the protocol.
	// A client that needs to interact with an older server (i.e. revision
	// zero) must examine header metadata to decide if it should expect a
	// settings message. Similarly, a server must examine header metadata to
	// decide if it should send a settings message.
	Settings *Settings `protobuf:"bytes,6,opt,name=settings,proto3,oneof"`
}

type ServerToClient_WindowUpdate added in v0.3.0 

type ServerToClient_WindowUpdate struct {
	// Lets the peer know that data has been consumed, so it may be able
	// to send more data, based on flow control window sizes.
	WindowUpdate uint32 `protobuf:"varint,7,opt,name=window_update,json=windowUpdate,proto3,oneof"`
}

type Settings added in v0.3.0 

type Settings struct {

	// The set of protocol revisions that this server supports. If the
	// client does not support any of them, it must hang up. This should
	// never be empty, but if that is observed, the client should assume
	// the server only supports revision zero.
	SupportedProtocolRevisions []ProtocolRevision `` /* 185-byte string literal not displayed */
	// The server's initial window size for all newly created streams.
	// When a new stream is created, this is the flow control window for
	// sending data to the server. The client indicates its own initial
	// window size, for receiving data from the server, in the NewStream
	// message.
	//
	// This value will be zero if the only supported protocol revision
	// is zero.
	InitialWindowSize uint32 `protobuf:"varint,2,opt,name=initial_window_size,json=initialWindowSize,proto3" json:"initial_window_size,omitempty"`
	// contains filtered or unexported fields
}

func (*Settings) Descriptor deprecated added in v0.3.0 

func (*Settings) Descriptor() ([]byte, []int)

Deprecated: Use Settings.ProtoReflect.Descriptor instead.

func (*Settings) GetInitialWindowSize added in v0.3.0 

func (x *Settings) GetInitialWindowSize() uint32

func (*Settings) GetSupportedProtocolRevisions added in v0.3.0 

func (x *Settings) GetSupportedProtocolRevisions() []ProtocolRevision

func (*Settings) ProtoMessage added in v0.3.0 

func (*Settings) ProtoMessage()

func (*Settings) ProtoReflect added in v0.3.0 

func (x *Settings) ProtoReflect() protoreflect.Message

func (*Settings) Reset added in v0.3.0 

func (x *Settings) Reset()

func (*Settings) String added in v0.3.0 

func (x *Settings) String() string

type TunnelServiceClient 

type TunnelServiceClient interface {
	// OpenTunnel creates a channel to the server which can be used to send
	// additional RPCs, all of which will be sent to the same server via a
	// single underlying gRPC stream. This can provide affinity for a "chatty"
	// sequence of calls, where the gRPC connection is load balanced (so there
	// may be multiple backend servers), but a particular "conversation" (which
	// may consist of numerous RPCs) needs to all go to a single server, for
	// consistency.
	OpenTunnel(ctx context.Context, opts ...grpc.CallOption) (TunnelService_OpenTunnelClient, error)
	// OpenReverseTunnel creates a "reverse" channel, which allows the server to
	// act as a client and send RPCs to the client that creates the tunnel. It
	// is in most respects identical to OpenTunnel except that the roles are
	// reversed: the server initiates RPCs and sends requests and the client
	// replies to them and sends responses.
	OpenReverseTunnel(ctx context.Context, opts ...grpc.CallOption) (TunnelService_OpenReverseTunnelClient, error)
}

TunnelServiceClient is the client API for TunnelService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewTunnelServiceClient 

func NewTunnelServiceClient(cc grpc.ClientConnInterface) TunnelServiceClient

type TunnelServiceServer 

type TunnelServiceServer interface {
	// OpenTunnel creates a channel to the server which can be used to send
	// additional RPCs, all of which will be sent to the same server via a
	// single underlying gRPC stream. This can provide affinity for a "chatty"
	// sequence of calls, where the gRPC connection is load balanced (so there
	// may be multiple backend servers), but a particular "conversation" (which
	// may consist of numerous RPCs) needs to all go to a single server, for
	// consistency.
	OpenTunnel(TunnelService_OpenTunnelServer) error
	// OpenReverseTunnel creates a "reverse" channel, which allows the server to
	// act as a client and send RPCs to the client that creates the tunnel. It
	// is in most respects identical to OpenTunnel except that the roles are
	// reversed: the server initiates RPCs and sends requests and the client
	// replies to them and sends responses.
	OpenReverseTunnel(TunnelService_OpenReverseTunnelServer) error
	// contains filtered or unexported methods
}

TunnelServiceServer is the server API for TunnelService service. All implementations must embed UnimplementedTunnelServiceServer for forward compatibility

type TunnelService_OpenReverseTunnelClient 

type TunnelService_OpenReverseTunnelClient interface {
	Send(*ServerToClient) error
	Recv() (*ClientToServer, error)
	grpc.ClientStream
}

type TunnelService_OpenReverseTunnelServer 

type TunnelService_OpenReverseTunnelServer interface {
	Send(*ClientToServer) error
	Recv() (*ServerToClient, error)
	grpc.ServerStream
}

type TunnelService_OpenTunnelClient 

type TunnelService_OpenTunnelClient interface {
	Send(*ClientToServer) error
	Recv() (*ServerToClient, error)
	grpc.ClientStream
}

type TunnelService_OpenTunnelServer 

type TunnelService_OpenTunnelServer interface {
	Send(*ServerToClient) error
	Recv() (*ClientToServer, error)
	grpc.ServerStream
}

type UnimplementedTunnelServiceServer 

type UnimplementedTunnelServiceServer struct {
}

UnimplementedTunnelServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedTunnelServiceServer) OpenReverseTunnel 

func (UnimplementedTunnelServiceServer) OpenReverseTunnel(TunnelService_OpenReverseTunnelServer) error

func (UnimplementedTunnelServiceServer) OpenTunnel 

func (UnimplementedTunnelServiceServer) OpenTunnel(TunnelService_OpenTunnelServer) error

type UnsafeTunnelServiceServer 

type UnsafeTunnelServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeTunnelServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to TunnelServiceServer will result in compilation errors.

Source Files

View all Source files

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.