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 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 _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 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 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 _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 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 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 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 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 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 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 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 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 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):
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 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
