Introducing Generic framework to do pre-deployment VNF & Network service testing

This patch introduces the framework which is aligned with ETSI-TST001

This patch adds:
1. NetworkServiceTestCase introduces following functions
      --> setup
            --> Verify if infrastructure mapping can meet topology
            --> Load VNF models
            --> Fill traffic profile with information from topology
            --> Provision VNFs
            --> Run experiment (traffic)
      --> run -> Yardstick calls run() at intervals defined in the yaml
                 and produces timestamped samples
      --> teardown --> Stop  VNFs

2. TrafficProfile is a generic class to get traffic profile for a given
   testcase and select the traffic generator for testcase.

3. QueueFileWrapper is a class to send/recive cmds to vnf

4. GenericVNF is a generic class to instantiate VNF

5. GenericTrafficGen is a generic class to run/listen/verify traffic.

JIRA: YARDSTICK-483
Change-Id: Ic453c917d34dcb508a7f3afb459011da85f6402e
Signed-off-by: Deepak S <deepak.s@linux.intel.com>

7 files changed, 790 insertions, 0 deletions

diff --git a/yardstick/benchmark/scenarios/networking/vnf_generic.py b/yardstick/benchmark/scenarios/networking/vnf_generic.py
new file mode 100644
index 000000000..d7ba418c3
--- /dev/null
+++ b/yardstick/benchmark/scenarios/networking/vnf_generic.py
@@ -0,0 +1,328 @@
+# Copyright (c) 2016-2017 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.
+""" NSPerf specific scenario definition """
+
+from __future__ import absolute_import
+import logging
+from contextlib import contextmanager
+import yaml
+
+from yardstick.benchmark.scenarios import base
+from yardstick.common.utils import import_modules_from_package, itersubclasses
+from yardstick.network_services.collector.subscriber import Collector
+from yardstick.network_services.vnf_generic import vnfdgen
+from yardstick.network_services.vnf_generic.vnf.base import GenericVNF
+from yardstick.network_services.traffic_profile.base import TrafficProfile
+from yardstick import ssh
+
+LOG = logging.getLogger(__name__)
+
+
+class SSHError(Exception):
+    """Class handles ssh connection error exception"""
+    pass
+
+
+class SSHTimeout(SSHError):
+    """Class handles ssh connection timeout exception"""
+    pass
+
+
+class IncorrectConfig(Exception):
+    """Class handles incorrect configuration during setup"""
+    pass
+
+
+class IncorrectSetup(Exception):
+    """Class handles incorrect setup during setup"""
+    pass
+
+
+@contextmanager
+def ssh_manager(node):
+    """
+    args -> network device mappings
+    returns -> ssh connection ready to be used
+    """
+    conn = None
+    try:
+        ssh_port = node.get("ssh_port", ssh.DEFAULT_PORT)
+        conn = ssh.SSH(user=node.get("user", ""),
+                       host=node.get("ip", ""),
+                       password=node.get("password", ""),
+                       port=ssh_port)
+        conn.wait()
+
+    except (SSHError) as error:
+        LOG.info("connect failed to %s, due to %s", node.get("ip", ""), error)
+    try:
+        if conn:
+            yield conn
+        else:
+            yield False
+    finally:
+        if conn:
+            conn.close()
+
+
+class NetworkServiceTestCase(base.Scenario):
+    """Class handles Generic framework to do pre-deployment VNF &
+       Network service testing  """
+
+    __scenario_type__ = "NSPerf"
+
+    def __init__(self, scenario_cfg, context_cfg):  # Yardstick API
+        super(NetworkServiceTestCase, self).__init__()
+        self.scenario_cfg = scenario_cfg
+        self.context_cfg = context_cfg
+
+        # fixme: create schema to validate all fields have been provided
+        with open(scenario_cfg["topology"]) as stream:
+            self.topology = yaml.load(stream)["nsd:nsd-catalog"]["nsd"][0]
+        self.vnfs = []
+        self.collector = None
+        self.traffic_profile = None
+
+    @classmethod
+    def _get_traffic_flow(cls, scenario_cfg):
+        try:
+            with open(scenario_cfg["traffic_options"]["flow"]) as fflow:
+                flow = yaml.load(fflow)
+        except (KeyError, IOError, OSError):
+            flow = {}
+        return flow
+
+    @classmethod
+    def _get_traffic_imix(cls, scenario_cfg):
+        try:
+            with open(scenario_cfg["traffic_options"]["imix"]) as fimix:
+                imix = yaml.load(fimix)
+        except (KeyError, IOError, OSError):
+            imix = {}
+        return imix
+
+    @classmethod
+    def _get_traffic_profile(cls, scenario_cfg, context_cfg):
+        traffic_profile_tpl = ""
+        private = {}
+        public = {}
+        try:
+            with open(scenario_cfg["traffic_profile"]) as infile:
+                traffic_profile_tpl = infile.read()
+
+        except (KeyError, IOError, OSError):
+            raise
+
+        return [traffic_profile_tpl, private, public]
+
+    def _fill_traffic_profile(self, scenario_cfg, context_cfg):
+        traffic_profile = {}
+
+        flow = self._get_traffic_flow(scenario_cfg)
+
+        imix = self._get_traffic_imix(scenario_cfg)
+
+        traffic_mapping, private, public = \
+            self._get_traffic_profile(scenario_cfg, context_cfg)
+
+        traffic_profile = vnfdgen.generate_vnfd(traffic_mapping,
+                                                {"imix": imix, "flow": flow,
+                                                 "private": private,
+                                                 "public": public})
+
+        return TrafficProfile.get(traffic_profile)
+
+    @classmethod
+    def _find_vnf_name_from_id(cls, topology, vnf_id):
+        return next((vnfd["vnfd-id-ref"]
+                     for vnfd in topology["constituent-vnfd"]
+                     if vnf_id == vnfd["member-vnf-index"]), None)
+
+    def _resolve_topology(self, context_cfg, topology):
+        for vld in topology["vld"]:
+            if len(vld["vnfd-connection-point-ref"]) > 2:
+                raise IncorrectConfig("Topology file corrupted, "
+                                      "too many endpoint for connection")
+
+            node_0, node_1 = vld["vnfd-connection-point-ref"]
+
+            node0 = self._find_vnf_name_from_id(topology,
+                                                node_0["member-vnf-index-ref"])
+            node1 = self._find_vnf_name_from_id(topology,
+                                                node_1["member-vnf-index-ref"])
+
+            if0 = node_0["vnfd-connection-point-ref"]
+            if1 = node_1["vnfd-connection-point-ref"]
+
+            try:
+                nodes = context_cfg["nodes"]
+                nodes[node0]["interfaces"][if0]["vld_id"] = vld["id"]
+                nodes[node1]["interfaces"][if1]["vld_id"] = vld["id"]
+
+                nodes[node0]["interfaces"][if0]["dst_mac"] = \
+                    nodes[node1]["interfaces"][if1]["local_mac"]
+                nodes[node0]["interfaces"][if0]["dst_ip"] = \
+                    nodes[node1]["interfaces"][if1]["local_ip"]
+
+                nodes[node1]["interfaces"][if1]["dst_mac"] = \
+                    nodes[node0]["interfaces"][if0]["local_mac"]
+                nodes[node1]["interfaces"][if1]["dst_ip"] = \
+                    nodes[node0]["interfaces"][if0]["local_ip"]
+            except KeyError:
+                raise IncorrectConfig("Required interface not found,"
+                                      "topology file corrupted")
+
+    @classmethod
+    def _find_list_index_from_vnf_idx(cls, topology, vnf_idx):
+        return next((topology["constituent-vnfd"].index(vnfd)
+                     for vnfd in topology["constituent-vnfd"]
+                     if vnf_idx == vnfd["member-vnf-index"]), None)
+
+    def _update_context_with_topology(self, context_cfg, topology):
+        for idx in topology["constituent-vnfd"]:
+            vnf_idx = idx["member-vnf-index"]
+            nodes = context_cfg["nodes"]
+            node = self._find_vnf_name_from_id(topology, vnf_idx)
+            list_idx = self._find_list_index_from_vnf_idx(topology, vnf_idx)
+            nodes[node].update(topology["constituent-vnfd"][list_idx])
+
+    def map_topology_to_infrastructure(self, context_cfg, topology):
+        """ This method should verify if the available resources defined in pod.yaml
+        match the topology.yaml file.
+
+        :param topology:
+        :return: None. Side effect: context_cfg is updated
+        """
+
+        for node, node_dict in context_cfg["nodes"].items():
+
+            cmd = "PATH=$PATH:/sbin:/usr/sbin ip addr show"
+            with ssh_manager(node_dict) as conn:
+                exit_status = conn.execute(cmd)[0]
+                if exit_status != 0:
+                    raise IncorrectSetup("Node's %s lacks ip tool." % node)
+
+                for interface in node_dict["interfaces"]:
+                    network = node_dict["interfaces"][interface]
+                    keys = ["vpci", "local_ip", "netmask",
+                            "local_mac", "driver", "dpdk_port_num"]
+                    missing = set(keys).difference(network)
+                    if missing:
+                        raise IncorrectConfig("Require interface fields '%s' "
+                                              "not found, topology file "
+                                              "corrupted" % ', '.join(missing))
+
+        # 3. Use topology file to find connections & resolve dest address
+        self._resolve_topology(context_cfg, topology)
+        self._update_context_with_topology(context_cfg, topology)
+
+    @classmethod
+    def get_vnf_impl(cls, vnf_model):
+        """ Find the implementing class from vnf_model["vnf"]["name"] field
+
+        :param vnf_model: dictionary containing a parsed vnfd
+        :return: subclass of GenericVNF
+        """
+        import_modules_from_package(
+            "yardstick.network_services.vnf_generic.vnf")
+        expected_name = vnf_model['id']
+        impl = [c for c in itersubclasses(GenericVNF)
+                if c.__name__ == expected_name]
+        try:
+            return next(iter(impl))
+        except StopIteration:
+            raise IncorrectConfig("No implementation for %s", expected_name)
+
+    def load_vnf_models(self, context_cfg):
+        """ Create VNF objects based on YAML descriptors
+
+        :param context_cfg:
+        :return:
+        """
+        vnfs = []
+        for node in context_cfg["nodes"]:
+            LOG.debug(context_cfg["nodes"][node])
+            with open(context_cfg["nodes"][node]["VNF model"]) as stream:
+                vnf_model = stream.read()
+            vnfd = vnfdgen.generate_vnfd(vnf_model, context_cfg["nodes"][node])
+            vnf_impl = self.get_vnf_impl(vnfd["vnfd:vnfd-catalog"]["vnfd"][0])
+            vnf_instance = vnf_impl(vnfd["vnfd:vnfd-catalog"]["vnfd"][0])
+            vnf_instance.name = node
+            vnfs.append(vnf_instance)
+
+        return vnfs
+
+    def setup(self):
+        """ Setup infrastructure, provission VNFs & start traffic
+
+        :return:
+        """
+
+        # 1. Verify if infrastructure mapping can meet topology
+        self.map_topology_to_infrastructure(self.context_cfg, self.topology)
+        # 1a. Load VNF models
+        self.vnfs = self.load_vnf_models(self.context_cfg)
+        # 1b. Fill traffic profile with information from topology
+        self.traffic_profile = self._fill_traffic_profile(self.scenario_cfg,
+                                                          self.context_cfg)
+
+        # 2. Provision VNFs
+        try:
+            for vnf in self.vnfs:
+                LOG.info("Instantiating %s", vnf.name)
+                vnf.instantiate(self.scenario_cfg, self.context_cfg)
+        except RuntimeError:
+            for vnf in self.vnfs:
+                vnf.terminate()
+            raise
+
+        # 3. Run experiment
+        # Start listeners first to avoid losing packets
+        traffic_runners = [vnf for vnf in self.vnfs if vnf.runs_traffic]
+        for traffic_gen in traffic_runners:
+            traffic_gen.listen_traffic(self.traffic_profile)
+
+        # register collector with yardstick for KPI collection.
+        self.collector = Collector(self.vnfs, self.traffic_profile)
+        self.collector.start()
+
+        # Start the actual traffic
+        for traffic_gen in traffic_runners:
+            LOG.info("Starting traffic on %s", traffic_gen.name)
+            traffic_gen.run_traffic(self.traffic_profile)
+
+    def run(self, result):  # yardstick API
+        """ Yardstick calls run() at intervals defined in the yaml and
+            produces timestamped samples
+
+        :param result: dictionary with results to update
+        :return: None
+        """
+
+        for vnf in self.vnfs:
+            # Result example:
+            # {"VNF1: { "tput" : [1000, 999] }, "VNF2": { "latency": 100 }}
+            LOG.debug("vnf")
+            result.update(self.collector.get_kpi(vnf))
+
+    def teardown(self):
+        """ Stop the collector and terminate VNF & TG instance
+
+        :return
+        """
+
+        self.collector.stop()
+        for vnf in self.vnfs:
+            LOG.info("Stopping %s", vnf.name)
+            vnf.terminate()
diff --git a/yardstick/network_services/traffic_profile/__init__.py b/yardstick/network_services/traffic_profile/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/yardstick/network_services/traffic_profile/__init__.py
diff --git a/yardstick/network_services/traffic_profile/base.py b/yardstick/network_services/traffic_profile/base.py
new file mode 100644
index 000000000..906498586
--- /dev/null
+++ b/yardstick/network_services/traffic_profile/base.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2016-2017 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.
+""" Base class for the generic traffic profile implementation """
+
+from __future__ import absolute_import
+from yardstick.common.utils import import_modules_from_package, itersubclasses
+
+
+class TrafficProfile(object):
+    """
+    This class defines the behavior
+
+    """
+
+    @staticmethod
+    def get(tp_config):
+        """Get the traffic profile instance for the given traffic type
+
+        :param tp_config: loaded YAML file
+        :return:
+        """
+        profile_class = tp_config["traffic_profile"]["traffic_type"]
+        import_modules_from_package(
+            "yardstick.network_services.traffic_profile")
+        try:
+            return next(c for c in itersubclasses(TrafficProfile)
+                        if c.__name__ == profile_class)(tp_config)
+        except StopIteration:
+            raise RuntimeError("No implementation for %s", profile_class)
+
+    def __init__(self, tp_config):
+        # e.g. RFC2544 start_ip, stop_ip, drop_rate,
+        # IMIX = {"10K": 0.1, "100M": 0.5}
+        self.params = tp_config
+
+    def execute(self, traffic_generator):
+        """ This methods defines the behavior of the traffic generator.
+        It will be called in a loop until the traffic generator exits.
+
+        :param traffic_generator: TrafficGen instance
+        :return: None
+        """
+        raise NotImplementedError()
+
+
+class DummyProfile(TrafficProfile):
+    """
+    This is an empty TrafficProfile implementation - if it is used,
+    the traffic will be completely handled by the Traffic Generator
+    implementation with no regard for the Traffic Profile.
+    """
+    def execute(self, traffic_generator):
+        pass
diff --git a/yardstick/network_services/vnf_generic/__init__.py b/yardstick/network_services/vnf_generic/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/yardstick/network_services/vnf_generic/__init__.py
diff --git a/yardstick/network_services/vnf_generic/vnf/__init__.py b/yardstick/network_services/vnf_generic/vnf/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/yardstick/network_services/vnf_generic/vnf/__init__.py
diff --git a/yardstick/network_services/vnf_generic/vnf/base.py b/yardstick/network_services/vnf_generic/vnf/base.py
new file mode 100644
index 000000000..1d770f724
--- /dev/null
+++ b/yardstick/network_services/vnf_generic/vnf/base.py
@@ -0,0 +1,327 @@
+# Copyright (c) 2016-2017 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.
+""" Base class implementation for generic vnf implementation """
+
+from __future__ import absolute_import
+import logging
+import ipaddress
+import six
+
+from yardstick.network_services.utils import get_nsb_option
+
+LOG = logging.getLogger(__name__)
+
+
+class QueueFileWrapper(object):
+    """ Class providing file-like API for talking with SSH connection """
+
+    def __init__(self, q_in, q_out, prompt):
+        self.q_in = q_in
+        self.q_out = q_out
+        self.closed = False
+        self.buf = []
+        self.bufsize = 20
+        self.prompt = prompt
+
+    def read(self, size):
+        """ read chunk from input queue """
+        if self.q_in.qsize() > 0 and size:
+            in_data = self.q_in.get()
+            return in_data
+
+    def write(self, chunk):
+        """ write chunk to output queue """
+        self.buf.append(chunk)
+        # flush on prompt or if we exceed bufsize
+
+        size = sum(len(c) for c in self.buf)
+        if self.prompt in chunk or size > self.bufsize:
+            out = ''.join(self.buf)
+            self.buf = []
+            self.q_out.put(out)
+
+    def close(self):
+        """ close multiprocessing queue """
+        pass
+
+    def clear(self):
+        """ clear queue """
+        while self.q_out.qsize() > 0:
+            self.q_out.get()
+
+
+class GenericVNF(object):
+    """ Class providing file-like API for generic VNF implementation """
+    def __init__(self, vnfd):
+        super(GenericVNF, self).__init__()
+        self.vnfd = vnfd  # fixme: parse this into a structure
+        # List of statistics we can obtain from this VNF
+        # - ETSI MANO 6.3.1.1 monitoring_parameter
+        self.kpi = self._get_kpi_definition(vnfd)
+        # Standard dictionary containing params like thread no, buffer size etc
+        self.config = {}
+        self.runs_traffic = False
+        self.name = "vnf__1"  # name in topology file
+        self.bin_path = get_nsb_option("bin_path", "")
+
+    @classmethod
+    def _get_kpi_definition(cls, vnfd):
+        """ Get list of KPIs defined in VNFD
+
+        :param vnfd:
+        :return: list of KPIs, e.g. ['throughput', 'latency']
+        """
+        return vnfd['benchmark']['kpi']
+
+    @classmethod
+    def get_ip_version(cls, ip_addr):
+        """ get ip address version v6 or v4 """
+        try:
+            address = ipaddress.ip_address(six.text_type(ip_addr))
+        except ValueError:
+            LOG.error(ip_addr, " is not valid")
+            return
+        else:
+            return address.version
+
+    def _ip_to_hex(self, ip_addr):
+        ip_to_convert = ip_addr.split(".")
+        ip_x = ip_addr
+        if self.get_ip_version(ip_addr) == 4:
+            ip_to_convert = ip_addr.split(".")
+            ip_octect = [int(octect) for octect in ip_to_convert]
+            ip_x = "{0[0]:02X}{0[1]:02X}{0[2]:02X}{0[3]:02X}".format(ip_octect)
+        return ip_x
+
+    def _get_dpdk_port_num(self, name):
+        for intf in self.vnfd['vdu'][0]['external-interface']:
+            if name == intf['name']:
+                return intf['virtual-interface']['dpdk_port_num']
+
+    def _append_routes(self, ip_pipeline_cfg):
+        if 'routing_table' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['routing_table']
+
+            where = ip_pipeline_cfg.find("arp_route_tbl")
+            link = ip_pipeline_cfg[:where]
+            route_add = ip_pipeline_cfg[where:]
+
+            tmp = route_add.find('\n')
+            route_add = route_add[tmp:]
+
+            cmds = "arp_route_tbl ="
+
+            for route in routing_table:
+                net = self._ip_to_hex(route['network'])
+                net_nm = self._ip_to_hex(route['netmask'])
+                net_gw = self._ip_to_hex(route['gateway'])
+                port = self._get_dpdk_port_num(route['if'])
+                cmd = \
+                    " ({port0_local_ip_hex},{port0_netmask_hex},{dpdk_port},"\
+                    "{port1_local_ip_hex})".format(port0_local_ip_hex=net,
+                                                   port0_netmask_hex=net_nm,
+                                                   dpdk_port=port,
+                                                   port1_local_ip_hex=net_gw)
+                cmds += cmd
+
+            cmds += '\n'
+            ip_pipeline_cfg = link + cmds + route_add
+
+        return ip_pipeline_cfg
+
+    def _append_nd_routes(self, ip_pipeline_cfg):
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            where = ip_pipeline_cfg.find("nd_route_tbl")
+            link = ip_pipeline_cfg[:where]
+            route_nd = ip_pipeline_cfg[where:]
+
+            tmp = route_nd.find('\n')
+            route_nd = route_nd[tmp:]
+
+            cmds = "nd_route_tbl ="
+
+            for route in routing_table:
+                net = route['network']
+                net_nm = route['netmask']
+                net_gw = route['gateway']
+                port = self._get_dpdk_port_num(route['if'])
+                cmd = \
+                    " ({port0_local_ip_hex},{port0_netmask_hex},{dpdk_port},"\
+                    "{port1_local_ip_hex})".format(port0_local_ip_hex=net,
+                                                   port0_netmask_hex=net_nm,
+                                                   dpdk_port=port,
+                                                   port1_local_ip_hex=net_gw)
+                cmds += cmd
+
+            cmds += '\n'
+            ip_pipeline_cfg = link + cmds + route_nd
+
+        return ip_pipeline_cfg
+
+    def _get_port0localip6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 1:
+                    return_value = route['network']
+        LOG.info("_get_port0localip6 : %s", return_value)
+        return return_value
+
+    def _get_port1localip6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 2:
+                    return_value = route['network']
+        LOG.info("_get_port1localip6 : %s", return_value)
+        return return_value
+
+    def _get_port0prefixlen6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 1:
+                    return_value = route['netmask']
+        LOG.info("_get_port0prefixlen6 : %s", return_value)
+        return return_value
+
+    def _get_port1prefixlen6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 2:
+                    return_value = route['netmask']
+        LOG.info("_get_port1prefixlen6 : %s", return_value)
+        return return_value
+
+    def _get_port0gateway6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 1:
+                    return_value = route['network']
+        LOG.info("_get_port0gateway6 : %s", return_value)
+        return return_value
+
+    def _get_port1gateway6(self):
+        return_value = ""
+        if 'nd_route_tbl' in self.vnfd['vdu'][0]:
+            routing_table = self.vnfd['vdu'][0]['nd_route_tbl']
+
+            inc = 0
+            for route in routing_table:
+                inc += 1
+                if inc == 2:
+                    return_value = route['network']
+        LOG.info("_get_port1gateway6 : %s", return_value)
+        return return_value
+
+    def instantiate(self, scenario_cfg, context_cfg):
+        """ Prepare VNF for operation and start the VNF process/VM
+
+        :param scenario_cfg:
+        :param context_cfg:
+        :return: True/False
+        """
+        raise NotImplementedError()
+
+    def terminate(self):
+        """ Kill all VNF processes
+
+        :return:
+        """
+        raise NotImplementedError()
+
+    def scale(self, flavor=""):
+        """
+
+        :param flavor:
+        :return:
+        """
+        raise NotImplementedError()
+
+    def collect_kpi(self):
+        """This method should return a dictionary containing the
+        selected KPI at a given point of time.
+
+        :return: {"kpi": value, "kpi2": value}
+        """
+        raise NotImplementedError()
+
+
+class GenericTrafficGen(GenericVNF):
+    """ Class providing file-like API for generic traffic generator """
+
+    def __init__(self, vnfd):
+        super(GenericTrafficGen, self).__init__(vnfd)
+        self.runs_traffic = True
+        self.traffic_finished = False
+        self.name = "tgen__1"  # name in topology file
+
+    def run_traffic(self, traffic_profile):
+        """ Generate traffic on the wire according to the given params.
+        Method is non-blocking, returns immediately when traffic process
+        is running. Mandatory.
+
+        :param traffic_profile:
+        :return: True/False
+        """
+        raise NotImplementedError()
+
+    def listen_traffic(self, traffic_profile):
+        """ Listen to traffic with the given parameters.
+        Method is non-blocking, returns immediately when traffic process
+        is running. Optional.
+
+        :param traffic_profile:
+        :return: True/False
+        """
+        pass
+
+    def verify_traffic(self, traffic_profile):
+        """ Verify captured traffic after it has ended. Optional.
+
+        :param traffic_profile:
+        :return: dict
+        """
+        pass
+
+    def terminate(self):
+        """ After this method finishes, all traffic processes should stop. Mandatory.
+
+        :return: True/False
+        """
+        raise NotImplementedError()
diff --git a/yardstick/network_services/vnf_generic/vnfdgen.py b/yardstick/network_services/vnf_generic/vnfdgen.py
new file mode 100644
index 000000000..9a02050a2
--- /dev/null
+++ b/yardstick/network_services/vnf_generic/vnfdgen.py
@@ -0,0 +1,71 @@
+# Copyright (c) 2016-2017 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.
+""" Generic file to map and build vnf discriptor """
+
+from __future__ import absolute_import
+import collections
+import yaml
+import six
+
+from yardstick.common.task_template import TaskTemplate
+
+
+def generate_vnfd(vnf_model, node):
+    """
+
+    :param vnf_model: VNF definition template, e.g. tg_ping_tpl.yaml
+    :param node: node configuration taken from pod.yaml
+    :return: Complete VNF Descriptor that will be taken
+             as input for GenericVNF.__init__
+    """
+    node["get"] = get
+    rendered_vnfd = TaskTemplate.render(vnf_model, **node)
+    # This is done to get rid of issues with serializing node
+    del node["get"]
+    filled_vnfd = yaml.load(rendered_vnfd)
+    return filled_vnfd
+
+
+def dict_key_flatten(data):
+    """ Convert nested dict structure to dotted key
+        (e.g. {"a":{"b":1}} -> {"a.b":1}
+
+    :param data: nested dictionary
+    :return: flat dicrionary
+    """
+    next_data = {}
+
+    if not any((isinstance(v, collections.Iterable) and not isinstance(v, str))
+               for v in data.values()):
+        return data
+
+    for key, val in six.iteritems(data):
+        if isinstance(val, collections.Mapping):
+            for n_k, n_v in six.iteritems(val):
+                next_data["%s.%s" % (key, n_k)] = n_v
+        elif isinstance(val, collections.Iterable) and not isinstance(val,
+                                                                      str):
+            for index, item in enumerate(val):
+                next_data["%s%d" % (key, index)] = item
+        else:
+            next_data[key] = val
+
+    return dict_key_flatten(next_data)
+
+
+def get(obj, key, *args):
+    """ Get template key from dictionary, get default value or raise an exception
+    """
+    data = dict_key_flatten(obj)
+    return data.get(key, *args)