common/components/server.go

package components
import (
	"fmt"
	"net"
	"pro2d/common/logger"
	"sync"
)
type ServerOption func(*Server)
func WithPlugin(iPlugin IPlugin) ServerOption {
	return func(server *Server) {
		server.plugins = iPlugin
	}
}
func WithSplitter(splitter ISplitter) ServerOption {
	return func(server *Server) {
		server.splitter = splitter
	}
}
func WithConnCbk(cb ConnectionCallback) ServerOption {
	return func(server *Server) {
		server.connectionCallback = cb
	}
}
func WithMsgCbk(cb MessageCallback) ServerOption {
	return func(server *Server) {
		server.messageCallback = cb
	}
}
func WithCloseCbk(cb CloseCallback) ServerOption {
	return func(server *Server) {
		server.closeCallback = cb
	}
}
func WithTimerCbk(cb TimerCallback) ServerOption {
	return func(server *Server) {
		server.timerCallback = cb
	}
}
type Server struct {
	PluginPath 			string
	plugins  			IPlugin
	splitter 			ISplitter
	connectionCallback 	ConnectionCallback
	messageCallback    	MessageCallback
	closeCallback      	CloseCallback
	timerCallback 		TimerCallback
	port 				int
	Clients *sync.Map
}
func NewServer(port int, options ...ServerOption) IServer {
	s := &Server{
		port:      port,
		Clients:    new(sync.Map),
	}
	for _, option := range options {
		option(s)
	}
	return s
}
func (s *Server) GetSplitter() ISplitter {
	return s.splitter
}
func (s *Server) GetIConnection(id int) IConnection {
	c, ok := s.Clients.Load(id)
	if !ok {
		return nil
	}
	return c.(IConnection)
}
func (s *Server) GetPlugin() IPlugin {
	return s.plugins
}
func (s *Server) GetAction(cmd uint32) interface{} {
	return s.plugins.GetAction(cmd)
}
func (s *Server) SetConnectionCallback(cb ConnectionCallback) {
	s.connectionCallback = cb
}
func (s *Server) SetMessageCallback(cb MessageCallback) {
	s.messageCallback = cb
}
func (s *Server) SetCloseCallback(cb CloseCallback) {
	s.closeCallback = cb
}
func (s *Server) SetTimerCallback(cb TimerCallback) {
	s.timerCallback = cb
}
func (s *Server) Start() error {
	if err := s.plugins.LoadPlugin(); err != nil {
		return err
	}
	port := fmt.Sprintf(":%d", s.port)
	l, err := net.Listen("tcp", port)
	if err != nil {
		return err
	}
	//监听端口
	logger.Debug("listen on %s\n", port)
	id := 0
	for {
		conn, err := l.Accept()
		if err != nil {
			return err
		}
		id++
		client := NewConn(id, conn, s)
		s.newConnection(client)
	}
}
func (s *Server)Stop()  {
	StopTimer()
	s.Clients.Range(func(key, value interface{}) bool {
		client := value.(IConnection)
		client.Stop()
		return true
	})
}
func (s *Server) newConnection(conn IConnection) {
	s.Clients.Store(conn.GetID(), conn)
	conn.SetConnectionCallback(s.connectionCallback)
	conn.SetCloseCallback(s.removeConnection)
	conn.SetMessageCallback(s.messageCallback)
	conn.SetTimerCallback(s.timerCallback)
	go conn.Start()
}
func (s *Server) removeConnection(conn IConnection) {
	s.closeCallback(conn)
	s.Clients.Delete(conn.GetID())
}