# See the License for the specific language governing permissions and
# limitations under the License.
-from __future__ import absolute_import
-import time
-import os
import logging
-import sys
-from yardstick.common.utils import ErrorClass
+from yardstick.common import utils
+from yardstick.network_services.libs.ixia_libs.ixnet import ixnet_api
from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
-try:
- from IxNet import IxNextgen
-except ImportError:
- IxNextgen = ErrorClass
LOG = logging.getLogger(__name__)
WAIT_AFTER_CFG_LOAD = 10
WAIT_FOR_TRAFFIC = 30
-IXIA_LIB = os.path.dirname(os.path.realpath(__file__))
-IXNET_LIB = os.path.join(IXIA_LIB, "../../libs/ixia_libs/IxNet")
-sys.path.append(IXNET_LIB)
class IxiaRfc2544Helper(Rfc2544ResourceHelper):
- pass
+ def is_done(self):
+ return self.latency and self.iteration.value > 10
class IxiaResourceHelper(ClientResourceHelper):
+ LATENCY_TIME_SLEEP = 120
+
def __init__(self, setup_helper, rfc_helper_type=None):
super(IxiaResourceHelper, self).__init__(setup_helper)
self.scenario_helper = setup_helper.scenario_helper
- self.client = IxNextgen()
+ self.client = ixnet_api.IxNextgen()
if rfc_helper_type is None:
rfc_helper_type = IxiaRfc2544Helper
self.rfc_helper = rfc_helper_type(self.scenario_helper)
- self.tg_port_pairs = []
- self.priv_ports = None
- self.pub_ports = None
+ self.uplink_ports = None
+ self.downlink_ports = None
+ self._connect()
def _connect(self, client=None):
self.client.connect(self.vnfd_helper)
- def _build_ports(self):
- # self.generate_port_pairs(self.topology)
- self.priv_ports = [int(x[0][-1]) for x in self.tg_port_pairs]
- self.pub_ports = [int(x[1][-1]) for x in self.tg_port_pairs]
- self.my_ports = list(set(self.priv_ports).union(set(self.pub_ports)))
-
def get_stats(self, *args, **kwargs):
- return self.client.ix_get_statistics()[1]
+ return self.client.get_statistics()
def stop_collect(self):
- self._terminated.value = 0
- if self.client:
- self.client.ix_stop_traffic()
+ self._terminated.value = 1
- def generate_samples(self, key=None, default=None):
- last_result = self.get_stats()
+ def generate_samples(self, ports, key=None):
+ stats = self.get_stats()
samples = {}
- for vpci_idx, interface in enumerate(self.vnfd_helper.interfaces):
- name = "xe{0}".format(vpci_idx)
- samples[name] = {
- "rx_throughput_kps": float(last_result["Rx_Rate_Kbps"][vpci_idx]),
- "tx_throughput_kps": float(last_result["Tx_Rate_Kbps"][vpci_idx]),
- "rx_throughput_mbps": float(last_result["Rx_Rate_Mbps"][vpci_idx]),
- "tx_throughput_mbps": float(last_result["Tx_Rate_Mbps"][vpci_idx]),
- "in_packets": int(last_result["Valid_Frames_Rx"][vpci_idx]),
- "out_packets": int(last_result["Frames_Tx"][vpci_idx]),
- "RxThroughput": int(last_result["Valid_Frames_Rx"][vpci_idx]) / 30,
- "TxThroughput": int(last_result["Frames_Tx"][vpci_idx]) / 30,
- }
+ # this is not DPDK port num, but this is whatever number we gave
+ # when we selected ports and programmed the profile
+ for port_num in ports:
+ try:
+ # reverse lookup port name from port_num so the stats dict is descriptive
+ intf = self.vnfd_helper.find_interface_by_port(port_num)
+ port_name = intf["name"]
+ samples[port_name] = {
+ "rx_throughput_kps": float(stats["Rx_Rate_Kbps"][port_num]),
+ "tx_throughput_kps": float(stats["Tx_Rate_Kbps"][port_num]),
+ "rx_throughput_mbps": float(stats["Rx_Rate_Mbps"][port_num]),
+ "tx_throughput_mbps": float(stats["Tx_Rate_Mbps"][port_num]),
+ "in_packets": int(stats["Valid_Frames_Rx"][port_num]),
+ "out_packets": int(stats["Frames_Tx"][port_num]),
+ # NOTE(ralonsoh): we need to make the traffic injection
+ # time variable.
+ "RxThroughput": int(stats["Valid_Frames_Rx"][port_num]) / 30,
+ "TxThroughput": int(stats["Frames_Tx"][port_num]) / 30,
+ }
+ if key:
+ avg_latency = stats["Store-Forward_Avg_latency_ns"][port_num]
+ min_latency = stats["Store-Forward_Min_latency_ns"][port_num]
+ max_latency = stats["Store-Forward_Max_latency_ns"][port_num]
+ samples[port_name][key] = \
+ {"Store-Forward_Avg_latency_ns": avg_latency,
+ "Store-Forward_Min_latency_ns": min_latency,
+ "Store-Forward_Max_latency_ns": max_latency}
+ except IndexError:
+ pass
return samples
- def run_traffic(self, traffic_profile):
+ def _initialize_client(self):
+ """Initialize the IXIA IxNetwork client and configure the server"""
+ self.client.clear_config()
+ self.client.assign_ports()
+ self.client.create_traffic_model()
+
+ def run_traffic(self, traffic_profile, *args):
+ if self._terminated.value:
+ return
+
min_tol = self.rfc_helper.tolerance_low
max_tol = self.rfc_helper.tolerance_high
+ default = "00:00:00:00:00:00"
self._build_ports()
- self._connect()
-
- # we don't know client_file_name until runtime as instantiate
- client_file_name = self.scenario_helper.scenario_cfg['ixia_profile']
- self.client.ix_load_config(client_file_name)
- time.sleep(WAIT_AFTER_CFG_LOAD)
-
- self.client.ix_assign_ports()
+ self._initialize_client()
mac = {}
- for index, interface in enumerate(self.vnfd_helper.interfaces):
- virt_intf = interface["virtual-interface"]
- mac.update({
- "src_mac_{}".format(index): virt_intf["local_mac"],
- "dst_mac_{}".format(index): virt_intf["dst_mac"],
- })
-
- samples = {}
- ixia_file = os.path.join(os.getcwd(), "ixia_traffic.cfg")
- # Generate ixia traffic config...
- while not self._terminated.value:
- traffic_profile.execute(self, self.client, mac, ixia_file)
- self.client_started.value = 1
- time.sleep(WAIT_FOR_TRAFFIC)
- self.client.ix_stop_traffic()
- samples = self.generate_samples()
- self._queue.put(samples)
- status, samples = traffic_profile.get_drop_percentage(self, samples, min_tol,
- max_tol, self.client, mac,
- ixia_file)
-
- current = samples['CurrentDropPercentage']
- if min_tol <= current <= max_tol or status == 'Completed':
- self._terminated.value = 1
-
- self.client.ix_stop_traffic()
- self._queue.put(samples)
+ for port_name in self.vnfd_helper.port_pairs.all_ports:
+ intf = self.vnfd_helper.find_interface(name=port_name)
+ virt_intf = intf["virtual-interface"]
+ # we only know static traffic id by reading the json
+ # this is used by _get_ixia_trafficrofile
+ port_num = self.vnfd_helper.port_num(intf)
+ mac["src_mac_{}".format(port_num)] = virt_intf.get("local_mac", default)
+ mac["dst_mac_{}".format(port_num)] = virt_intf.get("dst_mac", default)
+
+ try:
+ while not self._terminated.value:
+ first_run = traffic_profile.execute_traffic(
+ self, self.client, mac)
+ self.client_started.value = 1
+ # pylint: disable=unnecessary-lambda
+ utils.wait_until_true(lambda: self.client.is_traffic_stopped())
+ samples = self.generate_samples(traffic_profile.ports)
+
+ # NOTE(ralonsoh): the traffic injection duration is fixed to 30
+ # seconds. This parameter is configurable and must be retrieved
+ # from the traffic_profile.full_profile information.
+ # Every flow must have the same duration.
+ completed, samples = traffic_profile.get_drop_percentage(
+ samples, min_tol, max_tol, first_run=first_run)
+ self._queue.put(samples)
+
+ if completed:
+ self._terminated.value = 1
+
+ except Exception: # pylint: disable=broad-except
+ LOG.exception('Run Traffic terminated')
+
+ self._terminated.value = 1
+
+ def collect_kpi(self):
+ self.rfc_helper.iteration.value += 1
+ return super(IxiaResourceHelper, self).collect_kpi()
class IxiaTrafficGen(SampleVNFTrafficGen):
+ APP_NAME = 'Ixia'
+
def __init__(self, name, vnfd, setup_env_helper_type=None, resource_helper_type=None):
if resource_helper_type is None:
resource_helper_type = IxiaResourceHelper
resource_helper_type)
self._ixia_traffic_gen = None
self.ixia_file_name = ''
- self.tg_port_pairs = []
self.vnf_port_pairs = []
def _check_status(self):
pass
- def scale(self, flavor=""):
- pass
-
- def listen_traffic(self, traffic_profile):
- pass
-
def terminate(self):
self.resource_helper.stop_collect()
super(IxiaTrafficGen, self).terminate()