GO EASY 框架 之 Server 06

目录

1、Overview

2、监听服务接口

3、easy/servers package

3.1、基础类Server

3.2、WWServer 服务

3.3、TcpServer

3.4、KCPServer

4、hookAgent链接钩子

5、创建一个WebScoket监听服务

---

1、Overview

本节主要介绍，easy的监听服务。例如websocket 监听，tcp监听，kcp监听服务等。每个类型的监听可以多次实例，用以监听多个端口；每个实例可以绑定自己的路由器，编码解码器等。

2、监听服务接口

import (
	"github.com/slclub/easy/route"
	"github.com/slclub/easy/vendors/option"
)

type ListenServer interface {
	Init(assignment option.Assignment)
	OnInit()
	Router() route.Router
	Start()
	Hook() *hookAgent // agent 链接 回调
	//OnClose(func())
	Close()
}

3、easy/servers package

3.1、基础类Server

WSServer(WebSocket） 和 TCPServer(TcpSocket)等监听服务都是基于Server实现的。

• Import

import (
	"crypto/tls"
	"errors"
	"github.com/slclub/easy/log"
	"github.com/slclub/easy/nets/agent"
	"github.com/slclub/easy/nets/conns"
	"github.com/slclub/easy/route"
	"github.com/slclub/easy/route/bind"
	"github.com/slclub/easy/route/encode"
	"github.com/slclub/easy/typehandle"
	"github.com/slclub/easy/vendors/option"
	"io"
	"net"
	"sync"
	"time"
)

• Class

/**
 * 基类 监听服务
 */
type Server struct {
	agent.Gate
	ln         net.Listener
	box        *ConnBox
	router     route.Router
	hook       *hookAgent
	connOption *conns.Option
}

成员：

        box （*ConnBox）链接存储盒子；

        router（route.Router）路由器；

        hook （*hookAgent）链接阶段的事件；

        connOption（*conns.Option）conns选项；

• Methods

func (self *Server) Init(assignment option.Assignment) {
	//self.Gate.Init(gate)
	assignment.Target(&self.Gate)
	assignment.Default(
		option.OptionFunc(func() (string, any) {
			return "Protocol", typehandle.EnCriPT_DATA_PROTOBUF
		}),
		option.OptionFunc(func() (string, any) {
			return "MaxConnNum", 100
		}),
		option.OptionFunc(func() (string, any) {
			return "PendingWriteNum", 100
		}),
		option.OptionFunc(func() (string, any) {
			return "MaxMsgLen", 4096
		}),
		option.OptionFunc(func() (string, any) {
			return "HTTPTimeout", 10 * time.Second
		}),
		option.OptionFunc(func() (string, any) {
			return "MsgDigit", conns.CONST_MSG_DIGIT
		}),
	)

	//if self.Protocol == "" {
	//	self.Protocol = typehandle.EnCriPT_DATA_PROTOBUF
	//}
	assignment.Apply()
	self.defaultRouteEncripty()
	self.Router().Encoder().LittleEndian(self.LittleEndian)
}

func (self *Server) startBefore() {

	self.connOption = &conns.Option{
		Encrypt:   self.Router().Encoder(),
		MaxMsgLen: self.MaxMsgLen,
		MinMsgLen: 2,
		MsgDigit:  self.MsgDigit,
	}
	ln, err := net.Listen("tcp", self.Addr)
	if err != nil {
		log.Fatal("Listen error: %v", err)
	}
	if self.CertFile != "" || self.KeyFile != "" {
		config := &tls.Config{}
		config.NextProtos = []string{"http/1.1"}

		var err error
		config.Certificates = make([]tls.Certificate, 1)
		config.Certificates[0], err = tls.LoadX509KeyPair(self.CertFile, self.KeyFile)
		if err != nil {
			log.Fatal("%v", err)
		}
		ln = tls.NewListener(ln, config)
	}
	self.ln = ln

	// 链接容器
	self.box = &ConnBox{
		server: self,
		conns:  make(ConnSet),
		mutex:  sync.Mutex{},
	}
}

func (self *Server) defaultRouteEncripty() {
	switch self.Protocol {
	case typehandle.ENCRIPT_DATA_JSON:
		self.router.Binding(bind.NewBindJson(self.router.PathMap()), encode.NewJson(self.router.PathMap()))
	default:
		self.router.Binding(bind.NewBindProto(self.router.PathMap()), encode.NewProtobuf(self.router.PathMap()))
	}
}

func (self *Server) Close() {
	// 利用钩子优雅关闭
	self.hook.EmitWithKey(CONST_SERVER_CLOSE, nil)

	// 关闭监听
	self.ln.Close()

	// 关闭哦链接池
	self.box.Close()

}

func (self *Server) Router() route.Router {
	return self.router
}

func (self *Server) Hook() *hookAgent {
	return self.hook
}

3.2、WWServer 服务

WebSocket Server 服务源码；

WebSocket是用http升级转换而来；链接的关键是使用http.Handler接口；

• http.Handler接口

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

• WebSocket Server 服务源码

package servers

import (
	"github.com/gorilla/websocket"
	"github.com/slclub/easy/log"
	"github.com/slclub/easy/nets/agent"
	"github.com/slclub/easy/nets/conns"
	"github.com/slclub/easy/route"
	"net/http"
)

/**
 * web socket 监听服务
 */
type WSServer struct {
	Server
	upgrader websocket.Upgrader
}

func NewWSServer() *WSServer {
	ser := Server{
		router: route.NewRouter(),
		hook:   newHookAgent(),
	}
	return &WSServer{
		Server: ser,
	}
}

func (self *WSServer) Start() {
	self.startBefore()

	handleHttp := &WebSocketHandle{
		server: self,
		handle: dealHandle(&self.Server),
	}
	httpServer := &http.Server{
		Addr:           self.Addr,
		Handler:        handleHttp,
		ReadTimeout:    self.HTTPTimeout,
		WriteTimeout:   self.HTTPTimeout,
		MaxHeaderBytes: 1024,
	}

	go httpServer.Serve(self.ln)
}

var _ ListenServer = &WSServer{}

// ------------------------------------------------------------
// serverHttpHandle
type WebSocketHandle struct {
	server *WSServer
	handle agent.AgentHandle
}

func (self *WebSocketHandle) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "Method not allowed", 405)
		return
	}
	conn, err := self.server.upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Debug("upgrade error: %v", err)
		return
	}
	conn.SetReadLimit(int64(self.server.MaxMsgLen))

	if err = self.server.box.Add(conn); err != nil {
		conn.Close()
		log.Error("", err)
		return
	}
	wsConn := conns.NewWSConn(conn, self.server.connOption, self.server.PendingWriteNum, self.server.MaxMsgLen)
	ag := agent.NewAgent(wsConn)
	self.server.hook.EmitWithKey(CONST_AGENT_NEW, ag)
	ag.LoopRecv(self.handle)

	ag.Close()
	//ag.OnClose()
	self.server.hook.EmitWithKey(CONST_AGENT_CLOSE, ag)
	self.server.box.Del(conn)
}

// function handle 路由分发
func dealHandle(serv *Server) agent.AgentHandle {
	return func(data []byte, ag agent.Agent) {

		msg, err := serv.Router().Encoder().Unmarshal(data)
		if err != nil {
			log.Debug("unmarshal message error: %v", err)
			return
		}
		err = serv.Router().Route(msg, ag)
		if err != nil {
			log.Debug("route message error: %v", err)
			return
		}
	}
}

3.3、TcpServer

源码

package servers

import (
	"github.com/slclub/easy/log"
	"github.com/slclub/easy/nets/agent"
	"github.com/slclub/easy/nets/conns"
	"github.com/slclub/easy/route"
	"net"
	"time"
)

type TCPServer struct {
	Server
}

func NewTCPServer() *TCPServer {
	ser := Server{
		router: route.NewRouter(),
		hook:   newHookAgent(),
	}
	return &TCPServer{
		Server: ser,
	}
}

func (self *TCPServer) Start() {
	self.startBefore()
	self.run()
}

func (self *TCPServer) run() {
	var tempDelay time.Duration
	for {
		conn, err := self.ln.Accept()
		if err != nil {
			if ne, ok := err.(net.Error); ok && ne.Temporary() {
				if tempDelay == 0 {
					tempDelay = 5 * time.Millisecond
				} else {
					tempDelay *= 2
				}
				if max := 1 * time.Second; tempDelay > max {
					tempDelay = max
				}
				log.Release("accept error: %v; retrying in %v", err, tempDelay)
				time.Sleep(tempDelay)
				continue
			}
			return
		}
		tempDelay = 0

		if self.box.Len() >= self.MaxConnNum {
			conn.Close()
			log.Debug("EASY.TCP too many connections")
			continue
		}
		self.box.Add(conn)

		tcpConn := conns.NewTCPConn(conn, self.PendingWriteNum, self.connOption)
		ag := agent.NewAgent(tcpConn)
		go func() {
			self.hook.EmitWithKey(CONST_AGENT_NEW, ag)
			ag.LoopRecv(dealHandle(&self.Server))

			ag.Close()
			//ag.OnClose()
			self.hook.EmitWithKey(CONST_AGENT_CLOSE, ag)
			self.box.Del(conn)

			// cleanup
		}()
	}
}

3.4、KCPServer

待完成

4、hookAgent链接钩子

• 钩子

const (
	CONST_AGENT_CLOSE  = "CloseAgent"
	CONST_AGENT_NEW    = "NewAgent"
	CONST_SERVER_CLOSE = "CloseServer" // running your defined functions where you closed the listening server
)

• 源码

type hookAgent struct {
	hook map[string][]typehandle.AgentHandle
}

func newHookAgent() *hookAgent {
	return &hookAgent{
		hook: make(map[string][]typehandle.AgentHandle),
	}
}

func (self *hookAgent) Append(hkey string, handle typehandle.AgentHandle) {
	if self.hook[hkey] == nil {
		self.hook[hkey] = []typehandle.AgentHandle{}
	}
	self.hook[hkey] = append(self.hook[hkey], handle)
}

func (self *hookAgent) EmitWithKey(hkey string, ag agent.Agent) {
	if nil == self.hook[hkey] || len(self.hook[hkey]) == 0 {
		return
	}
	for _, fn := range self.hook[hkey] {
		fn(ag)
	}
}

5、创建一个WebScoket监听服务

	server1 = servers.NewWSServer()

	server1.Init(option.OptionWith(&agent.Gate{
		Addr:            ":" + strconv.Itoa(ListenPort),
		Protocol:        typehandle.ENCRIPT_DATA_JSON,
		PendingWriteNum: 2000,
		LittleEndian:    true,
		MaxConnNum:      20000,
	}).Default(option.DEFAULT_IGNORE_ZERO))