netx

type AttributeMap interface {
	// 属性数目
	Len() int
	// 是否包含key
	Contains(key unique.Key) bool
	// 获取属性,若不存在且creator不为nil,则会创建
	Get(key unique.Key, creator func() interface{}) interface{}
	// 设置属性
	Put(key unique.Key, value interface{})
	// 删除属性
	Remove(key unique.Key) interface{}
	// 清空属性
	Clear()
}

type BaseConn struct {
	sync.Mutex // 锁,用于控制状态等
	// contains filtered or unexported fields
}

type BaseFilter struct {
}

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

type Body = body.Body

type BodyWriter = body.Writer

type CallOption func(*CallOptions)

type CallOptions struct {
	DialTimeout time.Duration // 连接超时
	CallTimeout time.Duration //
	Callback    interface{}   // 异步回调函数
	RetryPolicy RetryPolicy   // 重试策略
}

type Callback func(conn Conn, packet Packet) error

type Client interface {
	Call(ctx context.Context, req Request, opts ...CallOption) (Response, error)
	Close() error
}

type Codec interface {
	Type() CodecType
	Name() string
	Encode(p bytex.Buffer, msg interface{}) error
	Decode(p bytex.Buffer, msg interface{}) error
}

type CodecType = uint

type Conn interface {
	ID() uint32                 // 唯一自增ID,由底层自动生成
	Tag() string                // 标签
	Tran() Tran                 // Transport
	Status() Status             // 当前状态
	IsActive() bool             // 是否已经建立好连接
	IsClient() bool             // 是否是通过Dial建立的Client连接
	LocalAddr() string          // 本地地址
	RemoteAddr() string         // 远程地址
	Write(p WriterTo) error     // 异步写数据,线程安全
	Send(msg interface{}) error // 异步发消息,会触发Filter Write操作
	Close() error               // 调用后将不再接收任何读写操作,并等待所有发送完成后再安全关闭
	Attributes() AttributeMap   // 扩展属性
	Protocol() interface{}      // 绑定协议
	SetProtocol(p interface{})  // 设置解析协议
}

type Detector interface {
	Detect(bytex.Peeker) Protocol // 服务端探测协议
	Default() Protocol            // 默认协议,客户端不需要
}

type DialCallback func(Conn, error)

type DialFunc func(addr string, opts *Options) (net.Conn, error)

type Endpoint func(ctx context.Context, req Request) (Response, error)

type Error interface {
	error
	Code() int
	Status() string
}

type Executor interface {
	Name() string
	Close() error
	Post(task Runnable) error
}

type Factory func() Tran

type Filter interface {
	Name() string
	HandleRead(ctx FilterCtx) error
	HandleWrite(ctx FilterCtx) error
	HandleOpen(ctx FilterCtx) error
	HandleClose(ctx FilterCtx) error
	HandleError(ctx FilterCtx) error
}

type FilterChain interface {
	Len() int                                     // 长度
	Front() Filter                                // 第一个
	Back() Filter                                 // 最后一个
	Get(index int) Filter                         // 通过索引获取filter
	Index(name string) int                        // 通过名字查询索引
	AddFirst(filters ...Filter)                   // 在前边插入
	AddLast(filters ...Filter)                    // 在末尾插入
	HandleOpen(conn Conn)                         // 建立连接
	HandleClose(conn Conn)                        // 关闭连接
	HandleError(conn Conn, err error)             // 发生错误
	HandleRead(conn Conn, msg interface{})        // 读事件
	HandleWrite(conn Conn, msg interface{}) error // 写事件
}

type FilterCtx interface {
	context.Context           //
	Recycler                  // 可回收复用
	Attributes() AttributeMap // 自定义数据,Ctx运行结束后,则会失效
	Conn() Conn               // Socket Connection
	Data() interface{}        // 获取数据
	SetData(data interface{}) // 设置数据
	Error() error             // 错误信息
	SetError(err error)       // 设置错误信息
	IsAbort() bool            // 是否已经强制终止
	Abort()                   // 终止调用
	Next() error              // 调用下一个
	Jump(index int) error     // 跳转到指定位置,可以是负索引
	JumpBy(name string) error // 通过名字跳转
	Call() error              // 开始执行,执行完成后会释放FilterCtx
	Clone() FilterCtx         // 拷贝当前状态,可用于转移到其他协程中继续执行
}

type Frame interface {
	Recycler
	Type() FrameType
	EndFlag() bool
	StreamID() uint32
	SetStreamID(id uint32)
	Identifier() *Identifier
	SetIdentifier(v *Identifier)
	Header() Header
	SetHeader(v Header)
	Trailer() Header
	SetTrailer(v Header)
	Payload() bytex.Buffer
	SetPayload(v bytex.Buffer)
}

type FrameType uint8

type Group interface {
	Group(prefix string, middlewares ...Middleware) Group
	Use(middlewares ...Middleware)

	CONNECT(path string, handler interface{}, middlewares ...Middleware)
	DELETE(path string, handler interface{}, middlewares ...Middleware)
	GET(path string, handler interface{}, middlewares ...Middleware)
	HEAD(path string, handler interface{}, middlewares ...Middleware)
	OPTIONS(path string, handler interface{}, middlewares ...Middleware)
	PATCH(path string, handler interface{}, middlewares ...Middleware)
	POST(path string, handler interface{}, middlewares ...Middleware)
	PUT(path string, handler interface{}, middlewares ...Middleware)
	TRACE(path string, handler interface{}, middlewares ...Middleware)
}

type Header = metadata.Metadata

type Identifier struct {
	Version    uint   // 版本信息,对于http1则对应[09,10,11]
	IsResponse bool   // 是否是应答消息
	IsOneway   bool   // 是否需要应答
	SeqID      uint32 // 动态唯一ID,用于查询Response回调
	CmdID      uint32 // CmdID,用于查询Request回调
	Method     Method // http method
	Service    string // http host
	URI        string // http URI
	Codec      uint32 // payload编码,区别于Content-Type,Codec只支持有限的编码方式
	StatusCode int32  // response status code
	StatusInfo string // response status info
	Params     Params // 从path中解析获得的参数
	// contains filtered or unexported fields
}

type ListenFunc func(host string, opts *Options) (net.Listener, error)

type Listener interface {
	Close() error
	Addr() net.Addr
}

type Method uint8

type Middleware func(Endpoint) Endpoint

type Module interface {
	Name() string
	Start() error
	Stop() error
}

type MsgType uint8

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

type Option func(o *Options)

type Options struct {
	Tag             string                 // 额外标签
	Network         string                 // 默认TCP,某些场景下会使用unix socket
	DialTimeout     time.Duration          // 连接超时设置
	DialCallback    DialCallback           // 连接回调
	DialNonBlocking bool                   // 连接是否阻塞,默认阻塞
	Listen          ListenFunc             // Listen
	Dial            DialFunc               // Dial
	Extra           map[string]interface{} // 其他扩展配置
}

type Packet interface {
	Recycler
	Identifier() *Identifier
	SetIdentifier(v *Identifier)
	Header() Header
	SetHeader(v Header)
	Trailer() Header
	SetTrailer(v Header)
	Body() Body
	SetBody(v Body)
}

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

type Processor interface {
	Process(conn Conn, frame Frame) error
}

type Protocol interface {
	Name() string
	Detect(data bytex.Peeker) bool
	Decode(conn Conn, data bytex.Buffer) (Frame, error)
	Encode(conn Conn, frame Frame) (bytex.Buffer, error)
}

type Recycler interface {
	Recycle()
}

type Request interface {
	Recycler
	Version() uint
	SetVersion(v uint)
	SeqID() uint32
	SetSeqID(v uint32)
	Codec() uint32
	SetCodec(v uint32)
	IsOneway() bool
	SetOneway(v bool)
	CmdID() uint32
	SetCmdID(v uint32)
	Service() string
	SetService(v string)
	URI() string
	SetURI(v string)
	URL() *url.URL
	Params() Params
	Method() Method
	SetMethod(v Method)
	Header() Header
	SetHeader(v Header)
	Trailer() Header
	SetTrailer(v Header)
	Body() Body
	SetBody(v Body)
	Encode(codecType CodecType, msg interface{}) error
	Decode(msg interface{}) error
}

type Response interface {
	Recycler
	Version() uint
	SetVersion(v uint)
	SeqID() uint32
	SetSeqID(v uint32)
	Codec() uint32
	SetCodec(v uint32)
	StatusCode() int32
	StatusInfo() string
	SetStatus(code int32, info string)
	Header() Header
	SetHeader(v Header)
	Trailer() Header
	SetTrailer(v Header)
	Body() Body
	SetBody(v Body)
	Encode(codecType CodecType, msg interface{}) error
	Decode(msg interface{}) error
}

type RetryPolicy interface {
	Allow(ctx context.Context, req Request, retryCount int) bool
}

type Route struct {
	Name        string            //
	Method      Method            //
	Path        string            //
	CmdID       uint              // 不宜过大尽量保持在uint16以内,底层数组存储
	Metadata    map[string]string // 自定义字段,可用于服务发现中注册额外字段
	Handler     interface{}       // 原始Handler,see handler.go中toEndpoint原型定义
	Middlewares []Middleware      // 中间件
	Callback    Callback          // Handler经过middleware加工后,转换成callback
}

type Router interface {
	Routes() []*Route
	Register(route *Route)
	NoRoute(callback Callback)
	Find(packet Packet) Callback
}

type RunFunc func() error

type Runnable interface {
	Run() error
}

type Server interface {
	Group
	Addr() net.Addr        // 服务器监听地址
	Register(route *Route) // 注册router
	NoRoute(handler interface{}, middlewares ...Middleware)
	Run() error
	Exit()
}

type Status int

type Tran interface {
	String() string
	GetChain() FilterChain
	SetChain(chain FilterChain)
	AddFilters(filters ...Filter)
	Dial(addr string, opts ...Option) (Conn, error)
	Listen(addr string, opts ...Option) (Listener, error)
	Close() error
}

type WriterTo interface {
	io.WriterTo
	io.Closer
}