# Copyright (c) 2015 Ericsson AB.
# Copyright (c) 2017-2021 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.
#


"""
Implementation of SQLAlchemy backend.
"""

import datetime
import sys
import threading

from oslo_db import api as oslo_db_api
from oslo_db import exception as db_exc
from oslo_db.sqlalchemy import enginefacade

from oslo_log import log as logging
from oslo_utils import strutils
from oslo_utils import timeutils
from oslo_utils import uuidutils

from sqlalchemy import asc
from sqlalchemy import desc
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm.exc import MultipleResultsFound
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy.orm import joinedload_all

from dcorch.common import consts
from dcorch.common import exceptions as exception
from dcorch.common.i18n import _
from dcorch.db.sqlalchemy import migration
from dcorch.db.sqlalchemy import models

LOG = logging.getLogger(__name__)

_facade = None

_main_context_manager = None
_CONTEXT = threading.local()


def _get_main_context_manager():
    global _main_context_manager
    if not _main_context_manager:
        _main_context_manager = enginefacade.transaction_context()
    return _main_context_manager


def get_engine():
    return _get_main_context_manager().get_legacy_facade().get_engine()


def get_session():
    return _get_main_context_manager().get_legacy_facade().get_session()


def read_session():
    return _get_main_context_manager().reader.using(_CONTEXT)


def write_session():
    return _get_main_context_manager().writer.using(_CONTEXT)


_DEFAULT_QUOTA_NAME = 'default'


def get_backend():
    """The backend is this module itself."""
    return sys.modules[__name__]


def model_query(context, *args, **kwargs):
    session = kwargs.get('session')
    if session:
        return session.query(*args).options(joinedload_all('*'))
    else:
        with read_session() as session:
            return session.query(*args).options(joinedload_all('*'))


def _session(context):
    return get_session()


def is_admin_context(context):
    """Indicate if the request context is an administrator."""
    if not context:
        LOG.warning(_('Use of empty request context is deprecated'),
                    DeprecationWarning)
        raise Exception('die')
    return context.is_admin


def is_user_context(context):
    """Indicate if the request context is a normal user."""
    if not context:
        return False
    if context.is_admin:
        return False
    if not context.user or not context.project:
        return False
    return True


def require_admin_context(f):
    """Decorator to require admin request context.

    The first argument to the wrapped function must be the context.
    """
    def wrapper(*args, **kwargs):
        if not is_admin_context(args[0]):
            raise exception.AdminRequired()
        return f(*args, **kwargs)

    return wrapper


def require_context(f):
    """Decorator to require *any* user or admin context.

    This does no authorization for user or project access matching, see
    :py:func:`authorize_project_context` and
    :py:func:`authorize_user_context`.
    The first argument to the wrapped function must be the context.

    """
    def wrapper(*args, **kwargs):
        if not is_admin_context(args[0]) and not is_user_context(args[0]):
            raise exception.NotAuthorized()
        return f(*args, **kwargs)

    return wrapper


###################


@require_context
def _quota_get(context, project_id, resource, session=None):
    result = model_query(context, models.Quota). \
        filter_by(project_id=project_id). \
        filter_by(resource=resource). \
        first()

    if not result:
        raise exception.ProjectQuotaNotFound(project_id=project_id)

    return result


@require_context
def quota_get(context, project_id, resource):
    return _quota_get(context, project_id, resource)


@require_context
def quota_get_all_by_project(context, project_id):
    rows = model_query(context, models.Quota). \
        filter_by(project_id=project_id). \
        all()
    result = {'project_id': project_id}
    for row in rows:
        result[row.resource] = row.hard_limit
    return result


@require_admin_context
def quota_create(context, project_id, resource, limit):
    with write_session() as session:
        quota_ref = models.Quota()
        quota_ref.project_id = project_id
        quota_ref.resource = resource
        quota_ref.hard_limit = limit
        session.add(quota_ref)
        return quota_ref


@require_admin_context
def quota_update(context, project_id, resource, limit):
    with write_session() as session:
        quota_ref = _quota_get(context, project_id, resource, session=session)
        if not quota_ref:
            raise exception.ProjectQuotaNotFound(project_id=project_id)
        quota_ref.hard_limit = limit
        quota_ref.save(session)
        return quota_ref


@require_admin_context
def quota_destroy(context, project_id, resource):
    with write_session() as session:
        quota_ref = _quota_get(context, project_id, resource, session=session)
        if not quota_ref:
            raise exception.ProjectQuotaNotFound(project_id=project_id)
        session.delete(quota_ref)


@require_admin_context
def quota_destroy_all(context, project_id):
    with write_session() as session:

        quotas = model_query(context, models.Quota). \
            filter_by(project_id=project_id). \
            all()

        if not quotas:
            raise exception.ProjectQuotaNotFound(project_id=project_id)

        for quota_ref in quotas:
            session.delete(quota_ref)


##########################

@require_context
def _quota_class_get(context, class_name, resource):
    result = model_query(context, models.QuotaClass). \
        filter_by(deleted=0). \
        filter_by(class_name=class_name). \
        filter_by(resource=resource). \
        first()

    if not result:
        raise exception.QuotaClassNotFound(class_name=class_name)

    return result


@require_context
def quota_class_get(context, class_name, resource):
    return _quota_class_get(context, class_name, resource)


@require_context
def quota_class_get_default(context):
    return quota_class_get_all_by_name(context, _DEFAULT_QUOTA_NAME)


@require_context
def quota_class_get_all_by_name(context, class_name):
    rows = model_query(context, models.QuotaClass). \
        filter_by(deleted=0). \
        filter_by(class_name=class_name). \
        all()

    result = {'class_name': class_name}
    for row in rows:
        result[row.resource] = row.hard_limit

    return result


@require_admin_context
def quota_class_create(context, class_name, resource, limit):
    with write_session() as session:
        quota_class_ref = models.QuotaClass()
        quota_class_ref.class_name = class_name
        quota_class_ref.resource = resource
        quota_class_ref.hard_limit = limit
        session.add(quota_class_ref)
        return quota_class_ref


@require_admin_context
def quota_class_update(context, class_name, resource, limit):
    with write_session() as session:
        quota_class_ref = session.query(models.QuotaClass). \
            filter_by(deleted=0). \
            filter_by(class_name=class_name). \
            filter_by(resource=resource).first()
        if not quota_class_ref:
            raise exception.QuotaClassNotFound(class_name=class_name)
        quota_class_ref.hard_limit = limit
        quota_class_ref.save(session)
        return quota_class_ref


@require_admin_context
def quota_class_destroy_all(context, class_name):
    with write_session() as session:
        quota_classes = session.query(models.QuotaClass). \
            filter_by(deleted=0). \
            filter_by(class_name=class_name). \
            all()
        if quota_classes:
            for quota_class_ref in quota_classes:
                session.delete(quota_class_ref)
        else:
            raise exception.QuotaClassNotFound()


def db_sync(engine, version=None):
    """Migrate the database to `version` or the most recent version."""
    return migration.db_sync(engine, version=version)


def db_version(engine):
    """Display the current database version."""
    return migration.db_version(engine)


def service_create(context, service_id, host=None, binary=None,
                   topic=None):
    with write_session() as session:
        time_now = timeutils.utcnow()
        svc = models.Service(id=service_id,
                             host=host,
                             binary=binary,
                             topic=topic,
                             created_at=time_now,
                             updated_at=time_now)
        session.add(svc)
        return svc


def service_update(context, service_id, values=None):
    with write_session() as session:
        service = session.query(models.Service).get(service_id)
        if not service:
            return

        if values is None:
            values = {}

        values.update({'updated_at': timeutils.utcnow()})
        service.update(values)
        service.save(session)
        return service


def service_delete(context, service_id):
    with write_session() as session:
        session.query(models.Service).filter_by(
            id=service_id).delete(synchronize_session='fetch')


def service_get(context, service_id):
    return model_query(context, models.Service).get(service_id)


def service_get_all(context):
    return model_query(context, models.Service).all()


##########################

# dbapi for orchestrator
def add_identity_filter(query, value,
                        use_region_name=None,
                        use_resource_type=None):
    """Adds an identity filter to a query.

    Filters results by 'id', if supplied value is a valid integer.
    then attempts to filter results by 'uuid';
    otherwise filters by name

    :param query: Initial query to add filter to.
    :param value: Value for filtering results by.
    :param use_region_name: Use region_name in filter
    :param use_resource_type: Use resource_type in filter

    :return: Modified query.
    """
    if use_region_name:
        return query.filter_by(region_name=value)
    elif strutils.is_int_like(value):
        return query.filter_by(id=value)
    elif uuidutils.is_uuid_like(value):
        return query.filter_by(uuid=value)
    elif use_resource_type:
        return query.filter_by(resource_type=value)
    else:
        return query.filter_by(name=value)


def add_filter_by_many_identities(query, model, values):
    """Adds an identity filter to a query for values list.

    Filters results by ID, if supplied values contain a valid integer.
    Otherwise attempts to filter results by UUID.

    :param query: Initial query to add filter to.
    :param model: Model for filter.
    :param values: Values for filtering results by.
    :return: tuple (Modified query, filter field name).
    """
    if not values:
        raise exception.Invalid()
    value = values[0]
    if strutils.is_int_like(value):
        return query.filter(getattr(model, 'id').in_(values)), 'id'
    elif uuidutils.is_uuid_like(value):
        return query.filter(getattr(model, 'uuid').in_(values)), 'uuid'
    else:
        raise exception.InvalidParameterValue(
            err="Invalid identity filter value %s" % value)


@require_context
def _subcloud_get(context, region_id, session=None):
    query = model_query(context, models.Subcloud, session=session). \
        filter_by(deleted=0)
    query = add_identity_filter(query, region_id, use_region_name=True)

    try:
        return query.one()
    except NoResultFound:
        raise exception.SubcloudNotFound(region_name=region_id)
    except MultipleResultsFound:
        raise exception.InvalidParameterValue(
            err="Multiple entries found for subcloud %s" % region_id)


@require_context
def subcloud_get(context, region_id):
    return _subcloud_get(context, region_id)


@require_context
def subcloud_get_all(context, region_name=None,
                     management_state=None,
                     availability_status=None,
                     initial_sync_state=None):
    query = model_query(context, models.Subcloud). \
        filter_by(deleted=0)

    if region_name:
        query = add_identity_filter(query, region_name, use_region_name=True)
    if management_state:
        query = query.filter_by(management_state=management_state)
    if availability_status:
        query = query.filter_by(availability_status=availability_status)
    if initial_sync_state:
        query = query.filter_by(initial_sync_state=initial_sync_state)
    return query.all()


@require_admin_context
def subcloud_create(context, region_name, values):
    with write_session() as session:
        result = models.Subcloud()
        result.region_name = region_name
        if not values.get('uuid'):
            values['uuid'] = uuidutils.generate_uuid()
        result.update(values)
        try:
            session.add(result)
        except db_exc.DBDuplicateEntry:
            raise exception.SubcloudAlreadyExists(region_name=region_name)
        return result


@require_admin_context
def subcloud_update(context, region_name, values):
    with write_session() as session:
        result = _subcloud_get(context, region_name, session)
        result.update(values)
        result.save(session)
        return result


@require_admin_context
def subcloud_delete(context, region_name):
    with write_session() as session:
        subclouds = session.query(models.Subcloud). \
            filter_by(deleted=0). \
            filter_by(region_name=region_name). \
            all()
        if subclouds:
            for subcloud_ref in subclouds:
                session.delete(subcloud_ref)
        else:
            raise exception.SubcloudNotFound(region_name=region_name)


@require_context
def _resource_get(context, resource_type, master_id, session):
    query = model_query(context, models.Resource, session=session). \
        filter_by(deleted=0)
    query = query.filter_by(resource_type=resource_type)
    query = query.filter_by(master_id=master_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.ResourceNotFound(resource_type=resource_type)
    except MultipleResultsFound:
        raise exception.InvalidParameterValue(
            err=("Multiple entries found for resource %(id)s of type %(type)s",
                 {'id': master_id, 'type': resource_type}))


@require_context
def resource_get_by_type_and_master_id(context, resource_type, master_id):
    with read_session() as session:
        return _resource_get(context, resource_type, master_id, session)


@require_context
def resource_get_by_id(context, resource_id, session=None):
    query = model_query(context, models.Resource, session=session). \
        filter_by(deleted=0)
    query = query.filter_by(id=resource_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.ResourceNotFound(id=resource_id)


@require_context
def resource_get_all(context, resource_type=None):
    query = model_query(context, models.Resource). \
        filter_by(deleted=0)

    if resource_type:
        query = add_identity_filter(query, resource_type,
                                    use_resource_type=True)

    return query.all()


@require_admin_context
def resource_create(context, resource_type, values):
    with write_session() as session:
        result = models.Resource()
        result.resource_type = resource_type
        if not values.get('uuid'):
            values['uuid'] = uuidutils.generate_uuid()
        result.update(values)
        session.add(result)
        return result


@require_admin_context
def resource_update(context, resource_id, values):
    with write_session() as session:
        result = resource_get_by_id(context, resource_id, session=session)
        result.update(values)
        result.save(session)
        return result


@require_admin_context
def resource_delete(context, resource_type, master_id):
    with write_session() as session:
        resources = session.query(models.Resource). \
            filter_by(deleted=0). \
            filter_by(resource_type=resource_type). \
            filter_by(master_id=master_id). \
            all()
        if resources:
            for resource_ref in resources:
                session.delete(resource_ref)
        else:
            raise exception.ResourceNotFound(resource_type=resource_type)


def add_subcloud_resource_filter_by_subcloud(query, value):
    if strutils.is_int_like(value):
        return query.filter(models.Subcloud.id == value)
    elif uuidutils.is_uuid_like(value):
        return query.filter(models.Subcloud.uuid == value)


@require_context
def _subcloud_resource_get(context, subcloud_resource_id, session=None):
    query = model_query(context, models.SubcloudResource, session=session). \
        filter_by(deleted=0)
    query = add_identity_filter(query, subcloud_resource_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.SubcloudResourceNotFound(resource=subcloud_resource_id)


@require_context
def subcloud_resource_get(context, subcloud_resource_id):
    return _subcloud_resource_get(context, subcloud_resource_id)


@require_context
def subcloud_resources_get_by_subcloud(context, subcloud_id):
    query = model_query(context, models.SubcloudResource). \
        filter_by(deleted=0)
    if subcloud_id:
        query = (query.join(models.Subcloud,
                            models.Subcloud.id ==
                            models.SubcloudResource.subcloud_id))
        query, field = add_filter_by_many_identities(
            query, models.Subcloud, [subcloud_id])
    return query.all()


@require_context
def subcloud_resources_get_by_resource(context, resource_id):
    # query by resource id or uuid, not resource master uuid.
    query = model_query(context, models.SubcloudResource). \
        filter_by(deleted=0)
    if resource_id:
        query = (query.join(models.Resource,
                            models.Resource.id ==
                            models.SubcloudResource.resource_id))
        query, field = add_filter_by_many_identities(
            query, models.Resource, [resource_id])
    return query.all()


def subcloud_resources_get_all(context):
    query = model_query(context, models.SubcloudResource). \
        filter_by(deleted=0)
    return query.all()


@require_context
def subcloud_resource_get_by_resource_and_subcloud(
        context, resource_id, subcloud_id):
    query = model_query(context, models.SubcloudResource). \
        filter_by(deleted=0). \
        filter_by(resource_id=resource_id). \
        filter_by(subcloud_id=subcloud_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.SubcloudResourceNotFound()
    except MultipleResultsFound:
        raise exception.InvalidParameterValue(
            err=("Multiple entries found for resource %(rid)d "
                 "subcloud %(sid)d",
                 {'rid': resource_id, 'sid': subcloud_id}))


@require_admin_context
def subcloud_resource_create(context, subcloud_id, resource_id, values):
    with write_session() as session:
        result = models.SubcloudResource()
        result.subcloud_id = subcloud_id
        result.resource_id = resource_id
        if not values.get('uuid'):
            values['uuid'] = uuidutils.generate_uuid()
        result.update(values)
        try:
            session.add(result)
        except db_exc.DBDuplicateEntry:
            raise exception.SubcloudResourceAlreadyExists(
                subcloud_id=subcloud_id,
                resource_id=resource_id)
        return result


@require_admin_context
def subcloud_resource_update(context, subcloud_resource_id, values):
    with write_session() as session:
        result = _subcloud_resource_get(context, subcloud_resource_id, session)
        result.update(values)
        result.save(session)
        return result


@require_admin_context
def subcloud_resource_delete(context, subcloud_resource_id):
    with write_session() as session:
        query = session.query(models.SubcloudResource). \
            filter_by(deleted=0)
        query = add_identity_filter(query, subcloud_resource_id)
        try:
            subcloud_resource_ref = query.one()
        except NoResultFound:
            raise exception.SubcloudResourceNotFound(
                resource=subcloud_resource_id)
        session.delete(subcloud_resource_ref)


def add_orch_job_filter_by_resource(query, value):
    if strutils.is_int_like(value):
        return query.filter(models.OrchJob.id == value)
    elif uuidutils.is_uuid_like(value):
        return query.filter(models.OrchJob.uuid == value)


@require_context
def _orch_job_get(context, orch_job_id, session=None):
    query = model_query(context, models.OrchJob, session=session). \
        filter_by(deleted=0)
    query = add_identity_filter(query, orch_job_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.OrchJobNotFound(orch_job=orch_job_id)


@require_context
def orch_job_get(context, orch_job_id):
    return _orch_job_get(context, orch_job_id)


@require_context
def orch_job_get_all(context, resource_id=None):
    query = model_query(context, models.OrchJob). \
        filter_by(deleted=0)
    if resource_id:
        query = (query.join(models.Resource,
                            models.Resource.id == models.OrchJob.resource_id))
        query, field = add_filter_by_many_identities(
            query, models.Resource, [resource_id])
    return query.all()


@require_admin_context
def orch_job_create(context, resource_id, endpoint_type,
                    operation_type, values):
    with write_session() as session:
        result = models.OrchJob()
        result.resource_id = resource_id
        result.endpoint_type = endpoint_type
        result.operation_type = operation_type
        if not values.get('uuid'):
            values['uuid'] = uuidutils.generate_uuid()
        result.update(values)
        try:
            session.add(result)
        except db_exc.DBDuplicateEntry:
            raise exception.OrchJobAlreadyExists(
                resource_id=resource_id,
                endpoint_type=endpoint_type,
                operation_type=operation_type)
        return result


@require_admin_context
def orch_job_update(context, orch_job_id, values):
    with write_session() as session:
        result = _orch_job_get(context, orch_job_id, session)
        result.update(values)
        result.save(session)
        return result


@require_admin_context
def orch_job_delete(context, orch_job_id):
    with write_session() as session:
        query = session.query(models.OrchJob). \
            filter_by(deleted=0)
        query = add_identity_filter(query, orch_job_id)
        try:
            orch_job_ref = query.one()
        except NoResultFound:
            raise exception.OrchJobNotFound(orch_job=orch_job_id)
        session.delete(orch_job_ref)


def add_orch_request_filter_by_resource(query, value):
    if strutils.is_int_like(value):
        return query.filter(models.OrchRequest.id == value)
    elif uuidutils.is_uuid_like(value):
        return query.filter(models.OrchRequest.uuid == value)


@require_context
def _orch_request_get(context, orch_request_id, session=None):
    query = model_query(context, models.OrchRequest, session=session). \
        filter_by(deleted=0)
    query = add_identity_filter(query, orch_request_id)
    try:
        return query.one()
    except NoResultFound:
        raise exception.OrchRequestNotFound(orch_request=orch_request_id)


@require_context
def orch_request_get(context, orch_request_id):
    return _orch_request_get(context, orch_request_id)


@require_context
def orch_request_get_most_recent_failed_request(context):
    query = model_query(context, models.OrchRequest). \
        filter_by(deleted=0). \
        filter_by(state=consts.ORCH_REQUEST_STATE_FAILED)

    try:
        return query.order_by(desc(models.OrchRequest.updated_at)).first()
    except NoResultFound:
        return None


@require_context
def orch_request_get_all(context, orch_job_id=None):
    query = model_query(context, models.OrchRequest). \
        filter_by(deleted=0)
    if orch_job_id:
        query = (query.join(models.OrchJob,
                            models.OrchJob.id ==
                            models.OrchRequest.orch_job_id))
        query, field = add_filter_by_many_identities(
            query, models.OrchJob, [orch_job_id])
    return query.all()


@require_context
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] note: must be a list
    :return: [OrchRequests] sorted by OrchRequest.id
    """
    query = model_query(context, models.OrchRequest). \
        filter_by(deleted=0)

    if target_region_name:
        query = query.filter_by(target_region_name=target_region_name)

    if states:
        states = set(states)
        query = query.filter(models.OrchRequest.state.in_(states))

    query = query.join(models.OrchJob,
                       models.OrchJob.id == models.OrchRequest.orch_job_id). \
        filter_by(endpoint_type=endpoint_type)

    if resource_type is not None:
        query = query.join(models.Resource,
                           models.Resource.id == models.OrchJob.resource_id). \
            filter_by(resource_type=resource_type)

    # sort by orch_request id
    query = query.order_by(asc(models.OrchRequest.id)).all()

    return query


@require_admin_context
def orch_request_create(context, orch_job_id, target_region_name, values):
    with write_session() as session:
        result = models.OrchRequest()
        result.orch_job_id = orch_job_id
        result.target_region_name = target_region_name
        if not values.get('uuid'):
            values['uuid'] = uuidutils.generate_uuid()
        result.update(values)
        try:
            session.add(result)
        except db_exc.DBDuplicateEntry:
            raise exception.OrchRequestAlreadyExists(
                orch_request=orch_job_id,
                target_region_name=target_region_name)
        return result


@require_admin_context
def orch_request_update(context, orch_request_id, values):
    with write_session() as session:
        result = _orch_request_get(context, orch_request_id, session)
        result.update(values)
        result.save(session)
        return result


@require_admin_context
def orch_request_destroy(context, orch_request_id):
    with write_session() as session:
        query = session.query(models.OrchRequest). \
            filter_by(deleted=0)
        query = add_identity_filter(query, orch_request_id)
        try:
            orch_request_ref = query.one()
        except NoResultFound:
            raise exception.OrchRequestNotFound(orch_request=orch_request_id)
        session.delete(orch_request_ref)


@require_admin_context
def orch_request_delete_by_subcloud(context, region_name):
    """Delete all orch_request entries for a given subcloud.

    This is used primarily when deleting a subcloud.
    In particular, it is not a bug if there are no entries to delete.
    """
    with write_session() as session:
        session.query(models.OrchRequest). \
            filter_by(target_region_name=region_name). \
            delete()


@require_admin_context
def orch_request_delete_previous_failed_requests(context, delete_timestamp):
    """Soft delete orch_request entries.

       This is used to soft delete all previously failed requests at
       the end of each audit cycle.
    """
    LOG.info('Soft deleting failed orch requests at and before %s',
             delete_timestamp)
    with write_session() as session:
        query = session.query(models.OrchRequest). \
            filter_by(deleted=0). \
            filter_by(state=consts.ORCH_REQUEST_STATE_FAILED). \
            filter(models.OrchRequest.updated_at <= delete_timestamp)

        count = query.update({'deleted': 1,
                              'deleted_at': timeutils.utcnow()})
    LOG.info('%d previously failed sync requests soft deleted', count)


@require_admin_context
def purge_deleted_records(context, age_in_days):
    deleted_age = \
        timeutils.utcnow() - datetime.timedelta(days=age_in_days)

    LOG.info('Purging deleted records older than %s', deleted_age)

    with write_session() as session:
        # Purging orch_request table
        count = session.query(models.OrchRequest). \
            filter_by(deleted=1). \
            filter(models.OrchRequest.deleted_at < deleted_age).delete()
        LOG.info('%d records were purged from orch_request table.', count)

        # Purging orch_job table
        subquery = model_query(context, models.OrchRequest.orch_job_id). \
            group_by(models.OrchRequest.orch_job_id)

        count = session.query(models.OrchJob). \
            filter(~models.OrchJob.id.in_(subquery)). \
            delete(synchronize_session='fetch')
        LOG.info('%d records were purged from orch_job table.', count)

        # Purging resource table
        orchjob_subquery = model_query(context, models.OrchJob.resource_id). \
            group_by(models.OrchJob.resource_id)

        subcloud_resource_subquery = model_query(
            context, models.SubcloudResource.resource_id). \
            group_by(models.SubcloudResource.resource_id)

        count = session.query(models.Resource). \
            filter(~models.Resource.id.in_(orchjob_subquery)). \
            filter(~models.Resource.id.in_(subcloud_resource_subquery)). \
            delete(synchronize_session='fetch')
        LOG.info('%d records were purged from resource table.', count)


def sync_lock_acquire(
        context, engine_id, subcloud_name, endpoint_type, action):
    LOG.debug("sync_lock_acquire: %s/%s/%s/%s" % (engine_id, subcloud_name,
                                                  endpoint_type, action))
    with write_session() as session:
        lock = session.query(models.SyncLock). \
            filter_by(deleted=0). \
            filter_by(subcloud_name=subcloud_name). \
            filter_by(endpoint_type=endpoint_type). \
            filter_by(action=action).all()
        if not lock:
            lock_ref = models.SyncLock()
            lock_ref.engine_id = engine_id
            lock_ref.subcloud_name = subcloud_name
            lock_ref.endpoint_type = endpoint_type
            lock_ref.action = action
            try:
                session.add(lock_ref)
                return True
            except IntegrityError:
                LOG.info("IntegrityError Engine id:%s, subcloud:%s, "
                         "endpoint_type:%s" %
                         (engine_id, subcloud_name, endpoint_type))
            except db_exc.DBDuplicateEntry:
                LOG.info("DBDuplicateEntry Engine id:%s, subcloud:%s, "
                         "endpoint_type:%s" %
                         (engine_id, subcloud_name, endpoint_type))
            except Exception:
                LOG.exception("Got session add exception")
    return False


# For robustness, this will attempt max_retries with inc_retry_interval
# backoff to release the sync_lock.
@oslo_db_api.wrap_db_retry(max_retries=3, retry_on_deadlock=True,
                           retry_interval=0.5, inc_retry_interval=True)
def sync_lock_release(context, subcloud_name, endpoint_type, action):
    with write_session() as session:
        session.query(models.SyncLock).filter_by(
            subcloud_name=subcloud_name). \
            filter_by(endpoint_type=endpoint_type). \
            filter_by(action=action). \
            delete(synchronize_session='fetch')


def sync_lock_steal(context, engine_id, subcloud_name, endpoint_type, action):
    sync_lock_release(context, subcloud_name, endpoint_type, action)
    return sync_lock_acquire(context, engine_id, subcloud_name, endpoint_type,
                             action)


def sync_lock_delete_by_engine_id(context, engine_id):
    """Delete all sync_lock entries for a given engine."""

    with write_session() as session:
        results = session.query(models.SyncLock). \
            filter_by(engine_id=engine_id).all()
        for result in results:
            LOG.info("Deleted sync lock id=%s engine_id=%s" %
                     (result.id, result.engine_id))
            session.delete(result)


def purge_stale_sync_lock(context):
    """Delete all sync lock entries where service ID no longer exists."""
    LOG.info('Purging stale sync_locks')
    with write_session() as session:
        # Purging sync_lock table
        subquery = model_query(context, models.Service.id). \
            group_by(models.Service.id)

        count = session.query(models.SyncLock). \
            filter(~models.SyncLock.engine_id.in_(subquery)). \
            delete(synchronize_session='fetch')
        LOG.info('%d records were purged from sync_lock table.', count)


def _subcloud_sync_get(context, subcloud_name, endpoint_type, session=None):
    query = model_query(context, models.SubcloudSync, session=session). \
        filter_by(subcloud_name=subcloud_name). \
        filter_by(endpoint_type=endpoint_type)
    try:
        return query.one()
    except NoResultFound:
        raise exception.SubcloudSyncNotFound(subcloud_name=subcloud_name,
                                             endpoint_type=endpoint_type)
    except MultipleResultsFound:
        err = ("Multiple entries found for subcloud %s endpoint_type %s" %
               (subcloud_name, endpoint_type))
        raise exception.InvalidParameterValue(err=err)


def subcloud_sync_get(context, subcloud_name, endpoint_type):
    return _subcloud_sync_get(context, subcloud_name, endpoint_type)


def subcloud_sync_create(context, subcloud_name, endpoint_type, values):
    with write_session() as session:
        result = models.SubcloudSync()
        result.subcloud_name = subcloud_name
        result.endpoint_type = endpoint_type
        result.update(values)
        try:
            session.add(result)
        except db_exc.DBDuplicateEntry:
            raise exception.SubcloudSyncAlreadyExists(
                subcloud_name=subcloud_name,
                endpoint_type=endpoint_type)
        return result


def subcloud_sync_update(context, subcloud_name, endpoint_type, values):
    with write_session() as session:
        result = _subcloud_sync_get(context, subcloud_name, endpoint_type,
                                    session)
        result.update(values)
        result.save(session)
        return result


def subcloud_sync_delete(context, subcloud_name, endpoint_type):
    with write_session() as session:
        results = session.query(models.SubcloudSync). \
            filter_by(subcloud_name=subcloud_name). \
            filter_by(endpoint_type=endpoint_type).all()
        for result in results:
            session.delete(result)