Beispiel #1
0
func BenchmarkTCPReconnectRouter(b *testing.B) {
	r, err := NewRouter(nil, ServiceProcessPayload)
	if err != nil {
		b.FailNow()
	}
	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	r.Run()
	<-time.Tick(1 * time.Millisecond)

	network := "tcp"
	address := "localhost:10000"
	if err := r.ListenAndServe("client", network, address, hf, ServiceProcessConn); err != nil {
		b.Log(err)
		b.FailNow()
	}

	<-time.Tick(1 * time.Millisecond)

	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			name := "scheduler"

			req := pbt.NewResourceReq()
			req.Id = proto.Uint64(1)

			r, err := NewRouter(nil, ServiceProcessPayload)
			if err != nil {
				b.FailNow()
			}

			hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

			r.Run()
			if err := r.Dial(name, network, address, hf); err != nil {
				b.Log(err)
				b.FailNow()
			}

			if _, err := r.CallWait(name, "rpc", req, 5); err != nil {
				b.Log(err)
				b.FailNow()
			}
			r.Stop()
		}
	})

	r.Stop()
}
Beispiel #2
0
func BenchmarkPipeShareRouter(b *testing.B) {
	r, err := NewRouter(nil, ServiceProcessPayload)
	if err != nil {
		b.FailNow()
	}

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	r.Run()
	<-time.Tick(1 * time.Millisecond)

	name := "scheduler"
	n := ConcurrentNum
	m := GoRoutineRequests
	for i := 0; i < n; i++ {
		c, s := net.Pipe()
		ep_c := r.newRouterEndPoint(name+string(i), c, hf)
		ep_s := r.newRouterEndPoint("client"+string(n), s, hf)
		r.AddEndPoint(ep_c)
		r.AddEndPoint(ep_s)
	}

	<-time.Tick(1 * time.Millisecond)
	testShareRouter(b, r, n, m)
}
Beispiel #3
0
func BenchmarkTCPShareRouter(b *testing.B) {
	r, err := NewRouter(nil, ServiceProcessPayload)
	if err != nil {
		b.FailNow()
	}

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	r.Run()
	<-time.Tick(1 * time.Millisecond)

	network := "tcp"
	address := "localhost:10001"
	if err := r.ListenAndServe("client", network, address, hf, ServiceProcessConn); err != nil {
		b.Log(err)
		b.FailNow()
	}

	name := "scheduler"
	n := ConcurrentNum
	m := GoRoutineRequests
	for i := 0; i < n; i++ {
		if err := r.Dial(name+string(i), network, address, hf); err != nil {
			b.Log(err)
			b.FailNow()
		}
	}

	<-time.Tick(1 * time.Millisecond)
	testShareRouter(b, r, n, m)
}
Beispiel #4
0
func BenchmarkPipeReadWriter(b *testing.B) {
	s, c := net.Pipe()

	ch_c_w := make(chanPayload, 1024)
	ch_s_w := make(chanPayload, 1024)
	ch_d := make(chanPayload, 1024)

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	ep_c := NewEndPoint("c", c, ch_c_w, ch_d, hf, nil, nil)
	ep_s := NewEndPoint("s", s, ch_s_w, ch_s_w, hf, nil, nil)

	ep_c.Run()
	ep_s.Run()

	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		req := pbt.NewResourceReq()
		req.Id = proto.Uint64(1)
		for pb.Next() {
			ch_c_w <- req
			<-ch_d
		}
	})

}
Beispiel #5
0
func TestMockMsg(t *testing.T) {
	pr, pw := io.Pipe()
	ch := make(chanPayload, 128)

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	w := NewWriter(pw, ch, hf.NewBuffer(), nil)
	r := NewReader(pr, ch, hf.NewBuffer(), nil)

	w.Run()
	r.Run()

	req := pbt.NewResourceReq()
	req.Id = proto.Uint64(10000)
	w.Write(req)
	<-time.After(1 * time.Second)

	select {
	case resp := <-ch:
		if resp.(*pbt.ResourceReq).GetId() != 10000 {
			t.Log(req, resp)
			t.Fail()
		}
	case <-time.After(1 * time.Second):
		t.Log("timeout")
		t.FailNow()
	}

	r.Stop()
	w.Stop()
}
Beispiel #6
0
func NewServer(opt ...ServerOption) *Server {
	var err error
	s := new(Server)

	if s.r, err = rpc.NewRouter(nil, nil); err != nil {
		return nil
	}

	s.ln = "grpc-api-listener"
	s.mf = rpc.NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	return s
}
Beispiel #7
0
func Dial(target string, opts ...DialOption) (*ClientConn, error) {
	var err error
	cc := new(ClientConn)

	if cc.r, err = rpc.NewRouter(nil, nil); err != nil {
		return nil, err
	}

	cc.r.Run()

	cc.cn = "grpc-api-connector"
	cc.mf = rpc.NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	if err = cc.r.Dial(cc.cn, "tcp", target, cc.mf); err != nil {
		cc.r.Stop()
		return nil, err
	}

	return cc, nil
}
Beispiel #8
0
func TestRouterMultiple(t *testing.T) {
	r, err := NewRouter(nil, ServiceProcessPayload)
	if err != nil {
		t.FailNow()
	}

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	name := "scheduler"
	network := "tcp"
	address := "localhost:10000"

	r.Run()

	if err := r.ListenAndServe("client", network, address, hf, ServiceProcessConn); err != nil {
		t.Log(err)
		t.FailNow()
	}
	if err := r.Dial(name, network, address, hf); err != nil {
		t.Log(err)
		t.FailNow()
	}

	time.Sleep(1)

	for i := 1; i < 10000; i++ {
		req := pbt.NewResourceReq()
		req.Id = proto.Uint64(uint64(i))
		if _, err := r.CallWait(name, "rpc", req, 5); err != nil {
			t.Log(i, ":", err)
			t.FailNow()
		}
	}

	r.DelEndPoint("scheduler")

	r.DelListener("client")

	r.Stop()
}
Beispiel #9
0
func BenchmarkTCPReadWriter(b *testing.B) {
	network := "tcp"
	address := "localhost:10008"

	l, err := net.Listen(network, address)
	if err != nil {
		b.FailNow()
	}
	c, err := net.Dial(network, address)
	if err != nil {
		b.FailNow()
	}
	s, err := l.Accept()
	if err != nil {
		b.FailNow()
	}

	ch_c_w := make(chanPayload, 1024)
	ch_s_w := make(chanPayload, 1024)
	ch_d := make(chanPayload, 1024)

	hf := NewMsgHeaderFactory(pbt.NewMsgProtobufFactory())

	ep_c := NewEndPoint("c", c, ch_c_w, ch_d, hf, nil, nil)
	ep_s := NewEndPoint("s", s, ch_s_w, ch_s_w, hf, nil, nil)

	ep_c.Run()
	ep_s.Run()

	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		req := pbt.NewResourceReq()
		req.Id = proto.Uint64(1)
		for pb.Next() {
			ch_c_w <- req
			<-ch_d
		}
	})

}