getty

package
v1.2.10 Latest Latest
Warning

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

 Go to latest Published: Jul 31, 2020 License: Apache-2.0 Imports: 26 Imported by: 13

Documentation

Index

Constants

View Source 
const (
	CompressNone            CompressType = flate.NoCompression      // 0
	CompressZip                          = flate.DefaultCompression // -1
	CompressBestSpeed                    = flate.BestSpeed          // 1
	CompressBestCompression              = flate.BestCompression    // 9
	CompressHuffman                      = flate.HuffmanOnly        // -2
	CompressSnappy                       = 10
)
View Source 
const (
	Version     = "1.2.7"
	DATE        = "2020/04/01"
	GETTY_MAJOR = 1
	GETTY_MINOR = 2
	GETTY_BUILD = 7
)
View Source 
const (
	MaxWheelTimeSpan = 900e9 // 900s, 15 minute

)

Variables

View Source 
var (
	ErrSessionClosed  = jerrors.New("session Already Closed")
	ErrSessionBlocked = jerrors.New("session Full Blocked")
	ErrNullPeerAddr   = jerrors.New("peer address is nil")
)
View Source 
var EndPointType_name = map[int32]string{
	0: "UDP_ENDPOINT",
	1: "UDP_CLIENT",
	2: "TCP_CLIENT",
	3: "WS_CLIENT",
	4: "WSS_CLIENT",
	7: "TCP_SERVER",
	8: "WS_SERVER",
	9: "WSS_SERVER",
}
View Source 
var EndPointType_value = map[string]int32{
	"UDP_ENDPOINT": 0,
	"UDP_CLIENT":   1,
	"TCP_CLIENT":   2,
	"WS_CLIENT":    3,
	"WSS_CLIENT":   4,
	"TCP_SERVER":   7,
	"WS_SERVER":    8,
	"WSS_SERVER":   9,
}

Functions

func GetTimeWheel 

func GetTimeWheel() *gxtime.Wheel

Types

type Client 

type Client interface {
	EndPoint
}

func NewTCPClient 

func NewTCPClient(opts ...ClientOption) Client

NewTcpClient function builds a tcp client.

func NewUDPClient 

func NewUDPClient(opts ...ClientOption) Client

NewUdpClient function builds a connected udp client

func NewWSClient 

func NewWSClient(opts ...ClientOption) Client

NewWsClient function builds a ws client.

func NewWSSClient 

func NewWSSClient(opts ...ClientOption) Client

NewWSSClient function builds a wss client.

type ClientOption 

type ClientOption func(*ClientOptions)

func WithConnectionNumber 

func WithConnectionNumber(num int) ClientOption

@num is connection number.

func WithReconnectInterval 

func WithReconnectInterval(reconnectInterval int) ClientOption

@reconnectInterval is server address.

func WithRootCertificateFile 

func WithRootCertificateFile(cert string) ClientOption

@cert is client certificate file. it can be empty.

func WithServerAddress 

func WithServerAddress(addr string) ClientOption

@addr is server address.

type ClientOptions 

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

type CompressType 

type CompressType int

type Connection 

type Connection interface {
	ID() uint32
	SetCompressType(CompressType)
	LocalAddr() string
	RemoteAddr() string

	// update session's active time
	UpdateActive()
	// get session's active time
	GetActive() time.Time

	// SetReadTimeout sets deadline for the future read calls.
	SetReadTimeout(time.Duration)

	// SetWriteTimeout sets deadline for the future read calls.
	SetWriteTimeout(time.Duration)
	// contains filtered or unexported methods
}

type EndPoint 

type EndPoint interface {
	// get EndPoint ID
	ID() EndPointID
	// get endpoint type
	EndPointType() EndPointType
	// run event loop and serves client request.
	RunEventLoop(newSession NewSessionCallback)
	// check the endpoint has been closed
	IsClosed() bool
	// close the endpoint and free its resource
	Close()
}

type EndPointID 

type EndPointID = int32

type EndPointType 

type EndPointType int32
const (
	UDP_ENDPOINT EndPointType = 0
	UDP_CLIENT   EndPointType = 1
	TCP_CLIENT   EndPointType = 2
	WS_CLIENT    EndPointType = 3
	WSS_CLIENT   EndPointType = 4
	TCP_SERVER   EndPointType = 7
	WS_SERVER    EndPointType = 8
	WSS_SERVER   EndPointType = 9
)

func (EndPointType) String 

func (x EndPointType) String() string

type EventListener 

type EventListener interface {
	// invoked when session opened
	// If the return error is not nil, @Session will be closed.
	OnOpen(Session) error

	// invoked when session closed.
	OnClose(Session)

	// invoked when got error.
	OnError(Session, error)

	// invoked periodically, its period can be set by (Session)SetCronPeriod
	OnCron(Session)

	// invoked when getty received a package. Pls attention that do not handle long time
	// logic processing in this func. You'd better set the package's maximum length.
	// If the message's length is greater than it, u should should return err in
	// Reader{Read} and getty will close this connection soon.
	//
	// If ur logic processing in this func will take a long time, u should start a goroutine
	// pool(like working thread pool in cpp) to handle the processing asynchronously. Or u
	// can do the logic processing in other asynchronous way.
	// !!!In short, ur OnMessage callback func should return asap.
	//
	// If this is a udp event listener, the second parameter type is UDPContext.
	OnMessage(Session, interface{})
}

EventListener is used to process pkg that received from remote session

type NewSessionCallback 

type NewSessionCallback func(Session) error

NewSessionCallback will be invoked when server accepts a new client connection or client connects to server successfully. If there are too many client connections or u do not want to connect a server again, u can return non-nil error. And then getty will close the new session.

type PacketServer added in v1.2.9 

type PacketServer interface {
	Server
	// get the network listener
	PacketConn() net.PacketConn
}

PacketServer is like udp listen endpoint

type ReadWriter 

type ReadWriter interface {
	Reader
	Writer
}

package handler interface

type Reader 

type Reader interface {
	// Parse tcp/udp/websocket pkg from buffer and if possible return a complete pkg.
	// When receiving a tcp network streaming segment, there are 4 cases as following:
	// case 1: a error found in the streaming segment;
	// case 2: can not unmarshal a pkg header from the streaming segment;
	// case 3: unmarshal a pkg header but can not unmarshal a pkg from the streaming segment;
	// case 4: just unmarshal a pkg from the streaming segment;
	// case 5: unmarshal more than one pkg from the streaming segment;
	//
	// The return value is (nil, 0, error) as case 1.
	// The return value is (nil, 0, nil) as case 2.
	// The return value is (nil, pkgLen, nil) as case 3.
	// The return value is (pkg, pkgLen, nil) as case 4.
	// The handleTcpPackage may invoke func Read many times as case 5.
	Read(Session, []byte) (interface{}, int, error)
}

Reader is used to unmarshal a complete pkg from buffer

type Server 

type Server interface {
	EndPoint
}

Server interface

func NewTCPServer 

func NewTCPServer(opts ...ServerOption) Server

NewTCServer builds a tcp server.

func NewUDPPEndPoint 

func NewUDPPEndPoint(opts ...ServerOption) Server

NewUDPEndPoint builds a unconnected udp server.

func NewWSSServer 

func NewWSSServer(opts ...ServerOption) Server

NewWSSServer builds a secure websocket server.

func NewWSServer 

func NewWSServer(opts ...ServerOption) Server

NewWSServer builds a websocket server.

type ServerOption 

type ServerOption func(*ServerOptions)

func WithLocalAddress 

func WithLocalAddress(addr string) ServerOption

@addr server listen address.

func WithWebsocketServerCert 

func WithWebsocketServerCert(cert string) ServerOption

@cert: server certificate file

func WithWebsocketServerPath 

func WithWebsocketServerPath(path string) ServerOption

@path: websocket request url path

func WithWebsocketServerPrivateKey 

func WithWebsocketServerPrivateKey(key string) ServerOption

@key: server private key(contains its public key)

func WithWebsocketServerRootCert 

func WithWebsocketServerRootCert(cert string) ServerOption

@cert is the root certificate file to verify the legitimacy of server

type ServerOptions 

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

type Session 

type Session interface {
	Connection
	Reset()
	Conn() net.Conn
	Stat() string
	IsClosed() bool
	// get endpoint type
	EndPoint() EndPoint

	SetMaxMsgLen(int)
	SetName(string)
	SetEventListener(EventListener)
	SetPkgHandler(ReadWriter)
	SetReader(Reader)
	SetWriter(Writer)
	SetCronPeriod(int)

	// Deprecated: don't use read queue.
	SetRQLen(int)
	SetWQLen(int)
	SetWaitTime(time.Duration)
	SetTaskPool(*gxsync.TaskPool)

	GetAttribute(interface{}) interface{}
	SetAttribute(interface{}, interface{})
	RemoveAttribute(interface{})

	// the Writer will invoke this function. Pls attention that if timeout is less than 0, WritePkg will send @pkg asap.
	// for udp session, the first parameter should be UDPContext.
	WritePkg(pkg interface{}, timeout time.Duration) error
	WriteBytes([]byte) error
	WriteBytesArray(...[]byte) error
	Close()
}

type StreamServer added in v1.2.9 

type StreamServer interface {
	Server
	// get the network listener
	Listener() net.Listener
}

StreamServer is like tcp/websocket/wss server

type UDPContext 

type UDPContext struct {
	Pkg      interface{}
	PeerAddr *net.UDPAddr
}

func (UDPContext) String 

func (c UDPContext) String() string

type Writer 

type Writer interface {
	// if @Session is udpGettySession, the second parameter is UDPContext.
	Write(Session, interface{}) ([]byte, error)
}

Writer is used to marshal pkg and write to session

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.