Ma/origin
1
0
Fork 0
mirror of https://github.com/duanhf2012/origin.git synced 2026-02-04 06:54:45 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

删除无用的示例

Browse Source
This commit is contained in:
duanhf2012
2020-05-07 16:41:48 +08:00
parent 1e36232f7c
commit 044fbf4be2
7 changed files with 0 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
example/GateService/GateService.go
View File

@@ -1,125 +0,0 @@
package GateService
import (
"encoding/json"
"fmt"
"github.com/duanhf2012/origin/network/processor"
"github.com/duanhf2012/origin/node"
"github.com/duanhf2012/origin/service"
"github.com/duanhf2012/origin/sysmodule"
"github.com/duanhf2012/origin/sysservice"
"net/http"
"time"
)
type GateService struct {
service.Service
processor *processor.PBProcessor
processor2 *processor.PBProcessor
httpRouter sysservice.IHttpRouter
redisModule *sysmodule.RedisModule
}
func (slf *GateService) OnInit() error{
tcpervice := node.GetService("TcpService").(*sysservice.TcpService)
slf.processor = &processor.PBProcessor{}
slf.processor.RegisterDisConnected(slf.OnDisconnected)
slf.processor.RegisterConnected(slf.OnConnected)
tcpervice.SetProcessor(slf.processor,slf.GetEventHandler())
wsService := node.GetService("WSService").(*sysservice.WSService)
slf.processor2 = &processor.PBProcessor{}
slf.processor2.RegisterDisConnected(slf.OnWSDisconnected)
slf.processor2.RegisterConnected(slf.OnWSConnected)
wsService.SetProcessor(slf.processor2,slf.GetEventHandler())
httpervice := node.GetService("HttpService").(*sysservice.HttpService)
slf.httpRouter = sysservice.NewHttpHttpRouter()
httpervice.SetHttpRouter(slf.httpRouter,slf.GetEventHandler())
slf.httpRouter.GET("/get/query", slf.HttpTest)
slf.httpRouter.POST("/post/query", slf.HttpTestPost)
slf.httpRouter.SetServeFile(sysservice.METHOD_GET,"/img/head/","d:/img")
//pCronExpr,_ := timer.NewCronExpr("0 * * * * *")
//slf.CronFunc(pCronExpr,slf.Test)
redisCfg := sysmodule.ConfigRedis{
IP :"192.168.0.5",
Port :"6379",
Password :"",
DbIndex :0,
MaxIdle :50, //最大的空闲连接数，表示即使没有redis连接时依然可以保持N个空闲的连接，而不被清除，随时处于待命状态。
MaxActive :50, //最大的激活连接数，表示同时最多有N个连接
IdleTimeout :30, //最大的空闲连接等待时间，超过此时间后，空闲连接将被关闭
SyncRouterNum :10, //异步执行Router数量
}
slf.redisModule = &sysmodule.RedisModule{}
slf.redisModule.Init(&redisCfg)
slf.redisModule.OnInit()
slf.AddModule(slf.redisModule)
slf.AfterFunc(time.Second, slf.TestRedis)
return nil
}
func (slf *GateService) Test(){
fmt.Print("xxxxx\n")
}
func (slf *GateService) TestRedis() {
//slf.redisModule.GetHashValueByHashKeyList("BITGET_2160_LastSetLevelInfo", "SBTC_USD_1", "BTC_SUSDT_1", "SBTC_USD_3")
//slf.redisModule.GetHashValueByKey("BITGET_2160_LastSetLevelInfo", "SBTC_USD_1")
slf.redisModule.ScanMatchKeys(192, "ZC*", 100)
}
func (slf *GateService) HttpTest(session *sysservice.HttpSession) {
session.SetHeader("a","b")
session.Write([]byte("this is a test"))
v,_:=session.Query("a")
v2,_:=session.Query("b")
fmt.Print(string(session.GetBody()),"\n",v,"\n",v2)
}
func (slf *GateService) HttpTestPost(session *sysservice.HttpSession) {
session.SetHeader("a","b")
v,_:=session.Query("a")
v2,_:=session.Query("b")
byteBody := session.GetBody()
fmt.Print(string(session.GetBody()),"\n",v,"\n",v2)
testa := struct {
AA int `json:"aa"`
BB string `json:"bb"`
}{}
json.Unmarshal(byteBody, &testa)
fmt.Println(testa)
testa.AA = 100
testa.BB = "this is a test"
session.WriteJsonDone(http.StatusOK,"asdasda")
}
func (slf *GateService) OnConnected(clientid uint64){
fmt.Printf("client id %d connected",clientid)
}
func (slf *GateService) OnDisconnected(clientid uint64){
fmt.Printf("client id %d disconnected",clientid)
}
func (slf *GateService) OnWSConnected(clientid uint64){
fmt.Printf("client id %d connected",clientid)
}
func (slf *GateService) OnWSDisconnected(clientid uint64){
fmt.Printf("client id %d disconnected",clientid)
}

11
example/config/cluster/subnet/cluster.json
View File

@@ -1,11 +0,0 @@
{
"NodeList":[
{
"NodeId": 1,
"ListenAddr":"127.0.0.1:8001",
"NodeName": "Node_Test1",
"remark":"//以_打头的，表示只在本机进程，不对整个子网开发",
"ServiceList": ["TestService1","TestService2","TestServiceCall","GateService","TcpService","HttpService","WSService"]
}
]
}

69
example/config/cluster/subnet/service.json
View File

@@ -1,69 +0,0 @@
{
"Service":{
"HttpService":{
"ListenAddr":"0.0.0.0:9402",
"ReadTimeout":10000,
"WriteTimeout":10000,
"ProcessTimeout":10000,
"CAFile":[
{
"Certfile":"",
"Keyfile":""
}
]
},
"TcpService":{
"ListenAddr":"0.0.0.0:9030",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"LittleEndian":false,
"MinMsgLen":4,
"MaxMsgLen":65535
},
"WSService":{
"ListenAddr":"0.0.0.0:9031",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"MaxMsgLen":65535
}
},
"NodeService":[
{
"NodeId":1,
"TcpService":{
"ListenAddr":"0.0.0.0:9830",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"LittleEndian":false,
"MinMsgLen":4,
"MaxMsgLen":65535
},
"WSService":{
"ListenAddr":"0.0.0.0:9031",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"MaxMsgLen":65535
}
},
{
"NodeId":2,
"TcpService":{
"ListenAddr":"0.0.0.0:9030",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"LittleEndian":false,
"MinMsgLen":4,
"MaxMsgLen":65535
},
"WSService":{
"ListenAddr":"0.0.0.0:9031",
"MaxConnNum":3000,
"PendingWriteNum":10000,
"MaxMsgLen":65535
}
}
]
}

1
example/main.exe.pid
View File

@@ -1 +0,0 @@
49288

315
example/main.go
View File

@@ -1,315 +0,0 @@
package main
import (
"fmt"
"github.com/duanhf2012/origin/event"
"github.com/duanhf2012/origin/example/GateService"
//"github.com/duanhf2012/origin/example/msgpb"
"github.com/duanhf2012/origin/log"
"github.com/duanhf2012/origin/node"
"github.com/duanhf2012/origin/service"
"github.com/duanhf2012/origin/sysmodule"
"github.com/duanhf2012/origin/sysservice"
//"github.com/golang/protobuf/proto"
"time"
)
type TestService1 struct {
service.Service
}
type TestService2 struct {
service.Service
}
type TestServiceCall struct {
service.Service
dbModule sysmodule.DBModule
param *Param
}
func init(){
node.Setup(&TestService1{},&TestService2{},&TestServiceCall{param:&Param{}})
}
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())
slf.AfterFunc(time.Second*5,func(){
slf.NotifyEvent(&event.Event{
Type: Event1,
Data: "xxxxxxxxxxx",
})
})
return nil
}
func (slf *Module2) OnInit() error {
fmt.Printf("I'm Module2:%d\n",slf.GetModuleId())
slf.GetEventProcessor().RegEventReciverFunc(Event1,slf.GetEventHandler(),slf.Module2Test)
moduleid3,_ = slf.AddModule(&Module3{})
slf.AfterFunc(time.Second*3, func() {
slf.ReleaseModule(moduleid3)
})
return nil
}
func (slf *Module2) Module2Test(ev *event.Event){
fmt.Print("\n>>>>>>>>Module2:",ev)
}
func (slf *Module3) OnInit() error {
slf.GetParent().GetParent().GetEventProcessor().RegEventReciverFunc(Event1,slf.GetEventHandler(),slf.Module3Test)
fmt.Printf("I'm Module3:%d\n",slf.GetModuleId())
moduleid4,_ = slf.AddModule(&Module4{})
return nil
}
func (slf *Module3) Module3Test(ev *event.Event){
fmt.Print("\n>>>>>>>>Module3:",ev)
}
const (
Event1 event.EventType = 10002
)
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)
slf.GetParent().GetParent().GetParent().GetEventProcessor().RegEventReciverFunc(Event1,slf.GetEventHandler(),slf.Module4Test)
return nil
}
func (slf *Module4) Module4Test(ev *event.Event){
fmt.Print("\n>>>>>>>>>>>Module4:",ev)
}
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) TestProtobufRpc(){
/* input := msgpb.InputRpc{}
input.Tag = proto.Int32(33333)
input.Msg = proto.String("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
slf.AsyncCall("TestService1.RPC_TestPB",&input, func(b *msgpb.OutputRpc,err error) {
fmt.Print(*b,err)
})
*/
//(a *Param,b *Param)
var input Param
input.Index = 1111
input.Pa = []string{"sadfsdf","cccccc"}
input.A = 33333
input.B ="asfasfasfd"
slf.AsyncCall("TestService1.RPC_Test",&input, func(b *Param,err error) {
fmt.Print(*b,err)
})
}
func (slf *TestServiceCall) OnInit() error {
slf.OpenProfiler()
slf.AfterFunc(time.Second*5,slf.TestProtobufRpc)
//slf.AfterFunc(time.Second*1,slf.Run)
//slf.AfterFunc(time.Second*1,slf.Test)
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
}
var index int
func (slf *TestServiceCall) Test(){
//any := slf.GetProfiler().Push("xxxxxx")
//defer any.Pop()
for{
time.Sleep(time.Second*1)
}
index += 1
//var param *Param
param:=&Param{}
param.A = 2342342341
param.B = "xxxxxxxxxxxxxxxxxxxxxxx"
param.Pa = []string{"ccccc","asfsdfsdaf","bbadfsdf","ewrwefasdf","safsadfka;fksd"}
param.Index = index
/*
slf.AsyncCall("TestService1.RPC_Test1",&param, func(reply *Param, err error) {
fmt.Print(reply,"\n")
})
*/
slf.Go("TestService1.RPC_Test",&slf.param)
//slf.AfterFunc(time.Second*1,slf.Test)
}
func (slf *TestServiceCall) OnRelease(){
fmt.Print("OnRelease")
}
func (slf *TestServiceCall) Run(){
//var ret int
var input int = 10000
bT := time.Now() // 开始时间
//err := slf.Call("TestServiceCall.RPC_Test",&ret,&input)
for i:=input;i>=0;i--{
var param Param
param.A = 2342342341
param.B = "xxxxxxxxxxxxxxxxxxxxxxx"
//param.Pa = []string{"ccccc","asfsdfsdaf","bbadfsdf","ewrwefasdf","safsadfka;fksd"}
param.Index = i
if param.Index == 0 {
fmt.Print(".......................\n")
}
err := slf.AsyncCall("TestService1.RPC_Test",&param, func(reply *Param, err error) {
log.Debug(" index %d ,err %+v",reply.Index,err)
if reply.Index == 0 {
eT := time.Since(bT) // 从开始到当前所消耗的时间
fmt.Print(err,eT.Milliseconds())
fmt.Print("xxxx..................",eT,err,"\n")
}
})
if err != nil {
fmt.Printf("x333333333333:%+v",err)
}
}
fmt.Print("finsh....")
}
func (slf *TestService1) RPC_Test(a *Param,b *Param) error {
//*a = *b
//a = nil
*b = *a
return nil
}
/*func (slf *TestService1) RPC_TestPB(a *msgpb.InputRpc,b *msgpb.OutputRpc) error {
b.Msg = proto.String(a.GetMsg())
b.Tag = proto.Int32(a.GetTag())
return nil
}*/
func (slf *TestService1) OnInit() error {
slf.OpenProfiler()
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 {
slf.OpenProfiler()
return nil
}
func main(){
//rpc.SetProcessor(&rpc.PBProcessor{})
//data := P{3, 4, 5, "CloudGeek"}
//buf := encode(data)
tcpService := &sysservice.TcpService{}
gateService := &GateService.GateService{}
httpService := &sysservice.HttpService{}
wsService := &sysservice.WSService{}
node.Setup(tcpService,gateService,httpService,wsService)
node.OpenProfilerReport(time.Second*10)
node.Start()
}

64
example/serviceTest/OriginServeOne.go
View File

@@ -1,64 +0,0 @@
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)
}
}

27
example/serviceTest/OriginServerTwo.go
View File

@@ -1,27 +0,0 @@
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
}