def __init__(self, setup_helper, rfc_helper_type=None):
super(IxiaResourceHelper, self).__init__(setup_helper)
self.scenario_helper = setup_helper.scenario_helper
self.client = IxNextgen()
if rfc_helper_type is None:
rfc_helper_type = IxiaRfc2544Helper
self.rfc_helper = rfc_helper_type(self.scenario_helper)
self.uplink_ports = None
self.downlink_ports = None
self._connect()
def __init__(self, setup_helper, rfc_helper_type=None):
super(IxiaResourceHelper, self).__init__(setup_helper)
self.scenario_helper = setup_helper.scenario_helper
self.client = IxNextgen()
if rfc_helper_type is None:
rfc_helper_type = IxiaRfc2544Helper
self.rfc_helper = rfc_helper_type(self.scenario_helper)
self.tg_port_pairs = []
self.priv_ports = None
self.pub_ports = None
class IxiaResourceHelper(ClientResourceHelper):
LATENCY_TIME_SLEEP = 120
def __init__(self, setup_helper, rfc_helper_type=None):
super(IxiaResourceHelper, self).__init__(setup_helper)
self.scenario_helper = setup_helper.scenario_helper
self.client = IxNextgen()
if rfc_helper_type is None:
rfc_helper_type = IxiaRfc2544Helper
self.rfc_helper = rfc_helper_type(self.scenario_helper)
self.uplink_ports = None
self.downlink_ports = None
self._connect()
def _connect(self, client=None):
self.client._connect(self.vnfd_helper)
def get_stats(self, *args, **kwargs):
return self.client.ix_get_statistics()
def stop_collect(self):
self._terminated.value = 1
if self.client:
self.client.ix_stop_traffic()
def generate_samples(self, ports, key=None, default=None):
stats = self.get_stats()
last_result = stats[1]
latency = stats[0]
samples = {}
# this is not DPDK port num, but this is whatever number we gave
# when we selected ports and programmed the profile
for port_num in ports:
try:
# reverse lookup port name from port_num so the stats dict is descriptive
intf = self.vnfd_helper.find_interface_by_port(port_num)
port_name = intf["name"]
samples[port_name] = {
"rx_throughput_kps":
float(last_result["Rx_Rate_Kbps"][port_num]),
"tx_throughput_kps":
float(last_result["Tx_Rate_Kbps"][port_num]),
"rx_throughput_mbps":
float(last_result["Rx_Rate_Mbps"][port_num]),
"tx_throughput_mbps":
float(last_result["Tx_Rate_Mbps"][port_num]),
"in_packets":
int(last_result["Valid_Frames_Rx"][port_num]),
"out_packets":
int(last_result["Frames_Tx"][port_num]),
"RxThroughput":
int(last_result["Valid_Frames_Rx"][port_num]) / 30,
"TxThroughput":
int(last_result["Frames_Tx"][port_num]) / 30,
}
if key:
avg_latency = latency["Store-Forward_Avg_latency_ns"][
port_num]
min_latency = latency["Store-Forward_Min_latency_ns"][
port_num]
max_latency = latency["Store-Forward_Max_latency_ns"][
port_num]
samples[port_name][key] = \
{"Store-Forward_Avg_latency_ns": avg_latency,
"Store-Forward_Min_latency_ns": min_latency,
"Store-Forward_Max_latency_ns": max_latency}
except IndexError:
pass
return samples
def run_traffic(self, traffic_profile):
if self._terminated.value:
return
min_tol = self.rfc_helper.tolerance_low
max_tol = self.rfc_helper.tolerance_high
default = "00:00:00:00:00:00"
self._build_ports()
# we don't know client_file_name until runtime as instantiate
client_file_name = \
utils.find_relative_file(
self.scenario_helper.scenario_cfg['ixia_profile'],
self.scenario_helper.scenario_cfg["task_path"])
self.client.ix_load_config(client_file_name)
time.sleep(WAIT_AFTER_CFG_LOAD)
self.client.ix_assign_ports()
mac = {}
for port_name in self.vnfd_helper.port_pairs.all_ports:
intf = self.vnfd_helper.find_interface(name=port_name)
virt_intf = intf["virtual-interface"]
# we only know static traffic id by reading the json
# this is used by _get_ixia_trafficrofile
port_num = self.vnfd_helper.port_num(intf)
mac["src_mac_{}".format(port_num)] = virt_intf.get(
"local_mac", default)
mac["dst_mac_{}".format(port_num)] = virt_intf.get(
"dst_mac", default)
samples = {}
# Generate ixia traffic config...
try:
while not self._terminated.value:
traffic_profile.execute_traffic(self, self.client, mac)
self.client_started.value = 1
time.sleep(WAIT_FOR_TRAFFIC)
self.client.ix_stop_traffic()
samples = self.generate_samples(traffic_profile.ports)
self._queue.put(samples)
status, samples = traffic_profile.get_drop_percentage(
samples, min_tol, max_tol, self.client, mac)
current = samples['CurrentDropPercentage']
if min_tol <= current <= max_tol or status == 'Completed':
self._terminated.value = 1
self.client.ix_stop_traffic()
self._queue.put(samples)
if not self.rfc_helper.is_done():
self._terminated.value = 1
return
traffic_profile.execute_traffic(self, self.client, mac)
for _ in range(5):
time.sleep(self.LATENCY_TIME_SLEEP)
self.client.ix_stop_traffic()
samples = self.generate_samples(traffic_profile.ports,
'latency', {})
self._queue.put(samples)
traffic_profile.start_ixia_latency(self, self.client, mac)
if self._terminated.value:
break
self.client.ix_stop_traffic()
except Exception: # pylint: disable=broad-except
LOG.exception("Run Traffic terminated")
self._terminated.value = 1
def collect_kpi(self):
self.rfc_helper.iteration.value += 1
return super(IxiaResourceHelper, self).collect_kpi()
class IxiaResourceHelper(ClientResourceHelper):
def __init__(self, setup_helper, rfc_helper_type=None):
super(IxiaResourceHelper, self).__init__(setup_helper)
self.scenario_helper = setup_helper.scenario_helper
self.client = IxNextgen()
if rfc_helper_type is None:
rfc_helper_type = IxiaRfc2544Helper
self.rfc_helper = rfc_helper_type(self.scenario_helper)
self.tg_port_pairs = []
self.priv_ports = None
self.pub_ports = None
def _connect(self, client=None):
self.client.connect(self.vnfd_helper)
def _build_ports(self):
# self.generate_port_pairs(self.topology)
self.priv_ports = [int(x[0][-1]) for x in self.tg_port_pairs]
self.pub_ports = [int(x[1][-1]) for x in self.tg_port_pairs]
self.my_ports = list(set(self.priv_ports).union(set(self.pub_ports)))
def get_stats(self, *args, **kwargs):
return self.client.ix_get_statistics()[1]
def stop_collect(self):
self._terminated.value = 0
if self.client:
self.client.ix_stop_traffic()
def generate_samples(self, key=None, default=None):
last_result = self.get_stats()
samples = {}
for vpci_idx, interface in enumerate(self.vnfd_helper.interfaces):
name = "xe{0}".format(vpci_idx)
samples[name] = {
"rx_throughput_kps": float(last_result["Rx_Rate_Kbps"][vpci_idx]),
"tx_throughput_kps": float(last_result["Tx_Rate_Kbps"][vpci_idx]),
"rx_throughput_mbps": float(last_result["Rx_Rate_Mbps"][vpci_idx]),
"tx_throughput_mbps": float(last_result["Tx_Rate_Mbps"][vpci_idx]),
"in_packets": int(last_result["Valid_Frames_Rx"][vpci_idx]),
"out_packets": int(last_result["Frames_Tx"][vpci_idx]),
"RxThroughput": int(last_result["Valid_Frames_Rx"][vpci_idx]) / 30,
"TxThroughput": int(last_result["Frames_Tx"][vpci_idx]) / 30,
}
return samples
def run_traffic(self, traffic_profile):
min_tol = self.rfc_helper.tolerance_low
max_tol = self.rfc_helper.tolerance_high
self._build_ports()
self._connect()
# we don't know client_file_name until runtime as instantiate
client_file_name = self.scenario_helper.scenario_cfg['ixia_profile']
self.client.ix_load_config(client_file_name)
time.sleep(WAIT_AFTER_CFG_LOAD)
self.client.ix_assign_ports()
mac = {}
for index, interface in enumerate(self.vnfd_helper.interfaces):
virt_intf = interface["virtual-interface"]
mac.update({
"src_mac_{}".format(index): virt_intf["local_mac"],
"dst_mac_{}".format(index): virt_intf["dst_mac"],
})
samples = {}
ixia_file = os.path.join(os.getcwd(), "ixia_traffic.cfg")
# Generate ixia traffic config...
while not self._terminated.value:
traffic_profile.execute(self, self.client, mac, ixia_file)
self.client_started.value = 1
time.sleep(WAIT_FOR_TRAFFIC)
self.client.ix_stop_traffic()
samples = self.generate_samples()
self._queue.put(samples)
status, samples = traffic_profile.get_drop_percentage(self, samples, min_tol,
max_tol, self.client, mac,
ixia_file)
current = samples['CurrentDropPercentage']
if min_tol <= current <= max_tol or status == 'Completed':
self._terminated.value = 1
self.client.ix_stop_traffic()
self._queue.put(samples)