def update_snapshot(request, snapshot_id):
util.assert_snapshots_enabled(request)
req = utils.get_json_body(request)
log.debug("User: %s, Snapshot: %s Action: update", request.user_uniq,
snapshot_id)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
snap_dict = utils.get_attribute(req,
"snapshot",
attr_type=dict,
required=True)
new_name = utils.get_attribute(snap_dict,
"display_name",
required=False,
attr_type=basestring)
new_description = utils.get_attribute(snap_dict,
"display_description",
required=False,
attr_type=basestring)
if new_name is None and new_description is None:
raise faults.BadRequest("Nothing to update.")
snapshot = snapshots.update(snapshot,
name=new_name,
description=new_description)
log.info("User %s updated snapshot %s", request.user_uniq, snapshot["id"])
data = json.dumps({'snapshot': snapshot_to_dict(snapshot, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def update_server_name(request, server_id):
# Normal Response Code: 204
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# badMediaType(415),
# itemNotFound (404),
# buildInProgress (409),
# overLimit (413)
req = utils.get_json_body(request)
log.debug("User: %s, VM: %s, Action: rename, Request: %s",
request.user_uniq, server_id, req)
req = utils.get_attribute(req, "server", attr_type=dict, required=True)
name = utils.get_attribute(req, "name", attr_type=basestring,
required=True)
vm = util.get_vm(server_id, request.user_uniq, request.user_projects,
for_update=True, non_suspended=True, non_deleted=True)
servers.rename(vm, new_name=name)
log.info("User %s renamed server %s", request.user_uniq, vm.id)
return HttpResponse(status=204)
def update_server_name(request, server_id):
# Normal Response Code: 204
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# badMediaType(415),
# itemNotFound (404),
# buildInProgress (409),
# overLimit (413)
credentials = request.credentials
req = utils.get_json_body(request)
log.debug("User: %s, VM: %s, Action: rename, Request: %s",
credentials.userid, server_id, req)
req = utils.get_attribute(req, "server", attr_type=dict, required=True)
name = utils.get_attribute(req, "name", attr_type=basestring,
required=True)
servers.rename(server_id, new_name=name, credentials=credentials)
log.info("User %s renamed server %s", credentials.userid, server_id)
return HttpResponse(status=204)
def update_server_name(request, server_id):
# Normal Response Code: 204
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# badMediaType(415),
# itemNotFound (404),
# buildInProgress (409),
# overLimit (413)
credentials = request.credentials
req = utils.get_json_body(request)
log.debug("User: %s, VM: %s, Action: rename, Request: %s",
credentials.userid, server_id, req)
req = utils.get_attribute(req, "server", attr_type=dict, required=True)
name = utils.get_attribute(req,
"name",
attr_type=basestring,
required=True)
servers.rename(server_id, new_name=name, credentials=credentials)
log.info("User %s renamed server %s", credentials.userid, server_id)
return HttpResponse(status=204)
def update_volume(request, volume_id):
req = utils.get_json_body(request)
log.debug('update_volume volume_id: %s, request: %s', volume_id, req)
volume = util.get_volume(request.user_uniq, volume_id, for_update=True,
non_deleted=True)
vol_req = utils.get_attribute(req, "volume", attr_type=dict,
required=True)
name = utils.get_attribute(vol_req, "display_name", required=False)
description = utils.get_attribute(vol_req, "display_description",
required=False)
delete_on_termination = utils.get_attribute(vol_req,
"delete_on_termination",
attr_type=bool,
required=False)
if name is None and description is None and\
delete_on_termination is None:
raise faults.BadRequest("Nothing to update.")
else:
volume = volumes.update(volume, name, description,
delete_on_termination)
data = json.dumps({'volume': volume_to_dict(volume, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def update_snapshot(request, snapshot_id):
credentials = request.credentials
util.assert_snapshots_enabled(request)
req = utils.get_json_body(request)
log.debug("User: %s, Snapshot: %s Action: update",
credentials.userid, snapshot_id)
snapshot = util.get_snapshot(credentials.userid, snapshot_id)
snap_dict = utils.get_attribute(req, "snapshot", attr_type=dict,
required=True)
new_name = utils.get_attribute(snap_dict, "display_name", required=False,
attr_type=basestring)
new_description = utils.get_attribute(snap_dict, "display_description",
required=False, attr_type=basestring)
if new_name is None and new_description is None:
raise faults.BadRequest("Nothing to update.")
snapshot = snapshots.update(snapshot, name=new_name,
description=new_description)
log.info("User %s updated snapshot %s", credentials.userid, snapshot["id"])
data = json.dumps({'snapshot': snapshot_to_dict(snapshot, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def get_cyclades_stats(request):
images = True
backend = None
if request.body:
req = utils.get_request_dict(request)
req_stats = utils.get_attribute(req, "stats", required=True,
attr_type=dict)
# Check backend
backend_id = utils.get_attribute(req_stats, "backend", required=False,
attr_type=(basestring, int))
if backend_id is not None:
try:
try:
backend_id = int(backend_id)
backend = Backend.objects.get(id=backend_id)
except (ValueError, TypeError):
backend = Backend.objects.get(clustername=backend_id)
except Backend.DoesNotExist:
raise faults.BadRequest("Invalid backend '%s'" % backend_id)
include_images = utils.get_attribute(req_stats, "images",
required=False,
attr_type=bool)
if include_images is not None:
images = include_images
_stats = stats.get_cyclades_stats(backend=backend, clusters=True,
servers=True, resources=True,
networks=True, images=images)
data = json.dumps(_stats)
return http.HttpResponse(data, status=200, content_type='application/json')
def update_server_name(request, server_id):
# Normal Response Code: 204
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# badMediaType(415),
# itemNotFound (404),
# buildInProgress (409),
# overLimit (413)
req = utils.get_json_body(request)
log.info('update_server_name %s %s', server_id, req)
req = utils.get_attribute(req, "server", attr_type=dict, required=True)
name = utils.get_attribute(req,
"name",
attr_type=basestring,
required=True)
vm = util.get_vm(server_id,
request.user_uniq,
for_update=True,
non_suspended=True,
non_deleted=True)
servers.rename(vm, new_name=name)
return HttpResponse(status=204)
def update_volume(request, volume_id):
credentials = request.credentials
req = utils.get_json_body(request)
log.debug("User: %s, Volume: %s Action: update_volume, Request: %s",
credentials.userid, volume_id, req)
vol_req = utils.get_attribute(req, "volume", attr_type=dict,
required=True)
name = utils.get_attribute(vol_req, "display_name", required=False)
description = utils.get_attribute(vol_req, "display_description",
required=False)
delete_on_termination = utils.get_attribute(vol_req,
"delete_on_termination",
attr_type=bool,
required=False)
if name is None and description is None and\
delete_on_termination is None:
raise faults.BadRequest("Nothing to update.")
volume = volumes.update(volume_id, name, description,
delete_on_termination, credentials=credentials)
log.info("User %s updated volume %s", credentials.userid, volume_id)
data = json.dumps({'volume': volume_to_dict(volume, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def update_volume(request, volume_id):
req = utils.get_json_body(request)
log.debug("User: %s, Volume: %s Action: update_volume, Request: %s",
request.user_uniq, volume_id, req)
volume = util.get_volume(request.user_uniq,
request.user_projects,
volume_id,
for_update=True,
non_deleted=True)
vol_req = utils.get_attribute(req, "volume", attr_type=dict, required=True)
name = utils.get_attribute(vol_req, "display_name", required=False)
description = utils.get_attribute(vol_req,
"display_description",
required=False)
delete_on_termination = utils.get_attribute(vol_req,
"delete_on_termination",
attr_type=bool,
required=False)
if name is None and description is None and\
delete_on_termination is None:
raise faults.BadRequest("Nothing to update.")
else:
volume = volumes.update(volume, name, description,
delete_on_termination)
log.info("User %s updated volume %s", request.user_uniq, volume.id)
data = json.dumps({'volume': volume_to_dict(volume, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def demux_server_action(request, server_id):
credentials = request.credentials
req = utils.get_json_body(request)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
try:
action = req.keys()[0]
except IndexError:
raise faults.BadRequest("Malformed Request.")
log.debug("User: %s, VM: %s, Action: %s Request: %s", credentials.userid,
server_id, action, req)
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
if key_to_action(action) not in [x[0] for x in VirtualMachine.ACTIONS]:
if action not in ARBITRARY_ACTIONS:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req,
action,
required=False,
attr_type=dict)
return server_actions[action](request, server_id, action_args)
def update_metadata(request, server_id):
# Normal Response Code: 201
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# buildInProgress (409),
# badMediaType(415),
# overLimit (413)
req = utils.get_request_dict(request)
log.info('update_server_metadata %s %s', server_id, req)
vm = util.get_vm(server_id, request.user_uniq, non_suspended=True)
metadata = utils.get_attribute(req, "metadata", required=True,
attr_type=dict)
for key, val in metadata.items():
if not isinstance(key, (basestring, int)) or\
not isinstance(val, (basestring, int)):
raise faults.BadRequest("Malformed Request. Invalid metadata.")
meta, created = vm.metadata.get_or_create(meta_key=key)
meta.meta_value = val
meta.save()
vm.save()
vm_meta = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())
return util.render_metadata(request, vm_meta, status=201)
def demux_server_action(request, server_id):
req = utils.get_json_body(request)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
# Do not allow any action on deleted or suspended VMs
vm = util.get_vm(server_id, request.user_uniq, request.user_projects,
for_update=True, non_deleted=True, non_suspended=True)
try:
action = req.keys()[0]
except IndexError:
raise faults.BadRequest("Malformed Request.")
log.debug("User: %s, VM: %s, Action: %s Request: %s",
request.user_uniq, server_id, action, req)
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
if key_to_action(action) not in [x[0] for x in VirtualMachine.ACTIONS]:
if action not in ARBITRARY_ACTIONS:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req, action, required=True,
attr_type=dict)
return server_actions[action](request, vm, action_args)
def demux_server_action(request, server_id):
req = utils.get_json_body(request)
log.debug('server_action %s %s', server_id, req)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
# Do not allow any action on deleted or suspended VMs
vm = util.get_vm(server_id,
request.user_uniq,
for_update=True,
non_deleted=True,
non_suspended=True)
try:
action = req.keys()[0]
except IndexError:
raise faults.BadRequest("Malformed Request.")
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
if key_to_action(action) not in [x[0] for x in VirtualMachine.ACTIONS]:
if action not in ARBITRARY_ACTIONS:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req,
action,
required=True,
attr_type=dict)
return server_actions[action](request, vm, action_args)
def update_metadata(request, server_id):
# Normal Response Code: 201
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# buildInProgress (409),
# badMediaType(415),
# overLimit (413)
req = utils.get_json_body(request)
credentials = request.credentials
userid = credentials.userid
log.debug("User: %s, VM: %s, Action: update_metadata, Request: %s", userid,
server_id, req)
vm = util.get_vm(server_id,
credentials,
non_suspended=True,
non_deleted=True)
metadata = utils.get_attribute(req,
"metadata",
required=True,
attr_type=dict)
if len(metadata) + len(vm.metadata.all()) - \
len(vm.metadata.all().filter(meta_key__in=metadata.keys())) > \
settings.CYCLADES_VM_MAX_METADATA:
raise faults.BadRequest("Virtual Machines cannot have more than %s "
"metadata items" %
settings.CYCLADES_VM_MAX_METADATA)
for key, val in metadata.items():
if len(key) > VirtualMachineMetadata.KEY_LENGTH:
raise faults.BadRequest("Malformed Request. Metadata key is too"
" long")
if len(val) > VirtualMachineMetadata.VALUE_LENGTH:
raise faults.BadRequest("Malformed Request. Metadata value is too"
" long")
if not isinstance(key, (basestring, int)) or\
not isinstance(val, (basestring, int)):
raise faults.BadRequest("Malformed Request. Invalid metadata.")
meta, created = vm.metadata.get_or_create(meta_key=key)
meta.meta_value = val
meta.save()
vm.save()
log.info("User %s updated metadata of VM %s", userid, vm.id)
vm_meta = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())
return util.render_metadata(request, vm_meta, status=201)
def update_snapshot(request, snapshot_id):
req = utils.get_json_body(request)
log.debug('update_snapshot snapshot_id: %s, request: %s', snapshot_id, req)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
snap_dict = utils.get_attribute(req, "snapshot", attr_type=dict,
required=True)
new_name = utils.get_attribute(snap_dict, "display_name", required=False,
attr_type=basestring)
new_description = utils.get_attribute(snap_dict, "display_description",
required=False, attr_type=basestring)
if new_name is None and new_description is None:
raise faults.BadRequest("Nothing to update.")
snapshot = snapshots.update(snapshot, name=new_name,
description=new_description)
data = json.dumps({'snapshot': snapshot_to_dict(snapshot, detail=True)})
return HttpResponse(data, content_type="application/json", status=200)
def create_snapshot(request):
"""Create a new Snapshot."""
req = utils.get_json_body(request)
log.debug("create_snapshot %s", req)
user_id = request.user_uniq
snap_dict = utils.get_attribute(req, "snapshot", required=True,
attr_type=dict)
volume_id = utils.get_attribute(snap_dict, "volume_id", required=True)
volume = util.get_volume(user_id, volume_id, for_update=True,
non_deleted=True,
exception=faults.BadRequest)
metadata = utils.get_attribute(snap_dict, "metadata", required=False,
attr_type=dict, default={})
name = utils.get_attribute(snap_dict, "display_name", required=False,
attr_type=basestring,
default="Snapshot of volume '%s'" % volume_id)
description = utils.get_attribute(snap_dict, "display_description",
required=False,
attr_type=basestring, default="")
# TODO: What to do with force ?
force = utils.get_attribute(req, "force", required=False, attr_type=bool,
default=False)
snapshot = snapshots.create(user_id=user_id, volume=volume, name=name,
description=description, metadata=metadata,
force=force)
# Render response
data = json.dumps(dict(snapshot=snapshot_to_dict(snapshot, detail=False)))
return HttpResponse(data, status=202)
def update_volume_metadata(request, volume_id, reset=False):
req = utils.get_json_body(request)
log.debug("User: %s, Volume: %s Action: update_metadata, Request: %s",
request.user_uniq, volume_id, req)
meta_dict = utils.get_attribute(req,
"metadata",
required=True,
attr_type=dict)
for key, value in meta_dict.items():
check_name_length(key, VolumeMetadata.KEY_LENGTH,
"Metadata key is too long.")
check_name_length(value, VolumeMetadata.VALUE_LENGTH,
"Metadata value is too long.")
volume = util.get_volume(request.user_uniq,
request.user_projects,
volume_id,
for_update=True,
non_deleted=True)
if reset:
if len(meta_dict) > settings.CYCLADES_VOLUME_MAX_METADATA:
raise faults.BadRequest("Volumes cannot have more than %s metadata"
" items" %
settings.CYCLADES_VOLUME_MAX_METADATA)
volume.metadata.all().delete()
for key, value in meta_dict.items():
volume.metadata.create(key=key, value=value)
else:
if len(meta_dict) + len(volume.metadata.all()) - \
len(volume.metadata.all().filter(key__in=meta_dict.keys())) > \
settings.CYCLADES_VOLUME_MAX_METADATA:
raise faults.BadRequest("Volumes cannot have more than %s metadata"
" items" %
settings.CYCLADES_VOLUME_MAX_METADATA)
for key, value in meta_dict.items():
try:
# Update existing metadata
meta = volume.metadata.get(key=key)
meta.value = value
meta.save()
except VolumeMetadata.DoesNotExist:
# Or create a new one
volume.metadata.create(key=key, value=value)
log.info("User %s updated metadata for volume %s", request.user_uniq,
volume.id)
metadata = volume.metadata.values_list('key', 'value')
data = json.dumps({"metadata": dict(metadata)})
return HttpResponse(data, content_type="application/json", status=200)
def update_snapshot_metadata(request, snapshot_id, reset=False):
req = utils.get_json_body(request)
log.debug('update_snapshot_meta snapshot_id: %s, reset: %s request: %s',
snapshot_id, reset, req)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
meta_dict = utils.get_attribute(req, "metadata", required=True,
attr_type=dict)
with backend.PlanktonBackend(request.user_uniq) as b:
b.update_properties(snapshot_id, meta_dict, replace=reset)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
metadata = snapshot["properties"]
data = json.dumps({"metadata": dict(metadata)})
return HttpResponse(data, content_type="application/json", status=200)
def get_cyclades_stats(request):
images = True
backend = None
if request.body:
req = utils.get_request_dict(request)
req_stats = utils.get_attribute(req,
"stats",
required=True,
attr_type=dict)
# Check backend
backend_id = utils.get_attribute(req_stats,
"backend",
required=False,
attr_type=(basestring, int))
if backend_id is not None:
try:
try:
backend_id = int(backend_id)
backend = Backend.objects.get(id=backend_id)
except (ValueError, TypeError):
backend = Backend.objects.get(clustername=backend_id)
except Backend.DoesNotExist:
raise faults.BadRequest("Invalid backend '%s'" % backend_id)
include_images = utils.get_attribute(req_stats,
"images",
required=False,
attr_type=bool)
if include_images is not None:
images = include_images
_stats = stats.get_cyclades_stats(backend=backend,
clusters=True,
servers=True,
resources=True,
networks=True,
images=images)
data = json.dumps(_stats)
return http.HttpResponse(data, status=200, content_type='application/json')
def update_metadata(request, server_id):
# Normal Response Code: 201
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# buildInProgress (409),
# badMediaType(415),
# overLimit (413)
req = utils.get_json_body(request)
credentials = request.credentials
userid = credentials.userid
log.debug("User: %s, VM: %s, Action: update_metadata, Request: %s",
userid, server_id, req)
vm = util.get_vm(server_id, credentials, non_suspended=True,
non_deleted=True)
metadata = utils.get_attribute(req, "metadata", required=True,
attr_type=dict)
if len(metadata) + len(vm.metadata.all()) - \
len(vm.metadata.all().filter(meta_key__in=metadata.keys())) > \
settings.CYCLADES_VM_MAX_METADATA:
raise faults.BadRequest("Virtual Machines cannot have more than %s "
"metadata items" %
settings.CYCLADES_VM_MAX_METADATA)
for key, val in metadata.items():
if len(key) > VirtualMachineMetadata.KEY_LENGTH:
raise faults.BadRequest("Malformed Request. Metadata key is too"
" long")
if len(val) > VirtualMachineMetadata.VALUE_LENGTH:
raise faults.BadRequest("Malformed Request. Metadata value is too"
" long")
if not isinstance(key, (basestring, int)) or\
not isinstance(val, (basestring, int)):
raise faults.BadRequest("Malformed Request. Invalid metadata.")
meta, created = vm.metadata.get_or_create(meta_key=key)
meta.meta_value = val
meta.save()
vm.save()
log.info("User %s updated metadata of VM %s", userid, vm.id)
vm_meta = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())
return util.render_metadata(request, vm_meta, status=201)
def update_snapshot_metadata(request, snapshot_id, reset=False):
req = utils.get_json_body(request)
log.debug('update_snapshot_meta snapshot_id: %s, reset: %s request: %s',
snapshot_id, reset, req)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
meta_dict = utils.get_attribute(req,
"metadata",
required=True,
attr_type=dict)
with backend.PlanktonBackend(request.user_uniq) as b:
b.update_properties(snapshot_id, meta_dict, replace=reset)
snapshot = util.get_snapshot(request.user_uniq, snapshot_id)
metadata = snapshot["properties"]
data = json.dumps({"metadata": dict(metadata)})
return HttpResponse(data, content_type="application/json", status=200)
def update_snapshot_metadata(request, snapshot_id, reset=False):
credentials = request.credentials
util.assert_snapshots_enabled(request)
req = utils.get_json_body(request)
log.debug("User: %s, Snapshot: %s Action: update_metadata",
credentials.userid, snapshot_id)
snapshot = util.get_snapshot(credentials.userid, snapshot_id)
meta_dict = utils.get_attribute(req, "metadata", required=True,
attr_type=dict)
with backend.PlanktonBackend(credentials.userid) as b:
b.update_properties(snapshot_id, meta_dict, replace=reset)
snapshot = util.get_snapshot(credentials.userid, snapshot_id)
metadata = snapshot["properties"]
data = json.dumps({"metadata": dict(metadata)})
return HttpResponse(data, content_type="application/json", status=200)
def update_server_name(request, server_id):
# Normal Response Code: 204
# Error Response Codes: computeFault (400, 500),
# serviceUnavailable (503),
# unauthorized (401),
# badRequest (400),
# badMediaType(415),
# itemNotFound (404),
# buildInProgress (409),
# overLimit (413)
req = utils.get_request_dict(request)
log.info('update_server_name %s %s', server_id, req)
req = utils.get_attribute(req, "server", attr_type=dict, required=True)
name = utils.get_attribute(req, "name", attr_type=basestring,
required=True)
vm = util.get_vm(server_id, request.user_uniq, for_update=True,
non_suspended=True)
servers.rename(vm, new_name=name)
return HttpResponse(status=204)
def update_volume_metadata(request, volume_id, reset=False):
credentials = request.credentials
req = utils.get_json_body(request)
log.debug("User: %s, Volume: %s Action: update_metadata, Request: %s",
credentials.userid, volume_id, req)
meta_dict = utils.get_attribute(req, "metadata", required=True,
attr_type=dict)
for key, value in meta_dict.items():
check_name_length(key, VolumeMetadata.KEY_LENGTH,
"Metadata key is too long.")
check_name_length(value, VolumeMetadata.VALUE_LENGTH,
"Metadata value is too long.")
volume = util.get_volume(request.credentials,
volume_id, for_update=True, non_deleted=True)
if reset:
if len(meta_dict) > settings.CYCLADES_VOLUME_MAX_METADATA:
raise faults.BadRequest("Volumes cannot have more than %s metadata"
" items" %
settings.CYCLADES_VOLUME_MAX_METADATA)
volume.metadata.all().delete()
for key, value in meta_dict.items():
volume.metadata.create(key=key, value=value)
else:
if len(meta_dict) + len(volume.metadata.all()) - \
len(volume.metadata.all().filter(key__in=meta_dict.keys())) > \
settings.CYCLADES_VOLUME_MAX_METADATA:
raise faults.BadRequest("Volumes cannot have more than %s metadata"
" items" %
settings.CYCLADES_VOLUME_MAX_METADATA)
for key, value in meta_dict.items():
try:
# Update existing metadata
meta = volume.metadata.get(key=key)
meta.value = value
meta.save()
except VolumeMetadata.DoesNotExist:
# Or create a new one
volume.metadata.create(key=key, value=value)
log.info("User %s updated metadata for volume %s", credentials.userid,
volume.id)
metadata = volume.metadata.values_list('key', 'value')
data = json.dumps({"metadata": dict(metadata)})
return HttpResponse(data, content_type="application/json", status=200)
def create_snapshot(request):
"""Create a new Snapshot."""
util.assert_snapshots_enabled(request)
req = utils.get_json_body(request)
user_id = request.user_uniq
log.debug("User: %s, Action: create_snapshot, Request: %s", user_id, req)
snap_dict = utils.get_attribute(req,
"snapshot",
required=True,
attr_type=dict)
volume_id = utils.get_attribute(snap_dict, "volume_id", required=True)
volume = util.get_volume(user_id,
request.user_projects,
volume_id,
for_update=True,
non_deleted=True,
exception=faults.BadRequest)
metadata = utils.get_attribute(snap_dict,
"metadata",
required=False,
attr_type=dict,
default={})
name = utils.get_attribute(snap_dict,
"display_name",
required=False,
attr_type=basestring,
default="Snapshot of volume '%s'" % volume_id)
description = utils.get_attribute(snap_dict,
"display_description",
required=False,
attr_type=basestring,
default="")
# TODO: What to do with force ?
force = utils.get_attribute(req,
"force",
required=False,
attr_type=bool,
default=False)
snapshot = snapshots.create(user_id=user_id,
volume=volume,
name=name,
description=description,
metadata=metadata,
force=force)
log.info("User %s created snapshot %s", user_id, snapshot["id"])
# Render response
data = json.dumps(dict(snapshot=snapshot_to_dict(snapshot, detail=False)))
return HttpResponse(data, status=202)
def volume_action_demux(request, volume_id):
req = utils.get_json_body(request)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
action = req.keys()[0]
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
try:
action_func = VOLUME_ACTIONS[action]
except KeyError:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req, action, required=True,
attr_type=dict)
return action_func(request, volume_id, action_args)
def volume_action_demux(request, volume_id):
req = utils.get_json_body(request)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
action = req.keys()[0]
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
try:
action_func = VOLUME_ACTIONS[action]
except KeyError:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req,
action,
required=True,
attr_type=dict)
return action_func(request, volume_id, action_args)
def demux_server_action(request, server_id):
credentials = request.credentials
req = utils.get_json_body(request)
if not isinstance(req, dict) and len(req) != 1:
raise faults.BadRequest("Malformed request")
try:
action = req.keys()[0]
except IndexError:
raise faults.BadRequest("Malformed Request.")
log.debug("User: %s, VM: %s, Action: %s Request: %s",
credentials.userid, server_id, action, req)
if not isinstance(action, basestring):
raise faults.BadRequest("Malformed Request. Invalid action.")
if key_to_action(action) not in [x[0] for x in VirtualMachine.ACTIONS]:
if action not in ARBITRARY_ACTIONS:
raise faults.BadRequest("Action %s not supported" % action)
action_args = utils.get_attribute(req, action, required=False,
attr_type=dict)
return server_actions[action](request, server_id, action_args)
def create_snapshot(request):
"""Create a new Snapshot."""
util.assert_snapshots_enabled(request)
req = utils.get_json_body(request)
credentials = request.credentials
user_id = credentials.userid
log.debug("User: %s, Action: create_snapshot, Request: %s", user_id, req)
snap_dict = utils.get_attribute(req, "snapshot", required=True,
attr_type=dict)
volume_id = utils.get_attribute(snap_dict, "volume_id", required=True)
metadata = utils.get_attribute(snap_dict, "metadata", required=False,
attr_type=dict, default={})
name = utils.get_attribute(snap_dict, "display_name", required=False,
attr_type=basestring,
default="Snapshot of volume '%s'" % volume_id)
description = utils.get_attribute(snap_dict, "display_description",
required=False,
attr_type=basestring, default="")
# TODO: What to do with force ?
force = utils.get_attribute(req, "force", required=False, attr_type=bool,
default=False)
snapshot = snapshots.create(user_id=user_id, volume_id=volume_id,
name=name,
description=description, metadata=metadata,
force=force, credentials=credentials)
log.info("User %s created snapshot %s", user_id, snapshot["id"])
# Render response
data = json.dumps(dict(snapshot=snapshot_to_dict(snapshot, detail=False)))
return HttpResponse(data, status=202)
def create_volume(request):
"""Create a new Volume."""
req = utils.get_json_body(request)
user_id = request.user_uniq
log.debug("User: %s, Action: create_volume, Request: %s", user_id, req)
vol_dict = utils.get_attribute(req,
"volume",
attr_type=dict,
required=True)
name = utils.get_attribute(vol_dict,
"display_name",
attr_type=basestring,
required=True)
# Get and validate 'size' parameter
size = utils.get_attribute(vol_dict,
"size",
attr_type=(basestring, int),
required=True)
try:
size = int(size)
if size <= 0:
raise ValueError
except (TypeError, ValueError):
raise faults.BadRequest("Volume 'size' needs to be a positive integer"
" value. '%s' cannot be accepted." % size)
project = vol_dict.get("project")
if project is None:
project = user_id
shared_to_project = vol_dict.get("shared_to_project", False)
# Optional parameters
volume_type_id = utils.get_attribute(vol_dict,
"volume_type",
attr_type=(basestring, int),
required=False)
description = utils.get_attribute(vol_dict,
"display_description",
attr_type=basestring,
required=False,
default="")
metadata = utils.get_attribute(vol_dict,
"metadata",
attr_type=dict,
required=False,
default={})
# Id of the volume to clone from
source_volume_id = utils.get_attribute(vol_dict,
"source_volid",
required=False)
# Id of the snapshot to create the volume from
source_snapshot_id = utils.get_attribute(vol_dict,
"snapshot_id",
required=False)
snapshots_enabled = util.snapshots_enabled_for_user(request.user)
if source_snapshot_id and not snapshots_enabled:
raise faults.NotImplemented("Making a clone from a snapshot is not"
" implemented")
# Reference to an Image stored in Glance
source_image_id = utils.get_attribute(vol_dict, "imageRef", required=False)
# Get server ID to attach the volume.
server_id = utils.get_attribute(vol_dict, "server_id", required=False)
server = None
if server_id:
try:
server = get_vm(server_id,
user_id,
request.user_projects,
for_update=True,
non_deleted=True)
except faults.ItemNotFound:
raise faults.BadRequest("Server %s not found" % server_id)
# Create the volume
volume = volumes.create(user_id=user_id,
size=size,
name=name,
source_volume_id=source_volume_id,
source_snapshot_id=source_snapshot_id,
source_image_id=source_image_id,
volume_type_id=volume_type_id,
description=description,
metadata=metadata,
server=server,
project_id=project,
shared_to_project=shared_to_project)
server_id = server.id if server else None
log.info("User %s created volume %s attached to server %s, shared: %s",
user_id, volume.id, server_id, shared_to_project)
# Render response
data = json.dumps(dict(volume=volume_to_dict(volume, detail=False)))
return HttpResponse(data, status=202)
def create_volume(request):
"""Create a new Volume."""
req = utils.get_json_body(request)
log.debug("create_volume %s", req)
user_id = request.user_uniq
vol_dict = utils.get_attribute(req,
"volume",
attr_type=dict,
required=True)
name = utils.get_attribute(vol_dict,
"display_name",
attr_type=basestring,
required=True)
# Get and validate 'size' parameter
size = utils.get_attribute(vol_dict,
"size",
attr_type=(basestring, int),
required=True)
try:
size = int(size)
if size <= 0:
raise ValueError
except (TypeError, ValueError):
raise faults.BadRequest("Volume 'size' needs to be a positive integer"
" value. '%s' cannot be accepted." % size)
project = vol_dict.get("project")
if project is None:
project = user_id
# Optional parameters
volume_type_id = utils.get_attribute(vol_dict,
"volume_type",
attr_type=(basestring, int),
required=False)
description = utils.get_attribute(vol_dict,
"display_description",
attr_type=basestring,
required=False,
default="")
metadata = utils.get_attribute(vol_dict,
"metadata",
attr_type=dict,
required=False,
default={})
# Id of the volume to clone from
source_volume_id = utils.get_attribute(vol_dict,
"source_volid",
required=False)
# Id of the snapshot to create the volume from
source_snapshot_id = utils.get_attribute(vol_dict,
"snapshot_id",
required=False)
if source_snapshot_id and not settings.CYCLADES_SNAPSHOTS_ENABLED:
raise faults.NotImplemented("Making a clone from a snapshot is not"
" implemented")
# Reference to an Image stored in Glance
source_image_id = utils.get_attribute(vol_dict, "imageRef", required=False)
# Get server ID to attach the volume. Since we currently do not supported
# detached volumes, server_id attribute is mandatory.
server_id = utils.get_attribute(vol_dict, "server_id", required=True)
# Create the volume
volume = volumes.create(user_id=user_id,
size=size,
name=name,
source_volume_id=source_volume_id,
source_snapshot_id=source_snapshot_id,
source_image_id=source_image_id,
volume_type_id=volume_type_id,
description=description,
metadata=metadata,
server_id=server_id,
project=project)
# Render response
data = json.dumps(dict(volume=volume_to_dict(volume, detail=False)))
return HttpResponse(data, status=202)
def create_volume(request):
"""Create a new Volume."""
req = utils.get_json_body(request)
log.debug("create_volume %s", req)
user_id = request.user_uniq
vol_dict = utils.get_attribute(req, "volume", attr_type=dict,
required=True)
name = utils.get_attribute(vol_dict, "display_name",
attr_type=basestring, required=True)
# Get and validate 'size' parameter
size = utils.get_attribute(vol_dict, "size",
attr_type=(basestring, int), required=True)
try:
size = int(size)
if size <= 0:
raise ValueError
except (TypeError, ValueError):
raise faults.BadRequest("Volume 'size' needs to be a positive integer"
" value. '%s' cannot be accepted." % size)
project = vol_dict.get("project")
if project is None:
project = user_id
# Optional parameters
volume_type_id = utils.get_attribute(vol_dict, "volume_type",
attr_type=(basestring, int),
required=False)
description = utils.get_attribute(vol_dict, "display_description",
attr_type=basestring, required=False,
default="")
metadata = utils.get_attribute(vol_dict, "metadata", attr_type=dict,
required=False, default={})
# Id of the volume to clone from
source_volume_id = utils.get_attribute(vol_dict, "source_volid",
required=False)
# Id of the snapshot to create the volume from
source_snapshot_id = utils.get_attribute(vol_dict, "snapshot_id",
required=False)
if source_snapshot_id and not settings.CYCLADES_SNAPSHOTS_ENABLED:
raise faults.NotImplemented("Making a clone from a snapshot is not"
" implemented")
# Reference to an Image stored in Glance
source_image_id = utils.get_attribute(vol_dict, "imageRef", required=False)
# Get server ID to attach the volume. Since we currently do not supported
# detached volumes, server_id attribute is mandatory.
server_id = utils.get_attribute(vol_dict, "server_id", required=True)
# Create the volume
volume = volumes.create(user_id=user_id, size=size, name=name,
source_volume_id=source_volume_id,
source_snapshot_id=source_snapshot_id,
source_image_id=source_image_id,
volume_type_id=volume_type_id,
description=description,
metadata=metadata,
server_id=server_id, project=project)
# Render response
data = json.dumps(dict(volume=volume_to_dict(volume, detail=False)))
return HttpResponse(data, status=202)
def create_volume(request):
"""Create a new Volume."""
req = utils.get_json_body(request)
credentials = request.credentials
user_id = credentials.userid
log.debug("User: %s, Action: create_volume, Request: %s",
user_id, req)
vol_dict = utils.get_attribute(req, "volume", attr_type=dict,
required=True)
name = utils.get_attribute(vol_dict, "display_name",
attr_type=basestring, required=True)
# Get and validate 'size' parameter
size = utils.get_attribute(vol_dict, "size",
attr_type=(basestring, int), required=True)
try:
size = int(size)
if size <= 0:
raise ValueError
except (TypeError, ValueError):
raise faults.BadRequest("Volume 'size' needs to be a positive integer"
" value. '%s' cannot be accepted." % size)
project = vol_dict.get("project")
if project is None:
project = user_id
shared_to_project= vol_dict.get("shared_to_project", False)
# Optional parameters
volume_type_id = utils.get_attribute(vol_dict, "volume_type",
attr_type=(basestring, int),
required=False)
description = utils.get_attribute(vol_dict, "display_description",
attr_type=basestring, required=False,
default="")
metadata = utils.get_attribute(vol_dict, "metadata", attr_type=dict,
required=False, default={})
# Id of the volume to clone from
source_volume_id = utils.get_attribute(vol_dict, "source_volid",
required=False)
# Id of the snapshot to create the volume from
source_snapshot_id = utils.get_attribute(vol_dict, "snapshot_id",
required=False)
snapshots_enabled = util.snapshots_enabled_for_user(request.user)
if source_snapshot_id and not snapshots_enabled:
raise faults.NotImplemented("Making a clone from a snapshot is not"
" implemented")
# Reference to an Image stored in Glance
source_image_id = utils.get_attribute(vol_dict, "imageRef", required=False)
# Get server ID to attach the volume.
server_id = utils.get_attribute(vol_dict, "server_id", required=False)
# Create the volume
volume = volumes.create(credentials, size=size, name=name,
source_volume_id=source_volume_id,
source_snapshot_id=source_snapshot_id,
source_image_id=source_image_id,
volume_type_id=volume_type_id,
description=description,
metadata=metadata,
server_id=server_id, project_id=project,
shared_to_project=shared_to_project)
log.info("User %s created volume %s attached to server %s, shared: %s",
user_id, volume.id, server_id, shared_to_project)
# Render response
data = json.dumps(dict(volume=volume_to_dict(volume, detail=False)))
return HttpResponse(data, status=202)
