def _synchronize_lrouters(self, ctx, lr_uuids, scan_missing=False):
if not lr_uuids and not scan_missing:
return
# TODO(salvatore-orlando): Deal with the case the tag
# has been tampered with
neutron_router_mappings = {}
for lr_uuid in lr_uuids:
lrouter = (self._nsx_cache[lr_uuid].get('data') or
self._nsx_cache[lr_uuid].get('data_bk'))
tags = self._get_tag_dict(lrouter['tags'])
neutron_router_id = tags.get('q_router_id')
if neutron_router_id:
neutron_router_mappings[neutron_router_id] = (
self._nsx_cache[lr_uuid])
else:
LOG.warning("Unable to find Neutron router id for "
"NSX logical router: %s", lr_uuid)
# Fetch neutron routers from database
filters = ({} if scan_missing else
{'id': neutron_router_mappings.keys()})
routers = model_query.get_collection(
ctx, l3_db.Router, self._plugin._make_router_dict,
filters=filters)
for router in routers:
lrouter = neutron_router_mappings.get(router['id'])
self.synchronize_router(
ctx, router, lrouter and lrouter.get('data'))
def _synchronize_lswitches(self, ctx, ls_uuids, scan_missing=False):
if not ls_uuids and not scan_missing:
return
neutron_net_ids = set()
neutron_nsx_mappings = {}
# TODO(salvatore-orlando): Deal with the case the tag
# has been tampered with
for ls_uuid in ls_uuids:
# If the lswitch has been deleted, get backup copy of data
lswitch = (self._nsx_cache[ls_uuid].get('data') or
self._nsx_cache[ls_uuid].get('data_bk'))
tags = self._get_tag_dict(lswitch['tags'])
neutron_id = tags.get('quantum_net_id')
neutron_net_ids.add(neutron_id)
neutron_nsx_mappings[neutron_id] = (
neutron_nsx_mappings.get(neutron_id, []) +
[self._nsx_cache[ls_uuid]])
# Fetch neutron networks from database
filters = {'router:external': [False]}
if not scan_missing:
filters['id'] = neutron_net_ids
networks = model_query.get_collection(
ctx, models_v2.Network, self._plugin._make_network_dict,
filters=filters)
for network in networks:
lswitches = neutron_nsx_mappings.get(network['id'], [])
lswitches = [lsw.get('data') for lsw in lswitches]
self.synchronize_network(ctx, network, lswitches)
def _synchronize_lswitchports(self, ctx, lp_uuids, scan_missing=False):
if not lp_uuids and not scan_missing:
return
# Find Neutron port id by tag - the tag is already
# loaded in memory, no reason for doing a db query
# TODO(salvatore-orlando): Deal with the case the tag
# has been tampered with
neutron_port_mappings = {}
for lp_uuid in lp_uuids:
lport = (self._nsx_cache[lp_uuid].get('data') or
self._nsx_cache[lp_uuid].get('data_bk'))
tags = self._get_tag_dict(lport['tags'])
neutron_port_id = tags.get('q_port_id')
if neutron_port_id:
neutron_port_mappings[neutron_port_id] = (
self._nsx_cache[lp_uuid])
# Fetch neutron ports from database
# At the first sync we need to fetch all ports
filters = ({} if scan_missing else
{'id': neutron_port_mappings.keys()})
# TODO(salv-orlando): Work out a solution for avoiding
# this query
ext_nets = [net['id'] for net in ctx.session.query(
models_v2.Network).join(
external_net_db.ExternalNetwork,
(models_v2.Network.id ==
external_net_db.ExternalNetwork.network_id))]
ports = model_query.get_collection(
ctx, models_v2.Port, self._plugin._make_port_dict,
filters=filters)
for port in ports:
lswitchport = neutron_port_mappings.get(port['id'])
self.synchronize_port(
ctx, port, lswitchport and lswitchport.get('data'),
ext_networks=ext_nets)
def get_nuage_l2bridges(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = lib_db_utils.get_marker_obj(self, context,
'nuage_l2bridges', limit,
marker)
l2bridges = lib_model_query.get_collection(context,
nuage_models.NuageL2bridge,
self._make_l2bridges_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
if not fields or 'physnets' in fields:
for l2bridge in l2bridges:
physnets = nuagedb.get_nuage_l2bridge_physnet_mappings(
context.session, l2bridge_id=l2bridge['id'])
l2bridge['physnets'] = self._make_physnet_mapping_dict(
physnets)
if not fields or 'networks' in fields:
for l2bridge in l2bridges:
networks = nuagedb.get_networks_for_nuage_l2bridge(
context.session, l2bridge['id'])
networks = [n['id'] for n in networks]
l2bridge['networks'] = networks
return l2bridges
def get_tap_flows(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
LOG.debug("get_tap_flows() called")
return model_query.get_collection(context, TapFlow,
self._make_tap_flow_dict,
filters=filters, fields=fields)
def get_ipsec_site_connections(self, context, filters=None, fields=None):
return model_query.get_collection(
context,
vpn_models.IPsecSiteConnection,
self._make_ipsec_site_connection_dict,
filters=filters,
fields=fields)
def get_port_assocs(self, context, bgpvpn_id, filters=None, fields=None):
if not filters:
filters = {}
filters['bgpvpn_id'] = [bgpvpn_id]
return model_query.get_collection(context, BGPVPNPortAssociation,
self._make_port_assoc_dict, filters,
fields)
def _get_collection(context, model, dict_func,
filters=None, fields=None, sorts=None,
limit=None, marker_obj=None,
page_reverse=False):
return model_query.get_collection(context, model, dict_func,
filters, fields, sorts,
limit, marker_obj,
page_reverse)
def get_objects(obj_cls, context, _pager=None, **kwargs):
with obj_cls.db_context_reader(context):
filters = _kwargs_to_filters(**kwargs)
return model_query.get_collection(
context, obj_cls.db_model,
dict_func=None, # return all the data
filters=filters,
**(_pager.to_kwargs(context, obj_cls) if _pager else {}))
def get_firewall_groups(self, context, filters=None, fields=None):
if context.tenant_id:
tenant_id = filters.get('tenant_id') if filters else None
tenant_id = tenant_id[0] if tenant_id else context.tenant_id
self._ensure_default_firewall_group(context, tenant_id)
return model_query.get_collection(
context, FirewallGroup, self._make_firewall_group_dict,
filters=filters, fields=fields)
def get_objects(obj_cls, context, _pager=None, **kwargs):
with obj_cls.db_context_reader(context):
filters = _kwargs_to_filters(**kwargs)
return model_query.get_collection(
context, obj_cls.db_model,
dict_func=None, # return all the data
filters=filters,
**(_pager.to_kwargs(context, obj_cls) if _pager else {}))
def _get_port_security_group_bindings(self,
context,
filters=None,
fields=None):
return model_query.get_collection(
context,
sg_models.SecurityGroupPortBinding,
self._make_security_group_binding_dict,
filters=filters,
fields=fields)
def get_network_gateways(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self,
context, 'network_gateway', limit, marker)
return model_query.get_collection(context, nsx_models.NetworkGateway,
self._make_network_gateway_dict,
filters=filters, fields=fields,
sorts=sorts, limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def get_port_pair_groups(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'port_pair_group',
limit, marker)
return model_query.get_collection(
context, PortPairGroup,
self._make_port_pair_group_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_port_chains(self, context, filters=None, fields=None,
sorts=None, limit=None,
marker=None, page_reverse=False, default_sg=False):
marker_obj = db_utils.get_marker_obj(self, context, 'port_chain',
limit, marker)
return model_query.get_collection(
context, PortChain,
self._make_port_chain_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_reachabilityquicktests(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
reachabilityquicktests = \
model_query.get_collection(context, ReachabilityQuickTest,
self._make_reachabilityquicktest_dict,
filters=filters, fields=fields)
return reachabilityquicktests
def get_service_graphs(self, context, filters=None,
fields=None, sorts=None, limit=None,
marker=None, page_reverse=False):
"""Get Service Graphs."""
marker_obj = db_utils.get_marker_obj(self, context,
'service_graph', limit, marker)
return model_query.get_collection(
context, ServiceGraph,
self._make_service_graph_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_flow_classifiers(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'flow_classifier',
limit, marker)
return model_query.get_collection(
context,
FlowClassifier,
self._make_flow_classifier_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_networktemplates(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
networktemplates = \
model_query.get_collection(context, NetworkTemplate,
self._make_networktemplate_dict,
filters=filters, fields=fields)
return networktemplates
def get_gateway_devices(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'gateway_device',
limit, marker)
return model_query.get_collection(context,
GatewayDevice,
self._make_gateway_device_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_switchport_mappings(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = lib_db_utils.get_marker_obj(self, context,
'switchport_mappings',
limit, marker)
return lib_model_query.get_collection(
context,
nuage_models.NuageSwitchportMapping,
self._make_switchport_mapping_dict,
filters=filters, fields=fields,
sorts=sorts, limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_gateway_device_remote_mac_entries(self, context, gateway_device_id,
filters=None, fields=None,
sorts=None, limit=None,
marker=None, page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'remote_mac_entry',
limit, marker)
filters['device_id'] = [gateway_device_id]
return model_query.get_collection(context,
GatewayRemoteMacTable,
self._make_remote_mac_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_tenantpolicies(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
with db_api.CONTEXT_READER.using(context):
tenantpolicies = \
model_query.get_collection(context, TenantPolicy,
self._make_tenantpolicy_dict,
filters=filters, fields=fields)
return tenantpolicies
def get_flow_classifiers(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'flow_classifier',
limit, marker)
return model_query.get_collection(context,
FlowClassifier,
self._make_flow_classifier_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def get_network_gateways(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'network_gateway',
limit, marker)
return model_query.get_collection(context,
nsx_models.NetworkGateway,
self._make_network_gateway_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def get_project_net_partition_mappings(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = ndb_utils.get_marker_obj(self, context,
'project_net_partition_mapping',
limit, marker)
return model_query.get_collection(
context,
nuage_models.NetPartitionProject,
functools.partial(self._make_project_net_partition_mapping,
context),
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def _get_collection(self, ctx, model, func):
return mq.get_collection(ctx, model,
models._generate_dict_from_cg_db)
def get_endpoint_groups(self, context, filters=None, fields=None):
return model_query.get_collection(context,
vpn_models.VPNEndpointGroup,
self._make_endpoint_group_dict,
filters=filters,
fields=fields)
def get_vpnservices(self, context, filters=None, fields=None):
return model_query.get_collection(context,
vpn_models.VPNService,
self._make_vpnservice_dict,
filters=filters,
fields=fields)
def get_ipsecpolicies(self, context, filters=None, fields=None):
return model_query.get_collection(context,
vpn_models.IPsecPolicy,
self._make_ipsecpolicy_dict,
filters=filters,
fields=fields)
def get_firewall_policies(self, context, filters=None, fields=None):
return model_query.get_collection(
context, FirewallPolicy, self._make_firewall_policy_dict,
filters=filters, fields=fields)
def get_firewall_rules(self, context, filters=None, fields=None):
return model_query.get_collection(
context, FirewallRuleV2, self._make_firewall_rule_dict,
filters=filters, fields=fields)
def get_bgpvpns(self, context, filters=None, fields=None):
return model_query.get_collection(context,
BGPVPN,
self._make_bgpvpn_dict,
filters=filters,
fields=fields)
def _get_branches(self, context, filters):
return model_query.get_collection(
context, GraphChainAssoc,
self._make_graph_chain_assoc_dict,
filters=filters)
def _get_port_security_group_bindings(self, context,
filters=None, fields=None):
return model_query.get_collection(
context, sg_models.SecurityGroupPortBinding,
self._make_security_group_binding_dict,
filters=filters, fields=fields)
