4027eee390
System peer monitoring and handling:
It does peer health check by querying peer group list.
After failure is detected and the number of heartbeat
failure reaches the threshold, alarm will be raised.
After connection is back online, alarm will be cleared,
and will perform an audit to the peer groups that are associated
to the system peer.
Subcloud peer group audit and handling:
If the remote peer group's migration_status is in the 'migrating'
state, unmanage the subclouds of the local peer group.
If the remote peer group's migration_status is in the 'complete'
state, compare the subclouds on both ends.
If the remote end is in a 'managed+online' state,
set the local subclouds with the same region_name to
'unmanaged+secondary.'
If the remote peer group's migration_status is in the 'none' state,
set the migration_status of the local peer group to 'none' as well.
Batch rehome update:
When Subcloud Peer Group based batch rehoming is performed,
need to check if the associated System Peer is alive or not:
If yes, and the remote subcloud with same region_name is
being managed in peer site, need to unmanage it before
rehoming it to local site.
If not, this means the peer site is not available for the
subcloud management any more, rehoming can be performed
directly.
If the subcloud peer group priority is 0, will try to clear alarm
of FM_ALARM_ID_DC_SUBCLOUD_PEER_GROUP_NOT_MANAGED
after batch rehoming is complete.
Security enhancement:
Base64 encode/decode admin_password when save/load rehome_data
from DB.
Test Plan:
1. PASS - Add a system peer on DC0, unplug the OAM network
between DC0 and DC1. Alarm raised.
2. PASS - Reconnect the OAM network between DC0 and DC1,
previous alarm will be cleared.
3. PASS - Add a subcloud peer group on DC0.
Add two subclouds on DC0 under the subcloud peer group.
which should be in managed, online and complete states.
Add a system peer on DC0 pointing to DC1,
Add a peer-group-association associating the peer-group
and the system-peer above on DC0.
create another association in DC1, for system DC0 and the
peer group synced to DC1.
Shutdown DC0, perform the migrate operation on
subcloud-peer-group from DC1, after all subclouds have
been migrated and entered online managed states.
Power on DC0, check alarm like "Subcloud peer group
xxx is managed by remote system (peer_uuid=xxx) with
lower priority." has been raised.
Check the subcloud state on DC0, should be in 'secondary' state,
Perform the migrate operation on subcloud-peer-group from DC0.
After all subclouds have been migrated and entered online
managed states. Alarm is cleared.
Check subclouds on DC1, subcloud state should be in secondary state.
4.PASS - Migrate a subcloud peer group with 0 priority,
Before migrate, check alarm
FM_ALARM_ID_DC_SUBCLOUD_PEER_GROUP_NOT_MANAGED
exists.
After migration done, check alarm cleared.
5. PASS - When the remote peer group's migration_status is in the
'migrating' state (if DC0 comes back online while rehoming
is still in progress); DC0's subcloud will be auto set to 'unmanaged',
after DC1's migration is complete and all subcloud in 'managed+online',
DC0's subcloud will auto set to 'secondary'.
Story: 2010852
Task: 48483
Task: 48509
Task: 48819
Change-Id: Ic97e7c4a7628445522adfba4b0b2e0cc945cbe22
Signed-off-by: Wang Tao <tao.wang@windriver.com>
857 lines
34 KiB
Python
857 lines
34 KiB
Python
# 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,
|
|
"peer_group_id": subcloud.peer_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,
|
|
peer_group_id=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, peer_group_id, 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,
|
|
"heartbeat-status": system_peer.heartbeat_status,
|
|
"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 peer_group_get_for_system_peer(context, peer_id):
|
|
"""Get subcloud peer groups associated with a system peer."""
|
|
return IMPL.peer_group_get_for_system_peer(context, peer_id)
|
|
|
|
|
|
def system_peer_update(context, peer_id,
|
|
peer_uuid=None, peer_name=None,
|
|
endpoint=None, username=None, password=None,
|
|
gateway_ip=None,
|
|
administrative_state=None,
|
|
heartbeat_interval=None,
|
|
heartbeat_failure_threshold=None,
|
|
heartbeat_failure_policy=None,
|
|
heartbeat_maintenance_timeout=None,
|
|
heartbeat_status=None):
|
|
"""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,
|
|
heartbeat_status)
|
|
|
|
|
|
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)
|
|
###################
|
|
|
|
|
|
###################
|
|
# subcloud_peer_group
|
|
def subcloud_peer_group_db_model_to_dict(subcloud_peer_group):
|
|
"""Convert subcloud_peer_group db model to dictionary."""
|
|
result = {"id": subcloud_peer_group.id,
|
|
"peer_group_name": subcloud_peer_group.peer_group_name,
|
|
"group_priority": subcloud_peer_group.group_priority,
|
|
"group_state": subcloud_peer_group.group_state,
|
|
"max_subcloud_rehoming": subcloud_peer_group.max_subcloud_rehoming,
|
|
"system_leader_id": subcloud_peer_group.system_leader_id,
|
|
"system_leader_name": subcloud_peer_group.system_leader_name,
|
|
"migration_status": subcloud_peer_group.migration_status,
|
|
"created-at": subcloud_peer_group.created_at,
|
|
"updated-at": subcloud_peer_group.updated_at}
|
|
return result
|
|
|
|
|
|
def subcloud_peer_group_create(context, peer_group_name, group_priority,
|
|
group_state, max_subcloud_rehoming,
|
|
system_leader_id, system_leader_name,
|
|
migration_status=None):
|
|
"""Create a subcloud_peer_group."""
|
|
return IMPL.subcloud_peer_group_create(context,
|
|
peer_group_name,
|
|
group_priority,
|
|
group_state,
|
|
max_subcloud_rehoming,
|
|
system_leader_id,
|
|
system_leader_name,
|
|
migration_status)
|
|
|
|
|
|
def subcloud_peer_group_destroy(context, group_id):
|
|
"""Destroy the subcloud peer group or raise if it does not exist."""
|
|
return IMPL.subcloud_peer_group_destroy(context, group_id)
|
|
|
|
|
|
def subcloud_peer_group_get(context, group_id):
|
|
"""Retrieve a subcloud_peer_group or raise if it does not exist."""
|
|
return IMPL.subcloud_peer_group_get(context, group_id)
|
|
|
|
|
|
def subcloud_peer_group_get_by_name(context, name):
|
|
"""Retrieve a subcloud_peer_group by name or raise if it does not exist."""
|
|
return IMPL.subcloud_peer_group_get_by_name(context, name)
|
|
|
|
|
|
def subcloud_peer_group_get_by_leader_id(context, system_leader_id):
|
|
"""Retrieve subcloud peer groups by system_leader_id."""
|
|
return IMPL.subcloud_peer_group_get_by_leader_id(context, system_leader_id)
|
|
|
|
|
|
def subcloud_get_for_peer_group(context, group_id):
|
|
"""Retrieve all subclouds belonging to a subcloud_peer_group
|
|
|
|
or raise if it does not exist.
|
|
"""
|
|
return IMPL.subcloud_get_for_peer_group(context, group_id)
|
|
|
|
|
|
def subcloud_peer_group_get_all(context):
|
|
"""Retrieve all subcloud peer groups."""
|
|
return IMPL.subcloud_peer_group_get_all(context)
|
|
|
|
|
|
def subcloud_peer_group_update(context, group_id, peer_group_name=None,
|
|
group_priority=None, group_state=None,
|
|
max_subcloud_rehoming=None,
|
|
system_leader_id=None,
|
|
system_leader_name=None,
|
|
migration_status=None):
|
|
"""Update the subcloud peer group or raise if it does not exist."""
|
|
return IMPL.subcloud_peer_group_update(context,
|
|
group_id,
|
|
peer_group_name,
|
|
group_priority,
|
|
group_state,
|
|
max_subcloud_rehoming,
|
|
system_leader_id,
|
|
system_leader_name,
|
|
migration_status)
|
|
###################
|
|
|
|
|
|
###################
|
|
# peer_group_association
|
|
def peer_group_association_db_model_to_dict(peer_group_association):
|
|
"""Convert peer_group_association db model to dictionary."""
|
|
result = {"id": peer_group_association.id,
|
|
"peer-group-id": peer_group_association.peer_group_id,
|
|
"system-peer-id": peer_group_association.system_peer_id,
|
|
"peer-group-priority": peer_group_association.peer_group_priority,
|
|
"sync-status": peer_group_association.sync_status,
|
|
"sync-message": peer_group_association.sync_message,
|
|
"created-at": peer_group_association.created_at,
|
|
"updated-at": peer_group_association.updated_at}
|
|
return result
|
|
|
|
|
|
def peer_group_association_create(context, peer_group_id, system_peer_id,
|
|
peer_group_priority, sync_status=None,
|
|
sync_message=None):
|
|
"""Create a peer_group_association."""
|
|
return IMPL.peer_group_association_create(context,
|
|
peer_group_id,
|
|
system_peer_id,
|
|
peer_group_priority,
|
|
sync_status,
|
|
sync_message)
|
|
|
|
|
|
def peer_group_association_update(context, id, peer_group_priority=None,
|
|
sync_status=None, sync_message=None):
|
|
"""Update the system peer or raise if it does not exist."""
|
|
return IMPL.peer_group_association_update(context, id, peer_group_priority,
|
|
sync_status, sync_message)
|
|
|
|
|
|
def peer_group_association_destroy(context, id):
|
|
"""Destroy the peer_group_association or raise if it does not exist."""
|
|
return IMPL.peer_group_association_destroy(context, id)
|
|
|
|
|
|
def peer_group_association_get(context, id):
|
|
"""Retrieve a peer_group_association or raise if it does not exist."""
|
|
return IMPL.peer_group_association_get(context, id)
|
|
|
|
|
|
def peer_group_association_get_all(context):
|
|
"""Retrieve all peer_group_associations."""
|
|
return IMPL.peer_group_association_get_all(context)
|
|
|
|
|
|
def peer_group_association_get_by_peer_group_and_system_peer_id(context,
|
|
peer_group_id,
|
|
system_peer_id):
|
|
"""Get peer group associations by peer_group_id and system_peer_id."""
|
|
return IMPL.peer_group_association_get_by_peer_group_and_system_peer_id(
|
|
context, peer_group_id, system_peer_id)
|
|
|
|
|
|
def peer_group_association_get_by_peer_group_id(context, peer_group_id):
|
|
"""Get the peer_group_association list by peer_group_id"""
|
|
return IMPL.peer_group_association_get_by_peer_group_id(context,
|
|
peer_group_id)
|
|
|
|
|
|
def peer_group_association_get_by_system_peer_id(context, system_peer_id):
|
|
"""Get the peer_group_association list by system_peer_id"""
|
|
return IMPL.peer_group_association_get_by_system_peer_id(context,
|
|
system_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)
|