def test_many_subchannels(self):
k_channels = 4
self._pairs = _generate_channel_server_pairs(k_channels)
k_success = 17
k_failed = 19
for i in range(k_success):
self._send_successful_unary_unary(0)
self._send_successful_unary_unary(2)
for i in range(k_failed):
self._send_failed_unary_unary(1)
self._send_failed_unary_unary(2)
gtc_resp = self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=0))
self.assertEqual(len(gtc_resp.channel), k_channels)
for i in range(k_channels):
# If no call performed in the channel, there shouldn't be any subchannel
if gtc_resp.channel[i].data.calls_started == 0:
self.assertEqual(len(gtc_resp.channel[i].subchannel_ref), 0)
continue
# Otherwise, the subchannel should exist
self.assertGreater(len(gtc_resp.channel[i].subchannel_ref), 0)
gsc_resp = self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gtc_resp.channel[i].subchannel_ref[0].
subchannel_id))
self.assertEqual(gtc_resp.channel[i].data.calls_started,
gsc_resp.subchannel.data.calls_started)
self.assertEqual(gtc_resp.channel[i].data.calls_succeeded,
gsc_resp.subchannel.data.calls_succeeded)
self.assertEqual(gtc_resp.channel[i].data.calls_failed,
gsc_resp.subchannel.data.calls_failed)
async def bind_channelz(self, channelz_stub):
resp = await channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=0))
for channel in resp.channel:
if channel.data.target == self.address:
self.channel_ref_id = channel.ref.channel_id
resp = await channelz_stub.GetServers(
channelz_pb2.GetServersRequest(start_server_id=0))
self.server_ref_id = resp.server[-1].ref.server_id
async def test_get_top_channels_high_start_id(self):
pairs = await _create_channel_server_pairs(1)
resp = await self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(
start_channel_id=_LARGE_UNASSIGNED_ID))
self.assertEqual(len(resp.channel), 0)
self.assertEqual(resp.end, True)
await _destroy_channel_server_pairs(pairs)
def test_many_subchannels_and_sockets(self):
k_channels = 4
self._pairs = _generate_channel_server_pairs(k_channels)
k_success = 3
k_failed = 5
for i in range(k_success):
self._send_successful_unary_unary(0)
self._send_successful_unary_unary(2)
for i in range(k_failed):
self._send_failed_unary_unary(1)
self._send_failed_unary_unary(2)
gtc_resp = self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=0))
self.assertEqual(len(gtc_resp.channel), k_channels)
for i in range(k_channels):
# If no call performed in the channel, there shouldn't be any subchannel
if gtc_resp.channel[i].data.calls_started == 0:
self.assertEqual(len(gtc_resp.channel[i].subchannel_ref), 0)
continue
# Otherwise, the subchannel should exist
self.assertGreater(len(gtc_resp.channel[i].subchannel_ref), 0)
gsc_resp = self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gtc_resp.channel[i].subchannel_ref[0].
subchannel_id))
self.assertEqual(len(gsc_resp.subchannel.socket_ref), 1)
gs_resp = self._channelz_stub.GetSocket(
channelz_pb2.GetSocketRequest(
socket_id=gsc_resp.subchannel.socket_ref[0].socket_id))
self.assertEqual(gsc_resp.subchannel.data.calls_started,
gs_resp.socket.data.streams_started)
self.assertEqual(gsc_resp.subchannel.data.calls_started,
gs_resp.socket.data.streams_succeeded)
# Calls started == messages sent, only valid for unary calls
self.assertEqual(gsc_resp.subchannel.data.calls_started,
gs_resp.socket.data.messages_sent)
# Only receive responses when the RPC was successful
self.assertEqual(gsc_resp.subchannel.data.calls_succeeded,
gs_resp.socket.data.messages_received)
if gs_resp.socket.remote.HasField("tcpip_address"):
address = gs_resp.socket.remote.tcpip_address.ip_address
self.assertTrue(
len(address) == 4 or len(address) == 16, address)
if gs_resp.socket.local.HasField("tcpip_address"):
address = gs_resp.socket.local.tcpip_address.ip_address
self.assertTrue(
len(address) == 4 or len(address) == 16, address)
def test_many_channel(self):
k_channels = 4
self._pairs = _generate_channel_server_pairs(k_channels)
resp = self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=0))
self.assertEqual(len(resp.channel), k_channels)
def test_get_top_channels_high_start_id(self):
self._pairs = _generate_channel_server_pairs(1)
resp = self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=10000))
self.assertEqual(len(resp.channel), 0)
self.assertEqual(resp.end, True)
def _get_channel_id(self, idx):
"""Channel id may not be consecutive"""
resp = self._channelz_stub.GetTopChannels(
channelz_pb2.GetTopChannelsRequest(start_channel_id=0))
self.assertGreater(len(resp.channel), idx)
return resp.channel[idx].ref.channel_id
def test_has_channelz(self):
stub = channelz_pb2_grpc.ChannelzStub(self._channel)
resp = stub.GetTopChannels(channelz_pb2.GetTopChannelsRequest())
# No exception raised and the response is valid
self.assertGreater(len(resp.channel), 0)
