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