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