[PATCH v2] regression-tests: add simple_macsec test

[Kamil Jerabek]

This patch adds new test to phase3. The topology is the same as in
phase1 simple_netperf test.

This tests covers performance of macsec over ethernet. Ping and netperf is run.
Covered are both macsec options encrypt on and off.

---

v2: Availability check by ipv4 ping between physical interfaces moved before
    test loop.

Signed-off-by: Kamil Jerabek <kjerabek(a)redhat.com&gt;
---
 .../regression_tests/phase3/simple_macsec.README   |  90 +++++++
 recipes/regression_tests/phase3/simple_macsec.py   | 282 +++++++++++++++++++++
 recipes/regression_tests/phase3/simple_macsec.xml  |  36 +++
 3 files changed, 408 insertions(+)
 create mode 100644 recipes/regression_tests/phase3/simple_macsec.README
 create mode 100644 recipes/regression_tests/phase3/simple_macsec.py
 create mode 100644 recipes/regression_tests/phase3/simple_macsec.xml

diff --git a/recipes/regression_tests/phase3/simple_macsec.README
b/recipes/regression_tests/phase3/simple_macsec.README
new file mode 100644
index 0000000..8c5d9b4
--- /dev/null
+++ b/recipes/regression_tests/phase3/simple_macsec.README
@@ -0,0 +1,90 @@
+Topology:
+
+                         switch
+                        +------+
+                        |      |
+                        |      |
+          +-------------+      +-------------+
+          |             |      |             |
+          |             |      |             |
+          |             +------+             |
+          |                                  |
+          |                                  |
+        +-+--+                             +-+--+
++-------|eth1|------+              +-------|eth1|------+
+|       +-+--+      |              |       +-+--+      |
+|                   |              |                   |
+|                   |              |                   |
+|                   |              |                   |
+|                   |              |                   |
+|                   |              |                   |
+|       host1       |              |       host2       |
+|                   |              |                   |
+|                   |              |                   |
+|                   |              |                   |
++-------------------+              +-------------------+
+
+Number of hosts: 2
+Host #1 description:
+  One ethernet device configured with ip address {$net}.1/24
+
+  Macsec interface configured with ip addresses:
+    192.168.100.1/24
+    fc00::1/64
+
+Host #2 description:
+  One ethernet device configured with ip address {$net}.2/24
+
+  Macsec interface configured with ip addresses:
+    192.168.100.2/24
+    fc00::2/64
+
+Test name:
+  simple_macsec.py
+Test description:
+  Ping:
+    + count: 100
+    + interval: 0.1s
+    + between physical interfaces expecting PASS
+    + between macsec interfaces expecting PASS
+  Ping6:
+    + count: 100
+    + interval: 0.1s
+    + between macsec interfaces expecting PASS
+  Netperf:
+    + duration: 60s
+    + TCP_STREAM and UDP_STREAM
+    + ipv4 and ipv6
+    + between macsec interfaces
+  Macsec
+    + tested both encryption on and off
+
+PerfRepo integration:
+    First, preparation in PerfRepo is required - you need to create Test objects
+    through the web interface that properly describe the individual Netperf
+    tests that this recipe runs. Don't forget to also add appropriate metrics.
+    For these Netperf tests it's always:
+    * throughput
+    * throughput_min
+    * throughput_max
+    * throughput_deviation
+
+    After that, to enable support for PerfRepo you need to create the file
+    vxlan_remote.mapping and define the following id mappings:
+    tcp_ipv4_id -> to store ipv4 TCP_STREAM Netperf test results, maps to TestUid of a
PerfRepo Test object
+    tcp_ipv6_id -> to store ipv6 TCP_STREAM Netperf test results, maps to TestUid of a
PerfRepo Test object
+    udp_ipv4_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a
PerfRepo Test object
+    udp_ipv6_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a
PerfRepo Test object
+
+    To enable result comparison agains baselines you need to create a Report in
+    PerfRepo that will store the baseline. Set up the Report to only contain results
+    with the same hash tag and then add a new mapping to the mapping file, with
+    this format:
+    <some_hash> = <report_id>
+
+    The hash value is automatically generated during test execution and added
+    to each result stored in PerfRepo. To get the Report id you need to open
+    that report in our browser and find if in the URL.
+
+    When running this recipe you should also define the 'product_name' alias
+    (e.g. RHEL7) in order to tag the result object in PerfRepo.
diff --git a/recipes/regression_tests/phase3/simple_macsec.py
b/recipes/regression_tests/phase3/simple_macsec.py
new file mode 100644
index 0000000..2f6dd6a
--- /dev/null
+++ b/recipes/regression_tests/phase3/simple_macsec.py
@@ -0,0 +1,282 @@
+from lnst.Controller.Task import ctl
+from lnst.Controller.PerfRepoUtils import perfrepo_baseline_to_dict
+from lnst.Controller.PerfRepoUtils import netperf_result_template
+
+from lnst.RecipeCommon.ModuleWrap import ping, ping6, netperf
+from lnst.RecipeCommon.IRQ import pin_dev_irqs
+from lnst.RecipeCommon.PerfRepo import generate_perfrepo_comment
+
+# ------
+# SETUP
+# ------
+
+mapping_file = ctl.get_alias("mapping_file")
+perf_api = ctl.connect_PerfRepo(mapping_file)
+
+product_name = ctl.get_alias("product_name")
+
+m1 = ctl.get_host("machine1")
+m2 = ctl.get_host("machine2")
+
+m1.sync_resources(modules=["IcmpPing", "Icmp6Ping",
"Netperf"])
+m2.sync_resources(modules=["IcmpPing", "Icmp6Ping",
"Netperf"])
+
+# ------
+# TESTS
+# ------
+
+ipv = ctl.get_alias("ipv")
+mtu = ctl.get_alias("mtu")
+netperf_duration = int(ctl.get_alias("netperf_duration"))
+nperf_reserve = int(ctl.get_alias("nperf_reserve"))
+nperf_confidence = ctl.get_alias("nperf_confidence")
+nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
+nperf_cpupin = ctl.get_alias("nperf_cpupin")
+nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
+nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
+nperf_debug = ctl.get_alias("nperf_debug")
+nperf_max_dev = ctl.get_alias("nperf_max_dev")
+pr_user_comment = ctl.get_alias("perfrepo_comment")
+
+pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
+
+m1_phy = m1.get_interface("eth")
+m2_phy = m2.get_interface("eth")
+
+m1_phy_name = m1_phy.get_devname()
+m2_phy_name = m2_phy.get_devname()
+
+m1_phy_addr = m1_phy.get_ip()
+m2_phy_addr = m2_phy.get_ip()
+
+m1_phy_hwaddr = m1_phy.get_hwaddr()
+m2_phy_hwaddr = m2_phy.get_hwaddr()
+
+key1 = "7a16780284000775d4f0a3c0f0e092c0"
+key2 = "3212ef5c4cc5d0e4210b17208e88779e"
+
+msec_tif_name = "macsec0"
+m1_tif_addr = "192.168.100.1"
+m2_tif_addr = "192.168.100.2"
+
+m1_tif_addr6 = "fc00::1"
+m2_tif_addr6 = "fc00::2"
+
+#macsec setup
+def macsecSetup(encryption):
+    m1.run("ip link add link %s %s type macsec encrypt %s" %
+            (m1_phy_name, msec_tif_name, encryption))
+    m1.run("ip macsec add %s rx port 1 address %s" % (msec_tif_name,
m2_phy_hwaddr))
+    m1.run("ip macsec add %s tx sa 0 pn 1 on key 00 %s" % (msec_tif_name,
key1))
+    m1.run("ip macsec add %s rx port 1 address %s sa 0 pn 1 on key 01 %s" %
+            (msec_tif_name, m2_phy_hwaddr, key2))
+
+    m2.run("ip link add link %s %s type macsec encrypt %s" %
+            (m2_phy_name, msec_tif_name, encryption))
+    m2.run("ip macsec add %s rx port 1 address %s" % (msec_tif_name,
m1_phy_hwaddr))
+    m2.run("ip macsec add %s tx sa 0 pn 1 on key 01 %s" % (msec_tif_name,
key2))
+    m2.run("ip macsec add %s rx port 1 address %s sa 0 pn 1 on key 00 %s" %
+            (msec_tif_name, m1_phy_hwaddr, key1))
+
+    m1.run("ip link set %s up" % msec_tif_name)
+    m2.run("ip link set %s up" % msec_tif_name)
+
+    m1.run("ip addr add %s/24 dev %s" % (m1_tif_addr, msec_tif_name))
+    m2.run("ip addr add %s/24 dev %s" % (m2_tif_addr, msec_tif_name))
+
+    m1.run("ip -6 addr add %s/64 dev %s" % (m1_tif_addr6, msec_tif_name))
+    m2.run("ip -6 addr add %s/64 dev %s" % (m2_tif_addr6, msec_tif_name))
+
+
+if nperf_cpupin:
+    m1.run("service irqbalance stop")
+    m2.run("service irqbalance stop")
+
+    dev_list = [(m1, m1_phy), (m2, m2_phy)]
+
+    # this will pin devices irqs to cpu #0
+    for m, d in dev_list:
+        pin_dev_irqs(m, d, 0)
+
+nperf_opts = ""
+if nperf_cpupin and nperf_num_parallel == 1:
+    nperf_opts = " -T%s,%s" % (nperf_cpupin, nperf_cpupin)
+
+ctl.wait(15)
+
+ping_opts = {"count": 100, "interval": 0.1}
+
+encryption_settings = ['on', 'off']
+
+#availability check
+ping((m1, m1_phy, 0, {"scope": 0}),
+     (m2, m2_phy, 0, {"scope": 0}),
+     options=ping_opts)
+
+ctl.wait(2)
+
+for setting in encryption_settings:
+    #macsec setup
+    macsecSetup(setting)
+    m1_tif = m1.get_device(msec_tif_name)
+    m2_tif = m2.get_device(msec_tif_name)
+
+    if ipv in [ 'ipv4', 'both' ]:
+        ping((m1, m1_tif, 0, {"scope": 0}),
+             (m2, m2_tif, 0, {"scope": 0}),
+             options=ping_opts)
+
+        ctl.wait(2)
+
+
+        # prepare PerfRepo result for tcp
+        result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                         "tcp_ipv4_result",
+                                         hash_ignore=[
+                                             r'kernel_release',
+                                             r'redhat_release'])
+        result_tcp.add_tag(product_name)
+        if nperf_num_parallel > 1:
+            result_tcp.add_tag("multithreaded")
+            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+        result_tcp.set_parameter('encryption', setting)
+
+        baseline = perf_api.get_baseline_of_result(result_tcp)
+        baseline = perfrepo_baseline_to_dict(baseline)
+
+        tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+                               (m2, m2_tif, 0, {"scope": 0}),
+                               client_opts={"duration" : netperf_duration,
+                                            "testname" :
"TCP_STREAM",
+                                            "confidence" : nperf_confidence,
+                                            "num_parallel" :
nperf_num_parallel,
+                                            "cpu_util" : nperf_cpu_util,
+                                            "runs": nperf_max_runs,
+                                            "debug": nperf_debug,
+                                            "max_deviation": nperf_max_dev,
+                                            "netperf_opts": nperf_opts},
+                               baseline = baseline,
+                               timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+        netperf_result_template(result_tcp, tcp_res_data)
+        result_tcp.set_comment(pr_comment)
+        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=[
+                                             r'kernel_release',
+                                             r'redhat_release'])
+        result_udp.add_tag(product_name)
+        if nperf_num_parallel > 1:
+            result_udp.add_tag("multithreaded")
+            result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+        result_udp.set_parameter('encryption', setting)
+
+        baseline = perf_api.get_baseline_of_result(result_udp)
+        baseline = perfrepo_baseline_to_dict(baseline)
+
+        udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+                               (m2, m2_tif, 0, {"scope": 0}),
+                               client_opts={"duration" : netperf_duration,
+                                            "testname" :
"UDP_STREAM",
+                                            "confidence" : nperf_confidence,
+                                            "num_parallel" :
nperf_num_parallel,
+                                            "cpu_util" : nperf_cpu_util,
+                                            "runs": nperf_max_runs,
+                                            "debug": nperf_debug,
+                                            "max_deviation": nperf_max_dev,
+                                            "netperf_opts": nperf_opts},
+                               baseline = baseline,
+                               timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+        netperf_result_template(result_udp, udp_res_data)
+        result_udp.set_comment(pr_comment)
+        perf_api.save_result(result_udp)
+
+
+    if ipv in [ 'ipv6', 'both' ]:
+        ping6((m1, m1_tif, 1, {"scope": 0}),
+              (m2, m2_tif, 1, {"scope": 0}),
+              options=ping_opts)
+
+        ctl.wait(2)
+
+        # prepare PerfRepo result for tcp ipv6
+        result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                         "tcp_ipv6_result",
+                                         hash_ignore=[
+                                             r'kernel_release',
+                                             r'redhat_release'])
+        result_tcp.add_tag(product_name)
+        if nperf_num_parallel > 1:
+            result_tcp.add_tag("multithreaded")
+            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+        result_tcp.set_parameter('encryption', setting)
+
+        baseline = perf_api.get_baseline_of_result(result_tcp)
+        baseline = perfrepo_baseline_to_dict(baseline)
+
+        tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
+                               (m2, m2_tif, 1, {"scope": 0}),
+                               client_opts={"duration" : netperf_duration,
+                                            "testname" :
"TCP_STREAM",
+                                            "confidence" : nperf_confidence,
+                                            "num_parallel" :
nperf_num_parallel,
+                                            "cpu_util" : nperf_cpu_util,
+                                            "runs": nperf_max_runs,
+                                            "debug": nperf_debug,
+                                            "max_deviation": nperf_max_dev,
+                                            "netperf_opts" : nperf_opts +
" -6"},
+                               baseline = baseline,
+                               timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+        netperf_result_template(result_tcp, tcp_res_data)
+        result_tcp.set_comment(pr_comment)
+        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=[
+                                             r'kernel_release',
+                                             r'redhat_release'])
+        result_udp.add_tag(product_name)
+        if nperf_num_parallel > 1:
+            result_udp.add_tag("multithreaded")
+            result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+        result_udp.set_parameter('encryption', setting)
+
+        baseline = perf_api.get_baseline_of_result(result_udp)
+        baseline = perfrepo_baseline_to_dict(baseline)
+
+        udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
+                               (m2, m2_tif, 1, {"scope": 0}),
+                               client_opts={"duration" : netperf_duration,
+                                            "testname" :
"UDP_STREAM",
+                                            "confidence" : nperf_confidence,
+                                            "num_parallel" :
nperf_num_parallel,
+                                            "cpu_util" : nperf_cpu_util,
+                                            "runs": nperf_max_runs,
+                                            "debug": nperf_debug,
+                                            "max_deviation": nperf_max_dev,
+                                            "netperf_opts" : nperf_opts +
"-6"},
+                               baseline = baseline,
+                               timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+        netperf_result_template(result_udp, udp_res_data)
+        result_udp.set_comment(pr_comment)
+        perf_api.save_result(result_udp)
+
+
+    m1.run("ip link delete %s" % msec_tif_name)
+    m2.run("ip link delete %s" % msec_tif_name)
+
+if nperf_cpupin:
+    m1.run("service irqbalance start")
+    m2.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/simple_macsec.xml
b/recipes/regression_tests/phase3/simple_macsec.xml
new file mode 100644
index 0000000..83fbccc
--- /dev/null
+++ b/recipes/regression_tests/phase3/simple_macsec.xml
@@ -0,0 +1,36 @@
+<lnstrecipe>
+    <define>
+        <alias name="ipv" value="both" />
+        <alias name="mtu" value="1500" />
+        <alias name="netperf_duration" value="60" />
+        <alias name="nperf_reserve" value="20" />
+        <alias name="nperf_confidence" value="99,5" />
+        <alias name="nperf_max_runs" value="5" />
+        <alias name="nperf_num_parallel" value="1" />
+        <alias name="nperf_debug" value="0"/>
+        <alias name="nperf_max_dev" value="20%"/>
+        <alias name="mapping_file" value="simple_macsec.mapping"
/>
+        <alias name="net" value="192.168.0" />
+    </define>
+    <network>
+        <host id="machine1">
+            <interfaces>
+                <eth id="eth" label="tnet">
+                    <addresses>
+                        <address>{$net}.1/24</address>
+                    </addresses>
+                </eth>
+            </interfaces>
+        </host>
+        <host id="machine2">
+            <interfaces>
+                <eth id="eth" label="tnet">
+                    <addresses>
+                        <address>{$net}.2/24</address>
+                    </addresses>
+                </eth>
+            </interfaces>
+        </host>
+    </network>
+    <task python="simple_macsec.py"/>
+</lnstrecipe>
-- 
2.5.5

[Ondrej Lichtner]

On Tue, Oct 04, 2016 at 01:17:32PM +0200, Kamil Jerabek wrote:
>  This patch adds new test to phase3. The topology is the same as in
>  phase1 simple_netperf test.
>  
>  This tests covers performance of macsec over ethernet. Ping and netperf is run.
>  Covered are both macsec options encrypt on and off.
>  
>  ---
>  
>  v2: Availability check by ipv4 ping between physical interfaces moved before
>      test loop.
>  
>  Signed-off-by: Kamil Jerabek <kjerabek(a)redhat.com&gt;
>  ---
>   .../regression_tests/phase3/simple_macsec.README   |  90 +++++++
>   recipes/regression_tests/phase3/simple_macsec.py   | 282 +++++++++++++++++++++
>   recipes/regression_tests/phase3/simple_macsec.xml  |  36 +++
>   3 files changed, 408 insertions(+)
>   create mode 100644 recipes/regression_tests/phase3/simple_macsec.README
>   create mode 100644 recipes/regression_tests/phase3/simple_macsec.py
>   create mode 100644 recipes/regression_tests/phase3/simple_macsec.xml
>  
>  diff --git a/recipes/regression_tests/phase3/simple_macsec.README
> b/recipes/regression_tests/phase3/simple_macsec.README
>  new file mode 100644
>  index 0000000..8c5d9b4
>  --- /dev/null
>  +++ b/recipes/regression_tests/phase3/simple_macsec.README
>  @@ -0,0 +1,90 @@
>  +Topology:
>  +
>  +                         switch
>  +                        +------+
>  +                        |      |
>  +                        |      |
>  +          +-------------+      +-------------+
>  +          |             |      |             |
>  +          |             |      |             |
>  +          |             +------+             |
>  +          |                                  |
>  +          |                                  |
>  +        +-+--+                             +-+--+
>  ++-------|eth1|------+              +-------|eth1|------+
>  +|       +-+--+      |              |       +-+--+      |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  +|       host1       |              |       host2       |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  +|                   |              |                   |
>  ++-------------------+              +-------------------+
>  +
>  +Number of hosts: 2
>  +Host #1 description:
>  +  One ethernet device configured with ip address {$net}.1/24
>  +
>  +  Macsec interface configured with ip addresses:
>  +    192.168.100.1/24
>  +    fc00::1/64
>  +
>  +Host #2 description:
>  +  One ethernet device configured with ip address {$net}.2/24
>  +
>  +  Macsec interface configured with ip addresses:
>  +    192.168.100.2/24
>  +    fc00::2/64
>  +
>  +Test name:
>  +  simple_macsec.py
>  +Test description:
>  +  Ping:
>  +    + count: 100
>  +    + interval: 0.1s
>  +    + between physical interfaces expecting PASS
>  +    + between macsec interfaces expecting PASS
>  +  Ping6:
>  +    + count: 100
>  +    + interval: 0.1s
>  +    + between macsec interfaces expecting PASS
>  +  Netperf:
>  +    + duration: 60s
>  +    + TCP_STREAM and UDP_STREAM
>  +    + ipv4 and ipv6
>  +    + between macsec interfaces
>  +  Macsec
>  +    + tested both encryption on and off
>  +
>  +PerfRepo integration:
>  +    First, preparation in PerfRepo is required - you need to create Test objects
>  +    through the web interface that properly describe the individual Netperf
>  +    tests that this recipe runs. Don't forget to also add appropriate metrics.
>  +    For these Netperf tests it's always:
>  +    * throughput
>  +    * throughput_min
>  +    * throughput_max
>  +    * throughput_deviation
>  +
>  +    After that, to enable support for PerfRepo you need to create the file
>  +    vxlan_remote.mapping and define the following id mappings:
>  +    tcp_ipv4_id -> to store ipv4 TCP_STREAM Netperf test results, maps to TestUid of
> a PerfRepo Test object
>  +    tcp_ipv6_id -> to store ipv6 TCP_STREAM Netperf test results, maps to TestUid of
> a PerfRepo Test object
>  +    udp_ipv4_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of
> a PerfRepo Test object
>  +    udp_ipv6_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of
> a PerfRepo Test object
>  +
>  +    To enable result comparison agains baselines you need to create a Report in
>  +    PerfRepo that will store the baseline. Set up the Report to only contain results
>  +    with the same hash tag and then add a new mapping to the mapping file, with
>  +    this format:
>  +    <some_hash> = <report_id>
>  +
>  +    The hash value is automatically generated during test execution and added
>  +    to each result stored in PerfRepo. To get the Report id you need to open
>  +    that report in our browser and find if in the URL.
>  +
>  +    When running this recipe you should also define the 'product_name' alias
>  +    (e.g. RHEL7) in order to tag the result object in PerfRepo.
>  diff --git a/recipes/regression_tests/phase3/simple_macsec.py
> b/recipes/regression_tests/phase3/simple_macsec.py
>  new file mode 100644
>  index 0000000..2f6dd6a
>  --- /dev/null
>  +++ b/recipes/regression_tests/phase3/simple_macsec.py
>  @@ -0,0 +1,282 @@
>  +from lnst.Controller.Task import ctl
>  +from lnst.Controller.PerfRepoUtils import perfrepo_baseline_to_dict
>  +from lnst.Controller.PerfRepoUtils import netperf_result_template
>  +
>  +from lnst.RecipeCommon.ModuleWrap import ping, ping6, netperf
>  +from lnst.RecipeCommon.IRQ import pin_dev_irqs
>  +from lnst.RecipeCommon.PerfRepo import generate_perfrepo_comment
>  +
>  +# ------
>  +# SETUP
>  +# ------
>  +
>  +mapping_file = ctl.get_alias("mapping_file")
>  +perf_api = ctl.connect_PerfRepo(mapping_file)
>  +
>  +product_name = ctl.get_alias("product_name")
>  +
>  +m1 = ctl.get_host("machine1")
>  +m2 = ctl.get_host("machine2")
>  +
>  +m1.sync_resources(modules=["IcmpPing", "Icmp6Ping",
> "Netperf"])
>  +m2.sync_resources(modules=["IcmpPing", "Icmp6Ping",
> "Netperf"])
>  +
>  +# ------
>  +# TESTS
>  +# ------
>  +
>  +ipv = ctl.get_alias("ipv")
>  +mtu = ctl.get_alias("mtu")
>  +netperf_duration = int(ctl.get_alias("netperf_duration"))
>  +nperf_reserve = int(ctl.get_alias("nperf_reserve"))
>  +nperf_confidence = ctl.get_alias("nperf_confidence")
>  +nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
>  +nperf_cpupin = ctl.get_alias("nperf_cpupin")
>  +nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
>  +nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
>  +nperf_debug = ctl.get_alias("nperf_debug")
>  +nperf_max_dev = ctl.get_alias("nperf_max_dev")
>  +pr_user_comment = ctl.get_alias("perfrepo_comment")
>  +
>  +pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
>  +
>  +m1_phy = m1.get_interface("eth")
>  +m2_phy = m2.get_interface("eth")
>  +
>  +m1_phy_name = m1_phy.get_devname()
>  +m2_phy_name = m2_phy.get_devname()
>  +
>  +m1_phy_addr = m1_phy.get_ip()
>  +m2_phy_addr = m2_phy.get_ip()
>  +
>  +m1_phy_hwaddr = m1_phy.get_hwaddr()
>  +m2_phy_hwaddr = m2_phy.get_hwaddr()
>  +
>  +key1 = "7a16780284000775d4f0a3c0f0e092c0"
>  +key2 = "3212ef5c4cc5d0e4210b17208e88779e"
>  +
>  +msec_tif_name = "macsec0"
>  +m1_tif_addr = "192.168.100.1"
>  +m2_tif_addr = "192.168.100.2"
>  +
>  +m1_tif_addr6 = "fc00::1"
>  +m2_tif_addr6 = "fc00::2"
>  +
>  +#macsec setup
>  +def macsecSetup(encryption):
>  +    m1.run("ip link add link %s %s type macsec encrypt %s" %
>  +            (m1_phy_name, msec_tif_name, encryption))
>  +    m1.run("ip macsec add %s rx port 1 address %s" % (msec_tif_name,
> m2_phy_hwaddr))
>  +    m1.run("ip macsec add %s tx sa 0 pn 1 on key 00 %s" % (msec_tif_name,
> key1))
>  +    m1.run("ip macsec add %s rx port 1 address %s sa 0 pn 1 on key 01 %s" %
>  +            (msec_tif_name, m2_phy_hwaddr, key2))
>  +
>  +    m2.run("ip link add link %s %s type macsec encrypt %s" %
>  +            (m2_phy_name, msec_tif_name, encryption))
>  +    m2.run("ip macsec add %s rx port 1 address %s" % (msec_tif_name,
> m1_phy_hwaddr))
>  +    m2.run("ip macsec add %s tx sa 0 pn 1 on key 01 %s" % (msec_tif_name,
> key2))
>  +    m2.run("ip macsec add %s rx port 1 address %s sa 0 pn 1 on key 00 %s" %
>  +            (msec_tif_name, m1_phy_hwaddr, key1))
>  +
>  +    m1.run("ip link set %s up" % msec_tif_name)
>  +    m2.run("ip link set %s up" % msec_tif_name)
>  +
>  +    m1.run("ip addr add %s/24 dev %s" % (m1_tif_addr, msec_tif_name))
>  +    m2.run("ip addr add %s/24 dev %s" % (m2_tif_addr, msec_tif_name))
>  +
>  +    m1.run("ip -6 addr add %s/64 dev %s" % (m1_tif_addr6, msec_tif_name))
>  +    m2.run("ip -6 addr add %s/64 dev %s" % (m2_tif_addr6, msec_tif_name))
>  +
>  +
>  +if nperf_cpupin:
>  +    m1.run("service irqbalance stop")
>  +    m2.run("service irqbalance stop")
>  +
>  +    dev_list = [(m1, m1_phy), (m2, m2_phy)]
>  +
>  +    # this will pin devices irqs to cpu #0
>  +    for m, d in dev_list:
>  +        pin_dev_irqs(m, d, 0)
>  +
>  +nperf_opts = ""
>  +if nperf_cpupin and nperf_num_parallel == 1:
>  +    nperf_opts = " -T%s,%s" % (nperf_cpupin, nperf_cpupin)
>  +
>  +ctl.wait(15)
>  +
>  +ping_opts = {"count": 100, "interval": 0.1}
>  +
>  +encryption_settings = ['on', 'off']
>  +
>  +#availability check
>  +ping((m1, m1_phy, 0, {"scope": 0}),
>  +     (m2, m2_phy, 0, {"scope": 0}),
>  +     options=ping_opts)
>  +
>  +ctl.wait(2)
>  +
>  +for setting in encryption_settings:
>  +    #macsec setup
>  +    macsecSetup(setting)
>  +    m1_tif = m1.get_device(msec_tif_name)
>  +    m2_tif = m2.get_device(msec_tif_name)
>  +
>  +    if ipv in [ 'ipv4', 'both' ]:
>  +        ping((m1, m1_tif, 0, {"scope": 0}),
>  +             (m2, m2_tif, 0, {"scope": 0}),
>  +             options=ping_opts)
>  +
>  +        ctl.wait(2)
>  +
>  +
>  +        # prepare PerfRepo result for tcp
>  +        result_tcp = perf_api.new_result("tcp_ipv4_id",
>  +                                         "tcp_ipv4_result",
>  +                                         hash_ignore=[
>  +                                             r'kernel_release',
>  +                                             r'redhat_release'])
>  +        result_tcp.add_tag(product_name)
>  +        if nperf_num_parallel > 1:
>  +            result_tcp.add_tag("multithreaded")
>  +            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>  +
>  +        result_tcp.set_parameter('encryption', setting)
>  +
>  +        baseline = perf_api.get_baseline_of_result(result_tcp)
>  +        baseline = perfrepo_baseline_to_dict(baseline)
>  +
>  +        tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
>  +                               (m2, m2_tif, 0, {"scope": 0}),
>  +                               client_opts={"duration" : netperf_duration,
>  +                                            "testname" :
> "TCP_STREAM",
>  +                                            "confidence" : nperf_confidence,
>  +                                            "num_parallel" :
> nperf_num_parallel,
>  +                                            "cpu_util" : nperf_cpu_util,
>  +                                            "runs": nperf_max_runs,
>  +                                            "debug": nperf_debug,
>  +                                            "max_deviation": nperf_max_dev,
>  +                                            "netperf_opts": nperf_opts},
>  +                               baseline = baseline,
>  +                               timeout = (netperf_duration +
> nperf_reserve)*nperf_max_runs)
>  +
>  +        netperf_result_template(result_tcp, tcp_res_data)
>  +        result_tcp.set_comment(pr_comment)
>  +        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=[
>  +                                             r'kernel_release',
>  +                                             r'redhat_release'])
>  +        result_udp.add_tag(product_name)
>  +        if nperf_num_parallel > 1:
>  +            result_udp.add_tag("multithreaded")
>  +            result_udp.set_parameter('num_parallel', nperf_num_parallel)
>  +
>  +        result_udp.set_parameter('encryption', setting)
>  +
>  +        baseline = perf_api.get_baseline_of_result(result_udp)
>  +        baseline = perfrepo_baseline_to_dict(baseline)
>  +
>  +        udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
>  +                               (m2, m2_tif, 0, {"scope": 0}),
>  +                               client_opts={"duration" : netperf_duration,
>  +                                            "testname" :
> "UDP_STREAM",
>  +                                            "confidence" : nperf_confidence,
>  +                                            "num_parallel" :
> nperf_num_parallel,
>  +                                            "cpu_util" : nperf_cpu_util,
>  +                                            "runs": nperf_max_runs,
>  +                                            "debug": nperf_debug,
>  +                                            "max_deviation": nperf_max_dev,
>  +                                            "netperf_opts": nperf_opts},
>  +                               baseline = baseline,
>  +                               timeout = (netperf_duration +
> nperf_reserve)*nperf_max_runs)
>  +
>  +        netperf_result_template(result_udp, udp_res_data)
>  +        result_udp.set_comment(pr_comment)
>  +        perf_api.save_result(result_udp)
>  +
>  +
>  +    if ipv in [ 'ipv6', 'both' ]:
>  +        ping6((m1, m1_tif, 1, {"scope": 0}),
>  +              (m2, m2_tif, 1, {"scope": 0}),
>  +              options=ping_opts)
>  +
>  +        ctl.wait(2)
>  +
>  +        # prepare PerfRepo result for tcp ipv6
>  +        result_tcp = perf_api.new_result("tcp_ipv6_id",
>  +                                         "tcp_ipv6_result",
>  +                                         hash_ignore=[
>  +                                             r'kernel_release',
>  +                                             r'redhat_release'])
>  +        result_tcp.add_tag(product_name)
>  +        if nperf_num_parallel > 1:
>  +            result_tcp.add_tag("multithreaded")
>  +            result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>  +
>  +        result_tcp.set_parameter('encryption', setting)
>  +
>  +        baseline = perf_api.get_baseline_of_result(result_tcp)
>  +        baseline = perfrepo_baseline_to_dict(baseline)
>  +
>  +        tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
>  +                               (m2, m2_tif, 1, {"scope": 0}),
>  +                               client_opts={"duration" : netperf_duration,
>  +                                            "testname" :
> "TCP_STREAM",
>  +                                            "confidence" : nperf_confidence,
>  +                                            "num_parallel" :
> nperf_num_parallel,
>  +                                            "cpu_util" : nperf_cpu_util,
>  +                                            "runs": nperf_max_runs,
>  +                                            "debug": nperf_debug,
>  +                                            "max_deviation": nperf_max_dev,
>  +                                            "netperf_opts" : nperf_opts +
> " -6"},
>  +                               baseline = baseline,
>  +                               timeout = (netperf_duration +
> nperf_reserve)*nperf_max_runs)
>  +
>  +        netperf_result_template(result_tcp, tcp_res_data)
>  +        result_tcp.set_comment(pr_comment)
>  +        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=[
>  +                                             r'kernel_release',
>  +                                             r'redhat_release'])
>  +        result_udp.add_tag(product_name)
>  +        if nperf_num_parallel > 1:
>  +            result_udp.add_tag("multithreaded")
>  +            result_udp.set_parameter('num_parallel', nperf_num_parallel)
>  +
>  +        result_udp.set_parameter('encryption', setting)
>  +
>  +        baseline = perf_api.get_baseline_of_result(result_udp)
>  +        baseline = perfrepo_baseline_to_dict(baseline)
>  +
>  +        udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
>  +                               (m2, m2_tif, 1, {"scope": 0}),
>  +                               client_opts={"duration" : netperf_duration,
>  +                                            "testname" :
> "UDP_STREAM",
>  +                                            "confidence" : nperf_confidence,
>  +                                            "num_parallel" :
> nperf_num_parallel,
>  +                                            "cpu_util" : nperf_cpu_util,
>  +                                            "runs": nperf_max_runs,
>  +                                            "debug": nperf_debug,
>  +                                            "max_deviation": nperf_max_dev,
>  +                                            "netperf_opts" : nperf_opts +
> "-6"},
>  +                               baseline = baseline,
>  +                               timeout = (netperf_duration +
> nperf_reserve)*nperf_max_runs)
>  +
>  +        netperf_result_template(result_udp, udp_res_data)
>  +        result_udp.set_comment(pr_comment)
>  +        perf_api.save_result(result_udp)
>  +
>  +
>  +    m1.run("ip link delete %s" % msec_tif_name)
>  +    m2.run("ip link delete %s" % msec_tif_name)
>  +
>  +if nperf_cpupin:
>  +    m1.run("service irqbalance start")
>  +    m2.run("service irqbalance start")
>  diff --git a/recipes/regression_tests/phase3/simple_macsec.xml
> b/recipes/regression_tests/phase3/simple_macsec.xml
>  new file mode 100644
>  index 0000000..83fbccc
>  --- /dev/null
>  +++ b/recipes/regression_tests/phase3/simple_macsec.xml
>  @@ -0,0 +1,36 @@
>  +<lnstrecipe>
>  +    <define>
>  +        <alias name="ipv" value="both" />
>  +        <alias name="mtu" value="1500" />
>  +        <alias name="netperf_duration" value="60" />
>  +        <alias name="nperf_reserve" value="20" />
>  +        <alias name="nperf_confidence" value="99,5" />
>  +        <alias name="nperf_max_runs" value="5" />
>  +        <alias name="nperf_num_parallel" value="1" />
>  +        <alias name="nperf_debug" value="0"/>
>  +        <alias name="nperf_max_dev" value="20%"/>
>  +        <alias name="mapping_file" value="simple_macsec.mapping"
> />
>  +        <alias name="net" value="192.168.0" />
>  +    </define>
>  +    <network>
>  +        <host id="machine1">
>  +            <interfaces>
>  +                <eth id="eth" label="tnet">
>  +                    <addresses>
>  +                        <address>{$net}.1/24</address>
>  +                    </addresses>
>  +                </eth>
>  +            </interfaces>
>  +        </host>
>  +        <host id="machine2">
>  +            <interfaces>
>  +                <eth id="eth" label="tnet">
>  +                    <addresses>
>  +                        <address>{$net}.2/24</address>
>  +                    </addresses>
>  +                </eth>
>  +            </interfaces>
>  +        </host>
>  +    </network>
>  +    <task python="simple_macsec.py"/>
>  +</lnstrecipe>
>  -- 
>  2.5.5
>  _______________________________________________
>  LNST-developers mailing list -- lnst-developers(a)lists.fedorahosted.org
>  To unsubscribe send an email to lnst-developers-leave(a)lists.fedorahosted.org 
pushed, thanks.

Next time, put the sign-off line outside of the comment section (started
by ---)

-Ondrej