# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright (c) 2013 TrilioData, Inc.
# All Rights Reserved.

"""Defines interface for DB access.

The underlying driver is loaded as a :class:`LazyPluggable`.

Functions in this module are imported into the workloadmgr.db namespace.
Call these functions from workloadmgr.db namespace,
not the workloadmgr.db.api namespace.

All functions in this module return objects that implement a dictionary-like
interface. Currently, many of these objects are sqlalchemy objects that
implement a dictionary interface. However, a future goal is to have all of
these objects be simple dictionaries.


**Related Flags**

:db_backend:  string to lookup in the list of LazyPluggable backends.
              `sqlalchemy` is the only supported backend right now.

:sql_connection:  string specifying the sqlalchemy connection to use, like:
                  `sqlite:///var/lib/workloadmgr/workloadmgr.sqlite`.

:enable_new_services:  when adding a new service to the database, is it in the
                       pool of available hardware (Default: True)

"""

from oslo_config import cfg

from workloadmgr import exception
from workloadmgr import flags
from workloadmgr import utils

db_opts = [
    cfg.StrOpt('db_backend',
               default='sqlalchemy',
               help='The backend to use for db'),
    cfg.BoolOpt('enable_new_services',
                default=True,
                help='Services to be added to the available pool on create'),
    cfg.StrOpt('workload_name_template',
               default='workload-%s',
               help='Template string to be used to generate workload names'),
    cfg.StrOpt('migration_plan_name_template',
               default='migration_plan-%s',
               help='Template string to be used to generate migration_plan names'), ]

FLAGS = flags.FLAGS
FLAGS.register_opts(db_opts)

IMPL = utils.LazyPluggable('db_backend',
                           sqlalchemy='workloadmgr.db.sqlalchemy.api')


class NoMoreTargets(exception.WorkloadMgrException):

    """No more available targets"""
    pass

#


def service_delete(context, service_id):
    """Destroy the service or raise if it does not exist."""
    return IMPL.service_delete(context, service_id)


def service_get(context, service_id):
    """Get a service or raise if it does not exist."""
    return IMPL.service_get(context, service_id)


def service_get_by_host_and_topic(context, host, topic):
    """Get a service by host it's on and topic it listens to."""
    return IMPL.service_get_by_host_and_topic(context, host, topic)


def service_get_all(context):
    """Get all services."""
    return IMPL.service_get_all(context)


def service_get_all_by_topic(context, topic, read_disabled=False):
    """Get all services for a given topic."""
    return IMPL.service_get_all_by_topic(context, topic, read_disabled)


def service_get_all_by_host(context, host):
    """Get all services for a given host."""
    return IMPL.service_get_all_by_host(context, host)


def service_get_by_args(context, host, binary):
    """Get the state of an service by node name and binary."""
    return IMPL.service_get_by_args(context, host, binary)


def service_create(context, values):
    """Create a service from the values dictionary."""
    return IMPL.service_create(context, values)


def service_update(context, service_id, values):
    """Set the given properties on an service and update it.

    Raises NotFound if service does not exist.

    """
    return IMPL.service_update(context, service_id, values)

#


def file_search_get_all(context, **kwargs):
    """Get all file search for a given host."""
    return IMPL.file_search_get_all(context, **kwargs)


def file_search_delete(context, search_id):
    """Destroy the search or raise if it does not exist."""
    return IMPL.file_search_delete(context, search_id)


def file_search_get(context, search_id):
    """Get a search or raise if it does not exist."""
    return IMPL.file_search_get(context, search_id)


def file_search_create(context, values):
    """Create a search from the values dictionary."""
    return IMPL.file_search_create(context, values)


def file_search_update(context, search_id, values):
    """Set the given properties on an search and update it.
    """
    return IMPL.file_search_update(context, search_id, values)


def workload_type_create(context, values):
    return IMPL.workload_type_create(context, values)


def workload_type_update_all(context, values):
    return IMPL.workload_type_update_all(context, values)


def workload_type_update(context, id, values, purge_metadata=False):
    return IMPL.workload_type_update(context, id, values, purge_metadata)


def workload_types_get(context):
    return IMPL.workload_types_get(context)


def workload_type_get(context, id):
    return IMPL.workload_type_get(context, id)


def workload_type_delete(context, id):
    return IMPL.workload_type_delete(context, id)


def workload_get(context, workload_id, **kwargs):
    """Get a workload or raise if it does not exist."""
    return IMPL.workload_get(context, workload_id, **kwargs)


def workload_show(context, workload_id):
    """Get more details of the  workload or raise if it does not exist."""
    return IMPL.workload_show(context, workload_id)


def workload_get_all(context, **kwargs):
    """Get all workloads."""
    return IMPL.workload_get_all(context, **kwargs)


def workload_create(context, values):
    """Create a workload from the values dictionary."""
    return IMPL.workload_create(context, values)


def workload_update(context, workload_id, values, purge_metadata=False):
    """
    Set the given properties on a workload  and update it.
    Raises NotFound if workload  does not exist.
    """
    return IMPL.workload_update(context, workload_id, values, purge_metadata)

def workload_delete(context, workload_id):
    """Destroy the workload or raise if it does not exist."""
    return IMPL.workload_delete(context, workload_id)

def import_job_create(context, workload_ids):
    """Create Import Job or raise if workloads are found in DB."""
    return IMPL.import_job_create(context, workload_ids)

def workload_import_create(context, workload_ids):
    """Create each Workload Table which is part of Import Job."""
    return IMPL.workload_import_create(context, workload_ids)

def import_job_get(context, jobid):
    """return job details."""
    return IMPL.import_job_get(context, jobid)

def import_job_update(context, jobid, values):
    return IMPL.import_job_update(context, jobid, values)

def workload_import_update(context, jobid, workload_id, values):
    return IMPL.workload_import_update(context, jobid, workload_id, values)

def workload_import_get(context, jobid):
    return IMPL.workload_import_get(context, jobid)

def get_workload_count(context, project_id):
    return IMPL.get_workload_count(context, project_id)


def workload_vms_create(context, values):
    return IMPL.workload_vms_create(context, values)


def workload_vms_get(context, workload_id, **kwargs):
    return IMPL.workload_vms_get(context, workload_id, **kwargs)


def get_vms_count_by_project_id(context, project_id):
    return IMPL.get_vms_count_by_project_id(context, project_id)


def workload_vm_get_by_id(context, vm_id, **kwargs):
    return IMPL.workload_vm_get_by_id(context, vm_id, **kwargs)


def workload_vm_get(context, id):
    return IMPL.workload_vm_get(context, id)


def workload_vms_delete(context, vm_id, workload_id):
    return IMPL.workload_vms_delete(context, vm_id, workload_id)


def workload_vms_update(context, id, values, purge_metadata=False):
    return IMPL.workload_vms_update(context, id, values, purge_metadata)


def restored_instance_get(context, instance_id, **kwargs):
    return IMPL.restored_instance_get(context, instance_id, **kwargs)


def unlock_workloads_for_host(context, host):
    return IMPL.unlock_workloads_for_host(context, host)


def snapshot_mark_incomplete_as_error(context, host):
    return IMPL.snapshot_mark_incomplete_as_error(context, host)


def workloads_mark_deleting_as_error(context, host):
     return IMPL.workloads_mark_deleting_as_error(context, host)


def get_snapshot_children(context, snapshot_id, children=None):
    return IMPL.get_snapshot_children(context, snapshot_id, children)


def get_snapshot_parents(context, snapshot_id, parents=None):
    return IMPL.get_snapshot_parents(context, snapshot_id, parents)


def snapshot_create(context, values):
    return IMPL.snapshot_create(context, values)


def snapshot_type_time_size_update(context, snapshot_id):
    return IMPL.snapshot_type_time_size_update(context, snapshot_id)


def snapshot_delete(context, snapshot_id, hard_delete=False):
    """Destroy the snapshot or raise if it does not exist."""
    return IMPL.snapshot_delete(context, snapshot_id, hard_delete=hard_delete)


def get_active_snapshot_count(context, project_id):
    return IMPL.get_active_snapshot_count(context, project_id)


def snapshot_get(context, snapshot_id, **kwargs):
    return IMPL.snapshot_get(context, snapshot_id, **kwargs)


def snapshot_get_metadata_cancel_flag(
        context, snapshot_id, return_val=0, process=None, **kwargs):
    return IMPL.snapshot_get_metadata_cancel_flag(
        context, snapshot_id, return_val, process, **kwargs)


def snapshot_get_running_snapshots_by_host(context, **kwargs):
    return IMPL.snapshot_get_running_snapshots_by_host(context, **kwargs)


def migration_get_running_migrations_by_host(context, **kwargs):
    return IMPL.migration_get_running_migrations_by_host(context, **kwargs)


def snapshot_get_all(context, **kwargs):
    return IMPL.snapshot_get_all(context, **kwargs)


def snapshot_get_all_by_workload(context, workload_id, **kwargs):
    """Get all snapshots belonging to a workload."""
    return IMPL.snapshot_get_all_by_workload(context, workload_id, **kwargs)


def snapshot_get_all_by_project(context, project_id, **kwargs):
    """Get all snapshots belonging to a project."""
    return IMPL.snapshot_get_all_by_project(context, project_id, **kwargs)


def snapshot_get_all_by_project_workload(
        context, project_id, workload_id, **kwargs):
    """Get all snapshots belonging to a project and workload"""
    return IMPL.snapshot_get_all_by_project_workload(
        context, project_id, workload_id, **kwargs)


def snapshot_next(context, snapshot_id, workload_id, **kwargs):
    """Get next snapshot or raise if it does not exist."""
    return IMPL.snapshot_next(context, snapshot_id, workload_id, **kwargs)


def snapshot_prev(context, snapshot_id, workload_id, **kwargs):
    """Get prev snapshot or raise if it does not exist."""
    return IMPL.snapshot_prev(context, snapshot_id, workload_id, **kwargs)


def snapshot_show(context, snapshot_id, **kwargs):
    """Get more details of the  snapshot or raise if it does not exist."""
    return IMPL.snapshot_show(context, snapshot_id, **kwargs)


def snapshot_update(context, snapshot_id, values):
    return IMPL.snapshot_update(context, snapshot_id, values)


def snapshot_vm_create(context, values):
    return IMPL.snapshot_vm_create(context, values)


def snapshot_vms_get(context, snapshot_id, **kwargs):
    return IMPL.snapshot_vms_get(context, snapshot_id, **kwargs)


def snapshot_vm_get(context, vm_id, snapshot_id):
    return IMPL.snapshot_vm_get(context, vm_id, snapshot_id)


def snapshot_vm_update(context, vm_id, snapshot_id, values):
    return IMPL.snapshot_vm_update(context, vm_id, snapshot_id, values)


def snapshot_vm_delete(context, vm_id, snapshot_id):
    return IMPL.snapshot_vm_delete(context, vm_id, snapshot_id)


def vm_recent_snapshot_create(context, values):
    return IMPL.vm_recent_snapshot_create(context, values)


def vm_recent_snapshot_get(context, vm_id, **kwargs):
    return IMPL.vm_recent_snapshot_get(context, vm_id, **kwargs)


def vm_recent_snapshot_update(context, vm_id, values):
    return IMPL.vm_recent_snapshot_update(context, vm_id, values)


def vm_recent_snapshot_delete(context, vm_id):
    return IMPL.vm_recent_snapshot_delete(context, vm_id)


def snapshot_vm_resource_create(context, values):
    return IMPL.snapshot_vm_resource_create(context, values)


def snapshot_vm_resource_update(context, id, vaules, purge_metadata=False):
    return IMPL.snapshot_vm_resource_update(
        context, id, vaules, purge_metadata)


def snapshot_vm_resources_get(context, vm_id, snapshot_id):
    return IMPL.snapshot_vm_resources_get(context, vm_id, snapshot_id)


def snapshot_resources_get(context, snapshot_id, **kwargs):
    return IMPL.snapshot_resources_get(context, snapshot_id, **kwargs)


def snapshot_vm_resource_get_by_resource_pit_id(
        context, vm_id, snapshot_id, resource_pit_id):
    return IMPL.snapshot_vm_resource_get_by_resource_pit_id(
        context, vm_id, snapshot_id, resource_pit_id)


def snapshot_vm_resource_get_by_resource_name(
        context, vm_id, snapshot_id, resource_name):
    return IMPL.snapshot_vm_resource_get_by_resource_name(
        context, vm_id, snapshot_id, resource_name)


def snapshot_vm_resource_get(context, id):
    return IMPL.snapshot_vm_resource_get(context, id)


def snapshot_vm_resource_delete(context, id):
    return IMPL.snapshot_vm_resource_delete(context, id)


def vm_disk_resource_snap_create(context, values):
    return IMPL.vm_disk_resource_snap_create(context, values)


def vm_disk_resource_snap_update(context, id, vaules, purge_metadata=False):
    return IMPL.vm_disk_resource_snap_update(
        context, id, vaules, purge_metadata)


def vm_disk_resource_snaps_get(context, snapshot_vm_resource_id, **kwargs):
    return IMPL.vm_disk_resource_snaps_get(
        context, snapshot_vm_resource_id, **kwargs)


def vm_disk_resource_snap_get_top(context, snapshot_vm_resource_id):
    return IMPL.vm_disk_resource_snap_get_top(context, snapshot_vm_resource_id)


def vm_disk_resource_snap_get_bottom(context, snapshot_vm_resource_id):
    return IMPL.vm_disk_resource_snap_get_bottom(
        context, snapshot_vm_resource_id)


def vm_disk_resource_snap_get(context, vm_disk_resource_snap_id):
    return IMPL.vm_disk_resource_snap_get(context, vm_disk_resource_snap_id)


def vm_disk_resource_snap_get_snapshot_vm_resource_id(
        context, vm_disk_resource_snap_id):
    return IMPL.vm_disk_resource_snap_get_snapshot_vm_resource_id(
        context, vm_disk_resource_snap_id)


def vm_disk_resource_snap_delete(context, vm_disk_resource_snap_id):
    return IMPL.vm_disk_resource_snap_delete(context, vm_disk_resource_snap_id)


def vm_network_resource_snap_create(context, values):
    return IMPL.vm_network_resource_snap_create(context, values)


def vm_network_resource_snap_update(context, id, vaules, purge_metadata=False):
    return IMPL.vm_network_resource_snap_update(
        context, id, vaules, purge_metadata)


def vm_network_resource_snaps_get(context, snapshot_vm_resource_id, **kwargs):
    return IMPL.vm_network_resource_snaps_get(
        context, snapshot_vm_resource_id, **kwargs)


def vm_network_resource_snap_get(context, snapshot_vm_resource_id):
    return IMPL.vm_network_resource_snap_get(context, snapshot_vm_resource_id)


def vm_network_resource_snap_delete(context, vm_network_resource_snap_id):
    return IMPL.vm_network_resource_snap_delete(
        context, vm_network_resource_snap_id)


def vm_security_group_rule_snap_create(context, values):
    return IMPL.vm_security_group_rule_snap_create(context, values)


def vm_security_group_rule_snap_update(
        context, id, vm_security_group_snap_id, vaules, purge_metadata=False):
    return IMPL.vm_security_group_rule_snap_update(
        context, id, vm_security_group_snap_id, vaules, purge_metadata)


def vm_security_group_rule_snaps_get(
        context, vm_security_group_snap_id, **kwargs):
    return IMPL.vm_security_group_rule_snaps_get(
        context, vm_security_group_snap_id, **kwargs)


def vm_security_group_rule_snap_get(context, id, vm_security_group_snap_id):
    return IMPL.vm_security_group_rule_snap_get(
        context, id, vm_security_group_snap_id)


def vm_security_group_rule_snap_delete(
        context, id, vm_security_group_rule_snap_id):
    return IMPL.vm_security_group_rule_snap_delete(
        context, id, vm_security_group_rule_snap_id)


def get_metadata_value(metadata, key, default=None):
    return IMPL.get_metadata_value(metadata, key, default=default)


def restore_mark_incomplete_as_error(context, host):
    return IMPL.restore_mark_incomplete_as_error(context, host)


def restore_create(context, values):
    return IMPL.restore_create(context, values)


def restore_delete(context, restore_id):
    """Destroy the restore or raise if it does not exist."""
    return IMPL.restore_delete(context, restore_id)


def restore_get(context, restore_id, **kwargs):
    return IMPL.restore_get(context, restore_id, **kwargs)


def restore_get_metadata_cancel_flag(
        context, restore_id, return_val=0, process=None, **kwargs):
    return IMPL.restore_get_metadata_cancel_flag(
        context, restore_id, return_val, process, **kwargs)


def restore_get_all(context, snapshot_id=None, **kwargs):
    return IMPL.restore_get_all(context, snapshot_id, **kwargs)


def restore_get_all_by_snapshot(context, snapshot_id, **kwargs):
    """Get all restores belonging to a snapshot."""
    return IMPL.restore_get_all_by_snapshot(context, snapshot_id, **kwargs)


def restore_get_all_by_project(context, project_id, **kwargs):
    """Get all restores belonging to a project."""
    return IMPL.restore_get_all_by_project(context, project_id, **kwargs)


def restore_get_all_by_project_snapshot(
        context, project_id, snapshot_id, **kwargs):
    """Get all restores belonging to a project and snapshot"""
    return IMPL.restore_get_all_by_project_snapshot(
        context, project_id, snapshot_id, **kwargs)


def restore_show(context, restore_id):
    """Get more details of the  restore or raise if it does not exist."""
    return IMPL.restore_show(context, restore_id)


def restore_update(context, restore_id, values):
    return IMPL.restore_update(context, restore_id, values)


def restored_vm_create(context, values):
    return IMPL.restored_vm_create(context, values)


def restored_vm_update(context, vm_id, restore_id, values):
    return IMPL.restored_vm_update(context, vm_id, restore_id, values)


def restored_vm_get(context, vm_id, restore_id):
    return IMPL.restored_vm_get(context, vm_id, restore_id)


def restored_vms_get(context, restore_id, **kwargs):
    return IMPL.restored_vms_get(context, restore_id, **kwargs)


def restored_vm_delete(context, vm_id, restore_id):
    return IMPL.restored_vm_delete(context, vm_id, restore_id)


def restored_vm_resource_metadata_create(context, values):
    return IMPL.restored_vm_resource_metadata_create(context, values)


def restored_vm_resource_metadata_delete(context, metadata_ref):
    return IMPL.restored_vm_resource_metadata_delete(context, metadata_ref)


def restored_vm_resource_create(context, values):
    return IMPL.restored_vm_resource_create(context, values)


def restored_vm_resource_update(
        context, restored_vm_resource_id, values, purge_metadata=False):
    return IMPL.restored_vm_resource_update(
        context, restored_vm_resource_id, values, purge_metadata)


def restored_vm_resources_get(context, vm_id, restore_id):
    return IMPL.restored_vm_resources_get(context, vm_id, restore_id)


def restored_vm_resource_get_by_resource_name(
        context, vm_id, restore_id, resource_name):
    return IMPL.restored_vm_resource_get_by_resource_name(
        context, vm_id, restore_id, resource_name)


def restored_vm_resource_get(context, id):
    return IMPL.restored_vm_resource_get(context, id)


def restored_vm_resource_delete(context, id, vm_id, restore_id):
    return IMPL.restored_vm_resource_delete(context, id, vm_id, restore_id)


def get_all_project_quota_types(quota_type_id=None):
    return IMPL.get_all_project_quota_types(quota_type_id)


def create_project_quota_type(quota_type_data):
    return IMPL.create_project_quota_type(quota_type_data)


def update_project_quota_types(update_dict):
    return IMPL.update_project_quota_types(update_dict)


def get_allowed_quotas(
        context, project_id=None, allowed_quota_id=None, quota_type_id=None
):
    return IMPL.get_allowed_quotas(
        context, project_id, allowed_quota_id, quota_type_id
    )


def create_allowed_quotas(context, allowed_quota_data):
    return IMPL.create_allowed_quotas(context, allowed_quota_data)


def modify_allowed_quotas(context, id, allowed_quota_data):
    return IMPL.modify_allowed_quotas(context, id, allowed_quota_data)


def delete_allowed_quota(context, allowed_quota_id):
    return IMPL.delete_allowed_quota(context, allowed_quota_id)


def setting_create(context, values):
    return IMPL.setting_create(context, values)


def setting_bulk_create(context, setting_values, setting_metadata_values):
    return IMPL.setting_bulk_create(context, setting_values, setting_metadata_values)


def setting_delete(context, setting_key):
    """Destroy the setting or raise if it does not exist."""
    return IMPL.setting_delete(context, setting_key)


def setting_get(context, setting_key, **kwargs):
    return IMPL.setting_get(context, setting_key, **kwargs)


def setting_get_all(context, **kwargs):
    return IMPL.setting_get_all(context, **kwargs)


def setting_get_all_by_project(context, project_id, **kwargs):
    """Get all settings belonging to a project."""
    return IMPL.setting_get_all_by_project(context, project_id, **kwargs)


def setting_update(context, setting_key, values, **kwargs):
    return IMPL.setting_update(context, setting_key, values, **kwargs)


def purge_snapshot(context, id):
    return IMPL.purge_snapshot(context, id)


def purge_workload(context, id):
    return IMPL.purge_workload(context, id)


def config_workload_update(context, values):
    """
    Create a config_workload from the values dictionary or
    Set the given properties on a config_workload  and update it.
    """
    return IMPL.config_workload_update(context, values)


def config_workload_get(context, **kwargs):
    """Get a workload or raise if it does not exist."""
    return IMPL.config_workload_get(context, **kwargs)


# Workload Policy API's


def policy_create(context, values, **kwargs):
    """create workload policy"""
    return IMPL.policy_create(context, values, **kwargs)


def policy_update(context, policy_id, values, purge_metadata=False, **kwargs):
    """update workload policy"""
    return IMPL.policy_update(
        context, policy_id, values, purge_metadata, **kwargs
    )


def policy_get_all(context, **kwargs):
    """get all workload policy"""
    return IMPL.policy_get_all(context, **kwargs)


def policy_get(context, policy_id, **kwargs):
    """get workload policy"""
    return IMPL.policy_get(context, policy_id, **kwargs)


def policy_delete(context, policy_id, **kwargs):
    """delete workload policy"""
    return IMPL.policy_delete(context, policy_id, **kwargs)


def policy_metadata_create(context, values, **kwargs):
    """create policy metadata"""
    return IMPL.policy_metadata_create(context, values, **kwargs)


def policy_field_create(context, values, **kwargs):
    """create policy field"""
    return IMPL.policy_field_create(context, values, **kwargs)


def policy_field_update(context, field_id, values, **kwargs):
    """update policy field"""
    return IMPL.policy_field_update(context, field_id, values, **kwargs)


def policy_fields_get_all(context, **kwargs):
    """get all policy fields"""
    return IMPL.policy_fields_get_all(context, **kwargs)


def policy_field_get(context, field_id, **kwargs):
    """get policy field"""
    return IMPL.policy_field_get(context, field_id, **kwargs)


def policy_field_delete(context, field_id, **kwargs):
    """delete policy field"""
    return IMPL.policy_field_delete(context, field_id, **kwargs)


def policy_value_create(context, values, **kwargs):
    """create policy values"""
    return IMPL.policy_value_create(context, values, **kwargs)


def policy_values_get_all(context, **kwargs):
    """get all policy field values"""
    return IMPL.policy_values_get_all(context, **kwargs)


def policy_value_get(context, value_id, **kwargs):
    """get policy field value"""
    return IMPL.policy_value_get(context, value_id, **kwargs)


def policy_value_delete(context, value_id, **kwargs):
    """create policy metadata"""
    return IMPL.policy_value_delete(context, value_id, **kwargs)


def policy_assignment_create(context, values, **kwargs):
    """create policy assignment"""
    return IMPL.policy_assignment_create(context, values, **kwargs)


def policy_assignment_update(context, assignment_id, values, **kwargs):
    """update policy assignment"""
    return IMPL.policy_assignment_update(
        context, assignment_id, values, **kwargs
    )


def policy_assignments_get_all(context, **kwargs):
    """get all policy assignment"""
    return IMPL.policy_assignments_get_all(context, **kwargs)


def policy_assignment_get(context, assignment_id, **kwargs):
    """create policy assignment"""
    return IMPL.policy_assignment_get(context, assignment_id, **kwargs)


def policy_assignment_delete(context, assignment_id, **kwargs):
    """delete policy assignment"""
    return IMPL.policy_assignment_delete(context, assignment_id, **kwargs)


def get_tenants_usage(context, **kwargs):
    """Get storage usage of a tenant."""
    return IMPL.get_tenants_usage(context, **kwargs)


""" snapshot network resource methods """


def snapshot_network_resource_create(context, values):
    """Create network resource for a snapshot."""
    return IMPL.snapshot_network_resource_create(context, values)


def snapshot_network_resource_update(context, id, values, purge_metadata):
    """Update network resource for a snapshot."""
    return IMPL.snapshot_network_resource_update(
        context, id, values, purge_metadata
    )


def snapshot_network_resource_get(context, resource_id, **kwargs):
    """Return network resource for a snapshot."""
    return IMPL.snapshot_network_resource_get(context, resource_id, **kwargs)


def snapshot_network_resources_get(context, snapshot_id, **kwargs):
    """Return all network resources for a snapshot."""
    return IMPL.snapshot_network_resources_get(context, snapshot_id, **kwargs)


def snapshot_network_resource_delete(context, resource_id):
    """Delete network resource for a snapshot."""
    return IMPL.snapshot_network_resource_delete(context, resource_id)


def snapshot_network_resource_metadata_create(context, values):
    """Create metadata for network resource."""
    return IMPL.snapshot_network_resource_metadata_create(context, values)


def snapshot_network_resource_metadata_delete(context, metadata_ref, session):
    """Delete metadata for network resource."""
    return IMPL.snapshot_network_resource_metadata_delete(
        context, metadata_ref, session
    )


""" Schedule jobs resource method """


def job_create(context, job, **kwargs):
    """Create new scheduled job"""
    return IMPL.job_create(context, job, **kwargs)


def job_update(context, id, values, **kwargs):
    """Update existing scheduled jobs"""
    return IMPL.job_update(context, id, values, **kwargs)


def job_get_all(context, **kwargs):
    """List all scheduled jobs"""
    return IMPL.job_get_all(context, **kwargs)


def job_get(context, workload_id, **kwargs):
    """Show given job"""
    return IMPL.job_get(context, workload_id, **kwargs)


def job_delete(context, workload_id, **kwargs):
    """Delete given job"""
    return IMPL.job_delete(context, workload_id, **kwargs)


def job_multiple_delete(context, job_ids):
    """Delete given jobs"""
    return IMPL.job_multiple_delete(context, job_ids)


def migration_plan_create(context, values):
    return IMPL.migration_plan_create(context, values)


def migration_plan_delete(context, migration_plan_id):
    """Destroy the migration_plan or raise if it does not exist."""
    return IMPL.migration_plan_delete(context, migration_plan_id)


def migration_plan_update(context, id, values, purge_metadata=False):
    return IMPL.migration_plan_update(context, id, values, purge_metadata)


def migration_plan_vms_get(context, migration_plan_id, **kwargs):
    return IMPL.migration_plan_vms_get(context, migration_plan_id, **kwargs)


def migration_plan_vm_get_by_id(context, vm_id, **kwargs):
    return IMPL.migration_plan_vm_get_by_id(context, vm_id, **kwargs)


def migration_plan_vms_create(context, values):
    return IMPL.migration_plan_vms_create(context, values)


def migration_plan_vms_update(context, id, values, purge_metadata=False):
    return IMPL.migration_plan_vms_update(context, id, values, purge_metadata)


def migration_plan_vms_delete(context, vm_id, migration_plan_id):
    return IMPL.migration_plan_vms_delete(context, vm_id, migration_plan_id)


def migration_plan_get_all(context, **kwargs):
    """Get all migration_plans."""
    return IMPL.migration_plan_get_all(context, **kwargs)


def migration_plan_get_by_vmid(context, **kwargs):
    """Get migration_plan by given vmid."""
    return IMPL.migration_plan_get_by_vmid(context, **kwargs)


def migration_plan_get(context, migration_plan_id, **kwargs):
    """Get a migration_plan or raise if it does not exist."""
    return IMPL.migration_plan_get(context, migration_plan_id, **kwargs)


def migration_plan_vm_resource_create(context, values):
    return IMPL.migration_plan_vm_resource_create(context, values)


def migration_plan_get_metadata_cancel_flag(
        context, migration_plan_id, return_val=0, process=None, **kwargs):
    return IMPL.migration_plan_get_metadata_cancel_flag(
        context, migration_plan_id, return_val, process, **kwargs)


def migration_get_all_by_project_migration_plan(
        context, project_id, migration_plan_id, **kwargs):
    """Get all migration_plans belonging to a project and migration_plan"""
    return IMPL.migration_get_all_by_project_migration_plan(
        context, project_id, migration_plan_id, **kwargs)


def migration_plan_vm_resource_create(context, values):
    return IMPL.migration_plan_vm_resource_create(context, values)


def migration_plan_vm_resource_delete(context, vm_resource_id):
    return IMPL.migration_plan_vm_resource_delete(context, vm_resource_id)


def migration_plan_vm_resource_update(context, id, vaules, purge_metadata=False):
    return IMPL.migration_plan_vm_resource_update(
        context, id, vaules, purge_metadata)


def migration_plan_vm_network_resource_create(context, values):
    return IMPL.migration_plan_vm_network_resource_create(context, values)


def migration_plan_vm_network_resource_update(context, id, vaules, purge_metadata=False):
    return IMPL.migration_plan_vm_network_resource_update(
        context, id, vaules, purge_metadata)


def migration_plan_vm_network_resources_get(context, migration_plan_vm_resource_id, **kwargs):
    return IMPL.migration_plan_vm_network_resources_get(
        context, migration_plan_vm_resource_id, **kwargs)


def migration_plan_vm_network_resource_get(context, migration_plan_vm_resource_id):
    return IMPL.migration_plan_vm_network_resource_get(context, migration_plan_vm_resource_id)


def migration_plan_vm_network_resource_delete(context, vm_network_resource_id):
    return IMPL.migration_plan_vm_network_resource_delete(
        context, vm_network_resource_id)


def migration_plan_vm_resource_get(context, id):
    return IMPL.migration_plan_vm_resource_get(context, id)


def migration_plan_vm_resources_get(context, vm_id, migration_plan_id):
    return IMPL.migration_plan_vm_resources_get(context, vm_id, migration_plan_id)


def migration_plan_vm_disk_resource_create(context, values):
    return IMPL.migration_plan_vm_disk_resource_create(context, values)


def migration_plan_vm_disk_resource_update(context, id, vaules, purge_metadata=False):
    return IMPL.migration_plan_vm_disk_resource_update(
        context, id, vaules, purge_metadata)


def migration_plan_vm_disk_resources_get(context, migration_plan_vm_resource_id, **kwargs):
    return IMPL.migration_plan_vm_disk_resources_get(
        context, migration_plan_vm_resource_id, **kwargs)


def migration_plan_vm_disk_resource_get(context, vm_disk_resource_id):
    return IMPL.migration_plan_vm_disk_resource_get(context, vm_disk_resource_id)


def migration_plan_vm_disk_resource_delete(context, vm_disk_resource_id):
    return IMPL.migration_plan_vm_disk_resource_delete(context, vm_disk_resource_id)


def migration_plan_vm_security_group_rule_create(context, values):
    return IMPL.migration_plan_vm_security_group_rule_create(context, values)


def migration_plan_vm_security_group_rule_update(
        context, id, vm_security_group_id, vaules, purge_metadata=False):
    return IMPL.migration_plan_vm_security_group_rule_update(
        context, id, vm_security_group_id, vaules, purge_metadata)


def migration_plan_vm_security_group_rules_get(
        context, vm_security_group_id, **kwargs):
    return IMPL.migration_plan_vm_security_group_rules_get(
        context, vm_security_group_id, **kwargs)


def migration_plan_vm_security_group_rule_get(context, id, vm_security_group_id):
    return IMPL.migration_plan_vm_security_group_rule_get(
        context, id, vm_security_group_id)


def migration_plan_vm_security_group_rule_delete(
        context, id):
    return IMPL.migration_plan_vm_security_group_rule_delete(
        context, id)


def migration_plan_resources_get(context, migration_plan_id, **kwargs):
    return IMPL.migration_plan_resources_get(context, migration_plan_id, **kwargs)


def migration_plan_vm_get(context, vm_id, migration_plan_id):
    return IMPL.migration_plan_vm_get(context, vm_id, migration_plan_id)


def migration_create(context, values):
    return IMPL.migration_create(context, values)


def migration_update(context, migration_id, values):
    return IMPL.migration_update(context, migration_id, values)


def migration_get(context, migration_id, **kwargs):
    return IMPL.migration_get(context, migration_id, **kwargs)


def migration_vms_get(context, migration_id, **kwargs):
    return IMPL.migration_vms_get(context, migration_id, **kwargs)


def migration_get_all(context, migration_plan_id=None, **kwargs):
    return IMPL.migration_get_all(context, migration_plan_id, **kwargs)


def migration_get_metadata_cancel_flag(
        context, migration_id, return_val=0, process=None, **kwargs):
    return IMPL.migration_get_metadata_cancel_flag(
        context, migration_id, return_val, process, **kwargs)

def migration_type_time_size_update(context, migration_id):
    return IMPL.migration_type_time_size_update(context, migration_id)


def migration_delete(context, migration_id):
    """Destroy the migration or raise if it does not exist."""
    return IMPL.migration_delete(context, migration_id)

def migration_vm_create(context, values):
    return IMPL.migration_vm_create(context, values)


def migration_vm_update(context, vm_id, migration_id, values):
    return IMPL.migration_vm_update(context, vm_id, migration_id, values)


def migration_vm_get(context, vm_id, migration_id):
    return IMPL.migration_vm_get(context, vm_id, migration_id)


def migration_vms_get(context, migration_id, **kwargs):
    return IMPL.migration_vms_get(context, migration_id, **kwargs)


def migration_vm_delete(context, vm_id, migration_id):
    return IMPL.migration_vm_delete(context, vm_id, migration_id)


def migration_vm_resource_metadata_create(context, values):
    return IMPL.migration_vm_resource_metadata_create(context, values)


def migration_vm_resource_metadata_delete(context, metadata_ref):
    return IMPL.migration_vm_resource_metadata_delete(context, metadata_ref)


def migration_vm_resource_create(context, values):
    return IMPL.migration_vm_resource_create(context, values)


def migration_vm_resource_update(
        context, migration_vm_resource_id, values, purge_metadata=False):
    return IMPL.migration_vm_resource_update(
        context, migration_vm_resource_id, values, purge_metadata)


def migrated_vm_resources_get(context, vm_id, migration_id):
    return IMPL.migrated_vm_resources_get(context, vm_id, migration_id)


def migrated_vm_resource_get_by_resource_name(
        context, vm_id, restore_id, resource_name):
    return IMPL.migrated_vm_resource_get_by_resource_name(
        context, vm_id, restore_id, resource_name)


def migration_vm_resources_get_all(context, migration_id, **kwargs):
    return IMPL.migration_vm_resources_get_all(context, migration_id, **kwargs)


def migrated_vm_resource_get(context, id):
    return IMPL.migrated_vm_resource_get(context, id)


def migrated_vm_resource_delete(context, id, vm_id, migration_id):
    return IMPL.migrated_vm_resource_delete(context, id, vm_id, migration_id)


def unlock_migration_plans_for_host(context, host):
    return IMPL.unlock_migration_plans_for_host(context, host)


def migration_mark_incomplete_as_error(context, host):
    return IMPL.migration_mark_incomplete_as_error(context, host)


def migration_plans_mark_deleting_as_error(context, host):
     return IMPL.migration_plans_mark_deleting_as_error(context, host)


""" Backup Targets """
def backup_target_create(context, values):
    """Create a backup target from the values dictionary."""
    return IMPL.backup_target_create(context, values)

def backup_target_delete(context, backup_target_id):
    """Delete the backup target or raise if it does not exist."""
    return IMPL.backup_target_delete(context, backup_target_id)

def backup_target_update(context, backup_target_id, values):
    """
    Set the given properties on a backup target and update it.
    Raises NotFound if backup target does not exist.
    """
    return IMPL.backup_target_update(context, backup_target_id, values)

def backup_target_get_all(context):
    """Get all backup targets."""
    return IMPL.backup_target_get_all(context)

def backup_target_show(context, backup_target_id):
    """Get more details of the backup target"""
    return IMPL.backup_target_show(context, backup_target_id)

def get_backup_target_by_btt(context, backup_target_type):
    """ Get BT by backup_target_type name or id """
    return IMPL.get_backup_target_by_btt(context, backup_target_type)

def get_backup_target_by_backend_endpoint(context, backend_endpoint):
    """ Get BT by backend endpoint """
    return IMPL.get_backup_target_by_backend_endpoint(context, backend_endpoint)


""" Backup Target Types """
def backup_target_type_create(context, backup_target_id, values, project_list=[], purge_metadata=False, purge_projects=False):
    return IMPL.backup_target_type_create(context, backup_target_id, values, project_list, purge_metadata, purge_projects)

def backup_target_type_update(context, backup_target_type_id, values, project_list=[], purge_metadata=False, purge_projects=False):
    return IMPL.backup_target_type_update(context, backup_target_type_id, values, project_list, purge_metadata, purge_projects)

def backup_target_type_delete(context, backup_target_type_id):
    return IMPL.backup_target_type_delete(context, backup_target_type_id)

def backup_target_type_get_all(context, **kwargs):
    return IMPL.backup_target_type_get_all(context, **kwargs)

def backup_target_type_get_all_public_and_by_project_id(context, project_id=None, **kwargs):
    """ return all public BTT and BTT assigned to provided project """
    return IMPL.backup_target_type_get_all_public_and_by_project_id(context, project_id, **kwargs)

def backup_target_type_get_all_by_backup_target(context, backup_target_id, **kwargs):
    """Get all backup target types belonging to a backup target."""
    return IMPL.backup_target_type_get_all_by_backup_target(context, backup_target_id, **kwargs)

def backup_target_type_show(context, backup_target_type_id):
    """Get more details of the backup target type"""
    return IMPL.backup_target_type_show(context, backup_target_type_id)

def set_all_backup_target_type_to_non_default(context, backup_target_id):
    """ change all the BTT as non-default for non-default BT """
    return IMPL.set_all_backup_target_type_to_non_default(context, backup_target_id)

def get_default_backup_target_type(context):
    """ Get BT by backup_target_type nameor id """
    return IMPL.get_default_backup_target_type(context)

def backup_target_type_add_projects(context, backup_target_type_id, project_list=[]):
    """ Add projects to a BTT """
    return IMPL.backup_target_type_add_projects(context, backup_target_type_id, project_list)

def backup_target_type_remove_projects(context, backup_target_type_id, project_list=[]):
    """ Remove projects of a BTT """
    return IMPL.backup_target_type_remove_projects_api(context, backup_target_type_id, project_list)

def backup_target_type_add_metadata(context, backup_target_type_id, metadata=[]):
    """ Add metadata to a BTT """
    return IMPL.backup_target_type_add_metadata(context, backup_target_type_id, metadata)

def backup_target_type_remove_metadata(context, backup_target_type_id, metadata=[]):
    """ Remove metadata of a BTT """
    return IMPL.backup_target_type_remove_metadata(context, backup_target_type_id, metadata)