def _make_address_scope_dict(address_scope, fields=None):
res = {'id': address_scope['id'],
'name': address_scope['name'],
'tenant_id': address_scope['tenant_id'],
'shared': address_scope['shared'],
'ip_version': address_scope['ip_version']}
return db_utils.resource_fields(res, fields)
def _response(network_id, tenant_id, fields=None):
"""Build response for auto-allocated network."""
res = {
'id': network_id,
'tenant_id': tenant_id
}
return db_utils.resource_fields(res, fields)
def _make_metering_label_rule_dict(metering_label_rule, fields=None):
res = {'id': metering_label_rule['id'],
'metering_label_id': metering_label_rule['metering_label_id'],
'direction': metering_label_rule['direction'],
'remote_ip_prefix': metering_label_rule['remote_ip_prefix'],
'excluded': metering_label_rule['excluded']}
return db_utils.resource_fields(res, fields)
def get_flavor_next_provider(
self, context, flavor_id, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False
):
"""From flavor, choose service profile and find provider for driver."""
with db_api.context_manager.reader.using(context):
bind_qry = context.session.query(flavor_models.FlavorServiceProfileBinding)
binding = bind_qry.filter_by(flavor_id=flavor_id).first()
if not binding:
raise ext_flavors.FlavorServiceProfileBindingNotFound(sp_id="", fl_id=flavor_id)
# Get the service profile from the first binding
# TODO(jwarendt) Should become a scheduling framework instead
sp_db = self._get_service_profile(context, binding["service_profile_id"])
if not sp_db.enabled:
raise ext_flavors.ServiceProfileDisabled()
LOG.debug("Found driver %s.", sp_db.driver)
service_type_manager = sdb.ServiceTypeManager.get_instance()
providers = service_type_manager.get_service_providers(context, filters={"driver": sp_db.driver})
if not providers:
raise ext_flavors.ServiceProfileDriverNotFound(driver=sp_db.driver)
LOG.debug("Found providers %s.", providers)
res = {"driver": sp_db.driver, "provider": providers[0].get("name")}
return [db_utils.resource_fields(res, fields)]
def _make_metering_label_dict(metering_label, fields=None):
res = {'id': metering_label['id'],
'name': metering_label['name'],
'description': metering_label['description'],
'shared': metering_label['shared'],
'tenant_id': metering_label['tenant_id']}
return db_utils.resource_fields(res, fields)
def _make_subnet_dict(self, subnet, fields=None, context=None):
res = {'id': subnet['id'],
'name': subnet['name'],
'tenant_id': subnet['tenant_id'],
'network_id': subnet['network_id'],
'ip_version': subnet['ip_version'],
'cidr': subnet['cidr'],
'subnetpool_id': subnet.get('subnetpool_id'),
'allocation_pools': [{'start': pool['first_ip'],
'end': pool['last_ip']}
for pool in subnet['allocation_pools']],
'gateway_ip': subnet['gateway_ip'],
'enable_dhcp': subnet['enable_dhcp'],
'ipv6_ra_mode': subnet['ipv6_ra_mode'],
'ipv6_address_mode': subnet['ipv6_address_mode'],
'dns_nameservers': [dns['address']
for dns in subnet['dns_nameservers']],
'host_routes': [{'destination': route['destination'],
'nexthop': route['nexthop']}
for route in subnet['routes']],
}
# The shared attribute for a subnet is the same as its parent network
res['shared'] = self._is_network_shared(context, subnet.networks)
# Call auxiliary extend functions, if any
self._apply_dict_extend_functions(attributes.SUBNETS, res, subnet)
return db_utils.resource_fields(res, fields)
def get_flavor_next_provider(
self, context, flavor_id, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False
):
"""From flavor, choose service profile and find provider for driver."""
objs = obj_flavor.FlavorServiceProfileBinding.get_objects(context, flavor_id=flavor_id)
if not objs:
raise ext_flavors.FlavorServiceProfileBindingNotFound(sp_id="", fl_id=flavor_id)
# Get the service profile from the first binding
# TODO(jwarendt) Should become a scheduling framework instead
sp_obj = self._get_service_profile(context, objs[0].service_profile_id)
if not sp_obj.enabled:
raise ext_flavors.ServiceProfileDisabled()
LOG.debug("Found driver %s.", sp_obj.driver)
service_type_manager = sdb.ServiceTypeManager.get_instance()
providers = service_type_manager.get_service_providers(context, filters={"driver": sp_obj.driver})
if not providers:
raise ext_flavors.ServiceProfileDriverNotFound(driver=sp_obj.driver)
LOG.debug("Found providers %s.", providers)
res = {"driver": sp_obj.driver, "provider": providers[0].get("name")}
return [db_utils.resource_fields(res, fields)]
def get_flavor_service_profile(context, service_profile_id, flavor_id, fields=None):
if not obj_flavor.FlavorServiceProfileBinding.objects_exist(
context, service_profile_id=service_profile_id, flavor_id=flavor_id
):
raise ext_flavors.FlavorServiceProfileBindingNotFound(sp_id=service_profile_id, fl_id=flavor_id)
res = {"service_profile_id": service_profile_id, "flavor_id": flavor_id}
return db_utils.resource_fields(res, fields)
def _make_networks_dict(self, networks, context):
nets = []
for network in networks:
if network.mtu is None:
# TODO(ivar): also refactor this to run for bulk networks
network.mtu = self._get_network_mtu(network, validate=False)
res = {'id': network['id'],
'name': network['name'],
'tenant_id': network['tenant_id'],
'admin_state_up': network['admin_state_up'],
'mtu': network.get('mtu', n_const.DEFAULT_NETWORK_MTU),
'status': network['status'],
'subnets': [subnet['id']
for subnet in network['subnets']]}
res['shared'] = self._is_network_shared(context,
network.rbac_entries)
nets.append((res, network))
# Bulk extend first
resource_extend.apply_funcs(net_def.COLLECTION_NAME + '_BULK', nets,
None)
result = []
for res, network in nets:
res[api_plus.BULK_EXTENDED] = True
resource_extend.apply_funcs(net_def.COLLECTION_NAME, res, network)
res.pop(api_plus.BULK_EXTENDED, None)
result.append(db_utils.resource_fields(res, []))
return result
def get_service_providers(self, filters=None, fields=None):
return [db_utils.resource_fields({'service_type': k[0],
'name': k[1],
'driver': v['driver'],
'default': v['default']},
fields)
for k, v in self.providers.items()
if self._check_entry(k, v, filters)]
def _make_service_profile_dict(sp_obj, fields=None):
res = {'id': sp_obj['id'],
'description': sp_obj['description'],
'driver': sp_obj['driver'],
'enabled': sp_obj['enabled'],
'metainfo': sp_obj['metainfo'],
'flavors': list(sp_obj['flavor_ids'])}
return db_utils.resource_fields(res, fields)
def _make_flavor_dict(flavor_obj, fields=None):
res = {'id': flavor_obj['id'],
'name': flavor_obj['name'],
'description': flavor_obj['description'],
'service_type': flavor_obj['service_type'],
'enabled': flavor_obj['enabled'],
'service_profiles': list(flavor_obj['service_profile_ids'])}
return db_utils.resource_fields(res, fields)
def _make_security_group_dict(self, security_group, fields=None):
res = {'id': security_group['id'],
'name': security_group['name'],
'tenant_id': security_group['tenant_id'],
'description': security_group['description']}
res['security_group_rules'] = [self._make_security_group_rule_dict(r)
for r in security_group.rules]
self._apply_dict_extend_functions(ext_sg.SECURITYGROUPS, res,
security_group)
return db_utils.resource_fields(res, fields)
def _make_service_profile_dict(sp_obj, fields=None):
res = {
"id": sp_obj["id"],
"description": sp_obj["description"],
"driver": sp_obj["driver"],
"enabled": sp_obj["enabled"],
"metainfo": sp_obj["metainfo"],
"flavors": list(sp_obj["flavor_ids"]),
}
return db_utils.resource_fields(res, fields)
def _make_service_profile_dict(sp_db, fields=None):
res = {
"id": sp_db["id"],
"description": sp_db["description"],
"driver": sp_db["driver"],
"enabled": sp_db["enabled"],
"metainfo": sp_db["metainfo"],
}
if sp_db.flavors:
res["flavors"] = [fl["flavor_id"] for fl in sp_db.flavors]
return db_utils.resource_fields(res, fields)
def get_flavor_service_profile(context, service_profile_id, flavor_id, fields=None):
with db_api.context_manager.reader.using(context):
binding = (
context.session.query(flavor_models.FlavorServiceProfileBinding)
.filter_by(service_profile_id=service_profile_id, flavor_id=flavor_id)
.first()
)
if not binding:
raise ext_flavors.FlavorServiceProfileBindingNotFound(sp_id=service_profile_id, fl_id=flavor_id)
res = {"service_profile_id": service_profile_id, "flavor_id": flavor_id}
return db_utils.resource_fields(res, fields)
def _make_segment_dict(segment_obj, fields=None):
res = {'id': segment_obj['id'],
'network_id': segment_obj['network_id'],
'name': segment_obj['name'],
'description': segment_obj['description'],
db.PHYSICAL_NETWORK: segment_obj[db.PHYSICAL_NETWORK],
db.NETWORK_TYPE: segment_obj[db.NETWORK_TYPE],
db.SEGMENTATION_ID: segment_obj[db.SEGMENTATION_ID],
'hosts': segment_obj['hosts'],
'segment_index': segment_obj['segment_index']}
return db_utils.resource_fields(res, fields)
def _make_flavor_dict(flavor_obj, fields=None):
res = {
"id": flavor_obj["id"],
"name": flavor_obj["name"],
"description": flavor_obj["description"],
"service_type": flavor_obj["service_type"],
"enabled": flavor_obj["enabled"],
"service_profiles": list(flavor_obj["service_profile_ids"]),
}
return db_utils.resource_fields(res, fields)
def get_networks(self, context, filters=None, fields=None,
sorts=None, limit=None, marker=None, page_reverse=False):
with db_api.context_manager.writer.using(context):
nets_db = super(Ml2PlusPlugin, self)._get_networks(
context, filters, None, sorts, limit, marker, page_reverse)
net_data = self._make_networks_dict(nets_db, context)
self.type_manager.extend_networks_dict_provider(context, net_data)
nets = self._filter_nets_provider(context, net_data, filters)
return [db_utils.resource_fields(net, fields) for net in nets]
def _make_flavor_dict(flavor_db, fields=None):
res = {
"id": flavor_db["id"],
"name": flavor_db["name"],
"description": flavor_db["description"],
"service_type": flavor_db["service_type"],
"enabled": flavor_db["enabled"],
"service_profiles": [],
}
if flavor_db.service_profiles:
res["service_profiles"] = [sp["service_profile_id"] for sp in flavor_db.service_profiles]
return db_utils.resource_fields(res, fields)
def _make_agent_dict(self, agent, fields=None):
attr = ext_agent.RESOURCE_ATTRIBUTE_MAP.get(
ext_agent.RESOURCE_NAME + 's')
res = dict((k, agent[k]) for k in attr
if k not in ['alive', 'configurations'])
res['alive'] = not utils.is_agent_down(
res['heartbeat_timestamp']
)
res['configurations'] = self._get_dict(agent, 'configurations')
res['resource_versions'] = self._get_dict(agent, 'resource_versions',
ignore_missing=True)
res['availability_zone'] = agent['availability_zone']
return db_utils.resource_fields(res, fields)
def _make_subnet_dict(self, subnet, fields=None, context=None):
res = {'id': subnet['id'],
'name': subnet['name'],
'tenant_id': subnet['tenant_id'],
'network_id': subnet['network_id'],
'ip_version': subnet['ip_version'],
'subnetpool_id': subnet['subnetpool_id'],
'enable_dhcp': subnet['enable_dhcp'],
'ipv6_ra_mode': subnet['ipv6_ra_mode'],
'ipv6_address_mode': subnet['ipv6_address_mode'],
}
res['gateway_ip'] = str(
subnet['gateway_ip']) if subnet['gateway_ip'] else None
# TODO(korzen) this method can get subnet as DB object or Subnet OVO,
# so temporary workaround will be to fill in the fields in separate
# ways. After converting all code pieces to use Subnet OVO, the latter
# 'else' can be deleted
if isinstance(subnet, subnet_obj.Subnet):
res['cidr'] = str(subnet.cidr)
res['allocation_pools'] = [{'start': str(pool.start),
'end': str(pool.end)}
for pool in subnet.allocation_pools]
res['host_routes'] = [{'destination': str(route.destination),
'nexthop': str(route.nexthop)}
for route in subnet.host_routes]
res['dns_nameservers'] = [str(dns.address)
for dns in subnet.dns_nameservers]
res['shared'] = subnet.shared
# Call auxiliary extend functions, if any
resource_extend.apply_funcs(subnet_def.COLLECTION_NAME,
res, subnet.db_obj)
else:
res['cidr'] = subnet['cidr']
res['allocation_pools'] = [{'start': pool['first_ip'],
'end': pool['last_ip']}
for pool in subnet['allocation_pools']]
res['host_routes'] = [{'destination': route['destination'],
'nexthop': route['nexthop']}
for route in subnet['routes']]
res['dns_nameservers'] = [dns['address']
for dns in subnet['dns_nameservers']]
# The shared attribute for a subnet is the same
# as its parent network
res['shared'] = self._is_network_shared(context,
subnet.rbac_entries)
# Call auxiliary extend functions, if any
resource_extend.apply_funcs(subnet_def.COLLECTION_NAME,
res, subnet)
return db_utils.resource_fields(res, fields)
def _make_security_group_rule_dict(self, security_group_rule, fields=None):
res = {'id': security_group_rule['id'],
'tenant_id': security_group_rule['tenant_id'],
'security_group_id': security_group_rule['security_group_id'],
'ethertype': security_group_rule['ethertype'],
'direction': security_group_rule['direction'],
'protocol': security_group_rule['protocol'],
'port_range_min': security_group_rule['port_range_min'],
'port_range_max': security_group_rule['port_range_max'],
'remote_ip_prefix': security_group_rule['remote_ip_prefix'],
'remote_group_id': security_group_rule['remote_group_id']}
self._apply_dict_extend_functions(ext_sg.SECURITYGROUPRULES, res,
security_group_rule)
return db_utils.resource_fields(res, fields)
def _make_network_dict(self, network, fields=None,
process_extensions=True, context=None):
res = {'id': network['id'],
'name': network['name'],
'tenant_id': network['tenant_id'],
'admin_state_up': network['admin_state_up'],
'mtu': network.get('mtu', n_const.DEFAULT_NETWORK_MTU),
'status': network['status'],
'subnets': [subnet['id']
for subnet in network['subnets']]}
res['shared'] = self._is_network_shared(context, network.rbac_entries)
# Call auxiliary extend functions, if any
if process_extensions:
resource_extend.apply_funcs(attributes.NETWORKS, res, network)
return db_utils.resource_fields(res, fields)
def _make_subnets_dict(self, subnets_db, fields=None, context=None):
subnets = []
for subnet_db in subnets_db:
res = {'id': subnet_db['id'],
'name': subnet_db['name'],
'tenant_id': subnet_db['tenant_id'],
'network_id': subnet_db['network_id'],
'ip_version': subnet_db['ip_version'],
'subnetpool_id': subnet_db['subnetpool_id'],
'enable_dhcp': subnet_db['enable_dhcp'],
'ipv6_ra_mode': subnet_db['ipv6_ra_mode'],
'ipv6_address_mode': subnet_db['ipv6_address_mode'],
}
res['gateway_ip'] = str(
subnet_db['gateway_ip']) if subnet_db['gateway_ip'] else (
None)
res['cidr'] = subnet_db['cidr']
res['allocation_pools'] = [{'start': pool['first_ip'],
'end': pool['last_ip']}
for pool in
subnet_db['allocation_pools']]
res['host_routes'] = [{'destination': route['destination'],
'nexthop': route['nexthop']}
for route in subnet_db['routes']]
res['dns_nameservers'] = [dns['address']
for dns in subnet_db['dns_nameservers']]
# The shared attribute for a subnet is the same
# as its parent network
res['shared'] = self._is_network_shared(context,
subnet_db.rbac_entries)
subnets.append((res, subnet_db))
resource_extend.apply_funcs(subnet_def.COLLECTION_NAME + '_BULK',
subnets, None)
result = []
for res, subnet_db in subnets:
res[api_plus.BULK_EXTENDED] = True
resource_extend.apply_funcs(subnet_def.COLLECTION_NAME,
res, subnet_db)
res.pop(api_plus.BULK_EXTENDED, None)
result.append(db_utils.resource_fields(res, []))
return result
def _make_port_dict(self, port, fields=None,
process_extensions=True):
res = {"id": port["id"],
'name': port['name'],
"network_id": port["network_id"],
'tenant_id': port['tenant_id'],
"mac_address": port["mac_address"],
"admin_state_up": port["admin_state_up"],
"status": port["status"],
"fixed_ips": [{'subnet_id': ip["subnet_id"],
'ip_address': ip["ip_address"]}
for ip in port["fixed_ips"]],
"device_id": port["device_id"],
"device_owner": port["device_owner"]}
# Call auxiliary extend functions, if any
if process_extensions:
resource_extend.apply_funcs(attributes.PORTS, res, port)
return db_utils.resource_fields(res, fields)
def _make_subnetpool_dict(self, subnetpool, fields=None):
default_prefixlen = str(subnetpool['default_prefixlen'])
min_prefixlen = str(subnetpool['min_prefixlen'])
max_prefixlen = str(subnetpool['max_prefixlen'])
res = {'id': subnetpool['id'],
'name': subnetpool['name'],
'tenant_id': subnetpool['tenant_id'],
'default_prefixlen': default_prefixlen,
'min_prefixlen': min_prefixlen,
'max_prefixlen': max_prefixlen,
'is_default': subnetpool['is_default'],
'shared': subnetpool['shared'],
'prefixes': [prefix.cidr for prefix in subnetpool['prefixes']],
'ip_version': subnetpool['ip_version'],
'default_quota': subnetpool['default_quota'],
'address_scope_id': subnetpool['address_scope_id']}
resource_extend.apply_funcs(attributes.SUBNETPOOLS, res, subnetpool)
return db_utils.resource_fields(res, fields)
def _make_security_group_binding_dict(security_group, fields=None):
res = {'port_id': security_group['port_id'],
'security_group_id': security_group['security_group_id']}
return db_utils.resource_fields(res, fields)
def get_network(self, context, id, fields=None):
with db_api.context_manager.reader.using(context):
net = super(PortSecurityTestPlugin, self).get_network(context, id)
return db_utils.resource_fields(net, fields)
def get_network(self, context, id, fields=None):
with context.session.begin(subtransactions=True):
net = super(PortSecurityTestPlugin, self).get_network(context, id)
return db_utils.resource_fields(net, fields)
def _response(network_id, tenant_id, fields=None):
"""Build response for auto-allocated network."""
res = {'id': network_id, 'tenant_id': tenant_id}
return db_utils.resource_fields(res, fields)
def _make_port_security_dict(res, res_name, fields=None):
res_ = {
'%s_id' % res_name: res.id,
psec.PORTSECURITY: res.port_security_enabled
}
return db_utils.resource_fields(res_, fields)
def _make_allowed_address_pairs_dict(allowed_address_pairs, fields=None):
res = {
'mac_address': allowed_address_pairs['mac_address'],
'ip_address': allowed_address_pairs['ip_address']
}
return db_utils.resource_fields(res, fields)
def _fields(self, resource, fields):
return ndb_utils.resource_fields(resource, fields)
def _make_mac_learning_state_dict(self, port, fields=None):
res = {
'port_id': port['port_id'],
mac.MAC_LEARNING: port[mac.MAC_LEARNING]
}
return db_utils.resource_fields(res, fields)
def _make_security_group_binding_dict(security_group, fields=None):
res = {
'port_id': security_group['port_id'],
'security_group_id': security_group['security_group_id']
}
return db_utils.resource_fields(res, fields)
def _fields(resource, fields):
return ndb_utils.resource_fields(resource, fields)
def get_network(self, context, id, fields=None):
with context.session.begin(subtransactions=True):
net = super(PortSecurityTestPlugin, self).get_network(
context, id)
return db_utils.resource_fields(net, fields)
def _make_network_queue_binding_dict(self, queue, fields=None):
res = {
'network_id': queue['network_id'],
'queue_id': queue['queue_id']
}
return db_utils.resource_fields(res, fields)
