1 # Copyright 2016 Red Hat Inc
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
16 # Bill Michalowski, Red Hat Inc.
17 # Andrew Theurer, Red Hat Inc.
19 Moongen Traffic Generator Model
24 from collections import OrderedDict
29 from conf import settings
30 from core.results.results_constants import ResultsConstants
31 from tools.pkt_gen.trafficgen.trafficgenhelper import (
34 from tools.pkt_gen.trafficgen.trafficgen import ITrafficGenerator
36 class Moongen(ITrafficGenerator):
37 """Moongen Traffic generator wrapper."""
38 _traffic_defaults = TRAFFIC_DEFAULTS.copy()
39 _logger = logging.getLogger(__name__)
42 """Moongen class constructor."""
43 self._logger.info("In moongen __init__ method")
45 self._moongen_host_ip_addr = (
46 settings.getValue('TRAFFICGEN_MOONGEN_HOST_IP_ADDR'))
47 self._moongen_base_dir = (
48 settings.getValue('TRAFFICGEN_MOONGEN_BASE_DIR'))
49 self._moongen_user = settings.getValue('TRAFFICGEN_MOONGEN_USER')
50 self._moongen_ports = settings.getValue('TRAFFICGEN_MOONGEN_PORTS')
53 def traffic_defaults(self):
54 """Default traffic values.
56 These can be expected to be constant across traffic generators,
57 so no setter is provided. Changes to the structure or contents
58 will likely break traffic generator implementations or tests
61 self._logger.info("In Moongen traffic_defaults method")
62 return self._traffic_defaults
64 def create_moongen_cfg_file(self, traffic, duration=60,
65 acceptable_loss_pct=1, one_shot=0):
66 """Create the Moongen configuration file from VSPERF's traffic profile
67 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
68 :param duration: The length of time to generate packet throughput
69 :param acceptable_loss: Maximum packet loss acceptable
70 :param one_shot: No RFC 2544 binary search,
71 just packet flow at traffic specifics
73 logging.debug("traffic['frame_rate'] = " + \
74 str(traffic['frame_rate']))
76 logging.debug("traffic['multistream'] = " + \
77 str(traffic['multistream']))
79 logging.debug("traffic['stream_type'] = " + \
80 str(traffic['stream_type']))
82 logging.debug("traffic['l2']['srcmac'] = " + \
83 str(traffic['l2']['srcmac']))
85 logging.debug("traffic['l2']['dstmac'] = " + \
86 str(traffic['l2']['dstmac']))
88 logging.debug("traffic['l3']['proto'] = " + \
89 str(traffic['l3']['proto']))
91 logging.debug("traffic['l3']['srcip'] = " + \
92 str(traffic['l3']['srcip']))
94 logging.debug("traffic['l3']['dstip'] = " + \
95 str(traffic['l3']['dstip']))
97 logging.debug("traffic['l4']['srcport'] = " + \
98 str(traffic['l4']['srcport']))
100 logging.debug("traffic['l4']['dstport'] = " + \
101 str(traffic['l4']['dstport']))
103 logging.debug("traffic['vlan']['enabled'] = " + \
104 str(traffic['vlan']['enabled']))
106 logging.debug("traffic['vlan']['id'] = " + \
107 str(traffic['vlan']['id']))
109 logging.debug("traffic['vlan']['priority'] = " + \
110 str(traffic['vlan']['priority']))
112 logging.debug("traffic['vlan']['cfi'] = " + \
113 str(traffic['vlan']['cfi']))
115 logging.debug(traffic['l2']['framesize'])
117 out_file = open("opnfv-vsperf-cfg.lua", "wt")
119 out_file.write("VSPERF {\n")
121 out_file.write("testType = \"throughput\",\n")
123 out_file.write("runBidirec = " + \
124 traffic['bidir'].lower() + ",\n")
126 out_file.write("frameSize = " + \
127 str(traffic['l2']['framesize']) + ",\n")
129 out_file.write("srcMac = \"" + \
130 str(traffic['l2']['srcmac']) + "\",\n")
132 out_file.write("dstMac = \"" + \
133 str(traffic['l2']['dstmac']) + "\",\n")
135 out_file.write("srcIp = \"" + \
136 str(traffic['l3']['srcip']) + "\",\n")
138 out_file.write("dstIp = \"" + \
139 str(traffic['l3']['dstip']) + "\",\n")
141 out_file.write("vlanId = " + \
142 str(traffic['vlan']['id']) + ",\n")
144 out_file.write("searchRunTime = " + \
145 str(duration) + ",\n")
147 out_file.write("validationRunTime = " + \
148 str(duration) + ",\n")
150 out_file.write("acceptableLossPct = " + \
151 str(acceptable_loss_pct) + ",\n")
153 out_file.write("ports = " +\
154 str(self._moongen_ports) + ",\n")
157 out_file.write("oneShot = true,\n")
159 # Assume 10G line rates at the moment. Need to convert VSPERF
160 # frame_rate (percentage of line rate) to Mpps for Moongen
162 out_file.write("startRate = " + str((traffic['frame_rate'] / 100) * 14.88) + "\n")
163 out_file.write("}" + "\n")
166 copy_moongen_cfg = "scp opnfv-vsperf-cfg.lua " + \
167 self._moongen_user + "@" + \
168 self._moongen_host_ip_addr + ":" + \
169 self._moongen_base_dir + \
170 "/. && rm opnfv-vsperf-cfg.lua"
172 find_moongen = subprocess.Popen(copy_moongen_cfg,
174 stderr=subprocess.PIPE)
176 output, error = find_moongen.communicate()
179 logging.error(output)
181 raise RuntimeError('MOONGEN: Error copying configuration file')
184 """Connect to Moongen traffic generator
186 Verify that Moongen is on the system indicated by
187 the configuration file
189 self._logger.info("MOONGEN: In Moongen connect method...")
191 if self._moongen_host_ip_addr:
192 cmd_ping = "ping -c1 " + self._moongen_host_ip_addr
194 raise RuntimeError('MOONGEN: Moongen host not defined')
196 ping = subprocess.Popen(cmd_ping, shell=True, stderr=subprocess.PIPE)
197 output, error = ping.communicate()
200 self._logger.error(error)
201 self._logger.error(output)
202 raise RuntimeError('MOONGEN: Cannot ping Moongen host at ' + \
203 self._moongen_host_ip_addr)
205 connect_moongen = "ssh " + self._moongen_user + \
206 "@" + self._moongen_host_ip_addr
208 cmd_find_moongen = connect_moongen + " ls " + \
209 self._moongen_base_dir + "/examples/opnfv-vsperf.lua"
211 find_moongen = subprocess.Popen(cmd_find_moongen,
213 stderr=subprocess.PIPE)
215 output, error = find_moongen.communicate()
217 if find_moongen.returncode:
218 self._logger.error(error)
219 self._logger.error(output)
221 'MOONGEN: Cannot locate Moongen program at %s within %s' \
222 % (self._moongen_host_ip_addr, self._moongen_base_dir))
224 self._logger.info("MOONGEN: Moongen host successfully found...")
226 def disconnect(self):
227 """Disconnect from the traffic generator.
229 As with :func:`connect`, this function is optional.
231 Where implemented, this function should raise an exception on
236 self._logger.info("MOONGEN: In moongen disconnect method")
238 def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
239 """Send a burst of traffic.
241 Send a ``numpkts`` packets of traffic, using ``traffic``
242 configuration, with a timeout of ``time``.
244 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
245 :param numpkts: Number of packets to send
246 :param duration: Time to wait to receive packets
248 :returns: dictionary of strings with following data:
252 - List of List of Rx Bytes,
253 - Payload Errors and Sequence Errors.
255 self._logger.info("In Moongen send_burst_traffic method")
256 return NotImplementedError('Moongen Burst traffic not implemented')
258 def send_cont_traffic(self, traffic=None, duration=20):
259 """Send a continuous flow of traffic
261 Send packets at ``frame rate``, using ``traffic`` configuration,
262 until timeout ``time`` occurs.
264 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
265 :param duration: Time to wait to receive packets (secs)
266 :returns: dictionary of strings with following data:
267 - Tx Throughput (fps),
268 - Rx Throughput (fps),
269 - Tx Throughput (mbps),
270 - Rx Throughput (mbps),
271 - Tx Throughput (% linerate),
272 - Rx Throughput (% linerate),
277 self._logger.info("In Moongen send_cont_traffic method")
280 self._params['traffic'] = self.traffic_defaults.copy()
283 self._params['traffic'] = merge_spec(self._params['traffic'],
286 Moongen.create_moongen_cfg_file(self,
289 acceptable_loss_pct=100.0,
292 collected_results = Moongen.run_moongen_and_collect_results(self,
295 total_throughput_rx_fps = (
296 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]))
298 total_throughput_rx_mbps = (
299 float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS]))
301 total_throughput_rx_pct = (
302 float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]))
304 total_throughput_tx_fps = (
305 float(collected_results[ResultsConstants.TX_RATE_FPS]))
307 total_throughput_tx_mbps = (
308 float(collected_results[ResultsConstants.TX_RATE_MBPS]))
310 total_throughput_tx_pct = (
311 float(collected_results[ResultsConstants.TX_RATE_PERCENT]))
313 total_min_latency_ns = 0
314 total_max_latency_ns = 0
315 total_avg_latency_ns = 0
317 results = OrderedDict()
318 results[ResultsConstants.THROUGHPUT_RX_FPS] = (
319 '{:,.6f}'.format(total_throughput_rx_fps))
321 results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
322 '{:,.3f}'.format(total_throughput_rx_mbps))
324 results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
325 '{:,.3f}'.format(total_throughput_rx_pct))
327 results[ResultsConstants.TX_RATE_FPS] = (
328 '{:,.6f}'.format(total_throughput_tx_fps))
330 results[ResultsConstants.TX_RATE_MBPS] = (
331 '{:,.3f}'.format(total_throughput_tx_mbps))
333 results[ResultsConstants.TX_RATE_PERCENT] = (
334 '{:,.3f}'.format(total_throughput_tx_pct))
336 results[ResultsConstants.MIN_LATENCY_NS] = (
337 '{:,.3f}'.format(total_min_latency_ns))
339 results[ResultsConstants.MAX_LATENCY_NS] = (
340 '{:,.3f}'.format(total_max_latency_ns))
342 results[ResultsConstants.AVG_LATENCY_NS] = (
343 '{:,.3f}'.format(total_avg_latency_ns))
347 def start_cont_traffic(self, traffic=None, duration=20):
348 """ Non-blocking version of 'send_cont_traffic'.
350 Start transmission and immediately return. Do not wait for
352 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
353 :param duration: Time to wait to receive packets (secs)
355 self._logger.info("In Moongen start_cont_traffic method")
356 return NotImplementedError('moongen continuous traffic not implemented')
358 def stop_cont_traffic(self):
359 # Stop continuous transmission and return results.
360 self._logger.info("In Moongen stop_cont_traffic method")
362 def run_moongen_and_collect_results(self, test_run=1):
363 """Execute Moongen and transform results into VSPERF format
364 :param test_run: The number of tests to run
366 # Start Moongen and create logfile of the run
367 connect_moongen = "ssh " + self._moongen_user + "@" + \
368 self._moongen_host_ip_addr
370 cmd_moongen = " 'cd " + self._moongen_base_dir + \
371 "; ./build/MoonGen examples/opnfv-vsperf.lua | tee moongen_log.txt'"
373 cmd_start_moongen = connect_moongen + cmd_moongen
375 start_moongen = subprocess.Popen(cmd_start_moongen,
376 shell=True, stderr=subprocess.PIPE)
378 output, error = start_moongen.communicate()
380 if start_moongen.returncode:
382 logging.debug(output)
384 'MOONGEN: Error starting Moongen program at %s within %s' \
385 % (self._moongen_host_ip_addr, self._moongen_base_dir))
387 cmd_moongen = "mkdir -p /tmp/moongen/" + str(test_run)
389 moongen_create_log_dir = subprocess.Popen(cmd_moongen,
391 stderr=subprocess.PIPE)
393 output, error = moongen_create_log_dir.communicate()
395 if moongen_create_log_dir.returncode:
397 logging.debug(output)
399 'MOONGEN: Error obtaining Moongen log from %s within %s' \
400 % (self._moongen_host_ip_addr, self._moongen_base_dir))
402 cmd_moongen = " scp " + self._moongen_user + "@" + \
403 self._moongen_host_ip_addr + ":" + \
404 self._moongen_base_dir + "/moongen_log.txt /tmp/moongen/" + \
405 str(test_run) + "/moongen-run.log"
407 copy_moongen_log = subprocess.Popen(cmd_moongen,
409 stderr=subprocess.PIPE)
411 output, error = copy_moongen_log.communicate()
413 if copy_moongen_log.returncode:
415 logging.debug(output)
417 'MOONGEN: Error obtaining Moongen log from %s within %s' \
418 % (self._moongen_host_ip_addr, self._moongen_base_dir))
420 log_file = "/tmp/moongen/" + str(test_run) + "/moongen-run.log"
422 with open(log_file, 'r') as logfile_handle:
423 mytext = logfile_handle.read()
425 # REPORT results line
426 # match.group(1) = Tx frames
427 # match.group(2) = Rx frames
428 # match.group(3) = Frame loss (count)
429 # match.group(4) = Frame loss (percentage)
430 # match.group(5) = Tx Mpps
431 # match.group(6) = Rx Mpps
432 search_pattern = re.compile(
433 r'\[REPORT\]\s+total\:\s+'
434 r'Tx\s+frames\:\s+(\d+)\s+'
435 r'Rx\s+Frames\:\s+(\d+)\s+'
436 r'frame\s+loss\:\s+(\d+)\,'
437 r'\s+(\d+\.\d+|\d+)%\s+'
438 r'Tx\s+Mpps\:\s+(\d+.\d+|\d+)\s+'
439 r'Rx\s+Mpps\:\s+(\d+\.\d+|\d+)',
442 results_match = search_pattern.search(mytext)
444 if not results_match:
445 logging.error('There was a problem parsing ' +\
446 'Moongen REPORT section of Moongen log file')
448 moongen_results = OrderedDict()
449 moongen_results[ResultsConstants.THROUGHPUT_RX_FPS] = 0
450 moongen_results[ResultsConstants.THROUGHPUT_RX_MBPS] = 0
451 moongen_results[ResultsConstants.THROUGHPUT_RX_PERCENT] = 0
452 moongen_results[ResultsConstants.TX_RATE_FPS] = 0
453 moongen_results[ResultsConstants.TX_RATE_MBPS] = 0
454 moongen_results[ResultsConstants.TX_RATE_PERCENT] = 0
455 moongen_results[ResultsConstants.B2B_TX_COUNT] = 0
456 moongen_results[ResultsConstants.B2B_FRAMES] = 0
457 moongen_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = 0
458 moongen_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = 0
460 # find PARAMETERS line
461 # parameters_match.group(1) = Frame size
463 search_pattern = re.compile(
464 r'\[PARAMETERS\]\s+.*frameSize\:\s+(\d+)',
466 parameters_match = search_pattern.search(mytext)
469 frame_size = int(parameters_match.group(1))
471 logging.error('There was a problem parsing Moongen ' +\
472 'PARAMETERS section of Moongen log file')
475 if results_match and parameters_match:
476 # Assume for now 10G link speed
477 max_theoretical_mfps = (
478 (10000000000 / 8) / (frame_size + 20))
480 moongen_results[ResultsConstants.THROUGHPUT_RX_FPS] = (
481 float(results_match.group(6)) * 1000000)
483 moongen_results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
484 (float(results_match.group(6)) * frame_size + 20) * 8)
486 moongen_results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
487 float(results_match.group(6)) * \
488 1000000 / max_theoretical_mfps * 100)
490 moongen_results[ResultsConstants.TX_RATE_FPS] = (
491 float(results_match.group(5)) * 1000000)
493 moongen_results[ResultsConstants.TX_RATE_MBPS] = (
494 float(results_match.group(5)) * (frame_size + 20) * 8)
496 moongen_results[ResultsConstants.TX_RATE_PERCENT] = (
497 float(results_match.group(5)) *
498 1000000 / max_theoretical_mfps * 100)
500 moongen_results[ResultsConstants.B2B_TX_COUNT] = (
501 float(results_match.group(1)))
503 moongen_results[ResultsConstants.B2B_FRAMES] = (
504 float(results_match.group(2)))
506 moongen_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = (
507 float(results_match.group(3)))
509 moongen_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = (
510 float(results_match.group(4)))
512 return moongen_results
514 def send_rfc2544_throughput(self, traffic=None, duration=20,
515 lossrate=0.0, trials=1):
517 # Send traffic per RFC2544 throughput test specifications.
519 # Send packets at a variable rate, using ``traffic``
520 # configuration, until minimum rate at which no packet loss is
523 # :param traffic: Detailed "traffic" spec, see design docs for details
524 # :param trials: Number of trials to execute
525 # :param duration: Per iteration duration
526 # :param lossrate: Acceptable lossrate percentage
527 # :returns: dictionary of strings with following data:
528 # - Tx Throughput (fps),
529 # - Rx Throughput (fps),
530 # - Tx Throughput (mbps),
531 # - Rx Throughput (mbps),
532 # - Tx Throughput (% linerate),
533 # - Rx Throughput (% linerate),
534 # - Min Latency (ns),
535 # - Max Latency (ns),
538 self._logger.info("In moongen send_rfc2544_throughput method")
540 self._params['traffic'] = self.traffic_defaults.copy()
543 self._params['traffic'] = merge_spec(self._params['traffic'],
545 Moongen.create_moongen_cfg_file(self,
548 acceptable_loss_pct=lossrate)
550 total_throughput_rx_fps = 0
551 total_throughput_rx_mbps = 0
552 total_throughput_rx_pct = 0
553 total_throughput_tx_fps = 0
554 total_throughput_tx_mbps = 0
555 total_throughput_tx_pct = 0
556 total_min_latency_ns = 0
557 total_max_latency_ns = 0
558 total_avg_latency_ns = 0
560 for test_run in range(1, trials+1):
561 collected_results = (
562 Moongen.run_moongen_and_collect_results(self, test_run=test_run))
564 total_throughput_rx_fps += (
565 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]))
567 total_throughput_rx_mbps += (
568 float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS]))
570 total_throughput_rx_pct += (
571 float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]))
573 total_throughput_tx_fps += (
574 float(collected_results[ResultsConstants.TX_RATE_FPS]))
576 total_throughput_tx_mbps += (
577 float(collected_results[ResultsConstants.TX_RATE_MBPS]))
579 total_throughput_tx_pct += (
580 float(collected_results[ResultsConstants.TX_RATE_PERCENT]))
582 # Latency not supported now, leaving as placeholder
583 total_min_latency_ns = 0
584 total_max_latency_ns = 0
585 total_avg_latency_ns = 0
587 results = OrderedDict()
588 results[ResultsConstants.THROUGHPUT_RX_FPS] = (
589 '{:,.6f}'.format(total_throughput_rx_fps / trials))
591 results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
592 '{:,.3f}'.format(total_throughput_rx_mbps / trials))
594 results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
595 '{:,.3f}'.format(total_throughput_rx_pct / trials))
597 results[ResultsConstants.TX_RATE_FPS] = (
598 '{:,.6f}'.format(total_throughput_tx_fps / trials))
600 results[ResultsConstants.TX_RATE_MBPS] = (
601 '{:,.3f}'.format(total_throughput_tx_mbps / trials))
603 results[ResultsConstants.TX_RATE_PERCENT] = (
604 '{:,.3f}'.format(total_throughput_tx_pct / trials))
606 results[ResultsConstants.MIN_LATENCY_NS] = (
607 '{:,.3f}'.format(total_min_latency_ns / trials))
609 results[ResultsConstants.MAX_LATENCY_NS] = (
610 '{:,.3f}'.format(total_max_latency_ns / trials))
612 results[ResultsConstants.AVG_LATENCY_NS] = (
613 '{:,.3f}'.format(total_avg_latency_ns / trials))
617 def start_rfc2544_throughput(self, traffic=None, trials=3, duration=20,
619 """Non-blocking version of 'send_rfc2544_throughput'.
621 Start transmission and immediately return. Do not wait for
625 "MOONGEN: In moongen start_rfc2544_throughput method")
627 def wait_rfc2544_throughput(self):
628 """Wait for and return results of RFC2544 test.
630 self._logger.info('In moongen wait_rfc2544_throughput')
632 def send_rfc2544_back2back(self, traffic=None, duration=60,
633 lossrate=0.0, trials=1):
634 """Send traffic per RFC2544 back2back test specifications.
636 Send packets at a fixed rate, using ``traffic``
637 configuration, for duration seconds.
639 :param traffic: Detailed "traffic" spec, see design docs for details
640 :param trials: Number of trials to execute
641 :param duration: Per iteration duration
642 :param lossrate: Acceptable loss percentage
644 :returns: Named tuple of Rx Throughput (fps), Rx Throughput (mbps),
645 Tx Rate (% linerate), Rx Rate (% linerate), Tx Count (frames),
646 Back to Back Count (frames), Frame Loss (frames), Frame Loss (%)
647 :rtype: :class:`Back2BackResult`
650 self._params['traffic'] = self.traffic_defaults.copy()
653 self._params['traffic'] = merge_spec(self._params['traffic'],
656 Moongen.create_moongen_cfg_file(self,
659 acceptable_loss_pct=lossrate)
661 results = OrderedDict()
662 results[ResultsConstants.B2B_RX_FPS] = 0
663 results[ResultsConstants.B2B_TX_FPS] = 0
664 results[ResultsConstants.B2B_RX_PERCENT] = 0
665 results[ResultsConstants.B2B_TX_PERCENT] = 0
666 results[ResultsConstants.B2B_TX_COUNT] = 0
667 results[ResultsConstants.B2B_FRAMES] = 0
668 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = 0
669 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = 0
670 results[ResultsConstants.SCAL_STREAM_COUNT] = 0
671 results[ResultsConstants.SCAL_STREAM_TYPE] = 0
672 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0
674 for test_run in range(1, trials+1):
675 collected_results = (
676 Moongen.run_moongen_and_collect_results(self, test_run=test_run))
678 results[ResultsConstants.B2B_RX_FPS] += (
679 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]))
681 results[ResultsConstants.B2B_RX_PERCENT] += (
682 float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]))
684 results[ResultsConstants.B2B_TX_FPS] += (
685 float(collected_results[ResultsConstants.TX_RATE_FPS]))
687 results[ResultsConstants.B2B_TX_PERCENT] += (
688 float(collected_results[ResultsConstants.TX_RATE_PERCENT]))
690 results[ResultsConstants.B2B_TX_COUNT] += (
691 int(collected_results[ResultsConstants.B2B_TX_COUNT]))
693 results[ResultsConstants.B2B_FRAMES] += (
694 int(collected_results[ResultsConstants.B2B_FRAMES]))
696 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] += (
697 int(collected_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES]))
699 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] += (
700 int(collected_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT]))
702 # Calculate average results
703 results[ResultsConstants.B2B_RX_FPS] = (
704 results[ResultsConstants.B2B_RX_FPS] / trials)
706 results[ResultsConstants.B2B_RX_PERCENT] = (
707 results[ResultsConstants.B2B_RX_PERCENT] / trials)
709 results[ResultsConstants.B2B_TX_FPS] = (
710 results[ResultsConstants.B2B_TX_FPS] / trials)
712 results[ResultsConstants.B2B_TX_PERCENT] = (
713 results[ResultsConstants.B2B_TX_PERCENT] / trials)
715 results[ResultsConstants.B2B_TX_COUNT] = (
716 results[ResultsConstants.B2B_TX_COUNT] / trials)
718 results[ResultsConstants.B2B_FRAMES] = (
719 results[ResultsConstants.B2B_FRAMES] / trials)
721 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = (
722 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] / trials)
724 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = (
725 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] / trials)
727 results[ResultsConstants.SCAL_STREAM_COUNT] = 0
728 results[ResultsConstants.SCAL_STREAM_TYPE] = 0
729 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0
733 def start_rfc2544_back2back(self, traffic=None, trials=1, duration=20,
736 # Non-blocking version of 'send_rfc2544_back2back'.
738 # Start transmission and immediately return. Do not wait for results.
740 self._logger.info("In Moongen start_rfc2544_back2back method")
741 return NotImplementedError(
742 'Moongen start back2back traffic not implemented')
744 def wait_rfc2544_back2back(self):
745 self._logger.info("In moongen wait_rfc2544_back2back method")
747 # Wait and set results of RFC2544 test.
749 return NotImplementedError(
750 'Moongen wait back2back traffic not implemented')
752 if __name__ == "__main__":