tools/pkt_gen/testcenter/testcenter.py

   1 # Copyright 2016 Spirent Communications.
   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
  15 """
  16 Code to integrate Spirent TestCenter with the vsperf test framework.
  17
  18 Provides a model for Spirent TestCenter as a test tool for implementing
  19 various performance tests of a virtual switch.
  20 """
  21
  22 import csv
  23 import logging
  24 import os
  25 import subprocess
  26
  27 from conf import settings
  28 from core.results.results_constants import ResultsConstants
  29 from tools.pkt_gen import trafficgen
  30
  31
  32 class TestCenter(trafficgen.ITrafficGenerator):
  33     """
  34     Spirent TestCenter
  35     """
  36     _logger = logging.getLogger(__name__)
  37
  38     def connect(self):
  39         """
  40         Do nothing.
  41         """
  42         return self
  43
  44     def disconnect(self):
  45         """
  46         Do nothing.
  47         """
  48         pass
  49
  50     def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
  51         """
  52         Do nothing.
  53         """
  54         return None
  55
  56     def send_cont_traffic(self, traffic=None, duration=30):
  57         """
  58         Send Custom - Continuous Test traffic
  59         Reuse RFC2544 throughput test specifications along with
  60         'custom' configuration
  61         """
  62         verbose = False
  63         custom = "cont"
  64         framesize = settings.getValue("TRAFFICGEN_STC_FRAME_SIZE")
  65         if traffic and 'l2' in traffic:
  66             if 'framesize' in traffic['l2']:
  67                 framesize = traffic['l2']['framesize']
  68         args = [settings.getValue("TRAFFICGEN_STC_PYTHON2_PATH"),
  69                 os.path.join(
  70                     settings.getValue("TRAFFICGEN_STC_TESTCENTER_PATH"),
  71                     settings.getValue(
  72                         "TRAFFICGEN_STC_RFC2544_TPUT_TEST_FILE_NAME")),
  73                 "--lab_server_addr",
  74                 settings.getValue("TRAFFICGEN_STC_LAB_SERVER_ADDR"),
  75                 "--license_server_addr",
  76                 settings.getValue("TRAFFICGEN_STC_LICENSE_SERVER_ADDR"),
  77                 "--east_chassis_addr",
  78                 settings.getValue("TRAFFICGEN_STC_EAST_CHASSIS_ADDR"),
  79                 "--east_slot_num",
  80                 settings.getValue("TRAFFICGEN_STC_EAST_SLOT_NUM"),
  81                 "--east_port_num",
  82                 settings.getValue("TRAFFICGEN_STC_EAST_PORT_NUM"),
  83                 "--west_chassis_addr",
  84                 settings.getValue("TRAFFICGEN_STC_WEST_CHASSIS_ADDR"),
  85                 "--west_slot_num",
  86                 settings.getValue("TRAFFICGEN_STC_WEST_SLOT_NUM"),
  87                 "--west_port_num",
  88                 settings.getValue("TRAFFICGEN_STC_WEST_PORT_NUM"),
  89                 "--test_session_name",
  90                 settings.getValue("TRAFFICGEN_STC_TEST_SESSION_NAME"),
  91                 "--results_dir",
  92                 settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
  93                 "--csv_results_file_prefix",
  94                 settings.getValue("TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX"),
  95                 "--num_trials",
  96                 settings.getValue("TRAFFICGEN_STC_NUMBER_OF_TRIALS"),
  97                 "--trial_duration_sec",
  98                 settings.getValue("TRAFFICGEN_STC_TRIAL_DURATION_SEC"),
  99                 "--traffic_pattern",
 100                 settings.getValue("TRAFFICGEN_STC_TRAFFIC_PATTERN"),
 101                 "--traffic_custom",
 102                 str(custom),
 103                 "--search_mode",
 104                 settings.getValue("TRAFFICGEN_STC_SEARCH_MODE"),
 105                 "--learning_mode",
 106                 settings.getValue("TRAFFICGEN_STC_LEARNING_MODE"),
 107                 "--rate_lower_limit_pct",
 108                 settings.getValue("TRAFFICGEN_STC_RATE_LOWER_LIMIT_PCT"),
 109                 "--rate_upper_limit_pct",
 110                 settings.getValue("TRAFFICGEN_STC_RATE_UPPER_LIMIT_PCT"),
 111                 "--rate_initial_pct",
 112                 settings.getValue("TRAFFICGEN_STC_RATE_INITIAL_PCT"),
 113                 "--rate_step_pct",
 114                 settings.getValue("TRAFFICGEN_STC_RATE_STEP_PCT"),
 115                 "--resolution_pct",
 116                 settings.getValue("TRAFFICGEN_STC_RESOLUTION_PCT"),
 117                 "--frame_size_list",
 118                 str(framesize),
 119                 "--acceptable_frame_loss_pct",
 120                 settings.getValue("TRAFFICGEN_STC_ACCEPTABLE_FRAME_LOSS_PCT"),
 121                 "--east_intf_addr",
 122                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_ADDR"),
 123                 "--east_intf_gateway_addr",
 124                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_GATEWAY_ADDR"),
 125                 "--west_intf_addr",
 126                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_ADDR"),
 127                 "--west_intf_gateway_addr",
 128                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_GATEWAY_ADDR")]
 129
 130         if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
 131             args.append("--verbose")
 132             verbose = True
 133             self._logger.debug("Arguments used to call test: %s", args)
 134         subprocess.check_call(args)
 135
 136         filec = os.path.join(settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
 137                              settings.getValue(
 138                                  "TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX") +
 139                              ".csv")
 140
 141         if verbose:
 142             self._logger.info("file: %s", filec)
 143
 144         result = {}
 145
 146         with open(filec, "r") as csvfile:
 147             csvreader = csv.DictReader(csvfile)
 148             for row in csvreader:
 149                 self._logger.info("Row: %s", row)
 150                 tx_fps = ((float(row["TxFrameCount"])) /
 151                           (float(row["Duration(sec)"])))
 152                 rx_fps = ((float(row["RxFrameCount"])) /
 153                           (float(row["Duration(sec)"])))
 154                 tx_mbps = ((float(row["TxFrameCount"]) *
 155                             float(row["ConfiguredFrameSize"])) /
 156                            (float(row["Duration(sec)"]) * 1000000.0))
 157                 rx_mbps = ((float(row["RxFrameCount"]) *
 158                             float(row["ConfiguredFrameSize"])) /
 159                            (float(row["Duration(sec)"]) * 1000000.0))
 160                 result[ResultsConstants.TX_RATE_FPS] = tx_fps
 161                 result[ResultsConstants.THROUGHPUT_RX_FPS] = rx_fps
 162                 result[ResultsConstants.TX_RATE_MBPS] = tx_mbps
 163                 result[ResultsConstants.THROUGHPUT_RX_MBPS] = rx_mbps
 164                 result[ResultsConstants.TX_RATE_PERCENT] = float(
 165                     row["OfferedLoad(%)"])
 166                 result[ResultsConstants.THROUGHPUT_RX_PERCENT] = float(
 167                     row["Throughput(%)"])
 168                 result[ResultsConstants.MIN_LATENCY_NS] = float(
 169                     row["MinimumLatency(us)"]) * 1000
 170                 result[ResultsConstants.MAX_LATENCY_NS] = float(
 171                     row["MaximumLatency(us)"]) * 1000
 172                 result[ResultsConstants.AVG_LATENCY_NS] = float(
 173                     row["AverageLatency(us)"]) * 1000
 174                 result[ResultsConstants.FRAME_LOSS_PERCENT] = float(
 175                     row["PercentLoss"])
 176         return result
 177
 178     def send_rfc2544_throughput(self, traffic=None, trials=3, duration=20,
 179                                 lossrate=0.0):
 180         """
 181         Send traffic per RFC2544 throughput test specifications.
 182         """
 183         verbose = False
 184         framesize = settings.getValue("TRAFFICGEN_STC_FRAME_SIZE")
 185         if traffic and 'l2' in traffic:
 186             if 'framesize' in traffic['l2']:
 187                 framesize = traffic['l2']['framesize']
 188         args = [settings.getValue("TRAFFICGEN_STC_PYTHON2_PATH"),
 189                 os.path.join(
 190                     settings.getValue("TRAFFICGEN_STC_TESTCENTER_PATH"),
 191                     settings.getValue(
 192                         "TRAFFICGEN_STC_RFC2544_TPUT_TEST_FILE_NAME")),
 193                 "--lab_server_addr",
 194                 settings.getValue("TRAFFICGEN_STC_LAB_SERVER_ADDR"),
 195                 "--license_server_addr",
 196                 settings.getValue("TRAFFICGEN_STC_LICENSE_SERVER_ADDR"),
 197                 "--east_chassis_addr",
 198                 settings.getValue("TRAFFICGEN_STC_EAST_CHASSIS_ADDR"),
 199                 "--east_slot_num",
 200                 settings.getValue("TRAFFICGEN_STC_EAST_SLOT_NUM"),
 201                 "--east_port_num",
 202                 settings.getValue("TRAFFICGEN_STC_EAST_PORT_NUM"),
 203                 "--west_chassis_addr",
 204                 settings.getValue("TRAFFICGEN_STC_WEST_CHASSIS_ADDR"),
 205                 "--west_slot_num",
 206                 settings.getValue("TRAFFICGEN_STC_WEST_SLOT_NUM"),
 207                 "--west_port_num",
 208                 settings.getValue("TRAFFICGEN_STC_WEST_PORT_NUM"),
 209                 "--test_session_name",
 210                 settings.getValue("TRAFFICGEN_STC_TEST_SESSION_NAME"),
 211                 "--results_dir",
 212                 settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
 213                 "--csv_results_file_prefix",
 214                 settings.getValue("TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX"),
 215                 "--num_trials",
 216                 settings.getValue("TRAFFICGEN_STC_NUMBER_OF_TRIALS"),
 217                 "--trial_duration_sec",
 218                 settings.getValue("TRAFFICGEN_STC_TRIAL_DURATION_SEC"),
 219                 "--traffic_pattern",
 220                 settings.getValue("TRAFFICGEN_STC_TRAFFIC_PATTERN"),
 221                 "--search_mode",
 222                 settings.getValue("TRAFFICGEN_STC_SEARCH_MODE"),
 223                 "--learning_mode",
 224                 settings.getValue("TRAFFICGEN_STC_LEARNING_MODE"),
 225                 "--rate_lower_limit_pct",
 226                 settings.getValue("TRAFFICGEN_STC_RATE_LOWER_LIMIT_PCT"),
 227                 "--rate_upper_limit_pct",
 228                 settings.getValue("TRAFFICGEN_STC_RATE_UPPER_LIMIT_PCT"),
 229                 "--rate_initial_pct",
 230                 settings.getValue("TRAFFICGEN_STC_RATE_INITIAL_PCT"),
 231                 "--rate_step_pct",
 232                 settings.getValue("TRAFFICGEN_STC_RATE_STEP_PCT"),
 233                 "--resolution_pct",
 234                 settings.getValue("TRAFFICGEN_STC_RESOLUTION_PCT"),
 235                 "--frame_size_list",
 236                 str(framesize),
 237                 "--acceptable_frame_loss_pct",
 238                 settings.getValue("TRAFFICGEN_STC_ACCEPTABLE_FRAME_LOSS_PCT"),
 239                 "--east_intf_addr",
 240                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_ADDR"),
 241                 "--east_intf_gateway_addr",
 242                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_GATEWAY_ADDR"),
 243                 "--west_intf_addr",
 244                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_ADDR"),
 245                 "--west_intf_gateway_addr",
 246                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_GATEWAY_ADDR")]
 247
 248         if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
 249             args.append("--verbose")
 250             verbose = True
 251             self._logger.debug("Arguments used to call test: %s", args)
 252         subprocess.check_call(args)
 253
 254         filec = os.path.join(settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
 255                              settings.getValue(
 256                                  "TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX") +
 257                              ".csv")
 258
 259         if verbose:
 260             self._logger.info("file: %s", filec)
 261
 262         result = {}
 263
 264         with open(filec, "r") as csvfile:
 265             csvreader = csv.DictReader(csvfile)
 266             for row in csvreader:
 267                 self._logger.info("Row: %s", row)
 268                 tx_fps = ((float(row["TxFrameCount"])) /
 269                           (float(row["Duration(sec)"])))
 270                 rx_fps = ((float(row["RxFrameCount"])) /
 271                           (float(row["Duration(sec)"])))
 272                 tx_mbps = ((float(row["TxFrameCount"]) *
 273                             float(row["ConfiguredFrameSize"])) /
 274                            (float(row["Duration(sec)"]) * 1000000.0))
 275                 rx_mbps = ((float(row["RxFrameCount"]) *
 276                             float(row["ConfiguredFrameSize"])) /
 277                            (float(row["Duration(sec)"]) * 1000000.0))
 278                 result[ResultsConstants.TX_RATE_FPS] = tx_fps
 279                 result[ResultsConstants.THROUGHPUT_RX_FPS] = rx_fps
 280                 result[ResultsConstants.TX_RATE_MBPS] = tx_mbps
 281                 result[ResultsConstants.THROUGHPUT_RX_MBPS] = rx_mbps
 282                 result[ResultsConstants.TX_RATE_PERCENT] = float(
 283                     row["OfferedLoad(%)"])
 284                 result[ResultsConstants.THROUGHPUT_RX_PERCENT] = float(
 285                     row["Throughput(%)"])
 286                 result[ResultsConstants.MIN_LATENCY_NS] = float(
 287                     row["MinimumLatency(us)"]) * 1000
 288                 result[ResultsConstants.MAX_LATENCY_NS] = float(
 289                     row["MaximumLatency(us)"]) * 1000
 290                 result[ResultsConstants.AVG_LATENCY_NS] = float(
 291                     row["AverageLatency(us)"]) * 1000
 292                 result[ResultsConstants.FRAME_LOSS_PERCENT] = float(
 293                     row["PercentLoss"])
 294         return result
 295
 296     def send_rfc2544_back2back(self, traffic=None, trials=1, duration=20,
 297                                lossrate=0.0):
 298         """
 299         Send traffic per RFC2544 BacktoBack test specifications.
 300         """
 301         verbose = False
 302         framesize = settings.getValue("TRAFFICGEN_STC_FRAME_SIZE")
 303         if traffic and 'l2' in traffic:
 304             if 'framesize' in traffic['l2']:
 305                 framesize = traffic['l2']['framesize']
 306         args = [settings.getValue("TRAFFICGEN_STC_PYTHON2_PATH"),
 307                 os.path.join(
 308                     settings.getValue("TRAFFICGEN_STC_TESTCENTER_PATH"),
 309                     settings.getValue(
 310                         "TRAFFICGEN_STC_RFC2544_B2B_TEST_FILE_NAME")),
 311                 "--metric",
 312                 settings.getValue("TRAFFICGEN_STC_RFC2544_METRIC"),
 313                 "--lab_server_addr",
 314                 settings.getValue("TRAFFICGEN_STC_LAB_SERVER_ADDR"),
 315                 "--license_server_addr",
 316                 settings.getValue("TRAFFICGEN_STC_LICENSE_SERVER_ADDR"),
 317                 "--east_chassis_addr",
 318                 settings.getValue("TRAFFICGEN_STC_EAST_CHASSIS_ADDR"),
 319                 "--east_slot_num",
 320                 settings.getValue("TRAFFICGEN_STC_EAST_SLOT_NUM"),
 321                 "--east_port_num",
 322                 settings.getValue("TRAFFICGEN_STC_EAST_PORT_NUM"),
 323                 "--west_chassis_addr",
 324                 settings.getValue("TRAFFICGEN_STC_WEST_CHASSIS_ADDR"),
 325                 "--west_slot_num",
 326                 settings.getValue("TRAFFICGEN_STC_WEST_SLOT_NUM"),
 327                 "--west_port_num",
 328                 settings.getValue("TRAFFICGEN_STC_WEST_PORT_NUM"),
 329                 "--test_session_name",
 330                 settings.getValue("TRAFFICGEN_STC_TEST_SESSION_NAME"),
 331                 "--results_dir",
 332                 settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
 333                 "--csv_results_file_prefix",
 334                 settings.getValue("TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX"),
 335                 "--num_trials",
 336                 settings.getValue("TRAFFICGEN_STC_NUMBER_OF_TRIALS"),
 337                 "--trial_duration_sec",
 338                 settings.getValue("TRAFFICGEN_STC_TRIAL_DURATION_SEC"),
 339                 "--traffic_pattern",
 340                 settings.getValue("TRAFFICGEN_STC_TRAFFIC_PATTERN"),
 341                 "--search_mode",
 342                 settings.getValue("TRAFFICGEN_STC_SEARCH_MODE"),
 343                 "--learning_mode",
 344                 settings.getValue("TRAFFICGEN_STC_LEARNING_MODE"),
 345                 "--latency_type",
 346                 settings.getValue("TRAFFICGEN_STC_LATENCY_TYPE"),
 347                 "--rate_lower_limit_pct",
 348                 settings.getValue("TRAFFICGEN_STC_RATE_LOWER_LIMIT_PCT"),
 349                 "--rate_upper_limit_pct",
 350                 settings.getValue("TRAFFICGEN_STC_RATE_UPPER_LIMIT_PCT"),
 351                 "--rate_initial_pct",
 352                 settings.getValue("TRAFFICGEN_STC_RATE_INITIAL_PCT"),
 353                 "--rate_step_pct",
 354                 settings.getValue("TRAFFICGEN_STC_RATE_STEP_PCT"),
 355                 "--resolution_pct",
 356                 settings.getValue("TRAFFICGEN_STC_RESOLUTION_PCT"),
 357                 "--frame_size_list",
 358                 str(framesize),
 359                 "--acceptable_frame_loss_pct",
 360                 settings.getValue("TRAFFICGEN_STC_ACCEPTABLE_FRAME_LOSS_PCT"),
 361                 "--east_intf_addr",
 362                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_ADDR"),
 363                 "--east_intf_gateway_addr",
 364                 settings.getValue("TRAFFICGEN_STC_EAST_INTF_GATEWAY_ADDR"),
 365                 "--west_intf_addr",
 366                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_ADDR"),
 367                 "--west_intf_gateway_addr",
 368                 settings.getValue("TRAFFICGEN_STC_WEST_INTF_GATEWAY_ADDR")]
 369
 370         if settings.getValue("TRAFFICGEN_STC_VERBOSE") is "True":
 371             args.append("--verbose")
 372             verbose = True
 373             self._logger.info("Arguments used to call test: %s", args)
 374         subprocess.check_call(args)
 375
 376         filecs = os.path.join(settings.getValue("TRAFFICGEN_STC_RESULTS_DIR"),
 377                               settings.getValue(
 378                                   "TRAFFICGEN_STC_CSV_RESULTS_FILE_PREFIX") +
 379                               ".csv")
 380         if verbose:
 381             self._logger.debug("file: %s", filecs)
 382
 383         result = {}
 384
 385         with open(filecs, "r") as csvfile:
 386             csvreader = csv.DictReader(csvfile)
 387             for row in csvreader:
 388                 self._logger.info("Row: %s", row)
 389                 tx_fps = ((float(row["TxFrameCount"])) /
 390                           (float(row["Duration(sec)"])))
 391                 rx_fps = ((float(row["RxFrameCount"])) /
 392                           (float(row["Duration(sec)"])))
 393                 tx_mbps = ((float(row["TxFrameCount"]) *
 394                             float(row["ConfiguredFrameSize"])) /
 395                            (float(row["Duration(sec)"]) * 1000000.0))
 396                 rx_mbps = ((float(row["RxFrameCount"]) *
 397                             float(row["ConfiguredFrameSize"])) /
 398                            (float(row["Duration(sec)"]) * 1000000.0))
 399                 result[ResultsConstants.TX_RATE_FPS] = tx_fps
 400                 result[ResultsConstants.THROUGHPUT_RX_FPS] = rx_fps
 401                 result[ResultsConstants.TX_RATE_MBPS] = tx_mbps
 402                 result[ResultsConstants.THROUGHPUT_RX_MBPS] = rx_mbps
 403                 result[ResultsConstants.TX_RATE_PERCENT] = float(
 404                     row["OfferedLoad(%)"])
 405                 result[ResultsConstants.THROUGHPUT_RX_PERCENT] = float(
 406                     row["Throughput(%)"])
 407                 result[ResultsConstants.MIN_LATENCY_NS] = float(
 408                     row["MinimumLatency(us)"]) * 1000
 409                 result[ResultsConstants.MAX_LATENCY_NS] = float(
 410                     row["MaximumLatency(us)"]) * 1000
 411                 result[ResultsConstants.AVG_LATENCY_NS] = float(
 412                     row["AverageLatency(us)"]) * 1000
 413                 result[ResultsConstants.FRAME_LOSS_PERCENT] = float(
 414                     row["PercentLoss"])
 415         return result
 416
 417 if __name__ == '__main__':
 418     TRAFFIC = {
 419         'l3': {
 420             'proto': 'tcp',
 421             'srcip': '1.1.1.1',
 422             'dstip': '90.90.90.90',
 423         },
 424     }
 425     with TestCenter() as dev:
 426         print(dev.send_rfc2544_throughput(traffic=TRAFFIC))
 427         print(dev.send_rfc2544_backtoback(traffic=TRAFFIC))