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, vm=STLScVmRaw(vm_param))
 426
 427     def generate_streams(self, port, chain_id, stream_cfg, l2frame, latency=True,
 428                          e2e=False):
 429         """Create a list of streams corresponding to a given chain and stream config.
 430
 431         port: port where the streams originate (0 or 1)
 432         chain_id: the chain to which the streams are associated to
 433         stream_cfg: stream configuration
 434         l2frame: L2 frame size (including 4-byte FCS) or 'IMIX'
 435         latency: if True also create a latency stream
 436         e2e: True if performing "end to end" connectivity check
 437         """
 438         streams = []
 439         pg_id, lat_pg_id = self.get_pg_id(port, chain_id)
 440         if l2frame == 'IMIX':
 441             for ratio, l2_frame_size in zip(IMIX_RATIOS, IMIX_L2_SIZES):
 442                 pkt = self._create_pkt(stream_cfg, l2_frame_size)
 443                 if e2e:
 444                     streams.append(STLStream(packet=pkt,
 445                                              mode=STLTXCont(pps=ratio)))
 446                 else:
 447                     if stream_cfg['vxlan'] is True:
 448                         streams.append(STLStream(packet=pkt,
 449                                                  flow_stats=STLFlowStats(pg_id=pg_id,
 450                                                                          vxlan=True),
 451                                                  mode=STLTXCont(pps=ratio)))
 452                     else:
 453                         streams.append(STLStream(packet=pkt,
 454                                                  flow_stats=STLFlowStats(pg_id=pg_id),
 455                                                  mode=STLTXCont(pps=ratio)))
 456
 457             if latency:
 458                 # for IMIX, the latency packets have the average IMIX packet size
 459                 pkt = self._create_pkt(stream_cfg, IMIX_AVG_L2_FRAME_SIZE)
 460
 461         else:
 462             l2frame_size = int(l2frame)
 463             pkt = self._create_pkt(stream_cfg, l2frame_size)
 464             if e2e:
 465                 streams.append(STLStream(packet=pkt,
 466                                          mode=STLTXCont()))
 467             else:
 468                 if stream_cfg['vxlan'] is True:
 469                     streams.append(STLStream(packet=pkt,
 470                                              flow_stats=STLFlowStats(pg_id=pg_id,
 471                                                                      vxlan=True),
 472                                              mode=STLTXCont()))
 473                 else:
 474                     streams.append(STLStream(packet=pkt,
 475                                              flow_stats=STLFlowStats(pg_id=pg_id),
 476                                              mode=STLTXCont()))
 477             # for the latency stream, the minimum payload is 16 bytes even in case of vlan tagging
 478             # without vlan, the min l2 frame size is 64
 479             # with vlan it is 68
 480             # This only applies to the latency stream
 481             if latency and stream_cfg['vlan_tag'] and l2frame_size < 68:
 482                 pkt = self._create_pkt(stream_cfg, 68)
 483
 484         if latency:
 485             # TRex limitation: VXLAN skip is not supported for latency stream
 486             streams.append(STLStream(packet=pkt,
 487                                      flow_stats=STLFlowLatencyStats(pg_id=lat_pg_id),
 488                                      mode=STLTXCont(pps=self.LATENCY_PPS)))
 489         return streams
 490
 491     @timeout(5)
 492     def __connect(self, client):
 493         client.connect()
 494
 495     def __connect_after_start(self):
 496         # after start, Trex may take a bit of time to initialize
 497         # so we need to retry a few times
 498         for it in xrange(self.config.generic_retry_count):
 499             try:
 500                 time.sleep(1)
 501                 self.client.connect()
 502                 break
 503             except Exception as ex:
 504                 if it == (self.config.generic_retry_count - 1):
 505                     raise
 506                 LOG.info("Retrying connection to TRex (%s)...", ex.message)
 507
 508     def connect(self):
 509         """Connect to the TRex server."""
 510         server_ip = self.generator_config.ip
 511         LOG.info("Connecting to TRex (%s)...", server_ip)
 512
 513         # Connect to TRex server
 514         self.client = STLClient(server=server_ip, sync_port=self.generator_config.zmq_rpc_port,
 515                                 async_port=self.generator_config.zmq_pub_port)
 516         try:
 517             self.__connect(self.client)
 518             if server_ip == '127.0.0.1':
 519                 config_updated = self.__check_config()
 520                 if config_updated or self.config.restart:
 521                     self.__restart()
 522         except (TimeoutError, STLError) as e:
 523             if server_ip == '127.0.0.1':
 524                 self.__start_local_server()
 525             else:
 526                 raise TrafficGeneratorException(e.message)
 527
 528         ports = list(self.generator_config.ports)
 529         self.port_handle = ports
 530         # Prepare the ports
 531         self.client.reset(ports)
 532         # Read HW information from each port
 533         # this returns an array of dict (1 per port)
 534         """
 535         Example of output for Intel XL710
 536         [{'arp': '-', 'src_ipv4': '-', u'supp_speeds': [40000], u'is_link_supported': True,
 537           'grat_arp': 'off', 'speed': 40, u'index': 0, 'link_change_supported': 'yes',
 538           u'rx': {u'counters': 127, u'caps': [u'flow_stats', u'latency']},
 539           u'is_virtual': 'no', 'prom': 'off', 'src_mac': u'3c:fd:fe:a8:24:48', 'status': 'IDLE',
 540           u'description': u'Ethernet Controller XL710 for 40GbE QSFP+',
 541           'dest': u'fa:16:3e:3c:63:04', u'is_fc_supported': False, 'vlan': '-',
 542           u'driver': u'net_i40e', 'led_change_supported': 'yes', 'rx_filter_mode': 'hardware match',
 543           'fc': 'none', 'link': 'UP', u'hw_mac': u'3c:fd:fe:a8:24:48', u'pci_addr': u'0000:5e:00.0',
 544           'mult': 'off', 'fc_supported': 'no', u'is_led_supported': True, 'rx_queue': 'off',
 545           'layer_mode': 'Ethernet', u'numa': 0}, ...]
 546         """
 547         self.port_info = self.client.get_port_info(ports)
 548         LOG.info('Connected to TRex')
 549         for id, port in enumerate(self.port_info):
 550             LOG.info('   Port %d: %s speed=%dGbps mac=%s pci=%s driver=%s',
 551                      id, port['description'], port['speed'], port['src_mac'],
 552                      port['pci_addr'], port['driver'])
 553         # Make sure the 2 ports have the same speed
 554         if self.port_info[0]['speed'] != self.port_info[1]['speed']:
 555             raise TrafficGeneratorException('Traffic generator ports speed mismatch: %d/%d Gbps' %
 556                                             (self.port_info[0]['speed'],
 557                                              self.port_info[1]['speed']))
 558
 559     def __start_local_server(self):
 560         try:
 561             LOG.info("Starting TRex ...")
 562             self.__start_server()
 563             self.__connect_after_start()
 564         except (TimeoutError, STLError) as e:
 565             LOG.error('Cannot connect to TRex')
 566             LOG.error(traceback.format_exc())
 567             logpath = '/tmp/trex.log'
 568             if os.path.isfile(logpath):
 569                 # Wait for TRex to finish writing error message
 570                 last_size = 0
 571                 for _ in xrange(self.config.generic_retry_count):
 572                     size = os.path.getsize(logpath)
 573                     if size == last_size:
 574                         # probably not writing anymore
 575                         break
 576                     last_size = size
 577                     time.sleep(1)
 578                 with open(logpath, 'r') as f:
 579                     message = f.read()
 580             else:
 581                 message = e.message
 582             raise TrafficGeneratorException(message)
 583
 584     def __start_server(self):
 585         server = TRexTrafficServer()
 586         server.run_server(self.generator_config)
 587
 588     def __check_config(self):
 589         server = TRexTrafficServer()
 590         return server.check_config_updated(self.generator_config)
 591
 592     def __restart(self):
 593         LOG.info("Restarting TRex ...")
 594         self.__stop_server()
 595         # Wait for server stopped
 596         for _ in xrange(self.config.generic_retry_count):
 597             time.sleep(1)
 598             if not self.client.is_connected():
 599                 LOG.info("TRex is stopped...")
 600                 break
 601         self.__start_local_server()
 602
 603     def __stop_server(self):
 604         if self.generator_config.ip == '127.0.0.1':
 605             ports = self.client.get_acquired_ports()
 606             LOG.info('Release ports %s and stopping TRex...', ports)
 607             try:
 608                 if ports:
 609                     self.client.release(ports=ports)
 610                 self.client.server_shutdown()
 611             except STLError as e:
 612                 LOG.warn('Unable to stop TRex. Error: %s', e)
 613         else:
 614             LOG.info('Using remote TRex. Unable to stop TRex')
 615
 616     def resolve_arp(self):
 617         """Resolve all configured remote IP addresses.
 618
 619         return: None if ARP failed to resolve for all IP addresses
 620                 else a dict of list of dest macs indexed by port#
 621                 the dest macs in the list are indexed by the chain id
 622         """
 623         self.client.set_service_mode(ports=self.port_handle)
 624         LOG.info('Polling ARP until successful...')
 625         arp_dest_macs = {}
 626         for port, device in zip(self.port_handle, self.generator_config.devices):
 627             # there should be 1 stream config per chain
 628             stream_configs = device.get_stream_configs()
 629             chain_count = len(stream_configs)
 630             ctx = self.client.create_service_ctx(port=port)
 631             # all dest macs on this port indexed by chain ID
 632             dst_macs = [None] * chain_count
 633             dst_macs_count = 0
 634             # the index in the list is the chain id
 635             if self.config.vxlan:
 636                 arps = [
 637                     ServiceARP(ctx,
 638                                src_ip=device.vtep_src_ip,
 639                                dst_ip=device.vtep_dst_ip,
 640                                vlan=device.vtep_vlan)
 641                     for cfg in stream_configs
 642                 ]
 643             else:
 644                 arps = [
 645                     ServiceARP(ctx,
 646                                src_ip=cfg['ip_src_tg_gw'],
 647                                dst_ip=cfg['mac_discovery_gw'],
 648                                # will be None if no vlan tagging
 649                                vlan=cfg['vlan_tag'])
 650                     for cfg in stream_configs
 651                 ]
 652
 653             for attempt in range(self.config.generic_retry_count):
 654                 try:
 655                     ctx.run(arps)
 656                 except STLError:
 657                     LOG.error(traceback.format_exc())
 658                     continue
 659
 660                 unresolved = []
 661                 for chain_id, mac in enumerate(dst_macs):
 662                     if not mac:
 663                         arp_record = arps[chain_id].get_record()
 664                         if arp_record.dst_mac:
 665                             dst_macs[chain_id] = arp_record.dst_mac
 666                             dst_macs_count += 1
 667                             LOG.info('   ARP: port=%d chain=%d src IP=%s dst IP=%s -> MAC=%s',
 668                                      port, chain_id,
 669                                      arp_record.src_ip,
 670                                      arp_record.dst_ip, arp_record.dst_mac)
 671                         else:
 672                             unresolved.append(arp_record.dst_ip)
 673                 if dst_macs_count == chain_count:
 674                     arp_dest_macs[port] = dst_macs
 675                     LOG.info('ARP resolved successfully for port %s', port)
 676                     break
 677                 else:
 678                     retry = attempt + 1
 679                     LOG.info('Retrying ARP for: %s (retry %d/%d)',
 680                              unresolved, retry, self.config.generic_retry_count)
 681                     if retry < self.config.generic_retry_count:
 682                         time.sleep(self.config.generic_poll_sec)
 683             else:
 684                 LOG.error('ARP timed out for port %s (resolved %d out of %d)',
 685                           port,
 686                           dst_macs_count,
 687                           chain_count)
 688                 break
 689
 690         self.client.set_service_mode(ports=self.port_handle, enabled=False)
 691         if len(arp_dest_macs) == len(self.port_handle):
 692             return arp_dest_macs
 693         return None
 694
 695     def __is_rate_enough(self, l2frame_size, rates, bidirectional, latency):
 696         """Check if rate provided by user is above requirements. Applies only if latency is True."""
 697         intf_speed = self.generator_config.intf_speed
 698         if latency:
 699             if bidirectional:
 700                 mult = 2
 701                 total_rate = 0
 702                 for rate in rates:
 703                     r = utils.convert_rates(l2frame_size, rate, intf_speed)
 704                     total_rate += int(r['rate_pps'])
 705             else:
 706                 mult = 1
 707                 total_rate = utils.convert_rates(l2frame_size, rates[0], intf_speed)
 708             # rate must be enough for latency stream and at least 1 pps for base stream per chain
 709             required_rate = (self.LATENCY_PPS + 1) * self.config.service_chain_count * mult
 710             result = utils.convert_rates(l2frame_size,
 711                                          {'rate_pps': required_rate},
 712                                          intf_speed * mult)
 713             result['result'] = total_rate >= required_rate
 714             return result
 715
 716         return {'result': True}
 717
 718     def create_traffic(self, l2frame_size, rates, bidirectional, latency=True, e2e=False):
 719         """Program all the streams in Trex server.
 720
 721         l2frame_size: L2 frame size or IMIX
 722         rates: a list of 2 rates to run each direction
 723                each rate is a dict like {'rate_pps': '10kpps'}
 724         bidirectional: True if bidirectional
 725         latency: True if latency measurement is needed
 726         e2e: True if performing "end to end" connectivity check
 727         """
 728         r = self.__is_rate_enough(l2frame_size, rates, bidirectional, latency)
 729         if not r['result']:
 730             raise TrafficGeneratorException(
 731                 'Required rate in total is at least one of: \n{pps}pps \n{bps}bps \n{load}%.'
 732                 .format(pps=r['rate_pps'],
 733                         bps=r['rate_bps'],
 734                         load=r['rate_percent']))
 735         # a dict of list of streams indexed by port#
 736         # in case of fixed size, has self.chain_count * 2 * 2 streams
 737         # (1 normal + 1 latency stream per direction per chain)
 738         # for IMIX, has self.chain_count * 2 * 4 streams
 739         # (3 normal + 1 latency stream per direction per chain)
 740         streamblock = {}
 741         for port in self.port_handle:
 742             streamblock[port] = []
 743         stream_cfgs = [d.get_stream_configs() for d in self.generator_config.devices]
 744         self.rates = [utils.to_rate_str(rate) for rate in rates]
 745         for chain_id, (fwd_stream_cfg, rev_stream_cfg) in enumerate(zip(*stream_cfgs)):
 746             streamblock[0].extend(self.generate_streams(self.port_handle[0],
 747                                                         chain_id,
 748                                                         fwd_stream_cfg,
 749                                                         l2frame_size,
 750                                                         latency=latency,
 751                                                         e2e=e2e))
 752             if len(self.rates) > 1:
 753                 streamblock[1].extend(self.generate_streams(self.port_handle[1],
 754                                                             chain_id,
 755                                                             rev_stream_cfg,
 756                                                             l2frame_size,
 757                                                             latency=bidirectional and latency,
 758                                                             e2e=e2e))
 759
 760         for port in self.port_handle:
 761             if self.config.vxlan:
 762                 self.client.set_port_attr(ports=port, vxlan_fs=[4789])
 763             else:
 764                 self.client.set_port_attr(ports=port, vxlan_fs=None)
 765             self.client.add_streams(streamblock[port], ports=port)
 766             LOG.info('Created %d traffic streams for port %s.', len(streamblock[port]), port)
 767
 768     def clear_streamblock(self):
 769         """Clear all streams from TRex."""
 770         self.rates = []
 771         self.client.reset(self.port_handle)
 772         LOG.info('Cleared all existing streams')
 773
 774     def get_stats(self):
 775         """Get stats from Trex."""
 776         stats = self.client.get_stats()
 777         return self.extract_stats(stats)
 778
 779     def get_macs(self):
 780         """Return the Trex local port MAC addresses.
 781
 782         return: a list of MAC addresses indexed by the port#
 783         """
 784         return [port['src_mac'] for port in self.port_info]
 785
 786     def get_port_speed_gbps(self):
 787         """Return the Trex local port MAC addresses.
 788
 789         return: a list of speed in Gbps indexed by the port#
 790         """
 791         return [port['speed'] for port in self.port_info]
 792
 793     def clear_stats(self):
 794         """Clear all stats in the traffic gneerator."""
 795         if self.port_handle:
 796             self.client.clear_stats()
 797
 798     def start_traffic(self):
 799         """Start generating traffic in all ports."""
 800         for port, rate in zip(self.port_handle, self.rates):
 801             self.client.start(ports=port, mult=rate, duration=self.config.duration_sec, force=True)
 802
 803     def stop_traffic(self):
 804         """Stop generating traffic."""
 805         self.client.stop(ports=self.port_handle)
 806
 807     def start_capture(self):
 808         """Capture all packets on both ports that are unicast to us."""
 809         if self.capture_id:
 810             self.stop_capture()
 811         # Need to filter out unwanted packets so we do not end up counting
 812         # src MACs of frames that are not unicast to us
 813         src_mac_list = self.get_macs()
 814         bpf_filter = "ether dst %s or ether dst %s" % (src_mac_list[0], src_mac_list[1])
 815         # ports must be set in service in order to enable capture
 816         self.client.set_service_mode(ports=self.port_handle)
 817         self.capture_id = self.client.start_capture(rx_ports=self.port_handle,
 818                                                     bpf_filter=bpf_filter)
 819
 820     def fetch_capture_packets(self):
 821         """Fetch capture packets in capture mode."""
 822         if self.capture_id:
 823             self.packet_list = []
 824             self.client.fetch_capture_packets(capture_id=self.capture_id['id'],
 825                                               output=self.packet_list)
 826
 827     def stop_capture(self):
 828         """Stop capturing packets."""
 829         if self.capture_id:
 830             self.client.stop_capture(capture_id=self.capture_id['id'])
 831             self.capture_id = None
 832             self.client.set_service_mode(ports=self.port_handle, enabled=False)
 833
 834     def cleanup(self):
 835         """Cleanup Trex driver."""
 836         if self.client:
 837             try:
 838                 self.client.reset(self.port_handle)
 839                 self.client.disconnect()
 840             except STLError:
 841                 # TRex does not like a reset while in disconnected state
 842                 pass