| # Lint as: python3 |
| # Copyright 2022 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import kernel_utils |
| from autotest_lib.server.cros.minios import minios_test |
| |
| |
| class autoupdate_MiniOS(minios_test.MiniOsTest): |
| """Tests MiniOS update. """ |
| |
| version = 1 |
| |
| _EXCLUSION_PREFS_DIR = "exclusion" |
| _MINIOS_PREFS_DIR = "minios" |
| |
| def initialize(self, host=None): |
| """ |
| Clear test related prefs on the DUT before starting the test. |
| |
| """ |
| super(autoupdate_MiniOS, self).initialize(host=host) |
| self._remove_minios_update_prefs() |
| |
| def cleanup(self): |
| super(autoupdate_MiniOS, self).cleanup() |
| self._save_extra_update_engine_logs(number_of_logs=2) |
| self._remove_minios_update_prefs() |
| |
| def _remove_minios_update_prefs(self): |
| for pref in ((self._EXCLUSION_PREFS_DIR, True), |
| (self._MINIOS_PREFS_DIR, True)): |
| self._remove_update_engine_pref(pref=pref[0], is_dir=pref[1]) |
| |
| def _setup_minios_update(self, has_update, with_exclusion=False): |
| # Get payload URL for the MiniOS update. |
| # We'll always need a full payload for MiniOS update. |
| payload_url = self.get_payload_for_nebraska( |
| job_repo_url=self._job_repo_url, |
| full_payload=True, |
| payload_type=self._PAYLOAD_TYPE.MINIOS, |
| public_bucket=self._running_at_desk) |
| self._payload_urls.append(payload_url) |
| |
| # Test that MiniOS payload can be excluded by creating a pref file. |
| # This simulates that the update engine tries to exclude MiniOS payload |
| # after getting certain types of MiniOS update failure. |
| if with_exclusion: |
| self._create_update_engine_pref( |
| pref_name=self._get_exclusion_name(payload_url), |
| sub_dir=self._EXCLUSION_PREFS_DIR) |
| |
| # MiniOS booting to be verified. |
| if has_update: |
| self._verifications.append(self._boot_minios) |
| |
| def _setup_cros_update(self, has_update): |
| if has_update: |
| # Get payload URL for the platform (OS) update. |
| self._payload_urls.append( |
| self.get_payload_for_nebraska( |
| job_repo_url=self._job_repo_url, |
| full_payload=self._full_payload, |
| public_bucket=self._running_at_desk)) |
| |
| # Platform (OS) update to be verified. |
| self._verifications.append(lambda: self._verify_cros_update( |
| updated=has_update)) |
| |
| def _setup_dlc_update(self): |
| # Payload URLs for sample-dlc, a test DLC package. |
| # We'll always need a full payload for DLC installation, |
| # and optionally a delta payload if required by the test. |
| self._payload_urls.append( |
| self.get_payload_for_nebraska( |
| job_repo_url=self._job_repo_url, |
| full_payload=True, |
| payload_type=self._PAYLOAD_TYPE.DLC, |
| public_bucket=self._running_at_desk)) |
| if not self._full_payload: |
| self._payload_urls.append( |
| self.get_payload_for_nebraska( |
| job_repo_url=self._job_repo_url, |
| full_payload=False, |
| payload_type=self._PAYLOAD_TYPE.DLC, |
| public_bucket=self._running_at_desk)) |
| |
| # DLC update to be verified. |
| self._verifications.append(self._verify_dlc_update) |
| |
| def _verify_cros_update(self, updated): |
| if updated: |
| # Verify the platform (OS) update completed successfully. |
| kernel_utils.verify_boot_expectations(self._inactive_cros, |
| host=self._host) |
| rootfs_hostlog, _ = self._create_hostlog_files() |
| self.verify_update_events(self._FORCED_UPDATE, rootfs_hostlog) |
| else: |
| # Verify the Platform (OS) boot expectation unchanged. |
| kernel_utils.verify_boot_expectations(self._active_cros, |
| host=self._host) |
| |
| def _verify_dlc_update(self): |
| # Verify the DLC update completed successfully. |
| dlc_rootfs_hostlog, _ = self._create_dlc_hostlog_files() |
| logging.info('Checking DLC update events') |
| self.verify_update_events( |
| self._FORCED_UPDATE, |
| dlc_rootfs_hostlog[self._dlc_util._SAMPLE_DLC_ID]) |
| # Verify the DLC was successfully installed. |
| self._dlc_util.remove_preloaded(self._dlc_util._SAMPLE_DLC_ID) |
| self._dlc_util.install(self._dlc_util._SAMPLE_DLC_ID, |
| omaha_url='fake_url') |
| if not self._dlc_util.is_installed(self._dlc_util._SAMPLE_DLC_ID): |
| raise error.TestFail('Test DLC was not installed.') |
| |
| def run_once(self, |
| full_payload=True, |
| job_repo_url=None, |
| with_os=False, |
| with_dlc=False, |
| with_exclusion=False, |
| running_at_desk=False): |
| """ |
| Tests that we can successfully update MiniOS along with the OS. |
| |
| @param full_payload: True for full OS and DLC payloads. False for delta. |
| @param job_repo_url: This is used to figure out the current build and |
| the devserver to use. The test will read this |
| from a host argument when run in the lab. |
| @param with_os: True for MiniOS update along with Platform (OS) |
| update. False for MiniOS only update. |
| @param with_dlc: True for MiniOS update with Platform (OS) and DLC. |
| False for turning off DLC update. |
| @param with_exclusion: True for excluding MiniOS payload. |
| @param running_at_desk: Indicates test is run locally from a |
| workstation. |
| |
| """ |
| self._full_payload = full_payload |
| self._job_repo_url = job_repo_url |
| self._running_at_desk = running_at_desk |
| |
| if not with_os and with_dlc: |
| logging.info("DLC only updates with the platform (OS), " |
| "automatically set with_os to True.") |
| with_os = True |
| |
| # Record DUT state before the update. |
| self._active_cros, self._inactive_cros \ |
| = kernel_utils.get_kernel_state(self._host) |
| active_minios, inactive_minios \ |
| = kernel_utils.get_minios_priority(self._host) |
| |
| minios_update = with_os and not with_exclusion |
| # MiniOS update to be verified. |
| self._verifications = [ |
| lambda: kernel_utils.verify_minios_priority_after_update( |
| self._host, |
| expected=inactive_minios |
| if minios_update else active_minios) |
| ] |
| |
| # Get payload URLs and setup tests. |
| self._payload_urls = [] |
| self._setup_cros_update(has_update=with_os) |
| if with_dlc: |
| self._setup_dlc_update() |
| self._setup_minios_update(has_update=minios_update, |
| with_exclusion=with_exclusion) |
| |
| # Update MiniOS. |
| if with_dlc: |
| self._run_client_test_and_check_result( |
| 'autoupdate_InstallAndUpdateDLC', |
| payload_urls=self._payload_urls, |
| allow_failure=not with_os) |
| else: |
| self._run_client_test_and_check_result( |
| 'autoupdate_CannedOmahaUpdate', |
| payload_url=self._payload_urls, |
| allow_failure=not with_os) |
| |
| if with_os: |
| self._host.reboot() |
| |
| # Verify updates. |
| for verify in self._verifications: |
| verify() |
