X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FTrafficGenerator.py;h=52b5247dfd52b9741deb708de61c221fb0f55f08;hp=3969891cf9a050610016d10dd2d36098e9aefa12;hb=b2f75ec0f52110c267b90372e657b664417c1f4b;hpb=180d17939d123c04bf142cedf02daa325e3f4fa6 diff --git a/resources/libraries/python/TrafficGenerator.py b/resources/libraries/python/TrafficGenerator.py index 3969891cf9..52b5247dfd 100644 --- a/resources/libraries/python/TrafficGenerator.py +++ b/resources/libraries/python/TrafficGenerator.py @@ -16,6 +16,7 @@ from robot.api import logger from robot.libraries.BuiltIn import BuiltIn +from resources.libraries.python.constants import Constants from resources.libraries.python.ssh import SSH from resources.libraries.python.topology import NodeType from resources.libraries.python.topology import NodeSubTypeTG @@ -33,30 +34,60 @@ class TGDropRateSearchImpl(DropRateSearch): def measure_loss(self, rate, frame_size, loss_acceptance, loss_acceptance_type, traffic_type): - + """Runs the traffic and evaluate the measured results. + + :param rate: Offered traffic load. + :param frame_size: Size of frame. + :param loss_acceptance: Permitted drop ratio or frames count. + :param loss_acceptance_type: Type of permitted loss. + :param traffic_type: Traffic profile ([2,3]-node-L[2,3], ...). + :type rate: int + :type frame_size: str + :type loss_acceptance: float + :type loss_acceptance_type: LossAcceptanceType + :type traffic_type: str + :returns: Drop threshold exceeded? (True/False) + :rtype: bool + :raises: NotImplementedError if TG is not supported. + :raises: RuntimeError if TG is not specified. + """ # we need instance of TrafficGenerator instantiated by Robot Framework # to be able to use trex_stl-*() tg_instance = BuiltIn().get_library_instance( 'resources.libraries.python.TrafficGenerator') - if tg_instance._node['subtype'] is None: - raise Exception('TG subtype not defined') - elif tg_instance._node['subtype'] == NodeSubTypeTG.TREX: + if tg_instance.node['subtype'] is None: + raise RuntimeError('TG subtype not defined') + elif tg_instance.node['subtype'] == NodeSubTypeTG.TREX: unit_rate = str(rate) + self.get_rate_type_str() tg_instance.trex_stl_start_remote_exec(self.get_duration(), unit_rate, frame_size, - traffic_type, False) - - # TODO: getters for tg_instance and loss_acceptance_type - logger.trace("comparing: {} < {} ".format(tg_instance._loss, - loss_acceptance)) - if float(tg_instance._loss) > float(loss_acceptance): + traffic_type) + loss = tg_instance.get_loss() + sent = tg_instance.get_sent() + if self.loss_acceptance_type_is_percentage(): + loss = (float(loss) / float(sent)) * 100 + + logger.trace("comparing: {} < {} {}".format(loss, + loss_acceptance, + loss_acceptance_type)) + if float(loss) > float(loss_acceptance): return False else: return True else: raise NotImplementedError("TG subtype not supported") + def get_latency(self): + """Returns min/avg/max latency. + + :returns: Latency stats. + :rtype: list + """ + tg_instance = BuiltIn().get_library_instance( + 'resources.libraries.python.TrafficGenerator') + return tg_instance.get_latency_int() + class TrafficGenerator(object): """Traffic Generator.""" @@ -68,53 +99,105 @@ class TrafficGenerator(object): self._result = None self._loss = None self._sent = None + self._latency = None self._received = None self._node = None # T-REX interface order mapping self._ifaces_reordered = 0 - #pylint: disable=too-many-arguments, too-many-locals + @property + def node(self): + """Getter. + + :returns: Traffic generator node. + :rtype: dict + """ + return self._node + + def get_loss(self): + """Return number of lost packets. + + :returns: Number of lost packets. + :rtype: str + """ + return self._loss + + def get_sent(self): + """Return number of sent packets. + + :returns: Number of sent packets. + :rtype: str + """ + return self._sent + + def get_received(self): + """Return number of received packets. + + :returns: Number of received packets. + :rtype: str + """ + return self._received + + def get_latency_int(self): + """Return rounded min/avg/max latency. + + :returns: Latency stats. + :rtype: list + """ + return self._latency + def initialize_traffic_generator(self, tg_node, tg_if1, tg_if2, - dut1_node, dut1_if1, dut1_if2, - dut2_node, dut2_if1, dut2_if2, - test_type): + tg_if1_adj_node, tg_if1_adj_if, + tg_if2_adj_node, tg_if2_adj_if, + test_type, + tg_if1_dst_mac=None, tg_if2_dst_mac=None): """TG initialization. :param tg_node: Traffic generator node. :param tg_if1: TG - name of first interface. :param tg_if2: TG - name of second interface. - :param dut1_node: DUT1 node. - :param dut1_if1: DUT1 - name of first interface. - :param dut1_if2: DUT1 - name of second interface. - :param dut2_node: DUT2 node. - :param dut2_if1: DUT2 - name of first interface. - :param dut2_if2: DUT2 - name of second interface. - :test_type: 'L2' or 'L3' - src/dst MAC address. + :param tg_if1_adj_node: TG if1 adjecent node. + :param tg_if1_adj_if: TG if1 adjecent interface. + :param tg_if2_adj_node: TG if2 adjecent node. + :param tg_if2_adj_if: TG if2 adjecent interface. + :param test_type: 'L2' or 'L3' - src/dst MAC address. + :param tg_if1_dst_mac: Interface 1 destination MAC address. + :param tg_if2_dst_mac: Interface 2 destination MAC address. :type tg_node: dict :type tg_if1: str :type tg_if2: str - :type dut1_node: dict - :type dut1_if1: str - :type dut1_if2: str - :type dut2_node: dict - :type dut2_if1: str - :type dut2_if2: str + :type tg_if1_adj_node: dict + :type tg_if1_adj_if: str + :type tg_if2_adj_node: dict + :type tg_if2_adj_if: str :type test_type: str - :return: nothing + :type tg_if1_dst_mac: str + :type tg_if2_dst_mac: str + :returns: nothing + :raises: RuntimeError in case of issue during initialization. """ - trex_path = "/opt/trex-core-2.00" - topo = Topology() if tg_node['type'] != NodeType.TG: - raise Exception('Node type is not a TG') + raise RuntimeError('Node type is not a TG') self._node = tg_node if tg_node['subtype'] == NodeSubTypeTG.TREX: + trex_path = "/opt/trex-core-2.22" + ssh = SSH() ssh.connect(tg_node) + (ret, stdout, stderr) = ssh.exec_command( + "sudo -E sh -c '{}/resources/tools/t-rex/" + "t-rex-installer.sh'".format(Constants.REMOTE_FW_DIR), + timeout=1800) + if int(ret) != 0: + logger.error('trex installation failed: {0}'.format( + stdout + stderr)) + raise RuntimeError('Installation of TG failed') + if1_pci = topo.get_interface_pci_addr(tg_node, tg_if1) if2_pci = topo.get_interface_pci_addr(tg_node, tg_if2) if1_mac = topo.get_interface_mac(tg_node, tg_if1) @@ -124,10 +207,16 @@ class TrafficGenerator(object): if1_adj_mac = if2_mac if2_adj_mac = if1_mac elif test_type == 'L3': - if1_adj_mac = topo.get_interface_mac(dut1_node, dut1_if1) - if2_adj_mac = topo.get_interface_mac(dut2_node, dut2_if2) + if1_adj_mac = topo.get_interface_mac(tg_if1_adj_node, + tg_if1_adj_if) + if2_adj_mac = topo.get_interface_mac(tg_if2_adj_node, + tg_if2_adj_if) else: - raise Exception("test_type unknown") + raise ValueError("test_type unknown") + + if tg_if1_dst_mac is not None and tg_if2_dst_mac is not None: + if1_adj_mac = tg_if1_dst_mac + if2_adj_mac = tg_if2_dst_mac if min(if1_pci, if2_pci) != if1_pci: if1_mac, if2_mac = if2_mac, if1_mac @@ -145,7 +234,6 @@ class TrafficGenerator(object): "- port_limit : 2\n" " version : 2\n" " interfaces : [\"{}\",\"{}\"]\n" - " port_bandwidth_gb : 10\n" " port_info :\n" " - dest_mac : [{}]\n" " src_mac : [{}]\n" @@ -160,24 +248,43 @@ class TrafficGenerator(object): .format(stdout + stderr)) raise RuntimeError('trex config generation error') - (ret, stdout, stderr) = ssh.exec_command( - "sh -c 'cd {0}/scripts/ && " - "sudo ./trex-cfg'"\ - .format(trex_path)) - if int(ret) != 0: - logger.error('trex-cfg failed: {0}'.format(stdout + stderr)) - raise RuntimeError('trex-cfg failed') - - (ret, _, _) = ssh.exec_command( - "sh -c 'pgrep t-rex && sudo pkill t-rex'") + max_startup_retries = 3 + while max_startup_retries > 0: + # kill T-rex only if it is already running + (ret, _, _) = ssh.exec_command( + "sh -c 'pgrep t-rex && sudo pkill t-rex && sleep 3'") + + # configure T-rex + (ret, stdout, stderr) = ssh.exec_command( + "sh -c 'cd {0}/scripts/ && sudo ./trex-cfg'"\ + .format(trex_path)) + if int(ret) != 0: + logger.error('trex-cfg failed: {0}'.format(stdout + stderr)) + raise RuntimeError('trex-cfg failed') + + # start T-rex + (ret, _, _) = ssh.exec_command( + "sh -c 'cd {0}/scripts/ && " + "sudo nohup ./t-rex-64 -i -c 7 --iom 0 > /dev/null 2>&1 &'" + "> /dev/null"\ + .format(trex_path)) + if int(ret) != 0: + raise RuntimeError('t-rex-64 startup failed') + + # get T-rex server info + (ret, _, _) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-server-info.py'"\ + .format(Constants.REMOTE_FW_DIR), + timeout=120) + if int(ret) == 0: + # If we get info T-rex is running + return + # try again + max_startup_retries -= 1 + # after max retries T-rex is still not responding to API + # critical error occured + raise RuntimeError('t-rex-64 startup failed') - (ret, _, _) = ssh.exec_command( - "sh -c 'cd {0}/scripts/ && " - "sudo nohup ./t-rex-64 -i -c 7 --iom 0 > /dev/null 2>&1 &'" - "> /dev/null"\ - .format(trex_path)) - if int(ret) != 0: - raise RuntimeError('t-rex-64 startup failed') @staticmethod def teardown_traffic_generator(node): @@ -185,10 +292,12 @@ class TrafficGenerator(object): :param node: Traffic generator node. :type node: dict - :return: nothing + :returns: nothing + :raises: RuntimeError if T-rex teardown failed. + :raises: RuntimeError if node type is not a TG. """ if node['type'] != NodeType.TG: - raise Exception('Node type is not a TG') + raise RuntimeError('Node type is not a TG') if node['subtype'] == NodeSubTypeTG.TREX: ssh = SSH() ssh.connect(node) @@ -204,14 +313,15 @@ class TrafficGenerator(object): :param node: T-REX generator node. :type node: dict - :return: Nothing + :returns: Nothing + :raises: RuntimeError if stop traffic script fails. """ ssh = SSH() ssh.connect(node) (ret, stdout, stderr) = ssh.exec_command( - "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/" - "t-rex-stateless-stop.py'") + "sh -c '{}/resources/tools/t-rex/" + "t-rex-stateless-stop.py'".format(Constants.REMOTE_FW_DIR)) logger.trace(ret) logger.trace(stdout) logger.trace(stderr) @@ -220,7 +330,8 @@ class TrafficGenerator(object): raise RuntimeError('T-rex stateless runtime error') def trex_stl_start_remote_exec(self, duration, rate, framesize, - traffic_type, async_call, warmup_time=5): + traffic_type, async_call=False, + latency=True, warmup_time=5): """Execute script on remote node over ssh to start traffic. :param duration: Time expresed in seconds for how long to send traffic. @@ -228,69 +339,180 @@ class TrafficGenerator(object): :param framesize: L2 frame size to send (without padding and IPG). :param traffic_type: Traffic profile. :param async_call: If enabled then don't wait for all incomming trafic. + :param latency: With latency measurement. :param warmup_time: Warmup time period. :type duration: int :type rate: str :type framesize: int :type traffic_type: str :type async_call: bool + :type latency: bool :type warmup_time: int - :return: Nothing + :returns: Nothing + :raises: NotImplementedError if traffic type is not supported. + :raises: RuntimeError in case of TG driver issue. """ ssh = SSH() ssh.connect(self._node) _p0 = 1 _p1 = 2 - _async = "" + _async = "--async" if async_call else "" + _latency = "--latency" if latency else "" - if async_call: - _async = "--async" if self._ifaces_reordered != 0: _p0, _p1 = _p1, _p0 if traffic_type in ["3-node-xconnect", "3-node-bridge"]: (ret, stdout, stderr) = ssh.exec_command( - "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/" - "t-rex-stateless.py " - "--duration={0} -r {1} -s {2} " - "--p{3}_src_start_ip 10.10.10.1 " - "--p{3}_src_end_ip 10.10.10.254 " - "--p{3}_dst_start_ip 20.20.20.1 " - "--p{4}_src_start_ip 20.20.20.1 " - "--p{4}_src_end_ip 20.20.20.254 " - "--p{4}_dst_start_ip 10.10.10.1 " - "{5} --warmup_time={6}'".format(duration, rate, framesize, _p0, - _p1, _async, warmup_time), + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.10.10.1 " + "--p{4}_src_end_ip 10.10.10.254 " + "--p{4}_dst_start_ip 20.20.20.1 " + "--p{5}_src_start_ip 20.20.20.1 " + "--p{5}_src_end_ip 20.20.20.254 " + "--p{5}_dst_start_ip 10.10.10.1 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), timeout=int(duration)+60) elif traffic_type in ["3-node-IPv4"]: (ret, stdout, stderr) = ssh.exec_command( - "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/" - "t-rex-stateless.py " - "--duration={0} -r {1} -s {2} " - "--p{3}_src_start_ip 10.10.10.2 " - "--p{3}_src_end_ip 10.10.10.254 " - "--p{3}_dst_start_ip 20.20.20.2 " - "--p{4}_src_start_ip 20.20.20.2 " - "--p{4}_src_end_ip 20.20.20.254 " - "--p{4}_dst_start_ip 10.10.10.2 " - "{5} --warmup_time={6}'".format(duration, rate, framesize, _p0, - _p1, _async, warmup_time), + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.10.10.2 " + "--p{4}_src_end_ip 10.10.10.254 " + "--p{4}_dst_start_ip 20.20.20.2 " + "--p{5}_src_start_ip 20.20.20.2 " + "--p{5}_src_end_ip 20.20.20.254 " + "--p{5}_dst_start_ip 10.10.10.2 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv4-dst-10000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.0.0.1 " + "--p{4}_dst_start_ip 20.0.0.0 " + "--p{4}_dst_end_ip 20.0.39.15 " + "--p{5}_src_start_ip 20.0.0.1 " + "--p{5}_dst_start_ip 10.0.0.0 " + "--p{5}_dst_end_ip 10.0.39.15 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv4-dst-100000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.0.0.1 " + "--p{4}_dst_start_ip 20.0.0.0 " + "--p{4}_dst_end_ip 20.1.134.159 " + "--p{5}_src_start_ip 20.0.0.1 " + "--p{5}_dst_start_ip 10.0.0.0 " + "--p{5}_dst_end_ip 10.1.134.159 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv4-dst-1000000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.0.0.1 " + "--p{4}_dst_start_ip 20.0.0.0 " + "--p{4}_dst_end_ip 20.15.66.63 " + "--p{5}_src_start_ip 20.0.0.1 " + "--p{5}_dst_start_ip 10.0.0.0 " + "--p{5}_dst_end_ip 10.15.66.63 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), timeout=int(duration)+60) elif traffic_type in ["3-node-IPv6"]: (ret, stdout, stderr) = ssh.exec_command( - "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/" - "t-rex-stateless.py " - "--duration={0} -r {1} -s {2} -6 " - "--p{3}_src_start_ip 2001:1::2 " - "--p{3}_src_end_ip 2001:1::FE " - "--p{3}_dst_start_ip 2001:2::2 " - "--p{4}_src_start_ip 2001:2::2 " - "--p{4}_src_end_ip 2001:2::FE " - "--p{4}_dst_start_ip 2001:1::2 " - "{5} --warmup_time={6}'".format(duration, rate, framesize, _p0, - _p1, _async, warmup_time), + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} -6 " + "--p{4}_src_start_ip 2001:1::2 " + "--p{4}_src_end_ip 2001:1::FE " + "--p{4}_dst_start_ip 2001:2::2 " + "--p{5}_src_start_ip 2001:2::2 " + "--p{5}_src_end_ip 2001:2::FE " + "--p{5}_dst_start_ip 2001:1::2 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv6-dst-10000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} -6 " + "--p{4}_src_start_ip 2001:1::1 " + "--p{4}_dst_start_ip 2001:2::0 " + "--p{4}_dst_end_ip 2001:2::270F " + "--p{5}_src_start_ip 2001:2::1 " + "--p{5}_dst_start_ip 2001:1::0 " + "--p{5}_dst_end_ip 2001:1::270F " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv6-dst-100000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} -6 " + "--p{4}_src_start_ip 2001:1::1 " + "--p{4}_dst_start_ip 2001:2::0 " + "--p{4}_dst_end_ip 2001:2::1:869F " + "--p{5}_src_start_ip 2001:2::1 " + "--p{5}_dst_start_ip 2001:1::0 " + "--p{5}_dst_end_ip 2001:1::1:869F " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout=int(duration)+60) + elif traffic_type in ["3-node-IPv6-dst-1000000"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} -6 " + "--p{4}_src_start_ip 2001:1::1 " + "--p{4}_dst_start_ip 2001:2::0 " + "--p{4}_dst_end_ip 2001:2::F:423F " + "--p{5}_src_start_ip 2001:2::1 " + "--p{5}_dst_start_ip 2001:1::0 " + "--p{5}_dst_end_ip 2001:1::F:423F " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), timeout=int(duration)+60) + elif traffic_type in ["2-node-bridge"]: + (ret, stdout, stderr) = ssh.exec_command( + "sh -c '{0}/resources/tools/t-rex/t-rex-stateless.py " + "--duration={1} -r {2} -s {3} " + "--p{4}_src_start_ip 10.10.10.2 " + "--p{4}_src_end_ip 10.10.10.254 " + "--p{4}_dst_start_ip 20.20.20.2 " + "--p{5}_src_start_ip 20.20.20.2 " + "--p{5}_src_end_ip 20.20.20.254 " + "--p{5}_dst_start_ip 10.10.10.2 " + "{6} {7} --warmup_time={8}'".format(Constants.REMOTE_FW_DIR, + duration, rate, framesize, + _p0, _p1, _async, _latency, + warmup_time), + timeout = int(duration) + 60) else: raise NotImplementedError('Unsupported traffic type') @@ -305,6 +527,7 @@ class TrafficGenerator(object): self._received = None self._sent = None self._loss = None + self._latency = None else: # last line from console output line = stdout.splitlines()[-1] @@ -316,10 +539,15 @@ class TrafficGenerator(object): self._sent = self._result.split(', ')[2].split('=')[1] self._loss = self._result.split(', ')[3].split('=')[1] + self._latency = [] + self._latency.append(self._result.split(', ')[4].split('=')[1]) + self._latency.append(self._result.split(', ')[5].split('=')[1]) + def stop_traffic_on_tg(self): - """Stop all traffic on TG + """Stop all traffic on TG. - :return: Nothing + :returns: Nothing + :raises: RuntimeError if TG is not set. """ if self._node is None: raise RuntimeError("TG is not set") @@ -327,19 +555,29 @@ class TrafficGenerator(object): self.trex_stl_stop_remote_exec(self._node) def send_traffic_on_tg(self, duration, rate, framesize, - traffic_type, warmup_time=5, async_call=False): + traffic_type, warmup_time=5, async_call=False, + latency=True): """Send traffic from all configured interfaces on TG. :param duration: Duration of test traffic generation in seconds. :param rate: Offered load per interface (e.g. 1%, 3gbps, 4mpps, ...). :param framesize: Frame size (L2) in Bytes. :param traffic_type: Traffic profile. + :param warmup_time: Warmup phase in seconds. + :param async_call: Async mode. + :param latency: With latency measurement. :type duration: str :type rate: str :type framesize: str :type traffic_type: str - :return: TG output. + :type warmup_time: int + :type async_call: bool + :type latency: bool + :returns: TG output. :rtype: str + :raises: RuntimeError if TG is not set. + :raises: RuntimeError if node is not TG or subtype is not specified. + :raises: NotImplementedError if TG is not supported. """ node = self._node @@ -347,13 +585,13 @@ class TrafficGenerator(object): raise RuntimeError("TG is not set") if node['type'] != NodeType.TG: - raise Exception('Node type is not a TG') + raise RuntimeError('Node type is not a TG') if node['subtype'] is None: - raise Exception('TG subtype not defined') + raise RuntimeError('TG subtype not defined') elif node['subtype'] == NodeSubTypeTG.TREX: self.trex_stl_start_remote_exec(duration, rate, framesize, - traffic_type, async_call, + traffic_type, async_call, latency, warmup_time=warmup_time) else: raise NotImplementedError("TG subtype not supported") @@ -361,11 +599,37 @@ class TrafficGenerator(object): return self._result def no_traffic_loss_occurred(self): - """Fail is loss occurred in traffic run. + """Fail if loss occurred in traffic run. - :return: nothing + :returns: nothing + :raises: Exception if loss occured. """ if self._loss is None: raise Exception('The traffic generation has not been issued') if self._loss != '0': raise Exception('Traffic loss occurred: {0}'.format(self._loss)) + + def partial_traffic_loss_accepted(self, loss_acceptance, + loss_acceptance_type): + """Fail if loss is higher then accepted in traffic run. + + :param loss_acceptance: Permitted drop ratio or frames count. + :param loss_acceptance_type: Type of permitted loss. + :type loss_acceptance: float + :type loss_acceptance_type: LossAcceptanceType + :returns: nothing + :raises: Exception if loss is above acceptance criteria. + """ + if self._loss is None: + raise Exception('The traffic generation has not been issued') + + if loss_acceptance_type == 'percentage': + loss = (float(self._loss) / float(self._sent)) * 100 + elif loss_acceptance_type == 'frames': + loss = float(self._loss) + else: + raise Exception('Loss acceptance type not supported') + + if loss > float(loss_acceptance): + raise Exception("Traffic loss {} above loss acceptance: {}".format( + loss, loss_acceptance))