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

xds interop: update interop client to support new tests (#3737)

Browse Source
This commit is contained in:
Menghan Li
2020-07-27 18:27:21 -07:00
committed by GitHub
parent 7408372e0e
commit 8b7764bddb
4 changed files with 301 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
interop/grpc_testing/test.pb.go
View File

@ -713,6 +713,8 @@ type LoadBalancerStatsResponse struct {
RpcsByPeer map[string]int32 `protobuf:"bytes,1,rep,name=rpcs_by_peer,json=rpcsByPeer,proto3" json:"rpcs_by_peer,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
// The number of RPCs that failed to record a remote peer.
NumFailures int32 `protobuf:"varint,2,opt,name=num_failures,json=numFailures,proto3" json:"num_failures,omitempty"`
// The number of completed RPCs for each method (UnaryCall or EmptyCall).
RpcsByMethod map[string]*LoadBalancerStatsResponse_RpcsByPeer `protobuf:"bytes,3,rep,name=rpcs_by_method,json=rpcsByMethod,proto3" json:"rpcs_by_method,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -757,6 +759,53 @@ func (m *LoadBalancerStatsResponse) GetNumFailures() int32 {
return 0
}
func (m *LoadBalancerStatsResponse) GetRpcsByMethod() map[string]*LoadBalancerStatsResponse_RpcsByPeer {
if m != nil {
return m.RpcsByMethod
}
return nil
}
type LoadBalancerStatsResponse_RpcsByPeer struct {
// The number of completed RPCs for each peer.
RpcsByPeer map[string]int32 `protobuf:"bytes,1,rep,name=rpcs_by_peer,json=rpcsByPeer,proto3" json:"rpcs_by_peer,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) Reset() { *m = LoadBalancerStatsResponse_RpcsByPeer{} }
func (m *LoadBalancerStatsResponse_RpcsByPeer) String() string { return proto.CompactTextString(m) }
func (*LoadBalancerStatsResponse_RpcsByPeer) ProtoMessage() {}
func (*LoadBalancerStatsResponse_RpcsByPeer) Descriptor() ([]byte, []int) {
return fileDescriptor_534063719f48d90d, []int{11, 0}
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer.Unmarshal(m, b)
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer.Marshal(b, m, deterministic)
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) XXX_Merge(src proto.Message) {
xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer.Merge(m, src)
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) XXX_Size() int {
return xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer.Size(m)
}
func (m *LoadBalancerStatsResponse_RpcsByPeer) XXX_DiscardUnknown() {
xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer.DiscardUnknown(m)
}
var xxx_messageInfo_LoadBalancerStatsResponse_RpcsByPeer proto.InternalMessageInfo
func (m *LoadBalancerStatsResponse_RpcsByPeer) GetRpcsByPeer() map[string]int32 {
if m != nil {
return m.RpcsByPeer
}
return nil
}
func init() {
proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
proto.RegisterEnum("grpc.testing.GrpclbRouteType", GrpclbRouteType_name, GrpclbRouteType_value)
@ -772,75 +821,82 @@ func init() {
proto.RegisterType((*StreamingOutputCallResponse)(nil), "grpc.testing.StreamingOutputCallResponse")
proto.RegisterType((*LoadBalancerStatsRequest)(nil), "grpc.testing.LoadBalancerStatsRequest")
proto.RegisterType((*LoadBalancerStatsResponse)(nil), "grpc.testing.LoadBalancerStatsResponse")
proto.RegisterMapType((map[string]*LoadBalancerStatsResponse_RpcsByPeer)(nil), "grpc.testing.LoadBalancerStatsResponse.RpcsByMethodEntry")
proto.RegisterMapType((map[string]int32)(nil), "grpc.testing.LoadBalancerStatsResponse.RpcsByPeerEntry")
proto.RegisterType((*LoadBalancerStatsResponse_RpcsByPeer)(nil), "grpc.testing.LoadBalancerStatsResponse.RpcsByPeer")
proto.RegisterMapType((map[string]int32)(nil), "grpc.testing.LoadBalancerStatsResponse.RpcsByPeer.RpcsByPeerEntry")
}
func init() { proto.RegisterFile("interop/grpc_testing/test.proto", fileDescriptor_534063719f48d90d) }
var fileDescriptor_534063719f48d90d = []byte{
// 1019 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xfd, 0x6e, 0x1b, 0x45,
0x10, 0xcf, 0x39, 0x71, 0x1c, 0x8f, 0x5d, 0xc7, 0xdd, 0xb4, 0x70, 0x71, 0x28, 0x35, 0x07, 0xa2,
0xa6, 0xa8, 0x0e, 0x72, 0xc5, 0x87, 0x2a, 0x15, 0x14, 0x27, 0x4e, 0x88, 0xea, 0xda, 0xe6, 0x1c,
0x83, 0xca, 0x3f, 0xa7, 0xcd, 0x79, 0x72, 0x39, 0x71, 0x5f, 0xec, 0xed, 0x45, 0xb8, 0xff, 0x20,
0xf1, 0x08, 0xbc, 0x02, 0x8f, 0xc1, 0x8b, 0xf0, 0x38, 0x68, 0xf7, 0xee, 0xfc, 0x79, 0x51, 0x13,
0x2a, 0xfa, 0x97, 0x77, 0xe7, 0xe3, 0x37, 0x33, 0xbf, 0x99, 0x1d, 0x1f, 0x3c, 0xb4, 0x3d, 0x8e,
0xcc, 0x0f, 0xf6, 0x2d, 0x16, 0x98, 0x06, 0xc7, 0x90, 0xdb, 0x9e, 0xb5, 0x2f, 0x7e, 0x9b, 0x01,
0xf3, 0xb9, 0x4f, 0xca, 0x42, 0xd1, 0x4c, 0x14, 0x5a, 0x01, 0xf2, 0x1d, 0x37, 0xe0, 0x13, 0xad,
0x0b, 0x85, 0x01, 0x9d, 0x38, 0x3e, 0x1d, 0x93, 0x27, 0xb0, 0xc1, 0x27, 0x01, 0xaa, 0x4a, 0x5d,
0x69, 0x54, 0x5a, 0xbb, 0xcd, 0x79, 0x87, 0x66, 0x62, 0x74, 0x36, 0x09, 0x50, 0x97, 0x66, 0x84,
0xc0, 0xc6, 0xb9, 0x3f, 0x9e, 0xa8, 0xb9, 0xba, 0xd2, 0x28, 0xeb, 0xf2, 0xac, 0x3d, 0x03, 0xe8,
0x98, 0x97, 0xfe, 0x90, 0x53, 0x1e, 0x85, 0xc2, 0xc2, 0xf4, 0xc7, 0x31, 0x60, 0x5e, 0x97, 0x67,
0xa2, 0x42, 0xc1, 0xc5, 0x30, 0xa4, 0x16, 0x4a, 0xc7, 0xa2, 0x9e, 0x5e, 0xb5, 0x3f, 0xd7, 0xe1,
0xce, 0xd0, 0x76, 0x03, 0x07, 0x75, 0xfc, 0x35, 0xc2, 0x90, 0x93, 0x6f, 0xe1, 0x0e, 0xc3, 0x30,
0xf0, 0xbd, 0x10, 0x8d, 0x9b, 0x65, 0x56, 0x4e, 0xed, 0xc5, 0x8d, 0x7c, 0x3c, 0xe7, 0x1f, 0xda,
0xaf, 0xe3, 0x88, 0xf9, 0x99, 0xd1, 0xd0, 0x7e, 0x8d, 0x64, 0x1f, 0x0a, 0x41, 0x8c, 0xa0, 0xae,
0xd7, 0x95, 0x46, 0xa9, 0x75, 0x3f, 0x13, 0x5e, 0x4f, 0xad, 0x04, 0xea, 0x85, 0xed, 0x38, 0x46,
0x14, 0x22, 0xf3, 0xa8, 0x8b, 0xea, 0x46, 0x5d, 0x69, 0x6c, 0xe9, 0x65, 0x21, 0x1c, 0x25, 0x32,
0xd2, 0x80, 0xaa, 0x34, 0xf2, 0x69, 0xc4, 0x2f, 0x8d, 0xd0, 0xf4, 0x03, 0x54, 0xf3, 0xd2, 0xae,
0x22, 0xe4, 0x7d, 0x21, 0x1e, 0x0a, 0x29, 0x39, 0x80, 0xed, 0x59, 0x92, 0x92, 0x37, 0xb5, 0x20,
0xf3, 0x50, 0x17, 0xf3, 0x98, 0xf1, 0xaa, 0x57, 0xa6, 0x05, 0xc4, 0x3c, 0x7f, 0x02, 0x12, 0xd4,
0x08, 0x91, 0x5d, 0x21, 0x33, 0xec, 0xb1, 0x5a, 0x9c, 0xa5, 0x34, 0x94, 0xc2, 0xd3, 0x31, 0x79,
0x0a, 0xef, 0x49, 0x2b, 0x81, 0xea, 0x9c, 0x1b, 0xcc, 0x8f, 0x78, 0x42, 0x2b, 0x48, 0xeb, 0x1d,
0xa1, 0x3d, 0x91, 0x4a, 0x5d, 0xe8, 0x04, 0x85, 0xda, 0x1f, 0x39, 0xa8, 0xa4, 0x4d, 0x89, 0x63,
0xce, 0x13, 0xa6, 0xdc, 0x88, 0xb0, 0x1a, 0x6c, 0x4d, 0xb9, 0x8a, 0x7b, 0x3e, 0xbd, 0x93, 0x87,
0x50, 0x9a, 0xa7, 0x68, 0x5d, 0xaa, 0xc1, 0x9f, 0xd1, 0xb3, 0x07, 0xc5, 0x59, 0x59, 0x1b, 0xb1,
0x77, 0x98, 0x96, 0x74, 0x0a, 0x77, 0x57, 0xab, 0xc9, 0xcb, 0x21, 0x79, 0xb0, 0x98, 0xd4, 0x52,
0x5d, 0xfa, 0xb6, 0xb5, 0x28, 0x10, 0x49, 0x5e, 0xfa, 0x21, 0x97, 0x49, 0x6e, 0xc6, 0x61, 0xd2,
0xbb, 0xd6, 0x85, 0xdd, 0x21, 0x67, 0x48, 0x5d, 0xdb, 0xb3, 0x4e, 0xbd, 0x20, 0xe2, 0x87, 0xd4,
0x71, 0xd2, 0x21, 0xbd, 0x2d, 0x1d, 0xda, 0x19, 0xd4, 0xb2, 0xd0, 0x12, 0x76, 0xbf, 0x82, 0xf7,
0xa9, 0x65, 0x31, 0xb4, 0x28, 0xc7, 0xb1, 0x91, 0xf8, 0xc4, 0xd3, 0x1b, 0x3f, 0xa3, 0xfb, 0x33,
0x75, 0x02, 0x2d, 0xc6, 0x58, 0x3b, 0x05, 0x92, 0x62, 0x0c, 0x28, 0xa3, 0x2e, 0x72, 0x64, 0xf2,
0x05, 0xce, 0xb9, 0xca, 0xb3, 0xa0, 0x5c, 0xee, 0x8a, 0x2b, 0x2a, 0x66, 0x38, 0x79, 0x13, 0x90,
0x8a, 0x46, 0xa1, 0xf6, 0x57, 0x6e, 0x2e, 0xc3, 0x7e, 0xc4, 0x97, 0x0a, 0x7e, 0xdb, 0x57, 0xf9,
0x03, 0xec, 0x4c, 0xfd, 0x83, 0x69, 0xaa, 0x6a, 0xae, 0xbe, 0xde, 0x28, 0xb5, 0xea, 0x8b, 0x28,
0xab, 0x25, 0xe9, 0x84, 0xad, 0x96, 0x79, 0xeb, 0x37, 0xfc, 0xf6, 0x8f, 0x4e, 0xeb, 0xc1, 0x5e,
0x26, 0x49, 0xff, 0xf1, 0x95, 0x68, 0x3f, 0x82, 0xda, 0xf5, 0xe9, 0xb8, 0x4d, 0x1d, 0xea, 0x99,
0xc8, 0x44, 0x94, 0x30, 0xa5, 0x7c, 0x17, 0xb6, 0xbc, 0xc8, 0x35, 0x58, 0x60, 0x86, 0x49, 0x2b,
0x0b, 0x5e, 0xe4, 0xea, 0x81, 0x19, 0x8a, 0x6e, 0x72, 0xdb, 0x45, 0x3f, 0xe2, 0x46, 0x88, 0x66,
0xda, 0xcd, 0x44, 0x34, 0x44, 0x53, 0xfb, 0x47, 0x81, 0xdd, 0x0c, 0xe0, 0x24, 0xcd, 0x57, 0x50,
0x16, 0xa8, 0xc6, 0xf9, 0xc4, 0x08, 0x10, 0x99, 0xaa, 0xc8, 0x2e, 0x7c, 0xbd, 0x98, 0xeb, 0xb5,
0xee, 0x4d, 0x91, 0x42, 0x7b, 0x32, 0x40, 0x64, 0x1d, 0x8f, 0xb3, 0x89, 0x0e, 0x6c, 0x2a, 0x20,
0x1f, 0x41, 0x59, 0x24, 0x7d, 0x41, 0x6d, 0x27, 0x62, 0x98, 0x0e, 0x5a, 0xc9, 0x8b, 0xdc, 0xe3,
0x44, 0x54, 0x7b, 0x0e, 0xdb, 0x4b, 0x08, 0xa4, 0x0a, 0xeb, 0xbf, 0xe0, 0x44, 0x56, 0x59, 0xd4,
0xc5, 0x91, 0xdc, 0x83, 0xfc, 0x15, 0x75, 0xa2, 0x74, 0x7b, 0xc7, 0x97, 0x67, 0xb9, 0x6f, 0x94,
0xc7, 0xdf, 0x41, 0x69, 0x6e, 0xcc, 0x48, 0x15, 0xca, 0x87, 0xfd, 0x97, 0x03, 0xbd, 0x33, 0x1c,
0x1e, 0xb4, 0xbb, 0x9d, 0xea, 0x1a, 0x21, 0x50, 0x19, 0xf5, 0x16, 0x64, 0x0a, 0x01, 0xd8, 0xd4,
0x0f, 0x7a, 0x47, 0xfd, 0x97, 0xd5, 0xdc, 0x63, 0x1f, 0xb6, 0x97, 0x16, 0x03, 0x79, 0x00, 0xbb,
0x27, 0xfa, 0xe0, 0xb0, 0xdb, 0x36, 0xf4, 0xfe, 0xe8, 0xac, 0x63, 0x9c, 0xbd, 0x1a, 0x74, 0x8c,
0x51, 0xef, 0x45, 0xaf, 0xff, 0x53, 0xaf, 0xba, 0x46, 0x3e, 0x84, 0xda, 0xaa, 0xfa, 0xf8, 0xa0,
0xdb, 0x6d, 0x1f, 0x1c, 0xbe, 0xa8, 0x2a, 0xd9, 0xee, 0x42, 0xd7, 0xe9, 0x1d, 0x55, 0x73, 0xad,
0xbf, 0x37, 0xa0, 0x74, 0x86, 0x21, 0x17, 0x4b, 0xd9, 0x36, 0x91, 0x7c, 0x09, 0x45, 0xf9, 0x37,
0x2c, 0x46, 0x87, 0xec, 0x2c, 0xcd, 0x9e, 0x50, 0xd4, 0xb2, 0x84, 0xe4, 0x18, 0x8a, 0x23, 0x8f,
0xb2, 0xd8, 0x6d, 0x6f, 0xd1, 0x62, 0xe1, 0x2f, 0xb4, 0xf6, 0x41, 0xb6, 0x32, 0xe9, 0xbe, 0x03,
0x3b, 0x19, 0x33, 0x4c, 0x1a, 0x4b, 0x4e, 0xd7, 0xee, 0x82, 0xda, 0x67, 0x37, 0xb0, 0x8c, 0x63,
0x7d, 0xa1, 0x10, 0x1b, 0xc8, 0xea, 0xe2, 0x23, 0x8f, 0xae, 0x81, 0x58, 0x5e, 0xb4, 0xb5, 0xc6,
0x9b, 0x0d, 0xe3, 0x50, 0x0d, 0x11, 0xaa, 0x72, 0x1c, 0x39, 0xce, 0x51, 0x14, 0x38, 0xf8, 0xdb,
0xff, 0x56, 0x53, 0x43, 0x91, 0x55, 0x55, 0xbe, 0xa7, 0xce, 0xc5, 0x3b, 0x08, 0xd5, 0x1a, 0xc1,
0xbd, 0x91, 0x27, 0x3b, 0xe8, 0xa2, 0xc7, 0x71, 0x9c, 0x4e, 0xd1, 0x73, 0xb8, 0xbb, 0x20, 0xbf,
0xdd, 0x34, 0xb5, 0x7e, 0xcf, 0xd8, 0x3c, 0x29, 0xb4, 0x09, 0x95, 0x13, 0xe4, 0x87, 0x8e, 0x8d,
0x1e, 0x97, 0x0a, 0xf2, 0xe9, 0x1b, 0x77, 0x43, 0x5c, 0xdb, 0xa3, 0x1b, 0xee, 0x10, 0x6d, 0xad,
0xfd, 0xe4, 0xe7, 0xcf, 0x2d, 0xdf, 0xb7, 0x1c, 0x6c, 0x5a, 0xbe, 0x43, 0x3d, 0xab, 0xe9, 0x33,
0x4b, 0x7e, 0xc7, 0xee, 0x67, 0x7d, 0xd4, 0x9e, 0x6f, 0xca, 0x0f, 0xda, 0xa7, 0xff, 0x06, 0x00,
0x00, 0xff, 0xff, 0xaa, 0x43, 0x4c, 0xeb, 0xf3, 0x0a, 0x00, 0x00,
// 1083 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xdd, 0x72, 0xdb, 0xc4,
0x17, 0x8f, 0x1c, 0x3b, 0x8e, 0x8f, 0x5d, 0xc7, 0xd9, 0xb4, 0xff, 0xbf, 0xe2, 0x50, 0x6a, 0x04,
0x43, 0x4d, 0x99, 0x3a, 0x8c, 0x3b, 0x7c, 0x75, 0xa6, 0x30, 0x71, 0xe2, 0xa4, 0x99, 0x3a, 0xb6,
0x91, 0x63, 0x98, 0x72, 0xa3, 0xd9, 0xc8, 0x1b, 0x45, 0x83, 0xa4, 0x15, 0xab, 0x55, 0x06, 0xf7,
0x86, 0x19, 0x1e, 0x81, 0x57, 0xe0, 0x09, 0xb8, 0xe6, 0x6d, 0x78, 0x12, 0x66, 0x57, 0x92, 0x3f,
0x15, 0x1a, 0x93, 0x81, 0x2b, 0xef, 0x9e, 0xcf, 0xdf, 0xf9, 0x9d, 0x3d, 0xbb, 0x16, 0x3c, 0xb2,
0x3d, 0x4e, 0x18, 0xf5, 0xf7, 0x2d, 0xe6, 0x9b, 0x06, 0x27, 0x01, 0xb7, 0x3d, 0x6b, 0x5f, 0xfc,
0x36, 0x7c, 0x46, 0x39, 0x45, 0x25, 0xa1, 0x68, 0xc4, 0x0a, 0x2d, 0x0f, 0xb9, 0xb6, 0xeb, 0xf3,
0xb1, 0xd6, 0x81, 0x7c, 0x1f, 0x8f, 0x1d, 0x8a, 0x47, 0xe8, 0x29, 0x64, 0xf9, 0xd8, 0x27, 0xaa,
0x52, 0x53, 0xea, 0xe5, 0xe6, 0x6e, 0x63, 0xd6, 0xa1, 0x11, 0x1b, 0x9d, 0x8f, 0x7d, 0xa2, 0x4b,
0x33, 0x84, 0x20, 0x7b, 0x41, 0x47, 0x63, 0x35, 0x53, 0x53, 0xea, 0x25, 0x5d, 0xae, 0xb5, 0xe7,
0x00, 0x6d, 0xf3, 0x8a, 0x0e, 0x38, 0xe6, 0x61, 0x20, 0x2c, 0x4c, 0x3a, 0x8a, 0x02, 0xe6, 0x74,
0xb9, 0x46, 0x2a, 0xe4, 0x5d, 0x12, 0x04, 0xd8, 0x22, 0xd2, 0xb1, 0xa0, 0x27, 0x5b, 0xed, 0xd7,
0x75, 0xb8, 0x37, 0xb0, 0x5d, 0xdf, 0x21, 0x3a, 0xf9, 0x31, 0x24, 0x01, 0x47, 0x5f, 0xc1, 0x3d,
0x46, 0x02, 0x9f, 0x7a, 0x01, 0x31, 0x6e, 0x87, 0xac, 0x94, 0xd8, 0x8b, 0x1d, 0x7a, 0x7f, 0xc6,
0x3f, 0xb0, 0xdf, 0x44, 0x19, 0x73, 0x53, 0xa3, 0x81, 0xfd, 0x86, 0xa0, 0x7d, 0xc8, 0xfb, 0x51,
0x04, 0x75, 0xbd, 0xa6, 0xd4, 0x8b, 0xcd, 0x07, 0xa9, 0xe1, 0xf5, 0xc4, 0x4a, 0x44, 0xbd, 0xb4,
0x1d, 0xc7, 0x08, 0x03, 0xc2, 0x3c, 0xec, 0x12, 0x35, 0x5b, 0x53, 0xea, 0x9b, 0x7a, 0x49, 0x08,
0x87, 0xb1, 0x0c, 0xd5, 0xa1, 0x22, 0x8d, 0x28, 0x0e, 0xf9, 0x95, 0x11, 0x98, 0xd4, 0x27, 0x6a,
0x4e, 0xda, 0x95, 0x85, 0xbc, 0x27, 0xc4, 0x03, 0x21, 0x45, 0x07, 0xb0, 0x35, 0x05, 0x29, 0x79,
0x53, 0xf3, 0x12, 0x87, 0x3a, 0x8f, 0x63, 0xca, 0xab, 0x5e, 0x9e, 0x14, 0x10, 0xf1, 0xfc, 0x01,
0xc8, 0xa0, 0x46, 0x40, 0xd8, 0x35, 0x61, 0x86, 0x3d, 0x52, 0x0b, 0x53, 0x48, 0x03, 0x29, 0x3c,
0x1d, 0xa1, 0x67, 0xf0, 0x3f, 0x69, 0x25, 0xa2, 0x3a, 0x17, 0x06, 0xa3, 0x21, 0x8f, 0x69, 0x05,
0x69, 0xbd, 0x23, 0xb4, 0x27, 0x52, 0xa9, 0x0b, 0x9d, 0xa0, 0x50, 0xfb, 0x25, 0x03, 0xe5, 0xa4,
0x29, 0x51, 0xce, 0x59, 0xc2, 0x94, 0x5b, 0x11, 0x56, 0x85, 0xcd, 0x09, 0x57, 0x51, 0xcf, 0x27,
0x7b, 0xf4, 0x08, 0x8a, 0xb3, 0x14, 0xad, 0x4b, 0x35, 0xd0, 0x29, 0x3d, 0x7b, 0x50, 0x98, 0x96,
0x95, 0x8d, 0xbc, 0x83, 0xa4, 0xa4, 0x53, 0xd8, 0x5e, 0xae, 0x26, 0x27, 0x0f, 0xc9, 0xc3, 0x79,
0x50, 0x0b, 0x75, 0xe9, 0x5b, 0xd6, 0xbc, 0x40, 0x80, 0xbc, 0xa2, 0x01, 0x97, 0x20, 0x37, 0xa2,
0x34, 0xc9, 0x5e, 0xeb, 0xc0, 0xee, 0x80, 0x33, 0x82, 0x5d, 0xdb, 0xb3, 0x4e, 0x3d, 0x3f, 0xe4,
0x87, 0xd8, 0x71, 0x92, 0x43, 0xba, 0x2a, 0x1d, 0xda, 0x39, 0x54, 0xd3, 0xa2, 0xc5, 0xec, 0x7e,
0x06, 0xff, 0xc7, 0x96, 0xc5, 0x88, 0x85, 0x39, 0x19, 0x19, 0xb1, 0x4f, 0x74, 0x7a, 0xa3, 0x31,
0x7a, 0x30, 0x55, 0xc7, 0xa1, 0xc5, 0x31, 0xd6, 0x4e, 0x01, 0x25, 0x31, 0xfa, 0x98, 0x61, 0x97,
0x70, 0xc2, 0xe4, 0x04, 0xce, 0xb8, 0xca, 0xb5, 0xa0, 0x5c, 0xde, 0x15, 0xd7, 0x58, 0x9c, 0xe1,
0x78, 0x26, 0x20, 0x11, 0x0d, 0x03, 0xed, 0xb7, 0xcc, 0x0c, 0xc2, 0x5e, 0xc8, 0x17, 0x0a, 0xbe,
0xeb, 0x54, 0x7e, 0x03, 0x3b, 0x13, 0x7f, 0x7f, 0x02, 0x55, 0xcd, 0xd4, 0xd6, 0xeb, 0xc5, 0x66,
0x6d, 0x3e, 0xca, 0x72, 0x49, 0x3a, 0x62, 0xcb, 0x65, 0xae, 0x3c, 0xc3, 0x77, 0x1f, 0x3a, 0xad,
0x0b, 0x7b, 0xa9, 0x24, 0xfd, 0xc3, 0x29, 0xd1, 0xbe, 0x05, 0xb5, 0x43, 0xf1, 0xa8, 0x85, 0x1d,
0xec, 0x99, 0x84, 0x89, 0x2c, 0x41, 0x42, 0xf9, 0x2e, 0x6c, 0x7a, 0xa1, 0x6b, 0x30, 0xdf, 0x0c,
0xe2, 0x56, 0xe6, 0xbd, 0xd0, 0xd5, 0x7d, 0x33, 0x10, 0xdd, 0xe4, 0xb6, 0x4b, 0x68, 0xc8, 0x8d,
0x80, 0x98, 0x49, 0x37, 0x63, 0xd1, 0x80, 0x98, 0xda, 0x9f, 0x59, 0xd8, 0x4d, 0x09, 0x1c, 0xc3,
0x7c, 0x0d, 0x25, 0x11, 0xd5, 0xb8, 0x18, 0x1b, 0x3e, 0x21, 0x4c, 0x55, 0x64, 0x17, 0x3e, 0x9f,
0xc7, 0x7a, 0xa3, 0x7b, 0x43, 0x40, 0x68, 0x8d, 0xfb, 0x84, 0xb0, 0xb6, 0xc7, 0xd9, 0x58, 0x07,
0x36, 0x11, 0xa0, 0xf7, 0xa0, 0x24, 0x40, 0x5f, 0x62, 0xdb, 0x09, 0x19, 0x49, 0x0e, 0x5a, 0xd1,
0x0b, 0xdd, 0xe3, 0x58, 0x84, 0x0c, 0x28, 0x27, 0xd9, 0x5d, 0xc2, 0xaf, 0xa8, 0x68, 0x9f, 0xc8,
0xff, 0xe5, 0x6a, 0xf9, 0xcf, 0xa4, 0x6f, 0x84, 0xa0, 0xc4, 0x66, 0x44, 0xd5, 0xdf, 0x15, 0x80,
0x29, 0x46, 0x34, 0x4a, 0xad, 0xb6, 0xb5, 0x7a, 0xb5, 0x7f, 0x57, 0x78, 0xf5, 0x05, 0x6c, 0x2d,
0xa8, 0x51, 0x05, 0xd6, 0x7f, 0x20, 0x63, 0xd9, 0xbb, 0x82, 0x2e, 0x96, 0xe8, 0x3e, 0xe4, 0xae,
0xb1, 0x13, 0x26, 0x6f, 0x52, 0xb4, 0x79, 0x9e, 0xf9, 0x42, 0xb9, 0xab, 0x7b, 0x00, 0xdb, 0x4b,
0xac, 0xa4, 0x04, 0x78, 0x39, 0x1b, 0xa0, 0xd8, 0x6c, 0xae, 0xce, 0xc1, 0x4c, 0xd2, 0x27, 0x5f,
0x43, 0x71, 0x66, 0xe0, 0x51, 0x05, 0x4a, 0x87, 0xbd, 0xb3, 0xbe, 0xde, 0x1e, 0x0c, 0x0e, 0x5a,
0x9d, 0x76, 0x65, 0x0d, 0x21, 0x28, 0x0f, 0xbb, 0x73, 0x32, 0x05, 0x01, 0x6c, 0xe8, 0x07, 0xdd,
0xa3, 0xde, 0x59, 0x25, 0xf3, 0x84, 0xc2, 0xd6, 0xc2, 0x15, 0x8d, 0x1e, 0xc2, 0xee, 0x89, 0xde,
0x3f, 0xec, 0xb4, 0x0c, 0xbd, 0x37, 0x3c, 0x6f, 0x1b, 0xe7, 0xaf, 0xfb, 0x6d, 0x63, 0xd8, 0x7d,
0xd5, 0xed, 0x7d, 0xd7, 0xad, 0xac, 0xa1, 0x77, 0xa1, 0xba, 0xac, 0x3e, 0x3e, 0xe8, 0x74, 0x5a,
0x07, 0x87, 0xaf, 0x2a, 0x4a, 0xba, 0xbb, 0xd0, 0xb5, 0xbb, 0x47, 0x95, 0x4c, 0xf3, 0x8f, 0x2c,
0x14, 0xcf, 0x49, 0xc0, 0xc5, 0xf3, 0x68, 0x9b, 0x04, 0x7d, 0x0a, 0x05, 0xf9, 0x87, 0x48, 0x0c,
0x31, 0xda, 0x59, 0xb8, 0x05, 0x84, 0xa2, 0x9a, 0x26, 0x44, 0xc7, 0x50, 0x18, 0x7a, 0x98, 0x45,
0x6e, 0x7b, 0xf3, 0x16, 0x73, 0x7f, 0x66, 0xaa, 0xef, 0xa4, 0x2b, 0xe3, 0x39, 0x74, 0x60, 0x27,
0xe5, 0x36, 0x41, 0xf5, 0x05, 0xa7, 0x1b, 0x6f, 0xe5, 0xea, 0x47, 0xb7, 0xb0, 0x8c, 0x72, 0x7d,
0xa2, 0x20, 0x1b, 0xd0, 0xf2, 0x13, 0x84, 0x1e, 0xdf, 0x10, 0x62, 0xf1, 0xc9, 0xab, 0xd6, 0xdf,
0x6e, 0x18, 0xa5, 0xaa, 0x8b, 0x54, 0xe5, 0xe3, 0xd0, 0x71, 0x8e, 0x42, 0xdf, 0x21, 0x3f, 0xfd,
0x6b, 0x35, 0xd5, 0x15, 0x59, 0x55, 0xf9, 0x25, 0x76, 0x2e, 0xff, 0x83, 0x54, 0xcd, 0x21, 0xdc,
0x1f, 0x7a, 0xb2, 0x83, 0x2e, 0xf1, 0x38, 0x19, 0x25, 0xa7, 0xe8, 0x05, 0x6c, 0xcf, 0xc9, 0x57,
0x3b, 0x4d, 0xcd, 0x9f, 0x53, 0xde, 0x80, 0x24, 0xb4, 0x09, 0xe5, 0x13, 0xc2, 0x0f, 0x1d, 0x9b,
0x78, 0x5c, 0x2a, 0xd0, 0x87, 0x6f, 0x9d, 0xd9, 0xa8, 0xb6, 0xc7, 0xb7, 0x9c, 0x6d, 0x6d, 0xad,
0xf5, 0xf4, 0xfb, 0x8f, 0x2d, 0x4a, 0x2d, 0x87, 0x34, 0x2c, 0xea, 0x60, 0xcf, 0x6a, 0x50, 0x66,
0xc9, 0x2f, 0x8a, 0xfd, 0xb4, 0xcf, 0x8b, 0x8b, 0x0d, 0xf9, 0x69, 0xf1, 0xec, 0xaf, 0x00, 0x00,
0x00, 0xff, 0xff, 0x8c, 0x0b, 0x8c, 0x16, 0x7d, 0x0c, 0x00, 0x00,
}

7
interop/grpc_testing/test.proto
View File

@ -214,10 +214,17 @@ message LoadBalancerStatsRequest {
}
message LoadBalancerStatsResponse {
message RpcsByPeer {
// The number of completed RPCs for each peer.
map<string, int32> rpcs_by_peer = 1;
}
// The number of completed RPCs for each peer.
map<string, int32> rpcs_by_peer = 1;
// The number of RPCs that failed to record a remote peer.
int32 num_failures = 2;
// The number of completed RPCs for each method (UnaryCall or EmptyCall).
map<string, RpcsByPeer> rpcs_by_method = 3;
}
// A service used to obtain stats for verifying LB behavior.

178
interop/xds/client/client.go
View File

@ -23,13 +23,16 @@ import (
"context"
"flag"
"fmt"
"log"
"net"
"strings"
"sync"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/grpclog"
testpb "google.golang.org/grpc/interop/grpc_testing"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/peer"
_ "google.golang.org/grpc/xds"
)
@ -39,18 +42,43 @@ type statsWatcherKey struct {
endID int32
}
// rpcInfo contains the rpc type and the hostname where the response is received
// from.
type rpcInfo struct {
typ string
hostname string
}
type statsWatcher struct {
rpcsByPeer map[string]int32
rpcsByType map[string]map[string]int32
numFailures int32
remainingRpcs int32
c chan *testpb.SimpleResponse
chanHosts chan *rpcInfo
}
func (watcher *statsWatcher) buildResp() *testpb.LoadBalancerStatsResponse {
rpcsByType := make(map[string]*testpb.LoadBalancerStatsResponse_RpcsByPeer, len(watcher.rpcsByType))
for t, rpcsByPeer := range watcher.rpcsByType {
rpcsByType[t] = &testpb.LoadBalancerStatsResponse_RpcsByPeer{
RpcsByPeer: rpcsByPeer,
}
}
return &testpb.LoadBalancerStatsResponse{
NumFailures: watcher.numFailures + watcher.remainingRpcs,
RpcsByPeer: watcher.rpcsByPeer,
RpcsByMethod: rpcsByType,
}
}
var (
failOnFailedRPC = flag.Bool("fail_on_failed_rpc", false, "Fail client if any RPCs fail")
numChannels = flag.Int("num_channels", 1, "Num of channels")
printResponse = flag.Bool("print_response", false, "Write RPC response to stdout")
qps = flag.Int("qps", 1, "QPS per channel")
qps = flag.Int("qps", 1, "QPS per channel, for each type of RPC")
rpc = flag.String("rpc", "UnaryCall", "Types of RPCs to make, ',' separated string. RPCs can be EmptyCall or UnaryCall")
rpcMetadata = flag.String("metadata", "", "The metadata to send with RPC, in format EmptyCall:key1:value1,UnaryCall:key2:value2")
rpcTimeout = flag.Duration("rpc_timeout", 20*time.Second, "Per RPC timeout")
server = flag.String("server", "localhost:8080", "Address of server to connect to")
statsPort = flag.Int("stats_port", 8081, "Port to expose peer distribution stats service")
@ -75,9 +103,10 @@ func (s *statsService) GetClientStats(ctx context.Context, in *testpb.LoadBalanc
if !ok {
watcher = &statsWatcher{
rpcsByPeer: make(map[string]int32),
rpcsByType: make(map[string]map[string]int32),
numFailures: 0,
remainingRpcs: in.GetNumRpcs(),
c: make(chan *testpb.SimpleResponse),
chanHosts: make(chan *rpcInfo),
}
watchers[watcherKey] = watcher
}
@ -95,25 +124,86 @@ func (s *statsService) GetClientStats(ctx context.Context, in *testpb.LoadBalanc
// Wait until the requested RPCs have all been recorded or timeout occurs.
for {
select {
case r := <-watcher.c:
if r != nil {
watcher.rpcsByPeer[(*r).GetHostname()]++
case info := <-watcher.chanHosts:
if info != nil {
watcher.rpcsByPeer[info.hostname]++
rpcsByPeerForType := watcher.rpcsByType[info.typ]
if rpcsByPeerForType == nil {
rpcsByPeerForType = make(map[string]int32)
watcher.rpcsByType[info.typ] = rpcsByPeerForType
}
rpcsByPeerForType[info.hostname]++
} else {
watcher.numFailures++
}
watcher.remainingRpcs--
if watcher.remainingRpcs == 0 {
return &testpb.LoadBalancerStatsResponse{NumFailures: watcher.numFailures + watcher.remainingRpcs, RpcsByPeer: watcher.rpcsByPeer}, nil
return watcher.buildResp(), nil
}
case <-ctx.Done():
grpclog.Info("Timed out, returning partial stats")
return &testpb.LoadBalancerStatsResponse{NumFailures: watcher.numFailures + watcher.remainingRpcs, RpcsByPeer: watcher.rpcsByPeer}, nil
return watcher.buildResp(), nil
}
}
}
const (
unaryCall string = "UnaryCall"
emptyCall string = "EmptyCall"
)
func parseRPCTypes(rpcStr string) (ret []string) {
if len(rpcStr) == 0 {
return []string{unaryCall}
}
rpcs := strings.Split(rpcStr, ",")
for _, r := range rpcs {
switch r {
case unaryCall, emptyCall:
ret = append(ret, r)
default:
flag.PrintDefaults()
log.Fatalf("unsupported RPC type: %v", r)
}
}
return
}
type rpcConfig struct {
typ string
md metadata.MD
}
// parseRPCMetadata turns EmptyCall:key1:value1 into
// {typ: emptyCall, md: {key1:value1}}.
func parseRPCMetadata(rpcMetadataStr string, rpcs []string) []*rpcConfig {
rpcMetadataSplit := strings.Split(rpcMetadataStr, ",")
rpcsToMD := make(map[string][]string)
for _, rm := range rpcMetadataSplit {
rmSplit := strings.Split(rm, ":")
if len(rmSplit)%2 != 1 {
log.Fatalf("invalid metadata config %v, want EmptyCall:key1:value1", rm)
}
rpcsToMD[rmSplit[0]] = append(rpcsToMD[rmSplit[0]], rmSplit[1:]...)
}
ret := make([]*rpcConfig, 0, len(rpcs))
for _, rpcT := range rpcs {
rpcC := &rpcConfig{
typ: rpcT,
}
if md := rpcsToMD[string(rpcT)]; len(md) > 0 {
rpcC.md = metadata.Pairs(md...)
}
ret = append(ret, rpcC)
}
return ret
}
func main() {
flag.Parse()
rpcCfgs := parseRPCMetadata(*rpcMetadata, parseRPCTypes(*rpc))
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *statsPort))
if err != nil {
@ -135,16 +225,52 @@ func main() {
}
ticker := time.NewTicker(time.Second / time.Duration(*qps**numChannels))
defer ticker.Stop()
sendRPCs(clients, ticker)
sendRPCs(clients, rpcCfgs, ticker)
}
func sendRPCs(clients []testpb.TestServiceClient, ticker *time.Ticker) {
func makeOneRPC(c testpb.TestServiceClient, cfg *rpcConfig) (*peer.Peer, *rpcInfo, error) {
ctx, cancel := context.WithTimeout(context.Background(), *rpcTimeout)
defer cancel()
if len(cfg.md) != 0 {
ctx = metadata.NewOutgoingContext(ctx, cfg.md)
}
info := rpcInfo{typ: cfg.typ}
var (
p peer.Peer
header metadata.MD
err error
)
switch cfg.typ {
case unaryCall:
var resp *testpb.SimpleResponse
resp, err = c.UnaryCall(ctx, &testpb.SimpleRequest{FillServerId: true}, grpc.Peer(&p), grpc.Header(&header))
// For UnaryCall, also read hostname from response, in case the server
// isn't updated to send headers.
if resp != nil {
info.hostname = resp.Hostname
}
case emptyCall:
_, err = c.EmptyCall(ctx, &testpb.Empty{}, grpc.Peer(&p), grpc.Header(&header))
}
if err != nil {
return nil, nil, err
}
hosts := header["hostname"]
if len(hosts) > 0 {
info.hostname = hosts[0]
}
return &p, &info, err
}
func sendRPCs(clients []testpb.TestServiceClient, cfgs []*rpcConfig, ticker *time.Ticker) {
var i int
for range ticker.C {
go func(i int) {
c := clients[i]
ctx, cancel := context.WithTimeout(context.Background(), *rpcTimeout)
p := new(peer.Peer)
// Get and increment request ID, and save a list of watchers that
// are interested in this RPC.
mu.Lock()
savedRequestID := currentRequestID
currentRequestID++
@ -155,20 +281,32 @@ func sendRPCs(clients []testpb.TestServiceClient, ticker *time.Ticker) {
}
}
mu.Unlock()
r, err := c.UnaryCall(ctx, &testpb.SimpleRequest{FillServerId: true}, grpc.Peer(p))
success := err == nil
cancel()
c := clients[i]
for _, cfg := range cfgs {
p, info, err := makeOneRPC(c, cfg)
for _, watcher := range savedWatchers {
watcher.c <- r
// This sends an empty string if the RPC failed.
watcher.chanHosts <- info
}
if err != nil && *failOnFailedRPC {
grpclog.Fatalf("RPC failed: %v", err)
}
if success && *printResponse {
fmt.Printf("Greeting: Hello world, this is %s, from %v\n", r.GetHostname(), p.Addr)
if *printResponse {
if err == nil {
if cfg.typ == unaryCall {
// Need to keep this format, because some tests are
// relying on stdout.
fmt.Printf("Greeting: Hello world, this is %s, from %v\n", info.hostname, p.Addr)
} else {
fmt.Printf("RPC %q, from host %s, addr %v\n", cfg.typ, info.hostname, p.Addr)
}
} else {
fmt.Printf("RPC %q, failed with %v\n", cfg.typ, err)
}
}
}
}(i)
i = (i + 1) % len(clients)

7
interop/xds/server/server.go
View File

@ -30,6 +30,7 @@ import (
"google.golang.org/grpc"
"google.golang.org/grpc/grpclog"
testpb "google.golang.org/grpc/interop/grpc_testing"
"google.golang.org/grpc/metadata"
)
var (
@ -50,7 +51,13 @@ type server struct {
testpb.UnimplementedTestServiceServer
}
func (s *server) EmptyCall(ctx context.Context, _ *testpb.Empty) (*testpb.Empty, error) {
grpc.SetHeader(ctx, metadata.Pairs("hostname", hostname))
return &testpb.Empty{}, nil
}
func (s *server) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
grpc.SetHeader(ctx, metadata.Pairs("hostname", hostname))
return &testpb.SimpleResponse{ServerId: *serverID, Hostname: hostname}, nil
}