func getStatusClient() (serverpb.StatusClient, *stop.Stopper, error) {
conn, stopper, err := getGRPCConn()
if err != nil {
return nil, nil, err
}
return serverpb.NewStatusClient(conn), stopper, nil
}
func TestSpanStatsGRPCResponse(t *testing.T) {
defer leaktest.AfterTest(t)()
ts := startServer(t)
defer ts.Stopper().Stop()
rpcStopper := stop.NewStopper()
defer rpcStopper.Stop()
rpcContext := rpc.NewContext(log.AmbientContext{}, ts.RPCContext().Config, ts.Clock(), rpcStopper)
request := serverpb.SpanStatsRequest{
NodeID: "1",
StartKey: []byte(roachpb.RKeyMin),
EndKey: []byte(roachpb.RKeyMax),
}
url := ts.ServingAddr()
conn, err := rpcContext.GRPCDial(url)
if err != nil {
t.Fatal(err)
}
client := serverpb.NewStatusClient(conn)
response, err := client.SpanStats(context.Background(), &request)
if err != nil {
t.Fatal(err)
}
if a, e := int(response.RangeCount), ExpectedInitialRangeCount(); a != e {
t.Errorf("expected %d ranges, found %d", e, a)
}
}
func (c *Cluster) makeStatus(nodeIdx int) serverpb.StatusClient {
conn, err := c.rpcCtx.GRPCDial(c.RPCAddr(nodeIdx))
if err != nil {
log.Fatalf(context.Background(), "failed to initialize status client: %s", err)
}
return serverpb.NewStatusClient(conn)
}
func (s *statusServer) dialNode(nodeID roachpb.NodeID) (serverpb.StatusClient, error) {
addr, err := s.gossip.GetNodeIDAddress(nodeID)
if err != nil {
return nil, err
}
conn, err := s.rpcCtx.GRPCDial(addr.String())
if err != nil {
return nil, err
}
return serverpb.NewStatusClient(conn), nil
}
func TestStopServer(t *testing.T) {
defer leaktest.AfterTest(t)()
// Use insecure mode so our servers listen on util.IsolatedTestAddr
// and they fail cleanly instead of interfering with other tests.
// See https://github.com/cockroachdb/cockroach/issues/9256
tc := StartTestCluster(t, 3, base.TestClusterArgs{
ServerArgs: base.TestServerArgs{
Insecure: true,
},
ReplicationMode: base.ReplicationAuto,
})
defer tc.Stopper().Stop()
// Connect to server 1, ensure it is answering requests over HTTP and GRPC.
server1 := tc.Server(1)
var response serverpb.JSONResponse
httpClient1, err := server1.GetHTTPClient()
if err != nil {
t.Fatal(err)
}
url := server1.AdminURL() + "/_status/metrics/local"
if err := httputil.GetJSON(httpClient1, url, &response); err != nil {
t.Fatal(err)
}
rpcContext := rpc.NewContext(
log.AmbientContext{}, tc.Server(1).RPCContext().Config, tc.Server(1).Clock(), tc.Stopper(),
)
conn, err := rpcContext.GRPCDial(server1.ServingAddr())
if err != nil {
t.Fatal(err)
}
statusClient1 := serverpb.NewStatusClient(conn)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if _, err := statusClient1.Metrics(ctx, &serverpb.MetricsRequest{NodeId: "local"}); err != nil {
t.Fatal(err)
}
// Stop server 1.
tc.StopServer(1)
// Verify HTTP and GRPC requests to server now fail.
httpErrorText := "connection refused"
if err := httputil.GetJSON(httpClient1, url, &response); err == nil {
t.Fatal("Expected HTTP Request to fail after server stopped")
} else if !testutils.IsError(err, httpErrorText) {
t.Fatalf("Expected error from server with text %q, got error with text %q", httpErrorText, err.Error())
}
grpcErrorText := "rpc error"
if _, err := statusClient1.Metrics(ctx, &serverpb.MetricsRequest{NodeId: "local"}); err == nil {
t.Fatal("Expected GRPC Request to fail after server stopped")
} else if !testutils.IsError(err, grpcErrorText) {
t.Fatalf("Expected error from GRPC with text %q, got error with text %q", grpcErrorText, err.Error())
}
// Verify that request to Server 0 still works.
httpClient1, err = tc.Server(0).GetHTTPClient()
if err != nil {
t.Fatal(err)
}
url = tc.Server(0).AdminURL() + "/_status/metrics/local"
if err := httputil.GetJSON(httpClient1, url, &response); err != nil {
t.Fatal(err)
}
}