nfvbench/traffic_gen/trex_gen.py

   1 # Copyright 2016 Cisco Systems, Inc.  All rights reserved.
   2 #
   3 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   4 #    not use this file except in compliance with the License. You may obtain
   5 #    a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #    Unless required by applicable law or agreed to in writing, software
  10 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 #    License for the specific language governing permissions and limitations
  13 #    under the License.
  14 """Driver module for TRex traffic generator."""
  15
  16 import math
  17 import os
  18 import random
  19 import time
  20 import traceback
  21
  22 from itertools import count
  23 from nfvbench.log import LOG
  24 from nfvbench.traffic_server import TRexTrafficServer
  25 from nfvbench.utils import cast_integer
  26 from nfvbench.utils import timeout
  27 from nfvbench.utils import TimeoutError
  28 from traffic_base import AbstractTrafficGenerator
  29 from traffic_base import TrafficGeneratorException
  30 import traffic_utils as utils
  31 from traffic_utils import IMIX_AVG_L2_FRAME_SIZE
  32 from traffic_utils import IMIX_L2_SIZES
  33 from traffic_utils import IMIX_RATIOS
  34
  35 # pylint: disable=import-error
  36 from trex.common.services.trex_service_arp import ServiceARP
  37 from trex.stl.api import bind_layers
  38 from trex.stl.api import CTRexVmInsFixHwCs
  39 from trex.stl.api import Dot1Q
  40 from trex.stl.api import Ether
  41 from trex.stl.api import FlagsField
  42 from trex.stl.api import IP
  43 from trex.stl.api import Packet
  44 from trex.stl.api import STLClient
  45 from trex.stl.api import STLError
  46 from trex.stl.api import STLFlowLatencyStats
  47 from trex.stl.api import STLFlowStats
  48 from trex.stl.api import STLPktBuilder
  49 from trex.stl.api import STLScVmRaw
  50 from trex.stl.api import STLStream
  51 from trex.stl.api import STLTXCont
  52 from trex.stl.api import STLVmFixChecksumHw
  53 from trex.stl.api import STLVmFlowVar
  54 from trex.stl.api import STLVmFlowVarRepeatableRandom
  55 from trex.stl.api import STLVmWrFlowVar
  56 from trex.stl.api import ThreeBytesField
  57 from trex.stl.api import UDP
  58 from trex.stl.api import XByteField
  59
  60
  61 # pylint: enable=import-error
  62
  63 class VXLAN(Packet):
  64     """VxLAN class."""
  65
  66     _VXLAN_FLAGS = ['R' * 27] + ['I'] + ['R' * 5]
  67     name = "VXLAN"
  68     fields_desc = [FlagsField("flags", 0x08000000, 32, _VXLAN_FLAGS),
  69                    ThreeBytesField("vni", 0),
  70                    XByteField("reserved", 0x00)]
  71
  72     def mysummary(self):
  73         """Summary."""
  74         return self.sprintf("VXLAN (vni=%VXLAN.vni%)")
  75
  76 class TRex(AbstractTrafficGenerator):
  77     """TRex traffic generator driver."""
  78
  79     LATENCY_PPS = 1000
  80     CHAIN_PG_ID_MASK = 0x007F
  81     PORT_PG_ID_MASK = 0x0080
  82     LATENCY_PG_ID_MASK = 0x0100
  83
  84     def __init__(self, traffic_client):
  85         """Trex driver."""
  86         AbstractTrafficGenerator.__init__(self, traffic_client)
  87         self.client = None
  88         self.id = count()
  89         self.port_handle = []
  90         self.chain_count = self.generator_config.service_chain_count
  91         self.rates = []
  92         self.capture_id = None
  93         self.packet_list = []
  94
  95     def get_version(self):
  96         """Get the Trex version."""
  97         return self.client.get_server_version() if self.client else ''
  98
  99     def get_pg_id(self, port, chain_id):
 100         """Calculate the packet group IDs to use for a given port/stream type/chain_id.
 101
 102         port: 0 or 1
 103         chain_id: identifies to which chain the pg_id is associated (0 to 255)
 104         return: pg_id, lat_pg_id
 105
 106         We use a bit mask to set up the 3 fields:
 107         0x007F: chain ID (8 bits for a max of 128 chains)
 108         0x0080: port bit
 109         0x0100: latency bit
 110         """
 111         pg_id = port * TRex.PORT_PG_ID_MASK | chain_id
 112         return pg_id, pg_id | TRex.LATENCY_PG_ID_MASK
 113
 114     def extract_stats(self, in_stats):
 115         """Extract stats from dict returned by Trex API.
 116
 117         :param in_stats: dict as returned by TRex api
 118         """
 119         utils.nan_replace(in_stats)
 120         # LOG.debug(in_stats)
 121
 122         result = {}
 123         # port_handles should have only 2 elements: [0, 1]
 124         # so (1 - ph) will be the index for the far end port
 125         for ph in self.port_handle:
 126             stats = in_stats[ph]
 127             far_end_stats = in_stats[1 - ph]
 128             result[ph] = {
 129                 'tx': {
 130                     'total_pkts': cast_integer(stats['opackets']),
 131                     'total_pkt_bytes': cast_integer(stats['obytes']),
 132                     'pkt_rate': cast_integer(stats['tx_pps']),
 133                     'pkt_bit_rate': cast_integer(stats['tx_bps'])
 134                 },
 135                 'rx': {
 136                     'total_pkts': cast_integer(stats['ipackets']),
 137                     'total_pkt_bytes': cast_integer(stats['ibytes']),
 138                     'pkt_rate': cast_integer(stats['rx_pps']),
 139                     'pkt_bit_rate': cast_integer(stats['rx_bps']),
 140                     # how many pkts were dropped in RX direction
 141                     # need to take the tx counter on the far end port
 142                     'dropped_pkts': cast_integer(
 143                         far_end_stats['opackets'] - stats['ipackets'])
 144                 }
 145             }
 146             self.__combine_latencies(in_stats, result[ph]['rx'], ph)
 147
 148         total_tx_pkts = result[0]['tx']['total_pkts'] + result[1]['tx']['total_pkts']
 149         result["total_tx_rate"] = cast_integer(total_tx_pkts / self.config.duration_sec)
 150         result["flow_stats"] = in_stats["flow_stats"]
 151         result["latency"] = in_stats["latency"]
 152         return result
 153
 154     def get_stream_stats(self, trex_stats, if_stats, latencies, chain_idx):
 155         """Extract the aggregated stats for a given chain.
 156
 157         trex_stats: stats as returned by get_stats()
 158         if_stats: a list of 2 interface stats to update (port 0 and 1)
 159         latencies: a list of 2 Latency instances to update for this chain (port 0 and 1)
 160                    latencies[p] is the latency for packets sent on port p
 161                    if there are no latency streams, the Latency instances are not modified
 162         chain_idx: chain index of the interface stats
 163
 164         The packet counts include normal and latency streams.
 165
 166         Trex returns flows stats as follows:
 167
 168         'flow_stats': {0: {'rx_bps': {0: 0, 1: 0, 'total': 0},
 169                    'rx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 170                    'rx_bytes': {0: nan, 1: nan, 'total': nan},
 171                    'rx_pkts': {0: 0, 1: 15001, 'total': 15001},
 172                    'rx_pps': {0: 0, 1: 0, 'total': 0},
 173                    'tx_bps': {0: 0, 1: 0, 'total': 0},
 174                    'tx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 175                    'tx_bytes': {0: 1020068, 1: 0, 'total': 1020068},
 176                    'tx_pkts': {0: 15001, 1: 0, 'total': 15001},
 177                    'tx_pps': {0: 0, 1: 0, 'total': 0}},
 178                1: {'rx_bps': {0: 0, 1: 0, 'total': 0},
 179                    'rx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 180                    'rx_bytes': {0: nan, 1: nan, 'total': nan},
 181                    'rx_pkts': {0: 0, 1: 15001, 'total': 15001},
 182                    'rx_pps': {0: 0, 1: 0, 'total': 0},
 183                    'tx_bps': {0: 0, 1: 0, 'total': 0},
 184                    'tx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 185                    'tx_bytes': {0: 1020068, 1: 0, 'total': 1020068},
 186                    'tx_pkts': {0: 15001, 1: 0, 'total': 15001},
 187                    'tx_pps': {0: 0, 1: 0, 'total': 0}},
 188                 128: {'rx_bps': {0: 0, 1: 0, 'total': 0},
 189                 'rx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 190                 'rx_bytes': {0: nan, 1: nan, 'total': nan},
 191                 'rx_pkts': {0: 15001, 1: 0, 'total': 15001},
 192                 'rx_pps': {0: 0, 1: 0, 'total': 0},
 193                 'tx_bps': {0: 0, 1: 0, 'total': 0},
 194                 'tx_bps_l1': {0: 0.0, 1: 0.0, 'total': 0.0},
 195                 'tx_bytes': {0: 0, 1: 1020068, 'total': 1020068},
 196                 'tx_pkts': {0: 0, 1: 15001, 'total': 15001},
 197                 'tx_pps': {0: 0, 1: 0, 'total': 0}},etc...
 198
 199         the pg_id (0, 1, 128,...) is the key of the dict and is obtained using the
 200         get_pg_id() method.
 201         packet counters for a given stream sent on port p are reported as:
 202         - tx_pkts[p] on port p
 203         - rx_pkts[1-p] on the far end port
 204
 205         This is a tricky/critical counter transposition operation because
 206         the results are grouped by port (not by stream):
 207         tx_pkts_port(p=0) comes from pg_id(port=0, chain_idx)['tx_pkts'][0]
 208         rx_pkts_port(p=0) comes from pg_id(port=1, chain_idx)['rx_pkts'][0]
 209         tx_pkts_port(p=1) comes from pg_id(port=1, chain_idx)['tx_pkts'][1]
 210         rx_pkts_port(p=1) comes from pg_id(port=0, chain_idx)['rx_pkts'][1]
 211
 212         or using a more generic formula:
 213         tx_pkts_port(p) comes from pg_id(port=p, chain_idx)['tx_pkts'][p]
 214         rx_pkts_port(p) comes from pg_id(port=1-p, chain_idx)['rx_pkts'][p]
 215
 216         the second formula is equivalent to
 217         rx_pkts_port(1-p) comes from pg_id(port=p, chain_idx)['rx_pkts'][1-p]
 218
 219         If there are latency streams, those same counters need to be added in the same way
 220         """
 221         def get_latency(lval):
 222             try:
 223                 return int(round(lval))
 224             except ValueError:
 225                 return 0
 226
 227         for ifs in if_stats:
 228             ifs.tx = ifs.rx = 0
 229         for port in range(2):
 230             pg_id, lat_pg_id = self.get_pg_id(port, chain_idx)
 231             for pid in [pg_id, lat_pg_id]:
 232                 try:
 233                     pg_stats = trex_stats['flow_stats'][pid]
 234                     if_stats[port].tx += pg_stats['tx_pkts'][port]
 235                     if_stats[1 - port].rx += pg_stats['rx_pkts'][1 - port]
 236                 except KeyError:
 237                     pass
 238             try:
 239                 lat = trex_stats['latency'][lat_pg_id]['latency']
 240                 # dropped_pkts += lat['err_cntrs']['dropped']
 241                 latencies[port].max_usec = get_latency(lat['total_max'])
 242                 if math.isnan(lat['total_min']):
 243                     latencies[port].min_usec = 0
 244                     latencies[port].avg_usec = 0
 245                 else:
 246                     latencies[port].min_usec = get_latency(lat['total_min'])
 247                     latencies[port].avg_usec = get_latency(lat['average'])
 248                 # pick up the HDR histogram if present (otherwise will raise KeyError)
 249                 latencies[port].hdrh = lat['hdrh']
 250             except KeyError:
 251                 pass
 252
 253     def __combine_latencies(self, in_stats, results, port_handle):
 254         """Traverse TRex result dictionary and combines chosen latency stats.
 255
 256           example of latency dict returned by trex (2 chains):
 257          'latency': {256: {'err_cntrs': {'dropped': 0,
 258                                  'dup': 0,
 259                                  'out_of_order': 0,
 260                                  'seq_too_high': 0,
 261                                  'seq_too_low': 0},
 262                             'latency': {'average': 26.5,
 263                                         'hdrh': u'HISTFAAAAEx4nJNpmSgz...bFRgxi',
 264                                         'histogram': {20: 303,
 265                                                         30: 320,
 266                                                         40: 300,
 267                                                         50: 73,
 268                                                         60: 4,
 269                                                         70: 1},
 270                                         'jitter': 14,
 271                                         'last_max': 63,
 272                                         'total_max': 63,
 273                                         'total_min': 20}},
 274                     257: {'err_cntrs': {'dropped': 0,
 275                                         'dup': 0,
 276                                         'out_of_order': 0,
 277                                         'seq_too_high': 0,
 278                                         'seq_too_low': 0},
 279                             'latency': {'average': 29.75,
 280                                         'hdrh': u'HISTFAAAAEV4nJN...CALilDG0=',
 281                                         'histogram': {20: 261,
 282                                                         30: 431,
 283                                                         40: 3,
 284                                                         50: 80,
 285                                                         60: 225},
 286                                         'jitter': 23,
 287                                         'last_max': 67,
 288                                         'total_max': 67,
 289                                         'total_min': 20}},
 290                     384: {'err_cntrs': {'dropped': 0,
 291                                         'dup': 0,
 292                                         'out_of_order': 0,
 293                                         'seq_too_high': 0,
 294                                         'seq_too_low': 0},
 295                             'latency': {'average': 18.0,
 296                                         'hdrh': u'HISTFAAAADR4nJNpm...MjCwDDxAZG',
 297                                         'histogram': {20: 987, 30: 14},
 298                                         'jitter': 0,
 299                                         'last_max': 34,
 300                                         'total_max': 34,
 301                                         'total_min': 20}},
 302                     385: {'err_cntrs': {'dropped': 0,
 303                                     'dup': 0,
 304                                     'out_of_order': 0,
 305                                     'seq_too_high': 0,
 306                                     'seq_too_low': 0},
 307                             'latency': {'average': 19.0,
 308                                         'hdrh': u'HISTFAAAADR4nJNpm...NkYmJgDdagfK',
 309                                         'histogram': {20: 989, 30: 11},
 310                                         'jitter': 0,
 311                                         'last_max': 38,
 312                                         'total_max': 38,
 313                                         'total_min': 20}},
 314                     'global': {'bad_hdr': 0, 'old_flow': 0}},
 315         """
 316         total_max = 0
 317         average = 0
 318         total_min = float("inf")
 319         for chain_id in range(self.chain_count):
 320             try:
 321                 _, lat_pg_id = self.get_pg_id(port_handle, chain_id)
 322                 lat = in_stats['latency'][lat_pg_id]['latency']
 323                 # dropped_pkts += lat['err_cntrs']['dropped']
 324                 total_max = max(lat['total_max'], total_max)
 325                 total_min = min(lat['total_min'], total_min)
 326                 average += lat['average']
 327             except KeyError:
 328                 pass
 329         if total_min == float("inf"):
 330             total_min = 0
 331         results['min_delay_usec'] = total_min
 332         results['max_delay_usec'] = total_max
 333         results['avg_delay_usec'] = int(average / self.chain_count)
 334
 335     def _bind_vxlan(self):
 336         bind_layers(UDP, VXLAN, dport=4789)
 337         bind_layers(VXLAN, Ether)
 338
 339     def _create_pkt(self, stream_cfg, l2frame_size):
 340         """Create a packet of given size.
 341
 342         l2frame_size: size of the L2 frame in bytes (including the 32-bit FCS)
 343         """
 344         # Trex will add the FCS field, so we need to remove 4 bytes from the l2 frame size
 345         frame_size = int(l2frame_size) - 4
 346         vm_param = []
 347         if stream_cfg['vxlan'] is True:
 348             self._bind_vxlan()
 349             encap_level = '1'
 350             pkt_base = Ether(src=stream_cfg['vtep_src_mac'], dst=stream_cfg['vtep_dst_mac'])
 351             if stream_cfg['vtep_vlan'] is not None:
 352                 pkt_base /= Dot1Q(vlan=stream_cfg['vtep_vlan'])
 353             pkt_base /= IP(src=stream_cfg['vtep_src_ip'], dst=stream_cfg['vtep_dst_ip'])
 354             pkt_base /= UDP(sport=random.randint(1337, 32767), dport=4789)
 355             pkt_base /= VXLAN(vni=stream_cfg['net_vni'])
 356             pkt_base /= Ether(src=stream_cfg['mac_src'], dst=stream_cfg['mac_dst'])
 357             # need to randomize the outer header UDP src port based on flow
 358             vxlan_udp_src_fv = STLVmFlowVar(
 359                 name="vxlan_udp_src",
 360                 min_value=1337,
 361                 max_value=32767,
 362                 size=2,
 363                 op="random")
 364             vm_param = [vxlan_udp_src_fv,
 365                         STLVmWrFlowVar(fv_name="vxlan_udp_src", pkt_offset="UDP.sport")]
 366         else:
 367             encap_level = '0'
 368             pkt_base = Ether(src=stream_cfg['mac_src'], dst=stream_cfg['mac_dst'])
 369
 370         if stream_cfg['vlan_tag'] is not None:
 371             pkt_base /= Dot1Q(vlan=stream_cfg['vlan_tag'])
 372
 373         udp_args = {}
 374         if stream_cfg['udp_src_port']:
 375             udp_args['sport'] = int(stream_cfg['udp_src_port'])
 376         if stream_cfg['udp_dst_port']:
 377             udp_args['dport'] = int(stream_cfg['udp_dst_port'])
 378         pkt_base /= IP() / UDP(**udp_args)
 379
 380         if stream_cfg['ip_addrs_step'] == 'random':
 381             src_fv = STLVmFlowVarRepeatableRandom(
 382                 name="ip_src",
 383                 min_value=stream_cfg['ip_src_addr'],
 384                 max_value=stream_cfg['ip_src_addr_max'],
 385                 size=4,
 386                 seed=random.randint(0, 32767),
 387                 limit=stream_cfg['ip_src_count'])
 388             dst_fv = STLVmFlowVarRepeatableRandom(
 389                 name="ip_dst",
 390                 min_value=stream_cfg['ip_dst_addr'],
 391                 max_value=stream_cfg['ip_dst_addr_max'],
 392                 size=4,
 393                 seed=random.randint(0, 32767),
 394                 limit=stream_cfg['ip_dst_count'])
 395         else:
 396             src_fv = STLVmFlowVar(
 397                 name="ip_src",
 398                 min_value=stream_cfg['ip_src_addr'],
 399                 max_value=stream_cfg['ip_src_addr'],
 400                 size=4,
 401                 op="inc",
 402                 step=stream_cfg['ip_addrs_step'])
 403             dst_fv = STLVmFlowVar(
 404                 name="ip_dst",
 405                 min_value=stream_cfg['ip_dst_addr'],
 406                 max_value=stream_cfg['ip_dst_addr_max'],
 407                 size=4,
 408                 op="inc",
 409                 step=stream_cfg['ip_addrs_step'])
 410
 411         vm_param.extend([
 412             src_fv,
 413             STLVmWrFlowVar(fv_name="ip_src", pkt_offset="IP:{}.src".format(encap_level)),
 414             dst_fv,
 415             STLVmWrFlowVar(fv_name="ip_dst", pkt_offset="IP:{}.dst".format(encap_level))
 416         ])
 417
 418         for encap in range(int(encap_level), -1, -1):
 419             # Fixing the checksums for all encap levels
 420             vm_param.append(STLVmFixChecksumHw(l3_offset="IP:{}".format(encap),
 421                                                l4_offset="UDP:{}".format(encap),
 422                                                l4_type=CTRexVmInsFixHwCs.L4_TYPE_UDP))
 423         pad = max(0, frame_size - len(pkt_base)) * 'x'
 424
 425         return STLPktBuilder(pkt=pkt_base / pad,
 426                              vm=STLScVmRaw(vm_param, cache_size=int(self.config.cache_size)))
 427
 428     def generate_streams(self, port, chain_id, stream_cfg, l2frame, latency=True,
 429                          e2e=False):
 430         """Create a list of streams corresponding to a given chain and stream config.
 431
 432         port: port where the streams originate (0 or 1)
 433         chain_id: the chain to which the streams are associated to
 434         stream_cfg: stream configuration
 435         l2frame: L2 frame size (including 4-byte FCS) or 'IMIX'
 436         latency: if True also create a latency stream
 437         e2e: True if performing "end to end" connectivity check
 438         """
 439         streams = []
 440         pg_id, lat_pg_id = self.get_pg_id(port, chain_id)
 441         if l2frame == 'IMIX':
 442             for ratio, l2_frame_size in zip(IMIX_RATIOS, IMIX_L2_SIZES):
 443                 pkt = self._create_pkt(stream_cfg, l2_frame_size)
 444                 if e2e:
 445                     streams.append(STLStream(packet=pkt,
 446                                              mode=STLTXCont(pps=ratio)))
 447                 else:
 448                     if stream_cfg['vxlan'] is True:
 449                         streams.append(STLStream(packet=pkt,
 450                                                  flow_stats=STLFlowStats(pg_id=pg_id,
 451                                                                          vxlan=True),
 452                                                  mode=STLTXCont(pps=ratio)))
 453                     else:
 454                         streams.append(STLStream(packet=pkt,
 455                                                  flow_stats=STLFlowStats(pg_id=pg_id),
 456                                                  mode=STLTXCont(pps=ratio)))
 457
 458             if latency:
 459                 # for IMIX, the latency packets have the average IMIX packet size
 460                 pkt = self._create_pkt(stream_cfg, IMIX_AVG_L2_FRAME_SIZE)
 461
 462         else:
 463             l2frame_size = int(l2frame)
 464             pkt = self._create_pkt(stream_cfg, l2frame_size)
 465             if e2e:
 466                 streams.append(STLStream(packet=pkt,
 467                                          mode=STLTXCont()))
 468             else:
 469                 if stream_cfg['vxlan'] is True:
 470                     streams.append(STLStream(packet=pkt,
 471                                              flow_stats=STLFlowStats(pg_id=pg_id,
 472                                                                      vxlan=True),
 473                                              mode=STLTXCont()))
 474                 else:
 475                     streams.append(STLStream(packet=pkt,
 476                                              flow_stats=STLFlowStats(pg_id=pg_id),
 477                                              mode=STLTXCont()))
 478             # for the latency stream, the minimum payload is 16 bytes even in case of vlan tagging
 479             # without vlan, the min l2 frame size is 64
 480             # with vlan it is 68
 481             # This only applies to the latency stream
 482             if latency and stream_cfg['vlan_tag'] and l2frame_size < 68:
 483                 pkt = self._create_pkt(stream_cfg, 68)
 484
 485         if latency:
 486             if stream_cfg['vxlan'] is True:
 487                 streams.append(STLStream(packet=pkt,
 488                                          flow_stats=STLFlowLatencyStats(pg_id=lat_pg_id,
 489                                                                         vxlan=True),
 490                                          mode=STLTXCont(pps=self.LATENCY_PPS)))
 491             else:
 492                 streams.append(STLStream(packet=pkt,
 493                                          flow_stats=STLFlowLatencyStats(pg_id=lat_pg_id),
 494                                          mode=STLTXCont(pps=self.LATENCY_PPS)))
 495         return streams
 496
 497     @timeout(5)
 498     def __connect(self, client):
 499         client.connect()
 500
 501     def __connect_after_start(self):
 502         # after start, Trex may take a bit of time to initialize
 503         # so we need to retry a few times
 504         for it in xrange(self.config.generic_retry_count):
 505             try:
 506                 time.sleep(1)
 507                 self.client.connect()
 508                 break
 509             except Exception as ex:
 510                 if it == (self.config.generic_retry_count - 1):
 511                     raise
 512                 LOG.info("Retrying connection to TRex (%s)...", ex.message)
 513
 514     def connect(self):
 515         """Connect to the TRex server."""
 516         server_ip = self.generator_config.ip
 517         LOG.info("Connecting to TRex (%s)...", server_ip)
 518
 519         # Connect to TRex server
 520         self.client = STLClient(server=server_ip, sync_port=self.generator_config.zmq_rpc_port,
 521                                 async_port=self.generator_config.zmq_pub_port)
 522         try:
 523             self.__connect(self.client)
 524             if server_ip == '127.0.0.1':
 525                 config_updated = self.__check_config()
 526                 if config_updated or self.config.restart:
 527                     self.__restart()
 528         except (TimeoutError, STLError) as e:
 529             if server_ip == '127.0.0.1':
 530                 self.__start_local_server()
 531             else:
 532                 raise TrafficGeneratorException(e.message)
 533
 534         ports = list(self.generator_config.ports)
 535         self.port_handle = ports
 536         # Prepare the ports
 537         self.client.reset(ports)
 538         # Read HW information from each port
 539         # this returns an array of dict (1 per port)
 540         """
 541         Example of output for Intel XL710
 542         [{'arp': '-', 'src_ipv4': '-', u'supp_speeds': [40000], u'is_link_supported': True,
 543           'grat_arp': 'off', 'speed': 40, u'index': 0, 'link_change_supported': 'yes',
 544           u'rx': {u'counters': 127, u'caps': [u'flow_stats', u'latency']},
 545           u'is_virtual': 'no', 'prom': 'off', 'src_mac': u'3c:fd:fe:a8:24:48', 'status': 'IDLE',
 546           u'description': u'Ethernet Controller XL710 for 40GbE QSFP+',
 547           'dest': u'fa:16:3e:3c:63:04', u'is_fc_supported': False, 'vlan': '-',
 548           u'driver': u'net_i40e', 'led_change_supported': 'yes', 'rx_filter_mode': 'hardware match',
 549           'fc': 'none', 'link': 'UP', u'hw_mac': u'3c:fd:fe:a8:24:48', u'pci_addr': u'0000:5e:00.0',
 550           'mult': 'off', 'fc_supported': 'no', u'is_led_supported': True, 'rx_queue': 'off',
 551           'layer_mode': 'Ethernet', u'numa': 0}, ...]
 552         """
 553         self.port_info = self.client.get_port_info(ports)
 554         LOG.info('Connected to TRex')
 555         for id, port in enumerate(self.port_info):
 556             LOG.info('   Port %d: %s speed=%dGbps mac=%s pci=%s driver=%s',
 557                      id, port['description'], port['speed'], port['src_mac'],
 558                      port['pci_addr'], port['driver'])
 559         # Make sure the 2 ports have the same speed
 560         if self.port_info[0]['speed'] != self.port_info[1]['speed']:
 561             raise TrafficGeneratorException('Traffic generator ports speed mismatch: %d/%d Gbps' %
 562                                             (self.port_info[0]['speed'],
 563                                              self.port_info[1]['speed']))
 564
 565     def __start_local_server(self):
 566         try:
 567             LOG.info("Starting TRex ...")
 568             self.__start_server()
 569             self.__connect_after_start()
 570         except (TimeoutError, STLError) as e:
 571             LOG.error('Cannot connect to TRex')
 572             LOG.error(traceback.format_exc())
 573             logpath = '/tmp/trex.log'
 574             if os.path.isfile(logpath):
 575                 # Wait for TRex to finish writing error message
 576                 last_size = 0
 577                 for _ in xrange(self.config.generic_retry_count):
 578                     size = os.path.getsize(logpath)
 579                     if size == last_size:
 580                         # probably not writing anymore
 581                         break
 582                     last_size = size
 583                     time.sleep(1)
 584                 with open(logpath, 'r') as f:
 585                     message = f.read()
 586             else:
 587                 message = e.message
 588             raise TrafficGeneratorException(message)
 589
 590     def __start_server(self):
 591         server = TRexTrafficServer()
 592         server.run_server(self.generator_config)
 593
 594     def __check_config(self):
 595         server = TRexTrafficServer()
 596         return server.check_config_updated(self.generator_config)
 597
 598     def __restart(self):
 599         LOG.info("Restarting TRex ...")
 600         self.__stop_server()
 601         # Wait for server stopped
 602         for _ in xrange(self.config.generic_retry_count):
 603             time.sleep(1)
 604             if not self.client.is_connected():
 605                 LOG.info("TRex is stopped...")
 606                 break
 607         self.__start_local_server()
 608
 609     def __stop_server(self):
 610         if self.generator_config.ip == '127.0.0.1':
 611             ports = self.client.get_acquired_ports()
 612             LOG.info('Release ports %s and stopping TRex...', ports)
 613             try:
 614                 if ports:
 615                     self.client.release(ports=ports)
 616                 self.client.server_shutdown()
 617             except STLError as e:
 618                 LOG.warn('Unable to stop TRex. Error: %s', e)
 619         else:
 620             LOG.info('Using remote TRex. Unable to stop TRex')
 621
 622     def resolve_arp(self):
 623         """Resolve all configured remote IP addresses.
 624
 625         return: None if ARP failed to resolve for all IP addresses
 626                 else a dict of list of dest macs indexed by port#
 627                 the dest macs in the list are indexed by the chain id
 628         """
 629         self.client.set_service_mode(ports=self.port_handle)
 630         LOG.info('Polling ARP until successful...')
 631         arp_dest_macs = {}
 632         for port, device in zip(self.port_handle, self.generator_config.devices):
 633             # there should be 1 stream config per chain
 634             stream_configs = device.get_stream_configs()
 635             chain_count = len(stream_configs)
 636             ctx = self.client.create_service_ctx(port=port)
 637             # all dest macs on this port indexed by chain ID
 638             dst_macs = [None] * chain_count
 639             dst_macs_count = 0
 640             # the index in the list is the chain id
 641             if self.config.vxlan:
 642                 arps = [
 643                     ServiceARP(ctx,
 644                                src_ip=device.vtep_src_ip,
 645                                dst_ip=device.vtep_dst_ip,
 646                                vlan=device.vtep_vlan)
 647                     for cfg in stream_configs
 648                 ]
 649             else:
 650                 arps = [
 651                     ServiceARP(ctx,
 652                                src_ip=cfg['ip_src_tg_gw'],
 653                                dst_ip=cfg['mac_discovery_gw'],
 654                                # will be None if no vlan tagging
 655                                vlan=cfg['vlan_tag'])
 656                     for cfg in stream_configs
 657                 ]
 658
 659             for attempt in range(self.config.generic_retry_count):
 660                 try:
 661                     ctx.run(arps)
 662                 except STLError:
 663                     LOG.error(traceback.format_exc())
 664                     continue
 665
 666                 unresolved = []
 667                 for chain_id, mac in enumerate(dst_macs):
 668                     if not mac:
 669                         arp_record = arps[chain_id].get_record()
 670                         if arp_record.dst_mac:
 671                             dst_macs[chain_id] = arp_record.dst_mac
 672                             dst_macs_count += 1
 673                             LOG.info('   ARP: port=%d chain=%d src IP=%s dst IP=%s -> MAC=%s',
 674                                      port, chain_id,
 675                                      arp_record.src_ip,
 676                                      arp_record.dst_ip, arp_record.dst_mac)
 677                         else:
 678                             unresolved.append(arp_record.dst_ip)
 679                 if dst_macs_count == chain_count:
 680                     arp_dest_macs[port] = dst_macs
 681                     LOG.info('ARP resolved successfully for port %s', port)
 682                     break
 683                 else:
 684                     retry = attempt + 1
 685                     LOG.info('Retrying ARP for: %s (retry %d/%d)',
 686                              unresolved, retry, self.config.generic_retry_count)
 687                     if retry < self.config.generic_retry_count:
 688                         time.sleep(self.config.generic_poll_sec)
 689             else:
 690                 LOG.error('ARP timed out for port %s (resolved %d out of %d)',
 691                           port,
 692                           dst_macs_count,
 693                           chain_count)
 694                 break
 695
 696         self.client.set_service_mode(ports=self.port_handle, enabled=False)
 697         if len(arp_dest_macs) == len(self.port_handle):
 698             return arp_dest_macs
 699         return None
 700
 701     def __is_rate_enough(self, l2frame_size, rates, bidirectional, latency):
 702         """Check if rate provided by user is above requirements. Applies only if latency is True."""
 703         intf_speed = self.generator_config.intf_speed
 704         if latency:
 705             if bidirectional:
 706                 mult = 2
 707                 total_rate = 0
 708                 for rate in rates:
 709                     r = utils.convert_rates(l2frame_size, rate, intf_speed)
 710                     total_rate += int(r['rate_pps'])
 711             else:
 712                 mult = 1
 713                 total_rate = utils.convert_rates(l2frame_size, rates[0], intf_speed)
 714             # rate must be enough for latency stream and at least 1 pps for base stream per chain
 715             required_rate = (self.LATENCY_PPS + 1) * self.config.service_chain_count * mult
 716             result = utils.convert_rates(l2frame_size,
 717                                          {'rate_pps': required_rate},
 718                                          intf_speed * mult)
 719             result['result'] = total_rate >= required_rate
 720             return result
 721
 722         return {'result': True}
 723
 724     def create_traffic(self, l2frame_size, rates, bidirectional, latency=True, e2e=False):
 725         """Program all the streams in Trex server.
 726
 727         l2frame_size: L2 frame size or IMIX
 728         rates: a list of 2 rates to run each direction
 729                each rate is a dict like {'rate_pps': '10kpps'}
 730         bidirectional: True if bidirectional
 731         latency: True if latency measurement is needed
 732         e2e: True if performing "end to end" connectivity check
 733         """
 734         r = self.__is_rate_enough(l2frame_size, rates, bidirectional, latency)
 735         if not r['result']:
 736             raise TrafficGeneratorException(
 737                 'Required rate in total is at least one of: \n{pps}pps \n{bps}bps \n{load}%.'
 738                 .format(pps=r['rate_pps'],
 739                         bps=r['rate_bps'],
 740                         load=r['rate_percent']))
 741         # a dict of list of streams indexed by port#
 742         # in case of fixed size, has self.chain_count * 2 * 2 streams
 743         # (1 normal + 1 latency stream per direction per chain)
 744         # for IMIX, has self.chain_count * 2 * 4 streams
 745         # (3 normal + 1 latency stream per direction per chain)
 746         streamblock = {}
 747         for port in self.port_handle:
 748             streamblock[port] = []
 749         stream_cfgs = [d.get_stream_configs() for d in self.generator_config.devices]
 750         self.rates = [utils.to_rate_str(rate) for rate in rates]
 751         for chain_id, (fwd_stream_cfg, rev_stream_cfg) in enumerate(zip(*stream_cfgs)):
 752             streamblock[0].extend(self.generate_streams(self.port_handle[0],
 753                                                         chain_id,
 754                                                         fwd_stream_cfg,
 755                                                         l2frame_size,
 756                                                         latency=latency,
 757                                                         e2e=e2e))
 758             if len(self.rates) > 1:
 759                 streamblock[1].extend(self.generate_streams(self.port_handle[1],
 760                                                             chain_id,
 761                                                             rev_stream_cfg,
 762                                                             l2frame_size,
 763                                                             latency=bidirectional and latency,
 764                                                             e2e=e2e))
 765
 766         for port in self.port_handle:
 767             if self.config.vxlan:
 768                 self.client.set_port_attr(ports=port, vxlan_fs=[4789])
 769             else:
 770                 self.client.set_port_attr(ports=port, vxlan_fs=None)
 771             self.client.add_streams(streamblock[port], ports=port)
 772             LOG.info('Created %d traffic streams for port %s.', len(streamblock[port]), port)
 773
 774     def clear_streamblock(self):
 775         """Clear all streams from TRex."""
 776         self.rates = []
 777         self.client.reset(self.port_handle)
 778         LOG.info('Cleared all existing streams')
 779
 780     def get_stats(self):
 781         """Get stats from Trex."""
 782         stats = self.client.get_stats()
 783         return self.extract_stats(stats)
 784
 785     def get_macs(self):
 786         """Return the Trex local port MAC addresses.
 787
 788         return: a list of MAC addresses indexed by the port#
 789         """
 790         return [port['src_mac'] for port in self.port_info]
 791
 792     def get_port_speed_gbps(self):
 793         """Return the Trex local port MAC addresses.
 794
 795         return: a list of speed in Gbps indexed by the port#
 796         """
 797         return [port['speed'] for port in self.port_info]
 798
 799     def clear_stats(self):
 800         """Clear all stats in the traffic gneerator."""
 801         if self.port_handle:
 802             self.client.clear_stats()
 803
 804     def start_traffic(self):
 805         """Start generating traffic in all ports."""
 806         for port, rate in zip(self.port_handle, self.rates):
 807             self.client.start(ports=port, mult=rate, duration=self.config.duration_sec, force=True)
 808
 809     def stop_traffic(self):
 810         """Stop generating traffic."""
 811         self.client.stop(ports=self.port_handle)
 812
 813     def start_capture(self):
 814         """Capture all packets on both ports that are unicast to us."""
 815         if self.capture_id:
 816             self.stop_capture()
 817         # Need to filter out unwanted packets so we do not end up counting
 818         # src MACs of frames that are not unicast to us
 819         src_mac_list = self.get_macs()
 820         bpf_filter = "ether dst %s or ether dst %s" % (src_mac_list[0], src_mac_list[1])
 821         # ports must be set in service in order to enable capture
 822         self.client.set_service_mode(ports=self.port_handle)
 823         self.capture_id = self.client.start_capture(rx_ports=self.port_handle,
 824                                                     bpf_filter=bpf_filter)
 825
 826     def fetch_capture_packets(self):
 827         """Fetch capture packets in capture mode."""
 828         if self.capture_id:
 829             self.packet_list = []
 830             self.client.fetch_capture_packets(capture_id=self.capture_id['id'],
 831                                               output=self.packet_list)
 832
 833     def stop_capture(self):
 834         """Stop capturing packets."""
 835         if self.capture_id:
 836             self.client.stop_capture(capture_id=self.capture_id['id'])
 837             self.capture_id = None
 838             self.client.set_service_mode(ports=self.port_handle, enabled=False)
 839
 840     def cleanup(self):
 841         """Cleanup Trex driver."""
 842         if self.client:
 843             try:
 844                 self.client.reset(self.port_handle)
 845                 self.client.disconnect()
 846             except STLError:
 847                 # TRex does not like a reset while in disconnected state
 848                 pass