packet

package
v1.1.5 Latest Latest
Warning

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

 Go to latest Published: Mar 24, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// 0 means sessionID required
	SessionIDNull uint64 = 0
	// 1 means default session
	SessionID1 uint64 = 1
)
View Source 
const (
	ClientIDNull uint64 = 0
)
View Source 
const (
	PacketIDNull uint64 = 0
)
View Source 
const (
	V01 = 0x01
)

Variables

View Source 
var (
	ErrUnsupportedPacket = errors.New("unsupported packet")
	ErrIncompletePacket  = errors.New("incomplete packet")
	ErrExpectingData     = errors.New("expecting data")
	ErrInvalidArguments  = errors.New("invalid arguments")
	ErrIllegalPacket     = errors.New("illegal packet")
)

Functions

func ClientIDToHex 

func ClientIDToHex(id uint64) string

func ConnLayer 

func ConnLayer(pkt Packet) bool

func Encode 

func Encode(pkt Packet) ([]byte, error)

func EncodeToWriter 

func EncodeToWriter(pkt Packet, writer io.Writer) error

func PacketIDHex 

func PacketIDHex(id uint64) string

func SessionIDHex 

func SessionIDHex(id uint64) string

func SessionLayer 

func SessionLayer(pkt Packet) bool

Types

type AppAbove 

type AppAbove interface {
	SessionAbove
}

type Cnss 

type Cnss byte
const (
	CnssAtMostOnce      Cnss = 0x01
	CnssAtLeastOnce     Cnss = 0x02
	CnssAtEffectiveOnce Cnss = 0x03
)

type ConnAbove 

type ConnAbove interface {
	ClientID() uint64
	SetClientID(clientID uint64)
}

type ConnAckPacket 

type ConnAckPacket struct {
	*PacketHeader
	RetCode  RetCode
	ClientID uint64
	ConnData *ConnData
}

func (*ConnAckPacket) Decode 

func (connAckPkt *ConnAckPacket) Decode(data []byte) (uint32, error)

func (*ConnAckPacket) DecodeFromReader 

func (connAckPkt *ConnAckPacket) DecodeFromReader(reader io.Reader) error

func (*ConnAckPacket) Encode 

func (connAckPkt *ConnAckPacket) Encode() ([]byte, error)

type ConnData 

type ConnData struct {
	Meta  []byte `json:"meta,omitempty"`
	Error string `json:"error,omitempty"`
}

TODO 约束，包id由双方保障单调递增可信

type ConnFlags 

type ConnFlags struct {
	Heartbeat Heartbeat // heartbeat define 2 bits

	Retain bool // 是否保留连接上下文 1 bit，TODO
	Clear  bool // 是否清除连接上下文 1 bit，TODO
	// contains filtered or unexported fields
}

type ConnPacket 

type ConnPacket struct {
	*PacketHeader
	ConnFlags
	ClientID uint64
	ConnData *ConnData
}

TODO authN

func (*ConnPacket) ClientIDAcquire 

func (connPkt *ConnPacket) ClientIDAcquire() bool

func (*ConnPacket) Decode 

func (connPkt *ConnPacket) Decode(data []byte) (uint32, error)

func (*ConnPacket) DecodeFromReader 

func (connPkt *ConnPacket) DecodeFromReader(reader io.Reader) error

func (*ConnPacket) Encode 

func (connPkt *ConnPacket) Encode() ([]byte, error)

type DisConnAckPacket 

type DisConnAckPacket struct {
	*PacketHeader
	RetCode  RetCode
	ConnData *ConnData
}

func (*DisConnAckPacket) Decode 

func (disConnAckPkt *DisConnAckPacket) Decode(data []byte) (uint32, error)

func (*DisConnAckPacket) DecodeFromReader 

func (disConnAckPkt *DisConnAckPacket) DecodeFromReader(reader io.Reader) error

func (*DisConnAckPacket) Encode 

func (disConnAckPkt *DisConnAckPacket) Encode() ([]byte, error)

type DisConnPacket 

type DisConnPacket struct {
	*PacketHeader
}

func (*DisConnPacket) Decode 

func (disConnPkt *DisConnPacket) Decode(data []byte) (uint32, error)

func (*DisConnPacket) DecodeFromReader 

func (disConnPkt *DisConnPacket) DecodeFromReader(reader io.Reader) error

func (*DisConnPacket) Encode 

func (disConnPkt *DisConnPacket) Encode() ([]byte, error)

type DismissAckPacket 

type DismissAckPacket struct {
	*PacketHeader

	SessionData *SessionData
	// contains filtered or unexported fields
}

func (DismissAckPacket) ClientID 

func (basePacket DismissAckPacket) ClientID() uint64

func (*DismissAckPacket) Decode 

func (pkt *DismissAckPacket) Decode(data []byte) (uint32, error)

func (*DismissAckPacket) DecodeFromReader 

func (pkt *DismissAckPacket) DecodeFromReader(reader io.Reader) error

func (*DismissAckPacket) Encode 

func (pkt *DismissAckPacket) Encode() ([]byte, error)

func (*DismissAckPacket) SessionID 

func (pkt *DismissAckPacket) SessionID() uint64

func (*DismissAckPacket) SetSessionID 

func (pkt *DismissAckPacket) SetSessionID(sessionID uint64)

type DismissPacket 

type DismissPacket struct {
	*PacketHeader

	SessionData *SessionData
	// contains filtered or unexported fields
}

func (DismissPacket) ClientID 

func (basePacket DismissPacket) ClientID() uint64

func (*DismissPacket) Decode 

func (pkt *DismissPacket) Decode(data []byte) (uint32, error)

func (*DismissPacket) DecodeFromReader 

func (pkt *DismissPacket) DecodeFromReader(reader io.Reader) error

func (*DismissPacket) Encode 

func (pkt *DismissPacket) Encode() ([]byte, error)

func (*DismissPacket) SessionID 

func (pkt *DismissPacket) SessionID() uint64

func (*DismissPacket) SetSessionID 

func (pkt *DismissPacket) SetSessionID(sessionID uint64)

type Heartbeat 

type Heartbeat time.Duration
const (
	Heartbeat5   Heartbeat = 5
	Heartbeat20  Heartbeat = 20
	Heartbeat80  Heartbeat = 80
	Heartbeat320 Heartbeat = 320
)

type HeartbeatAckPacket 

type HeartbeatAckPacket struct {
	*PacketHeader
}

func (*HeartbeatAckPacket) Decode 

func (hbAckPkt *HeartbeatAckPacket) Decode(data []byte) (uint32, error)

func (*HeartbeatAckPacket) DecodeFromReader 

func (hbAckPkt *HeartbeatAckPacket) DecodeFromReader(reader io.Reader) error

func (*HeartbeatAckPacket) Encode 

func (hbAckPkt *HeartbeatAckPacket) Encode() ([]byte, error)

type HeartbeatPacket 

type HeartbeatPacket struct {
	*PacketHeader
}

func (*HeartbeatPacket) Decode 

func (hbPkt *HeartbeatPacket) Decode(data []byte) (uint32, error)

func (*HeartbeatPacket) DecodeFromReader 

func (hbPkt *HeartbeatPacket) DecodeFromReader(reader io.Reader) error

func (*HeartbeatPacket) Encode 

func (hbPkt *HeartbeatPacket) Encode() ([]byte, error)

type MessageAckPacket 

type MessageAckPacket struct {
	*PacketHeader

	Data *MessageData
	// contains filtered or unexported fields
}

func (MessageAckPacket) ClientID 

func (basePacket MessageAckPacket) ClientID() uint64

func (*MessageAckPacket) Decode 

func (pkt *MessageAckPacket) Decode(data []byte) (uint32, error)

func (*MessageAckPacket) DecodeFromReader 

func (pkt *MessageAckPacket) DecodeFromReader(reader io.Reader) error

func (*MessageAckPacket) Encode 

func (pkt *MessageAckPacket) Encode() ([]byte, error)

func (*MessageAckPacket) SessionID 

func (pkt *MessageAckPacket) SessionID() uint64

func (*MessageAckPacket) SetSessionID 

func (pkt *MessageAckPacket) SetSessionID(sessionID uint64)

type MessageData 

type MessageData struct {
	Key      []byte        `json:"key,omitempty"`
	Value    []byte        `json:"value,omitempty"`
	Topic    string        `json:"topic,omitempty"`
	Custom   []byte        `json:"custom,omitempty"`
	Error    string        `json:"error,omitempty"`
	Timeout  time.Duration `json:"timeout,omitempty"`
	Deadline time.Time     `json:"deadline,omitempty"`
	Context  struct {
		Deadline time.Time `json:"deadline,omitempty"`
	} `json:"context,omitempty"`
}

TODO 待优化

type MessagePacket 

type MessagePacket struct {
	*PacketHeader

	Data *MessageData
	// contains filtered or unexported fields
}

func (MessagePacket) ClientID 

func (basePacket MessagePacket) ClientID() uint64

func (*MessagePacket) Decode 

func (pkt *MessagePacket) Decode(data []byte) (uint32, error)

func (*MessagePacket) DecodeFromReader 

func (pkt *MessagePacket) DecodeFromReader(reader io.Reader) error

func (*MessagePacket) Encode 

func (pkt *MessagePacket) Encode() ([]byte, error)

func (*MessagePacket) SessionID 

func (pkt *MessagePacket) SessionID() uint64

func (*MessagePacket) SetSessionID 

func (pkt *MessagePacket) SetSessionID(sessionID uint64)

type Packet 

type Packet interface {
	Decode(data []byte) (uint32, error)
	DecodeFromReader(reader io.Reader) error
	Encode() ([]byte, error)
	Length() int

	Consistency() Cnss
	ID() uint64
	Type() Type
}

func Decode 

func Decode(data []byte) (Packet, uint32, error)

func DecodeFromReader 

func DecodeFromReader(reader io.Reader) (Packet, error)

type PacketFactory 

type PacketFactory interface {
	NewPacketID() uint64
	// conn layer
	NewConnPacket(wanted uint64, peersCall bool, heartbeat Heartbeat, meta []byte) *ConnPacket
	NewConnAckPacket(packetID uint64, confirmedClientID uint64, err error) *ConnAckPacket
	NewDisConnPacket() *DisConnPacket
	NewDisConnAckPacket(packetID uint64, err error) *DisConnAckPacket
	NewHeartbeatPacket() *HeartbeatPacket
	NewHeartbeatAckPacket(packetID uint64) *HeartbeatAckPacket
	// session layer
	NewSessionPacket(negotiateID uint64, sessionIDPeersCall bool, meta []byte, peer string) *SessionPacket
	NewSessionAckPacket(packetID uint64, negotiateID uint64, confirmedID uint64, err error) *SessionAckPacket
	NewDismissPacket(sessionID uint64) *DismissPacket
	NewDismissAckPacket(packetID uint64, sessionID uint64, err error) *DismissAckPacket
	// application layer
	NewMessagePacket(key, value []byte) *MessagePacket
	NewMessagePacketWithIDAndSessionID(id, sessionID uint64, key, value []byte) *MessagePacket
	NewMessagePacketWithSessionID(sessionID uint64, key, value, custom []byte) *MessagePacket
	NewMessageAckPacket(packetID uint64, err error) *MessageAckPacket
	NewMessageAckPacketWithSessionID(sessionID, packetID uint64, err error) *MessageAckPacket
	NewRequestPacket(pattern, data []byte) *RequestPacket
	NewRequestCancelPacketWithIDAndSessionID(id, sessionID uint64, cancelType RequestCancelType) *RequestCancelPacket
	NewRequestPacketWithIDAndSessionID(id, sessionID uint64, pattern, data []byte) *RequestPacket
	NewResponsePacket(requestPacketID uint64, pattern, data []byte, err error) *ResponsePacket
	NewStreamPacket(data []byte) *StreamPacket
	NewStreamPacketWithSessionID(sessionID uint64, data []byte) *StreamPacket
	NewRegisterPacket(method []byte) *RegisterPacket
	NewRegisterPacketWithSessionID(sessionID uint64, method []byte) *RegisterPacket
	NewRegisterAckPacket(packetID uint64, err error) *RegisterAckPacket
	NewRegisterAckPacketWithSessionID(sessionID uint64, packetID uint64, err error) *RegisterAckPacket
}

func NewPacketFactory 

func NewPacketFactory(packetIDs *id.IDCounter) PacketFactory

type PacketHeader 

type PacketHeader struct {
	Version   Version
	Typ       Type
	PacketID  uint64
	PacketLen uint32
	Cnss      Cnss
}

func (*PacketHeader) Consistency 

func (pktHdr *PacketHeader) Consistency() Cnss

func (*PacketHeader) Decode 

func (pktHdr *PacketHeader) Decode(data []byte) (uint32, error)

func (*PacketHeader) DecodeFromReader 

func (pktHdr *PacketHeader) DecodeFromReader(reader io.Reader) error

func (*PacketHeader) Encode 

func (pktHdr *PacketHeader) Encode() ([]byte, error)

func (*PacketHeader) ID 

func (pktHdr *PacketHeader) ID() uint64

func (*PacketHeader) Length 

func (pktHdr *PacketHeader) Length() int

Length returns payload length

func (*PacketHeader) Type 

func (pktHdr *PacketHeader) Type() Type

type RegisterAckPacket 

type RegisterAckPacket struct {
	*PacketHeader

	RegisterData *RegisterData
	// contains filtered or unexported fields
}

func (RegisterAckPacket) ClientID 

func (basePacket RegisterAckPacket) ClientID() uint64

func (*RegisterAckPacket) Decode 

func (pkt *RegisterAckPacket) Decode(data []byte) (uint32, error)

func (*RegisterAckPacket) DecodeFromReader 

func (pkt *RegisterAckPacket) DecodeFromReader(reader io.Reader) error

func (*RegisterAckPacket) Encode 

func (pkt *RegisterAckPacket) Encode() ([]byte, error)

func (*RegisterAckPacket) SessionID 

func (pkt *RegisterAckPacket) SessionID() uint64

func (*RegisterAckPacket) SetSessionID 

func (pkt *RegisterAckPacket) SetSessionID(sessionID uint64)

type RegisterData 

type RegisterData struct {
	Error string `json:"error,omitempty"`
}

type RegisterPacket 

type RegisterPacket struct {
	*PacketHeader
	// contains filtered or unexported fields
}

func (RegisterPacket) ClientID 

func (basePacket RegisterPacket) ClientID() uint64

func (*RegisterPacket) Decode 

func (pkt *RegisterPacket) Decode(data []byte) (uint32, error)

func (*RegisterPacket) DecodeFromReader 

func (pkt *RegisterPacket) DecodeFromReader(reader io.Reader) error

func (*RegisterPacket) Encode 

func (pkt *RegisterPacket) Encode() ([]byte, error)

func (*RegisterPacket) Length 

func (pkt *RegisterPacket) Length() int

func (*RegisterPacket) Method 

func (pkt *RegisterPacket) Method() string

func (*RegisterPacket) SessionID 

func (pkt *RegisterPacket) SessionID() uint64

func (*RegisterPacket) SetSessionID 

func (pkt *RegisterPacket) SetSessionID(sessionID uint64)

type RequestCancelPacket 

type RequestCancelPacket struct {
	*PacketHeader
	// contains filtered or unexported fields
}

Request cancel packet for RPC cancelation

func (*RequestCancelPacket) Decode 

func (pkt *RequestCancelPacket) Decode(data []byte) (uint32, error)

func (*RequestCancelPacket) DecodeFromReader 

func (pkt *RequestCancelPacket) DecodeFromReader(reader io.Reader) error

func (*RequestCancelPacket) Encode 

func (pkt *RequestCancelPacket) Encode() ([]byte, error)

func (*RequestCancelPacket) SessionID 

func (pkt *RequestCancelPacket) SessionID() uint64

func (*RequestCancelPacket) SetSessionID 

func (pkt *RequestCancelPacket) SetSessionID(sessionID uint64)

type RequestCancelType 

type RequestCancelType int16
const (
	RequestCancelTypeCanceled         RequestCancelType = 1
	RequestCancelTypeDeadlineExceeded RequestCancelType = 2
)

type RequestPacket 

type RequestPacket struct {
	*MessagePacket
}

Request packet for RPC call

func (RequestPacket) ClientID 

func (basePacket RequestPacket) ClientID() uint64

type ResponsePacket 

type ResponsePacket struct {
	*MessageAckPacket
}

Response packet for RPC handler

func (ResponsePacket) ClientID 

func (basePacket ResponsePacket) ClientID() uint64

type RetCode 

type RetCode byte
const (
	RetCodeOK  RetCode = 0x00
	RetCodeERR RetCode = 0x01
)

type SessionAbove 

type SessionAbove interface {
	SessionID() uint64
	SetSessionID(sessionID uint64)
}

type SessionAckPacket 

type SessionAckPacket struct {
	*PacketHeader
	SessionFlags // 16 bits, unused now

	SessionData *SessionData
	// contains filtered or unexported fields
}

func (SessionAckPacket) ClientID 

func (basePacket SessionAckPacket) ClientID() uint64

func (*SessionAckPacket) Decode 

func (pkt *SessionAckPacket) Decode(data []byte) (uint32, error)

func (*SessionAckPacket) DecodeFromReader 

func (pkt *SessionAckPacket) DecodeFromReader(reader io.Reader) error

func (*SessionAckPacket) Encode 

func (pkt *SessionAckPacket) Encode() ([]byte, error)

func (*SessionAckPacket) NegotiateID 

func (pkt *SessionAckPacket) NegotiateID() uint64

func (*SessionAckPacket) SessionID 

func (pkt *SessionAckPacket) SessionID() uint64

func (*SessionAckPacket) SetError 

func (pkt *SessionAckPacket) SetError(err error)

func (*SessionAckPacket) SetSessionID 

func (pkt *SessionAckPacket) SetSessionID(sessionID uint64)

type SessionData 

type SessionData struct {
	Meta  []byte `json:"meta,omitempty"`
	Error string `json:"error,omitempty"`
	Peer  string `json:"peer,omitempty"`
}

type SessionFlags 

type SessionFlags struct {
	Priority uint8 // 8 bits
	Qos      int8  // 4 bits, unused now
	// contains filtered or unexported fields
}

type SessionPacket 

type SessionPacket struct {
	*PacketHeader
	SessionFlags // 16 bits

	SessionData *SessionData // elastic fields
	// contains filtered or unexported fields
}

func (SessionPacket) ClientID 

func (basePacket SessionPacket) ClientID() uint64

func (*SessionPacket) Decode 

func (pkt *SessionPacket) Decode(data []byte) (uint32, error)

func (*SessionPacket) DecodeFromReader 

func (pkt *SessionPacket) DecodeFromReader(reader io.Reader) error

func (*SessionPacket) Encode 

func (pkt *SessionPacket) Encode() ([]byte, error)

func (*SessionPacket) NegotiateID 

func (pkt *SessionPacket) NegotiateID() uint64

func (*SessionPacket) SessionID 

func (pkt *SessionPacket) SessionID() uint64

func (*SessionPacket) SessionIDAcquire 

func (pkt *SessionPacket) SessionIDAcquire() bool

func (*SessionPacket) SetSessionID 

func (pkt *SessionPacket) SetSessionID(sessionID uint64)

type StreamPacket 

type StreamPacket struct {
	*PacketHeader

	Data []byte
	// contains filtered or unexported fields
}

func (StreamPacket) ClientID 

func (basePacket StreamPacket) ClientID() uint64

func (*StreamPacket) Decode 

func (pkt *StreamPacket) Decode(data []byte) (uint32, error)

func (*StreamPacket) DecodeFromReader 

func (pkt *StreamPacket) DecodeFromReader(reader io.Reader) error

func (*StreamPacket) Encode 

func (pkt *StreamPacket) Encode() ([]byte, error)

func (*StreamPacket) Length 

func (pkt *StreamPacket) Length() int

func (*StreamPacket) SessionID 

func (pkt *StreamPacket) SessionID() uint64

func (*StreamPacket) SetSessionID 

func (pkt *StreamPacket) SetSessionID(sessionID uint64)

type Type 

type Type byte
const (
	TypeConnPacket          Type = 0x01
	TypeConnAckPacket       Type = 0x02
	TypeDisConnPacket       Type = 0x11
	TypeDisConnAckPacket    Type = 0x12
	TypeHeartbeatPacket     Type = 0x21
	TypeHeartbeatAckPacket  Type = 0x22
	TypeSessionPacket       Type = 0x31
	TypeSessionAckPacket    Type = 0x32
	TypeDismissPacket       Type = 0x41
	TypeDismissAckPacket    Type = 0x42
	TypeMessagePacket       Type = 0x51
	TypeMessageAckPacket    Type = 0x52
	TypeStreamPacket        Type = 0x61
	TypeRequestPacket       Type = 0x71
	TypeResponsePacket      Type = 0x72
	TypeRequestCancelPacket Type = 0x73
	TypeRegisterPacket      Type = 0x81
	TypeRegisterAckPacket   Type = 0x82
)

func (Type) String 

func (typ Type) String() string

type Version 

type Version byte

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.