first commit

.gitignore

@@ -0,0 +1,17 @@
+# Binaries for programs and plugins
+*.exe
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
+.glide/
+
+.idea/
+.vscode/

component/base.go

@@ -0,0 +1,14 @@
+package component
+
+var _ Component = (*Base)(nil)
+
+// Base 空组件
+type Base struct{}
+
+func (*Base) Init() {}
+
+func (*Base) AfterInit() {}
+
+func (*Base) BeforeShutdown() {}
+
+func (*Base) Shutdown() {}

component/component.go

@@ -0,0 +1,16 @@
+package component
+
+// Component 具体组件的接口.
+type Component interface {
+	// Init 初始化组件时调用.
+	Init()
+
+	// AfterInit 初始化组件后调用.
+	AfterInit()
+
+	// BeforeShutdown 组件被停止前调用.
+	BeforeShutdown()
+
+	// Shutdown 停止组件时调用.
+	Shutdown()
+}

component/hub.go

@@ -0,0 +1,20 @@
+package component
+
+type CompWithOptions struct {
+	Comp Component
+	Opts []Option
+}
+
+type Components struct {
+	comps []CompWithOptions
+}
+
+// Register registers a component to hub with options
+func (cs *Components) Register(c Component, options ...Option) {
+	cs.comps = append(cs.comps, CompWithOptions{c, options})
+}
+
+// List returns all components with it's options
+func (cs *Components) List() []CompWithOptions {
+	return cs.comps
+}

component/method.go

@@ -0,0 +1,55 @@
+package component
+
+import (
+	"reflect"
+	"unicode"
+	"unicode/utf8"
+)
+
+var (
+	typeOfError = reflect.TypeOf((*error)(nil)).Elem()
+	typeOfBytes = reflect.TypeOf(([]byte)(nil))
+	//typeOfSession = reflect.TypeOf(session.New(nil))
+)
+
+func isExported(name string) bool {
+	w, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(w)
+}
+
+func isExportedOrBuiltinType(t reflect.Type) bool {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	// PkgPath will be non-empty even for an exported type,
+	// so we need to check the type name as well.
+	return isExported(t.Name()) || t.PkgPath() == ""
+}
+
+// isHandlerMethod decide a method is suitable handler method
+func isHandlerMethod(method reflect.Method) bool {
+	mt := method.Type
+	// Method must be exported.
+	if method.PkgPath != "" {
+		return false
+	}
+
+	// Method needs three ins: receiver, *Session, []byte or pointer.
+	if mt.NumIn() != 3 {
+		return false
+	}
+
+	// Method needs one outs: error
+	if mt.NumOut() != 1 {
+		return false
+	}
+
+	if t1 := mt.In(1); t1.Kind() != reflect.Ptr || t1 != typeOfSession {
+		return false
+	}
+
+	if (mt.In(2).Kind() != reflect.Ptr && mt.In(2) != typeOfBytes) || mt.Out(0) != typeOfError {
+		return false
+	}
+	return true
+}

component/options.go

@@ -0,0 +1,34 @@
+package component
+
+type (
+	options struct {
+		name          string              // component name
+		nameFunc      func(string) string // rename handler name
+		schedulerName string              // schedulerName name
+	}
+
+	// Option used to customize handler
+	Option func(options *options)
+)
+
+// WithName used to rename component name
+func WithName(name string) Option {
+	return func(opt *options) {
+		opt.name = name
+	}
+}
+
+// WithNameFunc override handler name by specific function
+// such as: strings.ToUpper/strings.ToLower
+func WithNameFunc(fn func(string) string) Option {
+	return func(opt *options) {
+		opt.nameFunc = fn
+	}
+}
+
+// WithSchedulerName set the name of the service scheduler
+func WithSchedulerName(name string) Option {
+	return func(opt *options) {
+		opt.schedulerName = name
+	}
+}

component/service.go

@@ -0,0 +1,107 @@
+package component
+
+import (
+	"errors"
+	"reflect"
+)
+
+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   // arg type of method
+		IsRawArg bool           // whether the data need to unserialize
+	}
+
+	// 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
+		SchedulerName string              // name of scheduler variable in session data
+		Options       options             // options
+	}
+)
+
+func NewService(comp Component, opts []Option) *Service {
+	s := &Service{
+		Type:     reflect.TypeOf(comp),
+		Receiver: reflect.ValueOf(comp),
+	}
+
+	// apply options
+	for i := range opts {
+		opt := opts[i]
+		opt(&s.Options)
+	}
+	if name := s.Options.name; name != "" {
+		s.Name = name
+	} else {
+		s.Name = reflect.Indirect(s.Receiver).Type().Name()
+	}
+	s.SchedulerName = s.Options.schedulerName
+
+	return s
+}
+
+// suitableMethods returns suitable methods of typ
+func (s *Service) suitableHandlerMethods(typ reflect.Type) map[string]*Handler {
+	methods := make(map[string]*Handler)
+	for m := 0; m < typ.NumMethod(); m++ {
+		method := typ.Method(m)
+		mt := method.Type
+		mn := method.Name
+		if isHandlerMethod(method) {
+			raw := false
+			if mt.In(2) == typeOfBytes {
+				raw = true
+			}
+			// rewrite handler name
+			if s.Options.nameFunc != nil {
+				mn = s.Options.nameFunc(mn)
+			}
+			methods[mn] = &Handler{Method: method, Type: mt.In(2), IsRawArg: raw}
+		}
+	}
+	return methods
+}
+
+// ExtractHandler extract the set of methods from the
+// receiver value which satisfy the following conditions:
+// - exported method of exported type
+// - two arguments, both of exported type
+// - the first argument is *session.Session
+// - the second argument is []byte or a pointer
+func (s *Service) ExtractHandler() error {
+	typeName := reflect.Indirect(s.Receiver).Type().Name()
+	if typeName == "" {
+		return errors.New("no service name for type " + s.Type.String())
+	}
+	if !isExported(typeName) {
+		return errors.New("type " + typeName + " is not exported")
+	}
+
+	// Install the methods
+	s.Handlers = s.suitableHandlerMethods(s.Type)
+
+	if len(s.Handlers) == 0 {
+		str := ""
+		// To help the user, see if a pointer receiver would work.
+		method := s.suitableHandlerMethods(reflect.PtrTo(s.Type))
+		if len(method) != 0 {
+			str = "type " + s.Name + " has no exported methods of suitable type (hint: pass a pointer to value of that type)"
+		} else {
+			str = "type " + s.Name + " has no exported methods of suitable type"
+		}
+		return errors.New(str)
+	}
+
+	for i := range s.Handlers {
+		s.Handlers[i].Receiver = s.Receiver
+	}
+
+	return nil
+}

go.mod

@@ -0,0 +1,3 @@
+module ng
+
+go 1.18

internal/codec/codec.go

@@ -0,0 +1,124 @@
+package codec
+
+import (
+	"bytes"
+	"errors"
+	"ng/internal/packet"
+)
+
+// Codec constants.
+const (
+	HeadLength    = 4
+	MaxPacketSize = 64 * 1024
+)
+
+// ErrPacketSizeExceed is the error used for encode/decode.
+var ErrPacketSizeExceed = errors.New("codec: packet size exceed")
+
+// A Decoder reads and decodes network data slice
+type Decoder struct {
+	buf  *bytes.Buffer
+	size int  // last packet length
+	typ  byte // last packet type
+}
+
+// NewDecoder returns a new decoder that used for decode network bytes slice.
+func NewDecoder() *Decoder {
+	return &Decoder{
+		buf:  bytes.NewBuffer(nil),
+		size: -1,
+	}
+}
+
+func (c *Decoder) forward() error {
+	header := c.buf.Next(HeadLength)
+	c.typ = header[0]
+	if c.typ < packet.Handshake || c.typ > packet.Kick {
+		return packet.ErrWrongPacketType
+	}
+	c.size = bytesToInt(header[1:])
+
+	// packet length limitation
+	if c.size > MaxPacketSize {
+		return ErrPacketSizeExceed
+	}
+	return nil
+}
+
+// Decode decode the network bytes slice to packet.Packet(s)
+// TODO(Warning): shared slice
+func (c *Decoder) Decode(data []byte) ([]*packet.Packet, error) {
+	c.buf.Write(data)
+
+	var (
+		packets []*packet.Packet
+		err     error
+	)
+	// check length
+	if c.buf.Len() < HeadLength {
+		return nil, err
+	}
+
+	// first time
+	if c.size < 0 {
+		if err = c.forward(); err != nil {
+			return nil, err
+		}
+	}
+
+	for c.size <= c.buf.Len() {
+		p := &packet.Packet{Type: packet.Type(c.typ), Length: c.size, Data: c.buf.Next(c.size)}
+		packets = append(packets, p)
+
+		// more packet
+		if c.buf.Len() < HeadLength {
+			c.size = -1
+			break
+		}
+
+		if err = c.forward(); err != nil {
+			return packets, err
+		}
+	}
+
+	return packets, nil
+}
+
+// Encode create a packet.Packet from  the raw bytes slice and then encode to network bytes slice
+// Protocol refs: https://github.com/NetEase/pomelo/wiki/Communication-Protocol
+//
+// -<type>-|--------<length>--------|-<data>-
+// --------|------------------------|--------
+// 1 byte packet type, 3 bytes packet data length(big end), and data segment
+func Encode(typ packet.Type, data []byte) ([]byte, error) {
+	if typ < packet.Handshake || typ > packet.Kick {
+		return nil, packet.ErrWrongPacketType
+	}
+
+	p := &packet.Packet{Type: typ, Length: len(data)}
+	buf := make([]byte, p.Length+HeadLength)
+	buf[0] = byte(p.Type)
+
+	copy(buf[1:HeadLength], intToBytes(p.Length))
+	copy(buf[HeadLength:], data)
+
+	return buf, nil
+}
+
+// Decode packet data length byte to int(Big end)
+func bytesToInt(b []byte) int {
+	result := 0
+	for _, v := range b {
+		result = result<<8 + int(v)
+	}
+	return result
+}
+
+// Encode packet data length to bytes(Big end)
+func intToBytes(n int) []byte {
+	buf := make([]byte, 3)
+	buf[0] = byte((n >> 16) & 0xFF)
+	buf[1] = byte((n >> 8) & 0xFF)
+	buf[2] = byte(n & 0xFF)
+	return buf
+}

internal/codec/codec_test.go

@@ -0,0 +1,27 @@
+package codec
+
+import (
+	. "ng/internal/packet"
+	"testing"
+)
+
+func BenchmarkDecoder_Decode(b *testing.B) {
+	data := []byte("hello world")
+	pp1, err := Encode(Handshake, data)
+	if err != nil {
+		b.Error(err.Error())
+	}
+
+	d1 := NewDecoder()
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		packets, err := d1.Decode(pp1)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if len(packets) != 1 {
+			b.Fatal("decode error")
+		}
+	}
+}

internal/log/logger.go

@@ -0,0 +1,33 @@
+package log
+
+import (
+	"log"
+	"os"
+)
+
+// Logger represents  the log interface
+type Logger interface {
+	Println(v ...interface{})
+	Fatal(v ...interface{})
+	Fatalf(format string, v ...interface{})
+}
+
+func init() {
+	SetLogger(log.New(os.Stderr, "[NGServer]", log.LstdFlags|log.Lshortfile))
+}
+
+var (
+	Println func(v ...interface{})
+	Fatal   func(v ...interface{})
+	Fatalf  func(format string, v ...interface{})
+)
+
+// SetLogger rewrites the default logger
+func SetLogger(logger Logger) {
+	if logger == nil {
+		return
+	}
+	Println = logger.Println
+	Fatal = logger.Fatal
+	Fatalf = logger.Fatalf
+}

internal/packet/packet.go

@@ -0,0 +1,47 @@
+package packet
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Type represents the network packet's type such as: handshake and so on.
+type Type byte
+
+const (
+	_ Type = iota
+	// Handshake represents a handshake: request(client) <====> handshake response(server)
+	Handshake = 0x01
+
+	// HandshakeAck represents a handshake ack from client to server
+	HandshakeAck = 0x02
+
+	// Heartbeat represents a heartbeat
+	Heartbeat = 0x03
+
+	// Data represents a common data packet
+	Data = 0x04
+
+	// Kick represents a kick off packet
+	Kick = 0x05 // disconnect message from server
+)
+
+// ErrWrongPacketType represents a wrong packet type.
+var ErrWrongPacketType = errors.New("wrong packet type")
+
+// Packet represents a network packet.
+type Packet struct {
+	Type   Type
+	Length int
+	Data   []byte
+}
+
+// New create a Packet instance.
+func New() *Packet {
+	return &Packet{}
+}
+
+// String represents the Packet's in text mode.
+func (p *Packet) String() string {
+	return fmt.Sprintf("Type: %d, Length: %d, Data: %s", p.Type, p.Length, string(p.Data))
+}