485 lines
19 KiB
Python
485 lines
19 KiB
Python
#
|
|
# Copyright (c) 2023 Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
|
|
import http.client as httpclient
|
|
import os
|
|
|
|
from oslo_log import log as logging
|
|
from oslo_messaging import RemoteError
|
|
import pecan
|
|
import yaml
|
|
|
|
from dcmanager.api.controllers import restcomm
|
|
from dcmanager.api.policies import phased_subcloud_deploy as \
|
|
phased_subcloud_deploy_policy
|
|
from dcmanager.api import policy
|
|
from dcmanager.common import consts
|
|
from dcmanager.common.context import RequestContext
|
|
from dcmanager.common import exceptions
|
|
from dcmanager.common.i18n import _
|
|
from dcmanager.common import phased_subcloud_deploy as psd_common
|
|
from dcmanager.common import prestage
|
|
from dcmanager.common import utils
|
|
from dcmanager.db import api as db_api
|
|
from dcmanager.db.sqlalchemy import models
|
|
from dcmanager.rpc import client as rpc_client
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
LOCK_NAME = 'PhasedSubcloudDeployController'
|
|
|
|
INSTALL = consts.DEPLOY_PHASE_INSTALL
|
|
BOOTSTRAP = consts.DEPLOY_PHASE_BOOTSTRAP
|
|
CONFIG = consts.DEPLOY_PHASE_CONFIG
|
|
COMPLETE = consts.DEPLOY_PHASE_COMPLETE
|
|
ABORT = consts.DEPLOY_PHASE_ABORT
|
|
RESUME = consts.DEPLOY_PHASE_RESUME
|
|
|
|
SUBCLOUD_CREATE_REQUIRED_PARAMETERS = (
|
|
consts.BOOTSTRAP_VALUES,
|
|
consts.BOOTSTRAP_ADDRESS
|
|
)
|
|
|
|
# The consts.DEPLOY_CONFIG is missing here because it's handled differently
|
|
# by the upload_deploy_config_file() function
|
|
SUBCLOUD_CREATE_GET_FILE_CONTENTS = (
|
|
consts.BOOTSTRAP_VALUES,
|
|
consts.INSTALL_VALUES,
|
|
)
|
|
|
|
SUBCLOUD_INSTALL_GET_FILE_CONTENTS = (
|
|
consts.INSTALL_VALUES,
|
|
)
|
|
|
|
SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS = (
|
|
consts.BOOTSTRAP_VALUES,
|
|
)
|
|
|
|
SUBCLOUD_CONFIG_GET_FILE_CONTENTS = (
|
|
consts.DEPLOY_CONFIG,
|
|
)
|
|
|
|
VALID_STATES_FOR_DEPLOY_INSTALL = (
|
|
consts.DEPLOY_STATE_CREATED,
|
|
consts.DEPLOY_STATE_PRE_INSTALL_FAILED,
|
|
consts.DEPLOY_STATE_INSTALL_FAILED,
|
|
consts.DEPLOY_STATE_INSTALLED,
|
|
consts.DEPLOY_STATE_INSTALL_ABORTED
|
|
)
|
|
|
|
VALID_STATES_FOR_DEPLOY_BOOTSTRAP = [
|
|
consts.DEPLOY_STATE_INSTALLED,
|
|
consts.DEPLOY_STATE_PRE_BOOTSTRAP_FAILED,
|
|
consts.DEPLOY_STATE_BOOTSTRAP_FAILED,
|
|
consts.DEPLOY_STATE_BOOTSTRAP_ABORTED,
|
|
consts.DEPLOY_STATE_BOOTSTRAPPED,
|
|
# The subcloud can be installed manually (without remote install) so we need
|
|
# to allow the bootstrap operation when the state == DEPLOY_STATE_CREATED
|
|
consts.DEPLOY_STATE_CREATED
|
|
]
|
|
|
|
VALID_STATES_FOR_DEPLOY_CONFIG = (
|
|
consts.DEPLOY_STATE_DONE,
|
|
consts.DEPLOY_STATE_PRE_CONFIG_FAILED,
|
|
consts.DEPLOY_STATE_CONFIG_FAILED,
|
|
consts.DEPLOY_STATE_BOOTSTRAPPED,
|
|
consts.DEPLOY_STATE_CONFIG_ABORTED,
|
|
# The next two states are needed due to upgrade scenario:
|
|
# TODO(gherzman): remove states when they are no longer needed
|
|
consts.DEPLOY_STATE_DEPLOY_FAILED,
|
|
consts.DEPLOY_STATE_DEPLOY_PREP_FAILED,
|
|
)
|
|
|
|
VALID_STATES_FOR_DEPLOY_ABORT = (
|
|
consts.DEPLOY_STATE_INSTALLING,
|
|
consts.DEPLOY_STATE_BOOTSTRAPPING,
|
|
consts.DEPLOY_STATE_CONFIGURING
|
|
)
|
|
|
|
FILES_FOR_RESUME_INSTALL = \
|
|
SUBCLOUD_INSTALL_GET_FILE_CONTENTS + \
|
|
SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS + \
|
|
SUBCLOUD_CONFIG_GET_FILE_CONTENTS
|
|
|
|
|
|
FILES_FOR_RESUME_BOOTSTRAP = \
|
|
SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS + \
|
|
SUBCLOUD_CONFIG_GET_FILE_CONTENTS
|
|
|
|
|
|
FILES_FOR_RESUME_CONFIG = SUBCLOUD_CONFIG_GET_FILE_CONTENTS
|
|
|
|
RESUMABLE_STATES = {
|
|
consts.DEPLOY_STATE_CREATED: [INSTALL, BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_INSTALLED: [BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_PRE_INSTALL_FAILED: [INSTALL, BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_INSTALL_FAILED: [INSTALL, BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_INSTALL_ABORTED: [INSTALL, BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_BOOTSTRAPPED: [CONFIG],
|
|
consts.DEPLOY_STATE_PRE_BOOTSTRAP_FAILED: [BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_BOOTSTRAP_FAILED: [BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_BOOTSTRAP_ABORTED: [BOOTSTRAP, CONFIG],
|
|
consts.DEPLOY_STATE_PRE_CONFIG_FAILED: [CONFIG],
|
|
consts.DEPLOY_STATE_CONFIG_FAILED: [CONFIG],
|
|
consts.DEPLOY_STATE_CONFIG_ABORTED: [CONFIG]
|
|
}
|
|
|
|
FILES_MAPPING = {
|
|
INSTALL: SUBCLOUD_INSTALL_GET_FILE_CONTENTS,
|
|
BOOTSTRAP: SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS,
|
|
CONFIG: SUBCLOUD_CONFIG_GET_FILE_CONTENTS
|
|
}
|
|
|
|
RESUME_PREP_UPDATE_STATUS = {
|
|
INSTALL: consts.DEPLOY_STATE_PRE_INSTALL,
|
|
BOOTSTRAP: consts.DEPLOY_STATE_PRE_BOOTSTRAP,
|
|
CONFIG: consts.DEPLOY_STATE_PRE_CONFIG
|
|
}
|
|
|
|
|
|
def get_create_payload(request: pecan.Request) -> dict:
|
|
payload = dict()
|
|
|
|
for f in SUBCLOUD_CREATE_GET_FILE_CONTENTS:
|
|
if f in request.POST:
|
|
file_item = request.POST[f]
|
|
file_item.file.seek(0, os.SEEK_SET)
|
|
data = yaml.safe_load(file_item.file.read().decode('utf8'))
|
|
if f == consts.BOOTSTRAP_VALUES:
|
|
payload.update(data)
|
|
else:
|
|
payload.update({f: data})
|
|
del request.POST[f]
|
|
payload.update(request.POST)
|
|
|
|
return payload
|
|
|
|
|
|
class PhasedSubcloudDeployController(object):
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.dcmanager_rpc_client = rpc_client.ManagerClient()
|
|
|
|
def _deploy_create(self, context: RequestContext, request: pecan.Request):
|
|
policy.authorize(phased_subcloud_deploy_policy.POLICY_ROOT % "create",
|
|
{}, restcomm.extract_credentials_for_policy())
|
|
psd_common.check_required_parameters(
|
|
request, SUBCLOUD_CREATE_REQUIRED_PARAMETERS)
|
|
|
|
payload = get_create_payload(request)
|
|
|
|
psd_common.pre_deploy_create(payload, context, request)
|
|
|
|
try:
|
|
# Add the subcloud details to the database
|
|
subcloud = psd_common.add_subcloud_to_database(context, payload)
|
|
|
|
# Ask dcmanager-manager to create the subcloud.
|
|
# It will do all the real work...
|
|
subcloud_dict = self.dcmanager_rpc_client.subcloud_deploy_create(
|
|
context, subcloud.id, payload)
|
|
|
|
return subcloud_dict
|
|
|
|
except RemoteError as e:
|
|
pecan.abort(httpclient.UNPROCESSABLE_ENTITY, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to create subcloud %s" % payload.get('name'))
|
|
pecan.abort(httpclient.INTERNAL_SERVER_ERROR,
|
|
_('Unable to create subcloud'))
|
|
|
|
def _deploy_install(self, context: RequestContext,
|
|
request: pecan.Request, subcloud):
|
|
payload = psd_common.get_request_data(
|
|
request, subcloud, SUBCLOUD_INSTALL_GET_FILE_CONTENTS)
|
|
if not payload:
|
|
pecan.abort(400, _('Body required'))
|
|
|
|
if subcloud.deploy_status not in VALID_STATES_FOR_DEPLOY_INSTALL:
|
|
allowed_states_str = ', '.join(VALID_STATES_FOR_DEPLOY_INSTALL)
|
|
pecan.abort(400, _('Subcloud deploy status must be either: %s')
|
|
% allowed_states_str)
|
|
|
|
payload['software_version'] = payload.get('release', subcloud.software_version)
|
|
psd_common.populate_payload_with_pre_existing_data(
|
|
payload, subcloud, SUBCLOUD_INSTALL_GET_FILE_CONTENTS)
|
|
|
|
psd_common.pre_deploy_install(payload, subcloud)
|
|
|
|
try:
|
|
# Align the software version of the subcloud with install
|
|
# version. Update the deploy status as pre-install.
|
|
|
|
self.dcmanager_rpc_client.subcloud_deploy_install(
|
|
context, subcloud.id, payload)
|
|
subcloud_dict = db_api.subcloud_db_model_to_dict(subcloud)
|
|
subcloud_dict['deploy-status'] = consts.DEPLOY_STATE_PRE_INSTALL
|
|
subcloud_dict['software-version'] = payload['software_version']
|
|
|
|
return subcloud_dict
|
|
except RemoteError as e:
|
|
pecan.abort(422, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to install subcloud %s" % subcloud.name)
|
|
pecan.abort(500, _('Unable to install subcloud'))
|
|
|
|
def _deploy_bootstrap(self, context: RequestContext,
|
|
request: pecan.Request,
|
|
subcloud: models.Subcloud):
|
|
if subcloud.deploy_status not in VALID_STATES_FOR_DEPLOY_BOOTSTRAP:
|
|
valid_states_str = ', '.join(VALID_STATES_FOR_DEPLOY_BOOTSTRAP)
|
|
pecan.abort(400, _('Subcloud deploy status must be either: %s')
|
|
% valid_states_str)
|
|
|
|
has_bootstrap_values = consts.BOOTSTRAP_VALUES in request.POST
|
|
payload = {}
|
|
|
|
# Try to load the existing override values
|
|
override_file = psd_common.get_config_file_path(subcloud.name)
|
|
if os.path.exists(override_file):
|
|
psd_common.populate_payload_with_pre_existing_data(
|
|
payload, subcloud, SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS)
|
|
elif not has_bootstrap_values:
|
|
msg = _("Required bootstrap-values file was not provided and it was"
|
|
" not previously available at %s") % (override_file)
|
|
pecan.abort(400, msg)
|
|
|
|
request_data = psd_common.get_request_data(
|
|
request, subcloud, SUBCLOUD_BOOTSTRAP_GET_FILE_CONTENTS)
|
|
|
|
# Update the existing values with new ones from the request
|
|
payload.update(request_data)
|
|
|
|
psd_common.pre_deploy_bootstrap(context, payload, subcloud,
|
|
has_bootstrap_values)
|
|
|
|
try:
|
|
# Ask dcmanager-manager to bootstrap the subcloud.
|
|
self.dcmanager_rpc_client.subcloud_deploy_bootstrap(
|
|
context, subcloud.id, payload)
|
|
return db_api.subcloud_db_model_to_dict(subcloud)
|
|
|
|
except RemoteError as e:
|
|
pecan.abort(httpclient.UNPROCESSABLE_ENTITY, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to bootstrap subcloud %s" %
|
|
payload.get('name'))
|
|
pecan.abort(httpclient.INTERNAL_SERVER_ERROR,
|
|
_('Unable to bootstrap subcloud'))
|
|
|
|
def _deploy_config(self, context: RequestContext,
|
|
request: pecan.Request, subcloud):
|
|
payload = psd_common.get_request_data(
|
|
request, subcloud, SUBCLOUD_CONFIG_GET_FILE_CONTENTS)
|
|
if not payload:
|
|
pecan.abort(400, _('Body required'))
|
|
|
|
if not (subcloud.deploy_status in VALID_STATES_FOR_DEPLOY_CONFIG or
|
|
prestage.is_deploy_status_prestage(subcloud.deploy_status)):
|
|
allowed_states_str = ', '.join(VALID_STATES_FOR_DEPLOY_CONFIG)
|
|
pecan.abort(400, _('Subcloud deploy status must be either '
|
|
'%s or prestage-...') % allowed_states_str)
|
|
|
|
psd_common.populate_payload_with_pre_existing_data(
|
|
payload, subcloud, SUBCLOUD_CONFIG_GET_FILE_CONTENTS)
|
|
|
|
psd_common.validate_sysadmin_password(payload)
|
|
|
|
try:
|
|
self.dcmanager_rpc_client.subcloud_deploy_config(
|
|
context, subcloud.id, payload)
|
|
subcloud_dict = db_api.subcloud_db_model_to_dict(subcloud)
|
|
subcloud_dict['deploy-status'] = consts.DEPLOY_STATE_PRE_CONFIG
|
|
return subcloud_dict
|
|
except RemoteError as e:
|
|
pecan.abort(422, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to configure subcloud %s" % subcloud.name)
|
|
pecan.abort(500, _('Unable to configure subcloud'))
|
|
|
|
def _deploy_complete(self, context: RequestContext, subcloud):
|
|
|
|
# The deployment should be able to be completed when the deploy state
|
|
# is consts.DEPLOY_STATE_BOOTSTRAPPED because the user could have
|
|
# configured the subcloud manually
|
|
if subcloud.deploy_status != consts.DEPLOY_STATE_BOOTSTRAPPED:
|
|
pecan.abort(400, _('Subcloud deploy can only be completed when'
|
|
' its deploy status is: %s')
|
|
% consts.DEPLOY_STATE_BOOTSTRAPPED)
|
|
|
|
try:
|
|
# Ask dcmanager-manager to complete the subcloud deployment
|
|
subcloud = self.dcmanager_rpc_client.subcloud_deploy_complete(
|
|
context, subcloud.id)
|
|
return subcloud
|
|
|
|
except RemoteError as e:
|
|
pecan.abort(httpclient.UNPROCESSABLE_ENTITY, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to complete subcloud %s deployment" %
|
|
subcloud.name)
|
|
pecan.abort(httpclient.INTERNAL_SERVER_ERROR,
|
|
_('Unable to complete subcloud deployment'))
|
|
|
|
def _deploy_abort(self, context, subcloud):
|
|
|
|
if subcloud.deploy_status not in VALID_STATES_FOR_DEPLOY_ABORT:
|
|
allowed_states_str = ', '.join(VALID_STATES_FOR_DEPLOY_ABORT)
|
|
pecan.abort(400, _('Subcloud deploy status must be in one '
|
|
'of the following states: %s')
|
|
% allowed_states_str)
|
|
|
|
try:
|
|
self.dcmanager_rpc_client.subcloud_deploy_abort(
|
|
context, subcloud.id, subcloud.deploy_status)
|
|
subcloud_dict = db_api.subcloud_db_model_to_dict(subcloud)
|
|
subcloud_dict['deploy-status'] = \
|
|
utils.ABORT_UPDATE_STATUS[subcloud.deploy_status]
|
|
return subcloud_dict
|
|
except RemoteError as e:
|
|
pecan.abort(422, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to abort subcloud %s deployment" % subcloud.name)
|
|
pecan.abort(500, _('Unable to abort subcloud deploy'))
|
|
|
|
def _deploy_resume(self, context: RequestContext,
|
|
request: pecan.Request, subcloud):
|
|
|
|
if subcloud.deploy_status not in RESUMABLE_STATES:
|
|
allowed_states_str = ', '.join(RESUMABLE_STATES)
|
|
pecan.abort(400, _('Subcloud deploy status must be either: %s')
|
|
% allowed_states_str)
|
|
|
|
# Since both install and config are optional phases,
|
|
# it's necessary to check if they should be executed
|
|
config_file = psd_common.get_config_file_path(subcloud.name,
|
|
consts.DEPLOY_CONFIG)
|
|
has_original_install_values = subcloud.data_install
|
|
has_original_config_values = os.path.exists(config_file)
|
|
has_new_install_values = consts.INSTALL_VALUES in request.POST
|
|
has_new_config_values = consts.DEPLOY_CONFIG in request.POST
|
|
has_bootstrap_values = consts.BOOTSTRAP_VALUES in request.POST
|
|
has_config_values = has_original_config_values or has_new_config_values
|
|
has_install_values = has_original_install_values or has_new_install_values
|
|
|
|
deploy_states_to_run = RESUMABLE_STATES[subcloud.deploy_status]
|
|
if deploy_states_to_run == [CONFIG] and not has_config_values:
|
|
msg = _("Only deploy phase left is deploy config. "
|
|
"Required %s file was not provided and it was not "
|
|
"previously available.") % consts.DEPLOY_CONFIG
|
|
pecan.abort(400, msg)
|
|
|
|
# Since the subcloud can be installed manually and the config is optional,
|
|
# skip those phases if the user doesn't provide the install or config values
|
|
# and they are not available from previous executions.
|
|
files_for_resume = []
|
|
for state in deploy_states_to_run:
|
|
if state == INSTALL and not has_install_values:
|
|
deploy_states_to_run.remove(state)
|
|
elif state == CONFIG and not has_config_values:
|
|
deploy_states_to_run.remove(state)
|
|
else:
|
|
files_for_resume.extend(FILES_MAPPING[state])
|
|
|
|
payload = psd_common.get_request_data(request, subcloud, files_for_resume)
|
|
|
|
# Consider the incoming release parameter only if install is one
|
|
# of the pending deploy states
|
|
if INSTALL in deploy_states_to_run:
|
|
payload['software_version'] = payload.get('release', subcloud.software_version)
|
|
else:
|
|
payload['software_version'] = subcloud.software_version
|
|
|
|
# Need to remove bootstrap_values from the list of files to populate
|
|
# pre existing data so it does not overwrite newly loaded values
|
|
if has_bootstrap_values:
|
|
files_for_resume = [f for f in files_for_resume if f
|
|
not in FILES_MAPPING[BOOTSTRAP]]
|
|
psd_common.populate_payload_with_pre_existing_data(
|
|
payload, subcloud, files_for_resume)
|
|
|
|
psd_common.validate_sysadmin_password(payload)
|
|
for state in deploy_states_to_run:
|
|
if state == INSTALL:
|
|
psd_common.pre_deploy_install(payload, validate_password=False)
|
|
elif state == BOOTSTRAP:
|
|
psd_common.pre_deploy_bootstrap(context, payload, subcloud,
|
|
has_bootstrap_values,
|
|
validate_password=False)
|
|
elif state == CONFIG:
|
|
# Currently the only pre_deploy_config step is validate_sysadmin_password
|
|
# which can't be executed more than once
|
|
pass
|
|
|
|
try:
|
|
self.dcmanager_rpc_client.subcloud_deploy_resume(
|
|
context, subcloud.id, subcloud.name, payload, deploy_states_to_run)
|
|
subcloud_dict = db_api.subcloud_db_model_to_dict(subcloud)
|
|
next_deploy_phase = RESUMABLE_STATES[subcloud.deploy_status][0]
|
|
next_deploy_state = RESUME_PREP_UPDATE_STATUS[next_deploy_phase]
|
|
subcloud_dict['deploy-status'] = next_deploy_state
|
|
subcloud_dict['software-version'] = payload['software_version']
|
|
return subcloud_dict
|
|
except RemoteError as e:
|
|
pecan.abort(422, e.value)
|
|
except Exception:
|
|
LOG.exception("Unable to resume subcloud %s deployment" % subcloud.name)
|
|
pecan.abort(500, _('Unable to resume subcloud deployment'))
|
|
|
|
@pecan.expose(generic=True, template='json')
|
|
def index(self):
|
|
# Route the request to specific methods with parameters
|
|
pass
|
|
|
|
@utils.synchronized(LOCK_NAME)
|
|
@index.when(method='POST', template='json')
|
|
def post(self):
|
|
context = restcomm.extract_context_from_environ()
|
|
return self._deploy_create(context, pecan.request)
|
|
|
|
@utils.synchronized(LOCK_NAME)
|
|
@index.when(method='PATCH', template='json')
|
|
def patch(self, subcloud_ref=None, verb=None):
|
|
"""Modify the subcloud deployment.
|
|
|
|
:param subcloud_ref: ID or name of subcloud to update
|
|
|
|
:param verb: Specifies the patch action to be taken
|
|
or subcloud operation
|
|
"""
|
|
|
|
policy.authorize(phased_subcloud_deploy_policy.POLICY_ROOT % "modify", {},
|
|
restcomm.extract_credentials_for_policy())
|
|
context = restcomm.extract_context_from_environ()
|
|
|
|
if not subcloud_ref:
|
|
pecan.abort(400, _('Subcloud ID required'))
|
|
|
|
try:
|
|
if subcloud_ref.isdigit():
|
|
subcloud = db_api.subcloud_get(context, subcloud_ref)
|
|
else:
|
|
subcloud = db_api.subcloud_get_by_name(context, subcloud_ref)
|
|
except (exceptions.SubcloudNotFound, exceptions.SubcloudNameNotFound):
|
|
pecan.abort(404, _('Subcloud not found'))
|
|
|
|
if verb == ABORT:
|
|
subcloud = self._deploy_abort(context, subcloud)
|
|
elif verb == RESUME:
|
|
subcloud = self._deploy_resume(context, pecan.request, subcloud)
|
|
elif verb == INSTALL:
|
|
subcloud = self._deploy_install(context, pecan.request, subcloud)
|
|
elif verb == BOOTSTRAP:
|
|
subcloud = self._deploy_bootstrap(context, pecan.request, subcloud)
|
|
elif verb == CONFIG:
|
|
subcloud = self._deploy_config(context, pecan.request, subcloud)
|
|
elif verb == COMPLETE:
|
|
subcloud = self._deploy_complete(context, subcloud)
|
|
else:
|
|
pecan.abort(400, _('Invalid request'))
|
|
|
|
return subcloud
|