7f156476f9
In this commit:
- completed orch request is soft deleted right away.
- failed orch requests that have not been soft deleted
are soft deleted at the end of the next audit cycle.
- prior to a sync run, if the managed subcloud has any
queued, in-progress, and/or failed requests, its
sync status will be set to out-of-sync.
- a cron job that runs 20 minutes in the first hour
daily (another commit in stx-puppet repo) will purge
all soft deleted orch requests that are 3 days old,
their orch jobs and resources.
Tests:
- Identity and platform config changes with and
without proxy.
- Database inspection after config changes and after
soak.
- Purge of large number of orch requests, orch jobs
and resources.
Story: 2007267
Task: 39044
Change-Id: If5c75b9af3e1e20c010308919cb6be8f11575546
Signed-off-by: Tee Ngo <tee.ngo@windriver.com>
311 lines
9.5 KiB
Python
311 lines
9.5 KiB
Python
# Copyright (c) 2015 Ericsson AB.
|
|
# 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.
|
|
#
|
|
# Copyright (c) 2020 Wind River Systems, Inc.
|
|
#
|
|
"""
|
|
Interface for database access.
|
|
|
|
SQLAlchemy is currently the only supported backend.
|
|
"""
|
|
|
|
from oslo_config import cfg
|
|
from oslo_db import api
|
|
|
|
CONF = cfg.CONF
|
|
|
|
_BACKEND_MAPPING = {'sqlalchemy': 'dcorch.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()
|
|
|
|
|
|
# quota usage db methods
|
|
|
|
###################
|
|
|
|
|
|
def quota_create(context, project_id, resource, limit):
|
|
"""Create a quota for the given project and resource."""
|
|
return IMPL.quota_create(context, project_id, resource, limit)
|
|
|
|
|
|
def quota_get(context, project_id, resource):
|
|
"""Retrieve a quota or raise if it does not exist."""
|
|
return IMPL.quota_get(context, project_id, resource)
|
|
|
|
|
|
def quota_get_all_by_project(context, project_id):
|
|
"""Retrieve all quotas associated with a given project."""
|
|
return IMPL.quota_get_all_by_project(context, project_id)
|
|
|
|
|
|
def quota_update(context, project_id, resource, limit):
|
|
"""Update a quota or raise if it does not exist."""
|
|
return IMPL.quota_update(context, project_id, resource, limit)
|
|
|
|
|
|
def quota_destroy(context, project_id, resource):
|
|
"""Destroy the quota or raise if it does not exist."""
|
|
return IMPL.quota_destroy(context, project_id, resource)
|
|
|
|
|
|
def quota_destroy_all(context, project_id):
|
|
"""Destroy the quota or raise if it does not exist."""
|
|
return IMPL.quota_destroy(context, project_id)
|
|
|
|
|
|
def quota_class_get(context, class_name, resource):
|
|
"""Retrieve quota from the given quota class."""
|
|
return IMPL.quota_class_get(context, class_name, resource)
|
|
|
|
|
|
def quota_class_get_default(context):
|
|
"""Get default class quotas."""
|
|
return IMPL.quota_class_get_default(context)
|
|
|
|
|
|
def quota_class_get_all_by_name(context, class_name):
|
|
"""Get all quota limits for a specified class."""
|
|
return IMPL.quota_class_get_all_by_name(context, class_name)
|
|
|
|
|
|
def quota_class_create(context, class_name, resource, limit):
|
|
"""Create a new quota limit in a specified class."""
|
|
return IMPL.quota_class_create(context, class_name, resource, limit)
|
|
|
|
|
|
def quota_class_destroy_all(context, class_name):
|
|
"""Destroy all quotas for class."""
|
|
return IMPL.quota_class_destroy_all(context, class_name)
|
|
|
|
|
|
def quota_class_update(context, class_name, resource, limit):
|
|
"""Update a quota or raise if it doesn't exist."""
|
|
return IMPL.quota_class_update(context, class_name, resource, limit)
|
|
|
|
|
|
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)
|
|
|
|
|
|
def service_create(context, service_id, host=None, binary=None,
|
|
topic=None):
|
|
return IMPL.service_create(context, service_id=service_id, host=host,
|
|
binary=binary, topic=topic)
|
|
|
|
|
|
def service_update(context, service_id, values=None):
|
|
return IMPL.service_update(context, service_id, values=values)
|
|
|
|
|
|
def service_delete(context, service_id):
|
|
return IMPL.service_delete(context, service_id)
|
|
|
|
|
|
def service_get(context, service_id):
|
|
return IMPL.service_get(context, service_id)
|
|
|
|
|
|
def service_get_all(context):
|
|
return IMPL.service_get_all(context)
|
|
|
|
|
|
def subcloud_get(context, region_id):
|
|
return IMPL.subcloud_get(context, region_id)
|
|
|
|
|
|
def subcloud_get_all(context, region_name=None,
|
|
management_state=None,
|
|
availability_status=None,
|
|
initial_sync_state=None):
|
|
return IMPL.subcloud_get_all(context, region_name=region_name,
|
|
management_state=management_state,
|
|
availability_status=availability_status,
|
|
initial_sync_state=initial_sync_state)
|
|
|
|
|
|
def subcloud_create(context, region_name, values):
|
|
return IMPL.subcloud_create(context, region_name, values)
|
|
|
|
|
|
def subcloud_update(context, region_name, values):
|
|
return IMPL.subcloud_update(context, region_name, values)
|
|
|
|
|
|
def subcloud_delete(context, region_name):
|
|
return IMPL.subcloud_delete(context, region_name)
|
|
|
|
|
|
def resource_get_by_type_and_master_id(context, resource_type, master_id):
|
|
return IMPL.resource_get_by_type_and_master_id(
|
|
context, resource_type, master_id)
|
|
|
|
|
|
def resource_get_by_id(context, id):
|
|
return IMPL.resource_get_by_id(context, id)
|
|
|
|
|
|
def resource_get_all(context, resource_type=None):
|
|
return IMPL.resource_get_all(context, resource_type=resource_type)
|
|
|
|
|
|
def resource_create(context, resource_type, values):
|
|
return IMPL.resource_create(context, resource_type, values)
|
|
|
|
|
|
def resource_update(context, resource_type, values):
|
|
return IMPL.resource_update(context, resource_type, values)
|
|
|
|
|
|
def resource_delete(context, resource_type, master_id):
|
|
return IMPL.resource_delete(context, resource_type, master_id)
|
|
|
|
|
|
def add_subcloud_resource_filter_by_subcloud(query, value):
|
|
return IMPL.add_subcloud_resource_filter_by_subcloud(query, value)
|
|
|
|
|
|
def subcloud_resource_get(context, subcloud_resource_id):
|
|
return IMPL.subcloud_resource_get(context, subcloud_resource_id)
|
|
|
|
|
|
def subcloud_resources_get_by_subcloud(context, subcloud_id):
|
|
return IMPL.subcloud_resources_get_by_subcloud(context, subcloud_id)
|
|
|
|
|
|
def subcloud_resources_get_by_resource(context, resource_id):
|
|
return IMPL.subcloud_resources_get_by_resource(context, resource_id)
|
|
|
|
|
|
def subcloud_resource_get_by_resource_and_subcloud(
|
|
context, resource_id, subcloud_id):
|
|
return IMPL.subcloud_resource_get_by_resource_and_subcloud(
|
|
context, resource_id, subcloud_id)
|
|
|
|
|
|
def subcloud_resources_get_all(context):
|
|
return IMPL.subcloud_resources_get_all(context)
|
|
|
|
|
|
def subcloud_resource_create(context, subcloud_id, resource_id, values):
|
|
return IMPL.subcloud_resource_create(context,
|
|
subcloud_id, resource_id, values)
|
|
|
|
|
|
def subcloud_resource_update(context, subcloud_resource_id, values):
|
|
return IMPL.subcloud_resource_update(context,
|
|
subcloud_resource_id, values)
|
|
|
|
|
|
def subcloud_resource_delete(context, subcloud_resource_id):
|
|
return IMPL.subcloud_resource_delete(context, subcloud_resource_id)
|
|
|
|
|
|
def orch_job_get(context, orch_job_id):
|
|
return IMPL.orch_job_get(context, orch_job_id)
|
|
|
|
|
|
def orch_job_get_all(context, resource_id=None):
|
|
return IMPL.orch_job_get_all(context, resource_id=resource_id)
|
|
|
|
|
|
def orch_job_create(context, resource_id, endpoint_type,
|
|
operation_type, values):
|
|
return IMPL.orch_job_create(context, resource_id, endpoint_type,
|
|
operation_type, values)
|
|
|
|
|
|
def orch_job_update(context, orch_job_id, values):
|
|
return IMPL.orch_job_update(context, orch_job_id, values)
|
|
|
|
|
|
def orch_job_delete(context, orch_job_id):
|
|
return IMPL.orch_job_delete(context, orch_job_id)
|
|
|
|
|
|
def orch_request_get(context, orch_request_id):
|
|
return IMPL.orch_request_get(context, orch_request_id)
|
|
|
|
|
|
def orch_request_get_most_recent_failed_request(context):
|
|
return IMPL.orch_request_get_most_recent_failed_request(context)
|
|
|
|
|
|
def orch_request_get_all(context, orch_job_id=None):
|
|
return IMPL.orch_request_get_all(context, orch_job_id=orch_job_id)
|
|
|
|
|
|
def orch_request_get_by_attrs(context,
|
|
endpoint_type,
|
|
resource_type=None,
|
|
target_region_name=None,
|
|
states=None):
|
|
"""Query OrchRequests by attributes.
|
|
|
|
:param context: authorization context
|
|
:param endpoint_type: OrchJob.endpoint_type
|
|
:param resource_type: Resource.resource_type
|
|
:param target_region_name: OrchRequest target_region_name
|
|
:param states: [OrchRequest.state] must be a list
|
|
:return: [OrchRequests] sorted by OrchRequest.id
|
|
"""
|
|
return IMPL.orch_request_get_by_attrs(
|
|
context,
|
|
endpoint_type,
|
|
resource_type=resource_type,
|
|
target_region_name=target_region_name,
|
|
states=states)
|
|
|
|
|
|
def orch_request_create(context, orch_job_id, target_region_name, values):
|
|
return IMPL.orch_request_create(context, orch_job_id,
|
|
target_region_name, values)
|
|
|
|
|
|
def orch_request_update(context, orch_request_id, values):
|
|
return IMPL.orch_request_update(context, orch_request_id, values)
|
|
|
|
|
|
def orch_request_destroy(context, orch_request_id):
|
|
return IMPL.orch_request_destroy(context, orch_request_id)
|
|
|
|
|
|
def orch_request_delete_by_subcloud(context, region_name):
|
|
return IMPL.orch_request_delete_by_subcloud(context, region_name)
|
|
|
|
|
|
def orch_request_delete_previous_failed_requests(context, delete_timestamp):
|
|
return IMPL.orch_request_delete_previous_failed_requests(
|
|
context, delete_timestamp)
|
|
|
|
|
|
# Periodic cleanup
|
|
def purge_deleted_records(context, age_in_days=1):
|
|
return IMPL.purge_deleted_records(context, age_in_days)
|