def get_nsxv_spoofguard_policy_network_mappings(session, filters=None,
like_filters=None):
session = db_api.get_reader_session()
query = session.query(nsxv_models.NsxvSpoofGuardPolicyNetworkMapping)
return nsx_db._apply_filters_to_query(
query, nsxv_models.NsxvSpoofGuardPolicyNetworkMapping,
filters, like_filters).all()
def get_nsxv_lbaas_loadbalancer_bindings(session, filters=None,
like_filters=None):
session = db_api.get_reader_session()
query = session.query(nsxv_models.NsxvLbaasLoadbalancerBinding)
return nsx_db._apply_filters_to_query(
query, nsxv_models.NsxvLbaasLoadbalancerBinding, filters,
like_filters).all()
def _verify_get_nsx_switch_and_port_id(self, exp_ls_uuid, exp_lp_uuid):
# The nsxlib 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_reader_session(), None, None)
self.assertEqual(exp_ls_uuid, ls_uuid)
self.assertEqual(exp_lp_uuid, lp_uuid)
def get_subnet_description(subnet, network_name=None):
if subnet['nuage_l2bridge']:
session = lib_db_api.get_reader_session()
return nuagedb.get_nuage_l2bridge(session,
subnet['nuage_l2bridge'])['name']
else:
return network_name or subnet['name']
def get_network_bindings_by_physical_net_and_type(session, phy_uuid,
binding_type):
session = session or db_api.get_reader_session()
return (session.query(nsxv_models.NsxvTzNetworkBinding).
filter_by(phy_uuid=phy_uuid,
binding_type=binding_type).
all())
def __init__(self, neutron_db):
self._ndb = neutron_db
self._validate_config()
self._server_ip = None
self.region = cfg.CONF.ml2_arista.region_name
self.sync_interval = cfg.CONF.ml2_arista.sync_interval
self.conn_timeout = cfg.CONF.ml2_arista.conn_timeout
self.eapi_hosts = cfg.CONF.ml2_arista.eapi_host.split(',')
self.security_group_driver = arista_sec_gp.AristaSecGroupSwitchDriver(
self._ndb)
# We denote mlag_pair physnets as peer1_peer2 in the physnet name, the
# following builds a mapping of peer name to physnet name for use
# during port binding
self.mlag_pairs = {}
session = db_api.get_reader_session()
with session.begin():
physnets = session.query(vlanallocation.VlanAllocation.
physical_network).distinct().all()
for (physnet, ) in physnets:
if '_' in physnet:
peers = physnet.split('_')
self.mlag_pairs[peers[0]] = physnet
self.mlag_pairs[peers[1]] = physnet
# Indication of CVX availabililty in the driver.
self._cvx_available = True
# Reference to SyncService object which is set in AristaDriver
self.sync_service = None
def _update_network_vlan_ranges(self):
session = db_api.get_reader_session()
va = vlanallocation.VlanAllocation
with session.begin(subtransactions=True):
vlans = session.query(va).filter(va.physical_network == 'default')
self.network_vlan_ranges = {
'default': set((vlan.vlan_id, vlan.vlan_id)
for vlan in vlans.all())}
def _get_node_row(self, node_uuid):
try:
session = db_api.get_reader_session()
with session.begin():
return session.query(models.OVNHashRing).filter_by(
node_uuid=node_uuid).one()
except exc.NoResultFound:
pass
def get_nsxv_lbaas_loadbalancer_bindings(session,
filters=None,
like_filters=None):
session = db_api.get_reader_session()
query = session.query(nsxv_models.NsxvLbaasLoadbalancerBinding)
return nsx_db._apply_filters_to_query(
query, nsxv_models.NsxvLbaasLoadbalancerBinding, filters,
like_filters).all()
def get_nsxv_spoofguard_policy_network_mappings(session,
filters=None,
like_filters=None):
session = db_api.get_reader_session()
query = session.query(nsxv_models.NsxvSpoofGuardPolicyNetworkMapping)
return nsx_db._apply_filters_to_query(
query, nsxv_models.NsxvSpoofGuardPolicyNetworkMapping, filters,
like_filters).all()
def get_port_binding_level(filters):
"""Returns entries from PortBindingLevel based on the specified filters."""
session = db.get_reader_session()
with session.begin():
return (session.query(ml2_models.PortBindingLevel).
filter_by(**filters).
order_by(ml2_models.PortBindingLevel.level).
all())
def port_provisioned(port_id):
"""Returns true if port still exists."""
session = db.get_reader_session()
with session.begin():
port_model = models_v2.Port
res = bool(session.query(port_model)
.filter(port_model.id == port_id).count())
return res
def instance_provisioned(device_id):
"""Returns true if any ports exist for an instance."""
session = db.get_reader_session()
with session.begin():
port_model = models_v2.Port
res = bool(session.query(port_model)
.filter(port_model.device_id == device_id).count())
return res
def segment_bound(segment_id):
session = db.get_reader_session()
with session.begin():
binding_level_model = ml2_models.PortBindingLevel
res = bool(session
.query(binding_level_model)
.filter_by(segment_id=segment_id).count())
return res
def get_revision_row(resource_uuid):
try:
session = db_api.get_reader_session()
with session.begin():
return session.query(models.OVNRevisionNumbers).filter_by(
resource_uuid=resource_uuid).one()
except exc.NoResultFound:
pass
def get_security_groups():
session = db.get_reader_session()
with session.begin():
sg_model = sg_models.SecurityGroup
# We do an immediate load to prevent the need for the sync worker
# to issue subqueries
security_groups = (session.query(sg_model)
.options(immediateload(sg_model.rules)))
return security_groups
def tenant_provisioned(tenant_id):
"""Returns true if any networks or ports exist for a tenant."""
session = db.get_reader_session()
with session.begin():
res = any(
session.query(m).filter(m.tenant_id == tenant_id).count()
for m in [models_v2.Network, models_v2.Port]
)
return res
def segment_is_dynamic(segment_id):
session = db.get_reader_session()
with session.begin():
segment_model = segment_models.NetworkSegment
res = bool(session
.query(segment_model)
.filter_by(id=segment_id)
.filter_by(is_dynamic=True).count())
return res
def get_segments(segment_id=None):
"""Returns list of all network segments that may be relevant on CVX"""
session = db.get_reader_session()
with session.begin():
model = segment_models.NetworkSegment
segments = session.query(model).filter_unnecessary_segments()
if segment_id:
segments = segments.filter(model.id == segment_id)
return segments.all()
def get_active_nodes(interval, from_host=False):
session = db_api.get_reader_session()
limit = timeutils.utcnow() - datetime.timedelta(seconds=interval)
with session.begin():
query = session.query(models.OVNHashRing).filter(
models.OVNHashRing.updated_at >= limit)
if from_host:
query = query.filter_by(hostname=CONF.host)
return query.all()
def get_networks(network_id=None):
"""Returns list of all networks that may be relevant on CVX"""
session = db.get_reader_session()
with session.begin():
model = models_v2.Network
networks = session.query(model).filter(model.project_id != '')
if network_id:
networks = networks.filter(model.id == network_id)
return networks.all()
def _verify_get_nsx_switch_ids(self, exp_ls_uuids):
# The nsxlib and db calls are mocked, therefore the cluster
# and the neutron_router_id parameters can be set to None
ls_uuids = nsx_utils.get_nsx_switch_ids(db_api.get_reader_session(),
None, None)
for ls_uuid in ls_uuids or []:
self.assertIn(ls_uuid, exp_ls_uuids)
exp_ls_uuids.remove(ls_uuid)
self.assertFalse(exp_ls_uuids)
def _ensure_in_db(self, assigned, allocated, available):
session = db_api.get_reader_session()
with session.begin():
vlans = session.query(vlanallocation.VlanAllocation).all()
for vlan in vlans:
self.assertIn(vlan.vlan_id, assigned)
if vlan.vlan_id in available:
self.assertFalse(vlan.allocated)
elif vlan.vlan_id in allocated:
self.assertTrue(vlan.allocated)
def get_ports(device_owners=None, vnic_type=None, port_id=None, active=True):
"""Returns list of all ports in neutron the db"""
session = db.get_reader_session()
with session.begin():
port_model = models_v2.Port
ports = (session
.query(port_model)
.filter_unnecessary_ports(device_owners, vnic_type, active))
if port_id:
ports = ports.filter(port_model.id == port_id)
return ports.all()
def __init__(self,
network,
segments=None,
original_network=None,
session=None):
self._network = network
self._original_network = original_network
self._segments = segments
self.is_admin = False
self.is_advsvc = False
self.tenant_id = network['tenant_id']
self.session = session or db_api.get_reader_session()
def get_tenants(tenant_id=None):
"""Returns list of all project/tenant ids that may be relevant on CVX"""
if tenant_id == '':
return []
session = db.get_reader_session()
project_ids = set()
with session.begin():
for m in [models_v2.Network, models_v2.Port]:
q = session.query(m.project_id).filter(m.project_id != '')
if tenant_id:
q = q.filter(m.project_id == tenant_id)
project_ids.update(pid[0] for pid in q.distinct())
return [{'project_id': project_id} for project_id in project_ids]
def get_mlag_physnets():
mlag_pairs = dict()
session = db.get_reader_session()
with session.begin():
physnets = session.query(
vlanallocation.VlanAllocation.physical_network
).distinct().all()
for (physnet,) in physnets:
if '_' in physnet:
peers = physnet.split('_')
mlag_pairs[peers[0]] = physnet
mlag_pairs[peers[1]] = physnet
return mlag_pairs
def get_inconsistent_resources():
"""Get a list of inconsistent resources.
:returns: A list of objects which the revision number from the
ovn_revision_number and standardattributes tables differs.
"""
session = db_api.get_reader_session()
with session.begin():
return (session.query(models.OVNRevisionNumbers).join(
standard_attr.StandardAttribute,
models.OVNRevisionNumbers.standard_attr_id ==
standard_attr.StandardAttribute.id).filter(
models.OVNRevisionNumbers.revision_number !=
standard_attr.StandardAttribute.revision_number).all())
def get_baremetal_sg_bindings():
session = db.get_reader_session()
with session.begin():
sg_binding_model = sg_models.SecurityGroupPortBinding
binding_model = ml2_models.PortBinding
sg_bindings = (session
.query(sg_binding_model,
binding_model)
.outerjoin(
binding_model,
sg_binding_model.port_id == binding_model.port_id)
.filter_unnecessary_ports(
vnic_type=portbindings.VNIC_BAREMETAL)
.group_by(sg_binding_model.port_id)
.having(func.count(sg_binding_model.port_id) == 1))
return sg_bindings
def get_inconsistent_resources():
"""Get a list of inconsistent resources.
:returns: A list of objects which the revision number from the
ovn_revision_number and standardattributes tables differs.
"""
sort_order = sa.case(value=models.OVNRevisionNumbers.resource_type,
whens=ovn_const.MAINTENANCE_CREATE_UPDATE_TYPE_ORDER)
session = db_api.get_reader_session()
with session.begin():
return (session.query(models.OVNRevisionNumbers).join(
standard_attr.StandardAttribute,
models.OVNRevisionNumbers.standard_attr_id ==
standard_attr.StandardAttribute.id).filter(
models.OVNRevisionNumbers.revision_number != standard_attr.
StandardAttribute.revision_number).order_by(sort_order).all())
def get_deleted_resources():
"""Get a list of resources that failed to be deleted in OVN.
Get a list of resources that have been deleted from neutron but not
in OVN. Once a resource is deleted in Neutron the ``standard_attr_id``
foreign key in the ovn_revision_numbers table will be set to NULL.
Upon successfully deleting the resource in OVN the entry in the
ovn_revision_number should also be deleted but if something fails
the entry will be kept and returned in this list so the maintenance
thread can later fix it.
"""
session = db_api.get_reader_session()
with session.begin():
return session.query(
models.OVNRevisionNumbers).filter_by(standard_attr_id=None).all()
def get_parent(port_id):
"""Get trunk subport's parent port"""
session = db.get_reader_session()
res = dict()
with session.begin():
subport_model = trunk_models.SubPort
trunk_model = trunk_models.Trunk
subport = (session.query(subport_model).
filter(subport_model.port_id == port_id).first())
if subport:
trunk = (session.query(trunk_model).
filter(trunk_model.id == subport.trunk_id).first())
if trunk:
trunk_port_id = trunk.port.id
res = get_ports(port_id=trunk_port_id, active=False)[0]
return res
def get_instances(device_owners=None, vnic_type=None, instance_id=None):
"""Returns filtered list of all instances in the neutron db"""
session = db.get_reader_session()
with session.begin():
port_model = models_v2.Port
binding_model = ml2_models.PortBinding
instances = (session
.query(port_model,
binding_model)
.outerjoin(
binding_model,
port_model.id == binding_model.port_id)
.distinct(port_model.device_id)
.group_by(port_model.device_id)
.filter_unnecessary_ports(device_owners, vnic_type))
if instance_id:
instances = instances.filter(port_model.device_id == instance_id)
return instances.all()
def __init__(self,
port,
original_port,
network,
status,
binding_levels,
session=None):
self._plugin_context = None
self._port = port
self._original_port = original_port
self._network_context = network
self._status = status
self._binding_levels = binding_levels
self.is_admin = False
self.is_advsvc = False
self.tenant_id = port['tenant_id']
self.project_id = port['tenant_id']
self.session = session or db_api.get_reader_session()
def get_inconsistent_resources():
"""Get a list of inconsistent resources.
:returns: A list of objects which the revision number from the
ovn_revision_number and standardattributes tables differs.
"""
sort_order = sa.case(value=models.OVNRevisionNumbers.resource_type,
whens=ovn_const.MAINTENANCE_CREATE_UPDATE_TYPE_ORDER)
session = db_api.get_reader_session()
time_ = (timeutils.utcnow() -
datetime.timedelta(seconds=INCONSISTENCIES_OLDER_THAN))
with session.begin():
query = session.query(models.OVNRevisionNumbers).join(
standard_attr.StandardAttribute,
models.OVNRevisionNumbers.standard_attr_id ==
standard_attr.StandardAttribute.id)
# Filter out new entries
query = query.filter(
standard_attr.StandardAttribute.created_at < time_)
# Filter for resources which revision_number differs
query = query.filter(models.OVNRevisionNumbers.revision_number !=
standard_attr.StandardAttribute.revision_number)
return query.order_by(sort_order).all()
def get_network_bindings_by_vlanid(session, vlan_id):
session = session or db_api.get_reader_session()
return (session.query(
nsxv_models.NsxvTzNetworkBinding).filter_by(vlan_id=vlan_id).all())
def get_network_bindings_by_phy_uuid(session, phy_uuid):
session = session or db_api.get_reader_session()
return (session.query(
nsx_models.TzNetworkBinding).filter_by(phy_uuid=phy_uuid).all())
def get_endpoint_by_ip(self, ip):
LOG.debug("get_endpoint_by_ip() called for ip %s", ip)
session = db_api.get_reader_session()
return (session.query(self.endpoint_model).
filter_by(ip_address=ip).first())
def get_sg_stateful_value(sg_id):
session = lib_db_api.get_reader_session()
value = nuagedb.get_nuage_sg_parameter(session, sg_id, 'STATEFUL')
session.close()
return not (value and value.parameter_value == '0')
def get_endpoint_by_ip(self, ip):
LOG.debug("get_endpoint_by_ip() called for ip %s", ip)
session = db_api.get_reader_session()
return (session.query(
self.endpoint_model).filter_by(ip_address=ip).first())
def _verify_get_nsx_sec_profile_id(self, exp_sec_prof_uuid):
# The nsxlib and db calls are mocked, therefore the cluster
# and the neutron_id parameters can be set to None
sec_prof_uuid = nsx_utils.get_nsx_security_group_id(
db_api.get_reader_session(), None, None)
self.assertEqual(exp_sec_prof_uuid, sec_prof_uuid)
def get_endpoint_by_host(self, host):
LOG.debug("get_endpoint_by_host() called for host %s", host)
session = db_api.get_reader_session()
return (session.query(
self.endpoint_model).filter_by(host=host).first())
def get_port_bindings(binding_key=None):
"""Returns filtered list of port bindings that may be relevant on CVX
This query is a little complex as we need all binding levels for any
binding that has a single managed physnet, but we need to filter bindings
that have no managed physnets. In order to achieve this, we join to the
binding_level_model once to filter bindings with no managed levels,
then a second time to get all levels for the remaining bindings.
The loop at the end is a convenience to associate levels with bindings
as a list. This would ideally be done through the use of an orm.relation,
but due to some sqlalchemy limitations imposed to make OVO work, we can't
add relations to existing models.
"""
session = db.get_reader_session()
with session.begin():
binding_level_model = ml2_models.PortBindingLevel
aliased_blm = aliased(ml2_models.PortBindingLevel)
port_binding_model = ml2_models.PortBinding
dist_binding_model = ml2_models.DistributedPortBinding
bindings = (session.query(port_binding_model, aliased_blm)
.join(binding_level_model,
and_(
port_binding_model.port_id ==
binding_level_model.port_id,
port_binding_model.host ==
binding_level_model.host))
.filter_unnecessary_ports()
.join(aliased_blm,
and_(port_binding_model.port_id ==
aliased_blm.port_id,
port_binding_model.host ==
aliased_blm.host)))
dist_bindings = (session.query(dist_binding_model, aliased_blm)
.join(
binding_level_model,
and_(dist_binding_model.port_id ==
binding_level_model.port_id,
dist_binding_model.host ==
binding_level_model.host))
.filter_unnecessary_ports()
.filter(dist_binding_model.status ==
n_const.PORT_STATUS_ACTIVE)
.join(aliased_blm,
and_(dist_binding_model.port_id ==
aliased_blm.port_id,
dist_binding_model.host ==
aliased_blm.host)))
if binding_key:
port_id = binding_key[0]
if type(binding_key[1]) == tuple:
switch_id = binding_key[1][0]
switch_port = binding_key[1][1]
bindings = bindings.filter(and_(
port_binding_model.port_id == port_id,
port_binding_model.profile.ilike('%%%s%%' % switch_id),
port_binding_model.profile.ilike('%%%s%%' % switch_port)))
dist_bindings = dist_bindings.filter(and_(
dist_binding_model.port_id == port_id,
dist_binding_model.profile.ilike('%%%s%%' % switch_id),
dist_binding_model.profile.ilike('%%%s%%' % switch_port)))
else:
host_id = binding_key[1]
bindings = bindings.filter(and_(
port_binding_model.port_id == port_id,
port_binding_model.host == host_id))
dist_bindings = dist_bindings.filter(and_(
dist_binding_model.port_id == port_id,
dist_binding_model.host == host_id))
binding_levels = collections.defaultdict(list)
for binding, level in bindings.all() + dist_bindings.all():
binding_levels[binding].append(level)
bindings_with_levels = list()
for binding, levels in binding_levels.items():
binding.levels = levels
bindings_with_levels.append(binding)
return bindings_with_levels
def _get_endpoints(self):
LOG.debug("_get_endpoints() called")
session = db_api.get_reader_session()
return session.query(self.endpoint_model)
def _verify_get_nsx_router_id(self, exp_lr_uuid):
neutron_router_id = uuidutils.generate_uuid()
lr_uuid = nsx_utils.get_nsx_router_id(db_api.get_reader_session(),
None, neutron_router_id)
self.assertEqual(exp_lr_uuid, lr_uuid)
def get_endpoint_by_host(self, host):
LOG.debug("get_endpoint_by_host() called for host %s", host)
session = db_api.get_reader_session()
return (session.query(self.endpoint_model).
filter_by(host=host).first())
def get_network_bindings(session, network_id):
session = session or db_api.get_reader_session()
return (session.query(
nsx_models.TzNetworkBinding).filter_by(network_id=network_id).all())
def _get_endpoints(self):
LOG.debug("_get_endpoints() called")
session = db_api.get_reader_session()
return session.query(self.endpoint_model)
def get_network_bindings_by_physical_net_and_type(session, phy_uuid,
binding_type):
session = session or db_api.get_reader_session()
return (session.query(nsxv_models.NsxvTzNetworkBinding).filter_by(
phy_uuid=phy_uuid, binding_type=binding_type).all())
def get_network_bindings_by_vlanid(session, vlan_id):
session = session or db_api.get_reader_session()
return (session.query(nsxv_models.NsxvTzNetworkBinding).
filter_by(vlan_id=vlan_id).
all())
def get_network_bindings_by_vlanid_and_physical_net(session, vlan_id,
phy_uuid):
session = session or db_api.get_reader_session()
return (session.query(nsx_models.TzNetworkBinding).filter_by(
vlan_id=vlan_id, phy_uuid=phy_uuid).all())
