def get_ip_availability(**kwargs):
LOG.debug("Begin querying %s" % kwargs)
used_ips = get_used_ips(neutron_db_api.get_session(), **kwargs)
unused_ips = get_unused_ips(neutron_db_api.get_session(), used_ips,
**kwargs)
LOG.debug("End querying")
return dict(used=used_ips, unused=unused_ips)
def _get_agent_fdb(self, segment, port, agent_host):
if not agent_host:
return
network_id = port['network_id']
session = db_api.get_session()
agent_active_ports = l2pop_db.get_agent_network_active_port_count(
session, agent_host, network_id)
agent = l2pop_db.get_agent_by_host(db_api.get_session(), agent_host)
if not self._validate_segment(segment, port['id'], agent):
return
agent_ip = l2pop_db.get_agent_ip(agent)
other_fdb_entries = self._get_fdb_entries_template(
segment, agent_ip, port['network_id'])
if agent_active_ports == 0:
# Agent is removing its last activated port in this network,
# other agents needs to be notified to delete their flooding entry.
other_fdb_entries[network_id]['ports'][agent_ip].append(
const.FLOODING_ENTRY)
# Notify other agents to remove fdb rules for current port
if port['device_owner'] != const.DEVICE_OWNER_DVR_INTERFACE:
fdb_entries = self._get_port_fdb_entries(port)
other_fdb_entries[network_id]['ports'][agent_ip] += fdb_entries
return other_fdb_entries
def update_port_state_with_notifier(self, rpc_context, **kwargs):
port_id = kwargs.get('port_id')
network_id = kwargs.get('network_id')
network_type = kwargs.get('network_type')
segmentation_id = kwargs.get('segmentation_id')
physical_network = kwargs.get('physical_network')
# 1 update segment
session = db_api.get_session()
with session.begin(subtransactions=True):
try:
query = (session.query(models_ml2.NetworkSegment).
filter_by(network_id=network_id))
query = query.filter_by(physical_network=physical_network)
query = query.filter_by(is_dynamic=True)
record = query.one()
record.segmentation_id = segmentation_id
except sa_exc.NoResultFound:
pass
# 2 change port state
plugin = manager.NeutronManager.get_plugin()
plugin.update_port_status(
rpc_context,
port_id,
constants.PORT_STATUS_ACTIVE
)
# 3 serch db from port_id
session = db_api.get_session()
port = None
with session.begin(subtransactions=True):
try:
port_db = (session.query(models_v2.Port).
enable_eagerloads(False).
filter(models_v2.Port.id.startswith(port_id)).
one())
port = plugin._make_port_dict(port_db)
except sa_exc.NoResultFound:
LOG.error(_LE("Can't find port with port_id %s"),
port_id)
except sa_exc.MultipleResultsFound:
LOG.error(_LE("Multiple ports have port_id starting with %s"),
port_id)
# 4 send notifier
if port is not None:
LOG.debug("notifier port_update %(net_type)s, %(seg_id)s, "
"%(physnet)s",
{'net_type': network_type,
'seg_id': segmentation_id,
'physnet': physical_network})
plugin.notifier.port_update(
rpc_context, port,
network_type,
segmentation_id,
physical_network
)
return {}
def _test_and_create_object(id):
try:
session = db_api.get_session()
with session.begin():
session.query(models.DFLockedObjects).filter_by(
object_uuid=id).one()
except orm_exc.NoResultFound:
try:
session = db_api.get_session()
with session.begin():
_create_db_row(session, oid=id)
except db_exc.DBDuplicateEntry:
# the lock is concurrently created.
pass
def test_create_network_with_default_n1kv_network_profile_id(self):
"""Test network create without passing network profile id."""
with self.network() as network:
db_session = db.get_session()
np = n1kv_db_v2.get_network_profile(
db_session, network['network'][n1kv.PROFILE_ID])
self.assertEqual(np['name'], 'default_network_profile')
def _delete_data(self):
session = db_api.get_session()
with session.begin():
query = session.query(test_quota.MehModel).filter_by(
tenant_id=self.tenant_id)
for item in query:
session.delete(item)
def _sync_vxlan_allocations(self):
"""
Synchronize vxlan_allocations table with configured tunnel ranges.
"""
# determine current configured allocatable vnis
vxlan_vnis = set()
for tun_min, tun_max in self.vxlan_vni_ranges:
if tun_max + 1 - tun_min > MAX_VXLAN_VNI:
LOG.error(_("Skipping unreasonable VXLAN VNI range "
"%(tun_min)s:%(tun_max)s"),
{'tun_min': tun_min, 'tun_max': tun_max})
else:
vxlan_vnis |= set(xrange(tun_min, tun_max + 1))
session = db_api.get_session()
with session.begin(subtransactions=True):
# remove from table unallocated tunnels not currently allocatable
allocs = session.query(VxlanAllocation)
for alloc in allocs:
try:
# see if tunnel is allocatable
vxlan_vnis.remove(alloc.vxlan_vni)
except KeyError:
# it's not allocatable, so check if its allocated
if not alloc.allocated:
# it's not, so remove it from table
LOG.debug(_("Removing tunnel %s from pool"),
alloc.vxlan_vni)
session.delete(alloc)
# add missing allocatable tunnels to table
for vxlan_vni in sorted(vxlan_vnis):
alloc = VxlanAllocation(vxlan_vni=vxlan_vni)
session.add(alloc)
def test_create_port_with_default_n1kv_policy_profile_id(self):
"""Test port create without passing policy profile id."""
with self.port() as port:
db_session = db.get_session()
pp = n1kv_db_v2.get_policy_profile(
db_session, port['port'][n1kv.PROFILE_ID])
self.assertEqual(pp['name'], 'service_profile')
def update_ip_owner(self, ip_owner_info):
ports_to_update = set()
port_id = ip_owner_info.get('port')
ipv4 = ip_owner_info.get('ip_address_v4')
ipv6 = ip_owner_info.get('ip_address_v6')
network_id = ip_owner_info.get('network_id')
if not port_id or (not ipv4 and not ipv6):
return ports_to_update
LOG.debug("Got IP owner update: %s", ip_owner_info)
core_plugin = self._get_plugin()
# REVISIT: just use SQLAlchemy session and models_v2.Port?
port = core_plugin.get_port(nctx.get_admin_context(), port_id)
if not port:
LOG.debug("Ignoring update for non-existent port: %s", port_id)
return ports_to_update
ports_to_update.add(port_id)
for ipa in [ipv4, ipv6]:
if not ipa:
continue
try:
session = db_api.get_session()
with session.begin(subtransactions=True):
old_owner = self.ha_ip_handler.get_port_for_ha_ipaddress(
ipa, network_id or port['network_id'], session=session)
self.ha_ip_handler.set_port_id_for_ha_ipaddress(port_id,
ipa,
session)
if old_owner and old_owner['port_id'] != port_id:
self.ha_ip_handler.delete_port_id_for_ha_ipaddress(
old_owner['port_id'], ipa, session=session)
ports_to_update.add(old_owner['port_id'])
except db_exc.DBReferenceError as dbe:
LOG.debug("Ignoring FK error for port %s: %s", port_id, dbe)
return ports_to_update
def get_port_from_device(device):
"""Get port from database."""
LOG.debug(_("get_port_from_device() called"))
session = db.get_session()
sg_binding_port = sg_db.SecurityGroupPortBinding.port_id
query = session.query(models_v2.Port,
sg_db.SecurityGroupPortBinding.security_group_id)
query = query.outerjoin(sg_db.SecurityGroupPortBinding,
models_v2.Port.id == sg_binding_port)
query = query.filter(models_v2.Port.id.startswith(device))
port_and_sgs = query.all()
if not port_and_sgs:
return
port = port_and_sgs[0][0]
plugin = manager.NeutronManager.get_plugin()
port_dict = plugin._make_port_dict(port)
port_dict['security_groups'] = []
for port_in_db, sg_id in port_and_sgs:
if sg_id:
port_dict['security_groups'].append(sg_id)
port_dict['security_group_rules'] = []
port_dict['security_group_source_groups'] = []
port_dict['fixed_ips'] = [ip['ip_address']
for ip in port['fixed_ips']]
return port_dict
def get_port_and_sgs(port_id):
"""Get port from database with security group info."""
LOG.debug(_("get_port_and_sgs() called for port_id %s"), port_id)
session = db_api.get_session()
sg_binding_port = sg_db.SecurityGroupPortBinding.port_id
with session.begin(subtransactions=True):
query = session.query(models_v2.Port,
sg_db.SecurityGroupPortBinding.security_group_id)
query = query.outerjoin(sg_db.SecurityGroupPortBinding,
models_v2.Port.id == sg_binding_port)
query = query.filter(models_v2.Port.id.startswith(port_id))
port_and_sgs = query.all()
if not port_and_sgs:
return
port = port_and_sgs[0][0]
plugin = manager.NeutronManager.get_plugin()
port_dict = plugin._make_port_dict(port)
port_dict['security_groups'] = [
sg_id for port_, sg_id in port_and_sgs if sg_id]
port_dict['security_group_rules'] = []
port_dict['security_group_source_groups'] = []
port_dict['fixed_ips'] = [ip['ip_address']
for ip in port['fixed_ips']]
return port_dict
def sync_network_states(network_vlan_ranges):
"""Synchronize network_states table with current configured VLAN ranges."""
session = db.get_session()
with session.begin():
# get existing allocations for all physical networks
allocations = dict()
entries = session.query(mlnx_models_v2.SegmentationIdAllocation).all()
for entry in entries:
allocations.setdefault(entry.physical_network, set()).add(entry)
# process vlan ranges for each configured physical network
for physical_network, vlan_ranges in network_vlan_ranges.iteritems():
# determine current configured allocatable vlans for this
# physical network
vlan_ids = set()
for vlan_range in vlan_ranges:
vlan_ids |= set(moves.xrange(vlan_range[0], vlan_range[1] + 1))
# remove from table unallocated vlans not currently allocatable
_remove_non_allocatable_vlans(session, allocations, physical_network, vlan_ids)
# add missing allocatable vlans to table
_add_missing_allocatable_vlans(session, physical_network, vlan_ids)
# remove from table unallocated vlans for any unconfigured physical
# networks
_remove_unconfigured_vlans(session, allocations)
def sanitize_policy_profile_table(self):
"""Clear policy profiles from stale VSM."""
db_session = db.get_session()
hosts = config.get_vsm_hosts()
vsm_info = db_session.query(
n1kv_models.PolicyProfile.vsm_ip).distinct()
if vsm_info is None or hosts is None:
return
vsm_ips = [vsm_ip[0] for vsm_ip in vsm_info if vsm_ip[0] not in hosts]
for vsm_ip in vsm_ips:
pprofiles = n1kv_db.get_policy_profiles_by_host(vsm_ip, db_session)
for pprofile in pprofiles:
# Do not delete profile if it is in use and if it
# is the only VSM to have it configured
pp_in_use = n1kv_db.policy_profile_in_use(pprofile['id'],
db_session)
num_vsm_using_pp = db_session.query(
n1kv_models.PolicyProfile).filter_by(
id=pprofile['id']).count()
if (not pp_in_use) or (num_vsm_using_pp > 1):
db_session.delete(pprofile)
db_session.flush()
else:
LOG.warning(_LW('Cannot delete policy profile %s '
'as it is in use.'), pprofile['id'])
def setUp(self):
super(VlanAllocationsTest, self).setUp()
db.configure_db()
self.session = db.get_session()
self.net_p = _create_test_network_profile_if_not_there(self.session)
n1kv_db_v2.sync_vlan_allocations(self.session, self.net_p)
self.addCleanup(db.clear_db)
def remove_reserved_binding(vlan_id, switch_ip, instance_id,
port_id):
"""Removes reserved binding.
This overloads port bindings to support reserved Switch binding
used to maintain the state of a switch so it can be viewed by
all other neutron processes. There's also the case of
a reserved port binding to keep switch information on a given
interface.
The values of these arguments is as follows:
:param vlan_id: 0
:param switch_ip: ip address of the switch
:param instance_id: fixed string RESERVED_NEXUS_SWITCH_DEVICE_ID_R1
: or RESERVED_NEXUS_PORT_DEVICE_ID_R1
:param port_id: switch-state of ACTIVE, RESTORE_S1, RESTORE_S2, INACTIVE
: port-expected port_id
"""
if not port_id:
LOG.warning(_LW("remove_reserved_binding called with no state"))
return
LOG.debug("remove_reserved_binding called")
session = db.get_session()
binding = _lookup_one_nexus_binding(session=session,
vlan_id=vlan_id,
switch_ip=switch_ip,
instance_id=instance_id,
port_id=port_id)
for bind in binding:
session.delete(bind)
session.flush()
return binding
def get_device_details(self, rpc_context, **kwargs):
"""Agent requests device details."""
agent_id = kwargs.get("agent_id")
device = kwargs.get("device")
LOG.debug(_("Device %(device)s details requested from %(agent_id)s"), {"device": device, "agent_id": agent_id})
port = self.get_port_from_device(device)
if port:
binding = db.get_network_binding(db_api.get_session(), port["network_id"])
(network_type, segmentation_id) = constants.interpret_vlan_id(binding.vlan_id)
entry = {
"device": device,
"network_type": network_type,
"physical_network": binding.physical_network,
"segmentation_id": segmentation_id,
"network_id": port["network_id"],
"port_id": port["id"],
"admin_state_up": port["admin_state_up"],
}
if cfg.CONF.AGENT.rpc_support_old_agents:
entry["vlan_id"] = binding.vlan_id
new_status = q_const.PORT_STATUS_ACTIVE if port["admin_state_up"] else q_const.PORT_STATUS_DOWN
if port["status"] != new_status:
db.set_port_status(port["id"], new_status)
else:
entry = {"device": device}
LOG.debug(_("%s can not be found in database"), device)
return entry
def get_device_details(self, rpc_context, **kwargs):
"""Agent requests device details."""
agent_id = kwargs.get('agent_id')
device = kwargs.get('device')
LOG.debug("Device %(device)s details requested from %(agent_id)s",
{'device': device, 'agent_id': agent_id})
plugin = manager.NeutronManager.get_plugin()
port = plugin.get_port_from_device(device)
if port:
binding = db.get_network_binding(db_api.get_session(),
port['network_id'])
entry = {'device': device,
'physical_network': binding.physical_network,
'network_type': binding.network_type,
'segmentation_id': binding.segmentation_id,
'network_id': port['network_id'],
'port_mac': port['mac_address'],
'port_id': port['id'],
'admin_state_up': port['admin_state_up']}
if cfg.CONF.AGENT.rpc_support_old_agents:
entry['vlan_id'] = binding.segmentation_id
new_status = (q_const.PORT_STATUS_ACTIVE if port['admin_state_up']
else q_const.PORT_STATUS_DOWN)
if port['status'] != new_status:
db.set_port_status(port['id'], new_status)
else:
entry = {'device': device}
LOG.debug("%s can not be found in database", device)
return entry
def update_switchports(cls, switchports, session=None):
if not session:
session = db_api.get_session()
with session.begin(subtransactions=True):
hardware_id = cls._validate_hardware_id(switchports)
originals = list(db.filter_switchports(
hardware_id=hardware_id, session=session))
# If the given switchports match what exists in the db,
# we don't have to do anything.
equal = db.compare_switchports(
originals, switchports, session=session)
if equal:
LOG.info(("No switchports update required "
"for hardware_id %s" % (hardware_id)))
return originals
else:
LOG.info(("Updating switchports for "
"hardware_id %s" % (hardware_id)))
# TODO(morgbara) this is a little ham-fisted
cls.delete_switchports(hardware_id, session=session)
return cls.create_switchports(switchports, session=session)
def sync_allocations(self):
# determine current configured allocatable vnis
vxlan_vnis = set()
for tun_min, tun_max in self.tunnel_ranges:
vxlan_vnis |= set(moves.range(tun_min, tun_max + 1))
session = db_api.get_session()
with session.begin(subtransactions=True):
# remove from table unallocated tunnels not currently allocatable
# fetch results as list via all() because we'll be iterating
# through them twice
allocs = session.query(VxlanAllocation).with_lockmode("update").all()
# collect all vnis present in db
existing_vnis = set(alloc.vxlan_vni for alloc in allocs)
# collect those vnis that needs to be deleted from db
vnis_to_remove = [
alloc.vxlan_vni for alloc in allocs if (alloc.vxlan_vni not in vxlan_vnis and not alloc.allocated)
]
# Immediately delete vnis in chunks. This leaves no work for
# flush at the end of transaction
bulk_size = 100
chunked_vnis = (vnis_to_remove[i : i + bulk_size] for i in range(0, len(vnis_to_remove), bulk_size))
for vni_list in chunked_vnis:
if vni_list:
session.query(VxlanAllocation).filter(VxlanAllocation.vxlan_vni.in_(vni_list)).delete(
synchronize_session=False
)
# collect vnis that need to be added
vnis = list(vxlan_vnis - existing_vnis)
chunked_vnis = (vnis[i : i + bulk_size] for i in range(0, len(vnis), bulk_size))
for vni_list in chunked_vnis:
bulk = [{"vxlan_vni": vni, "allocated": False} for vni in vni_list]
session.execute(VxlanAllocation.__table__.insert(), bulk)
def get_network_binding(session, network_id):
session = session or db.get_session()
try:
binding = session.query(ovs_models_v2.NetworkBinding).filter_by(network_id=network_id).one()
return binding
except exc.NoResultFound:
return
def _sync_gre_allocations(self):
"""Synchronize gre_allocations table with configured tunnel ranges."""
# determine current configured allocatable gres
gre_ids = set()
for gre_id_range in self.gre_id_ranges:
tun_min, tun_max = gre_id_range
if tun_max + 1 - tun_min > 1000000:
LOG.error(_("Skipping unreasonable gre ID range "
"%(tun_min)s:%(tun_max)s"),
{'tun_min': tun_min, 'tun_max': tun_max})
else:
gre_ids |= set(xrange(tun_min, tun_max + 1))
session = db_api.get_session()
with session.begin(subtransactions=True):
# remove from table unallocated tunnels not currently allocatable
allocs = (session.query(GreAllocation).all())
for alloc in allocs:
try:
# see if tunnel is allocatable
gre_ids.remove(alloc.gre_id)
except KeyError:
# it's not allocatable, so check if its allocated
if not alloc.allocated:
# it's not, so remove it from table
LOG.debug(_("Removing tunnel %s from pool"),
alloc.gre_id)
session.delete(alloc)
# add missing allocatable tunnels to table
for gre_id in sorted(gre_ids):
alloc = GreAllocation(gre_id=gre_id)
session.add(alloc)
def get_port(port_id):
session = db.get_session()
try:
port = session.query(models_v2.Port).filter_by(id=port_id).one()
except exc.NoResultFound:
port = None
return port
def _get_mock_port_operation_context():
current = {'status': 'DOWN',
'binding:host_id': '',
'allowed_address_pairs': [],
'device_owner': 'fake_owner',
'binding:profile': {},
'fixed_ips': [{
'subnet_id': '72c56c48-e9b8-4dcf-b3a7-0813bb3bd839'}],
'id': '83d56c48-e9b8-4dcf-b3a7-0813bb3bd940',
'security_groups': [SECURITY_GROUP],
'device_id': 'fake_device',
'name': '',
'admin_state_up': True,
'network_id': 'd897e21a-dfd6-4331-a5dd-7524fa421c3e',
'tenant_id': 'test-tenant',
'binding:vif_details': {},
'binding:vnic_type': 'normal',
'binding:vif_type': 'unbound',
'mac_address': '12:34:56:78:21:b6'}
context = mock.Mock(current=current)
context._plugin.get_security_group = mock.Mock(
return_value=SECURITY_GROUP)
context._plugin.get_port = mock.Mock(return_value=current)
context._plugin_context.session = neutron_db_api.get_session()
context._network_context = mock.Mock(
_network=OpenDaylightMechanismDriverTestCase.
_get_mock_network_operation_context().current)
return context
def update_port_ext(port_id, commit=None, hardware_id=None,
trunked=None, session=None):
if not session:
session = db_api.get_session()
updated = False
with session.begin(subtransactions=True):
port = (session.query(models.PortExt).
get(port_id))
if commit is not None:
port.commit = commit
updated = True
if hardware_id is not None:
port.hardware_id = hardware_id
updated = True
if trunked is not None:
port.trunked = trunked
updated = True
if updated:
session.add(port)
session.flush()
return port
def _sync_create_ports(self, combined_res_info, vsm_ip):
"""
Sync ports by creating missing ones on VSM.
:param combined_res_info: tuple containing VSM and neutron information
:param vsm_ip: string representing the IP address of the VSM
"""
(vsm_vmn_dict, neutron_ports) = combined_res_info
vsm_port_uuids = set()
for (k, v) in vsm_vmn_dict.items():
port_dict = v['properties']
port_ids = set(port_dict['portId'].split(','))
vsm_port_uuids = vsm_port_uuids.union(port_ids)
for port in neutron_ports:
if port['id'] not in vsm_port_uuids:
# create these ports on VSM
network_uuid = port['network_id']
binding = n1kv_db.get_policy_binding(port['id'])
policy_profile_id = binding.profile_id
policy_profile = n1kv_db.get_policy_profile_by_uuid(
db.get_session(), policy_profile_id)
vmnetwork_name = "%s%s_%s" % (n1kv_const.VM_NETWORK_PREFIX,
policy_profile_id,
network_uuid)
try:
self.n1kvclient.create_n1kv_port(port, vmnetwork_name,
policy_profile,
vsm_ip=vsm_ip)
except n1kv_exc.VSMError as e:
LOG.warning(_LW('Sync Exception: Port creation on VSM '
'failed: %s'), e.message)
def _verify_get_nsx_switch_and_port_id(self, exp_ls_uuid, exp_lp_uuid):
# The nvplib and db calls are mocked, therefore the cluster
# and the neutron_port_id parameters can be set to None
ls_uuid, lp_uuid = nsx_utils.get_nsx_switch_and_port_id(
db_api.get_session(), None, None)
self.assertEqual(exp_ls_uuid, ls_uuid)
self.assertEqual(exp_lp_uuid, lp_uuid)
def filter_port_ext(session=None, **kwargs):
if not session:
session = db_api.get_session()
with session.begin(subtransactions=True):
return (session.query(models.PortExt).
filter_by(**kwargs))
def add_tunnel_endpoint(ip, max_retries=10):
"""Return the endpoint of the given IP address or generate a new one."""
# NOTE(rpodolyaka): generation of a new tunnel endpoint must be put into a
# repeatedly executed transactional block to ensure it
# doesn't conflict with any other concurrently executed
# DB transactions in spite of the specified transactions
# isolation level value
for i in xrange(max_retries):
LOG.debug(_("Adding a tunnel endpoint for %s"), ip)
try:
session = db.get_session()
with session.begin(subtransactions=True):
tunnel = (
session.query(ovs_models_v2.TunnelEndpoint).filter_by(ip_address=ip).with_lockmode("update").first()
)
if tunnel is None:
tunnel_id = _generate_tunnel_id(session)
tunnel = ovs_models_v2.TunnelEndpoint(ip, tunnel_id)
session.add(tunnel)
return tunnel
except db_exc.DBDuplicateEntry:
# a concurrent transaction has been commited, try again
LOG.debug(
_(
"Adding a tunnel endpoint failed due to a concurrent"
"transaction had been commited (%s attempts left)"
),
max_retries - (i + 1),
)
raise q_exc.NeutronException(message="Unable to generate a new tunnel id")
def sync_tunnel_allocations(tunnel_id_ranges):
"""Synchronize tunnel_allocations table with configured tunnel ranges."""
# determine current configured allocatable tunnels
tunnel_ids = set()
for tunnel_id_range in tunnel_id_ranges:
tun_min, tun_max = tunnel_id_range
if tun_max + 1 - tun_min > 1000000:
LOG.error(
_("Skipping unreasonable tunnel ID range " "%(tun_min)s:%(tun_max)s"),
{"tun_min": tun_min, "tun_max": tun_max},
)
else:
tunnel_ids |= set(xrange(tun_min, tun_max + 1))
session = db.get_session()
with session.begin():
# remove from table unallocated tunnels not currently allocatable
allocs = session.query(ovs_models_v2.TunnelAllocation).all()
for alloc in allocs:
try:
# see if tunnel is allocatable
tunnel_ids.remove(alloc.tunnel_id)
except KeyError:
# it's not allocatable, so check if its allocated
if not alloc.allocated:
# it's not, so remove it from table
LOG.debug(_("Removing tunnel %s from pool"), alloc.tunnel_id)
session.delete(alloc)
# add missing allocatable tunnels to table
for tunnel_id in sorted(tunnel_ids):
alloc = ovs_models_v2.TunnelAllocation(tunnel_id)
session.add(alloc)
def test_populate_policy_profile_delete(self):
# Patch the Client class with the TestClient class
with mock.patch(n1kv_client.__name__ + ".Client",
new=fake_client.TestClient):
# Patch the _get_total_profiles() method to return a custom value
with mock.patch(fake_client.__name__ +
'.TestClient._get_total_profiles') as obj_inst:
# Return 3 policy profiles
obj_inst.return_value = 3
plugin = manager.NeutronManager.get_plugin()
plugin._populate_policy_profiles()
db_session = db.get_session()
profile = n1kv_db_v2.get_policy_profile(
db_session, '00000000-0000-0000-0000-000000000001')
# Verify that DB contains only 3 policy profiles
self.assertEqual('pp-1', profile['name'])
profile = n1kv_db_v2.get_policy_profile(
db_session, '00000000-0000-0000-0000-000000000002')
self.assertEqual('pp-2', profile['name'])
profile = n1kv_db_v2.get_policy_profile(
db_session, '00000000-0000-0000-0000-000000000003')
self.assertEqual('pp-3', profile['name'])
self.assertRaises(c_exc.PolicyProfileIdNotFound,
n1kv_db_v2.get_policy_profile,
db_session,
'00000000-0000-0000-0000-000000000004')
# Return 2 policy profiles
obj_inst.return_value = 2
plugin._populate_policy_profiles()
# Verify that the third policy profile is deleted
self.assertRaises(c_exc.PolicyProfileIdNotFound,
n1kv_db_v2.get_policy_profile,
db_session,
'00000000-0000-0000-0000-000000000003')
def setUp(self):
super(CiscoNexusDbTest, self).setUp()
db.configure_db()
self.session = db.get_session()
self.addCleanup(db.clear_db)
def setUp(self):
super(DbTestCase, self).setUp()
self.db_session = neutron_db_api.get_session()
self.addCleanup(self._db_cleanup)
def delete_all_n1kv_credentials():
session = db.get_session()
session.query(network_models_v2.Credential).filter_by(type='n1kv').delete()
def all_list(self):
session = db.get_session()
return session.query(ryu_models_v2.TunnelKey).all()
def _verify_get_nsx_router_id(self, exp_lr_uuid):
# The nvplib and db calls are mocked, therefore the cluster
# and the neutron_router_id parameters can be set to None
lr_uuid = nsx_utils.get_nsx_router_id(db_api.get_session(), None, None)
self.assertEqual(exp_lr_uuid, lr_uuid)
def get_all_qoss(tenant_id):
"""Lists all the qos to tenant associations."""
LOG.debug(_("get_all_qoss() called"))
session = db.get_session()
return (session.query(network_models_v2.QoS).
filter_by(tenant_id=tenant_id).all())
def get_ovs_vlans():
session = db.get_session()
bindings = (session.query(ovs_models_v2.VlanAllocation.vlan_id).
filter_by(allocated=True))
return [binding.vlan_id for binding in bindings]
def is_provider_network(network_id):
"""Return True if network_id is in the provider network table."""
session = db.get_session()
if session.query(network_models_v2.ProviderNetwork).filter_by(
network_id=network_id).first():
return True
def get_all_credentials():
"""Lists all the creds for a tenant."""
session = db.get_session()
return (session.query(network_models_v2.Credential).all())
def get_all_n1kv_credentials():
session = db.get_session()
return (session.query(network_models_v2.Credential).
filter_by(type='n1kv'))
def _update_port_up(self, context):
port = context.current
agent_host = context.host
port_infos = self._get_port_infos(context, port, agent_host)
if not port_infos:
return
agent, agent_host, agent_ip, segment, port_fdb_entries = port_infos
network_id = port['network_id']
session = db_api.get_session()
agent_active_ports = self.get_agent_network_active_port_count(
session, agent_host, network_id)
other_fdb_entries = {
network_id: {
'segment_id': segment['segmentation_id'],
'network_type': segment['network_type'],
'ports': {
agent_ip: []
}
}
}
if agent_active_ports == 1 or (self.get_agent_uptime(agent) <
cfg.CONF.l2pop.agent_boot_time):
# First port activated on current agent in this network,
# we have to provide it with the whole list of fdb entries
agent_fdb_entries = {
network_id: {
'segment_id': segment['segmentation_id'],
'network_type': segment['network_type'],
'ports': {}
}
}
ports = agent_fdb_entries[network_id]['ports']
nondvr_network_ports = self.get_nondvr_network_ports(
session, network_id)
for network_port in nondvr_network_ports:
binding, agent = network_port
if agent.host == agent_host:
continue
ip = self.get_agent_ip(agent)
if not ip:
LOG.debug(
_("Unable to retrieve the agent ip, check "
"the agent %(agent_host)s configuration."),
{'agent_host': agent.host})
continue
agent_ports = ports.get(ip, [const.FLOODING_ENTRY])
agent_ports += self._get_port_fdb_entries(binding.port)
ports[ip] = agent_ports
if cfg.CONF.l2pop.cascaded_gateway == 'no_gateway':
remote_ports = self.get_remote_ports(session, network_id)
else:
remote_ports = {}
for binding in remote_ports:
profile = binding['profile']
ip = self.get_host_ip_from_binding_profile_str(profile)
if not ip:
LOG.debug(
_("Unable to retrieve the agent ip, check "
"the agent %(agent_host)s configuration."),
{'agent_host': agent.host})
continue
agent_ports = ports.get(ip, [const.FLOODING_ENTRY])
agent_ports += self._get_port_fdb_entries(binding.port)
ports[ip] = agent_ports
dvr_network_ports = self.get_dvr_network_ports(session, network_id)
for network_port in dvr_network_ports:
binding, agent = network_port
if agent.host == agent_host:
continue
ip = self.get_agent_ip(agent)
if not ip:
LOG.debug(
"Unable to retrieve the agent ip, check "
"the agent %(agent_host)s configuration.",
{'agent_host': agent.host})
continue
agent_ports = ports.get(ip, [const.FLOODING_ENTRY])
ports[ip] = agent_ports
# And notify other agents to add flooding entry
other_fdb_entries[network_id]['ports'][agent_ip].append(
const.FLOODING_ENTRY)
if ports.keys():
self.L2populationAgentNotify.add_fdb_entries(
self.rpc_ctx, agent_fdb_entries, agent_host)
# Notify other agents to add fdb rule for current port
if port['device_owner'] != const.DEVICE_OWNER_DVR_INTERFACE:
other_fdb_entries[network_id]['ports'][agent_ip] += (
port_fdb_entries)
self.L2populationAgentNotify.add_fdb_entries(self.rpc_ctx,
other_fdb_entries)
def get_port_from_device_mac(device_mac):
"""Get port from database."""
LOG.debug(_("Get_port_from_device_mac() called"))
session = db.get_session()
qry = session.query(models_v2.Port).filter_by(mac_address=device_mac)
return qry.first()
def test__add_allocation_existing_allocated_is_kept(self):
session = db_api.get_session()
_add_allocation(session, gre_id=1, allocated=True)
self.driver._add_allocation(session, {2})
_get_allocation(session, 1)
def test__add_allocation_existing_not_allocated_is_removed(self):
session = db_api.get_session()
_add_allocation(session, gre_id=1)
self.driver._add_allocation(session, {2})
with testtools.ExpectedException(sa_exc.NoResultFound):
_get_allocation(session, 1)
def _update_port_up(self, context):
port_context = context.current
port_infos = self._get_port_infos(context, port_context)
if not port_infos:
return
agent, agent_ip, segment, port_fdb_entries = port_infos
agent_host = port_context['binding:host_id']
network_id = port_context['network_id']
session = db_api.get_session()
agent_active_ports = self.get_agent_network_active_port_count(
session, agent_host, network_id)
other_fdb_entries = {
network_id: {
'segment_id': segment['segmentation_id'],
'network_type': segment['network_type'],
'ports': {
agent_ip: []
}
}
}
if agent_active_ports == 1 or (self.get_agent_uptime(agent) <
cfg.CONF.l2pop.agent_boot_time):
# First port activated on current agent in this network,
# we have to provide it with the whole list of fdb entries
agent_fdb_entries = {
network_id: {
'segment_id': segment['segmentation_id'],
'network_type': segment['network_type'],
'ports': {}
}
}
ports = agent_fdb_entries[network_id]['ports']
network_ports = self.get_network_ports(session, network_id)
for network_port in network_ports:
binding, agent = network_port
if agent.host == agent_host:
continue
ip = self.get_agent_ip(agent)
if not ip:
LOG.debug(
_("Unable to retrieve the agent ip, check "
"the agent %(agent_host)s configuration."),
{'agent_host': agent.host})
continue
agent_ports = ports.get(ip, [const.FLOODING_ENTRY])
agent_ports += self._get_port_fdb_entries(binding.port)
ports[ip] = agent_ports
# And notify other agents to add flooding entry
other_fdb_entries[network_id]['ports'][agent_ip].append(
const.FLOODING_ENTRY)
if ports.keys():
l2pop_rpc.L2populationAgentNotify.add_fdb_entries(
self.rpc_ctx, agent_fdb_entries, agent_host)
# Notify other agents to add fdb rule for current port
other_fdb_entries[network_id]['ports'][agent_ip] += port_fdb_entries
l2pop_rpc.L2populationAgentNotify.add_fdb_entries(
self.rpc_ctx, other_fdb_entries)
def test__add_allocation_not_existing(self):
session = db_api.get_session()
_add_allocation(session, gre_id=1)
self.driver._add_allocation(session, {1, 2})
_get_allocation(session, 2)
def get_device_details(self, rpc_context, **kwargs):
"""Agent requests device details."""
agent_id = kwargs.get('agent_id')
device = kwargs.get('device')
LOG.debug(
_("Device %(device)s details requested by agent "
"%(agent_id)s"), {
'device': device,
'agent_id': agent_id
})
port_id = self._device_to_port_id(device)
session = db_api.get_session()
with session.begin(subtransactions=True):
port = db.get_port(session, port_id)
if not port:
LOG.warning(
_("Device %(device)s requested by agent "
"%(agent_id)s not found in database"), {
'device': device,
'agent_id': agent_id
})
return {'device': device}
segments = db.get_network_segments(session, port.network_id)
if not segments:
LOG.warning(
_("Device %(device)s requested by agent "
"%(agent_id)s has network %(network_id)s with "
"no segments"), {
'device': device,
'agent_id': agent_id,
'network_id': port.network_id
})
return {'device': device}
binding = db.ensure_port_binding(session, port.id)
if not binding.segment:
LOG.warning(
_("Device %(device)s requested by agent "
"%(agent_id)s on network %(network_id)s not "
"bound, vif_type: %(vif_type)s"), {
'device': device,
'agent_id': agent_id,
'network_id': port.network_id,
'vif_type': binding.vif_type
})
return {'device': device}
segment = self._find_segment(segments, binding.segment)
if not segment:
LOG.warning(
_("Device %(device)s requested by agent "
"%(agent_id)s on network %(network_id)s "
"invalid segment, vif_type: %(vif_type)s"), {
'device': device,
'agent_id': agent_id,
'network_id': port.network_id,
'vif_type': binding.vif_type
})
return {'device': device}
new_status = (q_const.PORT_STATUS_BUILD
if port.admin_state_up else q_const.PORT_STATUS_DOWN)
if port.status != new_status:
port.status = new_status
entry = {
'device': device,
'network_id': port.network_id,
'port_id': port.id,
'admin_state_up': port.admin_state_up,
'network_type': segment[api.NETWORK_TYPE],
'segmentation_id': segment[api.SEGMENTATION_ID],
'physical_network': segment[api.PHYSICAL_NETWORK]
}
LOG.debug(_("Returning: %s"), entry)
return entry
def setUp(self):
super(TestL3GwModeMixin, self).setUp()
plugin = __name__ + '.' + TestDbIntPlugin.__name__
self.setup_coreplugin(plugin)
self.target_object = TestDbIntPlugin()
# Patch the context
ctx_patcher = mock.patch('neutron.context', autospec=True)
mock_context = ctx_patcher.start()
self.context = mock_context.get_admin_context()
# This ensure also calls to elevated work in unit tests
self.context.elevated.return_value = self.context
self.context.session = db_api.get_session()
# Create sample data for tests
self.ext_net_id = _uuid()
self.int_net_id = _uuid()
self.int_sub_id = _uuid()
self.tenant_id = 'the_tenant'
self.network = models_v2.Network(
id=self.ext_net_id,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.net_ext = external_net_db.ExternalNetwork(
network_id=self.ext_net_id)
self.context.session.add(self.network)
# The following is to avoid complaints from SQLite on
# foreign key violations
self.context.session.flush()
self.context.session.add(self.net_ext)
self.router = l3_db.Router(
id=_uuid(),
name=None,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE,
enable_snat=True,
gw_port_id=None)
self.context.session.add(self.router)
self.context.session.flush()
self.router_gw_port = models_v2.Port(
id=FAKE_GW_PORT_ID,
tenant_id=self.tenant_id,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_GW,
admin_state_up=True,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_GW_PORT_MAC,
network_id=self.ext_net_id)
self.router.gw_port_id = self.router_gw_port.id
self.context.session.add(self.router)
self.context.session.add(self.router_gw_port)
self.context.session.flush()
self.fip_ext_port = models_v2.Port(
id=FAKE_FIP_EXT_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_FLOATINGIP,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_FIP_EXT_PORT_MAC,
network_id=self.ext_net_id)
self.context.session.add(self.fip_ext_port)
self.context.session.flush()
self.int_net = models_v2.Network(
id=self.int_net_id,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.int_sub = models_v2.Subnet(
id=self.int_sub_id,
tenant_id=self.tenant_id,
ip_version=4,
cidr='3.3.3.0/24',
gateway_ip='3.3.3.1',
network_id=self.int_net_id)
self.router_port = models_v2.Port(
id=FAKE_ROUTER_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_INTF,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_ROUTER_PORT_MAC,
network_id=self.int_net_id)
self.router_port_ip_info = models_v2.IPAllocation(
port_id=self.router_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.1')
self.context.session.add(self.int_net)
self.context.session.add(self.int_sub)
self.context.session.add(self.router_port)
self.context.session.add(self.router_port_ip_info)
self.context.session.flush()
self.fip_int_port = models_v2.Port(
id=FAKE_FIP_INT_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id='something',
device_owner=constants.DEVICE_OWNER_COMPUTE_PREFIX + 'nova',
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_FIP_INT_PORT_MAC,
network_id=self.int_net_id)
self.fip_int_ip_info = models_v2.IPAllocation(
port_id=self.fip_int_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.3')
self.fip = l3_db.FloatingIP(
id=_uuid(),
floating_ip_address='1.1.1.2',
floating_network_id=self.ext_net_id,
floating_port_id=FAKE_FIP_EXT_PORT_ID,
fixed_port_id=None,
fixed_ip_address=None,
router_id=None)
self.context.session.add(self.fip_int_port)
self.context.session.add(self.fip_int_ip_info)
self.context.session.add(self.fip)
self.context.session.flush()
self.fip_request = {'port_id': FAKE_FIP_INT_PORT_ID,
'tenant_id': self.tenant_id}
def setUp(self):
cfg.CONF.set_override('network_vlan_ranges', ['physnet1:1000:2999'],
group='OVS')
super(NetworkBindingsTest, self).setUp(plugin=PLUGIN_NAME)
db.configure_db()
self.session = db.get_session()
def setUp(self):
super(VlanAllocationsTest, self).setUp()
db.configure_db()
ovs_db_v2.sync_vlan_allocations(VLAN_RANGES)
self.session = db.get_session()
self.addCleanup(db.clear_db)
def setUp(self):
super(DnsSearchDomainDBTestCase, self).setUp()
self.session = db.get_session()
def setUp(self):
super(TunnelAllocationsTest, self).setUp()
db.configure_db()
ovs_db_v2.sync_tunnel_allocations(TUNNEL_RANGES)
self.session = db.get_session()
self.addCleanup(db.clear_db)
def setUp(self):
super(ProfileBindingsTest, self).setUp()
self.session = db.get_session()
def get_port_from_device_mac(device_mac):
LOG.debug("get_port_from_device_mac() called for mac %s", device_mac)
session = db_api.get_session()
qry = session.query(models_v2.Port).filter_by(mac_address=device_mac)
return qry.first()
def setUp(self):
super(NetworkBindingsTest, self).setUp()
self.session = db.get_session()
def setUp(self):
super(PolicyProfileTests, self).setUp()
self.session = db.get_session()
def network_all_tenant_list():
session = db.get_session()
return session.query(models_v2.Network).all()
def setUp(self):
super(NetworkProfileTests, self).setUp()
self.session = db.get_session()
def setUp(self):
super(TunnelTypeMultiRangeTestMixin, self).setUp()
self.driver = self.DRIVER_CLASS()
self.driver.tunnel_ranges = self.TUNNEL_MULTI_RANGES
self.driver.sync_allocations()
self.session = db.get_session()
def _forward_worker(self, thread_id):
LOG.debug('forward worker begun')
session = neutron_db_api.get_session()
etcd_election = EtcdElection(self.etcd_client, 'forward_worker',
self.election_key_space, thread_id,
wait_until_elected=True,
recovery_time=3)
while True:
try:
etcd_election.wait_until_elected()
def work(k, v):
LOG.debug('forward worker updating etcd key %s', k)
if self.do_etcd_update(k, v):
return True
else:
# something went bad; breathe, in case we end
# up in a tight loop
time.sleep(1)
return False
LOG.debug('forward worker reading journal')
# TODO(najoy): Limit the journal read entries processed
# by a worker thread to a finite number, say 50.
# This will ensure that one thread does not run forever.
# The re-election process will wake up one of the sleeping
# threads after the specified recovery_time of 3 seconds
# and will get a chance to split the available work
while db.journal_read(session, work):
pass
LOG.debug('forward worker has emptied journal')
# work queue is now empty.
LOG.debug("ML2_VPP(%s): worker thread pausing"
% self.__class__.__name__)
# Wait to be kicked, or (in case of emergency) run every
# few seconds in case another thread or process dumped
# work and failed to process it
try:
with eventlet.Timeout(PARANOIA_TIME):
# Wait for kick
dummy = self.db_q_ev.wait()
# Clear the event - we will now process till
# we've run out of things in the backlog
# so any trigger lost in this gap is harmless
self.db_q_ev.reset()
LOG.debug("ML2_VPP(%s): worker thread kicked: %s"
% (self.__class__.__name__, str(dummy)))
except eventlet.Timeout:
LOG.debug("ML2_VPP(%s): worker thread suspicious of "
"a long pause"
% self.__class__.__name__)
pass
LOG.debug("ML2_VPP(%s): worker thread active"
% self.__class__.__name__)
except Exception as e:
# TODO(ijw): log exception properly
LOG.error("problems in forward worker: %s", e)
LOG.error(traceback.format_exc())
# never quit
pass
