3aca3f7745
Now that all preparations are done, actually port the code to use
oslo.messaging. This patch does as little as possible. Follow up patches
that refactor and cleanup the code and configuration files, will be
merged later. The reason for this is to make the patch as slim as
possible, to make review process more smooth and concentrated.
Details:
* neutron/common/rpc.py:
- added init() and cleanup() to set global RPC layer state.
- added utility functions: get_server(), get_client(), get_notifier()
that wrap up oslo.messaging API a bit, enforcing eventlet executor
and setting serializer, among other things.
- removed PluginRpcDispatcher, instead introduced PluginRpcSerializer
to use as a default serializer for API callbacks.
* neutron/common/rpc_compat.py:
- emulated incubator RPC layer behaviour thru previously introduced
stub classes (RpcCallback, RpcProxy, ...) using new oslo.messaging
API.
- switched to using new oslo.messaging exception types.
* neutron/service.py:
- expect multiple RPC listeners that are of MessageHandlingServer
type, not GreenThread.
* neutron/common/config.py:
- initialize RPC layer in init()
* setup.cfg:
- added entry points for old notifier drivers to retain backward
compatibility.
* neutron/tests/...:
- introduced fake_notifier to replace impl_fake.
- faked out consume_in_thread() to avoid starting RPC listeners when
running unit tests.
- used 'fake' transport driver.
- made sure neutron.test.* exceptions are caught.
- initialize and clean up RPC layer for each test case.
* Ported all affected code from using neutron.openstack.common.notifier
API to oslo.messaging.Notifier.
* rpc.set_defaults() was renamed to rpc.set_transport_defaults()
* other changes not worth mentioning here.
blueprint oslo-messaging
DocImpact
Change-Id: I5a91c34df6e300f2dc46217b1b16352fcc3039fc
1040 lines
48 KiB
Python
1040 lines
48 KiB
Python
# Copyright 2012 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.
|
|
|
|
import netaddr
|
|
import sqlalchemy as sa
|
|
from sqlalchemy import orm
|
|
from sqlalchemy.orm import exc
|
|
|
|
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
|
|
from neutron.api.v2 import attributes
|
|
from neutron.common import constants as l3_constants
|
|
from neutron.common import exceptions as n_exc
|
|
from neutron.common import rpc as n_rpc
|
|
from neutron.common import utils
|
|
from neutron.db import model_base
|
|
from neutron.db import models_v2
|
|
from neutron.extensions import external_net
|
|
from neutron.extensions import l3
|
|
from neutron import manager
|
|
from neutron.openstack.common import log as logging
|
|
from neutron.openstack.common import uuidutils
|
|
from neutron.plugins.common import constants
|
|
|
|
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
|
|
EXTERNAL_GW_INFO = l3.EXTERNAL_GW_INFO
|
|
|
|
# Maps API field to DB column
|
|
# API parameter name and Database column names may differ.
|
|
# Useful to keep the filtering between API and Database.
|
|
API_TO_DB_COLUMN_MAP = {'port_id': 'fixed_port_id'}
|
|
CORE_ROUTER_ATTRS = ('id', 'name', 'tenant_id', 'admin_state_up', 'status')
|
|
|
|
|
|
class Router(model_base.BASEV2, models_v2.HasId, models_v2.HasTenant):
|
|
"""Represents a v2 neutron router."""
|
|
|
|
name = sa.Column(sa.String(255))
|
|
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')
|
|
|
|
|
|
class FloatingIP(model_base.BASEV2, models_v2.HasId, models_v2.HasTenant):
|
|
"""Represents a floating IP address.
|
|
|
|
This IP address may or may not be allocated to a tenant, and may or
|
|
may not be associated with an internal port/ip address/router.
|
|
"""
|
|
|
|
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'),
|
|
nullable=False)
|
|
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
|
|
# aysnchronous backend is unavailable when the floating IP is disassociated
|
|
last_known_router_id = sa.Column(sa.String(36))
|
|
status = sa.Column(sa.String(16))
|
|
|
|
|
|
class L3_NAT_db_mixin(l3.RouterPluginBase):
|
|
"""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 l3_rpc_notifier(self):
|
|
if not hasattr(self, '_l3_rpc_notifier'):
|
|
self._l3_rpc_notifier = l3_rpc_agent_api.L3AgentNotifyAPI()
|
|
return self._l3_rpc_notifier
|
|
|
|
@l3_rpc_notifier.setter
|
|
def l3_rpc_notifier(self, value):
|
|
self._l3_rpc_notifier = value
|
|
|
|
@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']}
|
|
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 _create_router_db(self, context, router, tenant_id, gw_info):
|
|
"""Create the DB object and update gw info, if available."""
|
|
with context.session.begin(subtransactions=True):
|
|
# pre-generate id so it will be available when
|
|
# configuring external gw port
|
|
router_db = Router(id=uuidutils.generate_uuid(),
|
|
tenant_id=tenant_id,
|
|
name=router['name'],
|
|
admin_state_up=router['admin_state_up'],
|
|
status="ACTIVE")
|
|
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)
|
|
tenant_id = self._get_tenant_id_for_create(context, r)
|
|
with context.session.begin(subtransactions=True):
|
|
router_db = self._create_router_db(context, r, tenant_id, gw_info)
|
|
if gw_info:
|
|
self._update_router_gw_info(context, router_db['id'], gw_info)
|
|
return self._make_router_dict(router_db)
|
|
|
|
def _update_router_db(self, context, router_id, data, gw_info):
|
|
"""Update the DB object and related gw info, if available."""
|
|
with context.session.begin(subtransactions=True):
|
|
if gw_info != attributes.ATTR_NOT_SPECIFIED:
|
|
self._update_router_gw_info(context, router_id, gw_info)
|
|
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
|
|
candidates = None
|
|
if gw_info != attributes.ATTR_NOT_SPECIFIED:
|
|
candidates = self._check_router_needs_rescheduling(
|
|
context, id, gw_info)
|
|
router_db = self._update_router_db(context, id, r, gw_info)
|
|
if candidates:
|
|
l3_plugin = manager.NeutronManager.get_service_plugins().get(
|
|
constants.L3_ROUTER_NAT)
|
|
l3_plugin.reschedule_router(context, id, candidates)
|
|
|
|
self.l3_rpc_notifier.routers_updated(context, [router_db['id']])
|
|
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
|
|
|
|
When external_network_bridge is set, each L3 agent can be associated
|
|
with at most one external network. If router's new external gateway
|
|
is on other network then the router needs to be rescheduled to the
|
|
proper l3 agent.
|
|
If external_network_bridge is not set then the agent
|
|
can support multiple external networks and rescheduling is not needed
|
|
|
|
:return: list of candidate agents if rescheduling needed,
|
|
None otherwise; raises exception if there is no eligible l3 agent
|
|
associated with target external 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(
|
|
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):
|
|
# Port has no 'tenant-id', as it is hidden from user
|
|
gw_port = self._core_plugin.create_port(context.elevated(), {
|
|
'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': ''}})
|
|
|
|
if not gw_port['fixed_ips']:
|
|
self._core_plugin.delete_port(context.elevated(), gw_port['id'],
|
|
l3_port_check=False)
|
|
msg = (_('No IPs available for external network %s') %
|
|
network_id)
|
|
raise n_exc.BadRequest(resource='router', msg=msg)
|
|
|
|
with context.session.begin(subtransactions=True):
|
|
router.gw_port = self._core_plugin._get_port(context.elevated(),
|
|
gw_port['id'])
|
|
context.session.add(router)
|
|
|
|
def _validate_gw_info(self, context, gw_port, info):
|
|
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)
|
|
return network_id
|
|
|
|
def _delete_current_gw_port(self, context, router_id, router, new_network):
|
|
"""Delete gw port, if it is attached to an old network."""
|
|
is_gw_port_attached_to_existing_network = (
|
|
router.gw_port and router.gw_port['network_id'] != new_network)
|
|
admin_ctx = context.elevated()
|
|
if is_gw_port_attached_to_existing_network:
|
|
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'])
|
|
with context.session.begin(subtransactions=True):
|
|
gw_port_id = router.gw_port['id']
|
|
router.gw_port = None
|
|
context.session.add(router)
|
|
self._core_plugin.delete_port(
|
|
admin_ctx, gw_port_id, l3_port_check=False)
|
|
|
|
def _create_gw_port(self, context, router_id, router, new_network):
|
|
new_valid_gw_port_attachment = (
|
|
new_network and (not router.gw_port or
|
|
router.gw_port['network_id'] != new_network))
|
|
if new_valid_gw_port_attachment:
|
|
subnets = self._core_plugin._get_subnets_by_network(context,
|
|
new_network)
|
|
for subnet in subnets:
|
|
self._check_for_dup_router_subnet(context, router_id,
|
|
new_network, subnet['id'],
|
|
subnet['cidr'])
|
|
self._create_router_gw_port(context, router, new_network)
|
|
|
|
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
|
|
network_id = self._validate_gw_info(context, gw_port, info)
|
|
self._delete_current_gw_port(context, router_id, router, network_id)
|
|
self._create_gw_port(context, router_id, router, network_id)
|
|
|
|
def _ensure_router_not_in_use(self, context, router_id):
|
|
admin_ctx = context.elevated()
|
|
router = self._get_router(context, router_id)
|
|
if self.get_floatingips_count(
|
|
admin_ctx, filters={'router_id': [router_id]}):
|
|
raise l3.RouterInUse(router_id=router_id)
|
|
device_owner = self._get_device_owner(context, router)
|
|
device_filter = {'device_id': [router_id],
|
|
'device_owner': [device_owner]}
|
|
port_count = self._core_plugin.get_ports_count(
|
|
admin_ctx, filters=device_filter)
|
|
if port_count:
|
|
raise l3.RouterInUse(router_id=router_id)
|
|
return router
|
|
|
|
def delete_router(self, context, id):
|
|
with context.session.begin(subtransactions=True):
|
|
router = self._ensure_router_not_in_use(context, id)
|
|
|
|
#TODO(nati) Refactor here when we have router insertion model
|
|
vpnservice = manager.NeutronManager.get_service_plugins().get(
|
|
constants.VPN)
|
|
if vpnservice:
|
|
vpnservice.check_router_in_use(context, id)
|
|
|
|
context.session.delete(router)
|
|
|
|
# Delete the gw port after the router has been removed to
|
|
# avoid a constraint violation.
|
|
device_filter = {'device_id': [id],
|
|
'device_owner': [DEVICE_OWNER_ROUTER_GW]}
|
|
ports = self._core_plugin.get_ports(context.elevated(),
|
|
filters=device_filter)
|
|
if ports:
|
|
self._core_plugin._delete_port(context.elevated(),
|
|
ports[0]['id'])
|
|
|
|
self.l3_rpc_notifier.router_deleted(context, id)
|
|
|
|
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_subnet(self, context, router_id,
|
|
network_id, subnet_id, subnet_cidr):
|
|
try:
|
|
rport_qry = context.session.query(models_v2.Port)
|
|
rports = rport_qry.filter_by(device_id=router_id)
|
|
# It's possible these ports are on the same network, but
|
|
# different subnets.
|
|
new_ipnet = netaddr.IPNetwork(subnet_cidr)
|
|
for p in rports:
|
|
for ip in p['fixed_ips']:
|
|
if ip['subnet_id'] == subnet_id:
|
|
msg = (_("Router already has a port on subnet %s")
|
|
% subnet_id)
|
|
raise n_exc.BadRequest(resource='router', msg=msg)
|
|
sub_id = ip['subnet_id']
|
|
cidr = self._core_plugin._get_subnet(context.elevated(),
|
|
sub_id)['cidr']
|
|
ipnet = netaddr.IPNetwork(cidr)
|
|
match1 = netaddr.all_matching_cidrs(new_ipnet, [cidr])
|
|
match2 = netaddr.all_matching_cidrs(ipnet, [subnet_cidr])
|
|
if match1 or match2:
|
|
data = {'subnet_cidr': subnet_cidr,
|
|
'subnet_id': subnet_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)
|
|
except exc.NoResultFound:
|
|
pass
|
|
|
|
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):
|
|
if not interface_info:
|
|
msg = _("Either subnet_id or port_id must be specified")
|
|
raise n_exc.BadRequest(resource='router', msg=msg)
|
|
port_id_specified = 'port_id' in interface_info
|
|
subnet_id_specified = 'subnet_id' in interface_info
|
|
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 _add_interface_by_port(self, context, router_id, port_id, owner):
|
|
with context.session.begin(subtransactions=True):
|
|
port = self._core_plugin._get_port(context, port_id)
|
|
if port['device_id']:
|
|
raise n_exc.PortInUse(net_id=port['network_id'],
|
|
port_id=port['id'],
|
|
device_id=port['device_id'])
|
|
fixed_ips = [ip for ip in port['fixed_ips']]
|
|
if len(fixed_ips) != 1:
|
|
msg = _('Router port must have exactly one fixed IP')
|
|
raise n_exc.BadRequest(resource='router', msg=msg)
|
|
subnet_id = fixed_ips[0]['subnet_id']
|
|
subnet = self._core_plugin._get_subnet(context, subnet_id)
|
|
self._check_for_dup_router_subnet(context, router_id,
|
|
port['network_id'],
|
|
subnet['id'],
|
|
subnet['cidr'])
|
|
port.update({'device_id': router_id, 'device_owner': owner})
|
|
return port
|
|
|
|
def _add_interface_by_subnet(self, context, router_id, 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)
|
|
self._check_for_dup_router_subnet(context, router_id,
|
|
subnet['network_id'],
|
|
subnet_id,
|
|
subnet['cidr'])
|
|
fixed_ip = {'ip_address': subnet['gateway_ip'],
|
|
'subnet_id': subnet['id']}
|
|
return self._core_plugin.create_port(context, {
|
|
'port':
|
|
{'tenant_id': subnet['tenant_id'],
|
|
'network_id': subnet['network_id'],
|
|
'fixed_ips': [fixed_ip],
|
|
'mac_address': attributes.ATTR_NOT_SPECIFIED,
|
|
'admin_state_up': True,
|
|
'device_id': router_id,
|
|
'device_owner': owner,
|
|
'name': ''}})
|
|
|
|
def add_router_interface(self, context, router_id, interface_info):
|
|
add_by_port, add_by_sub = self._validate_interface_info(interface_info)
|
|
device_owner = self._get_device_owner(context, router_id)
|
|
|
|
if add_by_port:
|
|
port = self._add_interface_by_port(
|
|
context, router_id, interface_info['port_id'], device_owner)
|
|
elif add_by_sub:
|
|
port = self._add_interface_by_subnet(
|
|
context, router_id, interface_info['subnet_id'], device_owner)
|
|
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, [router_id], 'add_router_interface')
|
|
info = {'id': router_id,
|
|
'tenant_id': port['tenant_id'],
|
|
'port_id': port['id'],
|
|
'subnet_id': port['fixed_ips'][0]['subnet_id']}
|
|
notifier = n_rpc.get_notifier('network')
|
|
notifier.info(
|
|
context, 'router.interface.create', {'router_interface': info})
|
|
return info
|
|
|
|
def _confirm_router_interface_not_in_use(self, context, router_id,
|
|
subnet_id):
|
|
subnet_db = self._core_plugin._get_subnet(context, subnet_id)
|
|
subnet_cidr = netaddr.IPNetwork(subnet_db['cidr'])
|
|
fip_qry = context.session.query(FloatingIP)
|
|
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):
|
|
port_db = self._core_plugin._get_port(context, port_id)
|
|
if not (port_db['device_owner'] == owner and
|
|
port_db['device_id'] == router_id):
|
|
raise l3.RouterInterfaceNotFound(router_id=router_id,
|
|
port_id=port_id)
|
|
port_subnet_id = port_db['fixed_ips'][0]['subnet_id']
|
|
if subnet_id and port_subnet_id != subnet_id:
|
|
raise n_exc.SubnetMismatchForPort(
|
|
port_id=port_id, subnet_id=subnet_id)
|
|
subnet = self._core_plugin._get_subnet(context, port_subnet_id)
|
|
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, subnet)
|
|
|
|
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)
|
|
ports = rport_qry.filter_by(
|
|
device_id=router_id,
|
|
device_owner=owner,
|
|
network_id=subnet['network_id'])
|
|
|
|
for p in ports:
|
|
if p['fixed_ips'][0]['subnet_id'] == subnet_id:
|
|
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):
|
|
if not interface_info:
|
|
msg = _("Either subnet_id or port_id must be specified")
|
|
raise n_exc.BadRequest(resource='router', msg=msg)
|
|
port_id = interface_info.get('port_id')
|
|
subnet_id = interface_info.get('subnet_id')
|
|
device_owner = self._get_device_owner(context, router_id)
|
|
if port_id:
|
|
port, subnet = self._remove_interface_by_port(context, router_id,
|
|
port_id, subnet_id,
|
|
device_owner)
|
|
elif subnet_id:
|
|
port, subnet = self._remove_interface_by_subnet(
|
|
context, router_id, subnet_id, device_owner)
|
|
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, [router_id], 'remove_router_interface')
|
|
info = {'id': router_id,
|
|
'tenant_id': port['tenant_id'],
|
|
'port_id': port['id'],
|
|
'subnet_id': subnet['id']}
|
|
notifier = n_rpc.get_notifier('network')
|
|
notifier.info(
|
|
context, 'router.interface.delete', {'router_interface': info})
|
|
return info
|
|
|
|
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):
|
|
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']}
|
|
return self._fields(res, fields)
|
|
|
|
def _get_interface_ports_for_network(self, context, network_id):
|
|
router_intf_qry = context.session.query(models_v2.Port)
|
|
return router_intf_qry.filter_by(
|
|
network_id=network_id,
|
|
device_owner=DEVICE_OWNER_ROUTER_INTF)
|
|
|
|
def _get_router_for_floatingip(self, context, internal_port,
|
|
internal_subnet_id,
|
|
external_network_id):
|
|
subnet_db = self._core_plugin._get_subnet(context,
|
|
internal_subnet_id)
|
|
if not subnet_db['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)
|
|
|
|
router_intf_ports = self._get_interface_ports_for_network(
|
|
context, internal_port['network_id'])
|
|
|
|
for intf_p in router_intf_ports:
|
|
if intf_p['fixed_ips'][0]['subnet_id'] == internal_subnet_id:
|
|
router_id = intf_p['device_id']
|
|
router_gw_qry = context.session.query(models_v2.Port)
|
|
has_gw_port = router_gw_qry.filter_by(
|
|
network_id=external_network_id,
|
|
device_id=router_id,
|
|
device_owner=DEVICE_OWNER_ROUTER_GW).count()
|
|
if has_gw_port:
|
|
return router_id
|
|
|
|
raise l3.ExternalGatewayForFloatingIPNotFound(
|
|
subnet_id=internal_subnet_id,
|
|
external_network_id=external_network_id,
|
|
port_id=internal_port['id'])
|
|
|
|
def _internal_fip_assoc_data(self, context, fip):
|
|
"""Retrieve internal port data for floating IP.
|
|
|
|
Retrieve information concerning the internal port where
|
|
the floating IP should be associated to.
|
|
"""
|
|
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 'fixed_ip_address' in fip and fip['fixed_ip_address']:
|
|
internal_ip_address = fip['fixed_ip_address']
|
|
for ip in internal_port['fixed_ips']:
|
|
if ip['ip_address'] == internal_ip_address:
|
|
internal_subnet_id = ip['subnet_id']
|
|
if not internal_subnet_id:
|
|
msg = (_('Port %(id)s does not have fixed ip %(address)s') %
|
|
{'id': internal_port['id'],
|
|
'address': internal_ip_address})
|
|
raise n_exc.BadRequest(resource='floatingip', msg=msg)
|
|
else:
|
|
ips = [ip['ip_address'] for ip in internal_port['fixed_ips']]
|
|
if not ips:
|
|
msg = (_('Cannot add floating IP to port %s that has'
|
|
'no fixed IP addresses') % internal_port['id'])
|
|
raise n_exc.BadRequest(resource='floatingip', msg=msg)
|
|
if len(ips) > 1:
|
|
msg = (_('Port %s has multiple fixed IPs. Must provide'
|
|
' a specific IP when assigning a floating IP') %
|
|
internal_port['id'])
|
|
raise n_exc.BadRequest(resource='floatingip', msg=msg)
|
|
internal_ip_address = internal_port['fixed_ips'][0]['ip_address']
|
|
internal_subnet_id = internal_port['fixed_ips'][0]['subnet_id']
|
|
return internal_port, internal_subnet_id, internal_ip_address
|
|
|
|
def get_assoc_data(self, context, fip, floating_network_id):
|
|
"""Determine/extract data associated with the internal port.
|
|
|
|
When a floating IP is associated with an internal port,
|
|
we need to extract/determine some data associated with the
|
|
internal port, including the internal_ip_address, and router_id.
|
|
We also need to confirm that this internal port is owned by the
|
|
tenant who owns the floating IP.
|
|
"""
|
|
(internal_port, internal_subnet_id,
|
|
internal_ip_address) = self._internal_fip_assoc_data(context, fip)
|
|
router_id = self._get_router_for_floatingip(context,
|
|
internal_port,
|
|
internal_subnet_id,
|
|
floating_network_id)
|
|
# confirm that this router has a floating
|
|
# ip enabled gateway with support for this floating IP network
|
|
try:
|
|
port_qry = context.elevated().session.query(models_v2.Port)
|
|
port_qry.filter_by(
|
|
network_id=floating_network_id,
|
|
device_id=router_id,
|
|
device_owner=DEVICE_OWNER_ROUTER_GW).one()
|
|
except exc.NoResultFound:
|
|
raise l3.ExternalGatewayForFloatingIPNotFound(
|
|
subnet_id=internal_subnet_id,
|
|
port_id=internal_port['id'])
|
|
|
|
return (fip['port_id'], internal_ip_address, router_id)
|
|
|
|
def _update_fip_assoc(self, context, fip, floatingip_db, external_port):
|
|
previous_router_id = floatingip_db.router_id
|
|
port_id = internal_ip_address = router_id = None
|
|
if (('fixed_ip_address' in fip and fip['fixed_ip_address']) and
|
|
not ('port_id' in fip and fip['port_id'])):
|
|
msg = _("fixed_ip_address cannot be specified without a port_id")
|
|
raise n_exc.BadRequest(resource='floatingip', msg=msg)
|
|
if 'port_id' in fip and fip['port_id']:
|
|
port_id, internal_ip_address, router_id = self.get_assoc_data(
|
|
context,
|
|
fip,
|
|
floatingip_db['floating_network_id'])
|
|
fip_qry = context.session.query(FloatingIP)
|
|
try:
|
|
fip_qry.filter_by(
|
|
fixed_port_id=fip['port_id'],
|
|
floating_network_id=floatingip_db['floating_network_id'],
|
|
fixed_ip_address=internal_ip_address).one()
|
|
raise l3.FloatingIPPortAlreadyAssociated(
|
|
port_id=fip['port_id'],
|
|
fip_id=floatingip_db['id'],
|
|
floating_ip_address=floatingip_db['floating_ip_address'],
|
|
fixed_ip=internal_ip_address,
|
|
net_id=floatingip_db['floating_network_id'])
|
|
except exc.NoResultFound:
|
|
pass
|
|
floatingip_db.update({'fixed_ip_address': internal_ip_address,
|
|
'fixed_port_id': port_id,
|
|
'router_id': router_id,
|
|
'last_known_router_id': previous_router_id})
|
|
|
|
def create_floatingip(
|
|
self, context, floatingip,
|
|
initial_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
|
|
fip = floatingip['floatingip']
|
|
tenant_id = self._get_tenant_id_for_create(context, fip)
|
|
fip_id = uuidutils.generate_uuid()
|
|
|
|
f_net_id = fip['floating_network_id']
|
|
if not self._core_plugin._network_is_external(context, f_net_id):
|
|
msg = _("Network %s is not a valid external network") % f_net_id
|
|
raise n_exc.BadRequest(resource='floatingip', msg=msg)
|
|
|
|
with context.session.begin(subtransactions=True):
|
|
# This external port is never exposed to the tenant.
|
|
# it is used purely for internal system and admin use when
|
|
# managing floating IPs.
|
|
external_port = self._core_plugin.create_port(context.elevated(), {
|
|
'port':
|
|
{'tenant_id': '', # tenant intentionally not set
|
|
'network_id': f_net_id,
|
|
'mac_address': attributes.ATTR_NOT_SPECIFIED,
|
|
'fixed_ips': attributes.ATTR_NOT_SPECIFIED,
|
|
'admin_state_up': True,
|
|
'device_id': fip_id,
|
|
'device_owner': DEVICE_OWNER_FLOATINGIP,
|
|
'name': ''}})
|
|
# Ensure IP addresses are allocated on external port
|
|
if not external_port['fixed_ips']:
|
|
raise n_exc.ExternalIpAddressExhausted(net_id=f_net_id)
|
|
|
|
floating_fixed_ip = external_port['fixed_ips'][0]
|
|
floating_ip_address = floating_fixed_ip['ip_address']
|
|
floatingip_db = FloatingIP(
|
|
id=fip_id,
|
|
tenant_id=tenant_id,
|
|
status=initial_status,
|
|
floating_network_id=fip['floating_network_id'],
|
|
floating_ip_address=floating_ip_address,
|
|
floating_port_id=external_port['id'])
|
|
fip['tenant_id'] = tenant_id
|
|
# Update association with internal port
|
|
# and define external IP address
|
|
self._update_fip_assoc(context, fip,
|
|
floatingip_db, external_port)
|
|
context.session.add(floatingip_db)
|
|
|
|
router_id = floatingip_db['router_id']
|
|
if router_id:
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, [router_id],
|
|
'create_floatingip')
|
|
return self._make_floatingip_dict(floatingip_db)
|
|
|
|
def update_floatingip(self, context, id, floatingip):
|
|
fip = floatingip['floatingip']
|
|
with context.session.begin(subtransactions=True):
|
|
floatingip_db = self._get_floatingip(context, id)
|
|
fip['tenant_id'] = floatingip_db['tenant_id']
|
|
fip['id'] = id
|
|
fip_port_id = floatingip_db['floating_port_id']
|
|
before_router_id = floatingip_db['router_id']
|
|
self._update_fip_assoc(context, fip, floatingip_db,
|
|
self._core_plugin.get_port(
|
|
context.elevated(), fip_port_id))
|
|
router_ids = []
|
|
if before_router_id:
|
|
router_ids.append(before_router_id)
|
|
router_id = floatingip_db['router_id']
|
|
if router_id and router_id != before_router_id:
|
|
router_ids.append(router_id)
|
|
if router_ids:
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, router_ids, 'update_floatingip')
|
|
return self._make_floatingip_dict(floatingip_db)
|
|
|
|
def update_floatingip_status(self, context, floatingip_id, status):
|
|
"""Update operational status for floating IP in neutron DB."""
|
|
fip_query = self._model_query(context, FloatingIP).filter(
|
|
FloatingIP.id == floatingip_id)
|
|
fip_query.update({'status': status}, synchronize_session=False)
|
|
|
|
def delete_floatingip(self, context, id):
|
|
floatingip = self._get_floatingip(context, id)
|
|
router_id = floatingip['router_id']
|
|
with context.session.begin(subtransactions=True):
|
|
context.session.delete(floatingip)
|
|
self._core_plugin.delete_port(context.elevated(),
|
|
floatingip['floating_port_id'],
|
|
l3_port_check=False)
|
|
if router_id:
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, [router_id],
|
|
'delete_floatingip')
|
|
|
|
def get_floatingip(self, context, id, fields=None):
|
|
floatingip = self._get_floatingip(context, id)
|
|
return self._make_floatingip_dict(floatingip, fields)
|
|
|
|
def get_floatingips(self, context, filters=None, fields=None,
|
|
sorts=None, limit=None, marker=None,
|
|
page_reverse=False):
|
|
marker_obj = self._get_marker_obj(context, 'floatingip', limit,
|
|
marker)
|
|
if filters is not None:
|
|
for key, val in API_TO_DB_COLUMN_MAP.iteritems():
|
|
if key in filters:
|
|
filters[val] = filters.pop(key)
|
|
|
|
return self._get_collection(context, FloatingIP,
|
|
self._make_floatingip_dict,
|
|
filters=filters, fields=fields,
|
|
sorts=sorts,
|
|
limit=limit,
|
|
marker_obj=marker_obj,
|
|
page_reverse=page_reverse)
|
|
|
|
def delete_disassociated_floatingips(self, context, network_id):
|
|
query = self._model_query(context, FloatingIP)
|
|
query = query.filter_by(floating_network_id=network_id,
|
|
fixed_port_id=None,
|
|
router_id=None)
|
|
for fip in query:
|
|
self.delete_floatingip(context, fip.id)
|
|
|
|
def get_floatingips_count(self, context, filters=None):
|
|
return self._get_collection_count(context, FloatingIP,
|
|
filters=filters)
|
|
|
|
def prevent_l3_port_deletion(self, context, port_id):
|
|
"""Checks to make sure a port is allowed to be deleted.
|
|
|
|
Raises 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_db = self._core_plugin._get_port(context, port_id)
|
|
if port_db['device_owner'] in self.router_device_owners:
|
|
# Raise port in use only if the port has IP addresses
|
|
# Otherwise it's a stale port that can be removed
|
|
fixed_ips = port_db['fixed_ips']
|
|
if fixed_ips:
|
|
raise l3.L3PortInUse(port_id=port_id,
|
|
device_owner=port_db['device_owner'])
|
|
else:
|
|
LOG.debug(_("Port %(port_id)s has owner %(port_owner)s, but "
|
|
"no IP address, so it can be deleted"),
|
|
{'port_id': port_db['id'],
|
|
'port_owner': port_db['device_owner']})
|
|
|
|
def disassociate_floatingips(self, context, port_id):
|
|
router_ids = set()
|
|
|
|
with context.session.begin(subtransactions=True):
|
|
fip_qry = context.session.query(FloatingIP)
|
|
floating_ips = fip_qry.filter_by(fixed_port_id=port_id)
|
|
for floating_ip in floating_ips:
|
|
router_ids.add(floating_ip['router_id'])
|
|
floating_ip.update({'fixed_port_id': None,
|
|
'fixed_ip_address': None,
|
|
'router_id': None})
|
|
|
|
if router_ids:
|
|
self.l3_rpc_notifier.routers_updated(
|
|
context, list(router_ids),
|
|
'disassociate_floatingips')
|
|
|
|
def _build_routers_list(self, routers, gw_ports):
|
|
gw_port_id_gw_port_dict = dict((gw_port['id'], gw_port)
|
|
for gw_port in gw_ports)
|
|
for router in routers:
|
|
gw_port_id = router['gw_port_id']
|
|
if gw_port_id:
|
|
router['gw_port'] = gw_port_id_gw_port_dict[gw_port_id]
|
|
return routers
|
|
|
|
def _get_sync_routers(self, context, router_ids=None, active=None):
|
|
"""Query routers and their gw ports for l3 agent.
|
|
|
|
Query routers with the router_ids. The gateway ports, if any,
|
|
will be queried too.
|
|
l3 agent has an option to deal with only one router id. In addition,
|
|
when we need to notify the agent the data about only one router
|
|
(when modification of router, its interfaces, gw_port and floatingips),
|
|
we will have router_ids.
|
|
@param router_ids: the list of router ids which we want to query.
|
|
if it is None, all of routers will be queried.
|
|
@return: a list of dicted routers with dicted gw_port populated if any
|
|
"""
|
|
filters = {'id': router_ids} if router_ids else {}
|
|
if active is not None:
|
|
filters['admin_state_up'] = [active]
|
|
router_dicts = self.get_routers(context, filters=filters)
|
|
gw_port_ids = []
|
|
if not router_dicts:
|
|
return []
|
|
for router_dict in router_dicts:
|
|
gw_port_id = router_dict['gw_port_id']
|
|
if gw_port_id:
|
|
gw_port_ids.append(gw_port_id)
|
|
gw_ports = []
|
|
if gw_port_ids:
|
|
gw_ports = self.get_sync_gw_ports(context, gw_port_ids)
|
|
return self._build_routers_list(router_dicts, gw_ports)
|
|
|
|
def _get_sync_floating_ips(self, context, router_ids):
|
|
"""Query floating_ips that relate to list of router_ids."""
|
|
if not router_ids:
|
|
return []
|
|
return self.get_floatingips(context, {'router_id': router_ids})
|
|
|
|
def get_sync_gw_ports(self, context, gw_port_ids):
|
|
if not gw_port_ids:
|
|
return []
|
|
filters = {'id': gw_port_ids}
|
|
gw_ports = self._core_plugin.get_ports(context, filters)
|
|
if gw_ports:
|
|
self._populate_subnet_for_ports(context, gw_ports)
|
|
return gw_ports
|
|
|
|
def get_sync_interfaces(self, context, router_ids, device_owners=None):
|
|
"""Query router interfaces that relate to list of router_ids."""
|
|
device_owners = device_owners or [DEVICE_OWNER_ROUTER_INTF]
|
|
if not router_ids:
|
|
return []
|
|
filters = {'device_id': router_ids,
|
|
'device_owner': device_owners}
|
|
interfaces = self._core_plugin.get_ports(context, filters)
|
|
if interfaces:
|
|
self._populate_subnet_for_ports(context, interfaces)
|
|
return interfaces
|
|
|
|
def _populate_subnet_for_ports(self, context, ports):
|
|
"""Populate ports with subnet.
|
|
|
|
These ports already have fixed_ips populated.
|
|
"""
|
|
if not ports:
|
|
return
|
|
|
|
def each_port_with_ip():
|
|
for port in ports:
|
|
fixed_ips = port.get('fixed_ips', [])
|
|
if len(fixed_ips) > 1:
|
|
LOG.info(_("Ignoring multiple IPs on router port %s"),
|
|
port['id'])
|
|
continue
|
|
elif not fixed_ips:
|
|
# Skip ports without IPs, which can occur if a subnet
|
|
# attached to a router is deleted
|
|
LOG.info(_("Skipping port %s as no IP is configure on it"),
|
|
port['id'])
|
|
continue
|
|
yield (port, fixed_ips[0])
|
|
|
|
network_ids = set(p['network_id'] for p, _ in each_port_with_ip())
|
|
filters = {'network_id': [id for id in network_ids]}
|
|
fields = ['id', 'cidr', 'gateway_ip', 'network_id']
|
|
|
|
subnets_by_network = dict((id, []) for id in network_ids)
|
|
for subnet in self._core_plugin.get_subnets(context, filters, fields):
|
|
subnets_by_network[subnet['network_id']].append(subnet)
|
|
|
|
for port, fixed_ip in each_port_with_ip():
|
|
port['extra_subnets'] = []
|
|
for subnet in subnets_by_network[port['network_id']]:
|
|
subnet_info = {'id': subnet['id'],
|
|
'cidr': subnet['cidr'],
|
|
'gateway_ip': subnet['gateway_ip']}
|
|
|
|
if subnet['id'] == fixed_ip['subnet_id']:
|
|
port['subnet'] = subnet_info
|
|
else:
|
|
port['extra_subnets'].append(subnet_info)
|
|
|
|
def _process_sync_data(self, routers, interfaces, floating_ips):
|
|
routers_dict = {}
|
|
for router in routers:
|
|
routers_dict[router['id']] = router
|
|
for floating_ip in floating_ips:
|
|
router = routers_dict.get(floating_ip['router_id'])
|
|
if router:
|
|
router_floatingips = router.get(l3_constants.FLOATINGIP_KEY,
|
|
[])
|
|
router_floatingips.append(floating_ip)
|
|
router[l3_constants.FLOATINGIP_KEY] = router_floatingips
|
|
for interface in interfaces:
|
|
router = routers_dict.get(interface['device_id'])
|
|
if router:
|
|
router_interfaces = router.get(l3_constants.INTERFACE_KEY, [])
|
|
router_interfaces.append(interface)
|
|
router[l3_constants.INTERFACE_KEY] = router_interfaces
|
|
return routers_dict.values()
|
|
|
|
def _get_router_info_list(self, context, router_ids=None, active=None,
|
|
device_owners=None):
|
|
"""Query routers and their related floating_ips, interfaces."""
|
|
with context.session.begin(subtransactions=True):
|
|
routers = self._get_sync_routers(context,
|
|
router_ids=router_ids,
|
|
active=active)
|
|
router_ids = [router['id'] for router in routers]
|
|
interfaces = self.get_sync_interfaces(
|
|
context, router_ids, device_owners)
|
|
floating_ips = self._get_sync_floating_ips(context, router_ids)
|
|
return (routers, interfaces, floating_ips)
|
|
|
|
def get_sync_data(self, context, router_ids=None, active=None):
|
|
routers, interfaces, floating_ips = self._get_router_info_list(
|
|
context, router_ids=router_ids, active=active)
|
|
return self._process_sync_data(routers, interfaces, floating_ips)
|