opensource/grpc-go
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

channelz: split channelz grpc and pb (#2068)

Browse Source
This commit is contained in:
Carl Mastrangelo
2018-05-15 11:24:46 -07:00
committed by lyuxuan
parent d24d0a4b99
commit f64553fe64
2 changed files with 93 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
channelz/service/service.go
View File

@ -29,43 +29,44 @@ import (
"golang.org/x/net/context" "golang.org/x/net/context"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/channelz" "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" "google.golang.org/grpc/connectivity"
) )
// RegisterChannelzServiceToServer registers the channelz service to the given server. // RegisterChannelzServiceToServer registers the channelz service to the given server.
func RegisterChannelzServiceToServer(s *grpc.Server) { func RegisterChannelzServiceToServer(s *grpc.Server) {
pb.RegisterChannelzServer(s, &serverImpl{}) channelzgrpc.RegisterChannelzServer(s, &serverImpl{})
} }
func newCZServer() pb.ChannelzServer { func newCZServer() channelzgrpc.ChannelzServer {
return &serverImpl{} return &serverImpl{}
} }
type serverImpl struct{} type serverImpl struct{}
func connectivityStateToProto(s connectivity.State) *pb.ChannelConnectivityState { func connectivityStateToProto(s connectivity.State) *channelzpb.ChannelConnectivityState {
switch s { switch s {
case connectivity.Idle: case connectivity.Idle:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_IDLE} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_IDLE}
case connectivity.Connecting: case connectivity.Connecting:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_CONNECTING} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_CONNECTING}
case connectivity.Ready: case connectivity.Ready:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_READY} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_READY}
case connectivity.TransientFailure: case connectivity.TransientFailure:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_TRANSIENT_FAILURE} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_TRANSIENT_FAILURE}
case connectivity.Shutdown: case connectivity.Shutdown:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_SHUTDOWN} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_SHUTDOWN}
default: default:
return &pb.ChannelConnectivityState{State: pb.ChannelConnectivityState_UNKNOWN} return &channelzpb.ChannelConnectivityState{State: channelzpb.ChannelConnectivityState_UNKNOWN}
} }
} }
func channelMetricToProto(cm *channelz.ChannelMetric) *pb.Channel { func channelMetricToProto(cm *channelz.ChannelMetric) *channelzpb.Channel {
c := &pb.Channel{} c := &channelzpb.Channel{}
c.Ref = &pb.ChannelRef{ChannelId: cm.ID, Name: cm.RefName} c.Ref = &channelzpb.ChannelRef{ChannelId: cm.ID, Name: cm.RefName}
c.Data = &pb.ChannelData{ c.Data = &channelzpb.ChannelData{
State: connectivityStateToProto(cm.ChannelData.State), State: connectivityStateToProto(cm.ChannelData.State),
Target: cm.ChannelData.Target, Target: cm.ChannelData.Target,
CallsStarted: cm.ChannelData.CallsStarted, 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 { if ts, err := ptypes.TimestampProto(cm.ChannelData.LastCallStartedTimestamp); err == nil {
c.Data.LastCallStartedTimestamp = ts 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 { 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 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 { 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 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 { 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 c.SocketRef = sockets
return c return c
} }
func subChannelMetricToProto(cm *channelz.SubChannelMetric) *pb.Subchannel { func subChannelMetricToProto(cm *channelz.SubChannelMetric) *channelzpb.Subchannel {
sc := &pb.Subchannel{} sc := &channelzpb.Subchannel{}
sc.Ref = &pb.SubchannelRef{SubchannelId: cm.ID, Name: cm.RefName} sc.Ref = &channelzpb.SubchannelRef{SubchannelId: cm.ID, Name: cm.RefName}
sc.Data = &pb.ChannelData{ sc.Data = &channelzpb.ChannelData{
State: connectivityStateToProto(cm.ChannelData.State), State: connectivityStateToProto(cm.ChannelData.State),
Target: cm.ChannelData.Target, Target: cm.ChannelData.Target,
CallsStarted: cm.ChannelData.CallsStarted, 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 { if ts, err := ptypes.TimestampProto(cm.ChannelData.LastCallStartedTimestamp); err == nil {
sc.Data.LastCallStartedTimestamp = ts 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 { 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 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 { 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 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 { 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 sc.SocketRef = sockets
return sc return sc
} }
func addrToProto(a net.Addr) *pb.Address { func addrToProto(a net.Addr) *channelzpb.Address {
switch a.Network() { switch a.Network() {
case "udp": case "udp":
// TODO: Address_OtherAddress{}. Need proto def for Value. // TODO: Address_OtherAddress{}. Need proto def for Value.
case "ip": case "ip":
// Note zone info is discarded through the conversion. // 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": case "ip+net":
// Note mask info is discarded through the conversion. // 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": case "tcp":
// Note zone info is discarded through the conversion. // 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": 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: default:
} }
return &pb.Address{} return &channelzpb.Address{}
} }
func socketMetricToProto(sm *channelz.SocketMetric) *pb.Socket { func socketMetricToProto(sm *channelz.SocketMetric) *channelzpb.Socket {
s := &pb.Socket{} s := &channelzpb.Socket{}
s.Ref = &pb.SocketRef{SocketId: sm.ID, Name: sm.RefName} s.Ref = &channelzpb.SocketRef{SocketId: sm.ID, Name: sm.RefName}
s.Data = &pb.SocketData{ s.Data = &channelzpb.SocketData{
StreamsStarted: sm.SocketData.StreamsStarted, StreamsStarted: sm.SocketData.StreamsStarted,
StreamsSucceeded: sm.SocketData.StreamsSucceeded, StreamsSucceeded: sm.SocketData.StreamsSucceeded,
StreamsFailed: sm.SocketData.StreamsFailed, StreamsFailed: sm.SocketData.StreamsFailed,
@ -186,9 +187,9 @@ func socketMetricToProto(sm *channelz.SocketMetric) *pb.Socket {
return s 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()) metrics, end := channelz.GetTopChannels(req.GetStartChannelId())
resp := &pb.GetTopChannelsResponse{} resp := &channelzpb.GetTopChannelsResponse{}
for _, m := range metrics { for _, m := range metrics {
resp.Channel = append(resp.Channel, channelMetricToProto(m)) resp.Channel = append(resp.Channel, channelMetricToProto(m))
} }
@ -196,11 +197,11 @@ func (s *serverImpl) GetTopChannels(ctx context.Context, req *pb.GetTopChannelsR
return resp, nil return resp, nil
} }
func serverMetricToProto(sm *channelz.ServerMetric) *pb.Server { func serverMetricToProto(sm *channelz.ServerMetric) *channelzpb.Server {
s := &pb.Server{} s := &channelzpb.Server{}
s.Ref = &pb.ServerRef{ServerId: sm.ID, Name: sm.RefName} s.Ref = &channelzpb.ServerRef{ServerId: sm.ID, Name: sm.RefName}
s.Data = &pb.ServerData{ s.Data = &channelzpb.ServerData{
CallsStarted: sm.ServerData.CallsStarted, CallsStarted: sm.ServerData.CallsStarted,
CallsSucceeded: sm.ServerData.CallsSucceeded, CallsSucceeded: sm.ServerData.CallsSucceeded,
CallsFailed: sm.ServerData.CallsFailed, 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 { if ts, err := ptypes.TimestampProto(sm.ServerData.LastCallStartedTimestamp); err == nil {
s.Data.LastCallStartedTimestamp = ts 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 { 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 s.ListenSocket = sockets
return s 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()) metrics, end := channelz.GetServers(req.GetStartServerId())
resp := &pb.GetServersResponse{} resp := &channelzpb.GetServersResponse{}
for _, m := range metrics { for _, m := range metrics {
resp.Server = append(resp.Server, serverMetricToProto(m)) resp.Server = append(resp.Server, serverMetricToProto(m))
} }
@ -227,39 +228,39 @@ func (s *serverImpl) GetServers(ctx context.Context, req *pb.GetServersRequest)
return resp, nil 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()) metrics, end := channelz.GetServerSockets(req.GetServerId(), req.GetStartSocketId())
resp := &pb.GetServerSocketsResponse{} resp := &channelzpb.GetServerSocketsResponse{}
for _, m := range metrics { 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 resp.End = end
return resp, nil 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 var metric *channelz.ChannelMetric
if metric = channelz.GetChannel(req.GetChannelId()); metric == nil { 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 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 var metric *channelz.SubChannelMetric
if metric = channelz.GetSubChannel(req.GetSubchannelId()); metric == nil { 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 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 var metric *channelz.SocketMetric
if metric = channelz.GetSocket(req.GetSocketId()); metric == nil { 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 return resp, nil
} }

60
channelz/service/service_test.go
View File

@ -28,7 +28,7 @@ import (
"github.com/golang/protobuf/ptypes" "github.com/golang/protobuf/ptypes"
"golang.org/x/net/context" "golang.org/x/net/context"
"google.golang.org/grpc/channelz" "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" "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{} dc := &dummyChannel{}
pdata := c.GetData() pdata := c.GetData()
switch pdata.GetState().GetState() { switch pdata.GetState().GetState() {
case pb.ChannelConnectivityState_UNKNOWN: case channelzpb.ChannelConnectivityState_UNKNOWN:
// TODO: what should we set here? // TODO: what should we set here?
case pb.ChannelConnectivityState_IDLE: case channelzpb.ChannelConnectivityState_IDLE:
dc.state = connectivity.Idle dc.state = connectivity.Idle
case pb.ChannelConnectivityState_CONNECTING: case channelzpb.ChannelConnectivityState_CONNECTING:
dc.state = connectivity.Connecting dc.state = connectivity.Connecting
case pb.ChannelConnectivityState_READY: case channelzpb.ChannelConnectivityState_READY:
dc.state = connectivity.Ready dc.state = connectivity.Ready
case pb.ChannelConnectivityState_TRANSIENT_FAILURE: case channelzpb.ChannelConnectivityState_TRANSIENT_FAILURE:
dc.state = connectivity.TransientFailure dc.state = connectivity.TransientFailure
case pb.ChannelConnectivityState_SHUTDOWN: case channelzpb.ChannelConnectivityState_SHUTDOWN:
dc.state = connectivity.Shutdown dc.state = connectivity.Shutdown
} }
dc.target = pdata.GetTarget() dc.target = pdata.GetTarget()
@ -150,7 +150,7 @@ func channelProtoToStruct(c *pb.Channel) *dummyChannel {
return dc return dc
} }
func serverProtoToStruct(s *pb.Server) *dummyServer { func serverProtoToStruct(s *channelzpb.Server) *dummyServer {
ds := &dummyServer{} ds := &dummyServer{}
pdata := s.GetData() pdata := s.GetData()
ds.callsStarted = pdata.CallsStarted ds.callsStarted = pdata.CallsStarted
@ -164,22 +164,22 @@ func serverProtoToStruct(s *pb.Server) *dummyServer {
return ds return ds
} }
func protoToAddr(a *pb.Address) net.Addr { func protoToAddr(a *channelzpb.Address) net.Addr {
switch v := a.Address.(type) { switch v := a.Address.(type) {
case *pb.Address_TcpipAddress: case *channelzpb.Address_TcpipAddress:
if port := v.TcpipAddress.GetPort(); port != 0 { if port := v.TcpipAddress.GetPort(); port != 0 {
return &net.TCPAddr{IP: v.TcpipAddress.GetIpAddress(), Port: int(port)} return &net.TCPAddr{IP: v.TcpipAddress.GetIpAddress(), Port: int(port)}
} }
return &net.IPAddr{IP: v.TcpipAddress.GetIpAddress()} return &net.IPAddr{IP: v.TcpipAddress.GetIpAddress()}
case *pb.Address_UdsAddress_: case *channelzpb.Address_UdsAddress_:
return &net.UnixAddr{Name: v.UdsAddress.GetFilename(), Net: "unix"} return &net.UnixAddr{Name: v.UdsAddress.GetFilename(), Net: "unix"}
case *pb.Address_OtherAddress_: case *channelzpb.Address_OtherAddress_:
// TODO: // TODO:
} }
return nil return nil
} }
func socketProtoToStruct(s *pb.Socket) *dummySocket { func socketProtoToStruct(s *channelzpb.Socket) *dummySocket {
ds := &dummySocket{} ds := &dummySocket{}
pdata := s.GetData() pdata := s.GetData()
ds.streamsStarted = pdata.GetStreamsStarted() ds.streamsStarted = pdata.GetStreamsStarted()
@ -224,7 +224,7 @@ func socketProtoToStruct(s *pb.Socket) *dummySocket {
return ds return ds
} }
func convertSocketRefSliceToMap(sktRefs []*pb.SocketRef) map[int64]string { func convertSocketRefSliceToMap(sktRefs []*channelzpb.SocketRef) map[int64]string {
m := make(map[int64]string) m := make(map[int64]string)
for _, sr := range sktRefs { for _, sr := range sktRefs {
m[sr.SocketId] = sr.Name m[sr.SocketId] = sr.Name
@ -264,7 +264,7 @@ func TestGetTopChannels(t *testing.T) {
channelz.RegisterChannel(c, 0, "") channelz.RegisterChannel(c, 0, "")
} }
s := newCZServer() s := newCZServer()
resp, _ := s.GetTopChannels(context.Background(), &pb.GetTopChannelsRequest{StartChannelId: 0}) resp, _ := s.GetTopChannels(context.Background(), &channelzpb.GetTopChannelsRequest{StartChannelId: 0})
if !resp.GetEnd() { if !resp.GetEnd() {
t.Fatalf("resp.GetEnd() want true, got %v", 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++ { for i := 0; i < 50; i++ {
channelz.RegisterChannel(tcs[0], 0, "") 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() { if resp.GetEnd() {
t.Fatalf("resp.GetEnd() want false, got %v", resp.GetEnd()) t.Fatalf("resp.GetEnd() want false, got %v", resp.GetEnd())
} }
@ -308,7 +308,7 @@ func TestGetServers(t *testing.T) {
channelz.RegisterServer(s, "") channelz.RegisterServer(s, "")
} }
svr := newCZServer() svr := newCZServer()
resp, _ := svr.GetServers(context.Background(), &pb.GetServersRequest{StartServerId: 0}) resp, _ := svr.GetServers(context.Background(), &channelzpb.GetServersRequest{StartServerId: 0})
if !resp.GetEnd() { if !resp.GetEnd() {
t.Fatalf("resp.GetEnd() want true, got %v", 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++ { for i := 0; i < 50; i++ {
channelz.RegisterServer(ss[0], "") 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() { if resp.GetEnd() {
t.Fatalf("resp.GetEnd() want false, got %v", 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[1] = channelz.RegisterNormalSocket(&dummySocket{}, svrID, refNames[1])
ids[2] = channelz.RegisterNormalSocket(&dummySocket{}, svrID, refNames[2]) ids[2] = channelz.RegisterNormalSocket(&dummySocket{}, svrID, refNames[2])
svr := newCZServer() 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() { if !resp.GetEnd() {
t.Fatalf("resp.GetEnd() want: true, got: %v", 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++ { for i := 0; i < 50; i++ {
channelz.RegisterNormalSocket(&dummySocket{}, svrID, "") 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() { if resp.GetEnd() {
t.Fatalf("resp.GetEnd() want false, got %v", 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[2] = channelz.RegisterSubChannel(&dummyChannel{}, ids[0], refNames[2])
ids[3] = channelz.RegisterChannel(&dummyChannel{}, ids[1], refNames[3]) ids[3] = channelz.RegisterChannel(&dummyChannel{}, ids[1], refNames[3])
svr := newCZServer() 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() metrics := resp.GetChannel()
subChans := metrics.GetSubchannelRef() subChans := metrics.GetSubchannelRef()
if len(subChans) != 1 || subChans[0].GetName() != refNames[2] || subChans[0].GetSubchannelId() != ids[2] { 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() nestedChans := metrics.GetChannelRef()
if len(nestedChans) != 1 || nestedChans[0].GetName() != refNames[1] || nestedChans[0].GetChannelId() != ids[1] { 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() metrics = resp.GetChannel()
nestedChans = metrics.GetChannelRef() nestedChans = metrics.GetChannelRef()
if len(nestedChans) != 1 || nestedChans[0].GetName() != refNames[3] || nestedChans[0].GetChannelId() != ids[3] { 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[2] = channelz.RegisterNormalSocket(&dummySocket{}, ids[1], refNames[2])
ids[3] = channelz.RegisterNormalSocket(&dummySocket{}, ids[1], refNames[3]) ids[3] = channelz.RegisterNormalSocket(&dummySocket{}, ids[1], refNames[3])
svr := newCZServer() 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() metrics := resp.GetSubchannel()
want := map[int64]string{ want := map[int64]string{
ids[2]: refNames[2], ids[2]: refNames[2],
@ -468,10 +468,10 @@ func TestGetSocket(t *testing.T) {
ids[i] = channelz.RegisterNormalSocket(s, svrID, strconv.Itoa(i)) ids[i] = channelz.RegisterNormalSocket(s, svrID, strconv.Itoa(i))
} }
for i, s := range ss { 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() metrics := resp.GetSocket()
if !reflect.DeepEqual(metrics.GetRef(), &pb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}) || !reflect.DeepEqual(socketProtoToStruct(metrics), s) { 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", &pb.SocketRef{SocketId: ids[i], Name: strconv.Itoa(i)}, s, metrics.GetRef(), socketProtoToStruct(metrics)) 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))
} }
} }
} }