1 # Copyright (c) 2016-2017 Intel Corporation
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
19 from yardstick.common import utils
20 from yardstick.network_services.libs.ixia_libs.ixnet import ixnet_api
21 from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
22 from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
23 from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
26 LOG = logging.getLogger(__name__)
28 WAIT_AFTER_CFG_LOAD = 10
30 WAIT_PROTOCOLS_STARTED = 360
33 class IxiaBasicScenario(object):
34 def __init__(self, client, context_cfg, ixia_cfg):
37 self.context_cfg = context_cfg
38 self.ixia_cfg = ixia_cfg
40 self._uplink_vports = None
41 self._downlink_vports = None
43 def apply_config(self):
46 def create_traffic_model(self):
47 vports = self.client.get_vports()
48 self._uplink_vports = vports[::2]
49 self._downlink_vports = vports[1::2]
50 self.client.create_traffic_model(self._uplink_vports,
51 self._downlink_vports)
53 def run_protocols(self):
56 def stop_protocols(self):
60 class IxiaPppoeClientScenario(object):
61 def __init__(self, client, context_cfg, ixia_cfg):
65 self._uplink_vports = None
66 self._downlink_vports = None
68 self._access_topologies = []
69 self._core_topologies = []
71 self._context_cfg = context_cfg
72 self._ixia_cfg = ixia_cfg
75 def apply_config(self):
76 vports = self.client.get_vports()
77 self._uplink_vports = vports[::2]
78 self._downlink_vports = vports[1::2]
79 self._fill_ixia_config()
80 self._apply_access_network_config()
81 self._apply_core_network_config()
83 def create_traffic_model(self):
84 self.client.create_ipv4_traffic_model(self._access_topologies,
85 self._core_topologies)
87 def run_protocols(self):
88 LOG.info('PPPoE Scenario - Start Protocols')
89 self.client.start_protocols()
90 utils.wait_until_true(
91 lambda: self.client.is_protocols_running(self.protocols),
92 timeout=WAIT_PROTOCOLS_STARTED, sleep=2)
94 def stop_protocols(self):
95 LOG.info('PPPoE Scenario - Stop Protocols')
96 self.client.stop_protocols()
98 def _get_intf_addr(self, intf):
99 """Retrieve interface IP address and mask
101 :param intf: could be the string which represents IP address
102 with mask (e.g 192.168.10.2/24) or a dictionary with the host
103 name and the port (e.g. {'tg__0': 'xe1'})
104 :return: (tuple) pair of ip address and mask
106 if isinstance(intf, six.string_types):
107 ip, mask = tuple(intf.split('/'))
110 node_name, intf_name = next(iter(intf.items()))
111 node = self._context_cfg["nodes"].get(node_name, {})
112 interface = node.get("interfaces", {})[intf_name]
113 ip = interface["local_ip"]
114 mask = interface["netmask"]
115 ipaddr = ipaddress.ip_network(six.text_type('{}/{}'.format(ip, mask)),
117 return ip, ipaddr.prefixlen
119 def _fill_ixia_config(self):
120 pppoe = self._ixia_cfg["pppoe_client"]
121 ipv4 = self._ixia_cfg["ipv4_client"]
123 _ip = [self._get_intf_addr(intf)[0] for intf in pppoe["ip"]]
124 self._ixia_cfg["pppoe_client"]["ip"] = _ip
126 _ip = [self._get_intf_addr(intf)[0] for intf in ipv4["gateway_ip"]]
127 self._ixia_cfg["ipv4_client"]["gateway_ip"] = _ip
129 addrs = [self._get_intf_addr(intf) for intf in ipv4["ip"]]
130 _ip = [addr[0] for addr in addrs]
131 _prefix = [addr[1] for addr in addrs]
133 self._ixia_cfg["ipv4_client"]["ip"] = _ip
134 self._ixia_cfg["ipv4_client"]["prefix"] = _prefix
136 def _apply_access_network_config(self):
137 pppoe = self._ixia_cfg["pppoe_client"]
138 sessions_per_port = pppoe['sessions_per_port']
139 sessions_per_svlan = pppoe['sessions_per_svlan']
140 svlan_count = int(sessions_per_port / sessions_per_svlan)
142 # add topology per uplink port (access network)
143 for access_tp_id, vport in enumerate(self._uplink_vports):
144 name = 'Topology access {}'.format(access_tp_id)
145 tp = self.client.add_topology(name, vport)
146 self._access_topologies.append(tp)
147 # add device group per svlan
148 for dg_id in range(svlan_count):
149 s_vlan_id = int(pppoe['s_vlan']) + dg_id + access_tp_id * svlan_count
150 s_vlan = ixnet_api.Vlan(vlan_id=s_vlan_id)
151 c_vlan = ixnet_api.Vlan(vlan_id=pppoe['c_vlan'], vlan_id_step=1)
152 name = 'SVLAN {}'.format(s_vlan_id)
153 dg = self.client.add_device_group(tp, name, sessions_per_svlan)
154 # add ethernet layer to device group
155 ethernet = self.client.add_ethernet(dg, 'Ethernet')
156 self.protocols.append(ethernet)
157 self.client.add_vlans(ethernet, [s_vlan, c_vlan])
158 # add ppp over ethernet
159 if 'pap_user' in pppoe:
160 ppp = self.client.add_pppox_client(ethernet, 'pap',
162 pppoe['pap_password'])
164 ppp = self.client.add_pppox_client(ethernet, 'chap',
166 pppoe['chap_password'])
167 self.protocols.append(ppp)
169 def _apply_core_network_config(self):
170 ipv4 = self._ixia_cfg["ipv4_client"]
171 sessions_per_port = ipv4['sessions_per_port']
172 sessions_per_vlan = ipv4['sessions_per_vlan']
173 vlan_count = int(sessions_per_port / sessions_per_vlan)
175 # add topology per downlink port (core network)
176 for core_tp_id, vport in enumerate(self._downlink_vports):
177 name = 'Topology core {}'.format(core_tp_id)
178 tp = self.client.add_topology(name, vport)
179 self._core_topologies.append(tp)
180 # add device group per vlan
181 for dg_id in range(vlan_count):
182 name = 'Core port {}'.format(core_tp_id)
183 dg = self.client.add_device_group(tp, name, sessions_per_vlan)
184 # add ethernet layer to device group
185 ethernet = self.client.add_ethernet(dg, 'Ethernet')
186 self.protocols.append(ethernet)
188 vlan_id = int(ipv4['vlan']) + dg_id + core_tp_id * vlan_count
189 vlan = ixnet_api.Vlan(vlan_id=vlan_id)
190 self.client.add_vlans(ethernet, [vlan])
192 gw_ip = ipv4['gateway_ip'][core_tp_id]
193 # use gw addr to generate ip addr from the same network
194 ip_addr = ipaddress.IPv4Address(gw_ip) + 1
195 ipv4_obj = self.client.add_ipv4(ethernet, name='ipv4',
198 prefix=ipv4['prefix'][core_tp_id],
200 self.protocols.append(ipv4_obj)
202 bgp_peer_obj = self.client.add_bgp(ipv4_obj,
203 dut_ip=ipv4["bgp"]["dut_ip"],
204 local_as=ipv4["bgp"]["as_number"],
205 bgp_type=ipv4["bgp"].get("bgp_type"))
206 self.protocols.append(bgp_peer_obj)
209 class IxiaRfc2544Helper(Rfc2544ResourceHelper):
212 return self.latency and self.iteration.value > 10
215 class IxiaResourceHelper(ClientResourceHelper):
217 LATENCY_TIME_SLEEP = 120
219 def __init__(self, setup_helper, rfc_helper_type=None):
220 super(IxiaResourceHelper, self).__init__(setup_helper)
221 self.scenario_helper = setup_helper.scenario_helper
223 self._ixia_scenarios = {
224 "IxiaBasic": IxiaBasicScenario,
225 "IxiaPppoeClient": IxiaPppoeClientScenario,
228 self.client = ixnet_api.IxNextgen()
230 if rfc_helper_type is None:
231 rfc_helper_type = IxiaRfc2544Helper
233 self.rfc_helper = rfc_helper_type(self.scenario_helper)
234 self.uplink_ports = None
235 self.downlink_ports = None
236 self.context_cfg = None
237 self._ix_scenario = None
240 def _connect(self, client=None):
241 self.client.connect(self.vnfd_helper)
243 def get_stats(self, *args, **kwargs):
244 return self.client.get_statistics()
247 super(IxiaResourceHelper, self).setup()
248 self._init_ix_scenario()
250 def stop_collect(self):
251 self._ix_scenario.stop_protocols()
252 self._terminated.value = 1
254 def generate_samples(self, ports, duration):
255 stats = self.get_stats()
258 # this is not DPDK port num, but this is whatever number we gave
259 # when we selected ports and programmed the profile
260 for port_num in ports:
262 # reverse lookup port name from port_num so the stats dict is descriptive
263 intf = self.vnfd_helper.find_interface_by_port(port_num)
264 port_name = intf['name']
265 avg_latency = stats['Store-Forward_Avg_latency_ns'][port_num]
266 min_latency = stats['Store-Forward_Min_latency_ns'][port_num]
267 max_latency = stats['Store-Forward_Max_latency_ns'][port_num]
268 samples[port_name] = {
269 'rx_throughput_kps': float(stats['Rx_Rate_Kbps'][port_num]),
270 'tx_throughput_kps': float(stats['Tx_Rate_Kbps'][port_num]),
271 'rx_throughput_mbps': float(stats['Rx_Rate_Mbps'][port_num]),
272 'tx_throughput_mbps': float(stats['Tx_Rate_Mbps'][port_num]),
273 'in_packets': int(stats['Valid_Frames_Rx'][port_num]),
274 'out_packets': int(stats['Frames_Tx'][port_num]),
275 'RxThroughput': float(stats['Valid_Frames_Rx'][port_num]) / duration,
276 'TxThroughput': float(stats['Frames_Tx'][port_num]) / duration,
277 'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
278 'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
279 'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
286 def _init_ix_scenario(self):
287 ixia_config = self.scenario_helper.scenario_cfg.get('ixia_config', 'IxiaBasic')
289 if ixia_config in self._ixia_scenarios:
290 scenario_type = self._ixia_scenarios[ixia_config]
292 self._ix_scenario = scenario_type(self.client, self.context_cfg,
293 self.scenario_helper.scenario_cfg['options'])
296 "IXIA config type '{}' not supported".format(ixia_config))
298 def _initialize_client(self):
299 """Initialize the IXIA IxNetwork client and configure the server"""
300 self.client.clear_config()
301 self.client.assign_ports()
302 self._ix_scenario.apply_config()
303 self._ix_scenario.create_traffic_model()
305 def run_traffic(self, traffic_profile, *args):
306 if self._terminated.value:
309 min_tol = self.rfc_helper.tolerance_low
310 max_tol = self.rfc_helper.tolerance_high
311 precision = self.rfc_helper.tolerance_precision
312 default = "00:00:00:00:00:00"
315 self._initialize_client()
318 for port_name in self.vnfd_helper.port_pairs.all_ports:
319 intf = self.vnfd_helper.find_interface(name=port_name)
320 virt_intf = intf["virtual-interface"]
321 # we only know static traffic id by reading the json
322 # this is used by _get_ixia_trafficrofile
323 port_num = self.vnfd_helper.port_num(intf)
324 mac["src_mac_{}".format(port_num)] = virt_intf.get("local_mac", default)
325 mac["dst_mac_{}".format(port_num)] = virt_intf.get("dst_mac", default)
327 self._ix_scenario.run_protocols()
330 while not self._terminated.value:
331 first_run = traffic_profile.execute_traffic(
332 self, self.client, mac)
333 self.client_started.value = 1
334 # pylint: disable=unnecessary-lambda
335 utils.wait_until_true(lambda: self.client.is_traffic_stopped(),
336 timeout=traffic_profile.config.duration * 2)
337 samples = self.generate_samples(traffic_profile.ports,
338 traffic_profile.config.duration)
340 completed, samples = traffic_profile.get_drop_percentage(
341 samples, min_tol, max_tol, precision, first_run=first_run)
342 self._queue.put(samples)
345 self._terminated.value = 1
347 except Exception: # pylint: disable=broad-except
348 LOG.exception('Run Traffic terminated')
350 self._ix_scenario.stop_protocols()
351 self._terminated.value = 1
353 def collect_kpi(self):
354 self.rfc_helper.iteration.value += 1
355 return super(IxiaResourceHelper, self).collect_kpi()
358 class IxiaTrafficGen(SampleVNFTrafficGen):
362 def __init__(self, name, vnfd, task_id, setup_env_helper_type=None,
363 resource_helper_type=None):
364 if resource_helper_type is None:
365 resource_helper_type = IxiaResourceHelper
366 super(IxiaTrafficGen, self).__init__(
367 name, vnfd, task_id, setup_env_helper_type, resource_helper_type)
368 self._ixia_traffic_gen = None
369 self.ixia_file_name = ''
370 self.vnf_port_pairs = []
372 def _check_status(self):
376 self.resource_helper.stop_collect()
377 super(IxiaTrafficGen, self).terminate()