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
23 from collections import OrderedDict
30 from conf import settings
31 from core.results.results_constants import ResultsConstants
32 from tools.pkt_gen.trafficgen.trafficgenhelper import (
35 from tools.pkt_gen.trafficgen.trafficgen import ITrafficGenerator
37 class Moongen(ITrafficGenerator):
38 """Moongen Traffic generator wrapper."""
39 _traffic_defaults = TRAFFIC_DEFAULTS.copy()
40 _logger = logging.getLogger(__name__)
43 """Moongen class constructor."""
44 self._logger.info("In moongen __init__ method")
46 self._moongen_host_ip_addr = (
47 settings.getValue('TRAFFICGEN_MOONGEN_HOST_IP_ADDR'))
48 self._moongen_base_dir = (
49 settings.getValue('TRAFFICGEN_MOONGEN_BASE_DIR'))
50 self._moongen_user = settings.getValue('TRAFFICGEN_MOONGEN_USER')
51 self._moongen_ports = settings.getValue('TRAFFICGEN_MOONGEN_PORTS')
53 if settings.getValue('TRAFFICGEN_MOONGEN_LINE_SPEED_GBPS') == '10':
54 self._moongen_line_speed = math.pow(10, 10)
57 'MOONGEN: Invalid line speed in configuration ' + \
58 'file (today 10Gbps supported)')
61 def traffic_defaults(self):
62 """Default traffic values.
64 These can be expected to be constant across traffic generators,
65 so no setter is provided. Changes to the structure or contents
66 will likely break traffic generator implementations or tests
69 self._logger.info("In Moongen traffic_defaults method")
70 return self._traffic_defaults
72 def create_moongen_cfg_file(self, traffic, duration=60,
73 acceptable_loss_pct=1, one_shot=0):
74 """Create the Moongen configuration file from VSPERF's traffic profile
75 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
76 :param duration: The length of time to generate packet throughput
77 :param acceptable_loss: Maximum packet loss acceptable
78 :param one_shot: No RFC 2544 binary search,
79 just packet flow at traffic specifics
81 logging.debug("traffic['frame_rate'] = " + \
82 str(traffic['frame_rate']))
84 logging.debug("traffic['multistream'] = " + \
85 str(traffic['multistream']))
87 logging.debug("traffic['stream_type'] = " + \
88 str(traffic['stream_type']))
90 logging.debug("traffic['l2']['srcmac'] = " + \
91 str(traffic['l2']['srcmac']))
93 logging.debug("traffic['l2']['dstmac'] = " + \
94 str(traffic['l2']['dstmac']))
96 logging.debug("traffic['l3']['proto'] = " + \
97 str(traffic['l3']['proto']))
99 logging.debug("traffic['l3']['srcip'] = " + \
100 str(traffic['l3']['srcip']))
102 logging.debug("traffic['l3']['dstip'] = " + \
103 str(traffic['l3']['dstip']))
105 logging.debug("traffic['l4']['srcport'] = " + \
106 str(traffic['l4']['srcport']))
108 logging.debug("traffic['l4']['dstport'] = " + \
109 str(traffic['l4']['dstport']))
111 logging.debug("traffic['vlan']['enabled'] = " + \
112 str(traffic['vlan']['enabled']))
114 logging.debug("traffic['vlan']['id'] = " + \
115 str(traffic['vlan']['id']))
117 logging.debug("traffic['vlan']['priority'] = " + \
118 str(traffic['vlan']['priority']))
120 logging.debug("traffic['vlan']['cfi'] = " + \
121 str(traffic['vlan']['cfi']))
123 logging.debug(traffic['l2']['framesize'])
125 out_file = open("opnfv-vsperf-cfg.lua", "wt")
127 out_file.write("VSPERF {\n")
129 out_file.write("testType = \"throughput\",\n")
131 out_file.write("runBidirec = " + \
132 traffic['bidir'].lower() + ",\n")
134 out_file.write("frameSize = " + \
135 str(traffic['l2']['framesize']) + ",\n")
137 out_file.write("srcMac = \"" + \
138 str(traffic['l2']['srcmac']) + "\",\n")
140 out_file.write("dstMac = \"" + \
141 str(traffic['l2']['dstmac']) + "\",\n")
143 out_file.write("srcIp = \"" + \
144 str(traffic['l3']['srcip']) + "\",\n")
146 out_file.write("dstIp = \"" + \
147 str(traffic['l3']['dstip']) + "\",\n")
149 if traffic['vlan']['enabled']:
150 out_file.write("vlanId = " + \
151 str(traffic['vlan']['id']) + ",\n")
153 out_file.write("searchRunTime = " + \
154 str(duration) + ",\n")
156 out_file.write("validationRunTime = " + \
157 str(duration) + ",\n")
159 out_file.write("acceptableLossPct = " + \
160 str(acceptable_loss_pct) + ",\n")
162 out_file.write("ports = " +\
163 str(self._moongen_ports) + ",\n")
166 out_file.write("oneShot = true,\n")
168 # Need to convert VSPERF frame_rate (percentage of line rate)
169 # to Mpps for Moongen
171 (traffic['frame_rate'] / 100) * (self._moongen_line_speed / \
172 (8 * (traffic['l2']['framesize'] + 20)) / math.pow(10, 6)))
174 logging.debug("startRate = " + start_rate)
176 out_file.write("startRate = " + \
179 out_file.write("}" + "\n")
182 copy_moongen_cfg = "scp opnfv-vsperf-cfg.lua " + \
183 self._moongen_user + "@" + \
184 self._moongen_host_ip_addr + ":" + \
185 self._moongen_base_dir + \
186 "/. && rm opnfv-vsperf-cfg.lua"
188 find_moongen = subprocess.Popen(copy_moongen_cfg,
190 stderr=subprocess.PIPE)
192 output, error = find_moongen.communicate()
195 logging.error(output)
197 raise RuntimeError('MOONGEN: Error copying configuration file')
200 """Connect to Moongen traffic generator
202 Verify that Moongen is on the system indicated by
203 the configuration file
205 self._logger.info("MOONGEN: In Moongen connect method...")
207 if self._moongen_host_ip_addr:
208 cmd_ping = "ping -c1 " + self._moongen_host_ip_addr
210 raise RuntimeError('MOONGEN: Moongen host not defined')
212 ping = subprocess.Popen(cmd_ping, shell=True, stderr=subprocess.PIPE)
213 output, error = ping.communicate()
216 self._logger.error(error)
217 self._logger.error(output)
218 raise RuntimeError('MOONGEN: Cannot ping Moongen host at ' + \
219 self._moongen_host_ip_addr)
221 connect_moongen = "ssh " + self._moongen_user + \
222 "@" + self._moongen_host_ip_addr
224 cmd_find_moongen = connect_moongen + " ls " + \
225 self._moongen_base_dir + "/examples/opnfv-vsperf.lua"
227 find_moongen = subprocess.Popen(cmd_find_moongen,
229 stderr=subprocess.PIPE)
231 output, error = find_moongen.communicate()
233 if find_moongen.returncode:
234 self._logger.error(error)
235 self._logger.error(output)
237 'MOONGEN: Cannot locate Moongen program at %s within %s' \
238 % (self._moongen_host_ip_addr, self._moongen_base_dir))
240 self._logger.info("MOONGEN: Moongen host successfully found...")
242 def disconnect(self):
243 """Disconnect from the traffic generator.
245 As with :func:`connect`, this function is optional.
247 Where implemented, this function should raise an exception on
252 self._logger.info("MOONGEN: In moongen disconnect method")
254 def send_burst_traffic(self, traffic=None, numpkts=100, duration=20):
255 """Send a burst of traffic.
257 Send a ``numpkts`` packets of traffic, using ``traffic``
258 configuration, with a timeout of ``time``.
260 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
261 :param numpkts: Number of packets to send
262 :param duration: Time to wait to receive packets
264 :returns: dictionary of strings with following data:
268 - List of List of Rx Bytes,
269 - Payload Errors and Sequence Errors.
271 self._logger.info("In Moongen send_burst_traffic method")
272 return NotImplementedError('Moongen Burst traffic not implemented')
274 def send_cont_traffic(self, traffic=None, duration=20):
275 """Send a continuous flow of traffic
277 Send packets at ``frame rate``, using ``traffic`` configuration,
278 until timeout ``time`` occurs.
280 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
281 :param duration: Time to wait to receive packets (secs)
282 :returns: dictionary of strings with following data:
283 - Tx Throughput (fps),
284 - Rx Throughput (fps),
285 - Tx Throughput (mbps),
286 - Rx Throughput (mbps),
287 - Tx Throughput (% linerate),
288 - Rx Throughput (% linerate),
293 self._logger.info("In Moongen send_cont_traffic method")
296 self._params['traffic'] = self.traffic_defaults.copy()
299 self._params['traffic'] = merge_spec(self._params['traffic'],
302 Moongen.create_moongen_cfg_file(self,
305 acceptable_loss_pct=100.0,
308 collected_results = Moongen.run_moongen_and_collect_results(self,
311 results = OrderedDict()
313 results[ResultsConstants.THROUGHPUT_RX_FPS] = (
315 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS])))
317 results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
319 float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS])))
321 results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
324 collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT])))
326 results[ResultsConstants.TX_RATE_FPS] = (
328 float(collected_results[ResultsConstants.TX_RATE_FPS])))
330 results[ResultsConstants.TX_RATE_MBPS] = (
332 float(collected_results[ResultsConstants.TX_RATE_MBPS])))
334 results[ResultsConstants.TX_RATE_PERCENT] = (
336 float(collected_results[ResultsConstants.TX_RATE_PERCENT])))
338 results[ResultsConstants.MIN_LATENCY_NS] = 0
340 results[ResultsConstants.MAX_LATENCY_NS] = 0
342 results[ResultsConstants.AVG_LATENCY_NS] = 0
346 def start_cont_traffic(self, traffic=None, duration=20):
347 """ Non-blocking version of 'send_cont_traffic'.
349 Start transmission and immediately return. Do not wait for
351 :param traffic: Detailed "traffic" spec, i.e. IP address, VLAN tags
352 :param duration: Time to wait to receive packets (secs)
354 self._logger.info("In Moongen start_cont_traffic method")
355 return NotImplementedError('moongen continuous traffic not implemented')
357 def stop_cont_traffic(self):
358 # Stop continuous transmission and return results.
359 self._logger.info("In Moongen stop_cont_traffic method")
361 def run_moongen_and_collect_results(self, test_run=1):
362 """Execute Moongen and transform results into VSPERF format
363 :param test_run: The number of tests to run
365 # Start Moongen and create logfile of the run
366 connect_moongen = "ssh " + self._moongen_user + "@" + \
367 self._moongen_host_ip_addr
369 cmd_moongen = " 'cd " + self._moongen_base_dir + \
370 "; ./build/MoonGen examples/opnfv-vsperf.lua | tee moongen_log.txt'"
372 cmd_start_moongen = connect_moongen + cmd_moongen
374 start_moongen = subprocess.Popen(cmd_start_moongen,
375 shell=True, stderr=subprocess.PIPE)
377 output, error = start_moongen.communicate()
379 if start_moongen.returncode:
381 logging.debug(output)
383 'MOONGEN: Error starting Moongen program at %s within %s' \
384 % (self._moongen_host_ip_addr, self._moongen_base_dir))
386 cmd_moongen = "mkdir -p /tmp/moongen/" + str(test_run)
388 moongen_create_log_dir = subprocess.Popen(cmd_moongen,
390 stderr=subprocess.PIPE)
392 output, error = moongen_create_log_dir.communicate()
394 if moongen_create_log_dir.returncode:
396 logging.debug(output)
398 'MOONGEN: Error obtaining Moongen log from %s within %s' \
399 % (self._moongen_host_ip_addr, self._moongen_base_dir))
401 cmd_moongen = " scp " + self._moongen_user + "@" + \
402 self._moongen_host_ip_addr + ":" + \
403 self._moongen_base_dir + "/moongen_log.txt /tmp/moongen/" + \
404 str(test_run) + "/moongen-run.log"
406 copy_moongen_log = subprocess.Popen(cmd_moongen,
408 stderr=subprocess.PIPE)
410 output, error = copy_moongen_log.communicate()
412 if copy_moongen_log.returncode:
414 logging.debug(output)
416 'MOONGEN: Error obtaining Moongen log from %s within %s' \
417 % (self._moongen_host_ip_addr, self._moongen_base_dir))
419 log_file = "/tmp/moongen/" + str(test_run) + "/moongen-run.log"
421 with open(log_file, 'r') as logfile_handle:
422 mytext = logfile_handle.read()
424 # REPORT results line
425 # match.group(1) = Tx frames
426 # match.group(2) = Rx frames
427 # match.group(3) = Frame loss (count)
428 # match.group(4) = Frame loss (percentage)
429 # match.group(5) = Tx Mpps
430 # match.group(6) = Rx Mpps
431 search_pattern = re.compile(
432 r'\[REPORT\]\s+total\:\s+'
433 r'Tx\s+frames\:\s+(\d+)\s+'
434 r'Rx\s+Frames\:\s+(\d+)\s+'
435 r'frame\s+loss\:\s+(\d+)\,'
436 r'\s+(\d+\.\d+|\d+)%\s+'
437 r'Tx\s+Mpps\:\s+(\d+.\d+|\d+)\s+'
438 r'Rx\s+Mpps\:\s+(\d+\.\d+|\d+)',
441 results_match = search_pattern.search(mytext)
443 if not results_match:
444 logging.error('There was a problem parsing ' +\
445 'Moongen REPORT section of Moongen log file')
447 moongen_results = OrderedDict()
448 moongen_results[ResultsConstants.THROUGHPUT_RX_FPS] = 0
449 moongen_results[ResultsConstants.THROUGHPUT_RX_MBPS] = 0
450 moongen_results[ResultsConstants.THROUGHPUT_RX_PERCENT] = 0
451 moongen_results[ResultsConstants.TX_RATE_FPS] = 0
452 moongen_results[ResultsConstants.TX_RATE_MBPS] = 0
453 moongen_results[ResultsConstants.TX_RATE_PERCENT] = 0
454 moongen_results[ResultsConstants.B2B_TX_COUNT] = 0
455 moongen_results[ResultsConstants.B2B_FRAMES] = 0
456 moongen_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = 0
457 moongen_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = 0
459 # find PARAMETERS line
460 # parameters_match.group(1) = Frame size
462 search_pattern = re.compile(
463 r'\[PARAMETERS\]\s+.*frameSize\:\s+(\d+)',
465 parameters_match = search_pattern.search(mytext)
468 frame_size = int(parameters_match.group(1))
470 logging.error('There was a problem parsing Moongen ' +\
471 'PARAMETERS section of Moongen log file')
474 # Each packet stream in the MoonGen report is prefaced with the
475 # words '[REPORT]Device'. Count the instances of this string to
476 # get the total aggregrate throughput. For example:
478 # - If num_traffic_streams = 1, there is a single
479 # unidirectional stream
481 # - If num_traffic_streams = 2, there is a bidirectional
483 num_traffic_streams = mytext.count('[REPORT]Device')
485 if results_match and parameters_match and num_traffic_streams:
486 # Assume for now 10G link speed
487 max_theoretical_fps = (
488 num_traffic_streams * (self._moongen_line_speed / 8) / (frame_size + 20))
490 moongen_results[ResultsConstants.THROUGHPUT_RX_FPS] = (
491 float(results_match.group(6)) * 1000000)
493 moongen_results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
494 float(results_match.group(6)) * (frame_size + 20) * 8)
496 moongen_results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
497 (100 * float(results_match.group(6)) * 1000000) / max_theoretical_fps)
499 moongen_results[ResultsConstants.TX_RATE_FPS] = (
500 float(results_match.group(5)) * 1000000)
502 moongen_results[ResultsConstants.TX_RATE_MBPS] = (
503 float(results_match.group(5)) * (frame_size + 20) * 8)
505 moongen_results[ResultsConstants.TX_RATE_PERCENT] = (
506 (100 * float(results_match.group(5)) * 1000000) / max_theoretical_fps)
508 moongen_results[ResultsConstants.B2B_TX_COUNT] = (
509 float(results_match.group(1)))
511 moongen_results[ResultsConstants.B2B_FRAMES] = (
512 float(results_match.group(2)))
514 moongen_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = (
515 float(results_match.group(3)))
517 moongen_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = (
518 float(results_match.group(4)))
520 return moongen_results
522 def send_rfc2544_throughput(self, traffic=None, duration=20,
523 lossrate=0.0, tests=1):
525 # Send traffic per RFC2544 throughput test specifications.
527 # Send packets at a variable rate, using ``traffic``
528 # configuration, until minimum rate at which no packet loss is
531 # :param traffic: Detailed "traffic" spec, see design docs for details
532 # :param tests: Number of tests to execute
533 # :param duration: Per iteration duration
534 # :param lossrate: Acceptable lossrate percentage
535 # :returns: dictionary of strings with following data:
536 # - Tx Throughput (fps),
537 # - Rx Throughput (fps),
538 # - Tx Throughput (mbps),
539 # - Rx Throughput (mbps),
540 # - Tx Throughput (% linerate),
541 # - Rx Throughput (% linerate),
542 # - Min Latency (ns),
543 # - Max Latency (ns),
546 self._logger.info("In moongen send_rfc2544_throughput method")
548 self._params['traffic'] = self.traffic_defaults.copy()
551 self._params['traffic'] = merge_spec(self._params['traffic'],
553 Moongen.create_moongen_cfg_file(self,
556 acceptable_loss_pct=lossrate)
558 # Initialize RFC 2544 throughput specific results
559 results = OrderedDict()
560 results[ResultsConstants.THROUGHPUT_RX_FPS] = 0
561 results[ResultsConstants.THROUGHPUT_RX_MBPS] = 0
562 results[ResultsConstants.THROUGHPUT_RX_PERCENT] = 0
563 results[ResultsConstants.TX_RATE_FPS] = 0
564 results[ResultsConstants.TX_RATE_MBPS] = 0
565 results[ResultsConstants.TX_RATE_PERCENT] = 0
566 results[ResultsConstants.MIN_LATENCY_NS] = 0
567 results[ResultsConstants.MAX_LATENCY_NS] = 0
568 results[ResultsConstants.AVG_LATENCY_NS] = 0
570 for test_run in range(1, tests+1):
571 collected_results = (
572 Moongen.run_moongen_and_collect_results(self, test_run=test_run))
574 results[ResultsConstants.THROUGHPUT_RX_FPS] += (
575 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]))
577 results[ResultsConstants.THROUGHPUT_RX_MBPS] += (
578 float(collected_results[ResultsConstants.THROUGHPUT_RX_MBPS]))
580 results[ResultsConstants.THROUGHPUT_RX_PERCENT] += (
581 float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]))
583 results[ResultsConstants.TX_RATE_FPS] += (
584 float(collected_results[ResultsConstants.TX_RATE_FPS]))
586 results[ResultsConstants.TX_RATE_MBPS] += (
587 float(collected_results[ResultsConstants.TX_RATE_MBPS]))
589 results[ResultsConstants.TX_RATE_PERCENT] += (
590 float(collected_results[ResultsConstants.TX_RATE_PERCENT]))
592 results[ResultsConstants.THROUGHPUT_RX_FPS] = (
593 '{:.6f}'.format(results[ResultsConstants.THROUGHPUT_RX_FPS] /
596 results[ResultsConstants.THROUGHPUT_RX_MBPS] = (
597 '{:.3f}'.format(results[ResultsConstants.THROUGHPUT_RX_MBPS] /
600 results[ResultsConstants.THROUGHPUT_RX_PERCENT] = (
601 '{:.3f}'.format(results[ResultsConstants.THROUGHPUT_RX_PERCENT] /
604 results[ResultsConstants.TX_RATE_FPS] = (
605 '{:.6f}'.format(results[ResultsConstants.TX_RATE_FPS] /
608 results[ResultsConstants.TX_RATE_MBPS] = (
609 '{:.3f}'.format(results[ResultsConstants.TX_RATE_MBPS] /
612 results[ResultsConstants.TX_RATE_PERCENT] = (
613 '{:.3f}'.format(results[ResultsConstants.TX_RATE_PERCENT] /
616 results[ResultsConstants.MIN_LATENCY_NS] = (
617 '{:.3f}'.format(results[ResultsConstants.MIN_LATENCY_NS] /
620 results[ResultsConstants.MAX_LATENCY_NS] = (
621 '{:.3f}'.format(results[ResultsConstants.MAX_LATENCY_NS] /
624 results[ResultsConstants.AVG_LATENCY_NS] = (
625 '{:.3f}'.format(results[ResultsConstants.AVG_LATENCY_NS] /
630 def start_rfc2544_throughput(self, traffic=None, tests=1, duration=20,
632 """Non-blocking version of 'send_rfc2544_throughput'.
634 Start transmission and immediately return. Do not wait for
638 "MOONGEN: In moongen start_rfc2544_throughput method")
640 def wait_rfc2544_throughput(self):
641 """Wait for and return results of RFC2544 test.
643 self._logger.info('In moongen wait_rfc2544_throughput')
645 def send_rfc2544_back2back(self, traffic=None, duration=60,
646 lossrate=0.0, tests=1):
647 """Send traffic per RFC2544 back2back test specifications.
649 Send packets at a fixed rate, using ``traffic``
650 configuration, for duration seconds.
652 :param traffic: Detailed "traffic" spec, see design docs for details
653 :param tests: Number of tests to execute
654 :param duration: Per iteration duration
655 :param lossrate: Acceptable loss percentage
657 :returns: Named tuple of Rx Throughput (fps), Rx Throughput (mbps),
658 Tx Rate (% linerate), Rx Rate (% linerate), Tx Count (frames),
659 Back to Back Count (frames), Frame Loss (frames), Frame Loss (%)
660 :rtype: :class:`Back2BackResult`
662 self._logger.info("In moongen send_rfc2544_back2back method")
664 self._params['traffic'] = self.traffic_defaults.copy()
667 self._params['traffic'] = merge_spec(self._params['traffic'],
670 Moongen.create_moongen_cfg_file(self,
673 acceptable_loss_pct=lossrate)
675 # Initialize RFC 2544 B2B specific results
676 results = OrderedDict()
677 results[ResultsConstants.B2B_RX_FPS] = 0
678 results[ResultsConstants.B2B_TX_FPS] = 0
679 results[ResultsConstants.B2B_RX_PERCENT] = 0
680 results[ResultsConstants.B2B_TX_PERCENT] = 0
681 results[ResultsConstants.B2B_TX_COUNT] = 0
682 results[ResultsConstants.B2B_FRAMES] = 0
683 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = 0
684 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = 0
685 results[ResultsConstants.SCAL_STREAM_COUNT] = 0
686 results[ResultsConstants.SCAL_STREAM_TYPE] = 0
687 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0
689 for test_run in range(1, tests+1):
690 collected_results = (
691 Moongen.run_moongen_and_collect_results(self, test_run=test_run))
693 results[ResultsConstants.B2B_RX_FPS] += (
694 float(collected_results[ResultsConstants.THROUGHPUT_RX_FPS]))
696 results[ResultsConstants.B2B_RX_PERCENT] += (
697 float(collected_results[ResultsConstants.THROUGHPUT_RX_PERCENT]))
699 results[ResultsConstants.B2B_TX_FPS] += (
700 float(collected_results[ResultsConstants.TX_RATE_FPS]))
702 results[ResultsConstants.B2B_TX_PERCENT] += (
703 float(collected_results[ResultsConstants.TX_RATE_PERCENT]))
705 results[ResultsConstants.B2B_TX_COUNT] += (
706 int(collected_results[ResultsConstants.B2B_TX_COUNT]))
708 results[ResultsConstants.B2B_FRAMES] += (
709 int(collected_results[ResultsConstants.B2B_FRAMES]))
711 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] += (
712 int(collected_results[ResultsConstants.B2B_FRAME_LOSS_FRAMES]))
714 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] += (
715 int(collected_results[ResultsConstants.B2B_FRAME_LOSS_PERCENT]))
717 # Calculate average results
718 results[ResultsConstants.B2B_RX_FPS] = (
719 results[ResultsConstants.B2B_RX_FPS] / tests)
721 results[ResultsConstants.B2B_RX_PERCENT] = (
722 results[ResultsConstants.B2B_RX_PERCENT] / tests)
724 results[ResultsConstants.B2B_TX_FPS] = (
725 results[ResultsConstants.B2B_TX_FPS] / tests)
727 results[ResultsConstants.B2B_TX_PERCENT] = (
728 results[ResultsConstants.B2B_TX_PERCENT] / tests)
730 results[ResultsConstants.B2B_TX_COUNT] = (
731 results[ResultsConstants.B2B_TX_COUNT] / tests)
733 results[ResultsConstants.B2B_FRAMES] = (
734 results[ResultsConstants.B2B_FRAMES] / tests)
736 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] = (
737 results[ResultsConstants.B2B_FRAME_LOSS_FRAMES] / tests)
739 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] = (
740 results[ResultsConstants.B2B_FRAME_LOSS_PERCENT] / tests)
742 results[ResultsConstants.SCAL_STREAM_COUNT] = 0
743 results[ResultsConstants.SCAL_STREAM_TYPE] = 0
744 results[ResultsConstants.SCAL_PRE_INSTALLED_FLOWS] = 0
748 def start_rfc2544_back2back(self, traffic=None, tests=1, duration=20,
751 # Non-blocking version of 'send_rfc2544_back2back'.
753 # Start transmission and immediately return. Do not wait for results.
755 self._logger.info("In Moongen start_rfc2544_back2back method")
756 return NotImplementedError(
757 'Moongen start back2back traffic not implemented')
759 def wait_rfc2544_back2back(self):
760 self._logger.info("In moongen wait_rfc2544_back2back method")
762 # Wait and set results of RFC2544 test.
764 return NotImplementedError(
765 'Moongen wait back2back traffic not implemented')
767 if __name__ == "__main__":