func TestRequestSubChannel(t *testing.T) {
ctx, cancel := NewContext(time.Second)
defer cancel()
tchan, err := tchannel.NewChannel("svc1", nil)
require.NoError(t, err, "server NewChannel failed")
require.NoError(t, tchan.ListenAndServe(":0"), "Listen failed")
defer tchan.Close()
clientCh, err := tchannel.NewChannel("client", nil)
require.NoError(t, err, "client NewChannel failed")
defer clientCh.Close()
clientCh.Peers().Add(tchan.PeerInfo().HostPort)
tests := []tchannel.Registrar{tchan, tchan.GetSubChannel("svc2"), tchan.GetSubChannel("svc3")}
for _, ch := range tests {
mockHandler := new(mocks.TChanSecondService)
server := NewServer(ch)
server.Register(gen.NewTChanSecondServiceServer(mockHandler))
client := NewClient(clientCh, ch.ServiceName(), nil)
secondClient := gen.NewTChanSecondServiceClient(client)
echoArg := ch.ServiceName()
echoRes := echoArg + "-echo"
mockHandler.On("Echo", ctxArg(), echoArg).Return(echoRes, nil)
res, err := secondClient.Echo(ctx, echoArg)
assert.NoError(t, err, "Echo failed")
assert.Equal(t, echoRes, res)
}
}
func getClients(dst string) (gen.TChanSimpleService, gen.TChanSecondService, error) {
tchan, err := tchannel.NewChannel("client", &tchannel.ChannelOptions{
Logger: tchannel.SimpleLogger,
})
if err != nil {
return nil, nil, err
}
tchan.Peers().Add(dst)
client := NewClient(tchan, "service", nil)
simpleClient := gen.NewTChanSimpleServiceClient(client)
secondClient := gen.NewTChanSecondServiceClient(client)
return simpleClient, secondClient, nil
}
func setupServer(h *mocks.TChanSimpleService, sh *mocks.TChanSecondService) (*tchannel.Channel, net.Listener, error) {
tchan, err := tchannel.NewChannel("service", nil)
if err != nil {
return nil, nil, err
}
listener, err := net.Listen("tcp", ":0")
if err != nil {
return nil, nil, err
}
server := NewServer(tchan)
server.Register(gen.NewTChanSimpleServiceServer(h))
server.Register(gen.NewTChanSecondServiceServer(sh))
tchan.Serve(listener)
return tchan, listener, nil
}
func setupServer() (net.Listener, error) {
tchan, err := tchannel.NewChannel("server", optsFor("server"))
if err != nil {
return nil, err
}
listener, err := net.Listen("tcp", ":0")
if err != nil {
return nil, err
}
server := thrift.NewServer(tchan)
server.Register(gen.NewTChanFirstServer(&firstHandler{}))
server.Register(gen.NewTChanSecondServer(&secondHandler{}))
// Serve will set the local peer info, and start accepting sockets in a separate goroutine.
tchan.Serve(listener)
return listener, nil
}
func runClient2(hyperbahnService string, addr net.Addr) error {
tchan, err := tchannel.NewChannel("client2", optsFor("client2"))
if err != nil {
return err
}
tchan.Peers().Add(addr.String())
tclient := thrift.NewClient(tchan, hyperbahnService, nil)
client := gen.NewTChanSecondClient(tclient)
go func() {
for {
ctx, cancel := thrift.NewContext(time.Second)
client.Test(ctx)
cancel()
time.Sleep(100 * time.Millisecond)
}
}()
return nil
}
func runClient1(hyperbahnService string, addr net.Addr) error {
tchan, err := tchannel.NewChannel("client1", optsFor("client1"))
if err != nil {
return err
}
tchan.Peers().Add(addr.String())
tclient := thrift.NewClient(tchan, hyperbahnService, nil)
client := gen.NewTChanFirstClient(tclient)
go func() {
for {
ctx, cancel := thrift.NewContext(time.Second)
res, err := client.Echo(ctx, "Hi")
log.Println("Echo(Hi) = ", res, ", err: ", err)
log.Println("AppError = ", client.AppError(ctx))
cancel()
time.Sleep(100 * time.Millisecond)
}
}()
return nil
}