245 lines
9.0 KiB
Python
245 lines
9.0 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 tsconfig.tsconfig as tsc
|
|
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 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'
|
|
|
|
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_BOOTSTRAP_GET_FILE_CONTENTS = (
|
|
consts.BOOTSTRAP_VALUES,
|
|
)
|
|
|
|
VALID_STATES_FOR_DEPLOY_BOOTSTRAP = [
|
|
consts.DEPLOY_STATE_INSTALLED,
|
|
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
|
|
]
|
|
|
|
|
|
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)
|
|
|
|
if not payload:
|
|
pecan.abort(400, _('Body required'))
|
|
|
|
psd_common.validate_bootstrap_values(payload)
|
|
|
|
# If a subcloud release is not passed, use the current
|
|
# system controller software_version
|
|
payload['software_version'] = payload.get('release', tsc.SW_VERSION)
|
|
|
|
psd_common.validate_subcloud_name_availability(context, payload['name'])
|
|
|
|
psd_common.validate_system_controller_patch_status("create")
|
|
|
|
psd_common.validate_subcloud_config(context, payload)
|
|
|
|
psd_common.validate_install_values(payload)
|
|
|
|
psd_common.validate_k8s_version(payload)
|
|
|
|
psd_common.format_ip_address(payload)
|
|
|
|
# Upload the deploy config files if it is included in the request
|
|
# It has a dependency on the subcloud name, and it is called after
|
|
# the name has been validated
|
|
psd_common.upload_deploy_config_file(request, payload)
|
|
|
|
try:
|
|
# Add the subcloud details to the database
|
|
subcloud = psd_common.add_subcloud_to_database(context, payload)
|
|
|
|
# Ask dcmanager-manager to add the subcloud.
|
|
# It will do all the real work...
|
|
subcloud = self.dcmanager_rpc_client.subcloud_deploy_create(
|
|
context, subcloud.id, payload)
|
|
return subcloud
|
|
|
|
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_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.validate_sysadmin_password(payload)
|
|
|
|
if has_bootstrap_values:
|
|
# Need to validate the new values
|
|
playload_name = payload.get('name')
|
|
if playload_name != subcloud.name:
|
|
pecan.abort(400, _('The bootstrap-values "name" value (%s) '
|
|
'must match the current subcloud name (%s)' %
|
|
(playload_name, subcloud.name)))
|
|
|
|
# Verify if payload contains all required bootstrap values
|
|
psd_common.validate_bootstrap_values(payload)
|
|
|
|
# It's ok for the management subnet to conflict with itself since we
|
|
# are only going to update it if it was modified, conflicts with
|
|
# other subclouds are still verified.
|
|
psd_common.validate_subcloud_config(context, payload,
|
|
ignore_conflicts_with=subcloud)
|
|
psd_common.format_ip_address(payload)
|
|
|
|
# Patch status and fresh_install_k8s_version may have been changed
|
|
# between deploy create and deploy bootstrap commands. Validate them
|
|
# again:
|
|
psd_common.validate_system_controller_patch_status("bootstrap")
|
|
psd_common.validate_k8s_version(payload)
|
|
|
|
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'))
|
|
|
|
@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 == 'bootstrap':
|
|
subcloud = self._deploy_bootstrap(context, pecan.request, subcloud)
|
|
else:
|
|
pecan.abort(400, _('Invalid request'))
|
|
|
|
return subcloud
|