framework: Add reworked framework to repo

This commit adds the vSwitch Integration Test Framework whose
design, based off TOIT, is outlined in the HLD previously made
availiable to the community for review.

The design of this framework allows developers to add different
implementations of components, specifically vSwitches, Traffic
Generators, Metrics Collectors and VNFs, easily.

The goal of this design is that all testcases should run regardless of
what is "under the hood".

This commit adds support for running the framework for a phy to phy
RFC2544 testcase only. More testcases will be added by the community.

vSwitches supported at this time:
* Intel DPDK (r) accelerated OpenvSwitch

Traffic Generators supported at this time:
* IxNet - IxNetwork Implementation
* Ixia - IxExplorer Implementation
* Dummy - Manual Implementation

Metrics Collectors supported at this time:
* Linux Metrics

No VNFs are supported at this time but the framework outlines how they
should be integrated and provides APIs for them to adhere to.

JIRA: VSPERF-27
Change-Id: I312e1a1199487ffee8f824be06cd97d4f793eee0
Signed-off-by: Stephen Finucane <Stephen.Finucane@intel.com>
Signed-off-by: Meghan Halton <Meghan.Halton@intel.com>
Signed-off-by: Christopher Nolan <Christopher.Nolan@intel.com>
Signed-off-by: Maryam Tahhan <Maryam.Tahhan@intel.com>
Signed-off-by: Ciara Loftus <Ciara.Loftus@intel.com>
Signed-off-by: Mark Kavanagh <Mark.B.Kavanagh@intel.com>
Signed-off-by: Cian Ferriter <Cian.Ferriter@intel.com>
Signed-off-by: Timo Puha <TimoX.Puha@intel.com>
Signed-off-by: Billy O'Mahony <billy.o.mahony@intel.com>
Signed-off-by: Michal Weglicki <MichalX.Weglicki@intel.com>
Signed-off-by: Rory Sexton <Rory.Sexton@intel.com>
Signed-off-by: Ian Stokes <Ian.Stokes@intel.com>
Signed-off-by: Kevin Traynor <Kevin.Traynor@intel.com>
Signed-off-by: Dino Simeon Madarang <dino.simeonx.madarang@intel.com>
Reviewed-by: Eugene Snider <Eugene.Snider@huawei.com>
Reviewed-by: Aihua Li <aihua.li@huawei.com>

17 files changed, 1229 insertions, 0 deletions

diff --git a/core/__init__.py b/core/__init__.py
new file mode 100644
index 00000000..0b41aaca
--- /dev/null
+++ b/core/__init__.py
@@ -0,0 +1,20 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Core structural interfaces and their implementations
+"""
+import core.component_factory
+from core.traffic_controller import (ITrafficController)
+from core.vnf_controller import (IVnfController)
+from core.vswitch_controller import (IVswitchController)
diff --git a/core/collector_controller.py b/core/collector_controller.py
new file mode 100644
index 00000000..10c9bce7
--- /dev/null
+++ b/core/collector_controller.py
@@ -0,0 +1,55 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""CollectorController class
+"""
+from core.results.results import IResults
+
+class CollectorController(IResults):
+    """Class which defines a collector controller object.
+
+    Used to set-up and control a collector provider.
+    """
+
+    def __init__(self, collector_class):
+        """Sets up the prerequisites for the Collector.
+
+        :param collector_class: the Collector class to be used.
+        """
+        self._collector = collector_class()
+        self._results = []
+
+    def log_mem_stats(self):
+        """Log memory stats.
+        """
+        self._results.append(self._collector.log_mem_stats())
+
+    def log_cpu_stats(self):
+        """Log CPU stats.
+        """
+        self._results.append(self._collector.log_cpu_stats())
+
+    def get_results(self):
+        """Return collected CPU and memory stats.
+
+        Implements IResults i/f, see IResults for details.
+        """
+        return self._results
+
+    def print_results(self):
+        """Prints collected CPU and memory stats.
+
+        Implements IResults i/f, see IResults for details.
+        """
+        print(self._results)
diff --git a/core/component_factory.py b/core/component_factory.py
new file mode 100644
index 00000000..eb963d6f
--- /dev/null
+++ b/core/component_factory.py
@@ -0,0 +1,101 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Functions for creating controller objects based on deployment or traffic
+"""
+
+from core.traffic_controller_rfc2544 import TrafficControllerRFC2544
+from core.vswitch_controller_p2p import VswitchControllerP2P
+from core.vswitch_controller_pvp import VswitchControllerPVP
+from core.vnf_controller_p2p import VnfControllerP2P
+from core.vnf_controller_pvp import VnfControllerPVP
+from core.collector_controller import CollectorController
+
+
+def __init__():
+    """Finds and loads all the modules required.
+
+    Very similar code to load_trafficgens().
+    """
+    pass
+
+def create_traffic(traffic_type, trafficgen_class):
+    """Return a new IVSwitchController for the traffic type.
+
+    The returned traffic controller has the given traffic type and traffic
+    generator class.
+
+    traffic_types: 'rfc2544_throughput'
+
+    :param traffic_type: Name of traffic type 
+    :param trafficgen_class: Reference to traffic generator class to be used.
+    :return: A new ITrafficController
+    """
+    #TODO - full mapping from all traffic_types to
+    #correct controller class
+    return TrafficControllerRFC2544(trafficgen_class)
+
+def create_vswitch(deployment_scenario, vswitch_class):
+    """Return a new IVSwitchController for the deployment_scenario.
+
+    The returned controller is configured with the given vSwitch class.
+
+    Deployment scenarios: 'p2p', 'pvp'
+
+    :param deployment_scenario: The deployment scenario name
+    :param vswitch_class: Reference to vSwitch class to be used.
+    :return: IVSwitchController for the deployment_scenario
+    """
+    #TODO - full mapping from all deployment_scenarios to
+    #correct controller class
+    deployment_scenario = deployment_scenario.lower()
+    if deployment_scenario.find("p2p") >= 0:
+        return VswitchControllerP2P(vswitch_class)
+    elif deployment_scenario.find("pvp") >= 0:
+        return VswitchControllerPVP(vswitch_class)
+
+def create_vnf(deployment_scenario, vnf_class):
+    """Return a new IVnfController for the deployment_scenario.
+
+    The returned controller is configured with the given VNF class.
+
+    Deployment scenarios: 'p2p', 'pvp'
+
+    :param deployment_scenario: The deployment scenario name
+    :param vswitch_class: Reference to vSwitch class to be used.
+    :return: IVnfController for the deployment_scenario
+    """
+    #TODO - full mapping from all deployment_scenarios to
+    #correct controller class
+    deployment_scenario = deployment_scenario.lower()
+    if deployment_scenario.find("p2p") >= 0:
+        return VnfControllerP2P(vnf_class)
+    elif deployment_scenario.find("pvp") >= 0:
+        return VnfControllerPVP(vnf_class)
+
+def create_collector(collector, collector_class):
+    """Return a new CollectorController of the given class
+
+    Supported collector type strings:
+    'cpu'
+    'memory':
+
+    :param collector: Collector type string
+    :param collector_class: The collector class to be used.
+    :return: A new CollectorController.
+    """
+    collector = collector.lower()
+    if "cpu" in collector or "memory" in collector:
+        return CollectorController(collector_class)
+
diff --git a/core/loader/__init__.py b/core/loader/__init__.py
new file mode 100644
index 00000000..023f30a6
--- /dev/null
+++ b/core/loader/__init__.py
@@ -0,0 +1,20 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Loader package
+
+This packet is responsible for loading classes & creating instances
+of requested objects. This component directly depends upon conf.
+"""
+from .loader import Loader
diff --git a/core/loader/loader.py b/core/loader/loader.py
new file mode 100755
index 00000000..57787751
--- /dev/null
+++ b/core/loader/loader.py
@@ -0,0 +1,153 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Loader module definition.
+"""
+
+from conf import settings
+from core.loader.loader_servant import LoaderServant
+from tools.pkt_gen.trafficgen import ITrafficGenerator
+from tools.collectors.collector import ICollector
+from vswitches.vswitch import IVSwitch
+
+class Loader(object):
+    """Loader class - main object context holder.
+    """
+    _trafficgen_loader = None
+    _metrics_loader = None
+    _vswitch_loader = None
+
+    def __init__(self):
+        """Loader ctor - initialization method.
+
+        All data is read from configuration each time Loader instance is
+        created. It is up to creator to maintain object life cycle if this
+        behavior is unwanted.
+        """
+        self._trafficgen_loader = LoaderServant(
+            settings.getValue('TRAFFICGEN_DIR'),
+            settings.getValue('TRAFFICGEN'),
+            ITrafficGenerator)
+
+        self._metrics_loader = LoaderServant(
+            settings.getValue('COLLECTOR_DIR'),
+            settings.getValue('COLLECTOR'),
+            ICollector)
+
+        self._vswitch_loader = LoaderServant(
+            settings.getValue('VSWITCH_DIR'),
+            settings.getValue('VSWITCH'),
+            IVSwitch)
+
+    def get_trafficgen(self):
+        """Returns a new instance configured traffic generator.
+
+        :return: ITrafficGenerator implementation if available, None otherwise.
+        """
+        return self._trafficgen_loader.get_class()()
+
+    def get_trafficgen_class(self):
+        """Returns type of currently configured traffic generator.
+
+        :return: Type of ITrafficGenerator implementation if available.
+            None otherwise.
+        """
+        return self._trafficgen_loader.get_class()
+
+    def get_trafficgens(self):
+        """Returns dictionary of all available traffic generators.
+
+        :return: Dictionary of traffic generators.
+            - key: name of the class which implements ITrafficGenerator,
+            - value: Type of traffic generator which implements
+              ITrafficGenerator.
+        """
+        return self._trafficgen_loader.get_classes()
+
+    def get_trafficgens_printable(self):
+        """Returns all available traffic generators in printable format.
+
+        :return: String containing printable list of traffic generators.
+        """
+        return self._trafficgen_loader.get_classes_printable()
+
+    def get_collector(self):
+        """Returns instance of currently configured collector implementation.
+
+        :return: ICollector implementation if available, None otherwise.
+        """
+        return self._metrics_loader.get_class()()
+
+    def get_collector_class(self):
+        """Returns type of currently configured collector implementation.
+
+        :return: Type of ICollector implementation if available.
+            None otherwise.
+        """
+        return self._metrics_loader.get_class()
+
+    def get_collectors(self):
+        """Returns dictionary of all available collectors.
+
+        :return: Dictionary of collectors.
+            - key: name of the class which implements ICollector,
+            - value: Type of traffic generator which implements ICollector.
+        """
+        return self._metrics_loader.get_classes()
+
+    def get_collectors_printable(self):
+        """Returns all available collectors in printable format.
+
+        :return: String containing printable list of collectors.
+        """
+        return self._metrics_loader.get_classes_printable()
+
+    def get_vswitch(self):
+        """Returns instance of currently configured vswitch implementation.
+
+        :return: IVSwitch implementation if available, None otherwise.
+        """
+        return self._vswitch_loader.get_class()()
+
+    def get_vswitch_class(self):
+        """Returns type of currently configured vswitch implementation.
+
+        :return: Type of IVSwitch implementation if available.
+            None otherwise.
+        """
+        return self._vswitch_loader.get_class()
+
+    def get_vswitches(self):
+        """Returns dictionary of all available vswitches.
+
+        :return: Dictionary of vswitches.
+            - key: name of the class which implements IVSwitch,
+            - value: Type of traffic generator which implements IVSwitch.
+        """
+        return self._vswitch_loader.get_classes()
+
+    def get_vswitches_printable(self):
+        """Returns all available vswitches in printable format.
+
+        :return: String containing printable list of vswitches.
+        """
+        return self._vswitch_loader.get_classes_printable()
+
+    def get_vnf_class(self):
+        """Returns a new instance of the configured VNF
+
+        Currently always returns None
+        """
+        #TODO: Load the VNF class
+        return None
diff --git a/core/loader/loader_servant.py b/core/loader/loader_servant.py
new file mode 100644
index 00000000..7966532c
--- /dev/null
+++ b/core/loader/loader_servant.py
@@ -0,0 +1,180 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Loader servant module used by Loader.
+
+Module is inteded to be private to serve only Loader itself, nevertheless
+some methods are exposed outside and can be used by any other clients:
+- load_modules(self, path, interface)
+- load_module(self, path, interface, class_name)
+Those method are stateless static members.
+
+"""
+import os
+from os import sys
+import imp
+import fnmatch
+import logging
+
+
+class LoaderServant(object):
+    """Class implements basic dynamic import operations.
+    """
+    _class_name = None
+    _path = None
+    _interface = None
+
+    def __init__(self, path, class_name, interface):
+        """LoaderServant constructor
+
+        Intializes all data needed for import operations.
+
+        Attributes:
+            path: path to directory which contains implementations derived from
+                    interface.
+            class_name: Class name which will be returned in get_class
+                        method, if such definition exists in directory
+                        represented by path,
+            interface: interface type. Every object which doesn't
+                        implement this particular interface will be
+                        filtered out.
+        """
+        self._class_name = class_name
+        self._path = path
+        self._interface = interface
+
+    def get_class(self):
+        """Returns class type based on parameters passed in __init__.
+
+        :return: Type of the found class.
+            None if class hasn't been found
+        """
+
+        return self.load_module(path=self._path,
+                                interface=self._interface,
+                                class_name=self._class_name)
+
+    def get_classes(self):
+        """Returns all classes in path derived from interface
+
+        :return: Dictionary with following data:
+            - key: String representing class name,
+            - value: Class type.
+        """
+        return self.load_modules(path=self._path,
+                                 interface=self._interface)
+
+    def get_classes_printable(self):
+        """Returns all classes derived from _interface found in path
+
+        :return: String - list of classes in printable format.
+        """
+
+        out = self.load_modules(path=self._path,
+                                interface=self._interface)
+        results = []
+
+        for (name, mod) in list(out.items()):
+            desc = (mod.__doc__ or 'No description').strip().split('\n')[0]
+            results.append((name, desc))
+
+        output = [
+            'Classes derived from: ' + self._interface.__name__ + '\n======\n']
+
+        for (name, desc) in results:
+            output.append('* %-18s%s' % ('%s:' % name, desc))
+
+            output.append('')
+
+        output.append('')
+
+        return '\n'.join(output)
+
+    @staticmethod
+    def load_module(path, interface, class_name):
+        """Imports everything from given path and returns class type
+
+        This is based on following conditions:
+            - Class is derived from interface,
+            - Class type name matches class_name.
+
+        :return: Type of the found class.
+            None if class hasn't been found
+        """
+
+        results = LoaderServant.load_modules(
+            path=path, interface=interface)
+
+        if class_name in results:
+            logging.info(
+                "Class found: " + class_name + ".")
+            return results.get(class_name)
+
+        return None
+
+    @staticmethod
+    def load_modules(path, interface):
+        """Returns dictionary of class name/class type found in path
+
+        This is based on following conditions:
+            - classes found under path are derived from interface.
+            - class is not interface itself.
+
+        :return: Dictionary with following data:
+            - key: String representing class name,
+            - value: Class type.
+        """
+        result = {}
+
+        for _, mod in LoaderServant._load_all_modules(path):
+            # find all system metric loggers defined in the module
+            gens = dict((k, v) for (k, v) in list(mod.__dict__.items())
+                        if type(v) == type and
+                        issubclass(v, interface) and k != interface.__name__)
+            if gens:
+                for (genname, gen) in list(gens.items()):
+                    result[genname] = gen
+        return result
+
+    @staticmethod
+    def _load_all_modules(path):
+        """Load all modules from ``path`` directory.
+
+        This is based on the design used by OFTest:
+            https://github.com/floodlight/oftest/blob/master/oft
+
+        :param path: Path to a folder of modules.
+
+        :return: List of modules in a folder.
+        """
+        mods = []
+
+        for root, _, filenames in os.walk(path):
+            # Iterate over each python file
+            for filename in fnmatch.filter(filenames, '[!.]*.py'):
+                modname = os.path.splitext(os.path.basename(filename))[0]
+
+                try:
+                    if modname in sys.modules:
+                        mod = sys.modules[modname]
+                    else:
+                        mod = imp.load_module(
+                            modname, *imp.find_module(modname, [root]))
+                except ImportError:
+                    logging.error('Could not import file ' + filename)
+                    raise
+
+                mods.append((modname, mod))
+
+        return mods
diff --git a/core/results/__init__.py b/core/results/__init__.py
new file mode 100644
index 00000000..38521211
--- /dev/null
+++ b/core/results/__init__.py
@@ -0,0 +1,17 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Results package contains the core IResults interface
+"""
+
+from core.results import results
diff --git a/core/results/results.py b/core/results/results.py
new file mode 100644
index 00000000..f73f6af5
--- /dev/null
+++ b/core/results/results.py
@@ -0,0 +1,36 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""IResult interface definition.
+"""
+
+class IResults(object):
+    """Abstract class defining an interface for gathering results
+    """
+    def print_results(self):
+        """Prints gathered results to screen.
+        """
+        raise NotImplementedError("This class does not implement the" \
+                                  " \"print_results\" function.")
+
+    def get_results(self):
+        """Returns gathered results as a list of dictionaries.
+
+        Each list element represents one record of data.
+
+        :return: Results dictionary
+            - key: Column name
+            - value: Column value.
+        """
+        raise NotImplementedError("This class does not implement the" \
+                                  " \"get_results\" function.")
diff --git a/core/results/results_constants.py b/core/results/results_constants.py
new file mode 100644
index 00000000..2af3f8d8
--- /dev/null
+++ b/core/results/results_constants.py
@@ -0,0 +1,77 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""ResultsConstants class
+"""
+
+class ResultsConstants(object):
+    """Constant fields holder used by various IResult implementations.
+    """
+    TYPE = 'type'
+    ID = 'id'
+    PACKET_SIZE = 'packet_size'
+    DEPLOYMENT = 'deployment'
+
+    UNKNOWN_VALUE = "Unknown"
+
+    #Traffic Constants
+    #RFC2544 Throughput & Continuous
+    THROUGHPUT_TX_FPS = 'throughput_tx_fps'
+    THROUGHPUT_RX_FPS = 'throughput_rx_fps'
+    THROUGHPUT_TX_MBPS = 'throughput_tx_mbps'
+    THROUGHPUT_RX_MBPS = 'throughput_rx_mbps'
+    THROUGHPUT_TX_PERCENT = 'throughput_tx_percent'
+    THROUGHPUT_RX_PERCENT = 'throughput_rx_percent'
+    MIN_LATENCY_NS = 'min_latency_ns'
+    MAX_LATENCY_NS = 'max_latency_ns'
+    AVG_LATENCY_NS = 'avg_latency_ns'
+    #Burst traffic
+    TX_FRAMES = 'tx_frames'
+    RX_FRAMES = 'rx_frames'
+    TX_BYTES = 'tx_bytes'
+    RX_BYTES = 'rx_bytes'
+    PAYLOAD_ERR = 'payload_err'
+    SEQ_ERR = 'seq_err'
+    #Back2Back
+    B2B_RX_FPS = 'b2b_rx_fps'
+    B2B_TX_FPS = 'b2b_tx_fps'
+    B2B_RX_PERCENT = 'b2b_rx_percent'
+    B2B_TX_PERCENT = 'b2b_tx_percent'
+    B2B_TX_COUNT = 'b2b_tx_count'
+    B2B_FRAMES = 'b2b_frames'
+    B2B_FRAME_LOSS_FRAMES = 'b2b_frame_loss_frames'
+    B2B_FRAME_LOSS_PERCENT = 'b2b_frame_loss_percent'
+
+    @staticmethod
+    def get_traffic_constants():
+        """Method returns all Constants used to store results.
+
+        These data can be used to generate final output.
+
+        :return: List of Strings which contains column names used as a result
+        This applies to any traffic(RFC2544 throughput or continuous flow)
+        operation.
+        """
+        return [ResultsConstants.TYPE,
+                ResultsConstants.ID,
+                ResultsConstants.PACKET_SIZE,
+                ResultsConstants.DEPLOYMENT,
+                ResultsConstants.THROUGHPUT_TX_FPS,
+                ResultsConstants.THROUGHPUT_RX_FPS,
+                ResultsConstants.THROUGHPUT_TX_MBPS,
+                ResultsConstants.THROUGHPUT_RX_MBPS,
+                ResultsConstants.THROUGHPUT_TX_PERCENT,
+                ResultsConstants.THROUGHPUT_RX_PERCENT,
+                ResultsConstants.MIN_LATENCY_NS,
+                ResultsConstants.MAX_LATENCY_NS,
+                ResultsConstants.AVG_LATENCY_NS]
diff --git a/core/traffic_controller.py b/core/traffic_controller.py
new file mode 100644
index 00000000..428e91f8
--- /dev/null
+++ b/core/traffic_controller.py
@@ -0,0 +1,60 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Interface to traffic controllers
+"""
+
+class ITrafficController(object):
+    """Abstract class which defines a traffic controller object
+
+    Used to setup and control a traffic generator for a particular deployment
+    scenario.
+    """
+
+    def send_traffic(self, traffic):
+        """Triggers traffic to be sent from the traffic generator.
+
+        This is a blocking function.
+
+        :param traffic: A dictionary describing the traffic to send.
+        """
+        raise NotImplementedError(
+            "The TrafficController does not implement",
+            "the \"send_traffic\" function.")
+
+    def send_traffic_async(self, traffic, function):
+        """Triggers traffic to be sent  asynchronously.
+
+        This is not a blocking function.
+
+        :param traffic: A dictionary describing the traffic to send.
+        :param function: A dictionary describing the function to call between
+             send and wait in the form:
+             function = {
+                 'function' : package.module.function,
+                 'args' : args
+             }
+             If this function requires more than one argument, all should be
+             should be passed using the args list and appropriately handled.
+         """
+        raise NotImplementedError(
+            "The TrafficController does not implement",
+            "the \"send_traffic_async\" function.")
+
+    def stop_traffic(self):
+        """Kills traffic being sent from the traffic generator.
+        """
+        raise NotImplementedError(
+            "The TrafficController does not implement",
+            "the \"stop_traffic\" function.")
diff --git a/core/traffic_controller_rfc2544.py b/core/traffic_controller_rfc2544.py
new file mode 100644
index 00000000..003307bf
--- /dev/null
+++ b/core/traffic_controller_rfc2544.py
@@ -0,0 +1,135 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""RFC2544 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 TrafficControllerRFC2544(ITrafficController, IResults):
+    """Traffic controller for RFC2544 traffic
+
+    Used to setup and control a traffic generator for an RFC2544 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._packet_sizes = settings.getValue('TRAFFICGEN_PKT_SIZES')
+        self._trials = get_test_param('rfc2544_trials', 1)
+        self._results = []
+
+    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 addictional entries.
+        """
+
+        ret_value = result_dict
+
+        #TODO Old TOIT controller had knowledge about scenario beeing
+        #executed, should new controller also fill Configuration & ID,
+        # or this should be passed to TestCase?
+        ret_value[ResultsConstants.TYPE] = 'rfc2544'
+        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:
+            traffic['l2'] = {'framesize': packet_size}
+            result = self._traffic_gen_class.send_rfc2544_throughput(
+                traffic,
+                trials=int(self._trials),
+                duration=int(get_test_param('rfc2544_duration', 20)))
+            result = TrafficControllerRFC2544._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_rfc2544_throughput(
+                traffic,
+                trials=int(self._trials),
+                duration=int(get_test_param('rfc2544_duration', 20)))
+            self._traffic_started = True
+            if len(function['args']) > 0:
+                function['function'](function['args'])
+            else:
+                function['function']()
+            result = self._traffic_gen_class.wait_rfc2544_throughput()
+            result = TrafficControllerRFC2544._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
diff --git a/core/vnf_controller.py b/core/vnf_controller.py
new file mode 100644
index 00000000..be1c7c4a
--- /dev/null
+++ b/core/vnf_controller.py
@@ -0,0 +1,48 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" VNF Controller interface
+"""
+
+class IVnfController(object):
+    """Abstract class which defines a VNF controller
+
+    Used to set-up and control a VNF provider for a particular
+    deployment scenario.
+    """
+
+    def get_vnfs(self):
+        """Returns a list of vnfs controlled by this controller.
+        """
+        raise NotImplementedError(
+            "The VnfController does not implement",
+            "the \"get_vnfs\" function.")
+
+    #TODO: Decide on contextmanager or __enter/exit__ strategy <MH 2015-05-01>
+    def start(self):
+        """Boots all VNFs set-up by __init__.
+
+        This is a blocking function.
+        """
+        raise NotImplementedError(
+            "The VnfController does not implement",
+            "the \"start\" function.")
+
+    def stop(self):
+        """Stops all VNFs set-up by __init__.
+
+        This is a blocking function.
+        """
+        raise NotImplementedError(
+            "The VnfController does not implement",
+            "the \"stop\" function.")
diff --git a/core/vnf_controller_p2p.py b/core/vnf_controller_p2p.py
new file mode 100644
index 00000000..60161480
--- /dev/null
+++ b/core/vnf_controller_p2p.py
@@ -0,0 +1,58 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""VNF Controller for the P2P scenario
+"""
+
+import logging
+
+from core.vnf_controller import IVnfController
+
+class VnfControllerP2P(IVnfController):
+    """VNF controller for the P2P scenario.
+
+    Does nothing as there is no VNF in P2P
+
+    Attributes:
+        _vnf_class: A class object representing the VNF to be used.
+        _deployment_scenario: A string describing the scenario to set-up in the
+            constructor.
+        _vnfs: A list of vnfs controlled by the controller.
+    """
+
+    #TODO: Decide on contextmanager or __enter/exit__ strategy <MH 2015-05-01>
+    def __init__(self, vnf_class):
+        """Sets up the VNF infrastructure for the P2P deployment scenario.
+
+        :param vnf_class: The VNF class to be used, this is mostly ignored.
+        """
+        self._logger = logging.getLogger(__name__)
+        self._vnf_class = vnf_class
+        self._deployment_scenario = "P2P"
+        self._logger.debug('__init__ with ' + str(self._vnf_class))
+
+    def get_vnfs(self):
+        """Returns an empty list of vnfs.
+        """
+        self._logger.debug('get_vnfs with ' + str(self._vnf_class))
+        return []
+
+    def start(self):
+        """Starts nothing.
+        """
+        self._logger.debug('start with ' + str(self._vnf_class))
+
+    def stop(self):
+        """Stops nothing.
+        """
+        self._logger.debug('stop with ' + str(self._vnf_class))
diff --git a/core/vnf_controller_pvp.py b/core/vnf_controller_pvp.py
new file mode 100644
index 00000000..16c21869
--- /dev/null
+++ b/core/vnf_controller_pvp.py
@@ -0,0 +1,60 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""VNF Controller for the PVP scenario
+"""
+
+import logging
+
+from core.vnf_controller import IVnfController
+
+class VnfControllerPVP(IVnfController):
+    """VNF controller for the PVP scenario.
+
+    Used to set-up and control a VNF provider for the PVP scenario.
+
+    Attributes:
+        _vnf_class: A class object representing the VNF to be used.
+        _deployment_scenario: A string describing the scenario to set-up in the
+            constructor.
+        _vnfs: A list of vnfs controlled by the controller.
+    """
+
+    #TODO: Decide on contextmanager or __enter/exit__ strategy <MH 2015-05-01>
+    def __init__(self, vnf_class):
+        """Sets up the VNF infrastructure for the PVP deployment scenario.
+
+        :param vnf_class: The VNF class to be used.
+        """
+        self._logger = logging.getLogger(__name__)
+        self._vnf_class = vnf_class
+        self._deployment_scenario = "PVP"
+        self._vnfs = []
+        self._logger.debug('__init__ with ' + str(self._vnf_class))
+        #TODO call vnf.xxx to carry out the required setup
+
+    def get_vnfs(self):
+        """See IVnfController for description
+        """
+        self._logger.debug('get_vnfs with ' + str(self._vnf_class))
+        return self._vnfs
+
+    def start(self):
+        """See IVnfController for description
+        """
+        self._logger.debug('start with ' + str(self._vnf_class))
+
+    def stop(self):
+        """See IVnfController for description
+        """
+        self._logger.debug('stop with ' + str(self._vnf_class))
diff --git a/core/vswitch_controller.py b/core/vswitch_controller.py
new file mode 100644
index 00000000..1caf94fb
--- /dev/null
+++ b/core/vswitch_controller.py
@@ -0,0 +1,50 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Interface for deployment specific vSwitch controllers
+"""
+
+class IVswitchController(object):
+    """Abstract class which defines a vSwitch controller object
+
+    This interface is used to setup and control a vSwitch provider for a
+    particular deployment scenario.
+    """
+    def setup(self):
+        """Sets up the switch for the particular deployment scenario
+        """
+        raise NotImplementedError(
+            "The VswitchController does not implement the \"setup\" function.")
+    def stop(self):
+        """Tears down the switch created in setup()
+        """
+        raise NotImplementedError(
+            "The VswitchController does not implement the \"stop\" function.")
+
+    def get_vswitch(self):
+        """Get the controlled vSwitch
+
+        :return: The controlled IVswitch
+        """
+        raise NotImplementedError(
+            "The VswitchController does not implement the \"get_vswitch\" "
+            "function.")
+
+    def get_ports_info(self):
+        """Returns a dictionary describing all ports on the vSwitch.
+
+        See IVswitch for dictionary structure details
+        """
+        raise NotImplementedError(
+            "The VswitchController does not implement the \"get_ports_info\" "
+            "function.")
diff --git a/core/vswitch_controller_p2p.py b/core/vswitch_controller_p2p.py
new file mode 100644
index 00000000..ceb29aa9
--- /dev/null
+++ b/core/vswitch_controller_p2p.py
@@ -0,0 +1,90 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""VSwitch controller for Physical to Physical deployment
+"""
+
+import logging
+
+from core.vswitch_controller import IVswitchController
+from vswitches.utils import add_ports_to_flow
+
+_FLOW_TEMPLATE = {
+    'idle_timeout': '0'
+}
+BRIDGE_NAME = 'br0'
+
+class VswitchControllerP2P(IVswitchController):
+    """VSwitch controller for P2P deployment scenario.
+
+    Attributes:
+        _vswitch_class: The vSwitch class to be used.
+        _vswitch: The vSwitch object controlled by this controller
+        _deployment_scenario: A string describing the scenario to set-up in the
+            constructor.
+    """
+    def __init__(self, vswitch_class):
+        """Initializes up the prerequisites for the P2P deployment scenario.
+
+        :vswitch_class: the vSwitch class to be used.
+        """
+        self._logger = logging.getLogger(__name__)
+        self._vswitch_class = vswitch_class
+        self._vswitch = vswitch_class()
+        self._deployment_scenario = "P2P"
+        self._logger.debug('Creation using ' + str(self._vswitch_class))
+
+    def setup(self):
+        """Sets up the switch for p2p.
+        """
+        self._logger.debug('Setup using ' + str(self._vswitch_class))
+
+        try:
+            self._vswitch.start()
+
+            self._vswitch.add_switch(BRIDGE_NAME)
+
+            (_, phy1_number) = self._vswitch.add_phy_port(BRIDGE_NAME)
+            (_, phy2_number) = self._vswitch.add_phy_port(BRIDGE_NAME)
+
+            self._vswitch.del_flow(BRIDGE_NAME)
+            flow = add_ports_to_flow(_FLOW_TEMPLATE, phy1_number, phy2_number)
+            self._vswitch.add_flow(BRIDGE_NAME, flow)
+
+        except:
+            self._vswitch.stop()
+            raise
+
+    def stop(self):
+        """Tears down the switch created in setup().
+        """
+        self._logger.debug('Stop using ' + str(self._vswitch_class))
+        self._vswitch.stop()
+
+    def __enter__(self):
+        self.setup()
+
+    def __exit__(self, type_, value, traceback):
+        self.stop()
+
+    def get_vswitch(self):
+        """See IVswitchController for description
+        """
+        return self._vswitch
+
+    def get_ports_info(self):
+        """See IVswitchController for description
+        """
+        self._logger.debug('get_ports_info  using ' + str(self._vswitch_class))
+        return self._vswitch.get_ports(BRIDGE_NAME)
diff --git a/core/vswitch_controller_pvp.py b/core/vswitch_controller_pvp.py
new file mode 100644
index 00000000..c0286323
--- /dev/null
+++ b/core/vswitch_controller_pvp.py
@@ -0,0 +1,69 @@
+# Copyright 2015 Intel Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""VSwitch controller for Physical to VM to Physical deployment
+"""
+
+import logging
+
+from core.vswitch_controller import IVswitchController
+
+class VswitchControllerPVP(IVswitchController):
+    """VSwitch controller for PVP deployment scenario.
+
+    Attributes:
+        _vswitch_class: The vSwitch class to be used.
+        _vswitch: The vSwitch object controlled by this controller
+        _deployment_scenario: A string describing the scenario to set-up in the
+            constructor.
+    """
+    def __init__(self, vswitch_class):
+        """Initializes up the prerequisites for the PVP deployment scenario.
+
+        :vswitch_class: the vSwitch class to be used.
+        """
+        self._logger = logging.getLogger(__name__)
+        self._vswitch_class = vswitch_class
+        self._vswitch = vswitch_class()
+        self._deployment_scenario = "PVP"
+        self._logger.debug('Creation using ' + str(self._vswitch_class))
+
+    def setup(self):
+        """
+        Sets up the switch for the particular deployment scenario passed in to
+        the constructor.
+        """
+        # TODO call IVSwitch methods to configure VSwitch for PVP scenario.
+        self._logger.debug('Setup using ' + str(self._vswitch_class))
+
+    def stop(self):
+        """
+        Tears down the switch created in setup().
+        """
+        # TODO call IVSwitch methods to stop VSwitch for PVP scenario.
+        self._logger.debug('Stop using ' + str(self._vswitch_class))
+
+    def get_vswitch(self):
+        """See IVswitchController for description
+        """
+        return self._vswitch
+
+    def get_ports_info(self):
+        """See IVswitchController for description
+        """
+        self._logger.debug('get_ports_info  using ' + str(self._vswitch_class))
+        return []
+
+
+