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 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_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 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_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
