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

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

"""
Client side of the workload scheduler RPC API.
"""
from workloadmgr import flags
from workloadmgr.openstack.common import log as logging
import oslo_messaging as messaging
from workloadmgr import autolog
from workloadmgr import rpc

LOG = logging.getLogger(__name__)
Logger = autolog.Logger(LOG)
FLAGS = flags.FLAGS


class WorkloadMgrAPI():
    """
    Client side of the workloadmgr rpc API.
    API version history:
    1.0 - Initial version.
    2.0 - Using oslo_messaging module
    """

    BASE_RPC_API_VERSION = '2.0'

    @autolog.log_method(logger=Logger)
    def __init__(self):
        super(WorkloadMgrAPI, self).__init__()
        target = messaging.Target(topic=FLAGS.workloads_topic,
                   version=self.BASE_RPC_API_VERSION)
        self.client = rpc.get_client(target, self.BASE_RPC_API_VERSION)


    @autolog.log_method(logger=Logger, password_arg=5)
    def workload_type_discover_instances(
            self, ctxt, host, workload_type_id, metadata):
        LOG.debug(
            "workload_type_discover_instances in rpcapi workload_type_id %s",
            workload_type_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        instances = cctxt.call(ctxt, 'workload_type_discover_instances',
                                  workload_type_id=workload_type_id,
                                  metadata=metadata)
        return instances

    @autolog.log_method(logger=Logger, password_arg=5)
    def workload_type_topology(self, ctxt, host, workload_type_id, metadata):
        LOG.debug(
            "workload_type_topology in rpcapi workload_type_id %s",
            workload_type_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        topology = cctxt.call(ctxt, 'workload_type_topology',
                                 workload_type_id=workload_type_id,
                                 metadata=metadata)
        return topology

    @autolog.log_method(logger=Logger)
    def workload_discover_instances(self, ctxt, host, workload_id):
        LOG.debug(
            "workload_discover_instances in rpcapi workload_id %s",
            workload_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        instances = cctxt.call(ctxt, 'workload_discover_instances',
                                  workload_id=workload_id)
        return instances

    @autolog.log_method(logger=Logger)
    def workload_get_topology(self, ctxt, host, workload_id):
        LOG.debug(
            "workload_get_topology in rpcapi workload_id %s",
            workload_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        topology = cctxt.call(ctxt, 'workload_get_topology',
                              workload_id=workload_id)
        return topology

    @autolog.log_method(logger=Logger)
    def workload_get_workflow_details(self, ctxt, host, workload_id):
        LOG.debug(
            "workload_get_workflow_details in rpcapi workload_id %s",
            workload_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        workflow = cctxt.call(ctxt, 'workload_get_workflow_details',
                                 workload_id=workload_id)
        return workflow

    @autolog.log_method(logger=Logger)
    def workload_create(self, ctxt, host, workload_id):
        LOG.debug("create_workload in rpcapi workload_id %s", workload_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'workload_create', workload_id=workload_id)

    @autolog.log_method(logger=Logger)
    def file_search(self, ctxt, host, search_id):
        LOG.debug("file search in rpcapi search_id:%s", search_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'file_search', search_id=search_id)

    @autolog.log_method(logger=Logger)
    def workload_snapshot(self, ctxt, host, snapshot_id):
        LOG.debug("snapshot workload in rpcapi snapshot_id:%s", snapshot_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'workload_snapshot', snapshot_id=snapshot_id)

    @autolog.log_method(logger=Logger)
    def workload_reset(self, ctxt, host, workload_id):
        LOG.debug("workload_reset workload_id:%s", workload_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.call(ctxt, 'workload_reset', workload_id=workload_id) 

    @autolog.log_method(logger=Logger)
    def workload_delete(self, ctxt, host, workload_id):
        LOG.debug("delete_workload  rpcapi workload_id %s", workload_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'workload_delete', workload_id=workload_id)

    @autolog.log_method(logger=Logger)
    def security_groups_restore(self, ctxt, host, restore_id):
        LOG.debug(
            "security groups restore is in rpcapi restore_id %s", restore_id
        )
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(
            ctxt, 'security_groups_restore', restore_id=restore_id
        )

    @autolog.log_method(logger=Logger)
    def network_topology_restore(self, ctxt, host, restore_id):
        LOG.debug("network topology restore is in rpcapi restore_id %s", restore_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'network_topology_restore', restore_id=restore_id)

    @autolog.log_method(logger=Logger)
    def snapshot_restore(self, ctxt, host, restore_id):
        LOG.debug("restore_snapshot in rpcapi restore_id %s", restore_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'snapshot_restore', restore_id=restore_id)

    @autolog.log_method(logger=Logger)
    def snapshot_delete(self, ctxt, host, snapshot_id, task_id):
        LOG.debug("delete_snapshot  rpcapi snapshot_id %s", snapshot_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'snapshot_delete',
                      snapshot_id=snapshot_id,
                      task_id=task_id)

    @autolog.log_method(logger=Logger)
    def snapshot_mount(self, ctxt, host, snapshot_id, mount_vm_id):
        LOG.debug("snapshot_mount in rpcapi snapshot_id %s, mount_vm_id %s",
                  snapshot_id, mount_vm_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'snapshot_mount',
                          snapshot_id=snapshot_id,
                          mount_vm_id=mount_vm_id)

    @autolog.log_method(logger=Logger)
    def snapshot_dismount(self, ctxt, host, snapshot_id):
        LOG.debug("snapshot_dismount in rpcapi snapshot_id %s",
                  snapshot_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        return cctxt.call(ctxt, 'snapshot_dismount',
                     snapshot_id=snapshot_id)

    @autolog.log_method(logger=Logger)
    def restore_delete(self, ctxt, host, restore_id):
        LOG.debug("delete_restore  rpcapi restore_id %s", restore_id)
        cctxt = self.client.prepare(server=host, timeout=300)
        return cctxt.call(ctxt, 'restore_delete', restore_id=restore_id)

    @autolog.log_method(logger=Logger)
    def config_backup(self, ctxt, host, backup_id):
        LOG.debug("config_backup in rpcapi backup_id:%s", backup_id)
        cctxt = self.client.prepare(server=host)
        return cctxt.cast(ctxt, 'config_backup',
                          backup_id=backup_id)