提交origin2.0版本

example/GateService/GateService.go

@@ -0,0 +1,43 @@
+package GateService
+
+import (
+	"github.com/duanhf2012/originnet/event"
+	"github.com/duanhf2012/originnet/node"
+	"github.com/duanhf2012/originnet/service"
+	"github.com/duanhf2012/originnet/sysservice"
+)
+
+type GateService struct {
+	processor *PBProcessor
+	service.Service
+}
+
+func (slf *GateService) OnInit() error{
+	tcpervice := node.GetService("TcpService").(*sysservice.TcpService)
+	tcpervice.SetProcessor(&PBProcessor{})
+	return nil
+}
+
+
+func (slf *GateService) OnEventHandler(ev *event.Event) error{
+	if ev.Type == event.Sys_Event_Tcp_RecvPack {
+		pPack := ev.Data.(*sysservice.TcpPack)
+		slf.processor.Route(pPack.Data,pPack.ClientId)
+	}else if ev.Type == event.Sys_Event_Tcp_Connected {
+		pPack := ev.Data.(*sysservice.TcpPack)
+		slf.OnConnected(pPack.ClientId)
+	}else if ev.Type == event.Sys_Event_Tcp_DisConnected {
+		pPack := ev.Data.(*sysservice.TcpPack)
+		slf.OnDisconnected(pPack.ClientId)
+	}
+	return nil
+}
+
+func (slf *GateService) OnConnected(clientid uint64){
+
+}
+
+
+func (slf *GateService) OnDisconnected(clientid uint64){
+
+}

example/GateService/pbprocessor.go

@@ -0,0 +1,79 @@
+package GateService
+
+import (
+	"encoding/binary"
+	"fmt"
+	"github.com/golang/protobuf/proto"
+	"reflect"
+)
+
+type MessageInfo struct {
+	msgType    reflect.Type
+	msgHandler MessageHandler
+}
+
+
+type PBProcessor struct {
+	mapMsg map[uint16]MessageInfo
+	LittleEndian bool
+}
+
+func (slf *PBProcessor) SetLittleEndian(littleEndian bool){
+	slf.LittleEndian = littleEndian
+}
+
+type PackInfo struct {
+	typ uint16
+	msg proto.Message
+}
+
+// must goroutine safe
+func (slf *PBProcessor ) Route(msg interface{},userdata interface{}) error{
+	pPackInfo := msg.(*PackInfo)
+	v,ok := slf.mapMsg[pPackInfo.typ]
+	if ok == false {
+		return fmt.Errorf("cannot find msgtype %d is register!",pPackInfo.typ)
+	}
+
+
+	v.msgHandler(userdata.(uint64),pPackInfo.msg)
+	return nil
+}
+
+// must goroutine safe
+func (slf *PBProcessor ) Unmarshal(data []byte) (interface{}, error) {
+	var msgType uint16
+	if slf.LittleEndian == true {
+		msgType = binary.LittleEndian.Uint16(data[:2])
+	}else{
+		msgType = binary.BigEndian.Uint16(data[:2])
+	}
+
+	info,ok := slf.mapMsg[msgType]
+	if ok == false {
+		return nil,fmt.Errorf("cannot find register %d msgtype!",msgType)
+	}
+	msg := reflect.New(info.msgType.Elem()).Interface()
+	protoMsg := msg.(proto.Message)
+	err := proto.Unmarshal(data[2:], protoMsg)
+	if err != nil {
+		return nil,err
+	}
+
+	return &PackInfo{typ:msgType,msg:protoMsg},nil
+}
+
+// must goroutine safe
+func (slf *PBProcessor ) Marshal(msg interface{}) ([]byte, error){
+	return proto.Marshal(msg.(proto.Message))
+}
+
+type MessageHandler func(clientid uint64,msg proto.Message)
+
+func (slf *PBProcessor) Register(msgtype uint16,msg proto.Message,handle MessageHandler)  {
+	var info MessageInfo
+
+	info.msgType = reflect.TypeOf(msg.(proto.Message))
+	info.msgHandler = handle
+	slf.mapMsg[msgtype] = info
+}

example/config/cluster/subnet/cluster.json

@@ -0,0 +1,23 @@
+{
+    "NodeList":[
+        {
+          "NodeId": 1,
+          "ListenAddr":"127.0.0.1:8001",
+          "NodeName": "Node_Test1",
+		  "remark":"//以_打头的，表示只在本机进程，不对整个子网开发",
+          "ServiceList": ["TestService1","TestService2","TestServiceCall"]
+        },
+        {
+          "NodeId": 2,
+          "ListenAddr":"127.0.0.1:8002",
+          "NodeName": "Node_Gate2",
+          "ServiceList": ["SubNet1_Service"]
+        },
+        {
+          "NodeId": 3,
+          "ListenAddr":"127.0.0.1:8003",
+          "NodeName": "Node_Room",
+          "ServiceList": ["SubNet1_Service"]
+        }
+    ]
+}

example/config/cluster/subnet/service.json

@@ -0,0 +1,13 @@
+{
+  "HttpService":{
+	"Port":10001
+  },
+  "TcpService":{
+	"ListenAddr":"0.0.0.0:9030",
+	"MaxConnNum":3000,
+	"PendingWriteNum":10000,
+	"LittleEndian":false,
+	"MinMsgLen":4,
+	"MaxMsgLen":65535
+  }
+}

example/main.exe.pid

@@ -0,0 +1 @@
+49288

example/main.go

@@ -0,0 +1,202 @@
+package main
+
+import (
+	"fmt"
+	"github.com/duanhf2012/originnet/example/GateService"
+	"github.com/duanhf2012/originnet/node"
+	"github.com/duanhf2012/originnet/service"
+	"github.com/duanhf2012/originnet/sysmodule"
+	"github.com/duanhf2012/originnet/sysservice"
+	"time"
+)
+
+type TestService1 struct {
+	service.Service
+}
+
+type TestService2 struct {
+	service.Service
+}
+
+type TestServiceCall struct {
+	service.Service
+	dbModule sysmodule.DBModule
+}
+
+func init(){
+	node.Setup(&TestService1{},&TestService2{},&TestServiceCall{})
+}
+
+type Module1 struct{
+	service.Module
+}
+
+type Module2 struct{
+	service.Module
+}
+
+type Module3 struct{
+	service.Module
+}
+
+type Module4 struct{
+	service.Module
+}
+var moduleid1 int64
+var moduleid2 int64
+var moduleid3 int64
+var moduleid4 int64
+
+func (slf *Module1) OnInit() error {
+	fmt.Printf("I'm Module1:%d\n",slf.GetModuleId())
+	return nil
+}
+
+func (slf *Module2) OnInit() error {
+	fmt.Printf("I'm Module2:%d\n",slf.GetModuleId())
+	moduleid3,_ = slf.AddModule(&Module3{})
+	return nil
+}
+func (slf *Module3) OnInit() error {
+	fmt.Printf("I'm Module3:%d\n",slf.GetModuleId())
+	moduleid4,_ = slf.AddModule(&Module4{})
+
+	return nil
+}
+
+func (slf *Module4) OnInit() error {
+	fmt.Printf("I'm Module4:%d\n",slf.GetModuleId())
+	//pService := slf.GetService().(*TestServiceCall)
+	//pService.RPC_Test(nil,nil)
+	slf.AfterFunc(time.Second*10,slf.TimerTest)
+	return nil
+}
+
+func (slf *Module4) TimerTest(){
+	fmt.Printf("Module4 tigger timer\n")
+}
+
+func (slf *Module1) OnRelease() {
+	fmt.Printf("Release Module1:%d\n",slf.GetModuleId())
+}
+func (slf *Module2) OnRelease() {
+	fmt.Printf("Release Module2:%d\n",slf.GetModuleId())
+}
+func (slf *Module3) OnRelease() {
+	fmt.Printf("Release Module3:%d\n",slf.GetModuleId())
+}
+func (slf *Module4) OnRelease() {
+	fmt.Printf("Release Module4:%d\n",slf.GetModuleId())
+}
+
+func (slf *TestServiceCall) OnInit() error {
+	slf.AfterFunc(time.Second*1,slf.Run)
+	moduleid1,_ = slf.AddModule(&Module1{})
+	moduleid2,_ = slf.AddModule(&Module2{})
+	fmt.Print(moduleid1,moduleid2)
+
+	slf.dbModule = sysmodule.DBModule{}
+	slf.dbModule.Init(10,3, "192.168.0.5:3306", "root", "Root!!2018", "Matrix")
+	slf.dbModule.SetQuerySlowTime(time.Second * 3)
+	slf.AddModule(&slf.dbModule)
+
+	slf.AfterFunc(time.Second*5,slf.Release)
+	slf.AfterFunc(time.Second, slf.TestDB)
+	return nil
+}
+
+func  (slf *TestServiceCall) Release(){
+	slf.ReleaseModule(moduleid1)
+	slf.ReleaseModule(moduleid2)
+}
+
+
+type Param struct {
+	Index int
+	A int
+	B string
+	Pa []string
+}
+
+
+func  (slf *TestServiceCall) Run(){
+	//var ret int
+	var input int = 10000
+	bT := time.Now()            // 开始时间
+
+	//err := slf.Call("TestServiceCall.RPC_Test",&ret,&input)
+	var param Param
+	param.A = 2342342341
+	param.B = "xxxxxxxxxxxxxxxxxxxxxxx"
+	param.Pa = []string{"ccccc","asfsdfsdaf","bbadfsdf","ewrwefasdf","safsadfka;fksd"}
+
+	for i:=input;i>=0;i--{
+		param.Index = i
+		slf.AsyncCall("TestService1.RPC_Test",&param, func(reply *Param, err error) {
+			if reply.Index == 0 || err != nil{
+				eT := time.Since(bT)      // 从开始到当前所消耗的时间
+				fmt.Print(err,eT.Milliseconds())
+				fmt.Print("..................",eT,"\n")
+			}
+			//fmt.Print(*reply,"\n",err)
+		})
+
+	}
+
+	fmt.Print("finsh....")
+
+
+}
+
+func (slf *TestService1) RPC_Test(a *Param,b *Param) error {
+	*a = *b
+	return nil
+}
+
+func (slf *TestService1) OnInit() error {
+	return nil
+}
+
+func (slf *TestServiceCall) RPC_Test(a *int,b *int) error {
+	fmt.Printf("TestService2\n")
+	*a = *b
+	return nil
+}
+
+func (slf *TestServiceCall) TestDB() {
+	assetsInfo := &struct {
+		Cash  int64 `json:"cash"`  //美金余额 100
+		Gold  int64 `json:"gold"`  //金币余额
+		Heart int64 `json:"heart"` //心数
+	}{}
+	sql := `call sp_select_userAssets(?)`
+	userID := 100000802
+	err := slf.dbModule.AsyncQuery(func(dataList *sysmodule.DataSetList, err error) {
+		if err != nil {
+			return
+		}
+		err = dataList.UnMarshal(assetsInfo)
+		if err != nil {
+			return
+		}
+	},-1, sql, &userID)
+
+	fmt.Println(err)
+}
+
+func (slf *TestService2) OnInit() error {
+	return nil
+}
+
+func main(){
+	node.Init()
+	tcpService := &sysservice.TcpService{}
+	gateService := &GateService.GateService{}
+
+	tcpService.SetEventReciver(gateService)
+	node.Setup(tcpService,gateService)
+
+	node.Start()
+}
+
+

example/serviceTest/OriginServeOne.go

@@ -0,0 +1,64 @@
+package serviceTest
+
+import (
+	"fmt"
+	"github.com/duanhf2012/originnet/service"
+	"time"
+)
+
+type TestAsyn struct {
+	a int
+	b string
+}
+
+type OriginServerOne struct {
+	service.Service
+}
+
+func (slf *OriginServerOne) OnInit() error {
+	//slf.AfterFunc(time.Second,slf.testCall)
+	//slf.AfterFunc(time.Second*5,slf.testCall)
+	//slf.AfterFunc(time.Second*10, slf.testGRCall)
+	//slf.AfterFunc(time.Second*15, slf.testGRCall)
+	//slf.AfterFunc(time.Second, slf.testAsyncCall)
+	slf.AfterFunc(time.Second, slf.testAsyncGRCall)
+	return nil
+}
+
+func (slf *OriginServerOne) testCall() {
+	a := 1
+	b := 10
+	slf.Call("OriginServerTwo.RPC_TestCall", &a, &b)
+	fmt.Println(b)
+}
+
+func (slf *OriginServerOne) testGRCall()  {
+	a := 1
+	b := 10
+	slf.GRCall("OriginServerTwo.RPC_TestCall", &a, &b)
+	fmt.Println(b)
+}
+
+func (slf *OriginServerOne) testAsyncCall() {
+	for i := 0; i < 100; i++ {
+		in := i
+		bT := time.Now()
+		slf.AsyncCall("OriginServerTwo.RPC_TestAsyncCall", &in, func(reply *TestAsyn, err error) {
+			eT := time.Since(bT)      // 从开始到当前所消耗的时间
+			fmt.Println(reply, eT)
+		})
+		fmt.Println(in)
+	}
+}
+
+func (slf *OriginServerOne) testAsyncGRCall() {
+	for i := 0; i < 100; i++ {
+		in := i
+		bT := time.Now()
+		slf.GRAsyncCall("OriginServerTwo.RPC_TestAsyncCall", &in, func(reply *TestAsyn, err error) {
+			eT := time.Since(bT)
+			fmt.Println(reply, eT)
+		})
+		fmt.Println(in)
+	}
+}

example/serviceTest/OriginServerTwo.go

@@ -0,0 +1,27 @@
+package serviceTest
+
+import (
+	"fmt"
+	"github.com/duanhf2012/originnet/service"
+	"time"
+)
+
+type OriginServerTwo struct {
+	service.Service
+}
+
+func (slf *OriginServerTwo) RPC_TestCall(a *int,b *int) error {
+	fmt.Printf("OriginServerTwo\n")
+	*a = *b*2
+	//slf.AfterFunc(time.Second,slf.Test)
+	return nil
+}
+
+func (slf *OriginServerTwo) RPC_TestAsyncCall(a *int, reply *TestAsyn) error {
+	fmt.Printf("OriginServerTwo async start sleep %d\n", *a)
+	time.Sleep(time.Second)
+
+	reply.a = *a
+	reply.b = "fuck!"
+	return nil
+}