Go开源游戏服务器框架——Pitaya

简介

Pitaya是一款由国外游戏公司topfreegames使用golang进行编写，易于使用，快速且轻量级的开源分布式游戏服务器框架
Pitaya使用etcd作为默认的服务发现组件，提供使用nats和grpc进行远程调用(server to server)的可选配置，并提供在docker中运行以上组件(etcd、nats)的docker-compose配置

抽象分析

• PlayerConn
  PlayerConn是一个封装的连接对象，继承net.Conn，并提供一个获取下一个数据包的方法

	type PlayerConn interface {
		GetNextMessage() (b []byte, err error)
		net.Conn
	}

• Acceptor
  Acceptor代表一个服务端端口进程，接收客户端连接，并用一个内部Chan来维护这些连接对象

	type Acceptor interface {
		ListenAndServe()
		Stop()
		GetAddr() string
		GetConnChan() chan PlayerConn
	}

• Acceptorwrapper
  Acceptorwrapper义如其名就是Acceptor的包装器，因为Acceptor的通过Chan来保存连接
  所以wrapper可以通过遍历这个Chan来实时包装这些连接

	type Wrapper interface {
		Wrap(acceptor.Acceptor) acceptor.Acceptor
	}

• Agent
  Agent是一个服务端的应用层连接对象，包含了：
  Session信息
  服务器预发送消息队列
  拆解包对象
  最后心跳时间
  停止发送心跳的chan
  关闭发送数据的chan
  全局的关闭信号
  连接对象
  Agent当前状态
  … …

	type (
		// Agent corresponds to a user and is used for storing raw Conn information
		Agent struct {
			Session            *session.Session  // session
			appDieChan         chan bool         // app die channel
			chDie              chan struct{}     // wait for close
			chSend             chan pendingWrite // push message queue
			chStopHeartbeat    chan struct{}     // stop heartbeats
			chStopWrite        chan struct{}     // stop writing messages
			closeMutex         sync.Mutex
			conn               net.Conn            // low-level conn fd
			decoder            codec.PacketDecoder // binary decoder
			encoder            codec.PacketEncoder // binary encoder
			heartbeatTimeout   time.Duration
			lastAt             int64 // last heartbeat unix time stamp
			messageEncoder     message.Encoder
			... ...
			state              int32                // current agent state
		}
	
		pendingWrite struct {
			ctx  context.Context
			data []byte
			err  error
		}
	)

• Component
  Component代表业务组件，提供若干个接口
  通过Component生成处理请求的Service

	type Component interface {
		Init()
		AfterInit()
		BeforeShutdown()
		Shutdown()
	}

• Handler、Remote、Service
  Handler和Remote分别代表本地逻辑执行器和远程逻辑执行器
  Service是一组服务对象，包含若干Handler和Remote
  这里有个温柔的细节——Receiver reflect.Value
  pitaya的设计者为了降低引用，采取在逻辑执行器中保留方法的Receiver以达到在Handler和Remote对象中，只需要保存类型的Method，而无需保存带对象引用的Value.Method

	type (
		//Handler represents a message.Message's handler's meta information.
		Handler struct {
			Receiver    reflect.Value  // receiver of method
			Method      reflect.Method // method stub
			Type        reflect.Type   // low-level type of method
			IsRawArg    bool           // whether the data need to serialize
			MessageType message.Type   // handler allowed message type (either request or notify)
		}
	
		//Remote represents remote's meta information.
		Remote struct {
			Receiver reflect.Value  // receiver of method
			Method   reflect.Method // method stub
			HasArgs  bool           // if remote has no args we won't try to serialize received data into arguments
			Type     reflect.Type   // low-level type of method
		}
	
		// Service implements a specific service, some of it's methods will be
		// called when the correspond events is occurred.
		Service struct {
			Name     string              // name of service
			Type     reflect.Type        // type of the receiver
			Receiver reflect.Value       // receiver of methods for the service
			Handlers map[string]*Handler // registered methods
			Remotes  map[string]*Remote  // registered remote methods
			Options  options             // options
		}
	)

• Modules
  Modules模块和Component结构一致，唯一的区别在于使用上
  Modules主要是面向系统的一些全局存活的对象
  方便在统一的时机，集中进行启动和关闭

	type Base struct{}
	
	func (c *Base) Init() error {
		return nil
	}
	
	func (c *Base) AfterInit() {}
	
	func (c *Base) BeforeShutdown() {}
	
	func (c *Base) Shutdown() error {
		return nil
	}

集中管理的对象容器在外部module.go中定义

	var (
		modulesMap = make(map[string]interfaces.Module)
		modulesArr = []moduleWrapper{}
	)
	
	type moduleWrapper struct {
		module inte