"port_name": 'Port Name',
"Frames_Tx": 'Frames Tx.',
"Valid_Frames_Rx": 'Valid Frames Rx.',
- "Frames_Tx_Rate": 'Frames Tx. Rate',
- "Valid_Frames_Rx_Rate": 'Valid Frames Rx. Rate',
- "Tx_Rate_Kbps": 'Tx. Rate (Kbps)',
- "Rx_Rate_Kbps": 'Rx. Rate (Kbps)',
- "Tx_Rate_Mbps": 'Tx. Rate (Mbps)',
- "Rx_Rate_Mbps": 'Rx. Rate (Mbps)',
"Bytes_Tx": 'Bytes Tx.',
"Bytes_Rx": 'Bytes Rx.'
}
num_ifaces = len(samples)
duration = self.config.duration
in_packets_sum = sum(
- [samples[iface]['in_packets'] for iface in samples])
+ [samples[iface]['InPackets'] for iface in samples])
out_packets_sum = sum(
- [samples[iface]['out_packets'] for iface in samples])
+ [samples[iface]['OutPackets'] for iface in samples])
in_bytes_sum = sum(
- [samples[iface]['in_bytes'] for iface in samples])
+ [samples[iface]['InBytes'] for iface in samples])
out_bytes_sum = sum(
- [samples[iface]['out_bytes'] for iface in samples])
+ [samples[iface]['OutBytes'] for iface in samples])
rx_throughput = round(float(in_packets_sum) / duration, 3)
tx_throughput = round(float(out_packets_sum) / duration, 3)
# Rx throughput in Bps
"completed=%s", tolerance, precision, drop_percent,
completed)
- latency_ns_avg = float(
- sum([samples[iface]['Store-Forward_Avg_latency_ns']
- for iface in samples])) / num_ifaces
- latency_ns_min = float(
- sum([samples[iface]['Store-Forward_Min_latency_ns']
- for iface in samples])) / num_ifaces
- latency_ns_max = float(
- sum([samples[iface]['Store-Forward_Max_latency_ns']
- for iface in samples])) / num_ifaces
+ latency_ns_avg = float(sum(
+ [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+ latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+ latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
samples['Status'] = self.STATUS_FAIL
if round(drop_percent, precision) <= tolerance:
samples['TxThroughputBps'] = tx_throughput_bps
samples['RxThroughputBps'] = rx_throughput_bps
samples['DropPercentage'] = drop_percent
- samples['latency_ns_avg'] = latency_ns_avg
- samples['latency_ns_min'] = latency_ns_min
- samples['latency_ns_max'] = latency_ns_max
+ samples['LatencyAvg'] = latency_ns_avg
+ samples['LatencyMin'] = latency_ns_min
+ samples['LatencyMax'] = latency_ns_max
samples['Rate'] = last_rate
samples['PktSize'] = self._get_framesize()
samples['Iteration'] = self.iteration
drop_percent = 100
for prio_id in stats:
prio_flow = stats[prio_id]
- sum_packet_drop = abs(prio_flow['out_packets'] - prio_flow['in_packets'])
+ sum_packet_drop = abs(prio_flow['OutPackets'] - prio_flow['InPackets'])
try:
drop_percent = round(
- (sum_packet_drop / float(prio_flow['out_packets'])) * 100,
+ (sum_packet_drop / float(prio_flow['OutPackets'])) * 100,
self.DROP_PERCENT_ROUND)
except ZeroDivisionError:
LOG.info('No traffic is flowing')
def _get_summary_pppoe_subs_counters(self, samples):
result = {}
- keys = ['sessions_up',
- 'sessions_down',
- 'sessions_not_started',
- 'sessions_total']
+ keys = ['SessionsUp',
+ 'SessionsDown',
+ 'SessionsNotStarted',
+ 'SessionsTotal']
for key in keys:
result[key] = \
sum([samples[port][key] for port in samples
priority_stats = self._get_prio_flows_drop_percentage(priority_stats)
summary_subs_stats = self._get_summary_pppoe_subs_counters(samples)
in_packets_sum = sum(
- [samples[iface]['in_packets'] for iface in samples])
+ [samples[iface]['InPackets'] for iface in samples])
out_packets_sum = sum(
- [samples[iface]['out_packets'] for iface in samples])
+ [samples[iface]['OutPackets'] for iface in samples])
in_bytes_sum = sum(
- [samples[iface]['in_bytes'] for iface in samples])
+ [samples[iface]['InBytes'] for iface in samples])
out_bytes_sum = sum(
- [samples[iface]['out_bytes'] for iface in samples])
+ [samples[iface]['OutBytes'] for iface in samples])
rx_throughput = round(float(in_packets_sum) / duration, 3)
tx_throughput = round(float(out_packets_sum) / duration, 3)
# Rx throughput in Bps
except ZeroDivisionError:
LOG.info('No traffic is flowing')
- latency_ns_avg = float(
- sum([samples[iface]['Store-Forward_Avg_latency_ns']
- for iface in samples])) / num_ifaces
- latency_ns_min = float(
- sum([samples[iface]['Store-Forward_Min_latency_ns']
- for iface in samples])) / num_ifaces
- latency_ns_max = float(
- sum([samples[iface]['Store-Forward_Max_latency_ns']
- for iface in samples])) / num_ifaces
+ latency_ns_avg = float(sum(
+ [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+ latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+ latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
samples['TxThroughput'] = tx_throughput
samples['RxThroughput'] = rx_throughput
samples['TxThroughputBps'] = tx_throughput_bps
samples['RxThroughputBps'] = rx_throughput_bps
samples['DropPercentage'] = sum_drop_percent
- samples['latency_ns_avg'] = latency_ns_avg
- samples['latency_ns_min'] = latency_ns_min
- samples['latency_ns_max'] = latency_ns_max
- samples['priority'] = priority_stats
+ samples['LatencyAvg'] = latency_ns_avg
+ samples['LatencyMin'] = latency_ns_min
+ samples['LatencyMax'] = latency_ns_max
+ samples['Priority'] = priority_stats
samples['Rate'] = last_rate
samples['PktSize'] = self._get_framesize()
samples['Iteration'] = self.iteration
if tc_rfc2544_opts:
priority = tc_rfc2544_opts.get('priority')
if priority:
- drop_percent = samples['priority'][priority]['DropPercentage']
+ drop_percent = samples['Priority'][priority]['DropPercentage']
else:
drop_percent = sum_drop_percent
else:
self.rate = self.config.frame_rate
self.max_rate = self.config.frame_rate
self.min_rate = 0
- self.drop_percent_max = 0
def register_generator(self, generator):
self.generator = generator
return streams
def get_drop_percentage(self, samples, tol_low, tol_high,
- correlated_traffic, resolution):
+ correlated_traffic, resolution): # pylint: disable=unused-argument
"""Calculate the drop percentage and run the traffic"""
completed = False
status = self.STATUS_FAIL
LOG.debug("rate=%s, next_rate=%s, resolution=%s, completed=%s",
last_rate, self.rate, resolution, completed)
- throughput = rx_rate_fps * 2 if correlated_traffic else rx_rate_fps
-
- if drop_percent > self.drop_percent_max:
- self.drop_percent_max = drop_percent
-
- latency = {port_num: value['latency']
- for port_num, value in samples[-1].items()}
-
- output = {
- 'TxThroughput': tx_rate_fps,
- 'RxThroughput': rx_rate_fps,
- 'RxThroughputBps': round(float(in_bytes) / time_diff, 3),
- 'TxThroughputBps': round(float(out_bytes) / time_diff, 3),
- 'CurrentDropPercentage': drop_percent,
- 'Throughput': throughput,
- 'DropPercentage': self.drop_percent_max,
- 'Rate': last_rate,
- 'Latency': latency,
- 'PktSize': self._get_framesize(),
- 'Iteration': self.iteration,
- 'Status': status
- }
+ ports = samples[-1].keys()
+ num_ports = len(ports)
+
+ output = {}
+ for port in ports:
+ output[port] = {}
+ first = samples[0][port]
+ last = samples[-1][port]
+ output[port]['InPackets'] = last['in_packets'] - first['in_packets']
+ output[port]['OutPackets'] = last['out_packets'] - first['out_packets']
+ output[port]['InBytes'] = last['in_bytes'] - first['in_bytes']
+ output[port]['OutBytes'] = last['out_bytes'] - first['out_bytes']
+ if self.config.enable_latency:
+ output[port]['LatencyAvg'] = float(sum(
+ [last['latency'][id]['average'] for id in
+ last['latency']]) * 1000) / len(last['latency'])
+ output[port]['LatencyMin'] = min(
+ [last['latency'][id]['total_min'] for id in
+ last['latency']]) * 1000
+ output[port]['LatencyMax'] = max(
+ [last['latency'][id]['total_max'] for id in
+ last['latency']]) * 1000
+
+ output['TxThroughput'] = tx_rate_fps
+ output['RxThroughput'] = rx_rate_fps
+ output['RxThroughputBps'] = round(float(in_bytes) / time_diff, 3)
+ output['TxThroughputBps'] = round(float(out_bytes) / time_diff, 3)
+ output['DropPercentage'] = drop_percent
+ output['Rate'] = last_rate
+ output['PktSize'] = self._get_framesize()
+ output['Iteration'] = self.iteration
+ output['Status'] = status
+
+ if self.config.enable_latency:
+ output['LatencyAvg'] = float(
+ sum([output[port]['LatencyAvg'] for port in ports])) / num_ports
+ output['LatencyMin'] = min([output[port]['LatencyMin'] for port in ports])
+ output['LatencyMax'] = max([output[port]['LatencyMax'] for port in ports])
+
return completed, output
min_latency = stats['Store-Forward_Min_latency_ns'][port_num]
max_latency = stats['Store-Forward_Max_latency_ns'][port_num]
samples[port_name] = {
- 'rx_throughput_kps': float(stats['Rx_Rate_Kbps'][port_num]),
- 'tx_throughput_kps': float(stats['Tx_Rate_Kbps'][port_num]),
- 'rx_throughput_mbps': float(stats['Rx_Rate_Mbps'][port_num]),
- 'tx_throughput_mbps': float(stats['Tx_Rate_Mbps'][port_num]),
'RxThroughputBps': float(stats['Bytes_Rx'][port_num]) / duration,
'TxThroughputBps': float(stats['Bytes_Tx'][port_num]) / duration,
- 'in_packets': int(stats['Valid_Frames_Rx'][port_num]),
- 'out_packets': int(stats['Frames_Tx'][port_num]),
- 'in_bytes': int(stats['Bytes_Rx'][port_num]),
- 'out_bytes': int(stats['Bytes_Tx'][port_num]),
+ 'InPackets': int(stats['Valid_Frames_Rx'][port_num]),
+ 'OutPackets': int(stats['Frames_Tx'][port_num]),
+ 'InBytes': int(stats['Bytes_Rx'][port_num]),
+ 'OutBytes': int(stats['Bytes_Tx'][port_num]),
'RxThroughput': float(stats['Valid_Frames_Rx'][port_num]) / duration,
'TxThroughput': float(stats['Frames_Tx'][port_num]) / duration,
- 'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
- 'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
- 'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+ 'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+ 'LatencyMin': utils.safe_cast(min_latency, int, 0),
+ 'LatencyMax': utils.safe_cast(max_latency, int, 0)
}
except IndexError:
pass
avg_latency_ns = sum(
[int(flow['Store-Forward_Avg_latency_ns']) for flow in samples
if flow['IP_Priority'] == priority]) / prio_flows_num
- min_latency_ns = sum(
+ min_latency_ns = min(
[int(flow['Store-Forward_Min_latency_ns']) for flow in samples
- if flow['IP_Priority'] == priority]) / prio_flows_num
- max_latency_ns = sum(
+ if flow['IP_Priority'] == priority])
+ max_latency_ns = max(
[int(flow['Store-Forward_Max_latency_ns']) for flow in samples
- if flow['IP_Priority'] == priority]) / prio_flows_num
+ if flow['IP_Priority'] == priority])
tx_throughput = float(tx_frames) / duration
rx_throughput = float(rx_frames) / duration
results[priority] = {
- 'in_packets': rx_frames,
- 'out_packets': tx_frames,
+ 'InPackets': rx_frames,
+ 'OutPackets': tx_frames,
'RxThroughput': round(rx_throughput, 3),
'TxThroughput': round(tx_throughput, 3),
- 'avg_latency_ns': utils.safe_cast(avg_latency_ns, int, 0),
- 'min_latency_ns': utils.safe_cast(min_latency_ns, int, 0),
- 'max_latency_ns': utils.safe_cast(max_latency_ns, int, 0)
+ 'LatencyAvg': utils.safe_cast(avg_latency_ns, int, 0),
+ 'LatencyMin': utils.safe_cast(min_latency_ns, int, 0),
+ 'LatencyMax': utils.safe_cast(max_latency_ns, int, 0)
}
return results
flows_stats, flow, 'Store-Forward_Avg_latency_ns'))
for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
min_latency = \
- sum([float(self.get_flow_id_data(
+ min([float(self.get_flow_id_data(
flows_stats, flow, 'Store-Forward_Min_latency_ns'))
- for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+ for flow in port_flow_map[port_num]])
max_latency = \
- sum([float(self.get_flow_id_data(
+ max([float(self.get_flow_id_data(
flows_stats, flow, 'Store-Forward_Max_latency_ns'))
- for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+ for flow in port_flow_map[port_num]])
samples[port_name] = {
- 'rx_throughput_kps': float(ports_stats[port_num]['Rx_Rate_Kbps']),
- 'tx_throughput_kps': float(ports_stats[port_num]['Tx_Rate_Kbps']),
- 'rx_throughput_mbps': float(ports_stats[port_num]['Rx_Rate_Mbps']),
- 'tx_throughput_mbps': float(ports_stats[port_num]['Tx_Rate_Mbps']),
'RxThroughputBps': float(ports_stats[port_num]['Bytes_Rx']) / duration,
'TxThroughputBps': float(ports_stats[port_num]['Bytes_Tx']) / duration,
- 'in_packets': int(ports_stats[port_num]['Valid_Frames_Rx']),
- 'out_packets': int(ports_stats[port_num]['Frames_Tx']),
- 'in_bytes': int(ports_stats[port_num]['Bytes_Rx']),
- 'out_bytes': int(ports_stats[port_num]['Bytes_Tx']),
+ 'InPackets': int(ports_stats[port_num]['Valid_Frames_Rx']),
+ 'OutPackets': int(ports_stats[port_num]['Frames_Tx']),
+ 'InBytes': int(ports_stats[port_num]['Bytes_Rx']),
+ 'OutBytes': int(ports_stats[port_num]['Bytes_Tx']),
'RxThroughput': float(ports_stats[port_num]['Valid_Frames_Rx']) / duration,
'TxThroughput': float(ports_stats[port_num]['Frames_Tx']) / duration,
- 'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
- 'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
- 'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+ 'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+ 'LatencyMin': utils.safe_cast(min_latency, int, 0),
+ 'LatencyMax': utils.safe_cast(max_latency, int, 0)
}
if port_subs_stats:
samples[port_name].update(
- {'sessions_up': int(port_subs_stats[0]['Sessions_Up']),
- 'sessions_down': int(port_subs_stats[0]['Sessions_Down']),
- 'sessions_not_started': int(port_subs_stats[0]['Sessions_Not_Started']),
- 'sessions_total': int(port_subs_stats[0]['Sessions_Total'])}
+ {'SessionsUp': int(port_subs_stats[0]['Sessions_Up']),
+ 'SessionsDown': int(port_subs_stats[0]['Sessions_Down']),
+ 'SessionsNotStarted': int(port_subs_stats[0]['Sessions_Not_Started']),
+ 'SessionsTotal': int(port_subs_stats[0]['Sessions_Total'])}
)
except IndexError:
def test_get_drop_percentage_completed(self):
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 23,
- 'Store-Forward_Min_latency_ns': 13,
- 'Store-Forward_Max_latency_ns': 28}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 23,
+ 'LatencyMin': 13,
+ 'LatencyMax': 28}
}
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile.rate = 100.0
self.assertEqual(66.9, samples['TxThroughput'])
self.assertEqual(66.833, samples['RxThroughput'])
self.assertEqual(0.099651, samples['DropPercentage'])
- self.assertEqual(21.5, samples['latency_ns_avg'])
- self.assertEqual(14.0, samples['latency_ns_min'])
- self.assertEqual(26.5, samples['latency_ns_max'])
+ self.assertEqual(21.5, samples['LatencyAvg'])
+ self.assertEqual(13.0, samples['LatencyMin'])
+ self.assertEqual(28.0, samples['LatencyMax'])
self.assertEqual(100.0, samples['Rate'])
self.assertEqual('64B', samples['PktSize'])
def test_get_drop_percentage_over_drop_percentage(self):
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile.rate = 1000
def test_get_drop_percentage_under_drop_percentage(self):
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile.rate = 1000
@mock.patch.object(ixia_rfc2544.LOG, 'info')
def test_get_drop_percentage_not_flow(self, *args):
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 0,
- 'in_bytes': 64000, 'out_bytes': 0,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 0,
+ 'InBytes': 64000, 'OutBytes': 0,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 0,
- 'in_bytes': 64320, 'out_bytes': 0,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 0,
+ 'InBytes': 64320, 'OutBytes': 0,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile.rate = 1000
def test_get_drop_percentage_first_run(self):
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile._get_next_rate = mock.Mock(return_value=50.0)
rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile._get_next_rate = mock.Mock(return_value=0.1)
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile.rate = 0.19
completed, _ = rfc2544_profile.get_drop_percentage(
self.assertTrue(completed)
samples = {'iface_name_1':
- {'in_packets': 1000, 'out_packets': 1000,
- 'in_bytes': 64000, 'out_bytes': 64000,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25},
+ {'InPackets': 1000, 'OutPackets': 1000,
+ 'InBytes': 64000, 'OutBytes': 64000,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25},
'iface_name_2':
- {'in_packets': 1005, 'out_packets': 1007,
- 'in_bytes': 64320, 'out_bytes': 64448,
- 'Store-Forward_Avg_latency_ns': 20,
- 'Store-Forward_Min_latency_ns': 15,
- 'Store-Forward_Max_latency_ns': 25}
+ {'InPackets': 1005, 'OutPackets': 1007,
+ 'InBytes': 64320, 'OutBytes': 64448,
+ 'LatencyAvg': 20,
+ 'LatencyMin': 15,
+ 'LatencyMax': 25}
}
rfc2544_profile.rate = 0.5
completed, _ = rfc2544_profile.get_drop_percentage(
input_stats = {
'0': {
- 'in_packets': 50,
- 'out_packets': 100,
+ 'InPackets': 50,
+ 'OutPackets': 100,
'Store-Forward_Avg_latency_ns': 10,
'Store-Forward_Min_latency_ns': 10,
'Store-Forward_Max_latency_ns': 10}}
def test__get_prio_flows_drop_percentage_traffic_not_flowing(self):
input_stats = {
'0': {
- 'in_packets': 0,
- 'out_packets': 0,
+ 'InPackets': 0,
+ 'OutPackets': 0,
'Store-Forward_Avg_latency_ns': 0,
'Store-Forward_Min_latency_ns': 0,
'Store-Forward_Max_latency_ns': 0}}
def test__get_summary_pppoe_subs_counters(self):
input_stats = {
'xe0': {
- 'out_packets': 100,
- 'sessions_up': 4,
- 'sessions_down': 0,
- 'sessions_not_started': 0,
- 'sessions_total': 4},
+ 'OutPackets': 100,
+ 'SessionsUp': 4,
+ 'SessionsDown': 0,
+ 'SessionsNotStarted': 0,
+ 'SessionsTotal': 4},
'xe1': {
- 'out_packets': 100,
- 'sessions_up': 4,
- 'sessions_down': 0,
- 'sessions_not_started': 0,
- 'sessions_total': 4}
+ 'OutPackets': 100,
+ 'SessionsUp': 4,
+ 'SessionsDown': 0,
+ 'SessionsNotStarted': 0,
+ 'SessionsTotal': 4}
}
expected_stats = {
- 'sessions_up': 8,
- 'sessions_down': 0,
- 'sessions_not_started': 0,
- 'sessions_total': 8
+ 'SessionsUp': 8,
+ 'SessionsDown': 0,
+ 'SessionsNotStarted': 0,
+ 'SessionsTotal': 8
}
res = self.ixia_tp._get_summary_pppoe_subs_counters(input_stats)
samples = {
'priority_stats': {
'0': {
- 'in_packets': 100,
- 'out_packets': 100,
- 'in_bytes': 6400,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10}},
+ 'InPackets': 100,
+ 'OutPackets': 100,
+ 'InBytes': 6400,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10}},
'xe0': {
- 'in_packets': 100,
- 'out_packets': 100,
- 'in_bytes': 6400,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10}}
-
- mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+ 'InPackets': 100,
+ 'OutPackets': 100,
+ 'InBytes': 6400,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10}}
+
+ mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
self.ixia_tp._get_framesize = mock.Mock(return_value='64B')
samples, tol_min=0.0, tolerance=0.0001, precision=0,
resolution=0.1, first_run=True)
self.assertIsNotNone(res.get('DropPercentage'))
- self.assertIsNotNone(res.get('priority'))
- self.assertIsNotNone(res.get('sessions_up'))
+ self.assertIsNotNone(res.get('Priority'))
+ self.assertIsNotNone(res.get('SessionsUp'))
self.assertEqual(res['DropPercentage'], 0.0)
self.assertEqual(res['Rate'], 100.0)
self.assertEqual(res['PktSize'], '64B')
samples = {
'priority_stats': {
'0': {
- 'in_packets': 90,
- 'out_packets': 100,
- 'in_bytes': 5760,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10}},
+ 'InPackets': 90,
+ 'OutPackets': 100,
+ 'InBytes': 5760,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10}},
'xe0': {
- 'in_packets': 90,
- 'out_packets': 100,
- 'in_bytes': 5760,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10}}
-
- mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+ 'InPackets': 90,
+ 'OutPackets': 100,
+ 'InBytes': 5760,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10}}
+
+ mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
status, res = self.ixia_tp.get_drop_percentage(
samples, tol_min=0.0, tolerance=0.0001, precision=0,
resolution=0.1, first_run=True)
self.assertIsNotNone(res.get('DropPercentage'))
- self.assertIsNotNone(res.get('priority'))
- self.assertIsNotNone(res.get('sessions_up'))
+ self.assertIsNotNone(res.get('Priority'))
+ self.assertIsNotNone(res.get('SessionsUp'))
self.assertEqual(res['DropPercentage'], 10.0)
self.assertFalse(status)
mock_sum_prio_drop_rate.assert_called_once()
samples = {
'priority_stats': {
'0': {
- 'in_packets': 100,
- 'out_packets': 100,
- 'in_bytes': 6400,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10}},
+ 'InPackets': 100,
+ 'OutPackets': 100,
+ 'InBytes': 6400,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10}},
'xe0': {
- 'in_packets': 90,
- 'out_packets': 100,
- 'in_bytes': 5760,
- 'out_bytes': 6400,
- 'Store-Forward_Avg_latency_ns': 10,
- 'Store-Forward_Min_latency_ns': 10,
- 'Store-Forward_Max_latency_ns': 10
+ 'InPackets': 90,
+ 'OutPackets': 100,
+ 'InBytes': 5760,
+ 'OutBytes': 6400,
+ 'LatencyAvg': 10,
+ 'LatencyMin': 10,
+ 'LatencyMax': 10
}}
- mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+ mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
tc_rfc2544_opts = {'priority': '0',
samples, tol_min=15.0000, tolerance=15.0001, precision=0,
resolution=0.1, first_run=True, tc_rfc2544_opts=tc_rfc2544_opts)
self.assertIsNotNone(res.get('DropPercentage'))
- self.assertIsNotNone(res.get('priority'))
- self.assertIsNotNone(res.get('sessions_up'))
+ self.assertIsNotNone(res.get('Priority'))
+ self.assertIsNotNone(res.get('SessionsUp'))
self.assertTrue(status)
mock_sum_prio_drop_rate.assert_called_once()
mock_get_pppoe_subs.assert_called_once()
mock_get_framesize.return_value = '64B'
samples = [
- {'xe1': {'tx_throughput_fps': 110,
- 'rx_throughput_fps': 101,
- 'out_packets': 2100,
+ {'xe1': {'out_packets': 2100,
'in_packets': 2010,
'out_bytes': 134400,
'in_bytes': 128640,
'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 1)},
- 'xe2': {'tx_throughput_fps': 210,
- 'rx_throughput_fps': 201,
- 'out_packets': 4100,
+ 'xe2': {'out_packets': 4100,
'in_packets': 4010,
'out_bytes': 262400,
'in_bytes': 256640,
'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 1)}},
- {'xe1': {'tx_throughput_fps': 156,
- 'rx_throughput_fps': 108,
- 'out_packets': 2110,
+ {'xe1': {'out_packets': 2110,
'in_packets': 2040,
'out_bytes': 135040,
'in_bytes': 130560,
'latency': 'Latency1',
'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 31)},
- 'xe2': {'tx_throughput_fps': 253,
- 'rx_throughput_fps': 215,
- 'out_packets': 4150,
+ 'xe2': {'out_packets': 4150,
'in_packets': 4010,
'out_bytes': 265600,
'in_bytes': 256640,
]
completed, output = rfc2544_profile.get_drop_percentage(
samples, 0, 0, False, 0.1)
- expected = {'DropPercentage': 50.0,
- 'Latency': {'xe1': 'Latency1', 'xe2': 'Latency2'},
+ expected = {'xe1': {'OutPackets': 10,
+ 'InPackets': 30,
+ 'OutBytes': 640,
+ 'InBytes': 1920},
+ 'xe2': {'OutPackets': 50,
+ 'InPackets': 0,
+ 'OutBytes': 3200,
+ 'InBytes': 0},
+ 'DropPercentage': 50.0,
'RxThroughput': 1000000.0,
'TxThroughput': 2000000.0,
'RxThroughputBps': 64000000.0,
'TxThroughputBps': 128000000.0,
- 'CurrentDropPercentage': 50.0,
'Rate': 100.0,
- 'Throughput': 1000000.0,
'Iteration': 1,
'PktSize': '64B',
'Status': 'Failure'}
def test_generate_samples(self, mock_get_stats):
expected_samples = {'xe0': {
- 'in_packets': 150,
- 'out_packets': 150,
- 'in_bytes': 9600,
- 'out_bytes': 9600,
- 'rx_throughput_mbps': 0.0,
- 'rx_throughput_kps': 0.0,
+ 'InPackets': 150,
+ 'OutPackets': 150,
+ 'InBytes': 9600,
+ 'OutBytes': 9600,
'RxThroughput': 5.0,
'TxThroughput': 5.0,
'RxThroughputBps': 320.0,
'TxThroughputBps': 320.0,
- 'tx_throughput_mbps': 0.0,
- 'tx_throughput_kps': 0.0,
- 'Store-Forward_Max_latency_ns': 100,
- 'Store-Forward_Min_latency_ns': 100,
- 'Store-Forward_Avg_latency_ns': 100},
+ 'LatencyMax': 100,
+ 'LatencyMin': 100,
+ 'LatencyAvg': 100},
'xe1': {
- 'in_packets': 150,
- 'out_packets': 150,
- 'in_bytes': 9600,
- 'out_bytes': 9600,
- 'rx_throughput_mbps': 0.0,
- 'rx_throughput_kps': 0.0,
+ 'InPackets': 150,
+ 'OutPackets': 150,
+ 'InBytes': 9600,
+ 'OutBytes': 9600,
'RxThroughput': 5.0,
'TxThroughput': 5.0,
'RxThroughputBps': 320.0,
'TxThroughputBps': 320.0,
- 'tx_throughput_mbps': 0.0,
- 'tx_throughput_kps': 0.0,
- 'Store-Forward_Max_latency_ns': 200,
- 'Store-Forward_Min_latency_ns': 200,
- 'Store-Forward_Avg_latency_ns': 200}}
+ 'LatencyMax': 200,
+ 'LatencyMin': 200,
+ 'LatencyAvg': 200}}
res_helper = mock.Mock()
res_helper.vnfd_helper.find_interface_by_port.side_effect = \
prio_flows_stats = {
'0': {
- 'in_packets': 6000,
- 'out_packets': 6000,
+ 'InPackets': 6000,
+ 'OutPackets': 6000,
'RxThroughput': 200.0,
'TxThroughput': 200.0,
- 'avg_latency_ns': 2,
- 'max_latency_ns': 2,
- 'min_latency_ns': 2
+ 'LatencyAvg': 2,
+ 'LatencyMax': 2,
+ 'LatencyMin': 2
}
}
expected_result = {'priority_stats': {
'0': {'RxThroughput': 200.0,
'TxThroughput': 200.0,
- 'avg_latency_ns': 2,
- 'max_latency_ns': 2,
- 'min_latency_ns': 2,
- 'in_packets': 6000,
- 'out_packets': 6000}},
+ 'LatencyAvg': 2,
+ 'LatencyMax': 2,
+ 'LatencyMin': 2,
+ 'InPackets': 6000,
+ 'OutPackets': 6000}},
'xe0': {'RxThroughput': 100.0,
- 'Store-Forward_Avg_latency_ns': 2,
- 'Store-Forward_Max_latency_ns': 2,
- 'Store-Forward_Min_latency_ns': 2,
+ 'LatencyAvg': 2,
+ 'LatencyMax': 2,
+ 'LatencyMin': 2,
'TxThroughput': 100.0,
- 'in_packets': 3000,
- 'out_packets': 3000,
- 'in_bytes': 192000,
- 'out_bytes': 192000,
+ 'InPackets': 3000,
+ 'OutPackets': 3000,
+ 'InBytes': 192000,
+ 'OutBytes': 192000,
'RxThroughputBps': 6400.0,
'TxThroughputBps': 6400.0,
- 'rx_throughput_kps': 0.0,
- 'rx_throughput_mbps': 0.0,
- 'sessions_down': 0,
- 'sessions_not_started': 0,
- 'sessions_total': 1,
- 'sessions_up': 1,
- 'tx_throughput_kps': 0.0,
- 'tx_throughput_mbps': 0.0},
+ 'SessionsDown': 0,
+ 'SessionsNotStarted': 0,
+ 'SessionsTotal': 1,
+ 'SessionsUp': 1},
'xe1': {'RxThroughput': 100.0,
- 'Store-Forward_Avg_latency_ns': 2,
- 'Store-Forward_Max_latency_ns': 2,
- 'Store-Forward_Min_latency_ns': 2,
+ 'LatencyAvg': 2,
+ 'LatencyMax': 2,
+ 'LatencyMin': 2,
'TxThroughput': 100.0,
- 'in_packets': 3000,
- 'out_packets': 3000,
- 'in_bytes': 192000,
- 'out_bytes': 192000,
+ 'InPackets': 3000,
+ 'OutPackets': 3000,
+ 'InBytes': 192000,
+ 'OutBytes': 192000,
'RxThroughputBps': 6400.0,
- 'TxThroughputBps': 6400.0,
- 'rx_throughput_kps': 0.0,
- 'rx_throughput_mbps': 0.0,
- 'tx_throughput_kps': 0.0,
- 'tx_throughput_mbps': 0.0}}
+ 'TxThroughputBps': 6400.0}}
mock_get_stats.return_value = ixia_stats
mock_prio_flow_statistics.return_value = prio_flows_stats
Code Review / yardstick.git / commitdiff