Merge "pkt_gen: Spirent Testcenter RFC 2889 Support"

3 files changed, 156 insertions, 1 deletions

diff --git a/core/component_factory.py b/core/component_factory.py
index 7f453bd2..ef7ba86f 100644
--- a/core/component_factory.py
+++ b/core/component_factory.py
@@ -16,6 +16,7 @@
 """
 
 from core.traffic_controller_rfc2544 import TrafficControllerRFC2544
+from core.traffic_controller_rfc2889 import TrafficControllerRFC2889
 from core.vswitch_controller_clean import VswitchControllerClean
 from core.vswitch_controller_p2p import VswitchControllerP2P
 from core.vswitch_controller_pxp import VswitchControllerPXP
@@ -47,7 +48,10 @@ def create_traffic(traffic_type, trafficgen_class):
     :param trafficgen_class: Reference to traffic generator class to be used.
     :return: A new ITrafficController
     """
-    return TrafficControllerRFC2544(trafficgen_class)
+    if traffic_type.lower().startswith('rfc2889'):
+        return TrafficControllerRFC2889(trafficgen_class)
+    else:
+        return TrafficControllerRFC2544(trafficgen_class)
 
 
 def create_vswitch(deployment_scenario, vswitch_class, traffic,
diff --git a/core/results/results_constants.py b/core/results/results_constants.py
index b7ab7052..864712bc 100644
--- a/core/results/results_constants.py
+++ b/core/results/results_constants.py
@@ -58,6 +58,11 @@ class ResultsConstants(object):
     SCAL_STREAM_COUNT = 'stream_count'
     SCAL_STREAM_TYPE = 'match_type'
     SCAL_PRE_INSTALLED_FLOWS = 'pre-installed_flows'
+    # RFC2889 Forwarding, Address-Caching and Congestion
+    FORWARDING_RATE_FPS = 'forwarding_rate_fps'
+    ADDRS_COUNT_FLOOD_COUNT_RATIO = 'addrs_count_flood_count_ratio'
+    CONGESTION_CONTROL_EXISTS = 'congestion_control_exists'
+    PORTS_MAP = 'ports_map'
 
     TEST_RUN_TIME = "test_execution_time"
 
diff --git a/core/traffic_controller_rfc2889.py b/core/traffic_controller_rfc2889.py
new file mode 100644
index 00000000..a97a47d3
--- /dev/null
+++ b/core/traffic_controller_rfc2889.py
@@ -0,0 +1,146 @@
+"""RFC2889 Traffic Controller implementation.
+"""
+import logging
+
+from core.traffic_controller import ITrafficController
+from core.results.results_constants import ResultsConstants
+from core.results.results import IResults
+from conf import settings
+from conf import get_test_param
+
+
+class TrafficControllerRFC2889(ITrafficController, IResults):
+    """Traffic controller for RFC2889 traffic
+
+    Used to setup and control a traffic generator for an RFC2889 deployment
+    traffic scenario.
+    """
+
+    def __init__(self, traffic_gen_class):
+        """Initialise the trafficgen and store.
+
+        :param traffic_gen_class: The traffic generator class to be used.
+        """
+        self._logger = logging.getLogger(__name__)
+        self._logger.debug("__init__")
+        self._traffic_gen_class = traffic_gen_class()
+        self._traffic_started = False
+        self._traffic_started_call_count = 0
+        self._trials = int(get_test_param('rfc2889_trials', 1))
+        self._duration = int(get_test_param('duration', 30))
+        self._results = []
+
+        # If set, comma separated packet_sizes value from --test_params
+        # on cli takes precedence over value in settings file.
+        self._packet_sizes = None
+        packet_sizes_cli = get_test_param('pkt_sizes')
+        if packet_sizes_cli:
+            self._packet_sizes = [int(x.strip())
+                                  for x in packet_sizes_cli.split(',')]
+        else:
+            self._packet_sizes = settings.getValue('TRAFFICGEN_PKT_SIZES')
+
+    def __enter__(self):
+        """Call initialisation function.
+        """
+        self._traffic_gen_class.connect()
+
+    def __exit__(self, type_, value, traceback):
+        """Stop traffic, clean up.
+        """
+        if self._traffic_started:
+            self.stop_traffic()
+
+    @staticmethod
+    def _append_results(result_dict, packet_size):
+        """Adds common values to traffic generator results.
+
+        :param result_dict: Dictionary containing results from trafficgen
+        :param packet_size: Packet size value.
+
+        :returns: dictionary of results with additional entries.
+        """
+
+        ret_value = result_dict
+
+        ret_value[ResultsConstants.TYPE] = 'rfc2889'
+        ret_value[ResultsConstants.PACKET_SIZE] = str(packet_size)
+
+        return ret_value
+
+    def send_traffic(self, traffic):
+        """See ITrafficController for description
+        """
+        self._logger.debug('send_traffic with ' +
+                           str(self._traffic_gen_class))
+
+        for packet_size in self._packet_sizes:
+            # Merge framesize with the default traffic definition
+            if 'l2' in traffic:
+                traffic['l2'] = dict(traffic['l2'],
+                                     **{'framesize': packet_size})
+            else:
+                traffic['l2'] = {'framesize': packet_size}
+
+            if traffic['traffic_type'] == 'caching':
+                result = self._traffic_gen_class.send_rfc2889_caching(
+                    traffic, trials=self._trials, duration=self._duration)
+            elif traffic['traffic_type'] == 'congestion':
+                result = self._traffic_gen_class.send_rfc2889_congestion(
+                    traffic, duration=self._duration)
+            else:
+                result = self._traffic_gen_class.send_rfc2889_forwarding(
+                    traffic, tests=self._trials, duration=self._duration)
+
+            result = TrafficControllerRFC2889._append_results(result,
+                                                              packet_size)
+            self._results.append(result)
+
+    def send_traffic_async(self, traffic, function):
+        """See ITrafficController for description
+        """
+        self._logger.debug('send_traffic_async with ' +
+                           str(self._traffic_gen_class))
+
+        for packet_size in self._packet_sizes:
+            traffic['l2'] = {'framesize': packet_size}
+            self._traffic_gen_class.start_rfc2889_forwarding(
+                traffic,
+                trials=self._trials,
+                duration=self._duration)
+            self._traffic_started = True
+            if len(function['args']) > 0:
+                function['function'](function['args'])
+            else:
+                function['function']()
+            result = self._traffic_gen_class.wait_rfc2889_forwarding(
+                        traffic, trials=self._trials, duration=self._duration)
+            result = TrafficControllerRFC2889._append_results(result,
+                                                              packet_size)
+            self._results.append(result)
+
+    def stop_traffic(self):
+        """Kills traffic being sent from the traffic generator.
+        """
+        self._logger.debug("stop_traffic()")
+
+    def print_results(self):
+        """IResult interface implementation.
+        """
+        counter = 0
+        for item in self._results:
+            logging.info("Record: " + str(counter))
+            counter += 1
+            for(key, value) in list(item.items()):
+                logging.info("         Key: " + str(key) +
+                             ", Value: " + str(value))
+
+    def get_results(self):
+        """IResult interface implementation.
+        """
+        return self._results
+
+    def validate_send_traffic(self, result, traffic):
+        """Verify that send traffic has succeeded
+        """
+        return True