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_network_queue_bindings(self, context, filters=None, fields=None):
return model_query.get_collection(
context,
nsx_models.NetworkQueueMapping,
self._make_network_queue_binding_dict,
filters=filters,
fields=fields)
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 get_security_groups(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False,
default_sg=False):
# If default_sg is True do not call _ensure_default_security_group()
# so this can be done recursively. Context.tenant_id is checked
# because all the unit tests do not explicitly set the context on
# GETS. TODO(arosen) context handling can probably be improved here.
if not default_sg and context.tenant_id:
tenant_id = filters.get('tenant_id')
if tenant_id:
tenant_id = tenant_id[0]
else:
tenant_id = context.tenant_id
self._ensure_default_security_group(context, tenant_id)
marker_obj = db_utils.get_marker_obj(self, context, 'security_group',
limit, marker)
return model_query.get_collection(context,
sg_models.SecurityGroup,
self._make_security_group_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def get_rbac_policies(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
page_reverse=False):
filters = filters or {}
object_type_filters = filters.pop('object_type', None)
models_to_query = [
m for t, m in models.get_type_model_map().items()
if object_type_filters is None or t in object_type_filters
]
collections = [
model_query.get_collection(context,
model,
self._make_rbac_policy_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
page_reverse=page_reverse)
for model in models_to_query
]
# NOTE(kevinbenton): we don't have to worry about pagination,
# limits, or page_reverse currently because allow_pagination is
# set to False in 'neutron.extensions.rbac'
return [item for c in collections for item in c]
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_objects(context, model, _pager=None, **kwargs):
with context.session.begin(subtransactions=True):
filters = _kwargs_to_filters(**kwargs)
return model_query.get_collection(
context, model,
dict_func=None, # return all the data
filters=filters,
**(_pager.to_kwargs(context, model) if _pager else {}))
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_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(context, model, _pager=None, **kwargs):
with context.session.begin(subtransactions=True):
filters = _kwargs_to_filters(**kwargs)
return model_query.get_collection(
context, model,
dict_func=None, # return all the data
filters=filters,
**(_pager.to_kwargs(context, model) if _pager else {}))
def get_agents(self, context, filters=None, fields=None):
agents = model_query.get_collection(context, agent_model.Agent,
self._make_agent_dict,
filters=filters, fields=fields)
alive = filters and filters.get('alive', None)
if alive:
alive = converters.convert_to_boolean(alive[0])
agents = [agent for agent in agents if agent['alive'] == alive]
return agents
def get_agents(self, context, filters=None, fields=None):
agents = model_query.get_collection(context, agent_model.Agent,
self._make_agent_dict,
filters=filters, fields=fields)
alive = filters and filters.get('alive', None)
if alive:
alive = converters.convert_to_boolean(alive[0])
agents = [agent for agent in agents if agent['alive'] == alive]
return agents
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_security_group_rules(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = self._get_marker_obj(context, 'security_group_rule',
limit, marker)
return model_query.get_collection(context,
sg_models.SecurityGroupRule,
self._make_security_group_rule_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit, marker_obj=marker_obj,
page_reverse=page_reverse)
def get_routers(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'router',
limit, marker)
routers_db = model_query.get_collection(context, l3_db.Router,
dict_func=None,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
return self._make_routers_dict(routers_db, fields)
def _get_subnets(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'subnet',
limit, marker)
make_subnet_dict = functools.partial(self._make_subnet_dict,
context=context)
return model_query.get_collection(context, models_v2.Subnet,
make_subnet_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def _get_subnets(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'subnet',
limit, marker)
make_subnet_dict = functools.partial(self._make_subnet_dict,
context=context)
return model_query.get_collection(context, models_v2.Subnet,
make_subnet_dict,
filters=filters, fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def get_rbac_policies(self, context, filters=None, fields=None,
sorts=None, limit=None, page_reverse=False):
filters = filters or {}
object_type_filters = filters.pop('object_type', None)
models_to_query = [
m for t, m in models.get_type_model_map().items()
if object_type_filters is None or t in object_type_filters
]
collections = [model_query.get_collection(
context, model, self._make_rbac_policy_dict,
filters=filters, fields=fields, sorts=sorts,
limit=limit, page_reverse=page_reverse)
for model in models_to_query]
# NOTE(kevinbenton): we don't have to worry about pagination,
# limits, or page_reverse currently because allow_pagination is
# set to False in 'neutron.extensions.rbac'
return [item for c in collections for item in c]
def get_qos_queues(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = db_utils.get_marker_obj(self, context, 'qos_queue', limit,
marker)
return model_query.get_collection(context,
nsx_models.QoSQueue,
self._make_qos_queue_dict,
filters=filters,
fields=fields,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
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)
