func TestClientHostPort(t *testing.T) {
ctx, cancel := NewContext(time.Second)
defer cancel()
s1ch := testutils.NewServer(t, nil)
s2ch := testutils.NewServer(t, nil)
defer s1ch.Close()
defer s2ch.Close()
s1ch.Peers().Add(s2ch.PeerInfo().HostPort)
s2ch.Peers().Add(s1ch.PeerInfo().HostPort)
mock1, mock2 := new(mocks.TChanSecondService), new(mocks.TChanSecondService)
NewServer(s1ch).Register(gen.NewTChanSecondServiceServer(mock1))
NewServer(s2ch).Register(gen.NewTChanSecondServiceServer(mock2))
// When we call using a normal client, it can only call the other server (only peer).
c1 := gen.NewTChanSecondServiceClient(NewClient(s1ch, s2ch.PeerInfo().ServiceName, nil))
mock2.On("Echo", ctxArg(), "call1").Return("call1", nil)
res, err := c1.Echo(ctx, "call1")
assert.NoError(t, err, "call1 failed")
assert.Equal(t, "call1", res)
// When we call using a client that specifies host:port, it should call that server.
c2 := gen.NewTChanSecondServiceClient(NewClient(s1ch, s1ch.PeerInfo().ServiceName, &ClientOptions{
HostPort: s1ch.PeerInfo().HostPort,
}))
mock1.On("Echo", ctxArg(), "call2").Return("call2", nil)
res, err = c2.Echo(ctx, "call2")
assert.NoError(t, err, "call2 failed")
assert.Equal(t, "call2", res)
}
func BenchmarkBothSerial(b *testing.B) {
serverAddr, err := setupBenchServer()
require.NoError(b, err, "setupBenchServer failed")
opts := testutils.NewOpts().SetFramePool(tchannel.NewSyncFramePool())
clientCh := testutils.NewClient(b, opts)
for _, addr := range serverAddr {
clientCh.Peers().Add(addr)
}
thriftClient := thrift.NewClient(clientCh, "bench-server", nil)
client := gen.NewTChanSecondServiceClient(thriftClient)
ctx, cancel := thrift.NewContext(10 * time.Millisecond)
client.Echo(ctx, "make connection")
cancel()
b.ResetTimer()
for i := 0; i < b.N; i++ {
ctx, cancel := thrift.NewContext(10 * time.Millisecond)
defer cancel()
_, err := client.Echo(ctx, "hello world")
if err != nil {
b.Errorf("Echo failed: %v", err)
}
}
}
func TestContextBuilder(t *testing.T) {
ctx, cancel := tchannel.NewContextBuilder(time.Second).SetShardKey("shard").Build()
defer cancel()
var called bool
testutils.WithServer(t, nil, func(ch *tchannel.Channel, hostPort string) {
peerInfo := ch.PeerInfo()
testutils.RegisterFunc(ch, "SecondService::Echo", func(ctx context.Context, args *raw.Args) (*raw.Res, error) {
call := tchannel.CurrentCall(ctx)
assert.Equal(t, peerInfo.ServiceName, call.CallerName(), "unexpected caller name")
assert.Equal(t, "shard", call.ShardKey(), "unexpected shard key")
assert.Equal(t, tchannel.Thrift, args.Format)
called = true
return nil, errors.New("err")
})
client := NewClient(ch, ch.PeerInfo().ServiceName, &ClientOptions{
HostPort: peerInfo.HostPort,
})
secondClient := gen.NewTChanSecondServiceClient(client)
secondClient.Echo(ctx, "asd")
assert.True(t, called, "test not called")
})
}
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(t *testing.T, serverCh *tchannel.Channel) (gen.TChanSimpleService, gen.TChanSecondService) {
serverInfo := serverCh.PeerInfo()
ch := testutils.NewClient(t, nil)
ch.Peers().Add(serverInfo.HostPort)
client := NewClient(ch, serverInfo.ServiceName, nil)
simpleClient := gen.NewTChanSimpleServiceClient(client)
secondClient := gen.NewTChanSecondServiceClient(client)
return simpleClient, secondClient
}
func getClients(serverCh *tchannel.Channel) (gen.TChanSimpleService, gen.TChanSecondService, error) {
serverInfo := serverCh.PeerInfo()
ch, err := testutils.NewClientChannel(nil)
if err != nil {
return nil, nil, err
}
ch.Peers().Add(serverInfo.HostPort)
client := NewClient(ch, serverInfo.ServiceName, nil)
simpleClient := gen.NewTChanSimpleServiceClient(client)
secondClient := gen.NewTChanSecondServiceClient(client)
return simpleClient, secondClient, nil
}
func newInternalClient(hosts []string, opts *options) inProcClient {
ch, err := tchannel.NewChannel(opts.svcName, &tchannel.ChannelOptions{
Logger: tchannel.NewLevelLogger(tchannel.NewLogger(os.Stderr), tchannel.LogLevelWarn),
})
if err != nil {
panic("failed to create channel: " + err.Error())
}
for _, host := range hosts {
ch.Peers().Add(host)
}
thriftClient := thrift.NewClient(ch, opts.svcName, nil)
client := gen.NewTChanSecondServiceClient(thriftClient)
return &internalClient{
ch: ch,
sc: ch.GetSubChannel(opts.svcName),
tClient: client,
argBytes: getRequestBytes(opts.reqSize),
argStr: getRequestString(opts.reqSize),
opts: opts,
}
}
func main() {
flag.Parse()
ch, err := testutils.NewClient(nil)
if err != nil {
log.Fatalf("err")
}
for _, host := range flag.Args() {
ch.Peers().Add(host)
}
thriftClient := thrift.NewClient(ch, *serviceName, nil)
client := gen.NewTChanSecondServiceClient(thriftClient)
fmt.Println("bench-client started")
rdr := bufio.NewReader(os.Stdin)
for {
line, err := rdr.ReadString('\n')
if err != nil {
if err == io.EOF {
return
}
log.Fatalf("stdin read failed: %v", err)
}
line = strings.TrimSuffix(line, "\n")
switch line {
case "call":
makeCall(client)
case "quit":
return
default:
log.Fatalf("unrecognized command: %v", line)
}
}
}