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)