arpc

Mar 10, 2024

Changes in this version

+ const CmdStream

+ const HeaderCmdBitMask

+ const HeaderStreamEOFBit

+ const HeaderStreamEOFBitIndex

+ const HeaderStreamFlagBitMask

+ const HeaderStreamLocalBit

+ const HeaderStreamLocalBitIndex

+ var ErrStreamClosedSend = errors.New("stream has closed send")

+ func SetStreamQueueSize(size int)

+ func StreamQueueSize() int

type Client

+ func (client *Client) NewStream(method string) *Stream

type Handler

+ HandleStream func(m string, h StreamHandlerFunc, args ...interface{})

+ SetStreamQueueSize func(size int)

+ StreamQueueSize func() int

type Message

+ func (m *Message) IsStreamEOF() bool

+ func (m *Message) IsStreamLocal() bool

+ func (m *Message) SetStreamEOF(eof bool)

+ func (m *Message) SetStreamLocal(local bool)

+ type Stream struct

+ func (s *Stream) CloseRecv()

+ func (s *Stream) CloseRecvContext(ctx context.Context)

+ func (s *Stream) CloseSend()

+ func (s *Stream) CloseSendContext(ctx context.Context)

+ func (s *Stream) Id() uint64

+ func (s *Stream) Recv(v interface{}) error

+ func (s *Stream) RecvContext(ctx context.Context, v interface{}) error

+ func (s *Stream) RecvWith(ctx context.Context, v interface{}) error

+ func (s *Stream) Send(v interface{}, args ...interface{}) error

+ func (s *Stream) SendAndClose(v interface{}, args ...interface{}) error

+ func (s *Stream) SendAndCloseContext(ctx context.Context, v interface{}, args ...interface{}) error

+ func (s *Stream) SendAndCloseWith(ctx context.Context, v interface{}, args ...interface{}) error

+ func (s *Stream) SendContext(ctx context.Context, v interface{}, args ...interface{}) error

+ func (s *Stream) SendWith(ctx context.Context, v interface{}, args ...interface{}) error

+ type StreamHandlerFunc func(*Stream)

Nov 20, 2023

Changes in this version

+ var ErrClientInvalidAsyncHandler = errors.New("invalid async handler: should not be nil")

+ type AsyncHandlerFunc func(*Context, error)

type Client

+ func (c *Client) CallContext(ctx context.Context, method string, req interface{}, rsp interface{}, ...) error

+ func (c *Client) NotifyContext(ctx context.Context, method string, data interface{}, args ...interface{}) error

Jan 30, 2023

Changes in this version

+ const CmdPing

+ const CmdPong

+ var PingMessage = newMessage(CmdPing, "", nil, false, false, 0, nil, nil, nil)

+ var PongMessage = newMessage(CmdPong, "", nil, false, false, 0, nil, nil, nil)

+ func ReadTimeout() time.Duration

+ func SetReadTimeout(timeout time.Duration)

+ func SetWriteTimeout(timeout time.Duration)

+ func WriteTimeout() time.Duration

type Client

+ func (c *Client) Keepalive(interval time.Duration)

+ func (c *Client) Ping()

+ func (c *Client) Pong()

type Handler

+ ReadTimeout func() time.Duration

+ SetReadTimeout func(timeout time.Duration)

+ SetWriteTimeout func(timeout time.Duration)

+ WriteTimeout func() time.Duration

Apr 3, 2022

Changes in this version

+ func Append(buf []byte, more ...byte) []byte

+ func AppendString(buf []byte, more string) []byte

+ func LogDebugInfo()

+ func SetDebug(enable bool)

+ type Allocator interface

+ Append func(buf []byte, more ...byte) []byte

+ AppendString func(buf []byte, more string) []byte

+ Free func(buf []byte)

+ Malloc func(size int) []byte

+ Realloc func(buf []byte, size int) []byte

+ var DefaultAllocator Allocator = New(64, 64)

type BufferPool

+ Debug bool

+ func (bp *BufferPool) Append(buf []byte, more ...byte) []byte

+ func (bp *BufferPool) AppendString(buf []byte, more string) []byte

+ func (bp *BufferPool) Free(buf []byte)

+ func (bp *BufferPool) LogDebugInfo()

+ func (bp *BufferPool) Malloc(size int) []byte

+ func (bp *BufferPool) Realloc(buf []byte, size int) []byte

type Client

+ func (c *Client) SetState(running bool)

type Handler

+ Append func(b []byte, more ...byte) []byte

+ HandleAppend func(f func(b []byte, more ...byte) []byte)

Sep 30, 2021

Changes in this version

type Handler

+ MaxReconnectTimes func() int

+ SetMaxReconnectTimes func(n int)

Sep 17, 2021

Changes in this version

type Server

+ func (s *Server) Broadcast(method string, v interface{}, args ...interface{})

+ func (s *Server) BroadcastWithFilter(method string, v interface{}, filter func(*Client) bool, args ...interface{})

+ func (s *Server) ForEach(h func(*Client))

+ func (s *Server) ForEachWithFilter(h func(*Client), filter func(*Client) bool)

Aug 30, 2021

Changes in this version

+ const DefaultMaxBodyLen

+ func SetMaxBodyLen(l int)

type Handler

+ MaxBodyLen func() int

+ SetMaxBodyLen func(l int)

Aug 19, 2021

Changes in this version

+ func AsyncExecute(f func())

+ func SetAsyncExecutor(executor func(f func()))

type Handler

+ AsyncExecute func(f func())

+ SetAsyncExecutor func(executor func(f func()))

Aug 16, 2021

Changes in this version

+ var BufferPool interface{ ... } = New(64)

+ func EnablePool(enable bool)

+ func Free(buf []byte)

+ func HandleMalloc(f func(int) []byte)

+ func Malloc(size int) []byte

+ func Realloc(buf []byte, size int) []byte

+ func SendBufferSize() int

+ func SetSendBufferSize(size int)

type Context

+ func (ctx *Context) Release()

type Handler

+ AsyncWrite func() bool

+ Cancel func()

+ Context func() (context.Context, context.CancelFunc)

+ EnablePool func(enable bool)

+ Free func([]byte)

+ HandleContextDone func(onContextDone func(ctx *Context))

+ HandleFree func(f func(buf []byte))

+ HandleMalloc func(f func(size int) []byte)

+ HandleMessageDone func(onMessageDone func(c *Client, m *Message))

+ Malloc func(size int) []byte

+ NewMessage func(cmd byte, method string, v interface{}, isError bool, isAsync bool, seq uint64, ...) *Message

+ NewMessageWithBuffer func(buffer []byte) *Message

+ OnContextDone func(ctx *Context)

+ OnMessageDone func(c *Client, m *Message)

+ SendBufferSize func() int

+ SetAsyncWrite func(async bool)

+ SetContext func(ctx context.Context, cancel context.CancelFunc)

+ SetSendBufferSize func(size int)

+ type MemPool struct

+ Debug bool

+ func New(minSize int) *MemPool

+ func (mp *MemPool) Free(buf []byte)

+ func (mp *MemPool) Malloc(size int) []byte

+ func (mp *MemPool) Realloc(buf []byte, size int) []byte

type Message

+ func NewMessage(cmd byte, method string, v interface{}, isError bool, isAsync bool, seq uint64, ...) *Message

+ func (m *Message) Payback()

+ func (m *Message) Release() int32

+ func (m *Message) ResetAttrs()

+ func (m *Message) Retain() int32

+ type NativeAllocator struct

+ func (a *NativeAllocator) Free(buf []byte)

+ func (a *NativeAllocator) Malloc(size int) []byte

+ func (a *NativeAllocator) Realloc(buf []byte, size int) []byte

Jul 6, 2021

Changes in this version

type Client

+ IsAsync bool

Dec 15, 2020

Changes in this version

type Context

+ func (ctx *Context) Abort()

+ func (ctx *Context) Deadline() (deadline time.Time, ok bool)

+ func (ctx *Context) Err() error

+ func (ctx *Context) Value(key interface{}) interface{}

Dec 7, 2020

Changes in this version

+ const CmdNone

+ const CmdNotify

+ const CmdRequest

+ const CmdResponse

+ const HeadLen

+ const HeaderFlagMaskAsync

+ const HeaderFlagMaskError

+ const HeaderIndexBodyLenBegin

+ const HeaderIndexBodyLenEnd

+ const HeaderIndexCmd

+ const HeaderIndexFlag

+ const HeaderIndexMethodLen

+ const HeaderIndexReserved

+ const HeaderIndexSeqBegin

+ const HeaderIndexSeqEnd

+ const MaxBodyLen

+ const MaxMethodLen

+ const TimeForever

+ const TimeZero

+ var ErrClientInvalidPoolDialers = errors.New("invalid dialers: empty array")

+ var ErrClientInvalidTimeoutLessThanZero = errors.New("invalid timeout, should not be < 0")

+ var ErrClientInvalidTimeoutZero = errors.New("invalid timeout, should not be 0")

+ var ErrClientInvalidTimeoutZeroWithNonNilCallback = errors.New("invalid timeout 0 with non-nil callback")

+ var ErrClientOverstock = errors.New("timeout: rpc Client's send queue is full")

+ var ErrClientReconnecting = errors.New("client reconnecting")

+ var ErrClientStopped = errors.New("client stopped")

+ var ErrClientTimeout = errors.New("timeout")

+ var ErrContextResponseToNotify = errors.New("should not response to a context with notify message")

+ var ErrInvalidFlagBitIndex = errors.New("invalid index, should be 0-7")

+ var ErrInvalidRspMessage = errors.New("invalid response message cmd")

+ var ErrMethodNotFound = errors.New("method not found")

+ var ErrTimeout = errors.New("timeout")

+ func AsyncResponse() bool

+ func BatchRecv() bool

+ func BatchSend() bool

+ func BeforeRecv(h func(net.Conn) error)

+ func BeforeSend(h func(net.Conn) error)

+ func Handle(m string, h HandlerFunc, args ...interface{})

+ func HandleConnected(onConnected func(*Client))

+ func HandleDisconnected(onDisConnected func(*Client))

+ func HandleMessageDropped(onOverstock func(c *Client, m *Message))

+ func HandleNotFound(h HandlerFunc)

+ func HandleOverstock(onOverstock func(c *Client, m *Message))

+ func HandleSessionMiss(onSessionMiss func(c *Client, m *Message))

+ func RecvBufferSize() int

+ func SendQueueSize() int

+ func SetAsyncResponse(async bool)

+ func SetBatchRecv(batch bool)

+ func SetBatchSend(batch bool)

+ func SetBufferFactory(f func(int) []byte)

+ func SetHandler(h Handler)

+ func SetLogTag(tag string)

+ func SetReaderWrapper(wrapper func(conn net.Conn) io.Reader)

+ func SetRecvBufferSize(size int)

+ func SetSendQueueSize(size int)

+ func Use(h HandlerFunc)

+ func UseCoder(coder MessageCoder)

+ type Client struct

+ Codec codec.Codec

+ Conn net.Conn

+ Dialer DialerFunc

+ Handler Handler

+ Head Header

+ Reader io.Reader

+ UserData interface{}

+ func NewClient(dialer DialerFunc) (*Client, error)

+ func (c *Client) Call(method string, req interface{}, rsp interface{}, timeout time.Duration, ...) error

+ func (c *Client) CallAsync(method string, req interface{}, handler HandlerFunc, timeout time.Duration, ...) error

+ func (c *Client) CallWith(ctx context.Context, method string, req interface{}, rsp interface{}, ...) error

+ func (c *Client) CheckState() error

+ func (c *Client) Delete(key string)

+ func (c *Client) Get(key string) (interface{}, bool)

+ func (c *Client) NewMessage(cmd byte, method string, v interface{}) *Message

+ func (c *Client) Notify(method string, data interface{}, timeout time.Duration, args ...interface{}) error

+ func (c *Client) NotifyWith(ctx context.Context, method string, data interface{}, args ...interface{}) error

+ func (c *Client) PushMsg(msg *Message, timeout time.Duration) error

+ func (c *Client) Restart() error

+ func (c *Client) Set(key string, value interface{})

+ func (c *Client) Stop()

+ type ClientPool struct

+ func NewClientPool(dialer DialerFunc, size int) (*ClientPool, error)

+ func NewClientPoolFromDialers(dialers []DialerFunc) (*ClientPool, error)

+ func (pool *ClientPool) Get(index int) *Client

+ func (pool *ClientPool) Handler() Handler

+ func (pool *ClientPool) Next() *Client

+ func (pool *ClientPool) Size() int

+ func (pool *ClientPool) Stop()

+ type Context struct

+ Client *Client

+ Message *Message

+ func (ctx *Context) Bind(v interface{}) error

+ func (ctx *Context) Body() []byte

+ func (ctx *Context) Done()

+ func (ctx *Context) Error(v interface{}) error

+ func (ctx *Context) Get(key string) (interface{}, bool)

+ func (ctx *Context) Next()

+ func (ctx *Context) Set(key string, value interface{})

+ func (ctx *Context) Values() map[string]interface{}

+ func (ctx *Context) Write(v interface{}) error

+ func (ctx *Context) WriteWithTimeout(v interface{}, timeout time.Duration) error

+ type DialerFunc func() (net.Conn, error)

+ type Handler interface

+ AsyncResponse func() bool

+ BatchRecv func() bool

+ BatchSend func() bool

+ BeforeRecv func(h func(net.Conn) error)

+ BeforeSend func(h func(net.Conn) error)

+ Clone func() Handler

+ Coders func() []MessageCoder

+ GetBuffer func(size int) []byte

+ Handle func(m string, h HandlerFunc, args ...interface{})

+ HandleConnected func(onConnected func(*Client))

+ HandleDisconnected func(onDisConnected func(*Client))

+ HandleMessageDropped func(onOverstock func(c *Client, m *Message))

+ HandleNotFound func(h HandlerFunc)

+ HandleOverstock func(onOverstock func(c *Client, m *Message))

+ HandleSessionMiss func(onSessionMiss func(c *Client, m *Message))

+ LogTag func() string

+ OnConnected func(c *Client)

+ OnDisconnected func(c *Client)

+ OnMessage func(c *Client, m *Message)

+ OnMessageDropped func(c *Client, m *Message)

+ OnOverstock func(c *Client, m *Message)

+ OnSessionMiss func(c *Client, m *Message)

+ Recv func(c *Client) (*Message, error)

+ RecvBufferSize func() int

+ Send func(c net.Conn, buffer []byte) (int, error)

+ SendN func(conn net.Conn, buffers net.Buffers) (int, error)

+ SendQueueSize func() int

+ SetAsyncResponse func(async bool)

+ SetBatchRecv func(batch bool)

+ SetBatchSend func(batch bool)

+ SetBufferFactory func(f func(int) []byte)

+ SetLogTag func(tag string)

+ SetReaderWrapper func(wrapper func(conn net.Conn) io.Reader)

+ SetRecvBufferSize func(size int)

+ SetSendQueueSize func(size int)

+ Use func(h HandlerFunc)

+ UseCoder func(coder MessageCoder)

+ WrapReader func(conn net.Conn) io.Reader

+ var DefaultHandler Handler = NewHandler()

+ func NewHandler() Handler

+ type HandlerFunc func(*Context)

+ type Header []byte

+ func (h Header) BodyLen() int

+ type Message struct

+ Buffer []byte

+ func (m *Message) BodyLen() int

+ func (m *Message) Cmd() byte

+ func (m *Message) Data() []byte

+ func (m *Message) Error() error

+ func (m *Message) Get(key string) (interface{}, bool)

+ func (m *Message) IsAsync() bool

+ func (m *Message) IsError() bool

+ func (m *Message) IsFlagBitSet(index int) bool

+ func (m *Message) Len() int

+ func (m *Message) Method() string

+ func (m *Message) MethodLen() int

+ func (m *Message) Seq() uint64

+ func (m *Message) Set(key string, value interface{})

+ func (m *Message) SetAsync(isAsync bool)

+ func (m *Message) SetBodyLen(l int)

+ func (m *Message) SetCmd(cmd byte)

+ func (m *Message) SetError(isError bool)

+ func (m *Message) SetFlagBit(index int, value bool) error

+ func (m *Message) SetMethodLen(l int)

+ func (m *Message) SetSeq(seq uint64)

+ func (m *Message) Values() map[string]interface{}

+ type MessageCoder interface

+ Decode func(*Client, *Message) *Message

+ Encode func(*Client, *Message) *Message

+ type Server struct

+ Accepted int64

+ Codec codec.Codec

+ CurrLoad int64

+ Handler Handler

+ Listener net.Listener

+ MaxLoad int64

+ func NewServer() *Server

+ func (s *Server) NewMessage(cmd byte, method string, v interface{}) *Message

+ func (s *Server) Run(addr string) error

+ func (s *Server) Serve(ln net.Listener) error

+ func (s *Server) Shutdown(ctx context.Context) error

+ func (s *Server) Stop() error

+ type WebsocketConn interface

+ HandleWebsocket func(func())