yardstick/network_services/traffic_profile/traffic_profile.py

   1 # Copyright (c) 2016-2017 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   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,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14 """ Trex Traffic Profile definitions """
  15
  16 from __future__ import absolute_import
  17 import struct
  18 import socket
  19 import logging
  20 from random import SystemRandom
  21 import six
  22
  23 from yardstick.network_services.traffic_profile.base import TrafficProfile
  24 from trex_stl_lib.trex_stl_client import STLStream
  25 from trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
  26 from trex_stl_lib.trex_stl_streams import STLTXCont
  27 from trex_stl_lib.trex_stl_streams import STLProfile
  28 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmWrFlowVar
  29 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVarRepeatableRandom
  30 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVar
  31 from trex_stl_lib.trex_stl_packet_builder_scapy import STLPktBuilder
  32 from trex_stl_lib.trex_stl_packet_builder_scapy import STLScVmRaw
  33 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFixIpv4
  34 from trex_stl_lib import api as Pkt
  35
  36
  37 class TrexProfile(TrafficProfile):
  38     """ This class handles Trex Traffic profile generation and execution """
  39
  40     def __init__(self, yaml_data):
  41         super(TrexProfile, self).__init__(yaml_data)
  42         self.flows = 100
  43         self.pps = 100
  44         self.pg_id = 0
  45         self.first_run = True
  46         self.streams = 1
  47         self.profile_data = []
  48         self.profile = None
  49         self.base_pkt = None
  50         self.fsize = None
  51         self.trex_vm = None
  52         self.vms = []
  53         self.rate = None
  54         self.ip_packet = None
  55         self.ip6_packet = None
  56         self.udp_packet = None
  57         self.udp_dport = ''
  58         self.udp_sport = ''
  59         self.qinq_packet = None
  60         self.qinq = False
  61         self.vm_flow_vars = []
  62         self.packets = []
  63         self.ether_packet = []
  64
  65     def execute(self, traffic_generator):
  66         """ Generate the stream and run traffic on the given ports """
  67         pass
  68
  69     def _set_ether_fields(self, **kwargs):
  70         """ set ethernet protocol fields """
  71         if not self.ether_packet:
  72             self.ether_packet = Pkt.Ether()
  73             for key, value in six.iteritems(kwargs):
  74                 setattr(self.ether_packet, key, value)
  75
  76     def _set_ip_fields(self, **kwargs):
  77         """ set l3 ipv4 protocol fields """
  78
  79         if not self.ip_packet:
  80             self.ip_packet = Pkt.IP()
  81         for key in kwargs:
  82             setattr(self.ip_packet, key, kwargs[key])
  83
  84     def _set_ip6_fields(self, **kwargs):
  85         """ set l3 ipv6 protocol fields """
  86         if not self.ip6_packet:
  87             self.ip6_packet = Pkt.IPv6()
  88         for key in kwargs:
  89             setattr(self.ip6_packet, key, kwargs[key])
  90
  91     def _set_udp_fields(self, **kwargs):
  92         """ set l4 udp ports fields """
  93         if not self.udp_packet:
  94             self.udp_packet = Pkt.UDP()
  95         for key in kwargs:
  96             setattr(self.udp_packet, key, kwargs[key])
  97
  98     def set_src_mac(self, src_mac):
  99         """ set source mac address fields """
 100         src_macs = src_mac.split('-')
 101         min_value = src_macs[0]
 102         if len(src_macs) == 1:
 103             src_mac = min_value
 104             self._set_ether_fields(src=src_mac)
 105         else:
 106             stl_vm_flow_var = STLVmFlowVar(name="mac_src",
 107                                            min_value=1,
 108                                            max_value=30,
 109                                            size=4,
 110                                            op='inc',
 111                                            step=1)
 112             self.vm_flow_vars.append(stl_vm_flow_var)
 113             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='mac_src',
 114                                                 pkt_offset='Ether.src')
 115             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 116
 117     def set_dst_mac(self, dst_mac):
 118         """ set destination mac address fields """
 119         dst_macs = dst_mac.split('-')
 120         min_value = dst_macs[0]
 121         if len(dst_macs) == 1:
 122             dst_mac = min_value
 123             self._set_ether_fields(dst=dst_mac)
 124         else:
 125             stl_vm_flow_var = STLVmFlowVar(name="mac_dst",
 126                                            min_value=1,
 127                                            max_value=30,
 128                                            size=4,
 129                                            op='inc',
 130                                            step=1)
 131             self.vm_flow_vars.append(stl_vm_flow_var)
 132             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='mac_dst',
 133                                                 pkt_offset='Ether.dst')
 134             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 135
 136     def set_src_ip4(self, src_ip4, count=1):
 137         """ set source ipv4 address fields """
 138         src_ips = src_ip4.split('-')
 139         min_value = src_ips[0]
 140         max_value = src_ips[1] if len(src_ips) == 2 else src_ips[0]
 141         if len(src_ips) == 1:
 142             src_ip4 = min_value
 143             self._set_ip_fields(src=src_ip4)
 144         else:
 145             stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="ip4_src",
 146                                                            min_value=min_value,
 147                                                            max_value=max_value,
 148                                                            size=4,
 149                                                            limit=int(count),
 150                                                            seed=0x1235)
 151             self.vm_flow_vars.append(stl_vm_flow_var)
 152             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='ip4_src',
 153                                                 pkt_offset='IP.src')
 154             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 155             stl_vm_fix_ipv4 = STLVmFixIpv4(offset="IP")
 156             self.vm_flow_vars.append(stl_vm_fix_ipv4)
 157
 158     def set_dst_ip4(self, dst_ip4, count=1):
 159         """ set destination ipv4 address fields """
 160         dst_ips = dst_ip4.split('-')
 161         min_value = dst_ips[0]
 162         max_value = dst_ips[1] if len(dst_ips) == 2 else dst_ips[0]
 163         if len(dst_ips) == 1:
 164             dst_ip4 = min_value
 165             self._set_ip_fields(dst=dst_ip4)
 166         else:
 167             stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="dst_ip4",
 168                                                            min_value=min_value,
 169                                                            max_value=max_value,
 170                                                            size=4,
 171                                                            limit=int(count),
 172                                                            seed=0x1235)
 173             self.vm_flow_vars.append(stl_vm_flow_var)
 174             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dst_ip4',
 175                                                 pkt_offset='IP.dst')
 176             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 177             stl_vm_fix_ipv4 = STLVmFixIpv4(offset="IP")
 178             self.vm_flow_vars.append(stl_vm_fix_ipv4)
 179
 180     def set_src_ip6(self, src_ip6):
 181         """ set source ipv6 address fields """
 182         src_ips = src_ip6.split('-')
 183         min_value = src_ips[0]
 184         max_value = src_ips[1] if len(src_ips) == 2 else src_ips[0]
 185         src_ip6 = min_value
 186         self._set_ip6_fields(src=src_ip6)
 187         if len(src_ips) == 2:
 188             min_value, max_value = \
 189                 self._get_start_end_ipv6(min_value, max_value)
 190             stl_vm_flow_var = STLVmFlowVar(name="ip6_src",
 191                                            min_value=min_value,
 192                                            max_value=max_value,
 193                                            size=8,
 194                                            op='random',
 195                                            step=1)
 196             self.vm_flow_vars.append(stl_vm_flow_var)
 197             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='ip6_src',
 198                                                 pkt_offset='IPv6.src',
 199                                                 offset_fixup=8)
 200             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 201
 202     def set_dst_ip6(self, dst_ip6):
 203         """ set destination ipv6 address fields """
 204         dst_ips = dst_ip6.split('-')
 205         min_value = dst_ips[0]
 206         max_value = dst_ips[1] if len(dst_ips) == 2 else dst_ips[0]
 207         dst_ip6 = min_value
 208         self._set_ip6_fields(dst=dst_ip6)
 209         if len(dst_ips) == 2:
 210             min_value, max_value = \
 211                 self._get_start_end_ipv6(min_value, max_value)
 212             stl_vm_flow_var = STLVmFlowVar(name="dst_ip6",
 213                                            min_value=min_value,
 214                                            max_value=max_value,
 215                                            size=8,
 216                                            op='random',
 217                                            step=1)
 218             self.vm_flow_vars.append(stl_vm_flow_var)
 219             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dst_ip6',
 220                                                 pkt_offset='IPv6.dst',
 221                                                 offset_fixup=8)
 222             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 223
 224     def set_dscp(self, dscp):
 225         """ set dscp for trex """
 226         dscps = str(dscp).split('-')
 227         min_value = int(dscps[0])
 228         max_value = int(dscps[1]) if len(dscps) == 2 else int(dscps[0])
 229         if len(dscps) == 1:
 230             dscp = min_value
 231             self._set_ip_fields(tos=dscp)
 232         else:
 233             stl_vm_flow_var = STLVmFlowVar(name="dscp",
 234                                            min_value=min_value,
 235                                            max_value=max_value,
 236                                            size=2,
 237                                            op='inc',
 238                                            step=8)
 239             self.vm_flow_vars.append(stl_vm_flow_var)
 240             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dscp',
 241                                                 pkt_offset='IP.tos')
 242             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 243
 244     def set_src_port(self, src_port, count=1):
 245         """ set packet source port """
 246         src_ports = str(src_port).split('-')
 247         min_value = int(src_ports[0])
 248         if len(src_ports) == 1:
 249             max_value = int(src_ports[0])
 250             src_port = min_value
 251             self._set_udp_fields(sport=src_port)
 252         else:
 253             max_value = int(src_ports[1])
 254             stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="port_src",
 255                                                            min_value=min_value,
 256                                                            max_value=max_value,
 257                                                            size=2,
 258                                                            limit=int(count),
 259                                                            seed=0x1235)
 260             self.vm_flow_vars.append(stl_vm_flow_var)
 261             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='port_src',
 262                                                 pkt_offset=self.udp_sport)
 263             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 264
 265     def set_dst_port(self, dst_port, count=1):
 266         """ set packet destnation port """
 267         dst_ports = str(dst_port).split('-')
 268         min_value = int(dst_ports[0])
 269         if len(dst_ports) == 1:
 270             max_value = int(dst_ports[0])
 271             dst_port = min_value
 272             self._set_udp_fields(dport=dst_port)
 273         else:
 274             max_value = int(dst_ports[1])
 275             stl_vm_flow_var = \
 276                 STLVmFlowVarRepeatableRandom(name="port_dst",
 277                                              min_value=min_value,
 278                                              max_value=max_value,
 279                                              size=2,
 280                                              limit=int(count),
 281                                              seed=0x1235)
 282             self.vm_flow_vars.append(stl_vm_flow_var)
 283             stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='port_dst',
 284                                                 pkt_offset=self.udp_dport)
 285             self.vm_flow_vars.append(stl_vm_wr_flow_var)
 286
 287     def set_svlan_cvlan(self, svlan, cvlan):
 288         """ set svlan & cvlan """
 289         self.qinq = True
 290         ether_params = {'type': 0x8100}
 291         self._set_ether_fields(**ether_params)
 292         svlans = str(svlan['id']).split('-')
 293         svlan_min = int(svlans[0])
 294         svlan_max = int(svlans[1]) if len(svlans) == 2 else int(svlans[0])
 295         if len(svlans) == 2:
 296             svlan = self._get_random_value(svlan_min, svlan_max)
 297         else:
 298             svlan = svlan_min
 299         cvlans = str(cvlan['id']).split('-')
 300         cvlan_min = int(cvlans[0])
 301         cvlan_max = int(cvlans[1]) if len(cvlans) == 2 else int(cvlans[0])
 302         if len(cvlans) == 2:
 303             cvlan = self._get_random_value(cvlan_min, cvlan_max)
 304         else:
 305             cvlan = cvlan_min
 306         self.qinq_packet = Pkt.Dot1Q(vlan=svlan) / Pkt.Dot1Q(vlan=cvlan)
 307
 308     def set_qinq(self, qinq):
 309         """ set qinq in packet """
 310         self.set_svlan_cvlan(qinq['S-VLAN'], qinq['C-VLAN'])
 311
 312     def set_outer_l2_fields(self, outer_l2):
 313         """ setup outer l2 fields from traffic profile """
 314         ether_params = {'type': 0x800}
 315         self._set_ether_fields(**ether_params)
 316         if 'srcmac' in outer_l2:
 317             self.set_src_mac(outer_l2['srcmac'])
 318         if 'dstmac' in outer_l2:
 319             self.set_dst_mac(outer_l2['dstmac'])
 320         if 'QinQ' in outer_l2:
 321             self.set_qinq(outer_l2['QinQ'])
 322
 323     def set_outer_l3v4_fields(self, outer_l3v4):
 324         """ setup outer l3v4 fields from traffic profile """
 325         ip_params = {}
 326         if 'proto' in outer_l3v4:
 327             ip_params['proto'] = outer_l3v4['proto']
 328             if outer_l3v4['proto'] == 'tcp':
 329                 self.udp_packet = Pkt.TCP()
 330                 self.udp_dport = 'TCP.dport'
 331                 self.udp_sport = 'TCP.sport'
 332                 tcp_params = {'flags': '', 'window': 0}
 333                 self._set_udp_fields(**tcp_params)
 334         if 'ttl' in outer_l3v4:
 335             ip_params['ttl'] = outer_l3v4['ttl']
 336         self._set_ip_fields(**ip_params)
 337         if 'dscp' in outer_l3v4:
 338             self.set_dscp(outer_l3v4['dscp'])
 339         if 'srcip4' in outer_l3v4:
 340             self.set_src_ip4(outer_l3v4['srcip4'], outer_l3v4['count'])
 341         if 'dstip4' in outer_l3v4:
 342             self.set_dst_ip4(outer_l3v4['dstip4'], outer_l3v4['count'])
 343
 344     def set_outer_l3v6_fields(self, outer_l3v6):
 345         """ setup outer l3v6 fields from traffic profile """
 346         ether_params = {'type': 0x86dd}
 347         self._set_ether_fields(**ether_params)
 348         ip6_params = {}
 349         if 'proto' in outer_l3v6:
 350             ip6_params['proto'] = outer_l3v6['proto']
 351             if outer_l3v6['proto'] == 'tcp':
 352                 self.udp_packet = Pkt.TCP()
 353                 self.udp_dport = 'TCP.dport'
 354                 self.udp_sport = 'TCP.sport'
 355                 tcp_params = {'flags': '', 'window': 0}
 356                 self._set_udp_fields(**tcp_params)
 357         if 'ttl' in outer_l3v6:
 358             ip6_params['ttl'] = outer_l3v6['ttl']
 359         if 'tc' in outer_l3v6:
 360             ip6_params['tc'] = outer_l3v6['tc']
 361         if 'hlim' in outer_l3v6:
 362             ip6_params['hlim'] = outer_l3v6['hlim']
 363         self._set_ip6_fields(**ip6_params)
 364         if 'srcip6' in outer_l3v6:
 365             self.set_src_ip6(outer_l3v6['srcip6'])
 366         if 'dstip6' in outer_l3v6:
 367             self.set_dst_ip6(outer_l3v6['dstip6'])
 368
 369     def set_outer_l4_fields(self, outer_l4):
 370         """ setup outer l4 fields from traffic profile """
 371         if 'srcport' in outer_l4:
 372             self.set_src_port(outer_l4['srcport'], outer_l4['count'])
 373         if 'dstport' in outer_l4:
 374             self.set_dst_port(outer_l4['dstport'], outer_l4['count'])
 375
 376     def generate_imix_data(self, packet_definition):
 377         """ generate packet size for a given traffic profile """
 378         imix_count = {}
 379         imix_data = {}
 380         if not packet_definition:
 381             return imix_count
 382         imix = packet_definition.get('framesize')
 383         if imix:
 384             for size in imix:
 385                 data = imix[size]
 386                 imix_data[int(size[:-1])] = int(data)
 387             imix_sum = sum(imix_data.values())
 388             if imix_sum > 100:
 389                 raise SystemExit("Error in IMIX data")
 390             elif imix_sum < 100:
 391                 imix_data[64] = imix_data.get(64, 0) + (100 - imix_sum)
 392
 393             avg_size = 0.0
 394             for size in imix_data:
 395                 count = int(imix_data[size])
 396                 if count:
 397                     avg_size += round(size * count / 100, 2)
 398                     pps = round(self.pps * count / 100, 0)
 399                     imix_count[size] = pps
 400             self.rate = round(1342177280 / avg_size, 0) * 2
 401             logging.debug("Imax: %s rate: %s", imix_count, self.rate)
 402         return imix_count
 403
 404     def get_streams(self, profile_data):
 405         """ generate trex stream
 406         :param profile_data:
 407         :type profile_data:
 408         """
 409         self.streams = []
 410         self.pps = self.params['traffic_profile'].get('frame_rate', 100)
 411         for packet_name in profile_data:
 412             outer_l2 = profile_data[packet_name].get('outer_l2')
 413             imix_data = self.generate_imix_data(outer_l2)
 414             if not imix_data:
 415                 imix_data = {64: self.pps}
 416             self.generate_vm(profile_data[packet_name])
 417             for size in imix_data:
 418                 self._generate_streams(size, imix_data[size])
 419         self._generate_profile()
 420         return self.profile
 421
 422     def generate_vm(self, packet_definition):
 423         """ generate  trex vm with flows setup """
 424         self.ether_packet = Pkt.Ether()
 425         self.ip_packet = Pkt.IP()
 426         self.ip6_packet = None
 427         self.udp_packet = Pkt.UDP()
 428         self.udp_dport = 'UDP.dport'
 429         self.udp_sport = 'UDP.sport'
 430         self.qinq = False
 431         self.vm_flow_vars = []
 432         outer_l2 = packet_definition.get('outer_l2', None)
 433         outer_l3v4 = packet_definition.get('outer_l3v4', None)
 434         outer_l3v6 = packet_definition.get('outer_l3v6', None)
 435         outer_l4 = packet_definition.get('outer_l4', None)
 436         if outer_l2:
 437             self.set_outer_l2_fields(outer_l2)
 438         if outer_l3v4:
 439             self.set_outer_l3v4_fields(outer_l3v4)
 440         if outer_l3v6:
 441             self.set_outer_l3v6_fields(outer_l3v6)
 442         if outer_l4:
 443             self.set_outer_l4_fields(outer_l4)
 444         self.trex_vm = STLScVmRaw(self.vm_flow_vars)
 445
 446     def generate_packets(self):
 447         """ generate packets from trex TG """
 448         base_pkt = self.base_pkt
 449         size = self.fsize - 4
 450         pad = max(0, size - len(base_pkt)) * 'x'
 451         self.packets = [STLPktBuilder(pkt=base_pkt / pad,
 452                                       vm=vm) for vm in self.vms]
 453
 454     def _create_single_packet(self, size=64):
 455         size = size - 4
 456         ether_packet = self.ether_packet
 457         ip_packet = self.ip6_packet if self.ip6_packet else self.ip_packet
 458         udp_packet = self.udp_packet
 459         if self.qinq:
 460             qinq_packet = self.qinq_packet
 461             base_pkt = ether_packet / qinq_packet / ip_packet / udp_packet
 462         else:
 463             base_pkt = ether_packet / ip_packet / udp_packet
 464         pad = max(0, size - len(base_pkt)) * 'x'
 465         packet = STLPktBuilder(pkt=base_pkt / pad, vm=self.trex_vm)
 466         return packet
 467
 468     def _create_single_stream(self, packet_size, pps, isg=0):
 469         packet = self._create_single_packet(packet_size)
 470         if self.pg_id:
 471             self.pg_id += 1
 472             stl_flow = STLFlowLatencyStats(pg_id=self.pg_id)
 473             stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps),
 474                                flow_stats=stl_flow)
 475         else:
 476             stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps))
 477         return stream
 478
 479     def _generate_streams(self, packet_size, pps):
 480         self.streams.append(self._create_single_stream(packet_size, pps))
 481
 482     def _generate_profile(self):
 483         self.profile = STLProfile(self.streams)
 484
 485     @classmethod
 486     def _get_start_end_ipv6(cls, start_ip, end_ip):
 487         try:
 488             ip1 = socket.inet_pton(socket.AF_INET6, start_ip)
 489             ip2 = socket.inet_pton(socket.AF_INET6, end_ip)
 490             hi1, lo1 = struct.unpack('!QQ', ip1)
 491             hi2, lo2 = struct.unpack('!QQ', ip2)
 492             if ((hi1 << 64) | lo1) > ((hi2 << 64) | lo2):
 493                 raise SystemExit("IPv6: start_ip is greater then end_ip")
 494             max_p1 = abs(int(lo1) - int(lo2))
 495             base_p1 = lo1
 496         except Exception as ex_error:
 497             raise SystemExit(ex_error)
 498         else:
 499             return base_p1, max_p1 + base_p1
 500
 501     @classmethod
 502     def _get_random_value(cls, min_port, max_port):
 503         cryptogen = SystemRandom()
 504         return cryptogen.randrange(min_port, max_port)