From: Ondrej Lichtner olichtne@redhat.com
This updates all regression recipes to use the new LNST-PerfRepo Task API which greatly simplifies them.
Signed-off-by: Ondrej Lichtner olichtne@redhat.com --- recipes/regression_tests/phase1/3_vlans.py | 235 ++++------- .../regression_tests/phase1/3_vlans_over_bond.py | 236 ++++------- recipes/regression_tests/phase1/bonding_test.py | 215 ++++------ .../phase1/virtual_bridge_2_vlans_over_bond.py | 213 +++------- .../phase1/virtual_bridge_vlan_in_guest.py | 216 +++------- .../phase1/virtual_bridge_vlan_in_host.py | 216 +++------- .../regression_tests/phase2/3_vlans_over_team.py | 231 ++++------- recipes/regression_tests/phase2/team_test.py | 451 +++++++-------------- ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 214 +++------- .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 214 +++------- .../phase2/virtual_ovs_bridge_vlan_in_host.py | 215 ++++------ 11 files changed, 843 insertions(+), 1813 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index b3c3966..3fdf60c 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -1,31 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - - m1 = ctl.get_host("testmachine1") m2 = ctl.get_host("testmachine2")
@@ -145,169 +131,100 @@ for vlan1 in vlans: # Ping test m1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = m2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: # Ping test m1.run(ping_mod6)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.set_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + tcp_res_data = m2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.set_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = m2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
# These tests should fail # Ping across different VLAN diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index 0fb6356..d96a44f 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -1,31 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - - m1 = ctl.get_host("testmachine1") m2 = ctl.get_host("testmachine2")
@@ -147,169 +133,101 @@ for vlan1 in vlans: # Ping test m1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = m2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: # Ping test m1.run(ping_mod6)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + tcp_res_data = m2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = m2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
# These tests should fail # Ping across different VLAN diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index 2e2e041..4d4a733 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - m1 = ctl.get_host("testmachine1") m2 = ctl.get_host("testmachine2")
@@ -133,153 +120,87 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: m1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = m2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6)
+ server_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result" + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name)
- # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- server_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) tcp_res_data = m2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = m2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py index d96eaec..5b0cb2b 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - # Host 1 + guests 1 and 2 h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1") @@ -224,168 +211,96 @@ for offload in offloads: g1.run(ping_mod_bad, expect="fail") g3.run(ping_mod_bad2, expect="fail")
+ server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + if enable_udp_perf is not None: + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # prepare PerfRepo result for udp - if enable_udp_perf is not None and udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) + result_udp.add_tag(product_name)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - tcp_res_data = g3.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - if enable_udp_perf is not None: udp_res_data = g3.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) + netperf_result_template(result_udp, udp_res_data) perf_api.save_result(result_udp)
+ server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) g4.run(ping_mod62) g1.run(ping_mod6_bad, expect="fail") g3.run(ping_mod6_bad2, expect="fail")
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + tcp_res_data = g3.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None and udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - tcp_res_data = g3.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - if enable_udp_perf is not None: udp_res_data = g3.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) + netperf_result_template(result_udp, udp_res_data) perf_api.save_result(result_udp) + + server_proc.intr() diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py index daba9f0..9b81c83 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1")
@@ -147,166 +134,93 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: g1.run(ping_mod)
+ server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + # prepare PerfRepo result for udp - if enable_udp_perf is not None and udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - if enable_udp_perf is not None: udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc.intr() - - if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) + netperf_result_template(result_udp, udp_res_data) perf_api.save_result(result_udp)
+ server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None and udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + udp_res_data = h2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
server_proc.intr() - - if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py index 10d0696..10ce9a8 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1")
@@ -147,166 +134,93 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: g1.run(ping_mod)
+ server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + ignore_hash=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + # prepare PerfRepo result for udp - if enable_udp_perf is not None and udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - if enable_udp_perf is not None: udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc.intr() - - if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) + netperf_result_template(result_udp, udp_res_data) perf_api.save_result(result_udp)
+ server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_tcp.set_tag(res_hash) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None and udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', + if enable_udp_perf: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_udp.set_tag(res_hash) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name)
- baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + udp_res_data = h2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
server_proc.intr() - - if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and result_udp is not None and\ - udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index 361f497..905674d 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - m1 = ctl.get_host("testmachine1") m2 = ctl.get_host("testmachine2")
@@ -148,168 +135,100 @@ for vlan1 in vlans: # Ping test m1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = m2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # Netperf test (both TCP and UDP) srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + tcp_res_data = m2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - srv_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ srv_proc.intr() # These tests should fail # Ping across different VLAN else: diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index e132be9..e974ec2 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -1,31 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id - +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - m1 = ctl.get_host("testmachine1") m2 = ctl.get_host("testmachine2")
@@ -134,166 +120,97 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: m1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine1") - result_udp.set_parameter('netperf_client', "testmachine2") - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server', "testmachine1") + result_udp.set_parameter('netperf_client', "testmachine2") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = m2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ server_proc.intr() if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - - # prepare PerfRepo result for udp - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine1") - result_udp.set_parameter('netperf_client', "testmachine2") - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + tcp_res_data = m2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*5) - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*5) - server_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server', "testmachine1") + result_udp.set_parameter('netperf_client', "testmachine2") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*5)
- result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ server_proc.intr()
ping_mod.update_options({"addr" : m1.get_ip("test_if", 0), @@ -327,158 +244,94 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: m2.run(ping_mod)
+ server_proc = m2.run(netperf_srv, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine2") - result_udp.set_parameter('netperf_client', "testmachine1") - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- server_proc = m2.run(netperf_srv, bg=True) - ctl.wait(2) - tcp_res_data = m1.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - udp_res_data = m1.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr() + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server', "testmachine2") + result_udp.set_parameter('netperf_client', "testmachine1") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m1.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ server_proc.intr() if ipv in [ 'ipv6', 'both' ]: m2.run(ping_mod6)
+ server_proc = m2.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine2") - result_udp.set_parameter('netperf_client', "testmachine1") - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.set_parameter('netperf_server', "testmachine2") + result_udp.set_parameter('netperf_client', "testmachine1") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m1.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = m2.run(netperf_srv6, bg=True) - ctl.wait(2) - tcp_res_data = m1.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - udp_res_data = m1.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr() + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + server_proc.intr() diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py index fa7961c..6ba9541 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - # Host 1 + guests 1 and 2 h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1") @@ -201,156 +188,89 @@ for offload in offloads: g1.run(ping_mod_bad, expect="fail") g3.run(ping_mod_bad2, expect="fail")
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = g3.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = g3.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ server_proc.intr() if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) g4.run(ping_mod62) g1.run(ping_mod6_bad, expect="fail") g3.run(ping_mod6_bad2, expect="fail")
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name)
- # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) tcp_res_data = g3.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = g3.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py index d953ab7..3a09ec0 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1")
@@ -133,155 +120,86 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: g1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = h2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc.intr() - - if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
+ server_proc.intr() if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name)
- # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) tcp_res_data = h2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = h2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc.intr() + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + server_proc.intr() diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py index 058f9ea..6e1cc74 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py @@ -1,30 +1,17 @@ import logging from lnst.Controller.Task import ctl -from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id +from lnst.Controller.PerfRepoUtils import netperf_baseline_template +from lnst.Controller.PerfRepoUtils import netperf_result_template
# ------ # SETUP # ------
mapping_file = ctl.get_alias("mapping_file") -mapping = parse_id_mapping(mapping_file) +perf_api = ctl.connect_PerfRepo(mapping_file)
product_name = ctl.get_alias("product_name")
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id") -tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id") -udp_ipv4_id = get_id(mapping, "udp_ipv4_id") -udp_ipv6_id = get_id(mapping, "udp_ipv6_id") - -if tcp_ipv4_id is not None or\ - tcp_ipv6_id is not None or\ - udp_ipv4_id is not None or\ - udp_ipv6_id is not None: - perf_api = ctl.connect_PerfRepo() - logging.info("PerfRepo support enabled for this run.") -else: - logging.info("PerfRepo support disabled for this run.") - h1 = ctl.get_host("host1") g1 = ctl.get_host("guest1")
@@ -132,153 +119,87 @@ for offload in offloads: if ipv in [ 'ipv4', 'both' ]: g1.run(ping_mod)
- # prepare PerfRepo result for tcp - result_tcp = None - result_udp = None - if tcp_ipv4_id is not None: - result_tcp = perf_api.new_result(tcp_ipv4_id, "tcp_ipv4_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - # prepare PerfRepo result for udp - if udp_ipv4_id is not None: - result_udp = perf_api.new_result(udp_ipv4_id, "udp_ipv4_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) - server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = h2.run(netperf_cli_tcp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and\ - tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
+ server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + # prepare PerfRepo result for tcp ipv6 - result_tcp = None - result_udp = None - if tcp_ipv6_id is not None: - result_tcp = perf_api.new_result(tcp_ipv6_id, "tcp_ipv6_result") - result_tcp.set_parameter(offload, state) - if product_name is not None: - result_tcp.set_tag(product_name) - res_hash = result_tcp.generate_hash(['kernel_release', - 'redhat_release']) - result_tcp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_tcp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_tcp.set_parameter(offload, state) + result_tcp.add_tag(product_name)
- # prepare PerfRepo result for udp ipv6 - if udp_ipv6_id is not None: - result_udp = perf_api.new_result(udp_ipv6_id, "udp_ipv6_result") - result_udp.set_parameter(offload, state) - if product_name is not None: - result_udp.set_tag(product_name) - res_hash = result_udp.generate_hash(['kernel_release', - 'redhat_release']) - result_udp.set_tag(res_hash) - - baseline = None - report_id = get_id(mapping, res_hash) - if report_id is not None: - baseline = perf_api.get_baseline(report_id) - - if baseline is not None: - baseline_throughput = baseline.get_value('throughput').get_result() - baseline_deviation = baseline.get_value('throughput_deviation').get_result() - netperf_cli_udp.update_options({'threshold': '%s bits/sec' % baseline_throughput, - 'threshold_deviation': '%s bits/sec' % baseline_deviation}) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) tcp_res_data = h2.run(netperf_cli_tcp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + result_udp.set_parameter(offload, state) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + udp_res_data = h2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - server_proc.intr()
- if result_tcp is not None and tcp_res_data.get_result() is not None and\ - tcp_res_data.get_result()['res_data'] is not None: - rate = tcp_res_data.get_result()['res_data']['rate'] - deviation = tcp_res_data.get_result()['res_data']['rate_deviation'] - - result_tcp.add_value('throughput', rate) - result_tcp.add_value('throughput_min', rate - deviation) - result_tcp.add_value('throughput_max', rate + deviation) - result_tcp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_tcp) - - if result_udp is not None and udp_res_data.get_result() is not None and\ - udp_res_data.get_result()['res_data'] is not None: - rate = udp_res_data.get_result()['res_data']['rate'] - deviation = udp_res_data.get_result()['res_data']['rate_deviation'] - - result_udp.add_value('throughput', rate) - result_udp.add_value('throughput_min', rate - deviation) - result_udp.add_value('throughput_max', rate + deviation) - result_udp.add_value('throughput_deviation', deviation) - perf_api.save_result(result_udp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr()