From f64553fe649d0f6c2e02f9495e43a36feb9b7af7 Mon Sep 17 00:00:00 2001 From: Carl Mastrangelo Date: Tue, 15 May 2018 11:24:46 -0700 Subject: [PATCH] channelz: split channelz grpc and pb (#2068) --- channelz/service/service.go | 125 ++++++++++++++++--------------- channelz/service/service_test.go | 60 +++++++-------- 2 files changed, 93 insertions(+), 92 deletions(-) diff --git a/channelz/service/service.go b/channelz/service/service.go index 16f69eb8..f3a3e92a 100644 --- a/channelz/service/service.go +++ b/channelz/service/service.go @@ -29,43 +29,44 @@ import ( "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/channelz" - pb "google.golang.org/grpc/channelz/grpc_channelz_v1" + channelzgrpc "google.golang.org/grpc/channelz/grpc_channelz_v1" + channelzpb "google.golang.org/grpc/channelz/grpc_channelz_v1" "google.golang.org/grpc/connectivity" ) // RegisterChannelzServiceToServer registers the channelz service to the given server. func RegisterChannelzServiceToServer(s *grpc.Server) { - pb.RegisterChannelzServer(s, &serverImpl{}) + channelzgrpc.RegisterChannelzServer(s, &serverImpl{}) } -func newCZServer() pb.ChannelzServer { +func newCZServer() channelzgrpc.ChannelzServer { return &serverImpl{} } type serverImpl struct{} -func connectivityStateToProto(s connectivity.State) *pb.ChannelConnectivityState { +func connectivityStateToProto(s connectivity.State) *channelzpb.ChannelConnectivityState { switch s { case connectivity.Idle: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_IDLE} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_IDLE} case connectivity.Connecting: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_CONNECTING} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_CONNECTING} case connectivity.Ready: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_READY} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_READY} case connectivity.TransientFailure: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_TRANSIENT_FAILURE} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_TRANSIENT_FAILURE} case connectivity.Shutdown: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_SHUTDOWN} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_SHUTDOWN} default: - return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_UNKNOWN} + return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_UNKNOWN} } } -func channelMetricToProto(cm *channelz.ChannelMetric) *pb.Channel { - c := &pb.Channel{} - c.Ref = &pb.ChannelRef{ChannelId: cm.ID, Name: cm.RefName} +func channelMetricToProto(cm *channelz.ChannelMetric) *channelzpb.Channel { + c := &channelzpb.Channel{} + c.Ref = &channelzpb.ChannelRef{ChannelId: cm.ID, Name: cm.RefName} - c.Data = &pb.ChannelData{ + c.Data = &channelzpb.ChannelData{ State: connectivityStateToProto(cm.ChannelData.State), Target: cm.ChannelData.Target, CallsStarted: cm.ChannelData.CallsStarted, @@ -75,31 +76,31 @@ func channelMetricToProto(cm *channelz.ChannelMetric) *pb.Channel { if ts, err := ptypes.TimestampProto(cm.ChannelData.LastCallStartedTimestamp); err == nil { c.Data.LastCallStartedTimestamp = ts } - nestedChans := make([]*pb.ChannelRef, 0, len(cm.NestedChans)) + nestedChans := make([]*channelzpb.ChannelRef, 0, len(cm.NestedChans)) for id, ref := range cm.NestedChans { - nestedChans = append(nestedChans, &pb.ChannelRef{ChannelId: id, Name: ref}) + nestedChans = append(nestedChans, &channelzpb.ChannelRef{ChannelId: id, Name: ref}) } c.ChannelRef = nestedChans - subChans := make([]*pb.SubchannelRef, 0, len(cm.SubChans)) + subChans := make([]*channelzpb.SubchannelRef, 0, len(cm.SubChans)) for id, ref := range cm.SubChans { - subChans = append(subChans, &pb.SubchannelRef{SubchannelId: id, Name: ref}) + subChans = append(subChans, &channelzpb.SubchannelRef{SubchannelId: id, Name: ref}) } c.SubchannelRef = subChans - sockets := make([]*pb.SocketRef, 0, len(cm.Sockets)) + sockets := make([]*channelzpb.SocketRef, 0, len(cm.Sockets)) for id, ref := range cm.Sockets { - sockets = append(sockets, &pb.SocketRef{SocketId: id, Name: ref}) + sockets = append(sockets, &channelzpb.SocketRef{SocketId: id, Name: ref}) } c.SocketRef = sockets return c } -func subChannelMetricToProto(cm *channelz.SubChannelMetric) *pb.Subchannel { - sc := &pb.Subchannel{} - sc.Ref = &pb.SubchannelRef{SubchannelId: cm.ID, Name: cm.RefName} +func subChannelMetricToProto(cm *channelz.SubChannelMetric) *channelzpb.Subchannel { + sc := &channelzpb.Subchannel{} + sc.Ref = &channelzpb.SubchannelRef{SubchannelId: cm.ID, Name: cm.RefName} - sc.Data = &pb.ChannelData{ + sc.Data = &channelzpb.ChannelData{ State: connectivityStateToProto(cm.ChannelData.State), Target: cm.ChannelData.Target, CallsStarted: cm.ChannelData.CallsStarted, @@ -109,51 +110,51 @@ func subChannelMetricToProto(cm *channelz.SubChannelMetric) *pb.Subchannel { if ts, err := ptypes.TimestampProto(cm.ChannelData.LastCallStartedTimestamp); err == nil { sc.Data.LastCallStartedTimestamp = ts } - nestedChans := make([]*pb.ChannelRef, 0, len(cm.NestedChans)) + nestedChans := make([]*channelzpb.ChannelRef, 0, len(cm.NestedChans)) for id, ref := range cm.NestedChans { - nestedChans = append(nestedChans, &pb.ChannelRef{ChannelId: id, Name: ref}) + nestedChans = append(nestedChans, &channelzpb.ChannelRef{ChannelId: id, Name: ref}) } sc.ChannelRef = nestedChans - subChans := make([]*pb.SubchannelRef, 0, len(cm.SubChans)) + subChans := make([]*channelzpb.SubchannelRef, 0, len(cm.SubChans)) for id, ref := range cm.SubChans { - subChans = append(subChans, &pb.SubchannelRef{SubchannelId: id, Name: ref}) + subChans = append(subChans, &channelzpb.SubchannelRef{SubchannelId: id, Name: ref}) } sc.SubchannelRef = subChans - sockets := make([]*pb.SocketRef, 0, len(cm.Sockets)) + sockets := make([]*channelzpb.SocketRef, 0, len(cm.Sockets)) for id, ref := range cm.Sockets { - sockets = append(sockets, &pb.SocketRef{SocketId: id, Name: ref}) + sockets = append(sockets, &channelzpb.SocketRef{SocketId: id, Name: ref}) } sc.SocketRef = sockets return sc } -func addrToProto(a net.Addr) *pb.Address { +func addrToProto(a net.Addr) *channelzpb.Address { switch a.Network() { case "udp": // TODO: Address_OtherAddress{}. Need proto def for Value. case "ip": // Note zone info is discarded through the conversion. - return &pb.Address{Address: &pb.Address_TcpipAddress{TcpipAddress: &pb.Address_TcpIpAddress{IpAddress: a.(*net.IPAddr).IP}}} + return &channelzpb.Address{Address: &channelzpb.Address_TcpipAddress{TcpipAddress: &channelzpb.Address_TcpIpAddress{IpAddress: a.(*net.IPAddr).IP}}} case "ip+net": // Note mask info is discarded through the conversion. - return &pb.Address{Address: &pb.Address_TcpipAddress{TcpipAddress: &pb.Address_TcpIpAddress{IpAddress: a.(*net.IPNet).IP}}} + return &channelzpb.Address{Address: &channelzpb.Address_TcpipAddress{TcpipAddress: &channelzpb.Address_TcpIpAddress{IpAddress: a.(*net.IPNet).IP}}} case "tcp": // Note zone info is discarded through the conversion. - return &pb.Address{Address: &pb.Address_TcpipAddress{TcpipAddress: &pb.Address_TcpIpAddress{IpAddress: a.(*net.TCPAddr).IP, Port: int32(a.(*net.TCPAddr).Port)}}} + return &channelzpb.Address{Address: &channelzpb.Address_TcpipAddress{TcpipAddress: &channelzpb.Address_TcpIpAddress{IpAddress: a.(*net.TCPAddr).IP, Port: int32(a.(*net.TCPAddr).Port)}}} case "unix", "unixgram", "unixpacket": - return &pb.Address{Address: &pb.Address_UdsAddress_{UdsAddress: &pb.Address_UdsAddress{Filename: a.String()}}} + return &channelzpb.Address{Address: &channelzpb.Address_UdsAddress_{UdsAddress: &channelzpb.Address_UdsAddress{Filename: a.String()}}} default: } - return &pb.Address{} + return &channelzpb.Address{} } -func socketMetricToProto(sm *channelz.SocketMetric) *pb.Socket { - s := &pb.Socket{} - s.Ref = &pb.SocketRef{SocketId: sm.ID, Name: sm.RefName} +func socketMetricToProto(sm *channelz.SocketMetric) *channelzpb.Socket { + s := &channelzpb.Socket{} + s.Ref = &channelzpb.SocketRef{SocketId: sm.ID, Name: sm.RefName} - s.Data = &pb.SocketData{ + s.Data = &channelzpb.SocketData{ StreamsStarted: sm.SocketData.StreamsStarted, StreamsSucceeded: sm.SocketData.StreamsSucceeded, StreamsFailed: sm.SocketData.StreamsFailed, @@ -186,9 +187,9 @@ func socketMetricToProto(sm *channelz.SocketMetric) *pb.Socket { return s } -func (s *serverImpl) GetTopChannels(ctx context.Context, req *pb.GetTopChannelsRequest) (*pb.GetTopChannelsResponse, error) { +func (s *serverImpl) GetTopChannels(ctx context.Context, req *channelzpb.GetTopChannelsRequest) (*channelzpb.GetTopChannelsResponse, error) { metrics, end := channelz.GetTopChannels(req.GetStartChannelId()) - resp := &pb.GetTopChannelsResponse{} + resp := &channelzpb.GetTopChannelsResponse{} for _, m := range metrics { resp.Channel = append(resp.Channel, channelMetricToProto(m)) } @@ -196,11 +197,11 @@ func (s *serverImpl) GetTopChannels(ctx context.Context, req *pb.GetTopChannelsR return resp, nil } -func serverMetricToProto(sm *channelz.ServerMetric) *pb.Server { - s := &pb.Server{} - s.Ref = &pb.ServerRef{ServerId: sm.ID, Name: sm.RefName} +func serverMetricToProto(sm *channelz.ServerMetric) *channelzpb.Server { + s := &channelzpb.Server{} + s.Ref = &channelzpb.ServerRef{ServerId: sm.ID, Name: sm.RefName} - s.Data = &pb.ServerData{ + s.Data = &channelzpb.ServerData{ CallsStarted: sm.ServerData.CallsStarted, CallsSucceeded: sm.ServerData.CallsSucceeded, CallsFailed: sm.ServerData.CallsFailed, @@ -209,17 +210,17 @@ func serverMetricToProto(sm *channelz.ServerMetric) *pb.Server { if ts, err := ptypes.TimestampProto(sm.ServerData.LastCallStartedTimestamp); err == nil { s.Data.LastCallStartedTimestamp = ts } - sockets := make([]*pb.SocketRef, 0, len(sm.ListenSockets)) + sockets := make([]*channelzpb.SocketRef, 0, len(sm.ListenSockets)) for id, ref := range sm.ListenSockets { - sockets = append(sockets, &pb.SocketRef{SocketId: id, Name: ref}) + sockets = append(sockets, &channelzpb.SocketRef{SocketId: id, Name: ref}) } s.ListenSocket = sockets return s } -func (s *serverImpl) GetServers(ctx context.Context, req *pb.GetServersRequest) (*pb.GetServersResponse, error) { +func (s *serverImpl) GetServers(ctx context.Context, req *channelzpb.GetServersRequest) (*channelzpb.GetServersResponse, error) { metrics, end := channelz.GetServers(req.GetStartServerId()) - resp := &pb.GetServersResponse{} + resp := &channelzpb.GetServersResponse{} for _, m := range metrics { resp.Server = append(resp.Server, serverMetricToProto(m)) } @@ -227,39 +228,39 @@ func (s *serverImpl) GetServers(ctx context.Context, req *pb.GetServersRequest) return resp, nil } -func (s *serverImpl) GetServerSockets(ctx context.Context, req *pb.GetServerSocketsRequest) (*pb.GetServerSocketsResponse, error) { +func (s *serverImpl) GetServerSockets(ctx context.Context, req *channelzpb.GetServerSocketsRequest) (*channelzpb.GetServerSocketsResponse, error) { metrics, end := channelz.GetServerSockets(req.GetServerId(), req.GetStartSocketId()) - resp := &pb.GetServerSocketsResponse{} + resp := &channelzpb.GetServerSocketsResponse{} for _, m := range metrics { - resp.SocketRef = append(resp.SocketRef, &pb.SocketRef{SocketId: m.ID, Name: m.RefName}) + resp.SocketRef = append(resp.SocketRef, &channelzpb.SocketRef{SocketId: m.ID, Name: m.RefName}) } resp.End = end return resp, nil } -func (s *serverImpl) GetChannel(ctx context.Context, req *pb.GetChannelRequest) (*pb.GetChannelResponse, error) { +func (s *serverImpl) GetChannel(ctx context.Context, req *channelzpb.GetChannelRequest) (*channelzpb.GetChannelResponse, error) { var metric *channelz.ChannelMetric if metric = channelz.GetChannel(req.GetChannelId()); metric == nil { - return &pb.GetChannelResponse{}, nil + return &channelzpb.GetChannelResponse{}, nil } - resp := &pb.GetChannelResponse{Channel: channelMetricToProto(metric)} + resp := &channelzpb.GetChannelResponse{Channel: channelMetricToProto(metric)} return resp, nil } -func (s *serverImpl) GetSubchannel(ctx context.Context, req *pb.GetSubchannelRequest) (*pb.GetSubchannelResponse, error) { +func (s *serverImpl) GetSubchannel(ctx context.Context, req *channelzpb.GetSubchannelRequest) (*channelzpb.GetSubchannelResponse, error) { var metric *channelz.SubChannelMetric if metric = channelz.GetSubChannel(req.GetSubchannelId()); metric == nil { - return &pb.GetSubchannelResponse{}, nil + return &channelzpb.GetSubchannelResponse{}, nil } - resp := &pb.GetSubchannelResponse{Subchannel: subChannelMetricToProto(metric)} + resp := &channelzpb.GetSubchannelResponse{Subchannel: subChannelMetricToProto(metric)} return resp, nil } -func (s *serverImpl) GetSocket(ctx context.Context, req *pb.GetSocketRequest) (*pb.GetSocketResponse, error) { +func (s *serverImpl) GetSocket(ctx context.Context, req *channelzpb.GetSocketRequest) (*channelzpb.GetSocketResponse, error) { var metric *channelz.SocketMetric if metric = channelz.GetSocket(req.GetSocketId()); metric == nil { - return &pb.GetSocketResponse{}, nil + return &channelzpb.GetSocketResponse{}, nil } - resp := &pb.GetSocketResponse{Socket: socketMetricToProto(metric)} + resp := &channelzpb.GetSocketResponse{Socket: socketMetricToProto(metric)} return resp, nil } diff --git a/channelz/service/service_test.go b/channelz/service/service_test.go index 9503b7e9..4d3973c1 100644 --- a/channelz/service/service_test.go +++ b/channelz/service/service_test.go @@ -28,7 +28,7 @@ import ( "github.com/golang/protobuf/ptypes" "golang.org/x/net/context" "google.golang.org/grpc/channelz" - pb "google.golang.org/grpc/channelz/grpc_channelz_v1" + channelzpb "google.golang.org/grpc/channelz/grpc_channelz_v1" "google.golang.org/grpc/connectivity" ) @@ -121,21 +121,21 @@ func (d *dummySocket) ChannelzMetric() *channelz.SocketInternalMetric { } } -func channelProtoToStruct(c *pb.Channel) *dummyChannel { +func channelProtoToStruct(c *channelzpb.Channel) *dummyChannel { dc := &dummyChannel{} pdata := c.GetData() switch pdata.GetState().GetState() { - case pb.ChannelConnectivityState_UNKNOWN: + case channelzpb.ChannelConnectivityState_UNKNOWN: // TODO: what should we set here? - case pb.ChannelConnectivityState_IDLE: + case channelzpb.ChannelConnectivityState_IDLE: dc.state = connectivity.Idle - case pb.ChannelConnectivityState_CONNECTING: + case channelzpb.ChannelConnectivityState_CONNECTING: dc.state = connectivity.Connecting - case pb.ChannelConnectivityState_READY: + case channelzpb.ChannelConnectivityState_READY: dc.state = connectivity.Ready - case pb.ChannelConnectivityState_TRANSIENT_FAILURE: + case channelzpb.ChannelConnectivityState_TRANSIENT_FAILURE: dc.state = connectivity.TransientFailure - case pb.ChannelConnectivityState_SHUTDOWN: + case channelzpb.ChannelConnectivityState_SHUTDOWN: dc.state = connectivity.Shutdown } dc.target = pdata.GetTarget() @@ -150,7 +150,7 @@ func channelProtoToStruct(c *pb.Channel) *dummyChannel { return dc } -func serverProtoToStruct(s *pb.Server) *dummyServer { +func serverProtoToStruct(s *channelzpb.Server) *dummyServer { ds := &dummyServer{} pdata := s.GetData() ds.callsStarted = pdata.CallsStarted @@ -164,22 +164,22 @@ func serverProtoToStruct(s *pb.Server) *dummyServer { return ds } -func protoToAddr(a *pb.Address) net.Addr { +func protoToAddr(a *channelzpb.Address) net.Addr { switch v := a.Address.(type) { - case *pb.Address_TcpipAddress: + case *channelzpb.Address_TcpipAddress: if port := v.TcpipAddress.GetPort(); port != 0 { return &net.TCPAddr{IP: v.TcpipAddress.GetIpAddress(), Port: int(port)} } return &net.IPAddr{IP: v.TcpipAddress.GetIpAddress()} - case *pb.Address_UdsAddress_: + case *channelzpb.Address_UdsAddress_: return &net.UnixAddr{Name: v.UdsAddress.GetFilename(), Net: "unix"} - case *pb.Address_OtherAddress_: + case *channelzpb.Address_OtherAddress_: // TODO: } return nil } -func socketProtoToStruct(s *pb.Socket) *dummySocket { +func socketProtoToStruct(s *channelzpb.Socket) *dummySocket { ds := &dummySocket{} pdata := s.GetData() ds.streamsStarted = pdata.GetStreamsStarted() @@ -224,7 +224,7 @@ func socketProtoToStruct(s *pb.Socket) *dummySocket { return ds } -func convertSocketRefSliceToMap(sktRefs []*pb.SocketRef) map[int64]string { +func convertSocketRefSliceToMap(sktRefs []*channelzpb.SocketRef) map[int64]string { m := make(map[int64]string) for _, sr := range sktRefs { m[sr.SocketId] = sr.Name @@ -264,7 +264,7 @@ func TestGetTopChannels(t *testing.T) { channelz.RegisterChannel(c, 0, "") } s := newCZServer() - resp, _ := s.GetTopChannels(context.Background(), &pb.GetTopChannelsRequest{StartChannelId: 0}) + resp, _ := s.GetTopChannels(context.Background(), &channelzpb.GetTopChannelsRequest{StartChannelId: 0}) if !resp.GetEnd() { t.Fatalf("resp.GetEnd() want true, got %v", resp.GetEnd()) } @@ -276,7 +276,7 @@ func TestGetTopChannels(t *testing.T) { for i := 0; i < 50; i++ { channelz.RegisterChannel(tcs[0], 0, "") } - resp, _ = s.GetTopChannels(context.Background(), &pb.GetTopChannelsRequest{StartChannelId: 0}) + resp, _ = s.GetTopChannels(context.Background(), &channelzpb.GetTopChannelsRequest{StartChannelId: 0}) if resp.GetEnd() { t.Fatalf("resp.GetEnd() want false, got %v", resp.GetEnd()) } @@ -308,7 +308,7 @@ func TestGetServers(t *testing.T) { channelz.RegisterServer(s, "") } svr := newCZServer() - resp, _ := svr.GetServers(context.Background(), &pb.GetServersRequest{StartServerId: 0}) + resp, _ := svr.GetServers(context.Background(), &channelzpb.GetServersRequest{StartServerId: 0}) if !resp.GetEnd() { t.Fatalf("resp.GetEnd() want true, got %v", resp.GetEnd()) } @@ -320,7 +320,7 @@ func TestGetServers(t *testing.T) { for i := 0; i < 50; i++ { channelz.RegisterServer(ss[0], "") } - resp, _ = svr.GetServers(context.Background(), &pb.GetServersRequest{StartServerId: 0}) + resp, _ = svr.GetServers(context.Background(), &channelzpb.GetServersRequest{StartServerId: 0}) if resp.GetEnd() { t.Fatalf("resp.GetEnd() want false, got %v", resp.GetEnd()) } @@ -335,7 +335,7 @@ func TestGetServerSockets(t *testing.T) { ids[1] = channelz.RegisterNormalSocket(&dummySocket{}, svrID, refNames[1]) ids[2] = channelz.RegisterNormalSocket(&dummySocket{}, svrID, refNames[2]) svr := newCZServer() - resp, _ := svr.GetServerSockets(context.Background(), &pb.GetServerSocketsRequest{ServerId: svrID, StartSocketId: 0}) + resp, _ := svr.GetServerSockets(context.Background(), &channelzpb.GetServerSocketsRequest{ServerId: svrID, StartSocketId: 0}) if !resp.GetEnd() { t.Fatalf("resp.GetEnd() want: true, got: %v", resp.GetEnd()) } @@ -351,7 +351,7 @@ func TestGetServerSockets(t *testing.T) { for i := 0; i < 50; i++ { channelz.RegisterNormalSocket(&dummySocket{}, svrID, "") } - resp, _ = svr.GetServerSockets(context.Background(), &pb.GetServerSocketsRequest{ServerId: svrID, StartSocketId: 0}) + resp, _ = svr.GetServerSockets(context.Background(), &channelzpb.GetServerSocketsRequest{ServerId: svrID, StartSocketId: 0}) if resp.GetEnd() { t.Fatalf("resp.GetEnd() want false, got %v", resp.GetEnd()) } @@ -366,22 +366,22 @@ func TestGetChannel(t *testing.T) { ids[2] = channelz.RegisterSubChannel(&dummyChannel{}, ids[0], refNames[2]) ids[3] = channelz.RegisterChannel(&dummyChannel{}, ids[1], refNames[3]) svr := newCZServer() - resp, _ := svr.GetChannel(context.Background(), &pb.GetChannelRequest{ChannelId: ids[0]}) + resp, _ := svr.GetChannel(context.Background(), &channelzpb.GetChannelRequest{ChannelId: ids[0]}) metrics := resp.GetChannel() subChans := metrics.GetSubchannelRef() if len(subChans) != 1 || subChans[0].GetName() != refNames[2] || subChans[0].GetSubchannelId() != ids[2] { - t.Fatalf("GetSubChannelRef() want %#v, got %#v", []*pb.SubchannelRef{{SubchannelId: ids[2], Name: refNames[2]}}, subChans) + t.Fatalf("GetSubChannelRef() want %#v, got %#v", []*channelzpb.SubchannelRef{{SubchannelId: ids[2], Name: refNames[2]}}, subChans) } nestedChans := metrics.GetChannelRef() if len(nestedChans) != 1 || nestedChans[0].GetName() != refNames[1] || nestedChans[0].GetChannelId() != ids[1] { - t.Fatalf("GetChannelRef() want %#v, got %#v", []*pb.ChannelRef{{ChannelId: ids[1], Name: refNames[1]}}, nestedChans) + t.Fatalf("GetChannelRef() want %#v, got %#v", []*channelzpb.ChannelRef{{ChannelId: ids[1], Name: refNames[1]}}, nestedChans) } - resp, _ = svr.GetChannel(context.Background(), &pb.GetChannelRequest{ChannelId: ids[1]}) + resp, _ = svr.GetChannel(context.Background(), &channelzpb.GetChannelRequest{ChannelId: ids[1]}) metrics = resp.GetChannel() nestedChans = metrics.GetChannelRef() if len(nestedChans) != 1 || nestedChans[0].GetName() != refNames[3] || nestedChans[0].GetChannelId() != ids[3] { - t.Fatalf("GetChannelRef() want %#v, got %#v", []*pb.ChannelRef{{ChannelId: ids[3], Name: refNames[3]}}, nestedChans) + t.Fatalf("GetChannelRef() want %#v, got %#v", []*channelzpb.ChannelRef{{ChannelId: ids[3], Name: refNames[3]}}, nestedChans) } } @@ -394,7 +394,7 @@ func TestGetSubChannel(t *testing.T) { ids[2] = channelz.RegisterNormalSocket(&dummySocket{}, ids[1], refNames[2]) ids[3] = channelz.RegisterNormalSocket(&dummySocket{}, ids[1], refNames[3]) svr := newCZServer() - resp, _ := svr.GetSubchannel(context.Background(), &pb.GetSubchannelRequest{SubchannelId: ids[1]}) + resp, _ := svr.GetSubchannel(context.Background(), &channelzpb.GetSubchannelRequest{SubchannelId: ids[1]}) metrics := resp.GetSubchannel() want := map[int64]string{ ids[2]: refNames[2], @@ -468,10 +468,10 @@ func TestGetSocket(t *testing.T) { ids[i] = channelz.RegisterNormalSocket(s, svrID, strconv.Itoa(i)) } for i, s := range ss { - resp, _ := svr.GetSocket(context.Background(), &pb.GetSocketRequest{SocketId: ids[i]}) + resp, _ := svr.GetSocket(context.Background(), &channelzpb.GetSocketRequest{SocketId: ids[i]}) metrics := resp.GetSocket() - if !reflect.DeepEqual(metrics.GetRef(), &pb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}) || !reflect.DeepEqual(socketProtoToStruct(metrics), s) { - t.Fatalf("resp.GetSocket() want: metrics.GetRef() = %#v and %#v, got: metrics.GetRef() = %#v and %#v", &pb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}, s, metrics.GetRef(), socketProtoToStruct(metrics)) + if !reflect.DeepEqual(metrics.GetRef(), &channelzpb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}) || !reflect.DeepEqual(socketProtoToStruct(metrics), s) { + t.Fatalf("resp.GetSocket() want: metrics.GetRef() = %#v and %#v, got: metrics.GetRef() = %#v and %#v", &channelzpb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}, s, metrics.GetRef(), socketProtoToStruct(metrics)) } } }