3rd_party/static/onap-ui/components/directory/directory.html


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

<!--
 Copyright (c) 2019 opnfv.

 All rights reserved. This program and the accompanying materials
 are made available under the terms of the Apache License, Version 2.0
 which accompanies this distribution, and is available at
 http://www.apache.org/licenses/LICENSE-2.0
-->

<div class="container-fluid common-main-container">
  <h3>ONAP Verified Product Directory</h3>
  <div>
    <h4>Compliance Marks Granted to {{ctrl.companyID}}</h4>
    <img src="api/v1/cvp/applications/getlogo/{{ctrl.company_logo}}" alt="Company Logo">
    <table class="table table-striped table-hover">
      <thead>
        <tr>
          <th>Product Name</th>
          <th>Description</th>
          <th>Model Language</th>
          <th>Artifact Checksum (SHA256)</th>
          <th>Product Version</th>
          <th>Version</th>
          <th>Date</th>
          <th>Product Info</th>
        </tr>
      </thead>
        <tbody class="directory_inner" style="overflow: hidden; text-overflow: ellipsis;">
          <tr style="vertical-align: center;" ng-repeat="prod in ctrl.directory"
              ng-if="prod.company_name==ctrl.companyID && prod.approved=='true'">
            <td style="width: 250px;">{{ prod.xnf_name }}</td>
            <td style="width: 350px;">{{ prod.xnf_description }}</td>
            <td style="width: 350px;">{{ prod.xnfd_model_lang }}</td>
            <td style="width: 350px;">{{ prod.xnf_checksum }}</td>
            <td style="width: 150px;">{{ prod.xnf_version }}</td>
            <td style="width: 150px;">{{ prod.onap_version }}</td>
            <td style="width: 150px;">{{ prod.approve_date | limitTo: 10 }}</td>
            <td style="width: 150px;"><a href="{{ prod.company_website }}" target="_blank" rel="noopener">{{ prod.company_website }}</a></td>
          </tr>
        </tbody>
    </table>
  </div>
</div>
# Copyright 2015-2016 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.

# The 1st value of SUPPORTED_TUNNELING_PROTO is used as the default
# tunneling protocol for OP2P tests.
SUPPORTED_TUNNELING_PROTO = ['vxlan', 'gre', 'geneve']

#
# Generic test configuration options are described at conf/01_testcases.conf
#

#
# Options specific to integration testcases are described below:
#
# Required for OP2P tests
# "Tunnel Type": ["vxlan"|"gre"|"geneve"]   # Tunnel Type defines tunneling protocol to use.
#                                   # It can be overridden by cli option tunnel_type.
#                                   # Values:
#                                   #    "vxlan" - iteration of destination MAC address
#                                   #    "gre" - iteration of destination IP address
#                                   #    "geneve" - iteration of destination UDP port
#                                   # Default value is "vxlan".
#
# biDirectional testing for OP2P is not yet supported.
# biDirectional must be set to False.
#
# "TestSteps": []                   # Definition of integration test steps.
#                                   # In case that this list is defined, then
#                                   # vsperf will execute defined test steps
#                                   # one by one. It can be used to configure
#                                   # vswitch, insert flows and transmit traffic.
#                                   # It is possible to refer to result of any
#                                   # previous step through #STEP[i][j] macro.
#                                   # Where i is a number of step (starts from 0)
#                                   # and j is index of result returned by step i.

#
# Common TestSteps parts ("macros")
#

# P2P macros
STEP_VSWITCH_P2P_FLOWS_INIT = [
    ['vswitch', 'add_switch', 'int_br0'],           # STEP 0
    ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 1
    ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 2
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[2][1]', 'actions': ['output:#STEP[1][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_P2P_FLOWS_FINIT = [
    ['vswitch', 'dump_flows', 'int_br0'],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[1][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[2][1]'}],
    ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
    ['vswitch', 'del_switch', 'int_br0'],
]

# PVP and PVVP macros
STEP_VSWITCH_PVP_INIT = [
    ['vswitch', 'add_switch', 'int_br0'],           # STEP 0
    ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 1
    ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 2
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 3    vm1 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 4
]

STEP_VSWITCH_PVP_FINIT = [
    ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[3][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[4][0]'],
    ['vswitch', 'del_switch', 'int_br0'],
]

STEP_VSWITCH_PVP_FLOWS_INIT = STEP_VSWITCH_PVP_INIT + [
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[2][1]', 'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[3][1]', 'actions': ['output:#STEP[1][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_PVP_FLOWS_FINIT = [
    ['vswitch', 'dump_flows', 'int_br0'],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[1][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[4][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[2][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[3][1]'}],
] + STEP_VSWITCH_PVP_FINIT

STEP_VSWITCH_PVVP_INIT = STEP_VSWITCH_PVP_INIT + [
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 5    vm2 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 6
]

STEP_VSWITCH_PVVP_FINIT = [
    ['vswitch', 'del_port', 'int_br0', '#STEP[5][0]'],  # vm2 ports
    ['vswitch', 'del_port', 'int_br0', '#STEP[6][0]'],
] + STEP_VSWITCH_PVP_FINIT

STEP_VSWITCH_PVVP_FLOWS_INIT = STEP_VSWITCH_PVVP_INIT + [
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', 'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[6][1]', 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[2][1]', 'actions': ['output:#STEP[6][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[5][1]', 'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
    ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[3][1]', 'actions': ['output:#STEP[1][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_PVVP_FLOWS_FINIT = [
    ['vswitch', 'dump_flows', 'int_br0'],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[1][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[4][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[6][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[2][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[5][1]'}],
    ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[3][1]'}],
] + STEP_VSWITCH_PVVP_FINIT

STEP_VSWITCH_P4VP_INIT = STEP_VSWITCH_PVVP_INIT + [
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 7    vm3 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 8
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 9    vm4 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 10
]

STEP_VSWITCH_P4VP_FINIT = [
    ['vswitch', 'del_port', 'int_br0', '#STEP[7][0]'],  # vm3 ports
    ['vswitch', 'del_port', 'int_br0', '#STEP[8][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[9][0]'],  # vm4 ports
    ['vswitch', 'del_port', 'int_br0', '#STEP[10][0]'],
] + STEP_VSWITCH_PVVP_FINIT

STEP_VSWITCH_P4VP_FLOWS_INIT = STEP_VSWITCH_P4VP_INIT + [
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
                'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[6][1]', \
                'actions': ['output:#STEP[7][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[8][1]', \
                'actions': ['output:#STEP[9][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[10][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[2][1]', \
                'actions': ['output:#STEP[10][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[9][1]', \
                'actions': ['output:#STEP[8][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[7][1]', \
                'actions': ['output:#STEP[6][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[5][1]', \
                'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[3][1]', \
                'actions': ['output:#STEP[1][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_P4VP_FLOWS_FINIT = [
    ['vswitch', 'dump_flows', 'int_br0'],
    ['vswitch', 'del_flow', 'int_br0'],
] + STEP_VSWITCH_P4VP_FINIT

STEP_VSWITCH_2PHY_2VM_INIT = STEP_VSWITCH_PVVP_INIT

STEP_VSWITCH_2PHY_2VM_FINIT = STEP_VSWITCH_PVVP_FINIT

STEP_VSWITCH_2_PARALLEL_VM_FLOWS_INIT  = [
            # Setup Flows to reply ICMPv6 and similar packets, so to
            # avoid flooding the internal port with their re-transmissions
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:01', \
                'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:02', \
                'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:03', \
                'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:04', \
                'actions': ['output:#STEP[6][1]'], 'idle_timeout': '0'}],
            # Forward UDP packets depending on dest port
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '0', \
                'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '1', \
                'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
            # Send VM outputs to phy port #2
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[6][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_2PHY_4VM_INIT = STEP_VSWITCH_2PHY_2VM_INIT + [
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 7    vm3 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 8
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 9    vm4 ports
    ['vswitch', 'add_vport', 'int_br0'],            # STEP 10
]

STEP_VSWITCH_2PHY_4VM_FINIT = [
    ['vswitch', 'del_port', 'int_br0', '#STEP[7][0]'],  # vm3 ports
    ['vswitch', 'del_port', 'int_br0', '#STEP[8][0]'],
    ['vswitch', 'del_port', 'int_br0', '#STEP[9][0]'],  # vm4 ports
    ['vswitch', 'del_port', 'int_br0', '#STEP[10][0]'],
] + STEP_VSWITCH_2PHY_2VM_FINIT

STEP_VSWITCH_FLOWS_FINIT = [
    ['vswitch', 'dump_flows', 'int_br0'],
    ['vswitch', 'del_flow', 'int_br0'],
]

STEP_VSWITCH_4_PARALLEL_VM_FLOWS_INIT = [
            # Setup Flows to reply ICMPv6 and similar packets, so to
            # avoid flooding the internal port with their re-transmissions
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:01', \
                'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:02', \
                'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:03', \
                'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:04', \
                'actions': ['output:#STEP[6][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:05', \
                'actions': ['output:#STEP[7][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:06', \
                'actions': ['output:#STEP[8][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:07', \
                'actions': ['output:#STEP[9][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:08', \
                'actions': ['output:#STEP[10][1]'], 'idle_timeout': '0'}],
            # Forward UDP packets depending on dest port
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '0', \
                'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '1', \
                'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '2', \
                'actions': ['output:#STEP[7][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '3', \
                'actions': ['output:#STEP[9][1]'], 'idle_timeout': '0'}],
            # Send VM outputs to phy port #2
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[6][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[8][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[10][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_2PHY_6VM_INIT = STEP_VSWITCH_2PHY_4VM_INIT + [
            ['vswitch', 'add_vport', 'int_br0'],        # STEP 11   vm5    vhu8
            ['vswitch', 'add_vport', 'int_br0'],        # STEP 12          vhu9
            ['vswitch', 'add_vport', 'int_br0'],        # STEP 13   vm6    vhu10
            ['vswitch', 'add_vport', 'int_br0'],        # STEP 14          vhu11
]

STEP_VSWITCH_6_PARALLEL_VM_FLOWS_INIT = STEP_VSWITCH_4_PARALLEL_VM_FLOWS_INIT + [
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:09', \
                'actions': ['output:#STEP[11][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:0a', \
                'actions': ['output:#STEP[12][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:0b', \
                'actions': ['output:#STEP[13][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', \
                {'priority': '1', 'dl_src': '00:00:00:00:00:0c', \
                'actions': ['output:#STEP[14][1]'], 'idle_timeout': '0'}],
            # Forward UDP packets depending on dest port
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '4', \
                'actions': ['output:#STEP[11][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
                'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '5', \
                'actions': ['output:#STEP[13][1]'], 'idle_timeout': '0'}],
            # Send VM outputs to phy port #2
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[12][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
            ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[14][1]', \
                'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
]

STEP_VSWITCH_2PHY_6VM_FINIT = [
            ['vswitch', 'del_port', 'int_br0', '#STEP[11][0]'],  # vm5 ports
            ['vswitch', 'del_port', 'int_br0', '#STEP[12][0]'],
            ['vswitch', 'del_port', 'int_br0', '#STEP[13][0]'],  # vm6 ports
            ['vswitch', 'del_port', 'int_br0', '#STEP[14][0]'],
] + STEP_VSWITCH_2PHY_4VM_FINIT

#
# Definition of integration tests
#
INTEGRATION_TESTS = [
    {
        "Name": "overlay_p2p_mod_tput",
        "Traffic Type": "rfc2544",
        "Deployment": "ptunp",
        "biDirectional": 'True',
        "Tunnel Type": "vxlan",
        "Description": ("Tunneling Throughput RFC2544 Test."
                       "The encap and decap are performed inside the "
                       "virtual switch itself in each direction to avoid "
                       "the need of ingress overlay traffic."),
    },
    {
        "Name": "overlay_p2p_tput",
        "Traffic Type": "rfc2544",
        "Deployment": "op2p",
        "biDirectional": 'False',
        "Tunnel Type": SUPPORTED_TUNNELING_PROTO[0],
        "Tunnel Operation": "encapsulation",
        "Description": "Overlay Encapsulation Throughput RFC2544 Test",
    },
    {
        "Name": "overlay_p2p_cont",
        "Traffic Type": "continuous",
        "Deployment": "op2p",
        "biDirectional": 'False',
        "Tunnel Type": SUPPORTED_TUNNELING_PROTO[0],
        "Tunnel Operation": "encapsulation",
        "Description": "Overlay Encapsulation Continuous Stream",
    },
    {
        "Name": "overlay_p2p_decap_tput",
        "Traffic Type": "rfc2544",
        "Deployment": "op2p",
        "biDirectional": 'False',
        "Tunnel Type": SUPPORTED_TUNNELING_PROTO[0],
        "Tunnel Operation": "decapsulation",
        "Description": "Overlay Decapsulation Throughput RFC2544 Test",
    },
    {
        "Name": "overlay_p2p_decap_cont",
        "Traffic Type": "continuous",
        "Deployment": "op2p",
        "biDirectional": 'False',
        "Tunnel Type": SUPPORTED_TUNNELING_PROTO[0],
        "Tunnel Operation": "decapsulation",
        "Description": "Overlay Decapsulation Continuous Stream",
    },
    {
        "Name": "vswitch_add_del_bridge",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete bridge",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_bridges",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete bridges",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_switch', 'int_br1'],
                        ['vswitch', 'del_switch', 'int_br0'],
                        ['vswitch', 'del_switch', 'int_br1'],
                     ]
    },
    {
        "Name": "vswitch_add_del_phy_port",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete physical port",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_phy_port', 'int_br0'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_phy_ports",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete physical ports",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_phy_port', 'int_br0'],
                        ['vswitch', 'add_phy_port', 'int_br0'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_vport",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete virtual port",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_vport', 'int_br0'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_vports",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete virtual ports",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_vport', 'int_br0'],
                        ['vswitch', 'add_vport', 'int_br0'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_flow",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete flow",
        "TestSteps": [
                        ['vswitch', 'add_switch', 'int_br0'],
                        ['vswitch', 'add_phy_port', 'int_br0'],
                        ['vswitch', 'add_phy_port', 'int_br0'],
                        ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
                        ['vswitch', 'del_flow', 'int_br0', {'in_port': '#STEP[1][1]'}],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
                        ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
                        ['vswitch', 'del_switch', 'int_br0'],
                     ]
    },
    {
        "Name": "vswitch_add_del_flows",
        "Deployment": "clean",
        "Description": "vSwitch - add and delete flows",
        "TestSteps": STEP_VSWITCH_P2P_FLOWS_INIT +
                     STEP_VSWITCH_P2P_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p2p_tput",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch and execute RFC2544 throughput test",
        "TestSteps": STEP_VSWITCH_P2P_FLOWS_INIT +
                     [
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', 'bidir' : 'True'}],
                     ] +
                     STEP_VSWITCH_P2P_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p2p_back2back",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch and execute RFC2544 back2back test",
        "TestSteps": STEP_VSWITCH_P2P_FLOWS_INIT +
                     [
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', 'bidir' : 'True'}],
                     ] +
                     STEP_VSWITCH_P2P_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p2p_cont",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch and execute continuous stream test",
        "TestSteps": STEP_VSWITCH_P2P_FLOWS_INIT +
                     [
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
                     ] +
                     STEP_VSWITCH_P2P_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvp",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch and one vnf",
        "TestSteps": STEP_VSWITCH_PVP_INIT +
                     [
                        ['vnf', 'start'],
                        ['vnf', 'stop'],
                     ] +
                     STEP_VSWITCH_PVP_FINIT
    },
    {
        "Name": "vswitch_pvp_tput",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, vnf and execute RFC2544 throughput test",
        "TestSteps": STEP_VSWITCH_PVP_FLOWS_INIT +
                     [
                        ['vnf', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', 'bidir' : 'True'}],
                        ['vnf', 'stop'],
                     ] +
                     STEP_VSWITCH_PVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvp_back2back",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, vnf and execute RFC2544 back2back test",
        "TestSteps": STEP_VSWITCH_PVP_FLOWS_INIT +
                     [
                        ['vnf', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', 'bidir' : 'True'}],
                        ['vnf', 'stop'],
                     ] +
                     STEP_VSWITCH_PVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvp_cont",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, vnf and execute continuous stream test",
        "TestSteps": STEP_VSWITCH_PVP_FLOWS_INIT +
                     [
                        ['vnf', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
                        ['vnf', 'stop'],
                     ] +
                     STEP_VSWITCH_PVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvp_all",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, vnf and execute all test types",
        "TestSteps": STEP_VSWITCH_PVP_FLOWS_INIT +
                     [
                        ['vnf', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', 'bidir' : 'True'}],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', 'bidir' : 'True'}],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
                        ['vnf', 'stop'],
                     ] +
                     STEP_VSWITCH_PVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvvp",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch and two vnfs",
        "TestSteps": STEP_VSWITCH_PVVP_INIT +
                     [
                        ['vnf1', 'start'],
                        ['vnf2', 'start'],
                        ['vnf1', 'stop'],
                        ['vnf2', 'stop'],
                     ] +
                     STEP_VSWITCH_PVVP_FINIT
    },
    {
        "Name": "vswitch_pvvp_tput",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, two chained vnfs and execute RFC2544 throughput test",
        "TestSteps": STEP_VSWITCH_PVVP_FLOWS_INIT +
                     [
                        ['vnf1', 'start'],
                        ['vnf2', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', 'bidir' : 'True'}],
                        ['vnf1', 'stop'],
                        ['vnf2', 'stop'],
                     ] +
                     STEP_VSWITCH_PVVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvvp_back2back",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, two chained vnfs and execute RFC2544 back2back test",
        "TestSteps": STEP_VSWITCH_PVVP_FLOWS_INIT +
                     [
                        ['vnf1', 'start'],
                        ['vnf2', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', 'bidir' : 'True'}],
                        ['vnf1', 'stop'],
                        ['vnf2', 'stop'],
                     ] +
                     STEP_VSWITCH_PVVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvvp_cont",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, two chained vnfs and execute continuous stream test",
        "TestSteps": STEP_VSWITCH_PVVP_FLOWS_INIT +
                     [
                        ['vnf1', 'start'],
                        ['vnf2', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
                        ['vnf1', 'stop'],
                        ['vnf2', 'stop'],
                     ] +
                     STEP_VSWITCH_PVVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_pvvp_all",
        "Deployment": "clean",
        "Description": "vSwitch - configure switch, two chained vnfs and execute all test types",
        "TestSteps": STEP_VSWITCH_PVVP_FLOWS_INIT +
                     [
                        ['vnf1', 'start'],
                        ['vnf2', 'start'],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', 'bidir' : 'True'}],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', 'bidir' : 'True'}],
                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
                        ['vnf1', 'stop'],
                        ['vnf2', 'stop'],
                     ] +
                     STEP_VSWITCH_PVVP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p4vp",
        "Description": "Just configure 4 chained vnfs",
        "Deployment": "clean",
        "TestSteps": STEP_VSWITCH_P4VP_FLOWS_INIT +
        [
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
        ] +
        STEP_VSWITCH_P4VP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p4vp_tput",
        "Description": "4 chained vnfs, execute RFC2544 throughput test",
        "Deployment": "clean",
        "TestSteps": STEP_VSWITCH_P4VP_FLOWS_INIT +
        [
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', \
                'bidir' : 'True'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
        ] +
        STEP_VSWITCH_P4VP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p4vp_back2back",
        "Description": "4 chained vnfs, execute RFC2544 back2back test",
        "Deployment": "clean",
        "TestSteps": STEP_VSWITCH_P4VP_FLOWS_INIT +
        [
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', \
                'bidir' : 'True'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
        ] +
        STEP_VSWITCH_P4VP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p4vp_cont",
        "Description": "4 chained vnfs, execute continuous stream test",
        "Deployment": "clean",
        "TestSteps": STEP_VSWITCH_P4VP_FLOWS_INIT +
        [
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', \
                'bidir' : 'True'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
        ] +
        STEP_VSWITCH_P4VP_FLOWS_FINIT
    },
    {
        "Name": "vswitch_p4vp_all",
        "Description": "4 chained vnfs, execute RFC2544 throughput test",
        "Deployment": "clean",
        "TestSteps": STEP_VSWITCH_P4VP_FLOWS_INIT +
        [
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'throughput', \
                'bidir' : 'True'}],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'back2back', \
                'bidir' : 'True'}],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', \
                'bidir' : 'True'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
        ] +
        STEP_VSWITCH_P4VP_FLOWS_FINIT
    },
    {
      # Topology: 2 Parallel PVP connections
      # To run a Linux bridge as a loopback in the Guest use:
      #     --test-params "guest_loopback=linux_bridge" --integration 2pvp_udp_dest_flows
        "Name": "2pvp_udp_dest_flows",
        "Description": "Continuous TC with 2 Parallel VMs, flows on UDP Dest Port",
        "Deployment": "clean",
        "Stream Type": "L4",
        "MultiStream": 2,
        "TestSteps": STEP_VSWITCH_2PHY_2VM_INIT +
            STEP_VSWITCH_2_PARALLEL_VM_FLOWS_INIT + [
            # Start 2 VMs
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'False'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            # Clean up
        ] + STEP_VSWITCH_FLOWS_FINIT +
            STEP_VSWITCH_2PHY_2VM_FINIT
    },
    {
      # Topology: 4 Parallel PVP connections
      # To run a Linux bridge as a loopback in the Guest use:
      #     --test-params "guest_loopback=linux_bridge" --integration 4pvp_udp_dest_flows
        "Name": "4pvp_udp_dest_flows",
        "Description": "Continuous TC with 4 Parallel VMs, flows on UDP Dest Port",
        "Deployment": "clean",
        "Stream Type": "L4",
        "MultiStream": 4,
        "TestSteps": STEP_VSWITCH_2PHY_4VM_INIT +
            STEP_VSWITCH_4_PARALLEL_VM_FLOWS_INIT + [
            # Start 4 VMs
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'False'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
            # Clean up
        ] + STEP_VSWITCH_FLOWS_FINIT +
            STEP_VSWITCH_2PHY_4VM_FINIT
    },
    {
      # Topology: 6 Parallel PVP connections
      # To run a Linux bridge as a loopback in the Guest use:
      #     --test-params "guest_loopback=linux_bridge" --integration 6pvp_udp_dest_flows
        "Name": "6pvp_udp_dest_flows",
        "Description": "Continuous TC with 6 Parallel VMs, flows on UDP Dest Port",
        "Deployment": "clean",
        "Stream Type": "L4",
        "MultiStream": 6,
        "TestSteps": STEP_VSWITCH_2PHY_6VM_INIT +
            STEP_VSWITCH_6_PARALLEL_VM_FLOWS_INIT + [
            # Start VMs
            ['vnf1', 'start'],
            ['vnf2', 'start'],
            ['vnf3', 'start'],
            ['vnf4', 'start'],
            ['vnf5', 'start'],
            ['vnf6', 'start'],
            ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'False'}],
            ['vnf1', 'stop'],
            ['vnf2', 'stop'],
            ['vnf3', 'stop'],
            ['vnf4', 'stop'],
            ['vnf5', 'stop'],
            ['vnf6', 'stop'],
        ] + STEP_VSWITCH_FLOWS_FINIT +
        STEP_VSWITCH_2PHY_6VM_FINIT
    },
    {
        # Testcase for verification of vHost User NUMA awareness feature
        # introduced in DPDK v2.2. Test case will execute two VNFs, each
        # pinned to different NUMA slot. After that it will verify that
        # QEMU and PMD threads serving its interfaces are co-located
        # at the same NUMA slot.
        #
        # Prerequisites:
        #     * architecture with at least 2 NUMA slots
        #     * OVS with DPDK support and DPDK v2.2 and newer
        #     * OVS configuration utilizing both NUMA slots
        #
        #     Example of OVS configuration valid for DPDK v16.04 and cores
        #     split between NUMA slots as follows:
        #           node 0 cpus: 0 1 2 3 4 5 6 7 8 9
        #           node 1 cpus: 10 11 12 13 14 15 16 17 18 19
        #
        #     VSWITCH_PMD_CPU_MASK = '1010'
        #     VSWITCHD_DPDK_CONFIG = {
        #         'dpdk-init' : 'true',
        #         'dpdk-lcore-mask' : '0x4004',
        #         'pmd-cpu-mask' : 'FF0FF',
        #         'dpdk-socket-mem' : '1024,1024',
        #     }
        #
        "Name": "vhost_numa_awareness",
        "Deployment": "clean",
        "Description": "vSwitch DPDK - verify that PMD threads are served "
                       "by the same NUMA slot as QEMU instances",
        "vSwitch" : "OvsDpdkVhost",
        "TestSteps": STEP_VSWITCH_PVVP_INIT +                                       # STEP 0-6
            [
                # check that at least 2 numa slots are available
                ['tools', 'exec', 'numactl -H', 'available: ([0-9]+)'],             # STEP 7
                ['tools', 'assert', '#STEP[-1][0]>1'],                              # STEP 8
                # store last 2 cores from numa slot 0
                ['tools', 'exec', 'numactl -H', 'node 0 cpus:.*\s+(\\d+) (\\d+)$'], # STEP 9
                # store last 2 cores from numa slot 1
                ['tools', 'exec', 'numactl -H', 'node 1 cpus:.*\s+(\\d+) (\\d+)$'], # STEP 10
                # pin VNF1 to 1st NUMA slot and VNF2 to 2nd NUMA slot
                ['settings', 'setValue', 'GUEST_CORE_BINDING',                      # STEP 11
                    [("#STEP[-2][0][0]", "#STEP[-2][0][1]"),
                     ("#STEP[-1][0][0]", "#STEP[-1][0][1]")]
                ],
                # start 2 VNFs
                ['vnf1', 'start'],                                                  # STEP 12
                ['vnf2', 'start'],                                                  # STEP 13
                # read paths to ovs utilities
                ['settings', 'getValue', 'TOOLS'],                                  # STEP 14
                # check that PMD thread serving VNF1 runs at NUMA slot 0
                ## i.e. get numa slot ID serving dpdhvhostuser0...
                ['tools', 'exec', "sudo #STEP[-1]['ovs-appctl'] "                   # STEP 15
                    "dpif-netdev/pmd-rxq-show | "
                    "sed -e '/dpdkvhostuser0/,$d' | tac",
                    'pmd thread numa_id ([0-9])+'
                ],
                ## ...and check that it is NUMA slot 0
                ['tools', 'assert', '#STEP[-1][0]==0'],                             # STEP 16
                # check that PMD thread serving VNF2 runs at NUMA slot 1
                ## i.e. get numa slot ID serving dpdhvhostuser2...
                ['tools', 'exec', "sudo #STEP[-3]['ovs-appctl'] "                   # STEP 17
                    "dpif-netdev/pmd-rxq-show | "
                    "sed -e '/dpdkvhostuser2/,$d' | tac",
                    'pmd thread numa_id ([0-9])+'
                ],
                ## ...and check that it is NUMA slot 1
                ['tools', 'assert', '#STEP[-1][0]==1'],                             # STEP 18
                # clean up
                ['vnf2', 'stop'],                                                   # STEP 19
                ['vnf1', 'stop'],                                                   # STEP 20
            ] +
            STEP_VSWITCH_PVVP_FINIT                                                 # STEP 21...
    },
]

# Example of TC definition with exact vSwitch, VNF and TRAFFICGEN values.
#    {
#        "Name": "ovs_vanilla_linux_bridge_pvp_cont",
#        "Deployment": "clean",
#        "Description": "vSwitch - configure OVS Vanilla, QemuVirtioNet with linux bridge and execute continuous stream test",
#        "vSwitch" : "OvsVanilla",
#        "VNF" : "QemuVirtioNet",
#        "Trafficgen": "IxNet",
#        "Parameters": {"guest_loopback" : "linux_bridge"},
#        "TestSteps": STEP_VSWITCH_PVP_FLOWS_INIT +
#                     [
#                        ['vnf', 'start'],
#                        ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', 'bidir' : 'True'}],
#                        ['vnf', 'stop'],
#                     ] +
#                     STEP_VSWITCH_PVP_FLOWS_FINIT
#    },