def delete(network_id, credentials, atomic_context=None): network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) if network.public and not credentials.is_admin: raise faults.Forbidden("Cannot delete the public network.") validate_network_action(network, "DESTROY") if network.nics.exists(): raise faults.Conflict("Cannot delete network. There are ports still" " configured on network network %s" % network.id) if network.ips.filter(deleted=False, floating_ip=True).exists(): msg = "Cannot delete netowrk. Network has allocated floating IPs." raise faults.Conflict(msg) network.action = "DESTROY" # Mark network as drained to prevent automatic allocation of # public/floating IPs while the network is being deleted if network.public: network.drained = True network.save() # Delete network to all backends that exists for bnet in network.backend_networks.exclude(operstate="DELETED"): backend_mod.delete_network(network, bnet.backend) else: # If network does not exist in any backend, update the network state backend_mod.update_network_state(network, atomic_context=atomic_context) return network
def delete_network(request, network_id): log.info('delete_network %s', network_id) network = util.get_network(network_id, request.user_uniq, for_update=True) if network.public: raise api.faults.Forbidden("Cannot delete the public network.") networks.delete(network) return HttpResponse(status=204)
def allocate_floating_ip(request): """Allocate a floating IP.""" req = utils.get_request_dict(request) floating_ip_dict = api.utils.get_attribute(req, "floatingip", required=True, attr_type=dict) userid = request.user_uniq log.info('allocate_floating_ip user: %s request: %s', userid, req) # the network_pool is a mandatory field network_id = api.utils.get_attribute(floating_ip_dict, "floating_network_id", required=False, attr_type=(basestring, int)) if network_id is None: floating_ip = ips.create_floating_ip(userid) else: try: network_id = int(network_id) except ValueError: raise faults.BadRequest("Invalid networkd ID.") network = util.get_network(network_id, userid, for_update=True, non_deleted=True) address = api.utils.get_attribute(floating_ip_dict, "floating_ip_address", required=False, attr_type=basestring) floating_ip = ips.create_floating_ip(userid, network, address) log.info("User '%s' allocated floating IP '%s'", userid, floating_ip) request.serialization = "json" data = json.dumps({"floatingip": ip_to_dict(floating_ip)}) return HttpResponse(data, status=200)
def create_floating_ip(credentials, network_id=None, address=None, project=None, shared_to_project=False, atomic_context=None): userid = credentials.userid if network_id is None: floating_ip = allocate_public_ip(userid, floating_ip=True) else: network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) if not network.floating_ip_pool: msg = ("Cannot allocate floating IP. Network %s is" " not a floating IP pool.") raise faults.Conflict(msg % network.id) if network.action == "DESTROY": msg = "Cannot allocate floating IP. Network %s is being deleted." raise faults.Conflict(msg % network.id) # Allocate the floating IP floating_ip = allocate_ip(network, userid, address=address, floating_ip=True) if project is None: project = userid floating_ip.project = project floating_ip.shared_to_project=shared_to_project floating_ip.save() # Issue commission (quotas) quotas.issue_and_accept_commission( floating_ip, atomic_context=atomic_context) log.info("Created floating IP '%s' for user IP '%s'", floating_ip, userid) return floating_ip
def handle(self, *args, **options): if args: raise CommandError("Command doesn't accept any arguments") network_id = options['network_id'] address = options['address'] owner = options['owner'] if not owner: raise CommandError("'owner' is required for floating IP creation") if network_id is not None: network = util.get_network(network_id, owner, for_update=True, non_deleted=True) if not network.floating_ip_pool: raise CommandError("Network '%s' is not a floating IP pool." % network) else: network = None floating_ip = ips.create_floating_ip(userid=owner, network=network, address=address) self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
def create_port(credentials, network_id, machine_id=None, address=None, name="", security_groups=None, device_owner=None): user_id = credentials.userid vm = None if machine_id is not None: vm = util.get_vm(machine_id, credentials, for_update=True, non_deleted=True, non_suspended=True) if vm.nics.count() == settings.GANETI_MAX_NICS_PER_INSTANCE: raise faults.BadRequest("Maximum ports per server limit reached") network = util.get_network(network_id, credentials, non_deleted=True, for_update=True) ipaddress = None if network.public: # Creating a port to a public network is only allowed if the user has # already a floating IP address in this network which is specified # as the fixed IP address of the port if address is None: msg = ("'fixed_ips' attribute must contain a floating IP address" " in order to connect to a public network.") raise faults.BadRequest(msg) ipaddress = util.get_floating_ip_by_address(credentials, address, for_update=True) port = _create_port(user_id, network, machine=vm, use_ipaddress=ipaddress, name=name, security_groups=security_groups, device_owner=device_owner) log.info("User %s created port %s, network: %s, machine: %s, ip: %s", user_id, port.id, network, vm, ipaddress) return port
def _port_for_request(user_id, network_dict): if not isinstance(network_dict, dict): raise faults.BadRequest("Malformed request. Invalid 'networks' field") port_id = network_dict.get("port") network_id = network_dict.get("uuid") if port_id is not None: return util.get_port(port_id, user_id, for_update=True) elif network_id is not None: address = network_dict.get("fixed_ip") network = util.get_network(network_id, user_id, non_deleted=True) if network.public: if network.subnet4 is not None: if not "fixed_ip" in network_dict: return create_public_ipv4_port(user_id, network) elif address is None: msg = "Cannot connect to public network" raise faults.BadRequest(msg % network.id) else: return create_public_ipv4_port(user_id, network, address) else: raise faults.Forbidden("Cannot connect to IPv6 only public" " network %" % network.id) else: return _create_port(user_id, network, address=address) else: raise faults.BadRequest("Network 'uuid' or 'port' attribute" " is required.")
def _port_from_setting(user_id, network_id, category): # TODO: Fix this..you need only IPv4 and only IPv6 network if network_id == "SNF:ANY_PUBLIC_IPV4": return create_public_ipv4_port(user_id, category=category) elif network_id == "SNF:ANY_PUBLIC_IPV6": return create_public_ipv6_port(user_id, category=category) elif network_id == "SNF:ANY_PUBLIC": try: return create_public_ipv4_port(user_id, category=category) except faults.Conflict as e1: try: return create_public_ipv6_port(user_id, category=category) except faults.Conflict as e2: log.error( "Failed to connect server to a public IPv4 or IPv6" " network. IPv4: %s, IPv6: %s", e1, e2) msg = ("Cannot connect server to a public IPv4 or IPv6" " network.") raise faults.Conflict(msg) else: # Case of network ID if category in ["user", "default"]: return _port_for_request(user_id, {"uuid": network_id}) elif category == "admin": network = util.get_network(network_id, user_id, non_deleted=True) return _create_port(user_id, network) else: raise ValueError("Unknown category: %s" % category)
def update_network_name(request, network_id): # Normal Response Code: 204 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # forbidden (403) # badMediaType(415), # itemNotFound (404), # overLimit (413) req = utils.get_request_dict(request) log.info('update_network_name %s', network_id) try: name = req['network']['name'] except (TypeError, KeyError): raise faults.BadRequest('Malformed request.') net = util.get_network(network_id, request.user_uniq) if net.public: raise faults.Forbidden('Can not rename the public network.') if net.deleted: raise faults.BadRequest("Network has been deleted.") net.name = name net.save() return HttpResponse(status=204)
def _port_for_request(user_id, network_dict): if not isinstance(network_dict, dict): raise faults.BadRequest("Malformed request. Invalid 'networks' field") port_id = network_dict.get("port") network_id = network_dict.get("uuid") if port_id is not None: return util.get_port(port_id, user_id, for_update=True) elif network_id is not None: address = network_dict.get("fixed_ip") network = util.get_network(network_id, user_id, non_deleted=True) if network.public: if network.subnet4 is not None: if not "fixed_ip" in network_dict: return create_public_ipv4_port(user_id, network) elif address is None: msg = "Cannot connect to public network" raise faults.BadRequest(msg % network.id) else: return create_public_ipv4_port(user_id, network, address) else: raise faults.Forbidden("Cannot connect to IPv6 only public" " network '%s'" % network.id) else: return _create_port(user_id, network, address=address) else: raise faults.BadRequest("Network 'uuid' or 'port' attribute" " is required.")
def delete_network(request, network_id): # Normal Response Code: 204 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # forbidden (403) # itemNotFound (404), # overLimit (413) log.info('delete_network %s', network_id) net = util.get_network(network_id, request.user_uniq, for_update=True) if net.public: raise faults.Forbidden('Can not delete the public network.') if net.deleted: raise faults.BadRequest("Network has been deleted.") if net.machines.all(): # Nics attached on network raise faults.NetworkInUse('Machines are connected to network.') net.action = 'DESTROY' net.save() backend_networks = net.backend_networks.exclude(operstate="DELETED") for bnet in backend_networks: backend.delete_network(net, bnet.backend) if not backend_networks: backend.update_network_state(net) return HttpResponse(status=204)
def allocate_floating_ip(request): """Allocate a floating IP.""" req = utils.get_json_body(request) floating_ip_dict = api.utils.get_attribute(req, "floatingip", required=True, attr_type=dict) userid = request.user_uniq project = floating_ip_dict.get("project", None) log.info('allocate_floating_ip user: %s request: %s', userid, req) # the network_pool is a mandatory field network_id = api.utils.get_attribute(floating_ip_dict, "floating_network_id", required=False, attr_type=(basestring, int)) if network_id is None: floating_ip = ips.create_floating_ip(userid, project=project) else: try: network_id = int(network_id) except ValueError: raise faults.BadRequest("Invalid networkd ID.") network = util.get_network(network_id, userid, for_update=True, non_deleted=True) address = api.utils.get_attribute(floating_ip_dict, "floating_ip_address", required=False, attr_type=basestring) floating_ip = ips.create_floating_ip(userid, network, address, project=project) log.info("User '%s' allocated floating IP '%s'", userid, floating_ip) request.serialization = "json" data = json.dumps({"floatingip": ip_to_dict(floating_ip)}) return HttpResponse(data, status=200)
def _port_from_setting(user_id, network_id, category): # TODO: Fix this..you need only IPv4 and only IPv6 network if network_id == "SNF:ANY_PUBLIC_IPV4": return create_public_ipv4_port(user_id, category=category) elif network_id == "SNF:ANY_PUBLIC_IPV6": return create_public_ipv6_port(user_id, category=category) elif network_id == "SNF:ANY_PUBLIC": try: return create_public_ipv4_port(user_id, category=category) except faults.Conflict as e1: try: return create_public_ipv6_port(user_id, category=category) except faults.Conflict as e2: log.error("Failed to connect server to a public IPv4 or IPv6" " network. IPv4: %s, IPv6: %s", e1, e2) msg = ("Cannot connect server to a public IPv4 or IPv6" " network.") raise faults.Conflict(msg) else: # Case of network ID if category in ["user", "default"]: return _port_for_request(user_id, {"uuid": network_id}) elif category == "admin": network = util.get_network(network_id, user_id, non_deleted=True) return _create_port(user_id, network) else: raise ValueError("Unknown category: %s" % category)
def rename(network_id, name, credentials): network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) if network.public: raise faults.Forbidden("Cannot rename the public network.") return _rename(network, name)
def undrain(network_id, credentials): if not credentials.is_admin: raise faults.Forbidden("Cannot unset network's drained flag.") network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) validate_network_action(network, "UNDRAIN") log.info("Undraining %s", network) network.drained = False network.save()
def update_network(request, network_id): info = api.utils.get_request_dict(request) network = api.utils.get_attribute(info, "network", attr_type=dict, required=True) new_name = api.utils.get_attribute(network, "name", attr_type=basestring) network = util.get_network(network_id, request.user_uniq, for_update=True) if network.public: raise api.faults.Forbidden("Cannot rename the public network.") network = networks.rename(network, new_name) return render_network(request, network_to_dict(network), 200)
def get_network_details(request, network_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('get_network_details %s', network_id) net = util.get_network(network_id, request.user_uniq) netdict = network_to_dict(net, request.user_uniq) return render_network(request, netdict)
def allocate_floating_ip(request): """Allocate a floating IP.""" req = utils.get_json_body(request) log.debug("User: %s, Action: create_floating_ip, Request: %s", request.user_uniq, req) floating_ip_dict = api.utils.get_attribute(req, "floatingip", required=True, attr_type=dict) userid = request.user_uniq project = floating_ip_dict.get("project", None) shared_to_project = floating_ip_dict.get("shared_to_project", False) # the network_pool is a mandatory field network_id = api.utils.get_attribute(floating_ip_dict, "floating_network_id", required=False, attr_type=(basestring, int)) if network_id is None: floating_ip = \ ips.create_floating_ip(userid, project=project, shared_to_project=shared_to_project) else: try: network_id = int(network_id) except ValueError: raise faults.BadRequest("Invalid networkd ID.") network = util.get_network(network_id, userid, request.user_projects, for_update=True, non_deleted=True) address = api.utils.get_attribute(floating_ip_dict, "floating_ip_address", required=False, attr_type=basestring) floating_ip = \ ips.create_floating_ip(userid, network, address, project=project, shared_to_project=shared_to_project) log.info("User %s created floating IP %s, network %s, address %s", userid, floating_ip.id, floating_ip.network_id, floating_ip.address) request.serialization = "json" data = json.dumps({"floatingip": ip_to_dict(floating_ip)}) return HttpResponse(data, status=200)
def network_action_demux(request, network_id): req = utils.get_json_body(request) network = util.get_network(network_id, request.user_uniq, for_update=True, non_deleted=True) action = req.keys()[0] try: f = NETWORK_ACTIONS[action] except KeyError: raise api.faults.BadRequest("Action %s not supported." % action) action_args = req[action] if not isinstance(action_args, dict): raise api.faults.BadRequest("Invalid argument.") return f(request, network, action_args)
def delete_network(request, network_id): network = util.get_network(network_id, request.user_uniq, request.user_projects, for_update=True, non_deleted=True) if network.public: raise api.faults.Forbidden("Cannot delete the public network.") log.debug("User: %s, Network: %s, Action: delete", request.user_uniq, network.id) networks.delete(network) log.info("User %s deleted network %s", request.user_uniq, network.id) return HttpResponse(status=204)
def list_addresses_by_network(request, server_id, network_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('list_addresses_by_network %s %s', server_id, network_id) machine = util.get_vm(server_id, request.user_uniq) network = util.get_network(network_id, request.user_uniq) nics = machine.nics.filter(network=network).all() addresses = nics_to_addresses(nics) if request.serialization == 'xml': data = render_to_string('address.xml', {'addresses': addresses}) else: data = json.dumps({'network': addresses}) return HttpResponse(data, status=200)
def list_addresses_by_network(request, server_id, network_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('list_addresses_by_network %s %s', server_id, network_id) machine = util.get_vm(server_id, request.user_uniq) network = util.get_network(network_id, request.user_uniq) nics = machine.nics.filter(network=network, state="ACTIVE") addresses = attachments_to_addresses(map(nic_to_attachments, nics)) if request.serialization == 'xml': data = render_to_string('address.xml', {'addresses': addresses}) else: data = json.dumps({'network': addresses}) return HttpResponse(data, status=200)
def network_action(request, network_id): req = utils.get_request_dict(request) log.debug('network_action %s %s', network_id, req) if len(req) != 1: raise faults.BadRequest('Malformed request.') net = util.get_network(network_id, request.user_uniq) if net.public: raise faults.Forbidden('Can not modify the public network.') if net.deleted: raise faults.BadRequest("Network has been deleted.") try: key = req.keys()[0] val = req[key] assert isinstance(val, dict) return network_actions[key](request, net, req[key]) except KeyError: raise faults.BadRequest('Unknown action.') except AssertionError: raise faults.BadRequest('Invalid argument.')
def list_addresses_by_network(request, server_id, network_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) credentials = request.credentials machine = util.get_vm(server_id, credentials) network = util.get_network(network_id, credentials) nics = machine.nics.filter(network=network, state="ACTIVE") addresses = attachments_to_addresses(map(nic_to_attachments, nics)) if request.serialization == 'xml': data = render_to_string('address.xml', {'addresses': addresses}) else: data = json.dumps({'network': addresses}) return HttpResponse(data, status=200)
def reassign(network_id, project, shared_to_project, credentials, atomic_context=None): network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) if network.public: raise faults.Forbidden("Cannot reassign public network") if not credentials.is_admin and credentials.userid != network.userid: raise faults.Forbidden("Action 'reassign' is allowed only to the owner" " of the network.") validate_network_action(network, "REASSIGN") if network.project == project: if network.shared_to_project != shared_to_project: log.info("%s network %s to project %s", "Sharing" if shared_to_project else "Unsharing", network, project) network.shared_to_project = shared_to_project network.save() else: action_fields = { "to_project": project, "from_project": network.project } log.info("Reassigning network %s from project %s to %s, shared: %s", network, network.project, project, shared_to_project) network.project = project network.shared_to_project = shared_to_project network.save() quotas.issue_and_accept_commission(network, action="REASSIGN", action_fields=action_fields, atomic_context=atomic_context) return network
def create_floating_ip(credentials, network_id=None, address=None, project=None, shared_to_project=False, atomic_context=None): userid = credentials.userid if network_id is None: floating_ip = allocate_public_ip(userid, floating_ip=True) else: network = util.get_network(network_id, credentials, for_update=True, non_deleted=True) if not network.floating_ip_pool: msg = ("Cannot allocate floating IP. Network %s is" " not a floating IP pool.") raise faults.Conflict(msg % network.id) if network.action == "DESTROY": msg = "Cannot allocate floating IP. Network %s is being deleted." raise faults.Conflict(msg % network.id) # Allocate the floating IP floating_ip = allocate_ip(network, userid, address=address, floating_ip=True) if project is None: project = userid floating_ip.project = project floating_ip.shared_to_project = shared_to_project floating_ip.save() # Issue commission (quotas) quotas.issue_and_accept_commission(floating_ip, atomic_context=atomic_context) log.info("Created floating IP '%s' for user IP '%s'", floating_ip, userid) return floating_ip
def update_network(request, network_id): info = api.utils.get_json_body(request) network = api.utils.get_attribute(info, "network", attr_type=dict, required=True) new_name = api.utils.get_attribute(network, "name", attr_type=basestring) network = util.get_network(network_id, request.user_uniq, request.user_projects, for_update=True, non_deleted=True) if network.public: raise api.faults.Forbidden("Cannot rename the public network.") network = networks.rename(network, new_name) log.info("User %s renamed network %s", request.user_uniq, network.id) return render_network(request, network_to_dict(network), 200)
def get_network_details(request, network_id): network = util.get_network(network_id, request.credentials) return render_network(request, network_to_dict(network, detail=True))
def get_network_details(request, network_id): log.debug('get_network_details %s', network_id) network = util.get_network(network_id, request.user_uniq) return render_network(request, network_to_dict(network, detail=True))
def create_port(request): user_id = request.user_uniq req = api.utils.get_json_body(request) log.info('create_port user: %s request: %s', user_id, req) port_dict = api.utils.get_attribute(req, "port", attr_type=dict) net_id = api.utils.get_attribute(port_dict, "network_id", attr_type=(basestring, int)) device_id = api.utils.get_attribute(port_dict, "device_id", required=False, attr_type=(basestring, int)) vm = None if device_id is not None: vm = util.get_vm(device_id, user_id, for_update=True, non_deleted=True, non_suspended=True) # Check if the request contains a valid IPv4 address fixed_ips = api.utils.get_attribute(port_dict, "fixed_ips", required=False, attr_type=list) if fixed_ips is not None and len(fixed_ips) > 0: if len(fixed_ips) > 1: msg = "'fixed_ips' attribute must contain only one fixed IP." raise faults.BadRequest(msg) fixed_ip = fixed_ips[0] if not isinstance(fixed_ip, dict): raise faults.BadRequest("Invalid 'fixed_ips' field.") fixed_ip_address = fixed_ip.get("ip_address") if fixed_ip_address is not None: try: ip = ipaddr.IPAddress(fixed_ip_address) if ip.version == 6: msg = "'ip_address' can be only an IPv4 address'" raise faults.BadRequest(msg) except ValueError: msg = "%s is not a valid IPv4 Address" % fixed_ip_address raise faults.BadRequest(msg) else: fixed_ip_address = None network = util.get_network(net_id, user_id, non_deleted=True, for_update=True) ipaddress = None if network.public: # Creating a port to a public network is only allowed if the user has # already a floating IP address in this network which is specified # as the fixed IP address of the port if fixed_ip_address is None: msg = ("'fixed_ips' attribute must contain a floating IP address" " in order to connect to a public network.") raise faults.BadRequest(msg) ipaddress = util.get_floating_ip_by_address(user_id, fixed_ip_address, for_update=True) elif fixed_ip_address: ipaddress = ips.allocate_ip(network, user_id, address=fixed_ip_address) name = api.utils.get_attribute(port_dict, "name", required=False, attr_type=basestring) if name is None: name = "" security_groups = api.utils.get_attribute(port_dict, "security_groups", required=False, attr_type=list) #validate security groups # like get security group from db sg_list = [] if security_groups: for gid in security_groups: try: sg = util.get_security_group(int(gid)) except (KeyError, ValueError): raise faults.BadRequest("Invalid 'security_groups' field.") sg_list.append(sg) new_port = servers.create_port(user_id, network, use_ipaddress=ipaddress, machine=vm, name=name) response = render_port(request, port_to_dict(new_port), status=201) return response
def get_network_details(request, network_id): network = util.get_network(network_id, request.user_uniq, request.user_projects) return render_network(request, network_to_dict(network, detail=True))
def create_port(request): user_id = request.user_uniq req = api.utils.get_json_body(request) log.debug("User: %s, Action: create_port, Request: %s", user_id, req) port_dict = api.utils.get_attribute(req, "port", attr_type=dict) net_id = api.utils.get_attribute(port_dict, "network_id", attr_type=(basestring, int)) device_id = api.utils.get_attribute(port_dict, "device_id", required=False, attr_type=(basestring, int)) vm = None if device_id is not None: vm = util.get_vm(device_id, user_id, request.user_projects, for_update=True, non_deleted=True, non_suspended=True) # Check if the request contains a valid IPv4 address fixed_ips = api.utils.get_attribute(port_dict, "fixed_ips", required=False, attr_type=list) if fixed_ips is not None and len(fixed_ips) > 0: if len(fixed_ips) > 1: msg = "'fixed_ips' attribute must contain only one fixed IP." raise faults.BadRequest(msg) fixed_ip = fixed_ips[0] if not isinstance(fixed_ip, dict): raise faults.BadRequest("Invalid 'fixed_ips' field.") fixed_ip_address = fixed_ip.get("ip_address") if fixed_ip_address is not None: try: ip = ipaddr.IPAddress(fixed_ip_address) if ip.version == 6: msg = "'ip_address' can be only an IPv4 address'" raise faults.BadRequest(msg) except ValueError: msg = "%s is not a valid IPv4 Address" % fixed_ip_address raise faults.BadRequest(msg) else: fixed_ip_address = None network = util.get_network(net_id, user_id, request.user_projects, non_deleted=True, for_update=True) ipaddress = None if network.public: # Creating a port to a public network is only allowed if the user has # already a floating IP address in this network which is specified # as the fixed IP address of the port if fixed_ip_address is None: msg = ("'fixed_ips' attribute must contain a floating IP address" " in order to connect to a public network.") raise faults.BadRequest(msg) ipaddress = util.get_floating_ip_by_address(user_id, request.user_projects, fixed_ip_address, for_update=True) elif fixed_ip_address: ipaddress = ips.allocate_ip(network, user_id, address=fixed_ip_address) name = api.utils.get_attribute(port_dict, "name", required=False, attr_type=basestring) if name is None: name = "" security_groups = api.utils.get_attribute(port_dict, "security_groups", required=False, attr_type=list) #validate security groups # like get security group from db sg_list = [] if security_groups: for gid in security_groups: try: sg = util.get_security_group(int(gid)) except (KeyError, ValueError): raise faults.BadRequest("Invalid 'security_groups' field.") sg_list.append(sg) new_port = servers.create_port(user_id, network, use_ipaddress=ipaddress, machine=vm, name=name) log.info("User %s created port %s, network: %s, machine: %s, ip: %s", user_id, new_port.id, network, vm, ipaddress) response = render_port(request, port_to_dict(new_port), status=201) return response