franklin/agent/server.go

package main

import (
	"encoding/json"
	"git.wanbits.io/joe/franklin/comp"
	"git.wanbits.io/joe/franklin/protos"
	"git.wanbits.io/joe/kettle/log"
	"git.wanbits.io/joe/kettle/utl"
	"git.wanbits.io/joe/nnet"
	"github.com/golang/protobuf/proto"
	"go.uber.org/zap"
)

// C/S packet
type CSPacket struct {
	*protos.Request
}

func (self *CSPacket) ShouldClose() (bool, int32) {
	return false, 0
}

type SCPacket struct {
	resp    *protos.Response
	closing bool
	reason  int32
}

func (self *SCPacket) ShouldClose() (bool, int32) {
	return self.closing, self.reason
}

// protocol && callback
type CSProtocol struct{
}

func (self *CSProtocol) ReadPacket(conn nnet.IConn) (nnet.IPacket, error) {
	buf := comp.GBufPool.Get()
	defer comp.GBufPool.Put(buf)

	n, err := conn.Read(buf)
	if err != nil {
		return nil, err
	}
	var req *protos.Request
	err = proto.Unmarshal(buf[:n], req)
	if err != nil {
		return nil, err
	}
	p := &CSPacket{
		req,
	}
	return p, nil
}

func (self *CSProtocol) Serialize(packet nnet.IPacket) ([]byte, error) {
	p, ok := packet.(*SCPacket)
	if !ok {
		return nil, utl.ErrInterfaceTransform
	}
	return json.Marshal(p.resp)
}

func (self *CSProtocol) OnClosed(ses nnet.ISession, reason int32) {
	log.Debug("lost connection", zap.String("remote", ses.GetRawConn().RemoteAddr().String()),
		zap.Uint64("id", ses.Id()))
}

func (self *CSProtocol) OnConnected(ses nnet.ISession) (bool, int32) {
	log.Debug("new client", zap.String("remote", ses.GetRawConn().RemoteAddr().String()))
	return true, 0
}

func (self *CSProtocol) OnMessage(ses nnet.ISession, pkt nnet.IPacket) bool {
	p, ok := pkt.(*CSPacket)
	if !ok {
		return false
	}
	dispatch(ses, p)
	return true
}

// server-side dont handle heartbeat.
func (self *CSProtocol) OnHeartbeat(ses nnet.ISession) bool {
	return true
}