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

# Copyright 2012 Nicira Networks, Inc.  All rights reserved.

#

# Copyright (c) 2014, Oracle and/or its affiliates. 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.

#

# @author: Dan Wendlandt, Nicira, Inc

# @author: Girish Moodalbail, Oracle, Inc.

#

"""

"""

import sqlalchemy as sa

LOG = logging.getLogger(__name__)

DEVICE_OWNER_ROUTER_INTF = l3_constants.DEVICE_OWNER_ROUTER_INTF

DEVICE_OWNER_ROUTER_GW = l3_constants.DEVICE_OWNER_ROUTER_GW

DEVICE_OWNER_FLOATINGIP = l3_constants.DEVICE_OWNER_FLOATINGIP

class Router(evs_db.EVS_DB_BASE):

    id = sa.Column(sa.String(36), primary_key=True,

                   default=uuidutils.generate_uuid)

    name = sa.Column(sa.String(255))

    status = sa.Column(sa.String(16))

    admin_state_up = sa.Column(sa.Boolean)

    tenant_id = sa.Column(sa.String(255))

    gw_port_id = sa.Column(sa.String(36))

    gw_port_network_id = sa.Column(sa.String(36))

class FloatingIP(evs_db.EVS_DB_BASE):

    id = sa.Column(sa.String(36), primary_key=True,

                   default=uuidutils.generate_uuid)

    floating_ip_address = sa.Column(sa.String(64), nullable=False)

    floating_network_id = sa.Column(sa.String(36), nullable=False)

    floating_port_id = sa.Column(sa.String(36), nullable=False)

    fixed_port_id = sa.Column(sa.String(36))

    fixed_ip_address = sa.Column(sa.String(64))

    router_id = sa.Column(sa.String(36), sa.ForeignKey('routers.id'))

    tenant_id = sa.Column(sa.String(255))

class EVS_L3_NAT_db_mixin(l3_db.L3_NAT_db_mixin):

    """Mixin class to add L3/NAT router methods"""

    Router = Router

    FloatingIP = FloatingIP

        res = {'id': router['id'],

               'name': router['name'],

               'tenant_id': router['tenant_id'],

               'admin_state_up': router['admin_state_up'],

               'status': router['status'],

        if router['gw_port_id']:

            nw_id = router['gw_port_network_id']

            res['external_gateway_info'] = {'network_id': nw_id}

        return self._fields(res, fields)

    def create_router(self, context, router):

        return super(EVS_L3_NAT_db_mixin, self).\

            create_router(evs_db.get_evs_context(context), router)

    def update_router(self, context, id, router):

        return super(EVS_L3_NAT_db_mixin, self).\

            update_router(evs_db.get_evs_context(context), id, router)

        """This method overrides the base class method and it's contents

        are exactly same as the base class method except that the Router

        DB columns are different for EVS and OVS"""

        gw_port_id = router['gw_port_id']

        gw_port_network_id = router['gw_port_network_id']

        network_id = info.get('network_id', None) if info else None

        if network_id:

            self._get_network(context, network_id)

            if not self._network_is_external(context, network_id):

                msg = _("Network %s is not a valid external "

                        "network") % network_id

                raise q_exc.BadRequest(resource='router', msg=msg)

        # figure out if we need to delete existing port

        if gw_port_id and gw_port_network_id != network_id:

            fip_count = self.get_floatingips_count(context.elevated(),

                                                   {'router_id': [router_id]})

            if fip_count:

                raise l3.RouterExternalGatewayInUseByFloatingIp(

                    router_id=router_id, net_id=gw_port_network_id)

            with context.session.begin(subtransactions=True):

                router['gw_port_id'] = None

                router['gw_port_network_id'] = None

                context.session.add(router)

            self.delete_port(context.elevated(), gw_port_id,

                             l3_port_check=False)

        if network_id is not None and (gw_port_id is None or

                                       gw_port_network_id != network_id):

            subnets = self._get_subnets_by_network(context,

                                                   network_id)

            for subnet in subnets:

                self._check_for_dup_router_subnet(context, router_id,

                                                  network_id, subnet['id'],

                                                  subnet['cidr'])

            # Port has no 'tenant-id', as it is hidden from user

                'port':

                {'tenant_id': '',  # intentionally not set

                 'network_id': network_id,

                 'mac_address': attributes.ATTR_NOT_SPECIFIED,

                 'fixed_ips': attributes.ATTR_NOT_SPECIFIED,

                 'device_id': router_id,

                 'device_owner': DEVICE_OWNER_ROUTER_GW,

                 'admin_state_up': True,

                 'name': ''}})

                msg = (_('No IPs available for external network %s') %

                       network_id)

                raise q_exc.BadRequest(resource='router', msg=msg)

            with context.session.begin(subtransactions=True):

                router['gw_port_id'] = gw_port['id']

                router['gw_port_network_id'] = gw_port['network_id']

                context.session.add(router)

    def delete_router(self, context, id):

        super(EVS_L3_NAT_db_mixin, self).\

            delete_router(evs_db.get_evs_context(context), id)

    def get_router(self, context, id, fields=None):

        return super(EVS_L3_NAT_db_mixin, self).\

            get_router(evs_db.get_evs_context(context), id, fields)

    def get_routers(self, context, filters=None, fields=None,

                    sorts=None, limit=None, marker=None, page_reverse=False):

        query = evs_db.get_session().query(self.Router)

        if filters is not None:

            for key, value in filters.iteritems():

                column = getattr(self.Router, key, None)

                if column:

                    query = query.filter(column.in_(value))

        routers = query.all()

        retlist = []

        for router in routers:

            retlist.append(self._make_router_dict(router, fields))

        return retlist

    def get_routers_count(self, context, filters=None):

        return len(self.get_routers(context, filters))

    def add_router_interface(self, context, router_id, interface_info):

        return super(EVS_L3_NAT_db_mixin, self).\

            add_router_interface(evs_db.get_evs_context(context),

                                 router_id, interface_info)

    def remove_router_interface(self, context, router_id, interface_info):

            remove_router_interface(evs_db.get_evs_context(context),

                                    router_id, interface_info)

    def create_floatingip(self, context, floatingip):

        return super(EVS_L3_NAT_db_mixin, self).\

            create_floatingip(evs_db.get_evs_context(context), floatingip)

    def update_floatingip(self, context, id, floatingip):

        return super(EVS_L3_NAT_db_mixin, self).\

            update_floatingip(evs_db.get_evs_context(context), id, floatingip)

    def delete_floatingip(self, context, id):

        super(EVS_L3_NAT_db_mixin, self).\

            delete_floatingip(evs_db.get_evs_context(context), id)

    def get_floatingip(self, context, id, fields=None):

        return super(EVS_L3_NAT_db_mixin, self).\

            get_floatingip(evs_db.get_evs_context(context), id, fields)

    def get_floatingips(self, context, filters=None, fields=None,

                        sorts=None, limit=None, marker=None,

                        page_reverse=False):

        query = evs_db.get_session().query(self.FloatingIP)

        if filters:

            for key, value in filters.iteritems():

                column = getattr(self.FloatingIP, key, None)

                if column:

                    query = query.filter(column.in_(value))

        floatingips = query.all()

        retlist = []

        for floatingip in floatingips:

            retlist.append(self._make_floatingip_dict(floatingip, fields))

        return retlist

    def get_floatingips_count(self, context, filters=None):

        return len(self.get_floatingips(context, filters))

    def prevent_l3_port_deletion(self, context, port_id):

        """ Checks to make sure a port is allowed to be deleted, raising

        an exception if this is not the case.  This should be called by

        any plugin when the API requests the deletion of a port, since

        some ports for L3 are not intended to be deleted directly via a

        DELETE to /ports, but rather via other API calls that perform the

        proper deletion checks.

        """

        port = self.get_port(context, port_id)

        if port['device_owner'] in [DEVICE_OWNER_ROUTER_INTF,

                                    DEVICE_OWNER_ROUTER_GW,

                                    DEVICE_OWNER_FLOATINGIP]:

            raise l3.L3PortInUse(port_id=port_id,

                                 device_owner=port['device_owner'])

    def disassociate_floatingips(self, context, port_id):

        super(EVS_L3_NAT_db_mixin, self).\

            disassociate_floatingips(evs_db.get_evs_context(context), port_id)

    def get_sync_data(self, context, router_ids=None, active=None):

        return super(EVS_L3_NAT_db_mixin, self).\

            get_sync_data(evs_db.get_evs_context(context), router_ids, active)

    def _get_by_id(self, context, model, id):

        return context.session.query(model).\

            filter(model.id == id).one()

    def allow_l3_port_deletion(self, context, port_id):

        """ If an L3 agent is using this port, then we need to send

        a notification to L3 agent to release the port before we can

        delete the port"""

        pass