ikiosocket

Documentation

Index

• Constants
• Variables
• func Put(p *RPCPacket)
• type Context
• type IKIOSocket
  • func New(l *logging.Logger) *IKIOSocket
  • func (i *IKIOSocket) Call(req *Context, options ...Option) (*Context, error)
  • func (i *IKIOSocket) Close() error
  • func (i *IKIOSocket) Start(host string, dial time.Duration) error
  • func (i *IKIOSocket) StartWithConn(conn net.Conn)
• type Option
  • func Timeout(t time.Duration) Option
• type Options
• type RPCCodec
  • func (rc *RPCCodec) Decode(reader *bufio.Reader) (ikio.Packet, error)
  • func (rc *RPCCodec) Encode(p ikio.Packet, writer io.Writer) (int, error)
• type RPCNegoPacket
  • func (rnp *RPCNegoPacket) Serialize() ([]byte, error)
  • func (rnp *RPCNegoPacket) Type() int32
• type RPCPacket
  • func Get() *RPCPacket
  • func (rp *RPCPacket) AddHeader(key []byte, value []byte)
  • func (rp *RPCPacket) ForeachHeader(cb func(key, value []byte) error) error
  • func (rp *RPCPacket) GetHeader(key []byte) ([]byte, bool)
  • func (rp *RPCPacket) Serialize() ([]byte, error)
  • func (rp *RPCPacket) Type() int32
• type RPCPacketHeader
• type Server
  • func NewServer(l *logging.Logger, cb servercb) *Server
  • func (s *Server) Start(ln net.Listener) error
  • func (s *Server) Stop()
• type Timer
  • func NewTimer(d time.Duration, cb func()) *Timer
  • func (t *Timer) Start()
  • func (t *Timer) Stop()

Constants

const (
	PacketTypeRequest  = 0
	PacketTypeResponse = 1
	PacketTypeHint     = 2
)

const (
	RPCDefaultMaxHeaderLen = 10 * 1024 * 1024
	RPCDefaultMaxBodyLen   = 10 * 1024 * 1024
	RPCDefaultMaxPeerIDLen = 1024
)

RPC body/header limit

const (
	RPCNegoMessageType = 0xFFFF
)

RPC Nego msg type

Variables

var (
	NegoPacket = &RPCNegoPacket{Magic: 0x4D4F4341, Flag: negotiationFlagNoHint, ID: []byte("")}
	HintPacket = &RPCPacket{Tp: PacketTypeHint}
)

var (
	ErrRPCHeaderSizeLimit = errors.New("rpc header size max error")
	ErrRPCBodySizeLimit   = errors.New("rpc body size max error")
	ErrRPCPeerIDSizeLimit = errors.New("rpc peerid size max error")
)

rpc codec errors

var ErrChanSize = errors.New("ikioSocket: excced the request channel size")

var ErrExited = errors.New("ikioSocket: connection closed")

var ErrTimeout = errors.New("ikioSocket: request timeout")

Functions

func Put

func Put(p *RPCPacket)

Types

type Context

type Context struct {
	Header map[string]string
	Body   []byte
}

type IKIOSocket

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

func New

func New(l *logging.Logger) *IKIOSocket

func (*IKIOSocket) Call

func (i *IKIOSocket) Call(req *Context, options ...Option) (*Context, error)

func (*IKIOSocket) Close

func (i *IKIOSocket) Close() error

func (*IKIOSocket) Start

func (i *IKIOSocket) Start(host string, dial time.Duration) error

func (*IKIOSocket) StartWithConn

func (i *IKIOSocket) StartWithConn(conn net.Conn)

type Option

type Option func(*Options)

func Timeout

func Timeout(t time.Duration) Option

type Options

type Options struct {
	RequestTimeout time.Duration
}

type RPCCodec

type RPCCodec struct {
	MaxHeaderLen int32
	MaxBodyLen   int32
	MaxPeerIDLen int32
	// contains filtered or unexported fields
}

func (*RPCCodec) Decode

func (rc *RPCCodec) Decode(reader *bufio.Reader) (ikio.Packet, error)

func (*RPCCodec) Encode

func (rc *RPCCodec) Encode(p ikio.Packet, writer io.Writer) (int, error)

type RPCNegoPacket

type RPCNegoPacket struct {
	Magic uint32
	ID    []byte
	Flag  uint32
}

func (*RPCNegoPacket) Serialize

func (rnp *RPCNegoPacket) Serialize() ([]byte, error)

func (*RPCNegoPacket) Type

func (rnp *RPCNegoPacket) Type() int32

type RPCPacket

type RPCPacket struct {
	ID      int64
	Code    int32
	Header  []RPCPacketHeader
	Payload []byte
	Tp      int32
	Flags   int32
}

func Get

func Get() *RPCPacket

func (*RPCPacket) AddHeader

func (rp *RPCPacket) AddHeader(key []byte, value []byte)

func (*RPCPacket) ForeachHeader

func (rp *RPCPacket) ForeachHeader(cb func(key, value []byte) error) error

func (*RPCPacket) GetHeader

func (rp *RPCPacket) GetHeader(key []byte) ([]byte, bool)

func (*RPCPacket) Serialize

func (rp *RPCPacket) Serialize() ([]byte, error)

func (*RPCPacket) Type

func (rp *RPCPacket) Type() int32

type RPCPacketHeader

type RPCPacketHeader struct {
	Key   []byte
	Value []byte
}

type Server

type Server struct {
	*ikio.Server
	*logging.Logger
	// contains filtered or unexported fields
}

func NewServer

func NewServer(l *logging.Logger, cb servercb) *Server

func (*Server) Start

func (s *Server) Start(ln net.Listener) error

func (*Server) Stop

func (s *Server) Stop()

type Timer

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

func NewTimer

func NewTimer(d time.Duration, cb func()) *Timer

func (*Timer) Start

func (t *Timer) Start()

func (*Timer) Stop

func (t *Timer) Stop()