From: Ondrej Lichtner <olichtne(a)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(a)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()
--
2.6.0