def send_rfc2544_back2back(self, traffic=None, trials=1, duration=20, lossrate=0.0): """Send traffic per RFC2544 back2back test specifications. See ITrafficGenerator for description """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._setup_json_config(trials, lossrate, '2544_b2b') args = ["mono", "./tools/pkt_gen/xena/Xena2544.exe", "-c", "./tools/pkt_gen/xena/profiles/2bUsed.x2544", "-e", "-r", "./tools/pkt_gen/xena", "-u", settings.getValue('TRAFFICGEN_XENA_USER')] self.mono_pipe = subprocess.Popen( args, stdout=sys.stdout) self.mono_pipe.communicate() root = ET.parse(r'./tools/pkt_gen/xena/xena2544-report.xml').getroot() return Xena._create_throughput_result(root)
def send_burst_traffic(self, traffic=None, numpkts=100, duration=20): """Send a burst of traffic. Send a ``numpkts`` packets of traffic, using ``traffic`` configuration, with a timeout of ``time``. Attributes: :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags :param numpkts: Number of packets to send :param duration: Time to wait to receive packets :returns: dictionary of strings with following data: - List of Tx Frames, - List of Rx Frames, - List of Tx Bytes, - List of List of Rx Bytes, - Payload Errors and Sequence Errors. """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._start_traffic_api(numpkts) return self._stop_api_traffic()
def send_cont_traffic(self, traffic=None, duration=20): """Send a continuous flow of traffic.r Send packets at ``framerate``, using ``traffic`` configuration, until timeout ``time`` occurs. :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags :param duration: Time to wait to receive packets (secs) :returns: dictionary of strings with following data: - Tx Throughput (fps), - Rx Throughput (fps), - Tx Throughput (mbps), - Rx Throughput (mbps), - Tx Throughput (% linerate), - Rx Throughput (% linerate), - Min Latency (ns), - Max Latency (ns), - Avg Latency (ns) """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._start_traffic_api(-1) return self._stop_api_traffic()
def send_rfc2544_back2back(self, traffic=None, trials=1, duration=20, lossrate=0.0): """Send traffic per RFC2544 back2back test specifications. See ITrafficGenerator for description """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._setup_json_config(trials, lossrate, '2544_b2b') args = [ "mono", "./tools/pkt_gen/xena/Xena2544.exe", "-c", "./tools/pkt_gen/xena/profiles/2bUsed.x2544", "-e", "-r", "./tools/pkt_gen/xena", "-u", settings.getValue('TRAFFICGEN_XENA_USER') ] self.mono_pipe = subprocess.Popen(args, stdout=sys.stdout) self.mono_pipe.communicate() root = ET.parse(r'./tools/pkt_gen/xena/xena2544-report.xml').getroot() return Xena._create_throughput_result(root)
def start_rfc2544_back2back(self, traffic=None, trials=1, duration=20, lossrate=0.0): """Non-blocking version of 'send_rfc2544_back2back'. See ITrafficGenerator for description """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._setup_json_config(trials, lossrate, '2544_b2b') args = [ "mono", "./tools/pkt_gen/xena/Xena2544.exe", "-c", "./tools/pkt_gen/xena/profiles/2bUsed.x2544", "-e", "-r", "./tools/pkt_gen/xena", "-u", settings.getValue('TRAFFICGEN_XENA_USER') ] self.mono_pipe = subprocess.Popen(args, stdout=sys.stdout)
def start_cont_traffic(self, traffic=None, duration=20): """Non-blocking version of 'send_cont_traffic'. Start transmission and immediately return. Do not wait for results. :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags :param duration: Time to wait to receive packets (secs) """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._start_traffic_api(-1)
def start_rfc2544_throughput(self, traffic=None, trials=3, duration=20, lossrate=0.0): """Non-blocking version of 'send_rfc2544_throughput'. See ITrafficGenerator for description """ self._duration = duration self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) self._setup_json_config(trials, lossrate, '2544_throughput') args = ["mono", "./tools/pkt_gen/xena/Xena2544.exe", "-c", "./tools/pkt_gen/xena/profiles/2bUsed.x2544", "-e", "-r", "./tools/pkt_gen/xena", "-u", settings.getValue('TRAFFICGEN_XENA_USER')] self.mono_pipe = subprocess.Popen(args, stdout=sys.stdout)
def send_rfc2544_back2back(self, traffic=None, duration=60, lossrate=0.0, trials=1): """Send traffic per RFC2544 back2back test specifications. Send packets at a fixed rate, using ``traffic`` configuration, for duration seconds. :param traffic: Detailed "traffic" spec, see design docs for details :param trials: Number of trials to execute :param duration: Per iteration duration :param lossrate: Acceptable loss percentage :returns: Named tuple of Rx Throughput (fps), Rx Throughput (mbps), Tx Rate (% linerate), Rx Rate (% linerate), Tx Count (frames), Back to Back Count (frames), Frame Loss (frames), Frame Loss (%) :rtype: :class:`Back2BackResult` moongen_host_ip_addr = settings.getValue('TRAFFICGEN_MOONGEN_HOST_IP_ADDR') moongen_base_dir = settings.getValue('TRAFFICGEN_MOONGEN_BASE_DIR') moongen_user = settings.getValue('TRAFFICGEN_MOONGEN_USER') """ self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) Moongen._create_moongen_cfg_file(traffic, duration=duration, acceptable_loss_pct=lossrate) total_throughput_rx_fps = 0 total_throughput_rx_mbps = 0 total_throughput_rx_pct = 0 total_throughput_tx_fps = 0 total_throughput_tx_mbps = 0 total_throughput_tx_pct = 0 total_aggregate_tx_frames = 0 total_aggregate_rx_frames = 0 total_frame_loss_count = 0 total_frame_loss_pct = 0 for test_run in range(1,trials+1): collected_results = Moongen._run_moongen_and_collect_results(test_run=test_run) total_throughput_rx_fps += float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]) total_throughput_rx_mbps += float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS]) total_throughput_rx_pct += float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]) total_throughput_tx_fps += float(collected_results[ResultsConstants.TX_RATE_FPS]) total_throughput_tx_mbps += float(collected_results[ResultsConstants.TX_RATE_MBPS]) total_throughput_tx_pct += float(collected_results[ResultsConstants.TX_RATE_PERCENT]) total_aggregate_tx_frames += int(collected_results[ResultsConstants.B2B_TX_COUNT]) total_aggregate_rx_frames += int(collected_results[ResultsConstants.B2B_FRAMES]) total_frame_loss_count += int(collected_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES]) total_frame_loss_pct += int(collected_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT]) avg_throughput_rx_fps = total_throughput_rx_fps / trials avg_throughput_rx_mbps = total_throughput_rx_mbps / trials avg_throughput_rx_pct = total_throughput_rx_pct / trials avg_throughput_tx_fps = total_throughput_tx_fps / trials avg_throughput_tx_mbps = total_throughput_tx_mbps / trials avg_throughput_tx_pct = total_throughput_tx_pct / trials avg_aggregate_tx_frames = total_aggregate_tx_frames / trials avg_aggregate_rx_frames = total_aggregate_rx_frames / trials avg_total_frame_loss_count = total_frame_loss_count / trials avg_total_frame_loss_pct = total_frame_loss_pct / trials results = OrderedDict() results[ResultsConstants.B2B_RX_FPS] = avg_throughput_rx_fps results[ResultsConstants.B2B_TX_FPS] = avg_throughput_tx_fps results[ResultsConstants.B2B_RX_PERCENT] = avg_throughput_rx_pct results[ResultsConstants.B2B_TX_PERCENT] = avg_throughput_tx_pct results[ResultsConstants.B2B_TX_COUNT] = avg_aggregate_tx_frames results[ResultsConstants.B2B_FRAMES] = avg_aggregate_rx_frames results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] =avg_total_frame_loss_count results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = avg_total_frame_loss_pct results[ResultsConstants.SCAL_STREAM_COUNT] = 0 results[ResultsConstants.SCAL_STREAM_TYPE] = 0 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0 return results
def send_rfc2544_throughput(self, traffic=None, duration=20, lossrate=0.0, trials=1): # # Send traffic per RFC2544 throughput test specifications. # # Send packets at a variable rate, using ``traffic`` # configuration, until minimum rate at which no packet loss is # detected is found. # # :param traffic: Detailed "traffic" spec, see design docs for details # :param trials: Number of trials to execute # :param duration: Per iteration duration # :param lossrate: Acceptable lossrate percentage # :returns: dictionary of strings with following data: # - Tx Throughput (fps), # - Rx Throughput (fps), # - Tx Throughput (mbps), # - Rx Throughput (mbps), # - Tx Throughput (% linerate), # - Rx Throughput (% linerate), # - Min Latency (ns), # - Max Latency (ns), # - Avg Latency (ns) # self._logger.info("In moongen send_rfc2544_throughput method") self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) Moongen._create_moongen_cfg_file(traffic, duration=duration, acceptable_loss_pct=lossrate) total_throughput_rx_fps = 0 total_throughput_rx_mbps = 0 total_throughput_rx_pct = 0 total_throughput_tx_fps = 0 total_throughput_tx_mbps = 0 total_throughput_tx_pct = 0 total_min_latency_ns = 0 total_max_latency_ns = 0 total_avg_latency_ns = 0 for test_run in range(1,trials+1): collected_results = Moongen._run_moongen_and_collect_results(test_run=test_run) total_throughput_rx_fps += float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]) total_throughput_rx_mbps += float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS]) total_throughput_rx_pct += float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]) total_throughput_tx_fps += float(collected_results[ResultsConstants.TX_RATE_FPS]) total_throughput_tx_mbps += float(collected_results[ResultsConstants.TX_RATE_MBPS]) total_throughput_tx_pct += float(collected_results[ResultsConstants.TX_RATE_PERCENT]) total_min_latency_ns = 0 total_max_latency_ns = 0 total_avg_latency_ns = 0 avg_throughput_rx_fps = total_throughput_rx_fps / trials avg_throughput_rx_mbps = total_throughput_rx_mbps / trials avg_throughput_rx_pct = total_throughput_rx_pct / trials avg_throughput_tx_fps = total_throughput_tx_fps / trials avg_throughput_tx_mbps = total_throughput_tx_mbps / trials avg_throughput_tx_pct = total_throughput_tx_pct / trials avg_min_latency_ns = total_min_latency_ns / trials avg_max_latency_ns = total_max_latency_ns / trials avg_avg_latency_ns = total_avg_latency_ns / trials results = OrderedDict() results[ResultsConstants.THROUGHPUT_RX_FPS] = '{:,.6f}'.format(avg_throughput_rx_fps) results[ResultsConstants.THROUGHPUT_RX_MBPS] = '{:,.3f}'.format(avg_throughput_rx_mbps) results[ResultsConstants.THROUGHPUT_RX_PERCENT] = '{:,.3f}'.format(avg_throughput_rx_pct) results[ResultsConstants.TX_RATE_FPS] = '{:,.6f}'.format(avg_throughput_tx_fps) results[ResultsConstants.TX_RATE_MBPS] = '{:,.3f}'.format(avg_throughput_tx_mbps) results[ResultsConstants.TX_RATE_PERCENT] = '{:,.3f}'.format(avg_throughput_tx_pct) results[ResultsConstants.MIN_LATENCY_NS] = '{:,.3f}'.format(avg_min_latency_ns) results[ResultsConstants.MAX_LATENCY_NS] = '{:,.3f}'.format(avg_max_latency_ns) results[ResultsConstants.AVG_LATENCY_NS] = '{:,.3f}'.format(avg_avg_latency_ns) return results
def send_rfc2544_back2back(self, traffic=None, duration=60, lossrate=0.0, trials=1): """Send traffic per RFC2544 back2back test specifications. Send packets at a fixed rate, using ``traffic`` configuration, for duration seconds. :param traffic: Detailed "traffic" spec, see design docs for details :param trials: Number of trials to execute :param duration: Per iteration duration :param lossrate: Acceptable loss percentage :returns: Named tuple of Rx Throughput (fps), Rx Throughput (mbps), Tx Rate (% linerate), Rx Rate (% linerate), Tx Count (frames), Back to Back Count (frames), Frame Loss (frames), Frame Loss (%) :rtype: :class:`Back2BackResult` """ self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) Moongen.create_moongen_cfg_file(self, traffic, duration=duration, acceptable_loss_pct=lossrate) results = OrderedDict() results[ResultsConstants.B2B_RX_FPS] = 0 results[ResultsConstants.B2B_TX_FPS] = 0 results[ResultsConstants.B2B_RX_PERCENT] = 0 results[ResultsConstants.B2B_TX_PERCENT] = 0 results[ResultsConstants.B2B_TX_COUNT] = 0 results[ResultsConstants.B2B_FRAMES] = 0 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = 0 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = 0 results[ResultsConstants.SCAL_STREAM_COUNT] = 0 results[ResultsConstants.SCAL_STREAM_TYPE] = 0 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0 for test_run in range(1, trials+1): collected_results = ( Moongen.run_moongen_and_collect_results(self, test_run=test_run)) results[ResultsConstants.B2B_RX_FPS] += ( float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS])) results[ResultsConstants.B2B_RX_PERCENT] += ( float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT])) results[ResultsConstants.B2B_TX_FPS] += ( float(collected_results[ResultsConstants.TX_RATE_FPS])) results[ResultsConstants.B2B_TX_PERCENT] += ( float(collected_results[ResultsConstants.TX_RATE_PERCENT])) results[ResultsConstants.B2B_TX_COUNT] += ( int(collected_results[ResultsConstants.B2B_TX_COUNT])) results[ResultsConstants.B2B_FRAMES] += ( int(collected_results[ResultsConstants.B2B_FRAMES])) results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] += ( int(collected_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES])) results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] += ( int(collected_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT])) # Calculate average results results[ResultsConstants.B2B_RX_FPS] = ( results[ResultsConstants.B2B_RX_FPS] / trials) results[ResultsConstants.B2B_RX_PERCENT] = ( results[ResultsConstants.B2B_RX_PERCENT] / trials) results[ResultsConstants.B2B_TX_FPS] = ( results[ResultsConstants.B2B_TX_FPS] / trials) results[ResultsConstants.B2B_TX_PERCENT] = ( results[ResultsConstants.B2B_TX_PERCENT] / trials) results[ResultsConstants.B2B_TX_COUNT] = ( results[ResultsConstants.B2B_TX_COUNT] / trials) results[ResultsConstants.B2B_FRAMES] = ( results[ResultsConstants.B2B_FRAMES] / trials) results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = ( results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] / trials) results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = ( results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] / trials) results[ResultsConstants.SCAL_STREAM_COUNT] = 0 results[ResultsConstants.SCAL_STREAM_TYPE] = 0 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0 return results
def send_cont_traffic(self, traffic=None, duration=20): """Send a continuous flow of traffic Send packets at ``frame rate``, using ``traffic`` configuration, until timeout ``time`` occurs. :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags :param duration: Time to wait to receive packets (secs) :returns: dictionary of strings with following data: - Tx Throughput (fps), - Rx Throughput (fps), - Tx Throughput (mbps), - Rx Throughput (mbps), - Tx Throughput (% linerate), - Rx Throughput (% linerate), - Min Latency (ns), - Max Latency (ns), - Avg Latency (ns) """ self._logger.info("In moongen send_cont_traffic method") self._params.clear() self._params['traffic'] = self.traffic_defaults.copy() if traffic: self._params['traffic'] = merge_spec(self._params['traffic'], traffic) Moongen.create_moongen_cfg_file(self, traffic, duration=duration, acceptable_loss_pct=100.0, one_shot=1) collected_results = Moongen.run_moongen_and_collect_results(self, test_run=1) total_throughput_rx_fps = ( float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS])) total_throughput_rx_mbps = ( float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS])) total_throughput_rx_pct = ( float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT])) total_throughput_tx_fps = ( float(collected_results[ResultsConstants.TX_RATE_FPS])) total_throughput_tx_mbps = ( float(collected_results[ResultsConstants.TX_RATE_MBPS])) total_throughput_tx_pct = ( float(collected_results[ResultsConstants.TX_RATE_PERCENT])) total_min_latency_ns = 0 total_max_latency_ns = 0 total_avg_latency_ns = 0 results = OrderedDict() results[ResultsConstants.THROUGHPUT_RX_FPS] = ( '{:,.6f}'.format(total_throughput_rx_fps)) results[ResultsConstants.THROUGHPUT_RX_MBPS] = ( '{:,.3f}'.format(total_throughput_rx_mbps)) results[ResultsConstants.THROUGHPUT_RX_PERCENT] = ( '{:,.3f}'.format(total_throughput_rx_pct)) results[ResultsConstants.TX_RATE_FPS] = ( '{:,.6f}'.format(total_throughput_tx_fps)) results[ResultsConstants.TX_RATE_MBPS] = ( '{:,.3f}'.format(total_throughput_tx_mbps)) results[ResultsConstants.TX_RATE_PERCENT] = ( '{:,.3f}'.format(total_throughput_tx_pct)) results[ResultsConstants.MIN_LATENCY_NS] = ( '{:,.3f}'.format(total_min_latency_ns)) results[ResultsConstants.MAX_LATENCY_NS] = ( '{:,.3f}'.format(total_max_latency_ns)) results[ResultsConstants.AVG_LATENCY_NS] = ( '{:,.3f}'.format(total_avg_latency_ns)) return results