func BenchmarkCallsConcurrent(b *testing.B) {
const numWorkers = 5
serverCh, svcName, svcHostPort := setupServer(b)
defer serverCh.Close()
var wg sync.WaitGroup
inCh := make(chan struct{})
for i := 0; i < numWorkers; i++ {
go func() {
clientCh, err := testutils.NewClient(nil)
require.NoError(b, err)
defer clientCh.Close()
for range inCh {
ctx, cancel := NewContext(time.Second)
_, _, _, err = raw.Call(ctx, clientCh, svcHostPort, svcName, "echo", []byte("data111"), []byte("data222"))
assert.NoError(b, err)
cancel()
wg.Done()
}
}()
}
for i := 0; i < b.N; i++ {
wg.Add(1)
inCh <- struct{}{}
}
wg.Wait()
close(inCh)
}
func TestCloseNewClient(t *testing.T) {
ch, err := testutils.NewClient(nil)
require.NoError(t, err, "NewServer failed")
// If there are no connections, then the channel should close immediately.
ch.Close()
assert.Equal(t, ChannelClosed, ch.State())
assert.True(t, ch.Closed(), "Channel should be closed")
}
func TestPing(t *testing.T) {
require.Nil(t, testutils.WithServer(nil, func(ch *Channel, hostPort string) {
ctx, cancel := NewContext(time.Second * 5)
defer cancel()
clientCh, err := testutils.NewClient(nil)
require.NoError(t, err)
require.NoError(t, clientCh.Ping(ctx, hostPort))
}))
}
// TestCloseSendError tests that system errors are not attempted to be sent when
// a connection is closed, and ensures there's no race conditions such as the error
// frame being added to the channel just as it is closed.
// TODO(prashant): This test is waiting for timeout, but socket close shouldn't wait for timeout.
func TestCloseSendError(t *testing.T) {
ctx, cancel := NewContext(time.Second)
defer cancel()
serverCh, err := testutils.NewServer(nil)
require.NoError(t, err, "NewServer failed")
closed := uint32(0)
counter := uint32(0)
registerFunc(t, serverCh, "echo", func(ctx context.Context, args *raw.Args) (*raw.Res, error) {
atomic.AddUint32(&counter, 1)
return &raw.Res{Arg2: args.Arg2, Arg3: args.Arg3}, nil
})
clientCh, err := testutils.NewClient(nil)
require.NoError(t, err, "NewClient failed")
// Make a call to create a connection that will be shared.
peerInfo := serverCh.PeerInfo()
_, _, _, err = raw.Call(ctx, clientCh, peerInfo.HostPort, peerInfo.ServiceName, "echo", nil, nil)
require.NoError(t, err, "Call should succeed")
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
time.Sleep(time.Duration(rand.Intn(1000)) * time.Microsecond)
_, _, _, err := raw.Call(ctx, clientCh, peerInfo.HostPort, peerInfo.ServiceName, "echo", nil, nil)
if err != nil && atomic.LoadUint32(&closed) == 0 {
t.Errorf("Call failed: %v", err)
}
wg.Done()
}()
}
// Wait for the server to have processed some number of these calls.
for {
if atomic.LoadUint32(&counter) >= 10 {
break
}
runtime.Gosched()
}
atomic.AddUint32(&closed, 1)
serverCh.Close()
// Wait for all the goroutines to end
wg.Wait()
clientCh.Close()
VerifyNoBlockedGoroutines(t)
}
func BenchmarkCallsSerial(b *testing.B) {
serverCh, svcName, svcHostPort := setupServer(b)
defer serverCh.Close()
clientCh, err := testutils.NewClient(nil)
require.NoError(b, err)
b.ResetTimer()
for i := 0; i < b.N; i++ {
ctx, cancel := NewContext(time.Second)
_, _, _, err = raw.Call(ctx, clientCh, svcHostPort, svcName, "echo", []byte("data111"), []byte("data222"))
assert.NoError(b, err)
cancel()
}
}
func TestStatsCalls(t *testing.T) {
serverStats := newRecordingStatsReporter()
serverOpts := &testutils.ChannelOpts{
StatsReporter: serverStats,
}
require.NoError(t, testutils.WithServer(serverOpts, func(serverCh *Channel, hostPort string) {
handler := raw.Wrap(newTestHandler(t))
serverCh.Register(handler, "echo")
serverCh.Register(handler, "app-error")
clientStats := newRecordingStatsReporter()
ch, err := testutils.NewClient(&testutils.ChannelOpts{StatsReporter: clientStats})
require.NoError(t, err)
ctx, cancel := NewContext(time.Second * 5)
defer cancel()
_, _, _, err = raw.Call(ctx, ch, hostPort, testServiceName, "echo", []byte("Headers"), []byte("Body"))
require.NoError(t, err)
_, _, resp, err := raw.Call(ctx, ch, hostPort, testServiceName, "app-error", nil, nil)
require.NoError(t, err)
require.True(t, resp.ApplicationError(), "expected application error")
outboundTags := tagsForOutboundCall(serverCh, ch, "echo")
clientStats.Expected.IncCounter("outbound.calls.send", outboundTags, 1)
clientStats.Expected.IncCounter("outbound.calls.success", outboundTags, 1)
outboundTags["target-endpoint"] = "app-error"
clientStats.Expected.IncCounter("outbound.calls.send", outboundTags, 1)
clientStats.Expected.IncCounter("outbound.calls.app-errors", outboundTags, 1)
inboundTags := tagsForInboundCall(serverCh, ch, "echo")
serverStats.Expected.IncCounter("inbound.calls.recvd", inboundTags, 1)
serverStats.Expected.IncCounter("inbound.calls.success", inboundTags, 1)
inboundTags["endpoint"] = "app-error"
serverStats.Expected.IncCounter("inbound.calls.recvd", inboundTags, 1)
serverStats.Expected.IncCounter("inbound.calls.app-errors", inboundTags, 1)
clientStats.ValidateCounters(t)
serverStats.ValidateCounters(t)
}))
}
func TestLargeRequest(t *testing.T) {
if !*flagStressTest {
t.Skip("skipping as stress tests are not enabled")
}
const (
KB = 1024
MB = 1024 * KB
GB = 1024 * MB
maxRequestSize = 1 * GB
)
require.NoError(t, testutils.WithServer(nil, func(serverCh *Channel, hostPort string) {
serverCh.Register(raw.Wrap(newTestHandler(t)), "echo")
for reqSize := 2; reqSize <= maxRequestSize; reqSize *= 2 {
log.Printf("reqSize = %v", reqSize)
arg3 := makeData(reqSize)
arg2 := arg3[len(arg3)/2:]
clientCh, err := testutils.NewClient(nil)
require.NoError(t, err, "new client failed")
ctx, cancel := NewContext(time.Second * 30)
rArg2, rArg3, _, err := raw.Call(ctx, clientCh, hostPort, serverCh.PeerInfo().ServiceName, "echo", arg2, arg3)
require.NoError(t, err, "Call failed")
if !bytes.Equal(arg2, rArg2) {
t.Errorf("echo arg2 mismatch")
}
if !bytes.Equal(arg3, rArg3) {
t.Errorf("echo arg3 mismatch")
}
cancel()
}
}))
}
func TestCloseSemantics(t *testing.T) {
defer testutils.SetTimeout(t, 2*time.Second)()
ctx, cancel := NewContext(time.Second)
defer cancel()
makeServer := func(name string) (*Channel, chan struct{}) {
ch, err := testutils.NewServer(&testutils.ChannelOpts{ServiceName: name})
require.NoError(t, err)
c := make(chan struct{})
registerFunc(t, ch, "stream", func(ctx context.Context, args *raw.Args) (*raw.Res, error) {
<-c
return &raw.Res{}, nil
})
registerFunc(t, ch, "call", func(ctx context.Context, args *raw.Args) (*raw.Res, error) {
return &raw.Res{}, nil
})
return ch, c
}
withNewClient := func(f func(ch *Channel)) {
ch, err := testutils.NewClient(&testutils.ChannelOpts{ServiceName: "client"})
require.NoError(t, err)
f(ch)
ch.Close()
}
call := func(from *Channel, to *Channel) error {
toPeer := to.PeerInfo()
_, _, _, err := raw.Call(ctx, from, toPeer.HostPort, toPeer.ServiceName, "call", nil, nil)
return err
}
callStream := func(from *Channel, to *Channel) <-chan struct{} {
c := make(chan struct{})
toPeer := to.PeerInfo()
call, err := from.BeginCall(ctx, toPeer.HostPort, toPeer.ServiceName, "stream", nil)
require.NoError(t, err)
require.NoError(t, NewArgWriter(call.Arg2Writer()).Write(nil), "write arg2")
require.NoError(t, NewArgWriter(call.Arg3Writer()).Write(nil), "write arg3")
go func() {
var d []byte
require.NoError(t, NewArgReader(call.Response().Arg2Reader()).Read(&d), "read arg2 from %v to %v", from.PeerInfo(), to.PeerInfo())
require.NoError(t, NewArgReader(call.Response().Arg3Reader()).Read(&d), "read arg3")
c <- struct{}{}
}()
return c
}
s1, s1C := makeServer("s1")
s2, s2C := makeServer("s2")
// Make a call from s1 -> s2, and s2 -> s1
call1 := callStream(s1, s2)
call2 := callStream(s2, s1)
// s1 and s2 are both open, so calls to it should be successful.
withNewClient(func(ch *Channel) {
require.NoError(t, call(ch, s1))
require.NoError(t, call(ch, s2))
})
require.NoError(t, call(s1, s2))
require.NoError(t, call(s2, s1))
// Close s1, should no longer be able to call it.
s1.Close()
assert.Equal(t, ChannelStartClose, s1.State())
withNewClient(func(ch *Channel) {
assert.Error(t, call(ch, s1), "closed channel should not accept incoming calls")
require.NoError(t, call(ch, s2),
"closed channel with pending incoming calls should allow outgoing calls")
})
// Even an existing connection (e.g. from s2) should fail.
assert.Equal(t, ErrChannelClosed, call(s2, s1), "closed channel should not accept incoming calls")
require.NoError(t, call(s1, s2),
"closed channel with pending incoming calls should allow outgoing calls")
// Once the incoming connection is drained, outgoing calls should fail.
s1C <- struct{}{}
<-call2
assert.Equal(t, ChannelInboundClosed, s1.State())
require.Error(t, call(s1, s2),
"closed channel with no pending incoming calls should not allow outgoing calls")
// Now the channel should be completely closed as there are no pending connections.
s2C <- struct{}{}
<-call1
assert.Equal(t, ChannelClosed, s1.State())
// Close s2 so we don't leave any goroutines running.
s2.Close()
VerifyNoBlockedGoroutines(t)
}
func TestStatsCalls(t *testing.T) {
defer testutils.SetTimeout(t, time.Second)()
initialTime := time.Date(2015, 2, 1, 10, 10, 0, 0, time.UTC)
nowFn := testutils.NowStub(GetTimeNow(), initialTime)
defer testutils.ResetNowStub(GetTimeNow())
// time.Now will be called in this order for each call:
// sender records time they started sending
// receiver records time the request is sent to application
// receiver calculates application handler latency
// sender records call latency
// so expected inbound latency = incrementor, outbound = 3 * incrementor
clientStats := newRecordingStatsReporter()
serverStats := newRecordingStatsReporter()
serverOpts := &testutils.ChannelOpts{
StatsReporter: serverStats,
}
require.NoError(t, testutils.WithServer(serverOpts, func(serverCh *Channel, hostPort string) {
handler := raw.Wrap(newTestHandler(t))
serverCh.Register(handler, "echo")
serverCh.Register(handler, "app-error")
ch, err := testutils.NewClient(&testutils.ChannelOpts{StatsReporter: clientStats})
require.NoError(t, err)
ctx, cancel := NewContext(time.Second * 5)
defer cancel()
// Set now incrementor to 50ms, so expected Inbound latency is 50ms, outbound is 150ms.
nowFn(50 * time.Millisecond)
_, _, _, err = raw.Call(ctx, ch, hostPort, testServiceName, "echo", []byte("Headers"), []byte("Body"))
require.NoError(t, err)
outboundTags := tagsForOutboundCall(serverCh, ch, "echo")
clientStats.Expected.IncCounter("outbound.calls.send", outboundTags, 1)
clientStats.Expected.IncCounter("outbound.calls.success", outboundTags, 1)
clientStats.Expected.RecordTimer("outbound.calls.latency", outboundTags, 150*time.Millisecond)
inboundTags := tagsForInboundCall(serverCh, ch, "echo")
serverStats.Expected.IncCounter("inbound.calls.recvd", inboundTags, 1)
serverStats.Expected.IncCounter("inbound.calls.success", inboundTags, 1)
serverStats.Expected.RecordTimer("inbound.calls.latency", inboundTags, 50*time.Millisecond)
// Expected inbound latency = 70ms, outbound = 210ms.
nowFn(70 * time.Millisecond)
_, _, resp, err := raw.Call(ctx, ch, hostPort, testServiceName, "app-error", nil, nil)
require.NoError(t, err)
require.True(t, resp.ApplicationError(), "expected application error")
outboundTags = tagsForOutboundCall(serverCh, ch, "app-error")
clientStats.Expected.IncCounter("outbound.calls.send", outboundTags, 1)
clientStats.Expected.IncCounter("outbound.calls.app-errors", outboundTags, 1)
clientStats.Expected.RecordTimer("outbound.calls.latency", outboundTags, 210*time.Millisecond)
inboundTags = tagsForInboundCall(serverCh, ch, "app-error")
serverStats.Expected.IncCounter("inbound.calls.recvd", inboundTags, 1)
serverStats.Expected.IncCounter("inbound.calls.app-errors", inboundTags, 1)
serverStats.Expected.RecordTimer("inbound.calls.latency", inboundTags, 70*time.Millisecond)
}))
clientStats.Validate(t)
serverStats.Validate(t)
}
func TestParseConfiguration(t *testing.T) {
peers1 := []string{"1.1.1.1:1", "2.2.2.2:2"}
peers2 := []string{"3.3.3.3:3", "4.4.4.4:4"}
invalidPeer1 := []string{"2:2:2:2"}
invalidPeer2 := []string{"2.2.2.2"}
peersFile2 := `["3.3.3.3:3", "4.4.4.4:4"]`
tests := []struct {
name string
peersArg []string
peersFile string
wantPeers []string
wantErr bool
}{
{
name: "no peers",
wantErr: true,
},
{
name: "no peer list",
peersArg: peers1,
wantPeers: peers1,
},
{
name: "invalid peers invalid format",
peersArg: invalidPeer1,
wantErr: true,
},
{
name: "invalid peers no port",
peersArg: invalidPeer2,
wantErr: true,
},
{
name: "peer file",
peersFile: peersFile2,
wantPeers: peers2,
},
{
name: "peer file overrides args",
peersArg: peers1,
peersFile: peersFile2,
wantPeers: peers2,
},
}
for _, tt := range tests {
peerFile := ""
if tt.peersFile != "" {
f, err := ioutil.TempFile("", "hosts")
if !assert.NoError(t, err, "%v: TempFile failed", tt.name) {
continue
}
defer os.Remove(f.Name())
_, err = f.WriteString(tt.peersFile)
assert.NoError(t, err, "%v: write peer file failed", tt.name)
assert.NoError(t, err, "%v: write peer file failed", tt.name)
assert.NoError(t, f.Close(), "%v: close peer file failed", tt.name)
peerFile = f.Name()
}
config := Configuration{InitialNodes: tt.peersArg, InitialNodesFile: peerFile}
ch, err := testutils.NewClient(nil)
require.NoError(t, err, "%v: testutils.NewClient failed", tt.name)
defer ch.Close()
_, err = NewClient(ch, config, nil)
if tt.wantErr {
assert.Error(t, err, "%v: NewClient expected to fail")
continue
}
if !assert.NoError(t, err, "%v: hyperbahn.NewClient failed", tt.name) {
continue
}
assert.Equal(t, tt.wantPeers, getPeers(ch), "%v: got unexpected peers", tt.name)
}
}
