router_id = sa.Column(

sa.String(36),

sa.ForeignKey('routers.id', ondelete="CASCADE"),

primary_key=True)

port_id = sa.Column(

sa.String(36),

sa.ForeignKey('ports.id', ondelete="CASCADE"),

primary_key=True)

# The port_type attribute is redundant as the port table already specifies

# it in DEVICE_OWNER.However, this redundancy enables more efficient

# queries on router ports, and also prevents potential error-prone

# conditions which might originate from users altering the DEVICE_OWNER

# property of router ports.

port_type = sa.Column(sa.String(attributes.DEVICE_OWNER_MAX_LEN))

port = orm.relationship(

models_v2.Port,

backref=orm.backref('routerport', uselist=False, cascade="all,delete"),

model_base.HasId, model_base.HasTenant):

"""Represents a v2 neutron router."""

name = sa.Column(sa.String(attributes.NAME_MAX_LEN))

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

admin_state_up = sa.Column(sa.Boolean)

gw_port_id = sa.Column(sa.String(36), sa.ForeignKey('ports.id'))

gw_port = orm.relationship(models_v2.Port, lazy='joined')

attached_ports = orm.relationship(

RouterPort,

backref='router',

lazy='dynamic')

l3_agents = orm.relationship(

'Agent', lazy='joined', viewonly=True,

model_base.HasId, model_base.HasTenant):

"""Represents a floating IP address.

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),

sa.ForeignKey('ports.id', ondelete="CASCADE"),

nullable=False)

# The ORM-level "delete" cascade relationship between port and floating_ip

# is required for causing the in-Python event "after_delete" that needs for

# proper quota management in case when cascade removal of the floating_ip

# happens after removal of the floating_port

port = orm.relationship(models_v2.Port,

backref=orm.backref('floating_ips',

cascade='all,delete-orphan'),

foreign_keys='FloatingIP.floating_port_id')

fixed_port_id = sa.Column(sa.String(36), sa.ForeignKey('ports.id'))

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

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

# Additional attribute for keeping track of the router where the floating

# ip was associated in order to be able to ensure consistency even if an

# asynchronous backend is unavailable when the floating IP is disassociated

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

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

st_attr.StandardAttrDescriptionMixin):

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

router_device_owners = (

DEVICE_OWNER_ROUTER_INTF,

DEVICE_OWNER_ROUTER_GW,

DEVICE_OWNER_FLOATINGIP

)

@property

def _core_plugin(self):

return manager.NeutronManager.get_plugin()

def _get_router(self, context, router_id):

try:

router = self._get_by_id(context, Router, router_id)

except exc.NoResultFound:

raise l3.RouterNotFound(router_id=router_id)

return router

def _make_router_dict(self, router, fields=None, process_extensions=True):

res = dict((key, router[key]) for key in CORE_ROUTER_ATTRS)

if router['gw_port_id']:

ext_gw_info = {

'network_id': router.gw_port['network_id'],

'external_fixed_ips': [{'subnet_id': ip["subnet_id"],

'ip_address': ip["ip_address"]}

for ip in router.gw_port['fixed_ips']]}

else:

ext_gw_info = None

res.update({

EXTERNAL_GW_INFO: ext_gw_info,

'gw_port_id': router['gw_port_id'],

})

# NOTE(salv-orlando): The following assumes this mixin is used in a

# class inheriting from CommonDbMixin, which is true for all existing

# plugins.

if process_extensions:

self._apply_dict_extend_functions(l3.ROUTERS, res, router)

return self._fields(res, fields)

def filter_allocating_and_missing_routers(self, context, routers):

"""Filter out routers that shouldn't go to the agent.

router_ids = set(r['id'] for r in routers)

query = (context.session.query(Router.id).

filter(

Router.id.in_(router_ids),

Router.status != l3_constants.ROUTER_STATUS_ALLOCATING))

valid_routers = set(r.id for r in query)

if router_ids - valid_routers:

LOG.debug("Removing routers that were either concurrently "

"deleted or are in the ALLOCATING state: %s",

(router_ids - valid_routers))

return [r for r in routers if r['id'] in valid_routers]

def _create_router_db(self, context, router, tenant_id):

"""Create the DB object."""

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

# pre-generate id so it will be available when

# configuring external gw port

status = router.get('status', l3_constants.ROUTER_STATUS_ACTIVE)

router_db = Router(id=(router.get('id') or

uuidutils.generate_uuid()),

tenant_id=tenant_id,

name=router['name'],

admin_state_up=router['admin_state_up'],

status=status,

description=router.get('description'))

context.session.add(router_db)

return router_db

def create_router(self, context, router):

r = router['router']

gw_info = r.pop(EXTERNAL_GW_INFO, None)

router_db = self._create_router_db(context, r, r['tenant_id'])

try:

if gw_info:

self._update_router_gw_info(context, router_db['id'],

gw_info, router=router_db)

except Exception:

with excutils.save_and_reraise_exception():

LOG.debug("Could not update gateway info, deleting router.")

self.delete_router(context, router_db.id)

return self._make_router_dict(router_db)

def _update_router_db(self, context, router_id, data):

"""Update the DB object."""

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

router_db = self._get_router(context, router_id)

if data:

router_db.update(data)

return router_db

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

r = router['router']

gw_info = r.pop(EXTERNAL_GW_INFO, attributes.ATTR_NOT_SPECIFIED)

# check whether router needs and can be rescheduled to the proper

# l3 agent (associated with given external network);

# do check before update in DB as an exception will be raised

# in case no proper l3 agent found

if gw_info != attributes.ATTR_NOT_SPECIFIED:

candidates = self._check_router_needs_rescheduling(

context, id, gw_info)

# Update the gateway outside of the DB update since it involves L2

# calls that don't make sense to rollback and may cause deadlocks

# in a transaction.

self._update_router_gw_info(context, id, gw_info)

else:

candidates = None

router_db = self._update_router_db(context, id, r)

if candidates:

l3_plugin = manager.NeutronManager.get_service_plugins().get(

constants.L3_ROUTER_NAT)

l3_plugin.reschedule_router(context, id, candidates)

return self._make_router_dict(router_db)

def _check_router_needs_rescheduling(self, context, router_id, gw_info):

"""Checks whether router's l3 agent can handle the given network

# TODO(obondarev): rethink placement of this func as l3 db manager is

# not really a proper place for agent scheduling stuff

network_id = gw_info.get('network_id') if gw_info else None

if not network_id:

return

nets = self._core_plugin.get_networks(

context, {external_net.EXTERNAL: [True]})

# nothing to do if there is only one external network

if len(nets) <= 1:

return

# first get plugin supporting l3 agent scheduling

# (either l3 service plugin or core_plugin)

l3_plugin = manager.NeutronManager.get_service_plugins().get(

constants.L3_ROUTER_NAT)

if (not utils.is_extension_supported(

l3_plugin,

l3_constants.L3_AGENT_SCHEDULER_EXT_ALIAS) or

l3_plugin.router_scheduler is None):

# that might mean that we are dealing with non-agent-based

# implementation of l3 services

return

cur_agents = l3_plugin.list_l3_agents_hosting_router(

context, router_id)['agents']

for agent in cur_agents:

ext_net_id = agent['configurations'].get(

'gateway_external_network_id')

ext_bridge = agent['configurations'].get(

'external_network_bridge', 'br-ex')

if (ext_net_id == network_id or

(not ext_net_id and not ext_bridge)):

return

# otherwise find l3 agent with matching gateway_external_network_id

active_agents = l3_plugin.get_l3_agents(context, active=True)

router = {

'id': router_id,

'external_gateway_info': {'network_id': network_id}

}

candidates = l3_plugin.get_l3_agent_candidates(context,

router,

active_agents)

if not candidates:

msg = (_('No eligible l3 agent associated with external network '

'%s found') % network_id)

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

return candidates

def _create_router_gw_port(self, context, router, network_id, ext_ips):

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

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

'network_id': network_id,

'fixed_ips': ext_ips or attributes.ATTR_NOT_SPECIFIED,

'device_id': router['id'],

'device_owner': DEVICE_OWNER_ROUTER_GW,

'admin_state_up': True,

'name': ''}

gw_port = p_utils.create_port(self._core_plugin,

context.elevated(), {'port': port_data})

if not gw_port['fixed_ips']:

LOG.debug('No IPs available for external network %s',

network_id)

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

router.gw_port = self._core_plugin._get_port(context.elevated(),

gw_port['id'])

router_port = RouterPort(

router_id=router.id,

port_id=gw_port['id'],

port_type=DEVICE_OWNER_ROUTER_GW

)

context.session.add(router)

context.session.add(router_port)

def _validate_gw_info(self, context, gw_port, info, ext_ips):

network_id = info['network_id'] if info else None

if network_id:

network_db = self._core_plugin._get_network(context, network_id)

if not network_db.external:

msg = _("Network %s is not an external network") % network_id

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

if ext_ips:

subnets = self._core_plugin.get_subnets_by_network(context,

network_id)

for s in subnets:

if not s['gateway_ip']:

continue

for ext_ip in ext_ips:

if ext_ip.get('ip_address') == s['gateway_ip']:

msg = _("External IP %s is the same as the "

"gateway IP") % ext_ip.get('ip_address')

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

return network_id

def _delete_current_gw_port(self, context, router_id, router,

new_network_id):

"""Delete gw port if attached to an old network."""

port_requires_deletion = (

router.gw_port and router.gw_port['network_id'] != new_network_id)

if not port_requires_deletion:

return

admin_ctx = context.elevated()

old_network_id = router.gw_port['network_id']

if self.get_floatingips_count(

admin_ctx, {'router_id': [router_id]}):

raise l3.RouterExternalGatewayInUseByFloatingIp(

router_id=router_id, net_id=router.gw_port['network_id'])

gw_ips = [x['ip_address'] for x in router.gw_port.fixed_ips]

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

gw_port = router.gw_port

router.gw_port = None

context.session.add(router)

context.session.expire(gw_port)

self._check_router_gw_port_in_use(context, router_id)

self._core_plugin.delete_port(

admin_ctx, gw_port['id'], l3_port_check=False)

registry.notify(resources.ROUTER_GATEWAY,

events.AFTER_DELETE, self,

router_id=router_id,

network_id=old_network_id,

gateway_ips=gw_ips)

def _check_router_gw_port_in_use(self, context, router_id):

try:

kwargs = {'context': context, 'router_id': router_id}

registry.notify(

resources.ROUTER_GATEWAY, events.BEFORE_DELETE, self, **kwargs)

except exceptions.CallbackFailure as e:

with excutils.save_and_reraise_exception():

# NOTE(armax): preserve old check's behavior

if len(e.errors) == 1:

raise e.errors[0].error

raise l3.RouterInUse(router_id=router_id, reason=e)

def _create_gw_port(self, context, router_id, router, new_network_id,

ext_ips):

new_valid_gw_port_attachment = (

new_network_id and (not router.gw_port or

router.gw_port['network_id'] != new_network_id))

if new_valid_gw_port_attachment:

subnets = self._core_plugin.get_subnets_by_network(context,

new_network_id)

try:

kwargs = {'context': context, 'router_id': router_id,

'network_id': new_network_id, 'subnets': subnets}

registry.notify(

resources.ROUTER_GATEWAY, events.BEFORE_CREATE, self,

**kwargs)

except exceptions.CallbackFailure as e:

# raise the underlying exception

raise e.errors[0].error

self._check_for_dup_router_subnets(context, router,

new_network_id, subnets)

self._create_router_gw_port(context, router,

new_network_id, ext_ips)

registry.notify(resources.ROUTER_GATEWAY,

events.AFTER_CREATE,

self._create_gw_port,

gw_ips=ext_ips,

network_id=new_network_id,

router_id=router_id)

def _update_current_gw_port(self, context, router_id, router, ext_ips):

self._core_plugin.update_port(context, router.gw_port['id'], {'port':

{'fixed_ips': ext_ips}})

context.session.expire(router.gw_port)

def _update_router_gw_info(self, context, router_id, info, router=None):

# TODO(salvatore-orlando): guarantee atomic behavior also across

# operations that span beyond the model classes handled by this

# class (e.g.: delete_port)

router = router or self._get_router(context, router_id)

gw_port = router.gw_port

ext_ips = info.get('external_fixed_ips') if info else []

ext_ip_change = self._check_for_external_ip_change(

context, gw_port, ext_ips)

network_id = self._validate_gw_info(context, gw_port, info, ext_ips)

if gw_port and ext_ip_change and gw_port['network_id'] == network_id:

self._update_current_gw_port(context, router_id, router,

ext_ips)

else:

self._delete_current_gw_port(context, router_id, router,

network_id)

self._create_gw_port(context, router_id, router, network_id,

ext_ips)

def _check_for_external_ip_change(self, context, gw_port, ext_ips):

# determine if new external IPs differ from the existing fixed_ips

if not ext_ips:

# no external_fixed_ips were included

return False

if not gw_port:

return True

subnet_ids = set(ip['subnet_id'] for ip in gw_port['fixed_ips'])

new_subnet_ids = set(f['subnet_id'] for f in ext_ips

if f.get('subnet_id'))

subnet_change = not new_subnet_ids == subnet_ids

if subnet_change:

return True

ip_addresses = set(ip['ip_address'] for ip in gw_port['fixed_ips'])

new_ip_addresses = set(f['ip_address'] for f in ext_ips

if f.get('ip_address'))

ip_address_change = not ip_addresses == new_ip_addresses

return ip_address_change

def _ensure_router_not_in_use(self, context, router_id):

"""Ensure that no internal network interface is attached

router = self._get_router(context, router_id)

device_owner = self._get_device_owner(context, router)

if any(rp.port_type == device_owner

for rp in router.attached_ports.all()):

raise l3.RouterInUse(router_id=router_id)

return router

def delete_router(self, context, id):

#TODO(nati) Refactor here when we have router insertion model

router = self._ensure_router_not_in_use(context, id)

self._delete_current_gw_port(context, id, router, None)

router_ports = router.attached_ports.all()

for rp in router_ports:

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

rp.port.id,

l3_port_check=False)

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

context.session.delete(router)

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

router = self._get_router(context, id)

return self._make_router_dict(router, fields)

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

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

page_reverse=False):

marker_obj = self._get_marker_obj(context, 'router', limit, marker)

return self._get_collection(context, Router,

self._make_router_dict,

filters=filters, fields=fields,

sorts=sorts,

limit=limit,

marker_obj=marker_obj,

page_reverse=page_reverse)

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

return self._get_collection_count(context, Router,

filters=filters)

def _check_for_dup_router_subnets(self, context, router,

network_id, new_subnets):

# It's possible these ports are on the same network, but

# different subnets.

new_subnet_ids = {s['id'] for s in new_subnets}

router_subnets = []

for p in (rp.port for rp in router.attached_ports):

for ip in p['fixed_ips']:

if ip['subnet_id'] in new_subnet_ids:

msg = (_("Router already has a port on subnet %s")

% ip['subnet_id'])

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

router_subnets.append(ip['subnet_id'])

# Ignore temporary Prefix Delegation CIDRs

new_subnets = [s for s in new_subnets

if s['cidr'] != l3_constants.PROVISIONAL_IPV6_PD_PREFIX]

id_filter = {'id': router_subnets}

subnets = self._core_plugin.get_subnets(context.elevated(),

filters=id_filter)

for sub in subnets:

cidr = sub['cidr']

ipnet = netaddr.IPNetwork(cidr)

for s in new_subnets:

new_cidr = s['cidr']

new_ipnet = netaddr.IPNetwork(new_cidr)

match1 = netaddr.all_matching_cidrs(new_ipnet, [cidr])

match2 = netaddr.all_matching_cidrs(ipnet, [new_cidr])

if match1 or match2:

data = {'subnet_cidr': new_cidr,

'subnet_id': s['id'],

'cidr': cidr,

'sub_id': sub['id']}

msg = (_("Cidr %(subnet_cidr)s of subnet "

"%(subnet_id)s overlaps with cidr %(cidr)s "

"of subnet %(sub_id)s") % data)

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

def _get_device_owner(self, context, router=None):

"""Get device_owner for the specified router."""

# NOTE(armando-migliaccio): in the base case this is invariant

return DEVICE_OWNER_ROUTER_INTF

def _validate_interface_info(self, interface_info, for_removal=False):

port_id_specified = interface_info and 'port_id' in interface_info

subnet_id_specified = interface_info and 'subnet_id' in interface_info

if not (port_id_specified or subnet_id_specified):

msg = _("Either subnet_id or port_id must be specified")

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

for key in ('port_id', 'subnet_id'):

if key not in interface_info:

continue

err = attributes._validate_uuid(interface_info[key])

if err:

raise n_exc.BadRequest(resource='router', msg=err)

if not for_removal:

if port_id_specified and subnet_id_specified:

msg = _("Cannot specify both subnet-id and port-id")

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

return port_id_specified, subnet_id_specified

def _check_router_port(self, context, port_id, device_id):

port = self._core_plugin.get_port(context, port_id)

if port['device_id'] != device_id:

raise n_exc.PortInUse(net_id=port['network_id'],

port_id=port['id'],

device_id=port['device_id'])

if not port['fixed_ips']:

msg = _('Router port must have at least one fixed IP')

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

return port

def _validate_router_port_info(self, context, router, port_id):

with db_api.autonested_transaction(context.session):

# check again within transaction to mitigate race

port = self._check_router_port(context, port_id, router.id)

# Only allow one router port with IPv6 subnets per network id

if self._port_has_ipv6_address(port):

for existing_port in (rp.port for rp in router.attached_ports):

if (existing_port['network_id'] == port['network_id'] and

self._port_has_ipv6_address(existing_port)):

msg = _("Cannot have multiple router ports with the "

"same network id if both contain IPv6 "

"subnets. Existing port %(p)s has IPv6 "

"subnet(s) and network id %(nid)s")

raise n_exc.BadRequest(resource='router', msg=msg % {

'p': existing_port['id'],

'nid': existing_port['network_id']})

fixed_ips = [ip for ip in port['fixed_ips']]

subnets = []

for fixed_ip in fixed_ips:

subnet = self._core_plugin.get_subnet(context,

fixed_ip['subnet_id'])

subnets.append(subnet)

if subnets:

self._check_for_dup_router_subnets(context, router,

port['network_id'],

subnets)

# Keep the restriction against multiple IPv4 subnets

if len([s for s in subnets if s['ip_version'] == 4]) > 1:

msg = _("Cannot have multiple "

"IPv4 subnets on router port")

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

return port, subnets

def _add_interface_by_port(self, context, router, port_id, owner):

# Update owner before actual process in order to avoid the

# case where a port might get attached to a router without the

# owner successfully updating due to an unavailable backend.

port = self._check_router_port(context, port_id, '')

prev_owner = port['device_owner']

self._core_plugin.update_port(

context, port_id, {'port': {'device_id': router.id,

'device_owner': owner}})

try:

return self._validate_router_port_info(context, router, port_id)

except Exception:

with excutils.save_and_reraise_exception():

self._core_plugin.update_port(

context, port_id, {'port': {'device_id': '',

'device_owner': prev_owner}})

def _port_has_ipv6_address(self, port):

for fixed_ip in port['fixed_ips']:

if netaddr.IPNetwork(fixed_ip['ip_address']).version == 6:

return True

def _find_ipv6_router_port_by_network(self, router, net_id):

for port in router.attached_ports:

p = port['port']

if p['network_id'] == net_id and self._port_has_ipv6_address(p):

return port

def _add_interface_by_subnet(self, context, router, subnet_id, owner):

subnet = self._core_plugin.get_subnet(context, subnet_id)

if not subnet['gateway_ip']:

msg = _('Subnet for router interface must have a gateway IP')

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

if (subnet['ip_version'] == 6 and subnet['ipv6_ra_mode'] is None

and subnet['ipv6_address_mode'] is not None):

msg = (_('IPv6 subnet %s configured to receive RAs from an '

'external router cannot be added to Neutron Router.') %

subnet['id'])

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

self._check_for_dup_router_subnets(context, router,

subnet['network_id'], [subnet])

fixed_ip = {'ip_address': subnet['gateway_ip'],

'subnet_id': subnet['id']}

if (subnet['ip_version'] == 6 and not

ipv6_utils.is_ipv6_pd_enabled(subnet)):

# Add new prefix to an existing ipv6 port with the same network id

# if one exists

port = self._find_ipv6_router_port_by_network(router,

subnet['network_id'])

if port:

fixed_ips = list(port['port']['fixed_ips'])

fixed_ips.append(fixed_ip)

return self._core_plugin.update_port(context,

port['port_id'], {'port':

{'fixed_ips': fixed_ips}}), [subnet], False

port_data = {'tenant_id': subnet['tenant_id'],

'network_id': subnet['network_id'],

'fixed_ips': [fixed_ip],

'admin_state_up': True,

'device_id': router.id,

'device_owner': owner,

'name': ''}

return p_utils.create_port(self._core_plugin, context,

{'port': port_data}), [subnet], True

@staticmethod

def _make_router_interface_info(

router_id, tenant_id, port_id, network_id, subnet_id, subnet_ids):

return {

'id': router_id,

'tenant_id': tenant_id,

'port_id': port_id,

'network_id': network_id,

'subnet_id': subnet_id, # deprecated by IPv6 multi-prefix

'subnet_ids': subnet_ids

}

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

router = self._get_router(context, router_id)

add_by_port, add_by_sub = self._validate_interface_info(interface_info)

device_owner = self._get_device_owner(context, router_id)

# This should be True unless adding an IPv6 prefix to an existing port

new_port = True

if add_by_port:

port, subnets = self._add_interface_by_port(

context, router, interface_info['port_id'], device_owner)

# add_by_subnet is not used here, because the validation logic of

# _validate_interface_info ensures that either of add_by_* is True.

else:

port, subnets, new_port = self._add_interface_by_subnet(

context, router, interface_info['subnet_id'], device_owner)

if new_port:

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

router_port = RouterPort(

port_id=port['id'],

router_id=router.id,

port_type=device_owner

)

context.session.add(router_port)

gw_ips = []

gw_network_id = None

if router.gw_port:

gw_network_id = router.gw_port.network_id

gw_ips = router.gw_port.fixed_ips

registry.notify(resources.ROUTER_INTERFACE,

events.AFTER_CREATE,

self,

context=context,

network_id=gw_network_id,

gateway_ips=gw_ips,

cidrs=[x['cidr'] for x in subnets],

port_id=port['id'],

router_id=router_id,

port=port,

interface_info=interface_info)

return self._make_router_interface_info(

router.id, port['tenant_id'], port['id'], port['network_id'],

subnets[-1]['id'], [subnet['id'] for subnet in subnets])

def _confirm_router_interface_not_in_use(self, context, router_id,

subnet_id):

subnet = self._core_plugin.get_subnet(context, subnet_id)

subnet_cidr = netaddr.IPNetwork(subnet['cidr'])

fip_qry = context.session.query(FloatingIP)

try:

kwargs = {'context': context, 'subnet_id': subnet_id}

registry.notify(

resources.ROUTER_INTERFACE,

events.BEFORE_DELETE, self, **kwargs)

except exceptions.CallbackFailure as e:

with excutils.save_and_reraise_exception():

# NOTE(armax): preserve old check's behavior

if len(e.errors) == 1:

raise e.errors[0].error

raise l3.RouterInUse(router_id=router_id, reason=e)

for fip_db in fip_qry.filter_by(router_id=router_id):

if netaddr.IPAddress(fip_db['fixed_ip_address']) in subnet_cidr:

raise l3.RouterInterfaceInUseByFloatingIP(

router_id=router_id, subnet_id=subnet_id)

def _remove_interface_by_port(self, context, router_id,

port_id, subnet_id, owner):

qry = context.session.query(RouterPort)

qry = qry.filter_by(

port_id=port_id,

router_id=router_id,

port_type=owner

)

try:

port_db = qry.one().port

except exc.NoResultFound:

raise l3.RouterInterfaceNotFound(router_id=router_id,

port_id=port_id)

port_subnet_ids = [fixed_ip['subnet_id']

for fixed_ip in port_db['fixed_ips']]

if subnet_id and subnet_id not in port_subnet_ids:

raise n_exc.SubnetMismatchForPort(

port_id=port_id, subnet_id=subnet_id)

subnets = [self._core_plugin.get_subnet(context, port_subnet_id)

for port_subnet_id in port_subnet_ids]

for port_subnet_id in port_subnet_ids:

self._confirm_router_interface_not_in_use(

context, router_id, port_subnet_id)

self._core_plugin.delete_port(context, port_db['id'],

l3_port_check=False)

return (port_db, subnets)

def _remove_interface_by_subnet(self, context,

router_id, subnet_id, owner):

self._confirm_router_interface_not_in_use(

context, router_id, subnet_id)

subnet = self._core_plugin.get_subnet(context, subnet_id)

try:

rport_qry = context.session.query(models_v2.Port).join(RouterPort)

ports = rport_qry.filter(

RouterPort.router_id == router_id,

RouterPort.port_type == owner,

models_v2.Port.network_id == subnet['network_id']

)

for p in ports:

port_subnets = [fip['subnet_id'] for fip in p['fixed_ips']]

if subnet_id in port_subnets and len(port_subnets) > 1:

# multiple prefix port - delete prefix from port

fixed_ips = [fip for fip in p['fixed_ips'] if

fip['subnet_id'] != subnet_id]

self._core_plugin.update_port(context, p['id'],

{'port':

{'fixed_ips': fixed_ips}})

return (p, [subnet])

elif subnet_id in port_subnets:

# only one subnet on port - delete the port

self._core_plugin.delete_port(context, p['id'],

l3_port_check=False)

return (p, [subnet])

except exc.NoResultFound:

pass

raise l3.RouterInterfaceNotFoundForSubnet(router_id=router_id,

subnet_id=subnet_id)

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

remove_by_port, remove_by_subnet = (

self._validate_interface_info(interface_info, for_removal=True)

)

port_id = interface_info.get('port_id')

subnet_id = interface_info.get('subnet_id')

device_owner = self._get_device_owner(context, router_id)

if remove_by_port:

port, subnets = self._remove_interface_by_port(context, router_id,

port_id, subnet_id,

device_owner)

# remove_by_subnet is not used here, because the validation logic of

# _validate_interface_info ensures that at least one of remote_by_*

# is True.

else:

port, subnets = self._remove_interface_by_subnet(

context, router_id, subnet_id, device_owner)

gw_network_id = None

gw_ips = []

router = self._get_router(context, router_id)

if router.gw_port:

gw_network_id = router.gw_port.network_id

gw_ips = [x['ip_address'] for x in router.gw_port.fixed_ips]

registry.notify(resources.ROUTER_INTERFACE,

events.AFTER_DELETE,

self,

context=context,

cidrs=[x['cidr'] for x in subnets],

network_id=gw_network_id,

gateway_ips=gw_ips,

port=port)

return self._make_router_interface_info(router_id, port['tenant_id'],

port['id'], port['network_id'],

subnets[0]['id'],

[subnet['id'] for subnet in

subnets])

def _get_floatingip(self, context, id):

try:

floatingip = self._get_by_id(context, FloatingIP, id)

except exc.NoResultFound:

raise l3.FloatingIPNotFound(floatingip_id=id)

return floatingip

def _make_floatingip_dict(self, floatingip, fields=None,

process_extensions=True):

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

'tenant_id': floatingip['tenant_id'],

'floating_ip_address': floatingip['floating_ip_address'],

'floating_network_id': floatingip['floating_network_id'],

'router_id': floatingip['router_id'],

'port_id': floatingip['fixed_port_id'],

'fixed_ip_address': floatingip['fixed_ip_address'],

'status': floatingip['status']}

# NOTE(mlavalle): The following assumes this mixin is used in a

# class inheriting from CommonDbMixin, which is true for all existing

# plugins.

if process_extensions:

self._apply_dict_extend_functions(l3.FLOATINGIPS, res, floatingip)

return self._fields(res, fields)

def _get_router_for_floatingip(self, context, internal_port,

internal_subnet_id,

external_network_id):

subnet = self._core_plugin.get_subnet(context, internal_subnet_id)

if not subnet['gateway_ip']:

msg = (_('Cannot add floating IP to port on subnet %s '

'which has no gateway_ip') % internal_subnet_id)

raise n_exc.BadRequest(resource='floatingip', msg=msg)

return self.get_router_for_floatingip(context,

internal_port, subnet, external_network_id)

# NOTE(yamamoto): This method is an override point for plugins

# inheriting this class. Do not optimize this out.

def get_router_for_floatingip(self, context, internal_port,

internal_subnet, external_network_id):

"""Find a router to handle the floating-ip association.

# Find routers(with router_id and interface address) that

# connect given internal subnet and the external network.

# Among them, if the router's interface address matches

# with subnet's gateway-ip, return that router.

# Otherwise return the first router.

gw_port = orm.aliased(models_v2.Port, name="gw_port")

routerport_qry = context.session.query(

RouterPort.router_id, models_v2.IPAllocation.ip_address).join(

models_v2.Port, models_v2.IPAllocation).filter(

models_v2.Port.network_id == internal_port['network_id'],

RouterPort.port_type.in_(l3_constants.ROUTER_INTERFACE_OWNERS),

models_v2.IPAllocation.subnet_id == internal_subnet['id']

).join(gw_port, gw_port.device_id == RouterPort.router_id).filter(

gw_port.network_id == external_network_id,

gw_port.device_owner == l3_constants.DEVICE_OWNER_ROUTER_GW

).distinct()

first_router_id = None

for router_id, interface_ip in routerport_qry:

if interface_ip == internal_subnet['gateway_ip']:

return router_id

if not first_router_id:

first_router_id = router_id

if first_router_id:

return first_router_id

raise l3.ExternalGatewayForFloatingIPNotFound(

subnet_id=internal_subnet['id'],

external_network_id=external_network_id,

port_id=internal_port['id'])

def _port_ipv4_fixed_ips(self, port):

return [ip for ip in port['fixed_ips']

if netaddr.IPAddress(ip['ip_address']).version == 4]

def _internal_fip_assoc_data(self, context, fip):

"""Retrieve internal port data for floating IP.

internal_port = self._core_plugin.get_port(context, fip['port_id'])

if not internal_port['tenant_id'] == fip['tenant_id']:

port_id = fip['port_id']

if 'id' in fip:

floatingip_id = fip['id']

data = {'port_id': port_id,

'floatingip_id': floatingip_id}

msg = (_('Port %(port_id)s is associated with a different '

'tenant than Floating IP %(floatingip_id)s and '

'therefore cannot be bound.') % data)

else:

msg = (_('Cannot create floating IP and bind it to '

'Port %s, since that port is owned by a '

'different tenant.') % port_id)

raise n_exc.BadRequest(resource='floatingip', msg=msg)

internal_subnet_id = None

if fip.get('fixed_ip_address'):

internal_ip_address = fip['fixed_ip_address']

if netaddr.IPAddress(internal_ip_address).version != 4: