pillx

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

type Client struct {
	Addr string
}

type ClientData struct {
	Uid      int32
	RoomId   int32
	Channel  *Channel
	Platform int32
	Ip       string
	Uname    string
}

type ClientDataStruct struct {
	Uid      int
	RoomId   int
	Channel  *Channel
	Platform int
	Ip       string
	Uname    string
}

type Conn struct {
	Id uint64

	HandshakeFlg bool //是否已经通过握手验证
	// contains filtered or unexported fields
}

type Factory func() (*PoolConn, error)

type GateWayProtocol struct {
	Header *GatewayHeader
	//IPHeader *GatewayParamsHeader
	//IP       []byte
	//DataHeader *GatewayParamsHeader
	Content []byte
}

type Gateway struct {
	InnerAddr     string
	OuterAddr     string
	OuterProtocol IProtocol
	InnerServer   *Server
	OuterServer   *Server
	EtcdClient    *etcd.Client
	GatewayName   string
	WatchName     string
}

type GatewayHeader struct {
	Mark     uint8
	Version  uint8
	Cmd      uint16
	Sid      uint32
	ClientId uint64
	Error    uint16
	Size     uint16
}

type GatewayParamsHeader struct {
	Type uint8 //1.开始2.中断3.结束3.参数8.data
	Size uint16
}

type GatewayWebsocket struct {
	InnerAddr     string
	OuterAddr     string
	OuterProtocol IProtocol
	InnerServer   *Server
	OuterServer   *Server
	EtcdClient    *etcd.Client
	GatewayName   string
	WatchName     string
}

type Handler interface {
	Serve(*Response, IProtocol)
}

type HandlerFunc func(*Response, IProtocol)

type IProtocol interface {
	Analyze(client *Response) (err error)
	Encode(msg interface{}) (buf []byte, err error)
	Decode(buf []byte) (err error)
	GetCmd() (cmd uint16)
	New() (protocol IProtocol)
}

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

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

type PillProtocol struct {
	Header  *PillProtocolHeader
	Content []byte
}

type PillProtocolHeader struct {
	Mark    uint8
	Version uint8
	Cmd     uint16
	Sid     uint32
	Error   uint16
	Size    uint16
}

type Pool interface {
	// Get returns a new connection from the pool. Closing the connections puts
	// it back to the Pool. Closing it when the pool is destroyed or full will
	// be counted as an error.
	Get() (*PoolConn, error)

	// Close closes the pool and all its connections. After Close() the pool is
	// no longer usable.
	Close()

	// Len returns the current number of connections of the pool.
	Len() int
}

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

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

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

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

type Server struct {
	Addr     string  // TCP address to listen on, ":http" if empty
	Handler  Handler // handler to invoke, http.DefaultServeMux if nil
	Protocol IProtocol

	// ErrorLog specifies an optional logger for errors accepting
	// connections and unexpected behavior from handlers.
	// If nil, logging goes to os.Stderr via the log package's
	// standard logger.
	ErrorLog *log.Logger
}

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

type TextProtocol struct {
	Content []byte
}

type WebSocketHeader struct {
	OpcodeByte  byte
	PayloadByte byte
}

type WebSocketProtocol struct {
	Header  *WebSocketHeader
	Content []byte
}

type Worker struct {
	InnerAddr   string
	InnerServer *Server
	EtcdClient  *etcd.Client
	WorkerName  string
	WatchName   string
}

type WorkerClient struct {
	IP string
}