~ntt-pf-lab/nova/network-service

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

# Copyright (c) 2011 NTT.
# 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.
"""
SQLAlchemy models for flat vlan network service data.
"""
from sqlalchemy import or_
from sqlalchemy.orm import relationship, backref
from sqlalchemy.orm import joinedload, joinedload_all
from sqlalchemy import Column, Boolean, Integer, String
from sqlalchemy import ForeignKey
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.declarative import declarative_base

from nova import exception
from nova.db import api as nova_db
from nova.db.sqlalchemy.models import NovaBase

BASE = declarative_base()

# ----------------------
# Data Transfer Objects.
# ----------------------

class EthernetCard(BASE, NovaBase):
    """Represents an ethernet card."""
    __tablename__ = 'ethernet_cards'
    id = Column(Integer, primary_key=True)
    mac_address = Column(String(255), nullable=False, unique=True)


class Network(BASE, NovaBase):
    """Represents a simple IP network."""
    __tablename__ = 'networks'
    id = Column(Integer, primary_key=True)
    cidr = Column(String(255))
    netmask = Column(String(255))
    bridge = Column(String(255))
    gateway = Column(String(255))
    broadcast = Column(String(255))
    dns = Column(String(255))
    vlan = Column(Integer)
    vpn_public_address = Column(String(255))
    vpn_public_port = Column(Integer)
    vpn_private_address = Column(String(255))
    dhcp_start = Column(String(255))
    cidr_v6 = Column(String(255), unique=True)
    gateway_v6 = Column(String(255))
    netmask_v6 = Column(String(255))
    label = Column(String(255))
    project_id = Column(String(255))
    host = Column(String(255))  # , ForeignKey('hosts.id'))


class FixedIp(BASE, NovaBase):
    """Represents a fixed ip for an instance."""
    __tablename__ = 'fixed_ips'
    id = Column(Integer, primary_key=True)
    address = Column(String(255))
    network_id = Column(Integer, ForeignKey('networks.id'), nullable=True)
    network = relationship(Network, backref=backref('fixed_ips'))
    ethernet_card_id = Column(Integer, ForeignKey('ethernet_cards.id'))
    ethernet_card = relationship(EthernetCard, backref=backref('fixed_ips'))
    allocated = Column(Boolean, default=False)
    leased = Column(Boolean, default=False)
    reserved = Column(Boolean, default=False)


class FloatingIp(BASE, NovaBase):
    """Represents a floating ip that dynamically forwards to a fixed ip."""
    __tablename__ = 'floating_ips'
    id = Column(Integer, primary_key=True)
    address = Column(String(255))
    fixed_ip_id = Column(Integer, ForeignKey('fixed_ips.id'), nullable=True)
    fixed_ip = relationship(FixedIp,
                            backref=backref('floating_ips'),
                            foreign_keys=fixed_ip_id,
                            primaryjoin='and_('
                                'FloatingIp.fixed_ip_id == FixedIp.id,'
                                'FloatingIp.deleted == False)')
    project_id = Column(String(255))
    host = Column(String(255))  # , ForeignKey('hosts.id'))


class DataAccess(object):
    """The base class to implement Data Access Objects.
    """

    def __init__(self, session):
        """Initialize this Data Access Object.

        :param session: The SQLAlchemy session to use as this Data
            Access Object's data source.
        """
        self._session = session


class EthernetCardDataAccess(DataAccess):
    """A Data Access Object to access ethernet cards.
    """

    ethernet_card_dto_class = EthernetCard

    def ethernet_card_get(self, id):
        result = self._session.query(self.ethernet_card_dto_class).\
            filter_by(deleted=False).\
            filter_by(id=id).\
            first()

        if not result:
            raise exception.NotFound(_("No ethernet_card with id %s") % id)

        return result

    def ethernet_card_get_all(self, read_deleted=False):
        return self._session.query(self.ethernet_card_dto_class).\
            filter_by(deleted=read_deleted).\
            all()

    def ethernet_card_create(self, values):
        ethernet_card_ref = self.ethernet_card_dto_class()
        ethernet_card_ref.update(values)
        ethernet_card_ref.save(session=self._session)
        return ethernet_card_ref

    def ethernet_card_update(self, ethernet_card_id, values):
        with self._session.begin():
            ethernet_card_ref = self.ethernet_card_get(ethernet_card_id)
            ethernet_card_ref.update(values)
            ethernet_card_ref.save(session=self._session)

    def ethernet_card_delete(self, id):
        with self._session.begin():
            ethernet_card_ref = self.ethernet_card_get(id)
            ethernet_card_ref.delete(session=self._session)


class NetworkDataAccess(DataAccess):
    """A Data Access Object to access networks.
    """

    network_dto_class = Network

    def network_get(self, id):
        result = self._session.query(self.network_dto_class).\
            filter_by(deleted=False).\
            filter_by(id=id).\
            first()

        if not result:
            raise exception.NotFound(_("No network with id %s") % id)

        return result

    def network_get_by_bridge(self, bridge):
        result = self._session.query(self.network_dto_class).\
            filter_by(bridge=bridge).\
            filter_by(deleted=False).\
            first()

        if not result:
            raise exception.NotFound(_('No network for bridge %s') % bridge)

        return result

    def network_get_by_ethernet_card(self, ethernet_card_id):
        rv = self._session.query(self.network_dto_class).\
            filter_by(deleted=False).\
            join(self.network_dto_class.fixed_ips).\
            filter_by(ethernet_card_id=ethernet_card_id).\
            filter_by(deleted=False).\
            first()
        if not rv:
            raise exception.NotFound(_('No network for ethernet card %s') %
                                     ethernet_card_id)
        return rv

    def host_get_networks(self, host):
        with self._session.begin():
            return self._session.query(self.network_dto_class).\
                filter_by(deleted=False).\
                filter_by(host=host).\
                all()

    def network_get_all(self, read_deleted=False):
        return self._session.query(self.network_dto_class).\
            filter_by(deleted=read_deleted).\
            all()

    def network_create(self, values):
        network_ref = self.network_dto_class()
        network_ref.update(values)
        network_ref.save(session=self._session)
        return network_ref

    def network_create_safe(self, values):
        try:
            return self.network_create(values)
        except IntegrityError:
            return None

    def network_update(self, network_id, values):
        with self._session.begin():
            network_ref = self.network_get(network_id)
            network_ref.update(values)
            network_ref.save(session=self._session)

    def network_delete(self, id):
        with self._session.begin():
            network_ref = self.network_get(id)
            network_ref.delete(session=self._session)

    def network_delete_safe(self, id):
        try:
            return self.network_delete(id)
        except IntegrityError:
            return None

class FixedIpDataAccess(DataAccess):
    """A Data Access Object to access fixed IPs.
    """

    fixed_ip_dto_class = FixedIp

    def fixed_ip_create(self, values):
        fixed_ip_ref = self.fixed_ip_dto_class()
        fixed_ip_ref.update(values)
        fixed_ip_ref.save(session=self._session)
        return fixed_ip_ref['address']

    def fixed_ip_update(self, fixed_ip_id, values):
        with self._session.begin():
            fixed_ip_ref = self.fixed_ip_get(fixed_ip_id)
            fixed_ip_ref.update(values)
            fixed_ip_ref.save(session=self._session)

    def fixed_ip_get(self, fixed_ip_id):
        result = self._session.query(self.fixed_ip_dto_class).\
            filter_by(deleted=False).\
            filter_by(id=fixed_ip_id).\
            first()

        if not result:
            raise exception.NotFound(_("No Fixed IP with id %s") % id)

        return result

    def fixed_ip_get_all(self):
        result = self._session.query(self.fixed_ip_dto_class).all()
        if not result:
            raise exception.NotFound(_('No fixed ips defined'))

        return result

    def network_get_associated_fixed_ips(self, network_id):
        return self._session.query(self.fixed_ip_dto_class).\
            options(joinedload_all('ethernet_card')).\
            filter_by(network_id=network_id).\
            filter(self.fixed_ip_dto_class.ethernet_card_id != None).\
            filter_by(deleted=False).\
            all()

    network_get_associated_ips = network_get_associated_fixed_ips

    def fixed_ip_get_by_address(self, address, read_deleted=False):
        result = self._session.query(self.fixed_ip_dto_class).\
            filter_by(address=address).\
            filter_by(deleted=read_deleted).\
            options(joinedload('network')).\
            options(joinedload('ethernet_card')).\
            first()
        if not result:
            raise exception.NotFound(_('No fixed ip for address %s') % address)

        return result

    def fixed_ip_disassociate(self, fixed_ip_id):
        with self._session.begin():
            fixed_ip_ref = self.fixed_ip_get(fixed_ip_id)
            fixed_ip_ref.ethernet_card = None
            fixed_ip_ref.save(session=self._session)

    def fixed_ip_get_by_ethernet_card(self, ethernet_card_id,
                                      read_deleted=False):
        result = self._session.query(self.fixed_ip_dto_class).\
            filter_by(ethernet_card_id=ethernet_card_id).\
            filter_by(deleted=read_deleted).\
            first()
        return result

    def fixed_ip_disassociate_all_by_timeout(self, host, time):
        inner_q = self._session.query(Network.id).\
                            filter_by(host=host).\
                            subquery()
        result = self._session.query(self.fixed_ip_dto_class).\
                    filter(self.fixed_ip_dto_class.network_id.in_(inner_q)).\
                    filter(self.fixed_ip_dto_class.updated_at < time).\
                    filter(self.fixed_ip_dto_class.ethernet_card_id != None).\
                    filter_by(allocated=0).\
                    update({'ethernet_card_id': None,
                           'leased': 0}, synchronize_session='fetch')
        return result


class FloatingIpDataAccess(DataAccess):
    """A Data Access Object to access floating IPs.
    """

    floating_ip_dto_class = FloatingIp

    def floating_ip_count_by_project(self, project_id):
        return self._session.query(self.floating_ip_dto_class).\
            filter_by(project_id=project_id).\
            filter_by(deleted=False).\
            count()

    def floating_ip_allocate_address(self, host, project_id):
        with self._session.begin():
            floating_ip_ref = self._session.query(self.floating_ip_dto_class).\
                              filter_by(host=host).\
                              filter_by(fixed_ip_id=None).\
                              filter_by(project_id=None).\
                              filter_by(deleted=False).\
                              with_lockmode('update').\
                              first()
            # NOTE(vish): if with_lockmode isn't supported, as in sqlite,
            #             then this has concurrency issues
            if not floating_ip_ref:
                raise nova_db.NoMoreAddresses()
            floating_ip_ref['project_id'] = project_id
            self._session.add(floating_ip_ref)
        return floating_ip_ref

    def floating_ip_deallocate(self, address):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                address, read_deleted=False)
            floating_ip_ref['project_id'] = None
            floating_ip_ref.save(session=self._session)

    def floating_ip_destroy(self, address):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                address, read_deleted=False)
            floating_ip_ref.delete(session=self._session)

    def floating_ip_disassociate_by_address(self, address):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                address, read_deleted=False)
            fixed_ip_ref = floating_ip_ref.fixed_ip
            if fixed_ip_ref:
                fixed_ip_address = fixed_ip_ref['address']
            else:
                fixed_ip_address = None
            floating_ip_ref.fixed_ip = None
            floating_ip_ref.save(session=self._session)
        return fixed_ip_address

    def floating_ip_get_all(self):
        return self._session.query(self.floating_ip_dto_class).\
            options(joinedload_all('fixed_ip.ethernet_card')).\
            filter_by(deleted=False).\
            all()

    def floating_ip_get_all_by_project(self, project_id):
        return self._session.query(self.floating_ip_dto_class).\
            options(joinedload_all('fixed_ip.ethernet_card')).\
            filter_by(project_id=project_id).\
            filter_by(deleted=False).\
            all()

    def floating_ip_get_by_address(self, address, read_deleted=False):
        result = self._session.query(self.floating_ip_dto_class).\
            options(joinedload_all('fixed_ip.network')).\
            filter_by(address=address).\
            filter_by(deleted=read_deleted).\
            first()
        if not result:
            raise exception.NotFound('No floating ip for address %s' % address)
        return result

    def floating_ip_update(self, address, values):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                address, read_deleted=False)
            for (key, value) in values.iteritems():
                floating_ip_ref[key] = value
            floating_ip_ref.save(session=self._session)

    def floating_ip_create(self, values):
        floating_ip_ref = self.floating_ip_dto_class()
        floating_ip_ref.update(values)
        floating_ip_ref.save(session=self._session)
        return floating_ip_ref

    def floating_ip_disassociate(self, address):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                address, read_deleted=False)
            fixed_ip_ref = floating_ip_ref.fixed_ip
            if fixed_ip_ref:
                fixed_ip_address = fixed_ip_ref['address']
            else:
                fixed_ip_address = None
            floating_ip_ref.fixed_ip = None
            floating_ip_ref.save(session=self._session)
        return fixed_ip_ref

    def floating_ip_get_all_by_host(self, host):
        return self._session.query(self.floating_ip_dto_class).\
                   options(joinedload_all('fixed_ip.ethernet_card')).\
                   filter_by(host=host).\
                   filter_by(deleted=False).\
                   all()


# ----------------------
# Data Access Objects.
# ----------------------

class FlatVlanNetworkDataAccess(
    EthernetCardDataAccess, NetworkDataAccess, FixedIpDataAccess,
    FloatingIpDataAccess):
    """A Data Access Object to access all data for the Flat VLAN network
    service.

    Also access fixed IP address associations.
    """

    ethernet_card_dto_class = EthernetCard

    network_dto_class = Network

    fixed_ip_dto_class = FixedIp

    floating_ip_dto_class = FloatingIp

    def network_get_by_project(self, project_id, associate=True):
        result = self._session.query(self.network_dto_class).\
            filter_by(project_id=project_id).\
            filter_by(deleted=False).\
            first()
        if not result:
            if not associate:
                return None
            try:
                return self.network_associate(project_id)
            except IntegrityError:
                # NOTE(vish): We hit this if there is a race and two
                #             processes are attempting to allocate the
                #             network at the same time
                result = self._session.query(self.network_dto_class).\
                    filter_by(project_id=project_id).\
                    filter_by(deleted=False).\
                    first()
        return result

    def network_get_by_cidr(self, cidr):
        result = self._session.query(self.network_dto_class).\
            filter_by(cidr=cidr).first()

        if not result:
            raise exception.NotFound(_('Network with cidr %s does not exist') %
                                     cidr)
        return result

    def network_associate(self, project_id):
        with self._session.begin():
            network_ref = self._session.query(self.network_dto_class).\
                filter_by(deleted=False).\
                filter_by(project_id=None).\
                with_lockmode('update').\
                first()
            # NOTE(vish): if with_lockmode isn't supported, as in sqlite,
            #             then this has concurrency issues
            if not network_ref:
                raise nova_api.NoMoreNetworks()
            network_ref['project_id'] = project_id
            self._session.add(network_ref)
        return network_ref

    def fixed_ip_get_network(self, address, read_deleted=False):
        fixed_ip_ref = self.fixed_ip_get_by_address(
            address, read_deleted=read_deleted)
        return fixed_ip_ref.network

    def floating_ip_fixed_ip_associate(self, floating_address, fixed_address):
        with self._session.begin():
            floating_ip_ref = self.floating_ip_get_by_address(
                floating_address, read_deleted=False)
            fixed_ip_ref = self.fixed_ip_get_by_address(
                fixed_address, read_deleted=False)
            floating_ip_ref.fixed_ip = fixed_ip_ref
            floating_ip_ref.save(session=self._session)

    def fixed_ip_associate(self, fixed_ip_id, ethernet_card_id):
        with self._session.begin():
            ethernet_card = self.ethernet_card_get(ethernet_card_id)
            fixed_ip_ref = self._session.query(self.fixed_ip_dto_class).\
                                   filter_by(id=fixed_ip_id).\
                                   filter_by(deleted=False).\
                                   filter_by(ethernet_card=None).\
                                   with_lockmode('update').\
                                   first()
            # NOTE(vish): if with_lockmode isn't supported, as in sqlite,
            #             then this has concurrency issues
            if not fixed_ip_ref:
                raise nova_db.NoMoreAddresses()
            fixed_ip_ref.ethernet_card = ethernet_card
            self._session.add(fixed_ip_ref)

    def fixed_ip_associate_pool(self, network_id, ethernet_card_id):
        with self._session.begin():
            network_or_none = or_(
                self.fixed_ip_dto_class.network_id == network_id,
                self.fixed_ip_dto_class.network_id == None)
            ip_ref = self._session.query(self.fixed_ip_dto_class).\
                filter(network_or_none).\
                filter_by(reserved=False).\
                filter_by(deleted=False).\
                filter_by(ethernet_card=None).\
                with_lockmode('update').\
                first()
            if not ip_ref:
                raise nova_db.NoMoreAddresses()
            if not ip_ref.network or not ip_ref.ethernet_card:
                ip_ref.network = self.network_get(network_id)
                ip_ref.ethernet_card = self.ethernet_card_get(ethernet_card_id)
                self._session.add(ip_ref)
            return ip_ref