common

Documentation

Index

• Constants
• type Conn
  • func (c *Conn) Close() error
  • func (c *Conn) LocalAddr() net.Addr
  • func (c *Conn) Read(p []byte) (n int, err error)
  • func (c *Conn) RemoteAddr() net.Addr
  • func (c *Conn) SetDeadline(time.Time) error
  • func (c *Conn) SetReadDeadline(time.Time) error
  • func (c *Conn) SetWriteDeadline(time.Time) error
  • func (c *Conn) Write(p []byte) (int, error)
• type Decoder
  • func Decode(f func(proto.Message) *[]byte) Decoder
• type Encoder
  • func ChunkedEncoder(enc Encoder, size int) Encoder
  • func Encode(f func(proto.Message) *[]byte) Encoder

Constants

const (
	MaxMessageSize = 1 << 19
)

Types

type Conn

type Conn struct {
	// Stream is the stream to wrap into a Conn. This is duplex stream.
	Stream grpc.Stream

	// InMsg is the type to use for reading request data from the streaming
	// endpoint. This must be a non-nil allocated value and must NOT point to
	// the same value as OutMsg since they may be used concurrently.
	//
	// The Reset method will be called on InMsg during Reads so data you
	// set initially will be lost.
	InMsg proto.Message

	// OutMsg is the type to use for sending data to streaming endpoint. This must be
	// a non-nil allocated value and must NOT point to the same value as InMsg
	// since they may be used concurrently.
	//
	// The Reset method is never called on OutMsg so they will be sent for every request
	// unless the Encode field changes it.
	OutMsg proto.Message

	// WriteLock, if non-nil, will be locked while calling SendMsg
	// on the Stream. This can be used to prevent concurrent access to
	// SendMsg which is unsafe.
	WriteLock *sync.Mutex

	// Encode encodes messages into the Request. See Encoder for more information.
	Encode Encoder

	// Decode decodes messages from the Response into a byte slice. See
	// Decoder for more information.
	Decode Decoder
	// contains filtered or unexported fields
}

Conn implements net.Conn across a gRPC stream.

Methods such as LocalAddr, RemoteAddr, deadlines, etc. do not work.

func (*Conn) Close

func (c *Conn) Close() error

Close will close the client if this is a client. If this is a server stream this does nothing since gRPC expects you to close the stream by returning from the RPC call.

This calls CloseSend underneath for clients, so read the documentation for that to understand the semantics of this call.

func (*Conn) LocalAddr

func (c *Conn) LocalAddr() net.Addr

LocalAddr returns nil.

func (*Conn) Read

func (c *Conn) Read(p []byte) (n int, err error)

Read implements io.Reader.

func (*Conn) RemoteAddr

func (c *Conn) RemoteAddr() net.Addr

RemoteAddr returns nil.

func (*Conn) SetDeadline

func (c *Conn) SetDeadline(time.Time) error

SetDeadline is non-functional due to limitations on how gRPC works. You can mimic deadlines often using call options.

func (*Conn) SetReadDeadline

func (c *Conn) SetReadDeadline(time.Time) error

SetReadDeadline is non-functional, see SetDeadline.

func (*Conn) SetWriteDeadline

func (c *Conn) SetWriteDeadline(time.Time) error

SetWriteDeadline is non-functional, see SetDeadline.

func (*Conn) Write

func (c *Conn) Write(p []byte) (int, error)

Write implements io.Writer.

type Decoder

type Decoder func(m proto.Message, offset int, p []byte) ([]byte, error)

Decode is given a Response value and expects you to decode the response value into the byte slice given. You MUST decode up to len(p) if available.

This should return the data slice directly from m. The length of this is used to determine if there is more data and the offset for the next read.

func Decode

func Decode(f func(proto.Message) *[]byte) Decoder

SimpleDecoder is the easiest way to generate a Decoder for a proto.Message. Provide a callback that gets the pointer to the byte slice field and a valid decoder will be generated.

type Encoder

type Encoder func(proto.Message, []byte) (int, error)

Encoder encodes a byte slice to write into the destination proto.Message. You do not need to copy the slice; you may use it directly.

You do not have to encode the full byte slice in one packet. You can choose to chunk your packets by returning 0 < n < len(p) and the Conn will repeatedly send subsequent messages by slicing into the byte slice.

func ChunkedEncoder

func ChunkedEncoder(enc Encoder, size int) Encoder

ChunkedEncoder ensures that data to encode is chunked at the proper size.

func Encode

func Encode(f func(proto.Message) *[]byte) Encoder

Encode is the easiest way to generate an Encoder for a proto.Message. You just give it a callback that gets the pointer to the byte slice field and a valid encoder will be generated.

Example: given a structure that has a field "Data []byte", you could:

Encode(func(msg proto.Message) *[]byte {
    return &msg.(*pbx.Packet).Data
})