# Copyright (c) 2019 EMC Corporation.
# 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.

"""
EMC specific NAS storage driver. This driver is a pluggable driver
that allows specific EMC NAS devices to be plugged-in as the underlying
backend. Use the Manila configuration variable "share_backend_name"
to specify, which backend plugins to use.
"""

from oslo_config import cfg
from oslo_log import log

from manila.share import driver
from manila.share.drivers.dell_emc import plugin_manager as manager

EMC_NAS_OPTS = [
    cfg.StrOpt('emc_nas_login',
               help='User name for the EMC server.'),
    cfg.StrOpt('emc_nas_password',
               help='Password for the EMC server.'),
    cfg.HostAddressOpt('emc_nas_server',
                       help='EMC server hostname or IP address.'),
    cfg.PortOpt('emc_nas_server_port',
                default=8080,
                help='Port number for the EMC server.'),
    cfg.BoolOpt('emc_nas_server_secure',
                default=True,
                help='Use secure connection to server.'),
    cfg.StrOpt('emc_share_backend',
               ignore_case=True,
               choices=['isilon', 'vnx', 'unity', 'vmax', 'powermax'],
               help='Share backend.'),
    cfg.StrOpt('emc_nas_root_dir',
               help='The root directory where shares will be located.'),
    cfg.BoolOpt('emc_ssl_cert_verify',
                default=True,
                help='If set to False the https client will not validate the '
                     'SSL certificate of the backend endpoint.'),
    cfg.StrOpt('emc_ssl_cert_path',
               help='Can be used to specify a non default path to a '
                    'CA_BUNDLE file or directory with certificates of trusted '
                    'CAs, which will be used to validate the backend.')
]

LOG = log.getLogger(__name__)

CONF = cfg.CONF
CONF.register_opts(EMC_NAS_OPTS)


class EMCShareDriver(driver.ShareDriver):
    """EMC specific NAS driver. Allows for NFS and CIFS NAS storage usage."""

    def __init__(self, *args, **kwargs):
        self.configuration = kwargs.get('configuration', None)
        if self.configuration:
            self.configuration.append_config_values(EMC_NAS_OPTS)
            self.backend_name = self.configuration.safe_get(
                'emc_share_backend')
        else:
            self.backend_name = CONF.emc_share_backend
        self.backend_name = self.backend_name or 'EMC_NAS_Storage'
        self.plugin_manager = manager.EMCPluginManager(
            namespace='manila.share.drivers.dell_emc.plugins')
        if self.backend_name == 'vmax':
            LOG.warning("Configuration option 'emc_share_backend=vmax' will "
                        "remain a valid option until the V release of "
                        "OpenStack. After that, only "
                        "'emc_share_backend=powermax' will be excepted.")
            self.backend_name = 'powermax'
        self.plugin = self.plugin_manager.load_plugin(
            self.backend_name,
            configuration=self.configuration)
        super(EMCShareDriver, self).__init__(
            self.plugin.driver_handles_share_servers, *args, **kwargs)

        self.dhss_mandatory_security_service_association = (
            self.plugin.dhss_mandatory_security_service_association)

        if hasattr(self.plugin, 'ipv6_implemented'):
            self.ipv6_implemented = self.plugin.ipv6_implemented

        if hasattr(self.plugin, 'revert_to_snap_support'):
            self.revert_to_snap_support = self.plugin.revert_to_snap_support
        else:
            self.revert_to_snap_support = False

        if hasattr(self.plugin, 'shrink_share_support'):
            self.shrink_share_support = self.plugin.shrink_share_support
        else:
            self.shrink_share_support = False

        if hasattr(self.plugin, 'manage_existing_support'):
            self.manage_existing_support = self.plugin.manage_existing_support
        else:
            self.manage_existing_support = False

        if hasattr(self.plugin, 'manage_existing_with_server_support'):
            self.manage_existing_with_server_support = (
                self.plugin.manage_existing_with_server_support)
        else:
            self.manage_existing_with_server_support = False

        if hasattr(self.plugin, 'manage_existing_snapshot_support'):
            self.manage_existing_snapshot_support = (
                self.plugin.manage_existing_snapshot_support)
        else:
            self.manage_existing_snapshot_support = False

        if hasattr(self.plugin, 'manage_snapshot_with_server_support'):
            self.manage_snapshot_with_server_support = (
                self.plugin.manage_snapshot_with_server_support)
        else:
            self.manage_snapshot_with_server_support = False

        if hasattr(self.plugin, 'manage_server_support'):
            self.manage_server_support = self.plugin.manage_server_support
        else:
            self.manage_server_support = False

        if hasattr(self.plugin, 'get_share_server_network_info_support'):
            self.get_share_server_network_info_support = (
                self.plugin.get_share_server_network_info_support)
        else:
            self.get_share_server_network_info_support = False

    def manage_existing(self, share, driver_options):
        """manage an existing share"""
        if self.manage_existing_support:
            return self.plugin.manage_existing(share, driver_options)
        else:
            return NotImplementedError()

    def manage_existing_with_server(self, share, driver_options,
                                    share_server=None):
        """manage an existing share"""
        if self.manage_existing_with_server_support:
            return self.plugin.manage_existing_with_server(
                share, driver_options, share_server)
        else:
            return NotImplementedError()

    def manage_existing_snapshot(self, snapshot, driver_options):
        """manage an existing share snapshot"""
        if self.manage_existing_snapshot_support:
            return self.plugin.manage_existing_snapshot(snapshot,
                                                        driver_options)
        else:
            return NotImplementedError()

    def manage_existing_snapshot_with_server(self, snapshot, driver_options,
                                             share_server=None):
        """manage an existing share snapshot"""
        if self.manage_snapshot_with_server_support:
            return self.plugin.manage_existing_snapshot_with_server(
                snapshot, driver_options, share_server=None)
        else:
            return NotImplementedError()

    def manage_server(self, context, share_server, identifier,
                      driver_options):
        if self.manage_server_support:
            return self.plugin.manage_server(context, share_server,
                                             identifier, driver_options)
        else:
            return NotImplementedError()

    def get_share_server_network_info(
            self, context, share_server, identifier, driver_options):
        if self.get_share_server_network_info_support:
            return self.plugin.get_share_server_network_info(
                context, share_server, identifier, driver_options)
        else:
            return NotImplementedError()

    def unmanage_server(self, server_details, security_services=None):
        LOG.info('Dell EMC driver will unmanage share server: %s out of '
                 'OpenStack.', server_details.get('server_id'))

    def unmanage(self, share):
        LOG.info('Dell EMC driver will unmanage share: %s out of '
                 'OpenStack.', share.get('id'))

    def unmanage_with_server(self, share, share_server=None):
        LOG.info('Dell EMC driver will unmanage share: %s out of '
                 'OpenStack.', share.get('id'))

    def unmanage_snapshot(self, snapshot):
        LOG.info('Dell EMC driver will unmanage snapshot: %s out of '
                 'OpenStack.', snapshot.get('id'))

    def unmanage_snapshot_with_server(self, snapshot, share_server=None):
        LOG.info('Dell EMC driver will unmanage snapshot: %s out of '
                 'OpenStack.', snapshot.get('id'))

    def create_share(self, context, share, share_server=None):
        """Is called to create share."""
        location = self.plugin.create_share(context, share, share_server)

        return location

    def create_share_from_snapshot(self, context, share, snapshot,
                                   share_server=None, parent_share=None):
        """Is called to create share from snapshot."""
        location = self.plugin.create_share_from_snapshot(
            context, share, snapshot, share_server)

        return location

    def extend_share(self, share, new_size, share_server=None):
        """Is called to extend share."""
        self.plugin.extend_share(share, new_size, share_server)

    def shrink_share(self, share, new_size, share_server=None):
        """Is called to shrink share."""
        if self.shrink_share_support:
            self.plugin.shrink_share(share, new_size, share_server)
        else:
            raise NotImplementedError()

    def create_snapshot(self, context, snapshot, share_server=None):
        """Is called to create snapshot."""
        return self.plugin.create_snapshot(context, snapshot, share_server)

    def delete_share(self, context, share, share_server=None):
        """Is called to remove share."""
        self.plugin.delete_share(context, share, share_server)

    def delete_snapshot(self, context, snapshot, share_server=None):
        """Is called to remove snapshot."""
        self.plugin.delete_snapshot(context, snapshot, share_server)

    def ensure_share(self, context, share, share_server=None):
        """Invoked to sure that share is exported."""
        self.plugin.ensure_share(context, share, share_server)

    def allow_access(self, context, share, access, share_server=None):
        """Allow access to the share."""
        self.plugin.allow_access(context, share, access, share_server)

    def deny_access(self, context, share, access, share_server=None):
        """Deny access to the share."""
        self.plugin.deny_access(context, share, access, share_server)

    def update_access(self, context, share, access_rules, add_rules,
                      delete_rules, share_server=None):
        """Update access to the share."""
        self.plugin.update_access(context, share, access_rules, add_rules,
                                  delete_rules, share_server)

    def check_for_setup_error(self):
        """Check for setup error."""
        self.plugin.check_for_setup_error()

    def do_setup(self, context):
        """Any initialization the share driver does while starting."""
        self.plugin.connect(self, context)

    def _update_share_stats(self):
        """Retrieve stats info from share."""

        backend_name = self.configuration.safe_get(
            'share_backend_name') or "EMC_NAS_Storage"
        data = dict(
            share_backend_name=backend_name,
            vendor_name='Dell EMC',
            storage_protocol='NFS_CIFS',
            snapshot_support=True,
            create_share_from_snapshot_support=True,
            revert_to_snapshot_support=self.revert_to_snap_support)
        self.plugin.update_share_stats(data)
        super(EMCShareDriver, self)._update_share_stats(data)

    def get_network_allocations_number(self):
        """Returns number of network allocations for creating VIFs."""
        return self.plugin.get_network_allocations_number()

    def _setup_server(self, network_info, metadata=None):
        """Set up and configures share server with given network parameters."""
        return self.plugin.setup_server(network_info, metadata)

    def _teardown_server(self, server_details, security_services=None):
        """Teardown share server."""
        return self.plugin.teardown_server(server_details, security_services)

    def get_configured_ip_versions(self):
        if self.ipv6_implemented:
            return [4, 6]
        else:
            return [4]

    def revert_to_snapshot(self, context, snapshot, share_access_rules,
                           snapshot_access_rules, share_server=None):
        if self.revert_to_snap_support:
            return self.plugin.revert_to_snapshot(context, snapshot,
                                                  share_access_rules,
                                                  snapshot_access_rules,
                                                  share_server)
        else:
            raise NotImplementedError()

    def get_default_filter_function(self):
        if hasattr(self.plugin, 'get_default_filter_function'):
            return self.plugin.get_default_filter_function()
        return None
