~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