def get_agents_db(self, context, filters=None):
# TODO(annp): keep this method for backward compatibility,
# will need to clean it up later
query = model_query.get_collection_query(context,
agent_model.Agent,
filters=filters)
return query.all()
def _check_rules_for_policy_is_valid(self, context, fwp, fwp_db,
rule_id_list, filters):
rules_in_fwr_db = model_query.get_collection_query(
context, FirewallRuleV2, filters=filters)
rules_dict = dict((fwr_db['id'], fwr_db) for fwr_db in rules_in_fwr_db)
for fwrule_id in rule_id_list:
if fwrule_id not in rules_dict:
# Bail as soon as we find an invalid rule.
raise f_exc.FirewallRuleNotFound(
firewall_rule_id=fwrule_id)
if 'shared' in fwp:
if fwp['shared'] and not rules_dict[fwrule_id]['shared']:
raise f_exc.FirewallRuleSharingConflict(
firewall_rule_id=fwrule_id,
firewall_policy_id=fwp_db['id'])
elif fwp_db['shared'] and not rules_dict[fwrule_id]['shared']:
raise f_exc.FirewallRuleSharingConflict(
firewall_rule_id=fwrule_id,
firewall_policy_id=fwp_db['id'])
else:
# the policy is not shared, the rule and policy should be in
# the same project if the rule is not shared.
if not rules_dict[fwrule_id]['shared']:
if (rules_dict[fwrule_id]['tenant_id'] != fwp_db[
'tenant_id']):
raise f_exc.FirewallRuleConflict(
firewall_rule_id=fwrule_id,
project_id=rules_dict[fwrule_id]['tenant_id'])
def get_agents_db(self, context, filters=None):
# TODO(annp): keep this method for backward compatibility,
# will need to clean it up later
query = model_query.get_collection_query(context,
agent_model.Agent,
filters=filters)
return query.all()
def _set_rules_for_policy(self, context, firewall_policy_db, fwp):
rule_id_list = fwp['firewall_rules']
fwp_db = firewall_policy_db
with context.session.begin(subtransactions=True):
if not rule_id_list:
self._delete_all_rules_from_policy(context, fwp_db)
return
# We will first check if the new list of rules is valid
filters = {'firewall_rule_id': [r_id for r_id in rule_id_list]}
# Run a validation on the Firewall Rules table
self._check_rules_for_policy_is_valid(context, fwp, fwp_db,
rule_id_list, filters)
# new rules are valid, lets delete the old association
self._delete_all_rules_from_policy(context, fwp_db)
# and add in the new association
self._set_rules_in_policy_rule_assoc(context, fwp_db, fwp)
# we need care about the associations related with this policy
# and its rules only.
filters['firewall_policy_id'] = [fwp_db['id']]
rules_in_fpol_rul_db = model_query.get_collection_query(
context,
FirewallPolicyRuleAssociation,
filters=filters)
rules_dict = dict((fpol_rul_db['firewall_rule_id'], fpol_rul_db)
for fpol_rul_db in rules_in_fpol_rul_db)
fwp_db.rule_associations = []
for fwrule_id in rule_id_list:
fwp_db.rule_associations.append(rules_dict[fwrule_id])
fwp_db.rule_associations.reorder()
def get_l3_agents():
filters = {'agent_type': [constants.AGENT_TYPE_L3]}
ctx = context.get_admin_context()
query = model_query.get_collection_query(ctx,
agent_model.Agent,
filters=filters)
return query.all()
def get_srv6_encap_networks(self,
context,
filters=None,
fields=None,
sorts=None,
limit=None,
marker=None,
page_reverse=False):
marker_obj = self.db_utils.get_marker_obj(self, context,
'srv6_encap_networks', limit,
marker)
encap_networks = model_query.get_collection_query(
context,
Srv6EncapNetwork,
filters=filters,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
results = []
for encap_network in encap_networks:
encap_rule_db = self._get_srv6_encap_rule(context,
encap_network['id'])
result = self._make_srv6_encap_network_dict(encap_network,
encap_rule_db,
fields=fields)
results.append(result)
return results
def _get_filter_query(obj_cls, context, query_field=None, query_limit=None,
**kwargs):
filters = _kwargs_to_filters(**kwargs)
query = model_query.get_collection_query(
context, obj_cls.db_model, filters, limit=query_limit,
field=query_field)
return query
def get_l3_agents():
filters = {'agent_type': [constants.AGENT_TYPE_L3]}
ctx = context.get_admin_context()
query = model_query.get_collection_query(ctx,
agent_model.Agent,
filters=filters)
return query.all()
def _get_collection_query(context, model,
filters=None, sorts=None,
limit=None, marker_obj=None,
page_reverse=False):
return model_query.get_collection_query(context, model,
filters, sorts,
limit, marker_obj,
page_reverse)
def _query_gateway_devices(self, context,
filters=None, sorts=None,
limit=None, marker=None,
page_reverse=None):
marker_obj = db_utils.get_marker_obj(self,
context, 'gateway_device', limit, marker)
return model_query.get_collection_query(
context, nsx_models.NetworkGatewayDevice,
filters=filters, sorts=sorts, limit=limit,
marker_obj=marker_obj, page_reverse=page_reverse)
def get_extra_dhcp_opts():
"""Get extra DHCP options for all ports from Database
:return: list of ports' extra_dhcp_option names and values
"""
ctx = context.get_admin_context()
query = model_query.get_collection_query(
ctx,
extra_dhcp_opt_models.ExtraDhcpOpt)
return query.all()
def _retrieve_gateway_connections(self, context, gateway_id,
mapping_info=None, only_one=False):
mapping_info = mapping_info or {}
filters = {'network_gateway_id': [gateway_id]}
for k, v in six.iteritems(mapping_info):
if v and k != NETWORK_ID:
filters[k] = [v]
query = model_query.get_collection_query(context,
nsx_models.NetworkConnection,
filters)
return query.one() if only_one else query.all()
def get_agents(agt_type):
"""Get agent information from Database
:param agt_type: agent type, one of constants.AGENT_TYPE_*
:return: list of database query results
"""
filters = {'agent_type': [agt_type]}
ctx = context.get_admin_context()
query = model_query.get_collection_query(ctx,
agent_model.Agent,
filters=filters)
return query.all()
def _retrieve_gateway_connections(self,
context,
gateway_id,
mapping_info=None,
only_one=False):
mapping_info = mapping_info or {}
filters = {'network_gateway_id': [gateway_id]}
for k, v in six.iteritems(mapping_info):
if v and k != NETWORK_ID:
filters[k] = [v]
query = model_query.get_collection_query(context,
nsx_models.NetworkConnection,
filters)
return query.one() if only_one else query.all()
def _query_gateway_devices(self,
context,
filters=None,
sorts=None,
limit=None,
marker=None,
page_reverse=None):
marker_obj = db_utils.get_marker_obj(self, context, 'gateway_device',
limit, marker)
return model_query.get_collection_query(
context,
nsx_models.NetworkGatewayDevice,
filters=filters,
sorts=sorts,
limit=limit,
marker_obj=marker_obj,
page_reverse=page_reverse)
def _load_ports_by_side(self, side):
ports = []
if getattr(self, side + '_ppg'):
# pylint: disable=no-member
reverse_side = (side if self.reverse_hop else
constants.REVERSE_PORT_SIDE[side])
ports = ([
getattr(pp, reverse_side)
for pp in model_query.get_collection_query(
self.obj_context,
sfc_db.PortPair,
filters={
'portpairgroup_id': [getattr(self, side + '_ppg')]
})
])
elif getattr(self, side + '_network'):
port_objs = (Port.get_objects(self.obj_context,
network_id=getattr(
self, side + '_network')))
ports = [port_obj.id for port_obj in port_objs]
setattr(self, side + '_ports', ports)
self.obj_reset_changes([side + '_ports'])
def _is_device_in_use(self, context, device_id):
query = model_query.get_collection_query(
context, nsx_models.NetworkGatewayDeviceReference,
{'id': [device_id]})
return query.first()
def query_subnets_on_network(cls, context, network_id):
query = model_query.get_collection_query(context, cls.db_model)
return query.filter(cls.db_model.network_id == network_id)
def _is_device_in_use(self, context, device_id):
query = model_query.get_collection_query(
context, nsx_models.NetworkGatewayDeviceReference,
{'id': [device_id]})
return query.first()
def get_networks():
ctx = context.get_admin_context()
query = model_query.get_collection_query(ctx,
models_v2.Network)
return query.all()
def query_subnets_on_network(cls, context, network_id):
query = model_query.get_collection_query(context, cls.db_model)
return query.filter(cls.db_model.network_id == network_id)
def _get_filter_query(obj_cls, context, **kwargs):
with obj_cls.db_context_reader(context):
filters = _kwargs_to_filters(**kwargs)
query = model_query.get_collection_query(
context, obj_cls.db_model, filters)
return query
def _get_filter_query(obj_cls, context, **kwargs):
with obj_cls.db_context_reader(context):
filters = _kwargs_to_filters(**kwargs)
query = model_query.get_collection_query(context, obj_cls.db_model,
filters)
return query
def _get_resources(self, context, model, filters=None, options=None):
query = model_query.get_collection_query(context, model,
filters=filters)
if options:
query = query.options(options)
return [model_instance for model_instance in query]
