Example #1
0
func (s *Skeleton) Init() {
	if s.GoLen <= 0 {
		s.GoLen = 0
	}
	if s.TimerDispatcherLen <= 0 {
		s.TimerDispatcherLen = 0
	}

	s.g = g.New(s.GoLen)
	s.dispatcher = timer.NewDispatcher(s.TimerDispatcherLen)
	s.server = s.ChanRPCServer

	if s.server == nil {
		s.server = chanrpc.NewServer(0)
	}
	s.commandServer = chanrpc.NewServer(0)
}
Example #2
0
//创建骨架
func NewSkeleton() *module.Skeleton {
	skeleton := &module.Skeleton{ //创建骨架
		GoLen:              conf.GoLen,
		TimerDispatcherLen: conf.TimerDispatcherLen,
		ChanRPCServer:      chanrpc.NewServer(conf.ChanRPCLen),
	}
	skeleton.Init() //初始化骨架
	return skeleton //返回骨架
}
Example #3
0
func NewSkeleton() *module.Skeleton {
	skeleton := &module.Skeleton{
		GoLen:              conf.GoLen,
		TimerDispatcherLen: conf.TimerDispatcherLen,
		ChanRPCServer:      chanrpc.NewServer(conf.ChanRPCLen),
	}
	skeleton.Init()
	return skeleton
}
Example #4
0
//初始化
func (s *Skeleton) Init() {
	//检查Go管道长度
	if s.GoLen <= 0 {
		s.GoLen = 0
	}
	//检查定时器分发器管道长度
	if s.TimerDispatcherLen <= 0 {
		s.TimerDispatcherLen = 0
	}

	s.g = g.New(s.GoLen)                                     //创建Go
	s.dispatcher = timer.NewDispatcher(s.TimerDispatcherLen) //创建分发器
	s.server = s.ChanRPCServer                               //外部传入的,内部引用

	if s.server == nil { //外部传入的为空
		s.server = chanrpc.NewServer(0) //内部创建一个
	}
	s.commandServer = chanrpc.NewServer(0) //创建命令RPC服务器
}
Example #5
0
func Example() {
	s := chanrpc.NewServer(10) //创建一个RPC服务器,调用管道的长度为10
	//调用管道:用于传输调用信息
	//一个rpc服务器可以对应多个rpc客户端,rpc客户端将调用信息传输到RPC服务器的管道(共用一个),rpc服务器再将响应消息返回到rpc客户端各自的管道内
	var wg sync.WaitGroup //声明等待组
	wg.Add(1)             //等待组+1

	// goroutine 1
	go func() {
		//注册函数:id->function
		s.Register("f0", func(args []interface{}) {

		})

		s.Register("f1", func(args []interface{}) interface{} {
			return 1
		})

		s.Register("fn", func(args []interface{}) []interface{} {
			return []interface{}{1, 2, 3}
		})

		s.Register("add", func(args []interface{}) interface{} {
			n1 := args[0].(int)
			n2 := args[1].(int)
			return n1 + n2
		})
		//注册完成,释放等待组
		wg.Done()

		//死循环,处理rpc服务器调用
		for {
			err := s.Exec(<-s.ChanCall) //从管道里读取一个调用信息并执行
			if err != nil {
				fmt.Println(err)
			}
		}
	}()

	wg.Wait() //等待等待组,阻塞在这里,等待注册函数完成
	wg.Add(1) //注册函数完成,等待组再+1

	// goroutine 2
	go func() {
		c := s.Open(10) //打开一个rpc客户端

		// sync 同步调用
		//同步调用0,无返回值(0个返回值)
		err := c.Call0("f0")
		if err != nil {
			fmt.Println(err)
		}
		//同步调用1,1个返回值
		r1, err := c.Call1("f1")
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(r1)
		}
		//同步调用N,N个返回值
		rn, err := c.CallN("fn")
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(rn[0], rn[1], rn[2])
		}
		//同步调用1,1个返回值
		ra, err := c.Call1("add", 1, 2)
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(ra)
		}

		// asyn 异步调用
		c.AsynCall("f0", func(err error) {
			if err != nil {
				fmt.Println(err)
			}
		})

		c.AsynCall("f1", func(ret interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret)
			}
		})

		c.AsynCall("fn", func(ret []interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret[0], ret[1], ret[2])
			}
		})

		c.AsynCall("add", 1, 2, func(ret interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret)
			}
		})

		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)

		// go Go调用
		s.Go("f0")

		wg.Done() //goroutine2完成
	}()

	wg.Wait() //等待goroutine2完成

	// Output:
	// 1
	// 1 2 3
	// 3
	// 1
	// 1 2 3
	// 3
}
Example #6
0
func Example() {
	s := chanrpc.NewServer(10)

	var wg sync.WaitGroup
	wg.Add(1)

	// goroutine 1
	go func() {
		s.Register("f0", func(args []interface{}) {

		})

		s.Register("f1", func(args []interface{}) interface{} {
			return 1
		})

		s.Register("fn", func(args []interface{}) []interface{} {
			return []interface{}{1, 2, 3}
		})

		s.Register("add", func(args []interface{}) interface{} {
			n1 := args[0].(int)
			n2 := args[1].(int)
			return n1 + n2
		})

		wg.Done()

		for {
			s.Exec(<-s.ChanCall)
		}
	}()

	wg.Wait()
	wg.Add(1)

	// goroutine 2
	go func() {
		c := s.Open(10)

		// sync
		err := c.Call0("f0")
		if err != nil {
			fmt.Println(err)
		}

		r1, err := c.Call1("f1")
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(r1)
		}

		rn, err := c.CallN("fn")
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(rn[0], rn[1], rn[2])
		}

		ra, err := c.Call1("add", 1, 2)
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(ra)
		}

		// asyn
		c.AsynCall("f0", func(err error) {
			if err != nil {
				fmt.Println(err)
			}
		})

		c.AsynCall("f1", func(ret interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret)
			}
		})

		c.AsynCall("fn", func(ret []interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret[0], ret[1], ret[2])
			}
		})

		c.AsynCall("add", 1, 2, func(ret interface{}, err error) {
			if err != nil {
				fmt.Println(err)
			} else {
				fmt.Println(ret)
			}
		})

		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)
		c.Cb(<-c.ChanAsynRet)

		// go
		s.Go("f0")

		wg.Done()
	}()

	wg.Wait()

	// Output:
	// 1
	// 1 2 3
	// 3
	// 1
	// 1 2 3
	// 3
}
Example #7
0
package login

import (
	"github.com/name5566/leaf/chanrpc"
	"server/conf"
)

var ChanRPC = chanrpc.NewServer(conf.ChanRPCLen)