探索 Golang 云原生游戏服务器开发，5 分钟上手 Nano 游戏服务器框架

type DemoComponent struct{}
func (c *DemoComponent) Init()           {}
func (c *DemoComponent) AfterInit()      {}
func (c *DemoComponent) BeforeShutdown() {}
func (c *DemoComponent) Shutdown()       {}

type (
  // 房间的定义
  Room struct {
    // 管理房间内所有的会话
    group *nano.Group
  }
  // RoomManager 表示一个包含一堆房间的组件，他是 nano 组件，可在生命周期内 hook 逻辑
  RoomManager struct {
    // 继承 nano 组件，拥有完整的生命周期
    component.Base
    // 组件初始化完成后，做一些定时任务
    timer *scheduler.Timer
    // 多个房间，key-value 存储
    rooms map[int]*Room
  }
  // 表示一个用户发送的消息定义
  UserMessage struct {
    Name    string `json:"name"`
    Content string `json:"content"`
  }
  // 当新用户加入房间时将收到新用户消息（广播）
  NewUser struct {
    Content string `json:"content"`
  }
  // 包含所有成员的 UID 
  AllMembers struct {
    Members []int64 `json:"members"`
  }
  // 表示加入房间服务端的响应结果
  JoinResponse struct {
    Code   int    `json:"code"`
    Result string `json:"result"`
  }
  // 流量统计
  Stats struct {
    // 继承 nano 组件，拥有完整的生命周期
    component.Base
    // 组件初始化完成后，做一些定时任务
    timer         *scheduler.Timer
    // 出口流量统计
    outboundBytes int
    // 入口流量统计
    inboundBytes  int
  }
)
// 统计出口流量，会定义到 nano 的 pipeline
func (stats *Stats) outbound(s *session.Session, msg *pipeline.Message) error {
  stats.outboundBytes += len(msg.Data)
  return nil
}
// 统计入口流量，会定义到 nano 的 pipeline
func (stats *Stats) inbound(s *session.Session, msg *pipeline.Message) error {
  stats.inboundBytes += len(msg.Data)
  return nil
}
// 组件初始化完成后，会调用
// 每分钟会打印下出口与入口的流量
func (stats *Stats) AfterInit() {
  stats.timer = scheduler.NewTimer(time.Minute, func() {
    println("OutboundBytes", stats.outboundBytes)
    println("InboundBytes", stats.outboundBytes)
  })
}
func (st *Stats) Nil(s *session.Session, msg []byte) error {
  return nil
}
const (
  // 测试房间 id
  testRoomID = 1
  // 测试房间 key
  roomIDKey  = "ROOM_ID"
)
// 初始化 RoomManager
func NewRoomManager() *RoomManager {
  return &RoomManager{
    rooms: map[int]*Room{},
  }
}
// RoomManager 初始化完成后将被调用
func (mgr *RoomManager) AfterInit() {
  // 用户断开连接后将会被调用
  // 将它从房间中移除
  session.Lifetime.OnClosed(func(s *session.Session) {
    if !s.HasKey(roomIDKey) {
      return
    }
    room := s.Value(roomIDKey).(*Room)
    // 移除这个会话
    room.group.Leave(s)
  })
  // 一个定时任务，每分钟打印下房间的成员数量
  mgr.timer = scheduler.NewTimer(time.Minute, func() {
    for roomId, room := range mgr.rooms {
      println(fmt.Sprintf("UserCount: RoomID=%d, Time=%s, Count=%d",
        roomId, time.Now().String(), room.group.Count()))
    }
  })
}
// 加入房间的业务逻辑处理
func (mgr *RoomManager) Join(s *session.Session, msg []byte) error {
  // 注意：这里 demo 仅仅只是加入 testRoomID
  room, found := mgr.rooms[testRoomID]
  if !found {
    room = &Room{
      group: nano.NewGroup(fmt.Sprintf("room-%d", testRoomID)),
    }
    mgr.rooms[testRoomID] = room
  }
  fakeUID := s.ID() // 这里仅仅是用 sessionId 模拟下 uid
  s.Bind(fakeUID)   // 绑定 uid 到 session
  s.Set(roomIDKey, room) // 设置一下当前 session 关联到的房间
  // 推送房间所有成员到当前的 session
  s.Push("onMembers", &AllMembers{Members: room.group.Members()})
  // 广播房间内其它成员，有新人加入
  room.group.Broadcast("onNewUser", &NewUser{Content: fmt.Sprintf("New user: %d", s.ID())})
  // 将 session 加入到房间 group 统一管理
  room.group.Add(s)
  // 回应当前用户加入成功
  return s.Response(&JoinResponse{Result: "success"})
}
// 同步最新的消息给房间内所有成员
func (mgr *RoomManager) Message(s *session.Session, msg *UserMessage) error {
  if !s.HasKey(roomIDKey) {
    return fmt.Errorf("not join room yet")
  }
  room := s.Value(roomIDKey).(*Room)
  // 广播
  return room.group.Broadcast("onMessage", msg)
}
func main() {
  // 新建组件容器实例
  components := &component.Components{}
  // 注册组件
  components.Register(
    // 组件实例
    NewRoomManager(),
    // 重写组件名字
    component.WithName("room"),
    // 重写组件 handler 名字，这里是小写
    component.WithNameFunc(strings.ToLower),
  )
  // 流量统计
  pip := pipeline.New()
  var stats = &stats{}
  // 入队 Outbound pipeline 
  pip.Outbound().PushBack(stats.outbound)
  // 入队 Inbound pipeline
  pip.Inbound().PushBack(stats.inbound)
  // 注册下流量统计组件
  components.Register(stats, component.WithName("stats"))
  // 设置日志打印格式
  log.SetFlags(log.LstdFlags | log.Llongfile)
  // web 静态资源处理
  http.Handle("/web/", http.StripPrefix("/web/", http.FileServer(http.Dir("web"))))
  // 启动 nano 
  nano.Listen(":3250", // 端口号
    nano.WithIsWebsocket(true), // 是否使用 websocket
    nano.WithPipeline(pip), // 是否使用 pipeline
    nano.WithCheckOriginFunc(func(_ *http.Request) bool { return true }), // 允许跨域
    nano.WithWSPath("/nano"), // websocket 连接地址
    nano.WithDebugMode(),  // 开启 debug 模式
    nano.WithSerializer(json.NewSerializer()), // 使用 json 序列化器
    nano.WithComponents(components), // 加载组件
  )
}

FROM golang:1.14
WORKDIR /workspace
# 阿里云
RUN go env -w GO111MODULE=on
RUN go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct
# debug
RUN go get github.com/go-delve/delve/cmd/dlv
# live reload
RUN go get -u github.com/cosmtrek/air
# nano
RUN go mod init cloud-native-game-server
RUN go get github.com/lonng/nano@master

docker build -f Dockerfile.dev -t cloud-native-game-server:dev .

version: "3.4"
services:
  demo:
    image: cloud-native-game-server:dev
    command: >
      bash -c "cp ./go.mod ./go.sum app/
      && cd app/demo/${DEMO}
      && ls -la
      && air -c ../../.air.toml -d"
    volumes:
    - ./:/workspace/app
    ports:
      - 3250:3250
  demo-debug:
    image: cloud-native-game-server:dev
    command: >
      bash -c "cp ./go.mod ./go.sum app/
      && cd app/demo/${DEMO}
      && ls -la
      && dlv debug main.go --headless --log -l 0.0.0.0:2345 --api-version=2"
    volumes:
    - ./:/workspace/app
    ports:
      - 3250:3250
      - 2345:2345
    security_opt:
      - "seccomp:unconfined"

# 如我要开发 1-nano-chat
DEMO=1-nano-chat docker-compose up demo

# 如我要调试 1-nano-chat
DEMO=1-nano-chat docker-compose up demo-debug