# Copyright 2014 VMware, 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.
#

from neutron_lib import exceptions as n_exc
from oslo_config import cfg
from oslo_db import exception as db_exc
from oslo_log import log as logging
from oslo_utils import excutils

from vmware_nsx._i18n import _
from vmware_nsx.api_client import exception as api_exc
from vmware_nsx.common import exceptions as p_exc
from vmware_nsx.common import nsx_utils
from vmware_nsx.db import lsn_db
from vmware_nsx.dhcp_meta import constants as const
from vmware_nsx.nsxlib.mh import lsn as lsn_api
from vmware_nsx.nsxlib.mh import switch as switch_api

LOG = logging.getLogger(__name__)

META_CONF = 'metadata-proxy'
DHCP_CONF = 'dhcp'


lsn_opts = [
    cfg.BoolOpt('sync_on_missing_data', default=False,
                help=_('Pull LSN information from NSX in case it is missing '
                       'from the local data store. This is useful to rebuild '
                       'the local store in case of server recovery.'))
]


def register_lsn_opts(config):
    config.CONF.register_opts(lsn_opts, "NSX_LSN")


class LsnManager(object):
    """Manage LSN entities associated with networks."""

    def __init__(self, plugin):
        self.plugin = plugin

    @property
    def cluster(self):
        return self.plugin.cluster

    def lsn_exists(self, context, network_id):
        """Return True if a Logical Service Node exists for the network."""
        return self.lsn_get(
            context, network_id, raise_on_err=False) is not None

    def lsn_get(self, context, network_id, raise_on_err=True):
        """Retrieve the LSN id associated to the network."""
        try:
            return lsn_api.lsn_for_network_get(self.cluster, network_id)
        except (n_exc.NotFound, api_exc.NsxApiException):
            if raise_on_err:
                LOG.error('Unable to find Logical Service Node for '
                          'network %s.',
                          network_id)
                raise p_exc.LsnNotFound(entity='network',
                                        entity_id=network_id)
            else:
                LOG.warning('Unable to find Logical Service Node for '
                            'the requested network %s.',
                            network_id)

    def lsn_create(self, context, network_id):
        """Create a LSN associated to the network."""
        try:
            return lsn_api.lsn_for_network_create(self.cluster, network_id)
        except api_exc.NsxApiException:
            err_msg = _('Unable to create LSN for network %s') % network_id
            raise p_exc.NsxPluginException(err_msg=err_msg)

    def lsn_delete(self, context, lsn_id):
        """Delete a LSN given its id."""
        try:
            lsn_api.lsn_delete(self.cluster, lsn_id)
        except (n_exc.NotFound, api_exc.NsxApiException):
            LOG.warning('Unable to delete Logical Service Node %s',
                        lsn_id)

    def lsn_delete_by_network(self, context, network_id):
        """Delete a LSN associated to the network."""
        lsn_id = self.lsn_get(context, network_id, raise_on_err=False)
        if lsn_id:
            self.lsn_delete(context, lsn_id)

    def lsn_port_get(self, context, network_id, subnet_id, raise_on_err=True):
        """Retrieve LSN and LSN port for the network and the subnet."""
        lsn_id = self.lsn_get(context, network_id, raise_on_err=raise_on_err)
        if lsn_id:
            try:
                lsn_port_id = lsn_api.lsn_port_by_subnet_get(
                    self.cluster, lsn_id, subnet_id)
            except (n_exc.NotFound, api_exc.NsxApiException):
                if raise_on_err:
                    LOG.error('Unable to find Logical Service Node Port '
                              'for LSN %(lsn_id)s and subnet '
                              '%(subnet_id)s',
                              {'lsn_id': lsn_id, 'subnet_id': subnet_id})
                    raise p_exc.LsnPortNotFound(lsn_id=lsn_id,
                                                entity='subnet',
                                                entity_id=subnet_id)
                else:
                    LOG.warning('Unable to find Logical Service Node Port '
                                'for LSN %(lsn_id)s and subnet '
                                '%(subnet_id)s',
                                {'lsn_id': lsn_id, 'subnet_id': subnet_id})
                return (lsn_id, None)
            else:
                return (lsn_id, lsn_port_id)
        else:
            return (None, None)

    def lsn_port_get_by_mac(self, context, network_id, mac, raise_on_err=True):
        """Retrieve LSN and LSN port given network and mac address."""
        lsn_id = self.lsn_get(context, network_id, raise_on_err=raise_on_err)
        if lsn_id:
            try:
                lsn_port_id = lsn_api.lsn_port_by_mac_get(
                    self.cluster, lsn_id, mac)
            except (n_exc.NotFound, api_exc.NsxApiException):
                if raise_on_err:
                    LOG.error('Unable to find Logical Service Node Port '
                              'for LSN %(lsn_id)s and mac address '
                              '%(mac)s',
                              {'lsn_id': lsn_id, 'mac': mac})
                    raise p_exc.LsnPortNotFound(lsn_id=lsn_id,
                                                entity='MAC',
                                                entity_id=mac)
                else:
                    LOG.warning('Unable to find Logical Service Node '
                                'Port for LSN %(lsn_id)s and mac address '
                                '%(mac)s',
                                {'lsn_id': lsn_id, 'mac': mac})
                return (lsn_id, None)
            else:
                return (lsn_id, lsn_port_id)
        else:
            return (None, None)

    def lsn_port_create(self, context, lsn_id, subnet_info):
        """Create and return LSN port for associated subnet."""
        try:
            return lsn_api.lsn_port_create(self.cluster, lsn_id, subnet_info)
        except n_exc.NotFound:
            raise p_exc.LsnNotFound(entity='', entity_id=lsn_id)
        except api_exc.NsxApiException:
            err_msg = _('Unable to create port for LSN  %s') % lsn_id
            raise p_exc.NsxPluginException(err_msg=err_msg)

    def lsn_port_delete(self, context, lsn_id, lsn_port_id):
        """Delete a LSN port from the Logical Service Node."""
        try:
            lsn_api.lsn_port_delete(self.cluster, lsn_id, lsn_port_id)
        except (n_exc.NotFound, api_exc.NsxApiException):
            LOG.warning('Unable to delete LSN Port %s', lsn_port_id)

    def lsn_port_dispose(self, context, network_id, mac_address):
        """Delete a LSN port given the network and the mac address."""
        lsn_id, lsn_port_id = self.lsn_port_get_by_mac(
            context, network_id, mac_address, raise_on_err=False)
        if lsn_port_id:
            self.lsn_port_delete(context, lsn_id, lsn_port_id)
            if mac_address == const.METADATA_MAC:
                try:
                    lswitch_port_id = switch_api.get_port_by_neutron_tag(
                        self.cluster, network_id,
                        const.METADATA_PORT_ID)['uuid']
                    switch_api.delete_port(
                        self.cluster, network_id, lswitch_port_id)
                except (n_exc.PortNotFoundOnNetwork,
                        api_exc.NsxApiException):
                    LOG.warning("Metadata port not found while attempting "
                                "to delete it from network %s",
                                network_id)
        else:
            LOG.warning("Unable to find Logical Services Node "
                        "Port with MAC %s", mac_address)

    def lsn_port_dhcp_setup(
        self, context, network_id, port_id, port_data, subnet_config=None):
        """Connect network to LSN via specified port and port_data."""
        try:
            lsn_id = None
            switch_id = nsx_utils.get_nsx_switch_ids(
                context.session, self.cluster, network_id)[0]
            lswitch_port_id = switch_api.get_port_by_neutron_tag(
                self.cluster, switch_id, port_id)['uuid']
            lsn_id = self.lsn_get(context, network_id)
            lsn_port_id = self.lsn_port_create(context, lsn_id, port_data)
        except (n_exc.NotFound, p_exc.NsxPluginException):
            raise p_exc.PortConfigurationError(
                net_id=network_id, lsn_id=lsn_id, port_id=port_id)
        else:
            try:
                lsn_api.lsn_port_plug_network(
                    self.cluster, lsn_id, lsn_port_id, lswitch_port_id)
            except p_exc.LsnConfigurationConflict:
                self.lsn_port_delete(context, lsn_id, lsn_port_id)
                raise p_exc.PortConfigurationError(
                    net_id=network_id, lsn_id=lsn_id, port_id=port_id)
            if subnet_config:
                self.lsn_port_dhcp_configure(
                    context, lsn_id, lsn_port_id, subnet_config)
            else:
                return (lsn_id, lsn_port_id)

    def lsn_port_metadata_setup(self, context, lsn_id, subnet):
        """Connect subnet to specified LSN."""
        data = {
            "mac_address": const.METADATA_MAC,
            "ip_address": subnet['cidr'],
            "subnet_id": subnet['id']
        }
        network_id = subnet['network_id']
        tenant_id = subnet['tenant_id']
        lswitch_port_id = None
        try:
            switch_id = nsx_utils.get_nsx_switch_ids(
                context.session, self.cluster, network_id)[0]
            lswitch_port_id = switch_api.create_lport(
                self.cluster, switch_id, tenant_id,
                const.METADATA_PORT_ID, const.METADATA_PORT_NAME,
                const.METADATA_DEVICE_ID, True)['uuid']
            lsn_port_id = self.lsn_port_create(context, lsn_id, data)
        except (n_exc.NotFound, p_exc.NsxPluginException,
                api_exc.NsxApiException):
            raise p_exc.PortConfigurationError(
                net_id=network_id, lsn_id=lsn_id, port_id=lswitch_port_id)
        else:
            try:
                lsn_api.lsn_port_plug_network(
                    self.cluster, lsn_id, lsn_port_id, lswitch_port_id)
            except p_exc.LsnConfigurationConflict:
                self.lsn_port_delete(self.cluster, lsn_id, lsn_port_id)
                switch_api.delete_port(
                    self.cluster, network_id, lswitch_port_id)
                raise p_exc.PortConfigurationError(
                    net_id=network_id, lsn_id=lsn_id, port_id=lsn_port_id)

    def lsn_port_dhcp_configure(self, context, lsn_id, lsn_port_id, subnet):
        """Enable/disable dhcp services with the given config options."""
        is_enabled = subnet["enable_dhcp"]
        dhcp_options = {
            "domain_name": cfg.CONF.NSX_DHCP.domain_name,
            "default_lease_time": cfg.CONF.NSX_DHCP.default_lease_time,
        }
        dns_servers = cfg.CONF.NSX_DHCP.extra_domain_name_servers or []
        dns_servers.extend(subnet["dns_nameservers"])
        if subnet['gateway_ip']:
            dhcp_options["routers"] = subnet["gateway_ip"]
        if dns_servers:
            dhcp_options["domain_name_servers"] = ",".join(dns_servers)
        if subnet["host_routes"]:
            dhcp_options["classless_static_routes"] = (
                ",".join(subnet["host_routes"])
            )
        try:
            lsn_api.lsn_port_dhcp_configure(
                self.cluster, lsn_id, lsn_port_id, is_enabled, dhcp_options)
        except (n_exc.NotFound, api_exc.NsxApiException):
            err_msg = (_('Unable to configure dhcp for Logical Service '
                         'Node %(lsn_id)s and port %(lsn_port_id)s')
                       % {'lsn_id': lsn_id, 'lsn_port_id': lsn_port_id})
            LOG.error(err_msg)
            raise p_exc.NsxPluginException(err_msg=err_msg)

    def lsn_metadata_configure(self, context, subnet_id, is_enabled):
        """Configure metadata service for the specified subnet."""
        subnet = self.plugin.get_subnet(context, subnet_id)
        network_id = subnet['network_id']
        meta_conf = cfg.CONF.NSX_METADATA
        metadata_options = {
            'metadata_server_ip': meta_conf.metadata_server_address,
            'metadata_server_port': meta_conf.metadata_server_port,
            'metadata_proxy_shared_secret': meta_conf.metadata_shared_secret
        }
        try:
            lsn_id = self.lsn_get(context, network_id)
            lsn_api.lsn_metadata_configure(
                self.cluster, lsn_id, is_enabled, metadata_options)
        except (p_exc.LsnNotFound, api_exc.NsxApiException):
            err_msg = (_('Unable to configure metadata '
                         'for subnet %s') % subnet_id)
            LOG.error(err_msg)
            raise p_exc.NsxPluginException(err_msg=err_msg)
        if is_enabled:
            try:
                # test that the lsn port exists
                self.lsn_port_get(context, network_id, subnet_id)
            except p_exc.LsnPortNotFound:
                # this might happen if subnet had dhcp off when created
                # so create one, and wire it
                self.lsn_port_metadata_setup(context, lsn_id, subnet)
        else:
            self.lsn_port_dispose(context, network_id, const.METADATA_MAC)

    def _lsn_port_host_conf(self, context, network_id, subnet_id, data, hdlr):
        lsn_id, lsn_port_id = self.lsn_port_get(
            context, network_id, subnet_id, raise_on_err=False)
        try:
            if lsn_id and lsn_port_id:
                hdlr(self.cluster, lsn_id, lsn_port_id, data)
        except (n_exc.NotFound, api_exc.NsxApiException):
            LOG.error('Error while configuring LSN '
                      'port %s', lsn_port_id)
            raise p_exc.PortConfigurationError(
                net_id=network_id, lsn_id=lsn_id, port_id=lsn_port_id)

    def lsn_port_dhcp_host_add(self, context, network_id, subnet_id, host):
        """Add dhcp host entry to LSN port configuration."""
        self._lsn_port_host_conf(context, network_id, subnet_id, host,
                                 lsn_api.lsn_port_dhcp_host_add)

    def lsn_port_dhcp_host_remove(self, context, network_id, subnet_id, host):
        """Remove dhcp host entry from LSN port configuration."""
        self._lsn_port_host_conf(context, network_id, subnet_id, host,
                                 lsn_api.lsn_port_dhcp_host_remove)

    def lsn_port_meta_host_add(self, context, network_id, subnet_id, host):
        """Add dhcp host entry to LSN port configuration."""
        self._lsn_port_host_conf(context, network_id, subnet_id, host,
                                 lsn_api.lsn_port_metadata_host_add)

    def lsn_port_meta_host_remove(self, context, network_id, subnet_id, host):
        """Remove dhcp host entry from LSN port configuration."""
        self._lsn_port_host_conf(context, network_id, subnet_id, host,
                                 lsn_api.lsn_port_metadata_host_remove)

    def lsn_port_update(
        self, context, network_id, subnet_id, dhcp=None, meta=None):
        """Update the specified configuration for the LSN port."""
        if not dhcp and not meta:
            return
        try:
            lsn_id, lsn_port_id = self.lsn_port_get(
                context, network_id, subnet_id, raise_on_err=False)
            if dhcp and lsn_id and lsn_port_id:
                lsn_api.lsn_port_host_entries_update(
                    self.cluster, lsn_id, lsn_port_id, DHCP_CONF, dhcp)
            if meta and lsn_id and lsn_port_id:
                lsn_api.lsn_port_host_entries_update(
                    self.cluster, lsn_id, lsn_port_id, META_CONF, meta)
        except api_exc.NsxApiException:
            raise p_exc.PortConfigurationError(
                net_id=network_id, lsn_id=lsn_id, port_id=lsn_port_id)


class PersistentLsnManager(LsnManager):
    """Add local persistent state to LSN Manager."""

    def __init__(self, plugin):
        super(PersistentLsnManager, self).__init__(plugin)
        self.sync_on_missing = cfg.CONF.NSX_LSN.sync_on_missing_data

    def lsn_get(self, context, network_id, raise_on_err=True):
        try:
            obj = lsn_db.lsn_get_for_network(
                context, network_id, raise_on_err=raise_on_err)
            return obj.lsn_id if obj else None
        except p_exc.LsnNotFound:
            with excutils.save_and_reraise_exception() as ctxt:
                ctxt.reraise = False
                if self.sync_on_missing:
                    lsn_id = super(PersistentLsnManager, self).lsn_get(
                        context, network_id, raise_on_err=raise_on_err)
                    self.lsn_save(context, network_id, lsn_id)
                    return lsn_id
                if raise_on_err:
                    ctxt.reraise = True

    def lsn_save(self, context, network_id, lsn_id):
        """Save LSN-Network mapping to the DB."""
        try:
            lsn_db.lsn_add(context, network_id, lsn_id)
        except db_exc.DBError:
            err_msg = _('Unable to save LSN for network %s') % network_id
            LOG.exception(err_msg)
            raise p_exc.NsxPluginException(err_msg=err_msg)

    def lsn_create(self, context, network_id):
        lsn_id = super(PersistentLsnManager,
                       self).lsn_create(context, network_id)
        try:
            self.lsn_save(context, network_id, lsn_id)
        except p_exc.NsxPluginException:
            with excutils.save_and_reraise_exception():
                super(PersistentLsnManager, self).lsn_delete(context, lsn_id)
        return lsn_id

    def lsn_delete(self, context, lsn_id):
        lsn_db.lsn_remove(context, lsn_id)
        super(PersistentLsnManager, self).lsn_delete(context, lsn_id)

    def lsn_port_get(self, context, network_id, subnet_id, raise_on_err=True):
        try:
            obj = lsn_db.lsn_port_get_for_subnet(
                context, subnet_id, raise_on_err=raise_on_err)
            return (obj.lsn_id, obj.lsn_port_id) if obj else (None, None)
        except p_exc.LsnPortNotFound:
            with excutils.save_and_reraise_exception() as ctxt:
                ctxt.reraise = False
                if self.sync_on_missing:
                    lsn_id, lsn_port_id = (
                        super(PersistentLsnManager, self).lsn_port_get(
                            context, network_id, subnet_id,
                            raise_on_err=raise_on_err))
                    mac_addr = lsn_api.lsn_port_info_get(
                        self.cluster, lsn_id, lsn_port_id)['mac_address']
                    self.lsn_port_save(
                        context, lsn_port_id, subnet_id, mac_addr, lsn_id)
                    return (lsn_id, lsn_port_id)
                if raise_on_err:
                    ctxt.reraise = True

    def lsn_port_get_by_mac(self, context, network_id, mac, raise_on_err=True):
        try:
            obj = lsn_db.lsn_port_get_for_mac(
                context, mac, raise_on_err=raise_on_err)
            return (obj.lsn_id, obj.lsn_port_id) if obj else (None, None)
        except p_exc.LsnPortNotFound:
            with excutils.save_and_reraise_exception() as ctxt:
                ctxt.reraise = False
                if self.sync_on_missing:
                    lsn_id, lsn_port_id = (
                        super(PersistentLsnManager, self).lsn_port_get_by_mac(
                            context, network_id, mac,
                            raise_on_err=raise_on_err))
                    subnet_id = lsn_api.lsn_port_info_get(
                        self.cluster, lsn_id, lsn_port_id).get('subnet_id')
                    self.lsn_port_save(
                        context, lsn_port_id, subnet_id, mac, lsn_id)
                    return (lsn_id, lsn_port_id)
                if raise_on_err:
                    ctxt.reraise = True

    def lsn_port_save(self, context, lsn_port_id, subnet_id, mac_addr, lsn_id):
        """Save LSN Port information to the DB."""
        try:
            lsn_db.lsn_port_add_for_lsn(
                context, lsn_port_id, subnet_id, mac_addr, lsn_id)
        except db_exc.DBError:
            err_msg = _('Unable to save LSN port for subnet %s') % subnet_id
            LOG.exception(err_msg)
            raise p_exc.NsxPluginException(err_msg=err_msg)

    def lsn_port_create(self, context, lsn_id, subnet_info):
        lsn_port_id = super(PersistentLsnManager,
                            self).lsn_port_create(context, lsn_id, subnet_info)
        try:
            self.lsn_port_save(context, lsn_port_id, subnet_info['subnet_id'],
                               subnet_info['mac_address'], lsn_id)
        except p_exc.NsxPluginException:
            with excutils.save_and_reraise_exception():
                super(PersistentLsnManager, self).lsn_port_delete(
                    context, lsn_id, lsn_port_id)
        return lsn_port_id

    def lsn_port_delete(self, context, lsn_id, lsn_port_id):
        lsn_db.lsn_port_remove(context, lsn_port_id)
        super(PersistentLsnManager, self).lsn_port_delete(
            context, lsn_id, lsn_port_id)
