4 files changed, 159 insertions, 88 deletions

diff --git a/lib/oeqa/selftest/cases/testutils.py b/lib/oeqa/selftest/cases/testutils.py
index 2ad99ad..f8b1904 100644
--- a/lib/oeqa/selftest/cases/testutils.py
+++ b/lib/oeqa/selftest/cases/testutils.py
@@ -7,49 +7,57 @@ from time import sleep
 from oeqa.utils.commands import runCmd, bitbake, get_bb_var, get_bb_vars
 from qemucommand import QemuCommand
 
+logger = logging.getLogger("selftest")
 
-def qemu_launch(efi=False, machine=None, imagename=None):
-    logger = logging.getLogger("selftest")
-    if imagename is None:
-        imagename = 'core-image-minimal'
-    logger.info('Running bitbake to build {}'.format(imagename))
-    bitbake(imagename)
+
+def qemu_launch(efi=False, machine=None, imagename='core-image-minimal', **kwargs):
+    qemu_bake_image(imagename)
+    return qemu_boot_image(efi=efi, machine=machine, imagename=imagename, **kwargs)
+
+
+def qemu_terminate(s):
+    try:
+        s.terminate()
+        s.wait(timeout=10)
+    except KeyboardInterrupt:
+        pass
+
+
+def qemu_boot_image(imagename, **kwargs):
     # Create empty object.
     args = type('', (), {})()
     args.imagename = imagename
-    args.mac = None
+    args.mac = kwargs.get('mac', None)
     # Could use DEPLOY_DIR_IMAGE here but it's already in the machine
     # subdirectory.
     args.dir = 'tmp/deploy/images'
-    args.efi = efi
-    args.machine = machine
+    args.efi = kwargs.get('efi', False)
+    args.machine = kwargs.get('machine', None)
     qemu_use_kvm = get_bb_var("QEMU_USE_KVM")
     if qemu_use_kvm and \
-            (qemu_use_kvm == 'True' and 'x86' in machine or
+            (qemu_use_kvm == 'True' and 'x86' in args.machine or
              get_bb_var('MACHINE') in qemu_use_kvm.split()):
         args.kvm = True
     else:
         args.kvm = None  # Autodetect
-    args.no_gui = True
-    args.gdb = False
-    args.pcap = None
-    args.overlay = None
-    args.dry_run = False
-    args.secondary_network = False
+    args.no_gui = kwargs.get('no_gui', True)
+    args.gdb = kwargs.get('gdb', False)
+    args.pcap = kwargs.get('pcap', None)
+    args.overlay = kwargs.get('overlay', None)
+    args.dry_run = kwargs.get('dry_run', False)
+    args.secondary_network = kwargs.get('secondary_network', False)
 
     qemu = QemuCommand(args)
     cmdline = qemu.command_line()
     print('Booting image with run-qemu-ota...')
     s = subprocess.Popen(cmdline)
-    sleep(10)
+    sleep(kwargs.get('wait_for_boot_time', 10))
     return qemu, s
 
 
-def qemu_terminate(s):
-    try:
-        s.terminate()
-    except KeyboardInterrupt:
-        pass
+def qemu_bake_image(imagename):
+    logger.info('Running bitbake to build {}'.format(imagename))
+    bitbake(imagename)
 
 
 def qemu_send_command(port, command, timeout=60):
@@ -122,7 +130,6 @@ def verifyProvisioned(testInst, machine):
     m = p.search(stdout.decode())
     testInst.assertTrue(m, 'Device ID could not be read: ' + stderr.decode() + stdout.decode())
     testInst.assertGreater(m.lastindex, 0, 'Device ID could not be read: ' + stderr.decode() + stdout.decode())
-    logger = logging.getLogger("selftest")
     logger.info('Device successfully provisioned with ID: ' + m.group(1))
 
 # vim:set ts=4 sw=4 sts=4 expandtab:
diff --git a/lib/oeqa/selftest/cases/updater_minnowboard.py b/lib/oeqa/selftest/cases/updater_minnowboard.py
index f5df584..267445b 100644
--- a/lib/oeqa/selftest/cases/updater_minnowboard.py
+++ b/lib/oeqa/selftest/cases/updater_minnowboard.py
@@ -29,7 +29,7 @@ class MinnowTests(OESelftestTestCase):
             self.meta_minnow = None
         self.append_config('MACHINE = "intel-corei7-64"')
         self.append_config('OSTREE_BOOTLOADER = "grub"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
         self.qemu, self.s = qemu_launch(efi=True, machine='intel-corei7-64')
 
     def tearDownLocal(self):
diff --git a/lib/oeqa/selftest/cases/updater_qemux86_64.py b/lib/oeqa/selftest/cases/updater_qemux86_64.py
index 9f32bcf..e26a022 100644
--- a/lib/oeqa/selftest/cases/updater_qemux86_64.py
+++ b/lib/oeqa/selftest/cases/updater_qemux86_64.py
@@ -4,18 +4,19 @@ import logging
 import re
 import unittest
 from time import sleep
+from uuid import uuid4
 
 from oeqa.selftest.case import OESelftestTestCase
 from oeqa.utils.commands import runCmd, bitbake, get_bb_var, get_bb_vars
 from testutils import qemu_launch, qemu_send_command, qemu_terminate, \
-    akt_native_run, verifyNotProvisioned, verifyProvisioned
+    akt_native_run, verifyNotProvisioned, verifyProvisioned, qemu_bake_image, qemu_boot_image
 
 
 class GeneralTests(OESelftestTestCase):
     def test_credentials(self):
         logger = logging.getLogger("selftest")
         logger.info('Running bitbake to build core-image-minimal')
-        self.append_config('SOTA_CLIENT_PROV = "aktualizr-auto-prov"')
+        self.append_config('SOTA_CLIENT_PROV = "aktualizr-shared-prov"')
         bitbake('core-image-minimal')
         credentials = get_bb_var('SOTA_PACKED_CREDENTIALS')
         # skip the test if the variable SOTA_PACKED_CREDENTIALS is not set
@@ -45,13 +46,13 @@ class AktualizrToolsTests(OESelftestTestCase):
 
     def test_cert_provider_local_output(self):
         logger = logging.getLogger("selftest")
-        logger.info('Running bitbake to build aktualizr-ca-implicit-prov')
-        bitbake('aktualizr-ca-implicit-prov')
+        logger.info('Running bitbake to build aktualizr-device-prov')
+        bitbake('aktualizr-device-prov')
         bb_vars = get_bb_vars(['SOTA_PACKED_CREDENTIALS', 'T'], 'aktualizr-native')
         creds = bb_vars['SOTA_PACKED_CREDENTIALS']
         temp_dir = bb_vars['T']
-        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-ca-implicit-prov')
-        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota_implicit_prov_ca.toml'
+        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-device-prov')
+        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota-device-cred.toml'
 
         akt_native_run(self, 'aktualizr-cert-provider -c {creds} -r -l {temp} -g {config}'
                        .format(creds=creds, temp=temp_dir, config=config))
@@ -68,7 +69,7 @@ class AktualizrToolsTests(OESelftestTestCase):
         self.assertTrue(os.path.getsize(ca_path) > 0, "Client certificate at %s is empty." % ca_path)
 
 
-class AutoProvTests(OESelftestTestCase):
+class SharedCredProvTests(OESelftestTestCase):
 
     def setUpLocal(self):
         layer = "meta-updater-qemux86-64"
@@ -84,7 +85,7 @@ class AutoProvTests(OESelftestTestCase):
         else:
             self.meta_qemu = None
         self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
         self.qemu, self.s = qemu_launch(machine='qemux86-64')
 
     def tearDownLocal(self):
@@ -126,7 +127,7 @@ class ManualControlTests(OESelftestTestCase):
         else:
             self.meta_qemu = None
         self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
         self.append_config('SYSTEMD_AUTO_ENABLE_aktualizr = "disable"')
         self.qemu, self.s = qemu_launch(machine='qemux86-64')
 
@@ -154,7 +155,7 @@ class ManualControlTests(OESelftestTestCase):
                       'Aktualizr should have run' + stderr.decode() + stdout.decode())
 
 
-class ImplProvTests(OESelftestTestCase):
+class DeviceCredProvTests(OESelftestTestCase):
 
     def setUpLocal(self):
         layer = "meta-updater-qemux86-64"
@@ -170,9 +171,9 @@ class ImplProvTests(OESelftestTestCase):
         else:
             self.meta_qemu = None
         self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-ca-implicit-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-device-prov "')
         self.append_config('SOTA_DEPLOY_CREDENTIALS = "0"')
-        runCmd('bitbake -c cleanall aktualizr aktualizr-ca-implicit-prov')
+        runCmd('bitbake -c cleanall aktualizr aktualizr-device-prov')
         self.qemu, self.s = qemu_launch(machine='qemux86-64')
 
     def tearDownLocal(self):
@@ -200,8 +201,8 @@ class ImplProvTests(OESelftestTestCase):
         # Run aktualizr-cert-provider.
         bb_vars = get_bb_vars(['SOTA_PACKED_CREDENTIALS'], 'aktualizr-native')
         creds = bb_vars['SOTA_PACKED_CREDENTIALS']
-        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-ca-implicit-prov')
-        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota_implicit_prov_ca.toml'
+        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-device-prov')
+        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota-device-cred.toml'
 
         print('Provisining at root@localhost:%d' % self.qemu.ssh_port)
         akt_native_run(self, 'aktualizr-cert-provider -c {creds} -t root@localhost -p {port} -s -u -r -g {config}'
@@ -210,7 +211,7 @@ class ImplProvTests(OESelftestTestCase):
         verifyProvisioned(self, machine)
 
 
-class HsmTests(OESelftestTestCase):
+class DeviceCredProvHsmTests(OESelftestTestCase):
 
     def setUpLocal(self):
         layer = "meta-updater-qemux86-64"
@@ -226,11 +227,11 @@ class HsmTests(OESelftestTestCase):
         else:
             self.meta_qemu = None
         self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = "aktualizr-hsm-prov"')
+        self.append_config('SOTA_CLIENT_PROV = "aktualizr-device-prov-hsm"')
         self.append_config('SOTA_DEPLOY_CREDENTIALS = "0"')
         self.append_config('SOTA_CLIENT_FEATURES = "hsm"')
         self.append_config('IMAGE_INSTALL_append = " softhsm-testtoken"')
-        runCmd('bitbake -c cleanall aktualizr aktualizr-hsm-prov')
+        runCmd('bitbake -c cleanall aktualizr aktualizr-device-prov-hsm')
         self.qemu, self.s = qemu_launch(machine='qemux86-64')
 
     def tearDownLocal(self):
@@ -268,8 +269,8 @@ class HsmTests(OESelftestTestCase):
         # Run aktualizr-cert-provider.
         bb_vars = get_bb_vars(['SOTA_PACKED_CREDENTIALS'], 'aktualizr-native')
         creds = bb_vars['SOTA_PACKED_CREDENTIALS']
-        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-hsm-prov')
-        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota_hsm_prov.toml'
+        bb_vars_prov = get_bb_vars(['STAGING_DIR_HOST', 'libdir'], 'aktualizr-device-prov-hsm')
+        config = bb_vars_prov['STAGING_DIR_HOST'] + bb_vars_prov['libdir'] + '/sota/sota-device-cred-hsm.toml'
 
         akt_native_run(self, 'aktualizr-cert-provider -c {creds} -t root@localhost -p {port} -r -s -u -g {config}'
                        .format(creds=creds, port=self.qemu.ssh_port, config=config))
@@ -309,7 +310,91 @@ class HsmTests(OESelftestTestCase):
         verifyProvisioned(self, machine)
 
 
-class SecondaryTests(OESelftestTestCase):
+class IpSecondaryTests(OESelftestTestCase):
+
+    class Image:
+        def __init__(self, imagename, binaryname, machine='qemux86-64', bake=True, **kwargs):
+            self.machine = machine
+            self.imagename = imagename
+            self.boot_kwargs = kwargs
+            self.binaryname = binaryname
+            self.stdout = ''
+            self.stderr = ''
+            self.retcode = 0
+            if bake:
+                self.bake()
+
+        def bake(self):
+            self.configure()
+            qemu_bake_image(self.imagename)
+
+        def send_command(self, cmd):
+            stdout, stderr, retcode = qemu_send_command(self.qemu.ssh_port, cmd, timeout=60)
+            return str(stdout), str(stderr), retcode
+
+        def __enter__(self):
+            self.qemu, self.process = qemu_boot_image(machine=self.machine, imagename=self.imagename,
+                                                      wait_for_boot_time=1, **self.boot_kwargs)
+            # wait until the VM is booted and is SSHable
+            self.wait_till_sshable()
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            qemu_terminate(self.process)
+
+        def wait_till_sshable(self):
+            # qemu_send_command tries to ssh into the qemu VM and blocks until it gets there or timeout happens
+            # so it helps us to block q control flow until the VM is booted and a target binary/daemon is running there
+            self.stdout, self.stderr, self.retcode = self.send_command(self.binaryname + ' --help')
+
+        def was_successfully_booted(self):
+            return self.retcode == 0
+
+    class Secondary(Image):
+        def __init__(self, test_ctx):
+            self._test_ctx = test_ctx
+            self.sndry_serial = str(uuid4())
+            self.sndry_hw_id = 'qemux86-64-oeselftest-sndry'
+            self.id = (self.sndry_hw_id, self.sndry_serial)
+            super(IpSecondaryTests.Secondary, self).__init__('secondary-image', 'aktualizr-secondary',
+                                                             secondary_network=True)
+
+        def configure(self):
+            self._test_ctx.append_config('SECONDARY_SERIAL_ID = "{}"'.format(self.sndry_serial))
+            self._test_ctx.append_config('SECONDARY_HARDWARE_ID = "{}"'.format(self.sndry_hw_id))
+
+    class Primary(Image):
+        def __init__(self, test_ctx):
+            self._test_ctx = test_ctx
+            super(IpSecondaryTests.Primary, self).__init__('primary-image', 'aktualizr', secondary_network=True)
+
+        def configure(self):
+            self._test_ctx.append_config('MACHINE = "qemux86-64"')
+            self._test_ctx.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
+
+        def is_ecu_registered(self, ecu_id):
+            max_number_of_tries = 20
+            try_counter = 0
+
+            # aktualizr-info is not always able to load ECU serials from DB
+            # so, let's run it a few times until it actually succeeds
+            while try_counter < max_number_of_tries:
+                device_status = self.get_info()
+                try_counter += 1
+                if device_status.find("load ECU serials") == -1:
+                    break
+                sleep(1)
+
+            if not ((device_status.find(ecu_id[0]) != -1) and (device_status.find(ecu_id[1]) != -1)):
+                return False
+            not_registered_field = "Removed or not registered ecus:"
+            not_reg_start = device_status.find(not_registered_field)
+            return not_reg_start == -1 or (device_status.find(ecu_id[1], not_reg_start) == -1)
+
+        def get_info(self):
+            stdout, stderr, retcode = self.send_command('aktualizr-info')
+            self._test_ctx.assertEqual(retcode, 0, 'Unable to run aktualizr-info: {}'.format(stderr))
+            return stdout
+
     def setUpLocal(self):
         layer = "meta-updater-qemux86-64"
         result = runCmd('bitbake-layers show-layers')
@@ -323,57 +408,37 @@ class SecondaryTests(OESelftestTestCase):
             runCmd('bitbake-layers add-layer "%s"' % self.meta_qemu)
         else:
             self.meta_qemu = None
-        self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
-        self.qemu, self.s = qemu_launch(machine='qemux86-64', imagename='secondary-image')
+
+        self.primary = IpSecondaryTests.Primary(self)
+        self.secondary = IpSecondaryTests.Secondary(self)
 
     def tearDownLocal(self):
-        qemu_terminate(self.s)
         if self.meta_qemu:
             runCmd('bitbake-layers remove-layer "%s"' % self.meta_qemu, ignore_status=True)
 
-    def qemu_command(self, command):
-        return qemu_send_command(self.qemu.ssh_port, command)
+    def test_ip_secondary_registration_if_secondary_starts_first(self):
+        with self.secondary:
+            self.assertTrue(self.secondary.was_successfully_booted(),
+                            'The secondary failed to boot: {}'.format(self.secondary.stderr))
 
-    def test_secondary_present(self):
-        print('Checking aktualizr-secondary is present')
-        stdout, stderr, retcode = self.qemu_command('aktualizr-secondary --help')
-        self.assertEqual(retcode, 0, "Unable to run aktualizr-secondary --help")
-        self.assertEqual(stderr, b'', 'Error: ' + stderr.decode())
+            with self.primary:
+                self.assertTrue(self.primary.was_successfully_booted(),
+                                'The primary failed to boot: {}'.format(self.primary.stderr))
 
+                self.assertTrue(self.primary.is_ecu_registered(self.secondary.id),
+                                "The secondary wasn't registered at the primary: {}".format(self.primary.get_info()))
 
-class PrimaryTests(OESelftestTestCase):
-    def setUpLocal(self):
-        layer = "meta-updater-qemux86-64"
-        result = runCmd('bitbake-layers show-layers')
-        if re.search(layer, result.output) is None:
-            # Assume the directory layout for finding other layers. We could also
-            # make assumptions by using 'show-layers', but either way, if the
-            # layers we need aren't where we expect them, we are out of luck.
-            path = os.path.abspath(os.path.dirname(__file__))
-            metadir = path + "/../../../../../"
-            self.meta_qemu = metadir + layer
-            runCmd('bitbake-layers add-layer "%s"' % self.meta_qemu)
-        else:
-            self.meta_qemu = None
-        self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
-        self.append_config('SOTA_CLIENT_FEATURES = "secondary-network"')
-        self.qemu, self.s = qemu_launch(machine='qemux86-64', imagename='primary-image')
-
-    def tearDownLocal(self):
-        qemu_terminate(self.s)
-        if self.meta_qemu:
-            runCmd('bitbake-layers remove-layer "%s"' % self.meta_qemu, ignore_status=True)
+    def test_ip_secondary_registration_if_primary_starts_first(self):
+        with self.primary:
+            self.assertTrue(self.primary.was_successfully_booted(),
+                            'The primary failed to boot: {}'.format(self.primary.stderr))
 
-    def qemu_command(self, command):
-        return qemu_send_command(self.qemu.ssh_port, command)
+            with self.secondary:
+                self.assertTrue(self.secondary.was_successfully_booted(),
+                                'The secondary failed to boot: {}'.format(self.secondary.stderr))
 
-    def test_aktualizr_present(self):
-        print('Checking aktualizr is present')
-        stdout, stderr, retcode = self.qemu_command('aktualizr --help')
-        self.assertEqual(retcode, 0, "Unable to run aktualizr --help")
-        self.assertEqual(stderr, b'', 'Error: ' + stderr.decode())
+                self.assertTrue(self.primary.is_ecu_registered(self.secondary.id),
+                                "The secondary wasn't registered at the primary: {}".format(self.primary.get_info()))
 
 
 class ResourceControlTests(OESelftestTestCase):
@@ -391,7 +456,7 @@ class ResourceControlTests(OESelftestTestCase):
         else:
             self.meta_qemu = None
         self.append_config('MACHINE = "qemux86-64"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
         self.append_config('IMAGE_INSTALL_append += " aktualizr-resource-control "')
         self.append_config('RESOURCE_CPU_WEIGHT_pn-aktualizr = "1000"')
         self.append_config('RESOURCE_MEMORY_HIGH_pn-aktualizr = "50M"')
diff --git a/lib/oeqa/selftest/cases/updater_raspberrypi.py b/lib/oeqa/selftest/cases/updater_raspberrypi.py
index 785d703..f6ae903 100644
--- a/lib/oeqa/selftest/cases/updater_raspberrypi.py
+++ b/lib/oeqa/selftest/cases/updater_raspberrypi.py
@@ -53,7 +53,7 @@ class RpiTests(OESelftestTestCase):
             self.meta_qemu = None
 
         self.append_config('MACHINE = "raspberrypi3"')
-        self.append_config('SOTA_CLIENT_PROV = " aktualizr-auto-prov "')
+        self.append_config('SOTA_CLIENT_PROV = " aktualizr-shared-prov "')
 
     def tearDownLocal(self):
         if self.meta_qemu:
@@ -68,7 +68,6 @@ class RpiTests(OESelftestTestCase):
     def test_build(self):
         logger = logging.getLogger("selftest")
         logger.info('Running bitbake to build core-image-minimal')
-        self.append_config('SOTA_CLIENT_PROV = "aktualizr-auto-prov"')
         bitbake('core-image-minimal')
         credentials = get_bb_var('SOTA_PACKED_CREDENTIALS')
         # Skip the test if the variable SOTA_PACKED_CREDENTIALS is not set.