net

package
v0.0.0-...-04cfb28 Latest Latest
Warning

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

 Go to latest Published: May 22, 2020 License: MIT Imports: 25 Imported by: 9

README

目录

协议格式

  • 协议格式，小端字节序
包体长度 命令号 扩展字段 包体
4字节 4字节 8字节 包体
  1. 包体长度，4字节，有最大长度限制，TcpServer/TcpEngine可以通过SetSockMaxPackLen设置最大包长
  2. 命令号，4字节，用户层协议最大命令号为0xFFFFFF，大于0xFFFFFF为net包保留协议号 心跳包协议号： CmdPing = uint32(0x1 << 24)，无需包体
  3. 扩展字段，在rpc时为rpc call的序号标识
  4. 包体，用户可以自由选择序列化方案

Tcp Echo

tcp echo server

package main

import (
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var ()

const (
	addr = ":8888"

	CMD_ECHO = uint32(1)
)

func onEcho(client *net.TcpClient, msg net.IMessage) {
	log.Info("tcp server onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Body()))
	client.SendMsg(msg)
}

func main() {
	server := net.NewTcpServer("Echo")

	// 初始化协议号
	server.Handle(CMD_ECHO, onEcho)

	server.Serve(addr, time.Second*5)
}

tcp echo client

package main

import (
	"fmt"
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var (
	addr = "127.0.0.1:8888"

	CMD_ECHO = uint32(1)
)

func onConnected(c *net.TcpClient) {
	log.Info("TcpClient OnConnected")
}

func onEcho(client *net.TcpClient, msg net.IMessage) {
	log.Debug("tcp client onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Body()))
}

func main() {
	autoReconn := true
	netengine := net.NewTcpEngine()

	// 初始化协议号
	netengine.Handle(CMD_ECHO, onEcho)

	client, err := net.NewTcpClient(addr, netengine, nil, autoReconn, onConnected)
	if err != nil {
		log.Panic("NewTcpClient failed: %v, %v", client, err)
	}

	for i := 0; true; i++ {
		err = client.SendMsg(net.NewMessage(CMD_ECHO, []byte(fmt.Sprintf("hello %v", i))))
		if err != nil {
			log.Error("tcp client echo failed: %v", err)
		}
		time.Sleep(time.Second)
	}
}

Websocket Echo

用户自定义消息处理

raw ws echo server

package main

import (
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
)

var (
	addr = ":8888"

	CMD_ECHO = uint32(1)
)

func onEcho(client *net.WSClient, msg net.IMessage) {
	log.Info("ws server onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Data()))
	client.SendMsg(msg)
}

func main() {
	server, err := net.NewWebsocketServer("echo", addr)
	if err != nil {
		log.Panic("NewWebsocketServer failed: %v", err)
	}

	// 初始化http ws路由
	server.HandleWs("/ws/echo")

	// 设置消息处理接口
	server.HandleMessage(onEcho)

	server.Serve()
}

raw ws echo client

package main

import (
	"fmt"
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var (
	addr = "ws://localhost:8888/ws/echo"
)

func onMessage(client *net.WSClient, msg net.IMessage) {
	log.Debug("ws client onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Data()))
}

func main() {
	client, err := net.NewWebsocketClient(addr)
	if err != nil {
		log.Panic("NewWebsocketClient failed: %v, %v", err, time.Now())
	}

	// 设置消息处理接口
	client.HandleMessage(onMessage)

	for i := 0; true; i++ {
		err = client.SendMsg(net.RawMessage([]byte(fmt.Sprintf("hello %v", i))))
		if err != nil {
			log.Error("ws client echo failed: %v", err)
			break
		}
		time.Sleep(time.Second)
	}
}

按KISS的协议格式处理消息

kiss ws echo server

package main

import (
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
)

var (
	addr = ":8888"

	CMD_ECHO = uint32(1)
)

func onEcho(client *net.WSClient, msg net.IMessage) {
	log.Info("ws server onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Body()))
	client.SendMsg(msg)
}

func main() {
	server, err := net.NewWebsocketServer("echo", addr)
	if err != nil {
		log.Panic("NewWebsocketServer failed: %v", err)
	}

	// 初始化http ws路由
	server.HandleWs("/ws/echo")

	// 初始化协议号
	server.Handle(CMD_ECHO, onEcho)

	server.Serve()
}

kiss ws echo client

package main

import (
	"fmt"
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var (
	addr = "ws://localhost:8888/ws/echo"

	CMD_ECHO = uint32(1)
)

func onEcho(client *net.WSClient, msg net.IMessage) {
	log.Debug("ws client onEcho from %v: %v", client.Conn.RemoteAddr().String(), string(msg.Body()))
}

func main() {
	client, err := net.NewWebsocketClient(addr)
	if err != nil {
		log.Panic("NewWebsocketClient failed: %v, %v", err, time.Now())
	}

	// 初始化协议号
	client.Handle(CMD_ECHO, onEcho)

	for i := 0; true; i++ {
		err = client.SendMsg(net.NewMessage(CMD_ECHO, []byte(fmt.Sprintf("hello %v", i))))
		if err != nil {
			log.Error("ws client echo failed: %v", err)
			break
		}
		time.Sleep(time.Second)
	}
}

Rpc Echo

rpc server

package main

import (
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var (
	addr = "0.0.0.0:8888"
)

type HelloRequest struct {
	Message string
}

type HelloResponse struct {
	Message string
}

// Hello方法
func Hello(ctx *net.RpcContext) {
	req := &HelloRequest{}

	err := ctx.Bind(req)
	if err != nil {
		log.Error("Hello failed: %v", err)
		return
	}

	// 直接回包
	// err = ctx.Write(&HelloResponse{Message: req.Message})
	// if err != nil {
	// 	log.Error("Hello failed: %v", err)
	// 	return
	// }
	// log.Info("HelloRequest: %v", req.Message)

	// 支持异步回包
	go func() {
		err = ctx.Write(&HelloResponse{Message: req.Message})
		if err != nil {
			log.Error("Hello failed: %v", err)
			return
		}

		log.Info("HelloRequest: %v", req.Message)
	}()
}

func main() {
	server := net.NewRpcServer("Rpc")

	// 初始化方法，类似http初始化路由
	server.HandleRpcMethod("Hello", Hello)

	// 启动服务
	server.Serve(addr, time.Second*5)
}

rpc client

package main

import (
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"time"
)

var (
	addr = "0.0.0.0:8888"
)

type HelloRequest struct {
	Message string
}

type HelloResponse struct {
	Message string
}

func onConnected(c *net.RpcClient) {
	log.Info("RpcClient OnConnected")
}

func main() {
	engine := net.NewTcpEngine()
	client, err := net.NewRpcClient(addr, engine, nil, onConnected)
	if err != nil {
		log.Panic("NewReqClient Error: %v", err)
	}

	for {
		req := &HelloRequest{Message: "kiss"}
		rsp := &HelloResponse{}

		// 调用Hello方法
		err = client.Call("Hello", req, rsp, time.Second*3)
		if err != nil {
			log.Error("Hello failed: %v", err)
		} else {
			log.Info("HelloResponse: %v", rsp.Message)
		}

		time.Sleep(time.Second)
	}
}

Http Echo

http server

  • http只是简单支持优雅退出，实际路由等请使用标准库或其他第三方包
package main

import (
	"github.com/gin-gonic/gin"
	"github.com/nothollyhigh/kiss/log"
	"github.com/nothollyhigh/kiss/net"
	"net/http"
	"time"
)

// http://localhost:8080/hello
func main() {
	addr := ":8080"

	gin.SetMode(gin.ReleaseMode)

	router := gin.Default()
	router.GET("/hello", func(c *gin.Context) {
		log.Info("onHello")
		c.String(http.StatusOK, "hello")
	})

	net.ServeHttp("Hello", addr, router, time.Second*5, nil)
}

Documentation

Index

Constants

View Source 
const (
	CipherGzipAll  = 0
	CipherGzipNone = -1

	DefaultThreshold = CipherGzipNone
)
View Source 
const (
	// default message header length
	DEFAULT_MESSAGE_HEAD_LEN int = 16

	// default body length begin idx
	DEFAULT_BODY_LEN_IDX_BEGIN int = 0
	// default body length end idx
	DEFAULT_BODY_LEN_IDX_END int = 4

	// default cmd begin idx
	DEFAULT_CMD_IDX_BEGIN int = 4
	// default cmd end idx
	DEFAULT_CMD_IDX_END int = 8

	// default extension begin idx
	DEFAULT_EXT_IDX_BEGIN int = 8
	// default extension end idx
	DEFAULT_EXT_IDX_END int = 16

	// default gzip cipher flag mask
	CmdFlagMaskGzip = uint32(1) << 31

	// reserved cmd: ping
	CmdPing = uint32(0x1 << 24)
	// reserved cmd: ping2
	CmdPing2 = uint32(0x1<<24 + 1)
	// reserved cmd: set real ip
	CmdSetReaIp = uint32(0x1<<24 + 2)
	// reserved cmd: rpc method
	CmdRpcMethod = uint32(0x1<<24 + 3)
	// reserved cmd: rpc error
	CmdRpcError = uint32(0x1<<24 + 4)

	// max user space cmd
	CmdUserMax = uint32(0xFFFFFF)
)

Variables

View Source 
var (
	DefaultCodec        = json
	DefaultRpcCodecType = "json"
)
View Source 
var (
	// default tcp nodlay
	DefaultSockNodelay = true
	// default tcp keepalive
	DefaultSockKeepalive = false
	// default tcp bufio reader
	DefaultSockBufioReaderEnabled = false
	// default tcp client send queue size
	DefaultSendQSize = 512
	// default tcp client read buf length
	DefaultSockRecvBufLen = 1024
	// default tcp client write buf length
	DefaultSockSendBufLen = 1024
	// default max tcp client packet length
	DefaultSockPackMaxLen = 1024 * 1024
	// default tcp client linger time
	DefaultSockLingerSeconds = 0
	// default tcp client keepalive interval
	DefaultSockKeepaliveTime = time.Second * 60
	// default tcp client read block time
	DefaultSockRecvBlockTime = time.Second * 65
	// default tcp client write block time
	DefaultSockSendBlockTime = time.Second * 5

	// default rpc send queue size
	DefaultSockRpcSendQSize = 8192
	// default rpc read block time
	DefaultSockRpcRecvBlockTime = time.Second * 3600 * 24

	// default max concurrent
	DefaultMaxOnline = int64(40960)

	// default read block time
	DefaultReadTimeout = time.Second * 35

	// default write block time
	DefaultWriteTimeout = time.Second * 5

	// default shutdown timeout
	DefaultShutdownTimeout = time.Second * 5

	// default max websocket read length
	DefaultReadLimit int64 = 1024 * 1024

	// default enable set real ip multi times
	DefaultEnableMultiSetRealIp = false
)
View Source 
var (
	ErrTcpClientIsStopped       = errors.New("tcp client is stopped")
	ErrTcpClientWriteHalf       = errors.New("tcp client write half")
	ErrTcpClientSendQueueIsFull = errors.New("tcp client's send queue is full")

	ErrRpcClientIsDisconnected  = errors.New("rpc client disconnected")
	ErrRpcClientSendQueueIsFull = errors.New("rpc client's send queue is full")
	ErrRpcCallTimeout           = errors.New("rpc call timeout")
	ErrRpcCallClientError       = errors.New("rpc client error")

	ErrorRpcInvalidMessageHeadLen = errors.New("invalid Message Head Len")
	ErrorRpcInvalidPbMessage      = errors.New("invalid pb Message")

	ErrorBroadcastNotEnabled = errors.New("broadcast not enabled")

	ErrorReservedCmdInternal  = fmt.Errorf("cmd > %d/0x%X is reserved for internal, plz use other number", CmdUserMax, CmdUserMax)
	ErrorReservedCmdPing      = fmt.Errorf("cmd %d/0x%X is reserved for ping, plz use other number", CmdPing, CmdPing)
	ErrorReservedCmdSetRealip = fmt.Errorf("cmd %d/0x%X is reserved for set client's real ip, plz use other number", CmdSetReaIp, CmdSetReaIp)
	ErrorReservedCmdRpcMethod = fmt.Errorf("cmd %d/0x%X is reserved for rpc method, plz use other number", CmdRpcMethod, CmdRpcMethod)
	ErrorReservedCmdRpcError  = fmt.Errorf("cmd %d/0x%X is reserved for rpc method error, plz use other number", CmdRpcError, CmdRpcError)

	ErrWSClientIsStopped       = errors.New("websocket client is stopped")
	ErrWSClientSendQueueIsFull = errors.New("websocket client's send queue is full")
	ErrClientWithoutCodec      = errors.New("websocket client has no codec")
	ErrWSEngineShutdownTimeout = errors.New("shutdown timeout")
)

errors

View Source 
var (
	ErrInvalidBody = errors.New("invalid body")
)

Functions

func GetLocalAddr 

func GetLocalAddr() ([]string, error)

get all local addrs

func NewListener 

func NewListener(addr string, opt *SocketOpt) (net.Listener, error)

tcp listener factory

func Ping 

func Ping(addr string, to time.Duration) error

ping tcp addr

func ServeHttp 

func ServeHttp(tag string, addr string, handler http.Handler, timeout time.Duration, opt *SocketOpt)

serve http

func ServeHttps 

func ServeHttps(tag string, addr string, handler http.Handler, timeout time.Duration, opt *SocketOpt, certFile string, keyFile string)

serve https

Types

type CipherGzip 

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

default cipher with gzip

func (*CipherGzip) Decrypt 

func (cipher *CipherGzip) Decrypt(seq int64, key uint32, data []byte) ([]byte, error)

decrypt message

func (*CipherGzip) Encrypt 

func (cipher *CipherGzip) Encrypt(seq int64, key uint32, data []byte) []byte

encrypt message

func (*CipherGzip) Init 

func (cipher *CipherGzip) Init()

type CodecGob 

type CodecGob struct{}

gob codec

func (*CodecGob) Marshal 

func (c *CodecGob) Marshal(v interface{}) ([]byte, error)

marshal

func (*CodecGob) Unmarshal 

func (c *CodecGob) Unmarshal(data []byte, v interface{}) error

unmarshal

type CodecJson 

type CodecJson struct{}

json codec

func (*CodecJson) Marshal 

func (c *CodecJson) Marshal(v interface{}) ([]byte, error)

marshal

func (*CodecJson) Unmarshal 

func (c *CodecJson) Unmarshal(data []byte, v interface{}) error

unmarshal

type CodecMsgpack 

type CodecMsgpack struct{}

msgpack codec

func (*CodecMsgpack) Marshal 

func (c *CodecMsgpack) Marshal(v interface{}) ([]byte, error)

marshal

func (*CodecMsgpack) Unmarshal 

func (c *CodecMsgpack) Unmarshal(data []byte, v interface{}) error

unmarshal

type CodecProtobuf 

type CodecProtobuf struct{}

protobuf codec

func (*CodecProtobuf) Marshal 

func (c *CodecProtobuf) Marshal(v interface{}) ([]byte, error)

marshal

func (*CodecProtobuf) Unmarshal 

func (c *CodecProtobuf) Unmarshal(data []byte, v interface{}) error

unmarshal

type HttpHandlerWrapper 

type HttpHandlerWrapper struct {
	sync.WaitGroup
	// contains filtered or unexported fields
}

http middleware

func (*HttpHandlerWrapper) EnablePProf 

func (wrapper *HttpHandlerWrapper) EnablePProf(root string)

enable pprof

func (*HttpHandlerWrapper) ServeHTTP 

func (wrapper *HttpHandlerWrapper) ServeHTTP(w http.ResponseWriter, r *http.Request)

serve http

type HttpServer 

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

http server

func NewHttpServer 

func NewHttpServer(tag string, addr string, handler http.Handler, to time.Duration, opt *SocketOpt, onTimeout func()) (*HttpServer, error)

http server factory

func (*HttpServer) EnablePProf 

func (svr *HttpServer) EnablePProf(root string)

enable pprof

func (*HttpServer) Serve 

func (svr *HttpServer) Serve()

serve http

func (*HttpServer) ServeTLS 

func (svr *HttpServer) ServeTLS(certFile, keyFile string)

serve https

func (*HttpServer) Server 

func (svr *HttpServer) Server() *http.Server

http server

func (*HttpServer) SetSocketOpt 

func (svr *HttpServer) SetSocketOpt(opt *SocketOpt)

setting tcp socket option

func (*HttpServer) Shutdown 

func (svr *HttpServer) Shutdown() error

graceful shutdown

type ICipher 

type ICipher interface {
	Init()
	Encrypt(seq int64, key uint32, data []byte) []byte
	Decrypt(seq int64, key uint32, data []byte) ([]byte, error)
}

cipher interface

func NewCipherGzip 

func NewCipherGzip(threshold int) ICipher

type ICodec 

type ICodec interface {
	Marshal(v interface{}) ([]byte, error)
	Unmarshal(data []byte, v interface{}) error
}

codec interface

type IMessage 

type IMessage interface {
	// message body length
	BodyLen() int

	// message cmd
	Cmd() uint32
	// setting message cmd
	SetCmd(cmd uint32)

	// message extension
	Ext() int64
	// setting message extension
	SetExt(ext int64)

	// all message data
	Data() []byte
	// setting all message data
	SetData(data []byte)

	// message body
	Body() []byte
	// setting message body
	SetBody(body []byte)

	// encrypt message
	Encrypt(seq int64, key uint32, cipher ICipher) []byte
	// decrypt message
	Decrypt(seq int64, key uint32, cipher ICipher) ([]byte, error)
}

message interface

type Listener 

type Listener struct {
	*net.TCPListener
	// contains filtered or unexported fields
}

tcp listener

func (Listener) Accept 

func (ln Listener) Accept() (net.Conn, error)

accept

type Message 

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

default message implementation

func NewMessage 

func NewMessage(cmd uint32, data []byte) *Message

message factory

func NewRpcMessage 

func NewRpcMessage(cmd uint32, seq int64, data []byte) *Message

rpc message factory

func PingMsg 

func PingMsg() *Message

ping message

func RawMessage 

func RawMessage(data []byte) *Message

message factory by data

func RealIpMsg 

func RealIpMsg(ip string) *Message

real ip message

func (*Message) Body 

func (msg *Message) Body() []byte

body

func (*Message) BodyLen 

func (msg *Message) BodyLen() int

body length

func (*Message) Cmd 

func (msg *Message) Cmd() uint32

cmd

func (*Message) Data 

func (msg *Message) Data() []byte

all data

func (*Message) Decrypt 

func (msg *Message) Decrypt(seq int64, key uint32, cipher ICipher) ([]byte, error)

decrypt message

func (*Message) Encrypt 

func (msg *Message) Encrypt(seq int64, key uint32, cipher ICipher) []byte

encrypt message

func (*Message) Ext 

func (msg *Message) Ext() int64

extension

func (*Message) SetBody 

func (msg *Message) SetBody(data []byte)

setting body

func (*Message) SetCmd 

func (msg *Message) SetCmd(cmd uint32)

setting cmd

func (*Message) SetData 

func (msg *Message) SetData(data []byte)

setting all data

func (*Message) SetExt 

func (msg *Message) SetExt(ext int64)

setting extension

type RpcClient 

type RpcClient struct {
	*TcpClient
	// contains filtered or unexported fields
}

rpc client

func NewRpcClient 

func NewRpcClient(addr string, engine *TcpEngin, codec ICodec, onConnected func(*RpcClient)) (*RpcClient, error)

rpc client factory

func (*RpcClient) Call 

func (client *RpcClient) Call(method string, req interface{}, rsp interface{}, timeout time.Duration) error

rpc call

func (*RpcClient) CallCmd 

func (client *RpcClient) CallCmd(cmd uint32, req interface{}, rsp interface{}) error

call cmd

func (*RpcClient) CallCmdWithTimeout 

func (client *RpcClient) CallCmdWithTimeout(cmd uint32, req interface{}, rsp interface{}, timeout time.Duration) error

call cmd with timeout

func (*RpcClient) CallWithTimer 

func (client *RpcClient) CallWithTimer(method string, req interface{}, rsp interface{}, after *time.Timer) error

rpc call

func (*RpcClient) Codec 

func (client *RpcClient) Codec() ICodec

codec

type RpcContext 

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

rpc context

func (*RpcContext) Bind 

func (ctx *RpcContext) Bind(v interface{}) error

bind data

func (*RpcContext) BindGob 

func (ctx *RpcContext) BindGob(v interface{}) error

bind gob data

func (*RpcContext) BindJson 

func (ctx *RpcContext) BindJson(v interface{}) error

bind json

func (*RpcContext) BindMsgpack 

func (ctx *RpcContext) BindMsgpack(v interface{}) error

bind msgpack data

func (*RpcContext) BindProtobuf 

func (ctx *RpcContext) BindProtobuf(v proto.Message) error

bind protobuf data

func (*RpcContext) Body 

func (ctx *RpcContext) Body() []byte

rpc body

func (*RpcContext) Client 

func (ctx *RpcContext) Client() *TcpClient

tcp client

func (*RpcContext) Cmd 

func (ctx *RpcContext) Cmd() uint32

cmd

func (*RpcContext) Error 

func (ctx *RpcContext) Error(errText string) error

write error

func (*RpcContext) Method 

func (ctx *RpcContext) Method() string

rpc method

func (*RpcContext) Write 

func (ctx *RpcContext) Write(v interface{}) error

write data marshal by default codec

func (*RpcContext) WriteData 

func (ctx *RpcContext) WriteData(data []byte) error

write data

func (*RpcContext) WriteGob 

func (ctx *RpcContext) WriteGob(v interface{}) error

write gob data

func (*RpcContext) WriteJson 

func (ctx *RpcContext) WriteJson(v interface{}) error

write json data

func (*RpcContext) WriteMsg 

func (ctx *RpcContext) WriteMsg(msg IMessage) error

write message

func (*RpcContext) WriteMsgpack 

func (ctx *RpcContext) WriteMsgpack(v interface{}) error

write msgpack data

func (*RpcContext) WriteProtobuf 

func (ctx *RpcContext) WriteProtobuf(v proto.Message) error

write protobuf data

type RpcMessage 

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

rpc message

type SocketOpt 

type SocketOpt struct {
	NoDelay           bool
	Keepalive         bool
	KeepaliveInterval time.Duration
	ReadBufLen        int
	WriteBufLen       int
	ReadTimeout       time.Duration
	ReadHeaderTimeout time.Duration
	WriteTimeout      time.Duration
	MaxHeaderBytes    int
}

tcp socket option

type TcpClient 

type TcpClient struct {
	sync.RWMutex

	// tcp connection
	Conn *net.TCPConn
	// contains filtered or unexported fields
}

tcp client

func NewTcpClient 

func NewTcpClient(addr string, parent *TcpEngin, cipher ICipher, autoReconn bool, onConnected func(*TcpClient)) (*TcpClient, error)

func (*TcpClient) Bind 

func (client *TcpClient) Bind(data []byte, v interface{}) error

bind data

func (*TcpClient) CancelOnClose 

func (client *TcpClient) CancelOnClose(tag interface{})

unsetting close handler

func (*TcpClient) Cipher 

func (client *TcpClient) Cipher() ICipher

cipher

func (*TcpClient) Ip 

func (client *TcpClient) Ip() string

ip

func (*TcpClient) Keepalive 

func (client *TcpClient) Keepalive(interval time.Duration)

client keepalive

func (*TcpClient) OnClose 

func (client *TcpClient) OnClose(tag interface{}, cb func(client *TcpClient))

setting close handler

func (*TcpClient) Port 

func (client *TcpClient) Port() int

port

func (*TcpClient) Reader 

func (client *TcpClient) Reader() io.Reader

reader

func (*TcpClient) RecvKey 

func (client *TcpClient) RecvKey() uint32

receive key

func (*TcpClient) RecvSeq 

func (client *TcpClient) RecvSeq() int64

receive sequence

func (*TcpClient) SendData 

func (client *TcpClient) SendData(data []byte) error

send data

func (*TcpClient) SendDataWithCallback 

func (client *TcpClient) SendDataWithCallback(data []byte, cb func(*TcpClient, error)) error

send data with callback

func (*TcpClient) SendKey 

func (client *TcpClient) SendKey() uint32

send key

func (*TcpClient) SendMsg 

func (client *TcpClient) SendMsg(msg IMessage) error

send message

func (*TcpClient) SendMsgWithCallback 

func (client *TcpClient) SendMsgWithCallback(msg IMessage, cb func(*TcpClient, error)) error

send message with callback

func (*TcpClient) SendSeq 

func (client *TcpClient) SendSeq() int64

send sequence

func (*TcpClient) SetCipher 

func (client *TcpClient) SetCipher(cipher ICipher)

setting cipher

func (*TcpClient) SetRealIp 

func (client *TcpClient) SetRealIp(ip string)

set real ip

func (*TcpClient) SetUserData 

func (client *TcpClient) SetUserData(data interface{})

setting user data

func (*TcpClient) Shutdown 

func (client *TcpClient) Shutdown() error

shutdown for auto reconnect client

func (*TcpClient) Stop 

func (client *TcpClient) Stop() error

Stop

func (*TcpClient) UserData 

func (client *TcpClient) UserData() interface{}

user data

type TcpEngin 

type TcpEngin struct {
	sync.RWMutex

	// graceful
	sync.WaitGroup

	// codec
	Codec ICodec

	// new connection handler
	OnNewConnHandler func(conn *net.TCPConn) error
	// create tcp client handler
	CreateClientHandler func(conn *net.TCPConn, parent *TcpEngin, cipher ICipher) *TcpClient
	// new tcp client handler
	OnNewClientHandler func(client *TcpClient)
	// new cipher handler
	NewCipherHandler func() ICipher
	// tcp client disconnected handler
	OnDisconnectedHandler func(client *TcpClient)
	// tcp client send queue full handler
	SendQueueFullHandler func(*TcpClient, interface{})
	// tcp client receive handler
	RecvHandler func(client *TcpClient) IMessage
	// tcp client send handler
	SendHandler func(client *TcpClient, data []byte) error
	// tcp client message handler
	OnMsgHandler func(client *TcpClient, msg IMessage)
	// contains filtered or unexported fields
}

tcp engine

func NewTcpEngine 

func NewTcpEngine() *TcpEngin

tcp engine factory

func (*TcpEngin) BroadCast 

func (engine *TcpEngin) BroadCast(msg IMessage)

broadcast

func (*TcpEngin) CreateClient 

func (engine *TcpEngin) CreateClient(conn *net.TCPConn, parent *TcpEngin, cipher ICipher) *TcpClient

create client

func (*TcpEngin) DefaultCreateClientHandler 

func (engine *TcpEngin) DefaultCreateClientHandler(conn *net.TCPConn, parent *TcpEngin, cipher ICipher) *TcpClient

create client

func (*TcpEngin) DefaultNewConnHandler 

func (engine *TcpEngin) DefaultNewConnHandler(conn *net.TCPConn) error

on new connection

func (*TcpEngin) DefaultOnMessage 

func (engine *TcpEngin) DefaultOnMessage(client *TcpClient, msg IMessage)

func (*TcpEngin) DefaultRecvMsg 

func (engine *TcpEngin) DefaultRecvMsg(client *TcpClient) IMessage

recv message

func (*TcpEngin) DefaultSend 

func (engine *TcpEngin) DefaultSend(client *TcpClient, data []byte) error

tcp client send data

func (*TcpEngin) Handle 

func (engine *TcpEngin) Handle(cmd uint32, handler func(client *TcpClient, msg IMessage))

handle message by cmd

func (*TcpEngin) HandleCreateClient 

func (engine *TcpEngin) HandleCreateClient(createClient func(conn *net.TCPConn, parent *TcpEngin, cipher ICipher) *TcpClient)

setting create tcp client handler

func (*TcpEngin) HandleDisconnected 

func (engine *TcpEngin) HandleDisconnected(onDisconnected func(client *TcpClient))

setting disconnected handler

func (*TcpEngin) HandleMessage 

func (engine *TcpEngin) HandleMessage(onMsg func(client *TcpClient, msg IMessage))

setting message handler

func (*TcpEngin) HandleNewCipher 

func (engine *TcpEngin) HandleNewCipher(newCipher func() ICipher)

setting new cipher handler

func (*TcpEngin) HandleNewClient 

func (engine *TcpEngin) HandleNewClient(onNewClient func(client *TcpClient))

setting new client handler

func (*TcpEngin) HandleNewConn 

func (engine *TcpEngin) HandleNewConn(onNewConn func(conn *net.TCPConn) error)

handle new connection

func (*TcpEngin) HandleRecv 

func (engine *TcpEngin) HandleRecv(recver func(client *TcpClient) IMessage)

setting receive message handler

func (*TcpEngin) HandleRpcCmd 

func (engine *TcpEngin) HandleRpcCmd(cmd uint32, handler func(ctx *RpcContext), async bool)

handle rpc cmd

func (*TcpEngin) HandleRpcMethod 

func (engine *TcpEngin) HandleRpcMethod(method string, handler func(ctx *RpcContext), args ...interface{})

setting handle rpc method

func (*TcpEngin) HandleSend 

func (engine *TcpEngin) HandleSend(sender func(client *TcpClient, data []byte) error)

setting tcp client send data handler

func (*TcpEngin) HandleSendQueueFull 

func (engine *TcpEngin) HandleSendQueueFull(h func(*TcpClient, interface{}))

setting tcp client send queue full handler

func (*TcpEngin) MultiSetRealIpEnabled 

func (engine *TcpEngin) MultiSetRealIpEnabled() bool

multi set realip

func (*TcpEngin) NewCipher 

func (engine *TcpEngin) NewCipher() ICipher

new cipher

func (*TcpEngin) OnDisconnected 

func (engine *TcpEngin) OnDisconnected(client *TcpClient)

on disconnected

func (*TcpEngin) OnMessage 

func (engine *TcpEngin) OnMessage(client *TcpClient, msg IMessage)

func (*TcpEngin) OnNewClient 

func (engine *TcpEngin) OnNewClient(client *TcpClient)

on new client

func (*TcpEngin) OnNewConn 

func (engine *TcpEngin) OnNewConn(conn *net.TCPConn) error

on new connection

func (*TcpEngin) OnSendQueueFull 

func (engine *TcpEngin) OnSendQueueFull(client *TcpClient, msg interface{})

on tcp client send queue full

func (*TcpEngin) RecvMsg 

func (engine *TcpEngin) RecvMsg(client *TcpClient) IMessage

recv message

func (*TcpEngin) Send 

func (engine *TcpEngin) Send(client *TcpClient, data []byte) error

tcp client send data

func (*TcpEngin) SendQueueSize 

func (engine *TcpEngin) SendQueueSize() int

socket send queue size

func (*TcpEngin) SetMultiSetRealIpEnabled 

func (engine *TcpEngin) SetMultiSetRealIpEnabled(enable bool)

setting multi set realip

func (*TcpEngin) SetSendQueueSize 

func (engine *TcpEngin) SetSendQueueSize(size int)

setting socket send queue size

func (*TcpEngin) SetSockBufioReaderEnabled 

func (engine *TcpEngin) SetSockBufioReaderEnabled(enable bool)

setting socket bufio reader

func (*TcpEngin) SetSockKeepAlive 

func (engine *TcpEngin) SetSockKeepAlive(enable bool)

setting socket keepalive

func (*TcpEngin) SetSockKeepaliveTime 

func (engine *TcpEngin) SetSockKeepaliveTime(keepaliveTime time.Duration)

setting socket keepalive interval

func (*TcpEngin) SetSockLingerSeconds 

func (engine *TcpEngin) SetSockLingerSeconds(sec int)

setting socket linger time

func (*TcpEngin) SetSockMaxPackLen 

func (engine *TcpEngin) SetSockMaxPackLen(maxPackLen int)

setting socket max packet length

func (*TcpEngin) SetSockNoDelay 

func (engine *TcpEngin) SetSockNoDelay(enable bool)

setting socket nodelay

func (*TcpEngin) SetSockRecvBlockTime 

func (engine *TcpEngin) SetSockRecvBlockTime(recvBlockTime time.Duration)

setting socket receive block time

func (*TcpEngin) SetSockRecvBufLen 

func (engine *TcpEngin) SetSockRecvBufLen(recvBufLen int)

setting socket receive buf length

func (*TcpEngin) SetSockSendBlockTime 

func (engine *TcpEngin) SetSockSendBlockTime(sendBlockTime time.Duration)

setting socket send block time

func (*TcpEngin) SetSockSendBufLen 

func (engine *TcpEngin) SetSockSendBufLen(sendBufLen int)

setting send receive buf length

func (*TcpEngin) SockBufioReaderEnabled 

func (engine *TcpEngin) SockBufioReaderEnabled() bool

socket bufio reader

func (*TcpEngin) SockKeepAlive 

func (engine *TcpEngin) SockKeepAlive() bool

socket keepalive

func (*TcpEngin) SockKeepaliveTime 

func (engine *TcpEngin) SockKeepaliveTime() time.Duration

socket keepalive interval

func (*TcpEngin) SockLingerSeconds 

func (engine *TcpEngin) SockLingerSeconds() int

socket linger time

func (*TcpEngin) SockMaxPackLen 

func (engine *TcpEngin) SockMaxPackLen() int

socket max packet length

func (*TcpEngin) SockNoDelay 

func (engine *TcpEngin) SockNoDelay() bool

socket nodelay

func (*TcpEngin) SockRecvBlockTime 

func (engine *TcpEngin) SockRecvBlockTime() time.Duration

socket receive block time

func (*TcpEngin) SockRecvBufLen 

func (engine *TcpEngin) SockRecvBufLen() int

socket receive buf length

func (*TcpEngin) SockSendBlockTime 

func (engine *TcpEngin) SockSendBlockTime() time.Duration

socket send block time

func (*TcpEngin) SockSendBufLen 

func (engine *TcpEngin) SockSendBufLen() int

socket send buf length

type TcpServer 

type TcpServer struct {
	*TcpEngin
	// contains filtered or unexported fields
}

tcp server

func NewRpcServer 

func NewRpcServer(tag string) *TcpServer

rpc server factory

func NewTcpServer 

func NewTcpServer(tag string) *TcpServer

tcp server factory

func (*TcpServer) AcceptedNum 

func (server *TcpServer) AcceptedNum() int64

total accept num

func (*TcpServer) Broadcast 

func (server *TcpServer) Broadcast(msg IMessage)

broadcast

func (*TcpServer) BroadcastWithFilter 

func (server *TcpServer) BroadcastWithFilter(msg IMessage, filter func(*TcpClient) bool)

broadcast with filter

func (*TcpServer) CurrLoad 

func (server *TcpServer) CurrLoad() int64

currunt load

func (*TcpServer) EnableBroadcast 

func (server *TcpServer) EnableBroadcast()

enable broadcast

func (*TcpServer) HandleServerStop 

func (server *TcpServer) HandleServerStop(stopHandler func(server *TcpServer))

setting server stop handler

func (*TcpServer) MaxLoad 

func (server *TcpServer) MaxLoad() int64

max load

func (*TcpServer) Serve 

func (server *TcpServer) Serve(addr string, stopTimeout time.Duration)

serve

func (*TcpServer) SetMaxConcurrent 

func (server *TcpServer) SetMaxConcurrent(maxLoad int64)

set max concurrent

func (*TcpServer) Start 

func (server *TcpServer) Start(addr string) error

start

func (*TcpServer) Stop 

func (server *TcpServer) Stop()

stop

func (*TcpServer) StopWithTimeout 

func (server *TcpServer) StopWithTimeout(stopTimeout time.Duration, onStopTimeout func())

stop with timeout

type WSClient 

type WSClient struct {
	*WSEngine
	sync.RWMutex

	// websocket connection
	Conn *websocket.Conn
	// contains filtered or unexported fields
}

websocket client

func NewWebsocketClient 

func NewWebsocketClient(addr string) (*WSClient, error)

websocket client factory

func NewWebsocketTLSClient 

func NewWebsocketTLSClient(addr string) (*WSClient, error)

func (*WSClient) Bind 

func (cli *WSClient) Bind(data []byte, v interface{}) error

bind data

func (*WSClient) CancelOnClose 

func (cli *WSClient) CancelOnClose(tag interface{})

unsetting close handler

func (*WSClient) Cipher 

func (cli *WSClient) Cipher() ICipher

cipher

func (*WSClient) Ip 

func (cli *WSClient) Ip() string

ip

func (*WSClient) Keepalive 

func (cli *WSClient) Keepalive(interval time.Duration)

keepalive

func (*WSClient) OnClose 

func (cli *WSClient) OnClose(tag interface{}, cb func(client *WSClient))

setting close handler

func (*WSClient) Port 

func (cli *WSClient) Port() int

port

func (*WSClient) RecvKey 

func (cli *WSClient) RecvKey() uint32

receive key

func (*WSClient) RecvSeq 

func (cli *WSClient) RecvSeq() int64

receive sequence

func (*WSClient) SendData 

func (cli *WSClient) SendData(data []byte) error

send data

func (*WSClient) SendDataWithCallback 

func (cli *WSClient) SendDataWithCallback(data []byte, cb func(*WSClient, error)) error

send data with callback

func (*WSClient) SendKey 

func (cli *WSClient) SendKey() uint32

send key

func (*WSClient) SendMsg 

func (cli *WSClient) SendMsg(msg IMessage) error

send message

func (*WSClient) SendMsgWithCallback 

func (cli *WSClient) SendMsgWithCallback(msg IMessage, cb func(*WSClient, error)) error

send message with callback

func (*WSClient) SendSeq 

func (cli *WSClient) SendSeq() int64

send sequence

func (*WSClient) SetCipher 

func (cli *WSClient) SetCipher(cipher ICipher)

setting cipher

func (*WSClient) SetRealIp 

func (cli *WSClient) SetRealIp(ip string)

setting real ip

func (*WSClient) SetUserData 

func (cli *WSClient) SetUserData(data interface{})

setting user data

func (*WSClient) Stop 

func (cli *WSClient) Stop()

Stop

func (*WSClient) UserData 

func (cli *WSClient) UserData() interface{}

user data

type WSEngine 

type WSEngine struct {
	sync.Mutex
	sync.WaitGroup

	// 序列化
	Codec ICodec

	// 读超时时间
	ReadTimeout time.Duration

	// 写超时时间
	WriteTimeout time.Duration

	// 读最大包长限制
	ReadLimit int64

	// 发送队列容量
	SendQSize int

	// websocket消息类型
	MessageType int
	// contains filtered or unexported fields
}

websocket engine

func NewWebsocketEngine 

func NewWebsocketEngine() *WSEngine

websocket engine factory

func (*WSEngine) Handle 

func (engine *WSEngine) Handle(cmd uint32, h func(cli *WSClient, msg IMessage))

setting message handler by cmd

func (*WSEngine) HandleMessage 

func (engine *WSEngine) HandleMessage(h func(cli *WSClient, msg IMessage))

setting user defined message handler

func (*WSEngine) HandleNewCipher 

func (engine *WSEngine) HandleNewCipher(newCipher func() ICipher)

setting new cipher handler

func (*WSEngine) HandleRecv 

func (engine *WSEngine) HandleRecv(recver func(cli *WSClient) IMessage)

setting receive message handler

func (*WSEngine) HandleSend 

func (engine *WSEngine) HandleSend(sender func(cli *WSClient, data []byte) error)

setting send message handler

func (*WSEngine) HandleSendQueueFull 

func (engine *WSEngine) HandleSendQueueFull(h func(cli *WSClient, msg interface{}))

setting send queue full handler

func (*WSEngine) NewCipher 

func (engine *WSEngine) NewCipher() ICipher

new cipher

func (*WSEngine) OnSendQueueFull 

func (engine *WSEngine) OnSendQueueFull(cli *WSClient, msg interface{})

handle send queue full

func (*WSEngine) RecvMsg 

func (engine *WSEngine) RecvMsg(cli *WSClient) IMessage

receive message

func (*WSEngine) Send 

func (engine *WSEngine) Send(cli *WSClient, data []byte) error

send websocket data

type WSServer 

type WSServer struct {
	*WSEngine

	// http server
	*HttpServer
	// contains filtered or unexported fields
}

func NewWebsocketServer 

func NewWebsocketServer(tag string, addr string) (*WSServer, error)

websocket server factory

func (*WSServer) ClientNum 

func (s *WSServer) ClientNum() int

client num

func (*WSServer) CurrLoad 

func (server *WSServer) CurrLoad() int64

current load

func (*WSServer) HandleConnect 

func (s *WSServer) HandleConnect(h func(cli *WSClient, w http.ResponseWriter, r *http.Request) error)

setting websocket connection handler

func (*WSServer) HandleDisconnect 

func (s *WSServer) HandleDisconnect(h func(cli *WSClient, w http.ResponseWriter, r *http.Request))

setting websocket disconnected handler

func (*WSServer) HandleHttp 

func (s *WSServer) HandleHttp(h func(w http.ResponseWriter, r *http.Request))

setting http router

func (*WSServer) HandleRequest 

func (s *WSServer) HandleRequest(h func(w http.ResponseWriter, r *http.Request) error)

setting request handler

func (*WSServer) HandleWs 

func (s *WSServer) HandleWs(path string)

setting websocket router

func (*WSServer) MaxLoad 

func (server *WSServer) MaxLoad() int64

max load

func (*WSServer) ServeHTTP 

func (s *WSServer) ServeHTTP(w http.ResponseWriter, r *http.Request)

serve http

func (*WSServer) SetMaxConcurrent 

func (server *WSServer) SetMaxConcurrent(maxLoad int64)

setting max concurrent

func (*WSServer) SetUpgrader 

func (s *WSServer) SetUpgrader(upgrader *websocket.Upgrader)

setting websocket upgrader

func (*WSServer) Shutdown 

func (s *WSServer) Shutdown(timeout time.Duration, cb func(error))

graceful shutdown

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.