remote

package
v0.4.4 Latest Latest
Warning

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

Go to latest
Published: Dec 13, 2022 License: Apache-2.0 Imports: 17 Imported by: 47

Documentation

Overview

Package remote defines all interfaces that are used to do transport with peer side and contains default extension implementations.

Index

Constants

View Source
const (
	BitReadable = 1 << iota
	BitWritable
)

Mask bits.

View Source
const (
	// ReadFailed .
	ReadFailed string = "RFailed"

	// MeshHeader use in message.Tag to check MeshHeader
	MeshHeader string = "mHeader"
)
View Source
const (
	UnknownApplicationException = 0
	UnknownMethod               = 1
	InvalidMessageTypeException = 2
	WrongMethodName             = 3
	BadSequenceID               = 4
	MissingResult               = 5
	InternalError               = 6
	ProtocolError               = 7
	InvalidTransform            = 8
	InvalidProtocol             = 9
	UnsupportedClientType       = 10
)

corresponding with thrift TApplicationException, cannot change it

Variables

This section is empty.

Functions

func FillSendMsgFromRecvMsg

func FillSendMsgFromRecvMsg(recvMsg, sendMsg Message)

FillSendMsgFromRecvMsg is used to fill the transport information to the message to be sent.

func NewByteBufferIO

func NewByteBufferIO(buffer ByteBuffer) io.ReadWriter

NewByteBufferIO wraps ByBuffer to io.ReadWriter

func PutPayloadCode

func PutPayloadCode(name serviceinfo.PayloadCodec, v PayloadCodec)

PutPayloadCode puts the desired payload codec to message.

func RecycleMessage

func RecycleMessage(msg Message)

RecycleMessage is used to recycle message.

Types

type BoundHandler

type BoundHandler interface{}

BoundHandler is used to abstract the bound handler.

type ByteBuffer

type ByteBuffer interface {
	io.ReadWriter

	// Next reads the next n bytes sequentially and returns the original buffer.
	Next(n int) (p []byte, err error)

	// Peek returns the next n bytes without advancing the reader.
	Peek(n int) (buf []byte, err error)

	// Skip is used to skip the next few bytes quickly. It's faster than Next and doesn't cause release.
	Skip(n int) (err error)

	// Release will free the buffer. After release, buffer read by Next/Skip/Peek is invalid.
	// Param e is used when the buffer release depend on error.
	// For example, usually the write buffer will be released inside flush,
	// but if flush error happen, write buffer may need to be released explicitly.
	Release(e error) (err error)

	// ReadableLen returns the total length of readable buffer.
	// Return: -1 means unreadable.
	ReadableLen() (n int)

	// ReadLen returns the size already read.
	ReadLen() (n int)

	// ReadString is a more efficient way to read string than Next.
	ReadString(n int) (s string, err error)

	// ReadBinary like ReadString.
	// Returns a copy of original buffer.
	ReadBinary(n int) (p []byte, err error)

	// Malloc n bytes sequentially in the writer buffer.
	Malloc(n int) (buf []byte, err error)

	// MallocLen returns the total length of the buffer malloced.
	MallocLen() (length int)

	// WriteString is a more efficient way to write string, using the unsafe method to convert the string to []byte.
	WriteString(s string) (n int, err error)

	// WriteBinary writes the []byte directly. Callers must guarantee that the []byte doesn't change.
	WriteBinary(b []byte) (n int, err error)

	// Flush writes any malloc data to the underlying io.Writer.
	// The malloced buffer must be set correctly.
	Flush() (err error)

	// NewBuffer returns a new writable remote.ByteBuffer.
	NewBuffer() ByteBuffer
	// AppendBuffer appends buf to the original buffer.
	AppendBuffer(buf ByteBuffer) (err error)

	// Bytes return the backing bytes slice of this buffer
	Bytes() (buf []byte, err error)
}

ByteBuffer is the core abstraction of buffer in Kitex.

func NewReaderBuffer

func NewReaderBuffer(buf []byte) ByteBuffer

NewReaderBuffer is used to create a defaultByteBuffer using the given buf.

func NewReaderWriterBuffer

func NewReaderWriterBuffer(size int) ByteBuffer

NewReaderWriterBuffer is used to create a defaultByteBuffer using the given size.

func NewWriterBuffer

func NewWriterBuffer(size int) ByteBuffer

NewWriterBuffer is used to create a defaultByteBuffer using the given size. NOTICE: defaultByteBuffer is only used for testing.

type ByteBufferFactory

type ByteBufferFactory interface {
	NewByteBuffer(conn net.Conn) (ByteBuffer, error)
}

ByteBufferFactory is used to create ByteBuffer.

type ByteBufferIO

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

ByteBufferIO wrap ByteBuffer to implement io.ReadWriter

func (*ByteBufferIO) Read

func (p *ByteBufferIO) Read(b []byte) (n int, err error)

Read implements the io.ReadWriter interface.

func (*ByteBufferIO) Write

func (p *ByteBufferIO) Write(b []byte) (int, error)

Write implements the io.ReadWriter interface.

type ClientOption

type ClientOption struct {
	SvcInfo *serviceinfo.ServiceInfo

	CliHandlerFactory ClientTransHandlerFactory

	Codec Codec

	PayloadCodec PayloadCodec

	ConnPool ConnPool

	Dialer Dialer

	Option

	EnableConnPoolReporter bool
}

ClientOption is used to init the remote client.

type ClientTransHandler

type ClientTransHandler interface {
	TransHandler
}

ClientTransHandler is just TransHandler.

type ClientTransHandlerFactory

type ClientTransHandlerFactory interface {
	NewTransHandler(opt *ClientOption) (ClientTransHandler, error)
}

ClientTransHandlerFactory to new TransHandler for client

type Codec

type Codec interface {
	Encode(ctx context.Context, msg Message, out ByteBuffer) error
	Decode(ctx context.Context, msg Message, in ByteBuffer) error
	Name() string
}

Codec is the abstraction of the codec layer of Kitex.

type CompressType

type CompressType int32

CompressType tells compression type for a message.

const (
	NoCompress CompressType = iota
	GZip
)

Compression types. Not support now, compression will be supported at later version

type ConnOption

type ConnOption struct {
	Dialer         Dialer
	ConnectTimeout time.Duration
}

ConnOption contains configurations for connection pool.

type ConnPool

type ConnPool interface {
	// Get returns a connection to the given address.
	Get(ctx context.Context, network, address string, opt ConnOption) (net.Conn, error)

	// Put puts the connection back to pool.
	// Note that the Close method of conn may already be invoked.
	Put(conn net.Conn) error

	// Discard discards the connection rather than putting it to the pool.
	Discard(conn net.Conn) error

	// Close is to release resource of ConnPool, it is executed when client is closed.
	Close() error
}

ConnPool is used to get connections.

type ConnPoolReporter

type ConnPoolReporter interface {
	EnableReporter()
}

ConnPoolReporter is used to enable reporter.

type Dialer

type Dialer interface {
	DialTimeout(network, address string, timeout time.Duration) (net.Conn, error)
}

Dialer is used to dial and get a connection.

func NewDefaultDialer

func NewDefaultDialer() Dialer

NewDefaultDialer is used to create a default dialer.

type DuplexBoundHandler

type DuplexBoundHandler interface {
	OutboundHandler
	InboundHandler
}

DuplexBoundHandler can process both inbound and outbound connections.

type FrameWrite added in v0.3.0

type FrameWrite interface {
	// WriteHeader set header buffer without copy
	WriteHeader(buf []byte) (err error)
	// WriteData set data buffer without copy
	WriteData(buf []byte) (err error)
}

FrameWrite is to write header and data buffer separately to avoid memory copy

type GracefulShutdown added in v0.3.0

type GracefulShutdown interface {
	GracefulShutdown(ctx context.Context) error
}

GracefulShutdown supports closing connections in a graceful manner.

type InboundHandler

type InboundHandler interface {
	BoundHandler
	OnActive(ctx context.Context, conn net.Conn) (context.Context, error)
	OnInactive(ctx context.Context, conn net.Conn) context.Context
	OnRead(ctx context.Context, conn net.Conn) (context.Context, error)
	OnMessage(ctx context.Context, args, result Message) (context.Context, error)
}

InboundHandler is used to process read event.

type InvokeHandleFuncSetter

type InvokeHandleFuncSetter interface {
	SetInvokeHandleFunc(inkHdlFunc endpoint.Endpoint)
}

InvokeHandleFuncSetter is used to set invoke handle func.

type IsActive

type IsActive interface {
	IsActive() bool
}

IsActive is used to check if the connection is active.

type LongConnPool

type LongConnPool interface {
	ConnPool

	// Clean the state maintained in the poor for this address
	Clean(network, address string)
}

LongConnPool supports Clean connections to a desired address.

type Message

type Message interface {
	RPCInfo() rpcinfo.RPCInfo
	ServiceInfo() *serviceinfo.ServiceInfo
	Data() interface{}
	NewData(method string) (ok bool)
	MessageType() MessageType
	SetMessageType(MessageType)
	RPCRole() RPCRole
	PayloadLen() int
	SetPayloadLen(size int)
	TransInfo() TransInfo
	Tags() map[string]interface{}
	ProtocolInfo() ProtocolInfo
	SetProtocolInfo(ProtocolInfo)
	PayloadCodec() PayloadCodec
	SetPayloadCodec(pc PayloadCodec)
	Recycle()
}

Message is the core abstraction for Kitex message.

func NewMessage

func NewMessage(data interface{}, svcInfo *serviceinfo.ServiceInfo, ri rpcinfo.RPCInfo, msgType MessageType, rpcRole RPCRole) Message

NewMessage creates a new Message using the given info.

func NewMessageWithNewer

func NewMessageWithNewer(svcInfo *serviceinfo.ServiceInfo, ri rpcinfo.RPCInfo, msgType MessageType, rpcRole RPCRole) Message

NewMessageWithNewer creates a new Message and set data later.

type MessageTagging added in v0.4.3

type MessageTagging func(ctx context.Context, msg Message) (context.Context, []string)

MessageTagging extracting tags after whole decode process finished.

type MessageType

type MessageType int32

MessageType indicates the type of message.

const (
	// 0-4 corresponding to thrift.TMessageType
	InvalidMessageType MessageType = 0
	Call               MessageType = 1
	Reply              MessageType = 2
	Exception          MessageType = 3
	// Oneway means there's no need to wait for the response.
	// When the actual message is transmitted, Oneway writes a Call to avoid compatibility issues
	// and to maintain consistency with the original logic.
	Oneway MessageType = 4

	Stream MessageType = 5
)

MessageTypes.

type MetaDecoder added in v0.4.3

type MetaDecoder interface {
	DecodeMeta(ctx context.Context, msg Message, in ByteBuffer) error
	DecodePayload(ctx context.Context, msg Message, in ByteBuffer) error
}

MetaDecoder is an abstraction of the codec layer that has meta and payload stage

type MetaHandler

type MetaHandler interface {
	WriteMeta(ctx context.Context, msg Message) (context.Context, error)
	ReadMeta(ctx context.Context, msg Message) (context.Context, error)
}

MetaHandler reads or writes metadata through certain protocol.

func NewProfilerMetaHandler added in v0.4.3

func NewProfilerMetaHandler(pr profiler.Profiler, tagging MessageTagging) MetaHandler

NewProfilerMetaHandler creates profiler MetaHandler

type NocopyWrite

type NocopyWrite interface {
	// the buf will be wrapped as a new data node no copy, then insert into the linked buffer.
	// remainCap is the remain capacity of origin buff.
	WriteDirect(buf []byte, remainCap int) error
}

NocopyWrite is to write []byte without copying, and splits the original buffer. It is used with linked buffer implement.

type Option

type Option struct {
	Outbounds []OutboundHandler

	Inbounds []InboundHandler

	StreamingMetaHandlers []StreamingMetaHandler
}

Option is used to pack the inbound and outbound handlers.

func (*Option) AppendBoundHandler added in v0.3.0

func (o *Option) AppendBoundHandler(h BoundHandler)

AppendBoundHandler adds a BoundHandler to the end.

func (*Option) PrependBoundHandler added in v0.3.0

func (o *Option) PrependBoundHandler(h BoundHandler)

PrependBoundHandler adds a BoundHandler to the head.

type OutboundHandler

type OutboundHandler interface {
	BoundHandler
	Write(ctx context.Context, conn net.Conn, send Message) (context.Context, error)
}

OutboundHandler is used to process write event.

type PayloadCodec

type PayloadCodec interface {
	Marshal(ctx context.Context, message Message, out ByteBuffer) error
	Unmarshal(ctx context.Context, message Message, in ByteBuffer) error
	Name() string
}

PayloadCodec is used to marshal and unmarshal payload.

func GetPayloadCodec

func GetPayloadCodec(message Message) (PayloadCodec, error)

GetPayloadCodec gets desired payload codec from message.

type ProtocolInfo

type ProtocolInfo struct {
	TransProto transport.Protocol
	CodecType  serviceinfo.PayloadCodec
}

ProtocolInfo is used to indicate the transport protocol and payload codec information.

func NewProtocolInfo

func NewProtocolInfo(tp transport.Protocol, ct serviceinfo.PayloadCodec) ProtocolInfo

NewProtocolInfo creates a new ProtocolInfo using the given tp and ct.

type RPCRole

type RPCRole int

RPCRole is to distinguished client or server

const (
	Client RPCRole = iota
	Server
)

RPC role

type RawConn

type RawConn interface {
	RawConn() net.Conn
}

RawConn is used to get the raw connection.

type ServerOption

type ServerOption struct {
	SvcInfo *serviceinfo.ServiceInfo

	TransServerFactory TransServerFactory

	SvrHandlerFactory ServerTransHandlerFactory

	Codec Codec

	PayloadCodec PayloadCodec

	// Listener is used to specify the server listener, which comes with higher priority than Address below.
	Listener net.Listener

	// Address is the listener addr
	Address net.Addr

	ReusePort bool

	// Duration that server waits for to allow any existing connection to be closed gracefully.
	ExitWaitTime time.Duration

	// Duration that server waits for after error occurs during connection accepting.
	AcceptFailedDelayTime time.Duration

	// Duration that the accepted connection waits for to read or write data.
	MaxConnectionIdleTime time.Duration

	ReadWriteTimeout time.Duration

	InitOrResetRPCInfoFunc func(rpcinfo.RPCInfo, net.Addr) rpcinfo.RPCInfo

	TracerCtl *internal_stats.Controller

	Profiler                 profiler.Profiler
	ProfilerTransInfoTagging TransInfoTagging
	ProfilerMessageTagging   MessageTagging

	GRPCCfg *grpc.ServerConfig

	GRPCUnknownServiceHandler func(ctx context.Context, method string, stream streaming.Stream) error

	Option
}

ServerOption contains option that is used to init the remote server.

type ServerTransHandler

type ServerTransHandler interface {
	TransHandler
	OnActive(ctx context.Context, conn net.Conn) (context.Context, error)
	OnRead(ctx context.Context, conn net.Conn) error
}

ServerTransHandler have some new functions.

type ServerTransHandlerFactory

type ServerTransHandlerFactory interface {
	NewTransHandler(opt *ServerOption) (ServerTransHandler, error)
}

ServerTransHandlerFactory to new TransHandler for server

type StreamingMetaHandler

type StreamingMetaHandler interface {
	// writes metadata before create a stream
	OnConnectStream(ctx context.Context) (context.Context, error)
	// reads metadata before read first message from stream
	OnReadStream(ctx context.Context) (context.Context, error)
}

StreamingMetaHandler reads or writes metadata through streaming header(http2 header)

type SynthesizedDialer

type SynthesizedDialer struct {
	DialFunc func(network, address string, timeout time.Duration) (net.Conn, error)
}

SynthesizedDialer is used to synthesize a DialFunc to implement a Dialer.

func (SynthesizedDialer) DialTimeout

func (sd SynthesizedDialer) DialTimeout(network, address string, timeout time.Duration) (net.Conn, error)

DialTimeout implements the Dialer interface.

type TransError

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

TransError is the error that can be transmitted, it corresponds to TApplicationException in Thrift

func NewTransError

func NewTransError(typeID int32, err error) *TransError

NewTransError to build TransError with typeID and rawErr. rawErr can be used by errors.Is(target) to check err type, like read timeout.

func NewTransErrorWithMsg

func NewTransErrorWithMsg(typeID int32, message string) *TransError

NewTransErrorWithMsg to build TransError with typeID and errMsg

func (TransError) AppendMessage added in v0.3.3

func (e TransError) AppendMessage(extraMsg string) *TransError

AppendMessage append extra msg for TransError

func (TransError) Error

func (e TransError) Error() string

Error implements the error interface.

func (TransError) Is

func (e TransError) Is(target error) bool

Is to check if inner error that transError wrap is target error

func (TransError) TypeID

func (e TransError) TypeID() int32

TypeID return err type id

func (TransError) Unwrap

func (e TransError) Unwrap() error

Unwrap the transError to expose raw error

type TransHandler

type TransHandler interface {
	TransReadWriter
	OnInactive(ctx context.Context, conn net.Conn)
	OnError(ctx context.Context, err error, conn net.Conn)
	OnMessage(ctx context.Context, args, result Message) (context.Context, error)
	SetPipeline(pipeline *TransPipeline)
}

TransHandler is similar to the handler role in netty Transport can be refactored to support pipeline, and then is able to support other extensions at conn level.

type TransInfo

type TransInfo interface {
	TransStrInfo() map[string]string
	TransIntInfo() map[uint16]string
	PutTransIntInfo(map[uint16]string)
	PutTransStrInfo(kvInfo map[string]string)
	Recycle()
}

TransInfo contains transport information.

type TransInfoTagging added in v0.4.3

type TransInfoTagging func(ctx context.Context, msg Message) (context.Context, []string)

TransInfoTagging extracting tags after TransInfo decoded but before message decoded.

type TransPipeline

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

TransPipeline contains TransHandlers.

func NewTransPipeline

func NewTransPipeline(netHdlr TransHandler) *TransPipeline

NewTransPipeline is used to create a new TransPipeline.

func (*TransPipeline) AddInboundHandler

func (p *TransPipeline) AddInboundHandler(hdlr InboundHandler) *TransPipeline

AddInboundHandler adds an InboundHandler to the pipeline.

func (*TransPipeline) AddOutboundHandler

func (p *TransPipeline) AddOutboundHandler(hdlr OutboundHandler) *TransPipeline

AddOutboundHandler adds an OutboundHandler to the pipeline.

func (*TransPipeline) GracefulShutdown added in v0.3.0

func (p *TransPipeline) GracefulShutdown(ctx context.Context) error

GracefulShutdown implements the GracefulShutdown interface.

func (*TransPipeline) OnActive

func (p *TransPipeline) OnActive(ctx context.Context, conn net.Conn) (context.Context, error)

OnActive implements the InboundHandler interface.

func (*TransPipeline) OnError

func (p *TransPipeline) OnError(ctx context.Context, err error, conn net.Conn)

OnError calls

func (*TransPipeline) OnInactive

func (p *TransPipeline) OnInactive(ctx context.Context, conn net.Conn)

OnInactive implements the InboundHandler interface.

func (*TransPipeline) OnMessage

func (p *TransPipeline) OnMessage(ctx context.Context, args, result Message) (context.Context, error)

OnMessage implements the InboundHandler interface.

func (*TransPipeline) OnRead

func (p *TransPipeline) OnRead(ctx context.Context, conn net.Conn) error

OnRead implements the InboundHandler interface.

func (*TransPipeline) Read

func (p *TransPipeline) Read(ctx context.Context, conn net.Conn, msg Message) (nctx context.Context, err error)

Read reads from conn.

func (*TransPipeline) SetPipeline

func (p *TransPipeline) SetPipeline(transPipe *TransPipeline)

SetPipeline does nothing now.

func (*TransPipeline) Write

func (p *TransPipeline) Write(ctx context.Context, conn net.Conn, sendMsg Message) (nctx context.Context, err error)

Write implements the OutboundHandler interface.

type TransReadWriter

type TransReadWriter interface {
	Write(ctx context.Context, conn net.Conn, send Message) (nctx context.Context, err error)
	Read(ctx context.Context, conn net.Conn, msg Message) (nctx context.Context, err error)
}

TransReadWriter .

type TransServer

type TransServer interface {
	CreateListener(net.Addr) (net.Listener, error)
	BootstrapServer(net.Listener) (err error)
	Shutdown() error
	ConnCount() utils.AtomicInt
}

TransServer is the abstraction for remote server.

type TransServerFactory

type TransServerFactory interface {
	NewTransServer(opt *ServerOption, transHdlr ServerTransHandler) TransServer
}

TransServerFactory is used to create TransServer instances.

type TypeID added in v0.0.4

type TypeID interface {
	TypeID() int32
}

TypeId is used to assert Error with has 'TypeID() int32'

type TypeId added in v0.0.4

type TypeId interface {
	TypeId() int32
}

TypeId is used to assert Error with has 'TypeId() int32' like TApplicationException

Directories

Path Synopsis
Package connpool provide short connection and long connection pool.
Package connpool provide short connection and long connection pool.
Package remotecli for remote client
Package remotecli for remote client
detection
Package detection protocol detection, it is used for a scenario that switching KitexProtobuf to gRPC.
Package detection protocol detection, it is used for a scenario that switching KitexProtobuf to gRPC.
gonet
Package gonet contains server and client implementation for go net.
Package gonet contains server and client implementation for go net.
invoke
Package invoke .
Package invoke .
nphttp2
Package nphttp2 transport powered by netpoll
Package nphttp2 transport powered by netpoll
nphttp2/codes
Package codes defines the canonical error codes used by gRPC.
Package codes defines the canonical error codes used by gRPC.
nphttp2/grpc
The files in grpc package are forked from gRPC[github.com/grpc/grpc-go], and we keep the original Copyright[Copyright 2017 gRPC authors] and License of gRPC for those files.
The files in grpc package are forked from gRPC[github.com/grpc/grpc-go], and we keep the original Copyright[Copyright 2017 gRPC authors] and License of gRPC for those files.
nphttp2/grpc/syscall
Package syscall provides functionalities that grpc uses to get low-level operating system stats/info.
Package syscall provides functionalities that grpc uses to get low-level operating system stats/info.
nphttp2/grpc/testutils/leakcheck
Package leakcheck contains functions to check leaked goroutines.
Package leakcheck contains functions to check leaked goroutines.
nphttp2/metadata
Package metadata define the structure of the metadata supported by gRPC library.
Package metadata define the structure of the metadata supported by gRPC library.
nphttp2/status
Package status implements errors returned by gRPC.
Package status implements errors returned by gRPC.
Package transmeta .
Package transmeta .

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL