starlingx/distcloud
Code Issues Proposed changes
distcloud/distributedcloud/dcmanager/db/api.py
Cristian Mondo a6a6b84258 Subcloud Name Reconfiguration 
This change adds the capability to rename the subcloud after
bootstrap or during subcloud rehome operation.

Added a field in the database to separate the region name
from the subcloud name.
The region name determines the subcloud reference in the
Openstack core, through which it is possible to access
the endpoints of a given subcloud. Since the region name
cannot be changed, this commit adds the ability to maintain
a unique region name based on the UUID format, and allows
subcloud renaming when necessary without any endpoint
impact.
The region is randomly generated to configure the subcloud
when it is created and only applies to future subclouds.
For those systems that have existing subclouds, the region
will be the same as on day 0, that is, region will keep the
same name as the subcloud, but subclouds can be renamed.

This topic involves changes to dcmanager, dcmanager-client
and GUI. To ensure the region name reference needed by the
cert-monitor, a mechanism to determine if the request is
coming from the cert-monitor has been created.

Usage for subcloud rename:
dcmanager subcloud update <subcloud-name> --name <new-name>

Usage for subcloud rehoming:
dcmanager subcloud add --name <subcloud-name> --migrate ...

Note: Upgrade test from StarlingX 8 -> 9 for this commit
is deferred until upgrade functionality in master is
restored. Any issue found during upgrade test will be
addressed in a separate commit

Test Plan:
PASS: Run dcmanager subcloud passing subcommands:
      - add/delete/migrate/list/show/show --detail
      - errors/manage/unmanage/reinstall/reconfig
      - update/deploy
PASS: Run dcmanager subcloud add supplying --name
      parameter and validate the operation is not allowed
PASS: Run dcmanager supplying subcommands:
      - kube/patch/prestage strategies
PASS: Run dcmanager to apply patch and remove it
PASS: Run dcmanager subcloud-backup:
      - create/delete/restore/show/upload
PASS: Run subcloud-group:
      - add/delete/list/list-subclouds/show/update
PASS: Run dcmanager subcloud strategy for:
      - patch/kubernetes/firmware
PASS: Run dcmanager subcloud update command passing --name
      parameter supplying the following values:
      - current subcloud name (not changed)
      - different existing subcloud name
PASS: Run dcmanager to migrate a subcloud passing --name
      parameter supplying a new subcloud name
PASS: Run dcmanager to migrate a subcloud without --name
      parameter
PASS: Run dcmanager to migrate a subcloud passing --name
      parameter supplying a new subcloud name and
      different subcloud name in bootstrap file
PASS: Test dcmanager API response using cURL command line
      to validate new region name field
PASS: Run full DC sanity and regression

Story: 2010788
Task: 48217

Signed-off-by: Cristian Mondo <cristian.mondo@windriver.com>
Change-Id: Id04f42504b8e325d9ec3880c240fe4a06e3a20b7
2023-09-07 10:30:06 -03:00

695 lines
26 KiB
Python
Raw Blame History

# Copyright (c) 2015 Ericsson AB.
# Copyright (c) 2017-2023 Wind River Systems, Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
"""
Interface for database access.
SQLAlchemy is currently the only supported backend.
"""
from oslo_config import cfg
from oslo_db import api
from dccommon import consts as dccommon_consts
from dcmanager.db.sqlalchemy import models
CONF = cfg.CONF
_BACKEND_MAPPING = {'sqlalchemy': 'dcmanager.db.sqlalchemy.api'}
IMPL = api.DBAPI.from_config(CONF, backend_mapping=_BACKEND_MAPPING)
def get_engine():
return IMPL.get_engine()
def get_session():
return IMPL.get_session()
# subcloud audit db methods
##########################
def subcloud_audits_get(context, subcloud_id):
"""Get subcloud_audits info for a subcloud."""
return IMPL.subcloud_audits_get(context, subcloud_id)
def subcloud_audits_get_all(context):
"""Get subcloud_audits info for all subclouds."""
return IMPL.subcloud_audits_get_all(context)
def subcloud_audits_update_all(context, values):
""""Mark sub-audits as needed for all subclouds."""
return IMPL.subcloud_audits_update_all(context, values)
def subcloud_audits_create(context, subcloud_id):
""""Create subcloud_audits info for a subcloud."""
return IMPL.subcloud_audits_create(context, subcloud_id)
def subcloud_audits_update(context, subcloud_id, values):
"""Get all subcloud_audits that need auditing."""
return IMPL.subcloud_audits_update(context, subcloud_id, values)
def subcloud_audits_get_all_need_audit(context, last_audit_threshold):
"""Get all subcloud_audits that need auditing."""
return IMPL.subcloud_audits_get_all_need_audit(context, last_audit_threshold)
# In the functions below it would be cleaner if the timestamp were calculated
# by the DB server. If server time is in UTC func.now() might work.
def subcloud_audits_get_and_start_audit(context, subcloud_id):
"""Set the 'audit started' timestamp for the main audit."""
return IMPL.subcloud_audits_get_and_start_audit(context, subcloud_id)
def subcloud_audits_end_audit(context, subcloud_id, audits_done):
"""Set the 'audit finished' timestamp for the main audit."""
return IMPL.subcloud_audits_end_audit(context, subcloud_id, audits_done)
def subcloud_audits_fix_expired_audits(context, last_audit_threshold,
trigger_audits=False):
return IMPL.subcloud_audits_fix_expired_audits(context,
last_audit_threshold,
trigger_audits)
# subcloud db methods
###################
def subcloud_db_model_to_dict(subcloud):
"""Convert subcloud db model to dictionary."""
result = {"id": subcloud.id,
"name": subcloud.name,
"description": subcloud.description,
"location": subcloud.location,
"software-version": subcloud.software_version,
"management-state": subcloud.management_state,
"availability-status": subcloud.availability_status,
"deploy-status": subcloud.deploy_status,
"backup-status": subcloud.backup_status,
"backup-datetime": subcloud.backup_datetime,
"error-description": subcloud.error_description,
'region-name': subcloud.region_name,
"management-subnet": subcloud.management_subnet,
"management-start-ip": subcloud.management_start_ip,
"management-end-ip": subcloud.management_end_ip,
"management-gateway-ip": subcloud.management_gateway_ip,
"openstack-installed": subcloud.openstack_installed,
"systemcontroller-gateway-ip":
subcloud.systemcontroller_gateway_ip,
"data_install": subcloud.data_install,
"data_upgrade": subcloud.data_upgrade,
"created-at": subcloud.created_at,
"updated-at": subcloud.updated_at,
"group_id": subcloud.group_id,
"rehome_data": subcloud.rehome_data}
return result
def subcloud_create(context, name, description, location, software_version,
management_subnet, management_gateway_ip,
management_start_ip, management_end_ip,
systemcontroller_gateway_ip, deploy_status, error_description,
region_name, openstack_installed, group_id, data_install=None):
"""Create a subcloud."""
return IMPL.subcloud_create(context, name, description, location,
software_version,
management_subnet, management_gateway_ip,
management_start_ip, management_end_ip,
systemcontroller_gateway_ip, deploy_status,
error_description, region_name, openstack_installed, group_id,
data_install)
def subcloud_get(context, subcloud_id):
"""Retrieve a subcloud or raise if it does not exist."""
return IMPL.subcloud_get(context, subcloud_id)
def subcloud_get_with_status(context, subcloud_id):
"""Retrieve a subcloud and all endpoint sync statuses."""
return IMPL.subcloud_get_with_status(context, subcloud_id)
def subcloud_get_by_name(context, name) -> models.Subcloud:
"""Retrieve a subcloud by name or raise if it does not exist."""
return IMPL.subcloud_get_by_name(context, name)
def subcloud_get_by_region_name(context, region_name):
"""Retrieve a subcloud by region name or raise if it does not exist."""
return IMPL.subcloud_get_by_region_name(context, region_name)
def subcloud_get_by_name_or_region_name(context, name):
"""Retrieve a subcloud by name or region name or raise if it does not exist."""
return IMPL.subcloud_get_by_name_or_region_name(context, name)
def subcloud_get_all(context):
"""Retrieve all subclouds."""
return IMPL.subcloud_get_all(context)
def subcloud_get_all_ordered_by_id(context):
"""Retrieve all subclouds ordered by id."""
return IMPL.subcloud_get_all_ordered_by_id(context)
def subcloud_get_all_with_status(context):
"""Retrieve all subclouds and sync statuses."""
return IMPL.subcloud_get_all_with_status(context)
def subcloud_update(context, subcloud_id, management_state=None,
availability_status=None, software_version=None, name=None,
description=None, management_subnet=None, management_gateway_ip=None,
management_start_ip=None, management_end_ip=None,
location=None, audit_fail_count=None,
deploy_status=None, backup_status=None,
backup_datetime=None, error_description=None,
openstack_installed=None, group_id=None,
data_install=None, data_upgrade=None,
first_identity_sync_complete=None,
systemcontroller_gateway_ip=None,
rehome_data=None):
"""Update a subcloud or raise if it does not exist."""
return IMPL.subcloud_update(context, subcloud_id, management_state,
availability_status, software_version, name,
description, management_subnet, management_gateway_ip,
management_start_ip, management_end_ip, location,
audit_fail_count, deploy_status, backup_status,
backup_datetime, error_description, openstack_installed,
group_id, data_install, data_upgrade,
first_identity_sync_complete,
systemcontroller_gateway_ip, rehome_data)
def subcloud_bulk_update_by_ids(context, subcloud_ids, update_form):
"""Update subclouds in bulk using a set of subcloud IDs."""
return IMPL.subcloud_bulk_update_by_ids(context, subcloud_ids, update_form)
def subcloud_destroy(context, subcloud_id):
"""Destroy the subcloud or raise if it does not exist."""
return IMPL.subcloud_destroy(context, subcloud_id)
###################
def subcloud_status_create(context, subcloud_id, endpoint_type):
"""Create a subcloud status for an endpoint_type."""
return IMPL.subcloud_status_create(context, subcloud_id, endpoint_type)
def subcloud_status_create_all(context, subcloud_id):
"""Create a subcloud status for all endpoint_types."""
return IMPL.subcloud_status_create_all(context, subcloud_id)
def subcloud_status_delete(context, subcloud_id, endpoint_type):
"""Delete a subcloud status for an endpoint_type."""
return IMPL.subcloud_status_delete(context, subcloud_id, endpoint_type)
def subcloud_status_db_model_to_dict(subcloud_status):
"""Convert subcloud status db model to dictionary."""
if subcloud_status:
result = {"subcloud_id": subcloud_status.subcloud_id,
"sync_status": subcloud_status.sync_status}
else:
result = {"subcloud_id": 0,
"sync_status": "unknown"}
return result
def subcloud_endpoint_status_db_model_to_dict(subcloud_status):
"""Convert endpoint subcloud db model to dictionary."""
if subcloud_status:
result = {"endpoint_type": subcloud_status.endpoint_type,
"sync_status": subcloud_status.sync_status}
else:
result = {}
return result
def subcloud_status_get(context, subcloud_id, endpoint_type):
"""Retrieve the subcloud status for an endpoint
Will raise if subcloud does not exist.
"""
return IMPL.subcloud_status_get(context, subcloud_id, endpoint_type)
def subcloud_status_get_all(context, subcloud_id):
"""Retrieve all statuses for a subcloud."""
return IMPL.subcloud_status_get_all(context, subcloud_id)
def subcloud_status_get_all_by_name(context, name):
"""Retrieve all statuses for a subcloud by name."""
return IMPL.subcloud_status_get_all_by_name(context, name)
def subcloud_status_update(context, subcloud_id, endpoint_type, sync_status):
"""Update the status of a subcloud or raise if it does not exist."""
return IMPL.subcloud_status_update(context, subcloud_id, endpoint_type,
sync_status)
def subcloud_status_update_endpoints(context, subcloud_id,
endpoint_type_list, sync_status):
"""Update all statuses of the endpoints in endpoint_type_list of a subcloud."""
return IMPL.subcloud_status_update_endpoints(context, subcloud_id,
endpoint_type_list, sync_status)
def subcloud_status_destroy_all(context, subcloud_id):
"""Destroy all the statuses for a subcloud
Will raise if subcloud does not exist.
"""
return IMPL.subcloud_status_destroy_all(context, subcloud_id)
###################
# subcloud_group
def subcloud_group_db_model_to_dict(subcloud_group):
"""Convert subcloud_group db model to dictionary."""
result = {"id": subcloud_group.id,
"name": subcloud_group.name,
"description": subcloud_group.description,
"update_apply_type": subcloud_group.update_apply_type,
"max_parallel_subclouds": subcloud_group.max_parallel_subclouds,
"created-at": subcloud_group.created_at,
"updated-at": subcloud_group.updated_at}
return result
def subcloud_group_create(context, name, description, update_apply_type,
max_parallel_subclouds):
"""Create a subcloud_group."""
return IMPL.subcloud_group_create(context,
name,
description,
update_apply_type,
max_parallel_subclouds)
def subcloud_group_get(context, group_id):
"""Retrieve a subcloud_group or raise if it does not exist."""
return IMPL.subcloud_group_get(context, group_id)
def subcloud_group_get_by_name(context, name):
"""Retrieve a subcloud_group b name or raise if it does not exist."""
return IMPL.subcloud_group_get_by_name(context, name)
def subcloud_group_get_all(context):
"""Retrieve all subcloud groups."""
return IMPL.subcloud_group_get_all(context)
def subcloud_get_for_group(context, group_id):
"""Retrieve a subcloud_group or raise if it does not exist."""
return IMPL.subcloud_get_for_group(context, group_id)
def subcloud_group_update(context, group_id, name, description,
update_apply_type, max_parallel_subclouds):
"""Update the subcloud group or raise if it does not exist."""
return IMPL.subcloud_group_update(context,
group_id,
name,
description,
update_apply_type,
max_parallel_subclouds)
def subcloud_group_destroy(context, group_id):
"""Destroy the subcloud group or raise if it does not exist."""
return IMPL.subcloud_group_destroy(context, group_id)
###################
# system_peer
def system_peer_db_model_to_dict(system_peer):
"""Convert system_peer db model to dictionary."""
result = {"id": system_peer.id,
"peer-uuid": system_peer.peer_uuid,
"peer-name": system_peer.peer_name,
"manager-endpoint": system_peer.manager_endpoint,
"manager-username": system_peer.manager_username,
"peer-controller-gateway-address": system_peer.
peer_controller_gateway_ip,
"administrative-state": system_peer.administrative_state,
"heartbeat-interval": system_peer.heartbeat_interval,
"heartbeat-failure-threshold": system_peer.
heartbeat_failure_threshold,
"heartbeat-failure-policy": system_peer.heartbeat_failure_policy,
"heartbeat-maintenance-timeout": system_peer.
heartbeat_maintenance_timeout,
"created-at": system_peer.created_at,
"updated-at": system_peer.updated_at}
return result
def system_peer_create(context,
peer_uuid, peer_name,
endpoint, username, password,
gateway_ip,
administrative_state,
heartbeat_interval,
heartbeat_failure_threshold,
heartbeat_failure_policy,
heartbeat_maintenance_timeout):
"""Create a system_peer."""
return IMPL.system_peer_create(context,
peer_uuid, peer_name,
endpoint, username, password,
gateway_ip,
administrative_state,
heartbeat_interval,
heartbeat_failure_threshold,
heartbeat_failure_policy,
heartbeat_maintenance_timeout)
def system_peer_get(context, peer_id):
"""Retrieve a system_peer or raise if it does not exist."""
return IMPL.system_peer_get(context, peer_id)
def system_peer_get_by_uuid(context, uuid):
"""Retrieve a system_peer by uuid or raise if it does not exist."""
return IMPL.system_peer_get_by_uuid(context, uuid)
def system_peer_get_by_name(context, uuid):
"""Retrieve a system_peer by name or raise if it does not exist."""
return IMPL.system_peer_get_by_name(context, uuid)
def system_peer_get_all(context):
"""Retrieve all system peers."""
return IMPL.system_peer_get_all(context)
def system_peer_update(context, peer_id,
peer_uuid, peer_name,
endpoint, username, password,
gateway_ip,
administrative_state,
heartbeat_interval,
heartbeat_failure_threshold,
heartbeat_failure_policy,
heartbeat_maintenance_timeout):
"""Update the system peer or raise if it does not exist."""
return IMPL.system_peer_update(context, peer_id,
peer_uuid, peer_name,
endpoint, username, password,
gateway_ip,
administrative_state,
heartbeat_interval,
heartbeat_failure_threshold,
heartbeat_failure_policy,
heartbeat_maintenance_timeout)
def system_peer_destroy(context, peer_id):
"""Destroy the system peer or raise if it does not exist."""
return IMPL.system_peer_destroy(context, peer_id)
###################
def sw_update_strategy_db_model_to_dict(sw_update_strategy):
"""Convert sw update db model to dictionary."""
result = {"id": sw_update_strategy.id,
"type": sw_update_strategy.type,
"subcloud-apply-type": sw_update_strategy.subcloud_apply_type,
"max-parallel-subclouds":
sw_update_strategy.max_parallel_subclouds,
"stop-on-failure": sw_update_strategy.stop_on_failure,
"state": sw_update_strategy.state,
"created-at": sw_update_strategy.created_at,
"updated-at": sw_update_strategy.updated_at,
"extra-args": sw_update_strategy.extra_args}
return result
def sw_update_strategy_create(context, type, subcloud_apply_type,
max_parallel_subclouds, stop_on_failure, state,
extra_args=None):
"""Create a sw update."""
return IMPL.sw_update_strategy_create(context, type, subcloud_apply_type,
max_parallel_subclouds,
stop_on_failure, state,
extra_args=extra_args)
def sw_update_strategy_get(context, update_type=None):
"""Retrieve a sw update or raise if it does not exist."""
return IMPL.sw_update_strategy_get(context, update_type=update_type)
def sw_update_strategy_update(context, state=None,
update_type=None, additional_args=None):
"""Update a sw update or raise if it does not exist."""
return IMPL.sw_update_strategy_update(context,
state,
update_type=update_type,
additional_args=additional_args)
def sw_update_strategy_destroy(context, update_type=None):
"""Destroy the sw update or raise if it does not exist."""
return IMPL.sw_update_strategy_destroy(context, update_type=update_type)
###################
def strategy_step_db_model_to_dict(strategy_step):
"""Convert patch strategy db model to dictionary."""
if strategy_step.subcloud is not None:
cloud = strategy_step.subcloud.name
else:
cloud = dccommon_consts.SYSTEM_CONTROLLER_NAME
result = {"id": strategy_step.id,
"cloud": cloud,
"stage": strategy_step.stage,
"state": strategy_step.state,
"details": strategy_step.details,
"started-at": strategy_step.started_at,
"finished-at": strategy_step.finished_at,
"created-at": strategy_step.created_at,
"updated-at": strategy_step.updated_at}
return result
def strategy_step_get(context, subcloud_id):
"""Retrieve the patch strategy step for a subcloud ID.
Will raise if subcloud does not exist.
"""
return IMPL.strategy_step_get(context, subcloud_id)
def strategy_step_get_by_name(context, name):
"""Retrieve the patch strategy step for a subcloud name."""
return IMPL.strategy_step_get_by_name(context, name)
def strategy_step_get_all(context):
"""Retrieve all patch strategy steps."""
return IMPL.strategy_step_get_all(context)
def strategy_step_create(context, subcloud_id, stage, state, details):
"""Create a patch strategy step."""
return IMPL.strategy_step_create(context, subcloud_id, stage, state,
details)
def strategy_step_update(context, subcloud_id, stage=None, state=None,
details=None, started_at=None, finished_at=None):
"""Update a patch strategy step or raise if it does not exist."""
return IMPL.strategy_step_update(context, subcloud_id, stage, state,
details, started_at, finished_at)
def strategy_step_destroy_all(context):
"""Destroy all the patch strategy steps."""
return IMPL.strategy_step_destroy_all(context)
###################
def sw_update_opts_w_name_db_model_to_dict(sw_update_opts, subcloud_name):
"""Convert sw update options db model plus subcloud name to dictionary."""
result = {"id": sw_update_opts.id,
"name": subcloud_name,
"subcloud-id": sw_update_opts.subcloud_id,
"storage-apply-type": sw_update_opts.storage_apply_type,
"worker-apply-type": sw_update_opts.worker_apply_type,
"max-parallel-workers": sw_update_opts.max_parallel_workers,
"alarm-restriction-type": sw_update_opts.alarm_restriction_type,
"default-instance-action":
sw_update_opts.default_instance_action,
"created-at": sw_update_opts.created_at,
"updated-at": sw_update_opts.updated_at}
return result
def sw_update_opts_create(context, subcloud_id, storage_apply_type,
worker_apply_type, max_parallel_workers,
alarm_restriction_type, default_instance_action):
"""Create sw update options."""
return IMPL.sw_update_opts_create(context, subcloud_id,
storage_apply_type,
worker_apply_type,
max_parallel_workers,
alarm_restriction_type,
default_instance_action)
def sw_update_opts_get(context, subcloud_id):
"""Retrieve sw update options."""
return IMPL.sw_update_opts_get(context, subcloud_id)
def sw_update_opts_get_all_plus_subcloud_info(context):
"""Retrieve sw update options plus subcloud info."""
return IMPL.sw_update_opts_get_all_plus_subcloud_info(context)
def sw_update_opts_update(context, subcloud_id,
storage_apply_type=None,
worker_apply_type=None,
max_parallel_workers=None,
alarm_restriction_type=None,
default_instance_action=None):
"""Update sw update options or raise if it does not exist."""
return IMPL.sw_update_opts_update(context, subcloud_id,
storage_apply_type,
worker_apply_type,
max_parallel_workers,
alarm_restriction_type,
default_instance_action)
def sw_update_opts_destroy(context, subcloud_id):
"""Destroy sw update options or raise if it does not exist."""
return IMPL.sw_update_opts_destroy(context, subcloud_id)
###################
def sw_update_opts_default_create(context, storage_apply_type,
worker_apply_type, max_parallel_workers,
alarm_restriction_type,
default_instance_action):
"""Create default sw update options."""
return IMPL.sw_update_opts_default_create(context,
storage_apply_type,
worker_apply_type,
max_parallel_workers,
alarm_restriction_type,
default_instance_action)
def sw_update_opts_default_get(context):
"""Retrieve default sw update options."""
return IMPL.sw_update_opts_default_get(context)
def sw_update_opts_default_update(context,
storage_apply_type=None,
worker_apply_type=None,
max_parallel_workers=None,
alarm_restriction_type=None,
default_instance_action=None):
"""Update default sw update options."""
return IMPL.sw_update_opts_default_update(context,
storage_apply_type,
worker_apply_type,
max_parallel_workers,
alarm_restriction_type,
default_instance_action)
def sw_update_opts_default_destroy(context):
"""Destroy the default sw update options or raise if it does not exist."""
return IMPL.sw_update_opts_default_destroy(context)
###################
def db_sync(engine, version=None):
"""Migrate the database to `version` or the most recent version."""
return IMPL.db_sync(engine, version=version)
def db_version(engine):
"""Display the current database version."""
return IMPL.db_version(engine)
# Alarm Resources
###################
def subcloud_alarms_get(context, name):
return IMPL.subcloud_alarms_get(context, name)
def subcloud_alarms_get_all(context, name=None):
return IMPL.subcloud_alarms_get_all(context, name=name)
def subcloud_alarms_create(context, name, values):
return IMPL.subcloud_alarms_create(context, name, values)
def subcloud_alarms_update(context, name, values):
return IMPL.subcloud_alarms_update(context, name, values)
def subcloud_alarms_delete(context, name):
return IMPL.subcloud_alarms_delete(context, name)
def subcloud_rename_alarms(context, subcloud_name, new_name):
return IMPL.subcloud_rename_alarms(context, subcloud_name, new_name)
View Git Blame Copy Permalink