156 lines
6.6 KiB
Python
156 lines
6.6 KiB
Python
#
|
|
# Copyright (c) 2023-2024 Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
|
|
import os
|
|
import time
|
|
|
|
from dccommon.drivers.openstack import software_v1
|
|
from dcmanager.common import consts
|
|
from dcmanager.common.exceptions import StrategyStoppedException
|
|
from dcmanager.common import utils
|
|
from dcmanager.orchestrator.states.base import BaseState
|
|
from dcmanager.orchestrator.states.software.cache.cache_specifications import \
|
|
REGION_ONE_RELEASE_USM_CACHE_TYPE
|
|
|
|
# Max time: 30 minutes = 180 queries x 10 seconds between
|
|
DEFAULT_MAX_QUERIES = 180
|
|
DEFAULT_SLEEP_DURATION = 10
|
|
|
|
|
|
class UploadState(BaseState):
|
|
"""Software orchestration state for uploading releases"""
|
|
|
|
def __init__(self, region_name):
|
|
super(UploadState, self).__init__(
|
|
next_state=consts.STRATEGY_STATE_SW_DEPLOY_PRE_CHECK,
|
|
region_name=region_name)
|
|
self.sleep_duration = DEFAULT_SLEEP_DURATION
|
|
self.max_queries = DEFAULT_MAX_QUERIES
|
|
|
|
def _get_major_minor_versions(self, release_sw_version):
|
|
return release_sw_version.rsplit('.', 1)
|
|
|
|
def _find_missing_patches(self, subcloud_releases,
|
|
potential_missing_patches):
|
|
|
|
return [potential_missing_patch for potential_missing_patch
|
|
in potential_missing_patches
|
|
if potential_missing_patch not in subcloud_releases]
|
|
|
|
def perform_state_action(self, strategy_step):
|
|
"""Upload releases in this subcloud"""
|
|
self.info_log(strategy_step, "Uploading releases")
|
|
|
|
regionone_releases = self._read_from_cache(REGION_ONE_RELEASE_USM_CACHE_TYPE)
|
|
applied_releases_ids = list()
|
|
for release_id in regionone_releases:
|
|
if regionone_releases[release_id]['state'] in [
|
|
software_v1.DEPLOYED,
|
|
software_v1.COMMITTED]:
|
|
applied_releases_ids.append(release_id)
|
|
|
|
# Retrieve all subcloud releases
|
|
try:
|
|
subcloud_releases = self.get_software_client(
|
|
self.region_name).query()
|
|
except Exception:
|
|
message = ("Cannot retrieve subcloud releases. Please "
|
|
"see /var/log/software.log for details.")
|
|
self.exception_log(strategy_step, message)
|
|
raise Exception(message)
|
|
|
|
releases_to_upload = []
|
|
|
|
# RegionOne applied releases not present on the subcloud needs to be uploaded
|
|
for release_id in applied_releases_ids:
|
|
if release_id not in subcloud_releases:
|
|
self.info_log(strategy_step, (f"Release {release_id} missing from "
|
|
"subloud"))
|
|
releases_to_upload.append(release_id)
|
|
|
|
if releases_to_upload:
|
|
self.info_log(strategy_step,
|
|
f"Uploading releases {releases_to_upload} to subcloud")
|
|
|
|
files_to_upload = []
|
|
potential_missing_patches = []
|
|
iso_release = None
|
|
for release in releases_to_upload:
|
|
major_sw_version, minor_sw_version = self._get_major_minor_versions(
|
|
regionone_releases[release]['sw_version'])
|
|
|
|
# when minor is 0, it means that the release is an iso
|
|
if minor_sw_version == consts.ISO_VERSION:
|
|
iso_path, sig_path = utils.get_vault_load_files(major_sw_version)
|
|
files_to_upload.extend([iso_path, sig_path])
|
|
iso_release = release
|
|
else:
|
|
patch_path = (f"{consts.RELEASE_VAULT_DIR}/"
|
|
f"{major_sw_version}/{release}.patch")
|
|
if not os.path.isfile(patch_path):
|
|
# patch wasn't found but it may be included in an iso
|
|
potential_missing_patches.append(release)
|
|
else:
|
|
files_to_upload.append(patch_path)
|
|
if files_to_upload:
|
|
try:
|
|
self.get_software_client(
|
|
self.region_name).upload(files_to_upload)
|
|
except Exception:
|
|
message = ("Cannot upload releases to subcloud. Please "
|
|
"see /var/log/software.log for details.")
|
|
self.exception_log(strategy_step, message)
|
|
raise Exception(message)
|
|
|
|
if self.stopped():
|
|
self.info_log(strategy_step, "Exiting because task was stopped")
|
|
raise StrategyStoppedException()
|
|
|
|
if iso_release:
|
|
audit_counter = 0
|
|
while True:
|
|
time.sleep(self.sleep_duration)
|
|
|
|
if self.stopped():
|
|
raise StrategyStoppedException()
|
|
|
|
try:
|
|
subcloud_releases = self.get_software_client(
|
|
self.region_name).query()
|
|
except Exception:
|
|
self.debug_log(strategy_step, "failed to retrieve releases.")
|
|
|
|
if iso_release in subcloud_releases:
|
|
if potential_missing_patches:
|
|
# Retrieve patches that are present in the system
|
|
# controller and not in the subcloud after uploading
|
|
# load to the subcloud.
|
|
missing_patches = self. \
|
|
_find_missing_patches(subcloud_releases,
|
|
potential_missing_patches)
|
|
|
|
if missing_patches:
|
|
message = (f"Release files {missing_patches} "
|
|
"are missing")
|
|
self.error_log(strategy_step, message)
|
|
raise Exception(message)
|
|
break
|
|
audit_counter += 1
|
|
if audit_counter >= self.max_queries:
|
|
details = ("Timeout waiting for load import to complete. "
|
|
"Please check software.log on the subcloud.")
|
|
self.exception_log(strategy_step, details)
|
|
raise Exception(details)
|
|
else:
|
|
# No load was uploaded therefore the patches are really missing.
|
|
if potential_missing_patches:
|
|
message = (f"Release files {potential_missing_patches} "
|
|
"are missing")
|
|
self.error_log(strategy_step, message)
|
|
raise Exception(message)
|
|
|
|
return self.next_state
|