from robot.api import logger
from robot.libraries.BuiltIn import BuiltIn
-from robot.api.deco import keyword
from resources.libraries.python.ssh import SSH
from resources.libraries.python.topology import NodeType
__all__ = ['TrafficGenerator', 'TGDropRateSearchImpl']
+
class TGDropRateSearchImpl(DropRateSearch):
- """Drop Rate Search implementation"""
+ """Drop Rate Search implementation."""
def __init__(self):
super(TGDropRateSearchImpl, self).__init__()
def measure_loss(self, rate, frame_size, loss_acceptance,
loss_acceptance_type, traffic_type):
- #we need instance of TrafficGenerator instantiated by Robot Framework
- #to be able to use trex_stateless_remote_exec method
- tg_instance = BuiltIn().get_library_instance('resources.libraries.python.TrafficGenerator')
+ # we need instance of TrafficGenerator instantiated by Robot Framework
+ # to be able to use trex_stateless_remote_exec method
+ 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:
unit_rate = str(rate) + self.get_rate_type_str()
- tg_instance.trex_stateless_remote_exec(self.get_duration(), unit_rate,
- frame_size, traffic_type)
+ tg_instance.trex_stateless_remote_exec(self.get_duration(),
+ unit_rate, frame_size,
+ traffic_type)
- #TODO:getters for tg_instance and loss_acceptance_type
- logger.trace("comparing: {} < {} ".format(tg_instance._loss, loss_acceptance))
+ # 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):
return False
else:
else:
raise NotImplementedError("TG subtype not supported")
+
class TrafficGenerator(object):
- """Traffic Generator"""
+ """Traffic Generator."""
- #use one instance of TrafficGenerator for all tests in test suite
+ # use one instance of TrafficGenerator for all tests in test suite
ROBOT_LIBRARY_SCOPE = 'TEST SUITE'
def __init__(self):
self._sent = None
self._received = None
self._node = None
- #T-REX interface order mapping
+ # T-REX interface order mapping
self._ifaces_reordered = 0
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 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
+ """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.
:type tg_node: dict
:type tg_if1: str
:type tg_if2: str
:return: nothing
"""
- trex_path = "/opt/trex-core-1.91"
+ trex_path = "/opt/trex-core-2.00"
topo = Topology()
(ret, _, _) = ssh.exec_command(
"sh -c 'cd {0}/scripts/ && "
- "sudo nohup ./t-rex-64 -i -c 4 --iom 0 > /dev/null 2>&1 &'"
+ "sudo nohup ./t-rex-64 -i -c 7 --iom 0 > /dev/null 2>&1 &'"
"> /dev/null"\
.format(trex_path))
if int(ret) != 0:
@staticmethod
def teardown_traffic_generator(node):
- """TG teardown
- :param node: Traffic generator node
+ """TG teardown.
+
+ :param node: Traffic generator node.
:type node: dict
:return: nothing
"""
-
if node['type'] != NodeType.TG:
raise Exception('Node type is not a TG')
if node['subtype'] == NodeSubTypeTG.TREX:
def trex_stateless_remote_exec(self, duration, rate, framesize,
traffic_type):
- """Execute stateless script on remote node over ssh
+ """Execute stateless script on remote node over ssh.
- :param node: remote node
- :param traffic_type: Traffic profile
- :type node: dict
+ :param traffic_type: Traffic profile.
:type traffic_type: str
"""
ssh = SSH()
"--p{4}_dst_start_ip 10.10.10.2'".\
format(duration, rate, framesize, _p0, _p1),\
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 "
+ "-d {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'".\
+ format(duration, rate, framesize, _p0, _p1),\
+ timeout=int(duration)+60)
else:
raise NotImplementedError('Unsupported traffic type')
logger.trace(stdout)
logger.trace(stderr)
- #last line from console output
- line = stdout.splitlines()[-1]
+ if int(ret) != 0:
+ raise RuntimeError('T-rex stateless runtime error')
+ else:
+ # last line from console output
+ line = stdout.splitlines()[-1]
- self._result = line
- logger.info('TrafficGen result: {0}'.format(self._result))
+ self._result = line
+ logger.info('TrafficGen result: {0}'.format(self._result))
- self._received = self._result.split(', ')[1].split('=')[1]
- self._sent = self._result.split(', ')[2].split('=')[1]
- self._loss = self._result.split(', ')[3].split('=')[1]
+ self._received = self._result.split(', ')[1].split('=')[1]
+ self._sent = self._result.split(', ')[2].split('=')[1]
+ self._loss = self._result.split(', ')[3].split('=')[1]
def send_traffic_on(self, node, duration, rate,
framesize, traffic_type):
- """Send traffic from all configured interfaces on TG
- :param node: Dictionary containing TG information
- :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
+ """Send traffic from all configured interfaces on TG.
+
+ :param node: Dictionary containing TG information.
+ :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.
:type node: dict
:type duration: str
:type rate: str
:type framesize: str
:type traffic_type: str
- :return: TG output
+ :return: TG output.
:rtype: str
"""
-
if node['type'] != NodeType.TG:
raise Exception('Node type is not a TG')
return self._result
- def no_traffic_loss_occured(self):
- """Fail is loss occured in traffic run
+ def no_traffic_loss_occurred(self):
+ """Fail is loss occurred in traffic run.
+
:return: nothing
"""
-
if self._loss is None:
raise Exception('The traffic generation has not been issued')
if self._loss != '0':
- raise Exception('Traffic loss occured: {0}'.format(self._loss))
+ raise Exception('Traffic loss occurred: {0}'.format(self._loss))
Code Review / csit.git / blobdiff