def get(self, request, provider_uuid, identity_uuid):
"""
Retrieves list of volumes and updates the DB
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
volume_list_method = esh_driver.list_volumes
if AccountProvider.objects.filter(identity__uuid=identity_uuid):
# Instance list method changes when using the OPENSTACK provider
volume_list_method = esh_driver.list_all_volumes
try:
esh_volume_list = volume_list_method()
except MalformedResponseError:
return malformed_response(provider_id, identity_id)
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_volume_list = [convert_esh_volume(volume, provider_uuid,
identity_uuid, user)
for volume in esh_volume_list]
serializer = VolumeSerializer(core_volume_list,
context={'request': request}, many=True)
response = Response(serializer.data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
try:
request_user = request.user
logger.debug("filtered_machine_list")
filtered_machine_list = provider_filtered_machines(
request, provider_uuid, identity_uuid, request_user)
logger.debug(filtered_machine_list)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except Exception as e:
logger.exception("Unexpected exception for user:%s" % request_user)
return failure_response(status.HTTP_500_INTERNAL_SERVER_ERROR,
e.message)
logger.debug(filtered_machine_list)
serialized_data = ProviderMachineSerializer(filtered_machine_list,
request_user=request.user,
many=True).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
# TODO: Decide how we should pass this in (I.E. GET query string?)
active = False
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_size_list = esh_driver.list_sizes()
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
all_size_list = [convert_esh_size(size, provider_uuid)
for size in esh_size_list]
if active:
all_size_list = [s for s in all_size_list if s.active()]
serialized_data = ProviderSizeSerializer(all_size_list, many=True).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
"""
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_snapshots = esh_driver._connection.ex_list_snapshots()
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
snapshot_data = []
for ss in esh_snapshots:
snapshot_data.append({
'id': ss.id,
'name': ss.extra['name'],
'size': ss.size,
'description': ss.extra['description'],
'created': ss.extra['created'],
'status': ss.extra['status'],
'volume_id': ss.extra['volume_id'], })
response = Response(snapshot_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Retrieves list of volumes and updates the DB
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
volume_list_method = esh_driver.list_volumes
if AccountProvider.objects.filter(identity__uuid=identity_uuid):
# Instance list method changes when using the OPENSTACK provider
volume_list_method = esh_driver.list_all_volumes
try:
esh_volume_list = volume_list_method()
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception:
logger.exception("Uncaught Exception in Volume list method")
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume list method failed. Contact support')
core_volume_list = [convert_esh_volume(volume, provider_uuid,
identity_uuid, user)
for volume in esh_volume_list]
serializer = VolumeSerializer(core_volume_list,
context={'request': request}, many=True)
response = Response(serializer.data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
identity = Identity.objects.get(uuid=identity_uuid)
try:
esh_instance_list = get_cached_instances(identity=identity)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
core_instance_list = [convert_esh_instance(esh_driver,
inst,
provider_uuid,
identity_uuid,
user)
for inst in esh_instance_list]
# TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={"request": request},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_uuid, identity_uuid):
"""
"""
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_snapshots = esh_driver._connection.ex_list_snapshots()
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
snapshot_data = []
for ss in esh_snapshots:
snapshot_data.append({
'id': ss.id,
'name': ss.extra['name'],
'size': ss.size,
'description': ss.extra['description'],
'created': ss.extra['created'],
'status': ss.extra['status'],
'volume_id': ss.extra['volume_id'], })
response = Response(snapshot_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
"""
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_snapshots = esh_driver._connection.ex_list_snapshots()
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
snapshot_data = []
for ss in esh_snapshots:
snapshot_data.append({
'id': ss.id,
'name': ss.extra['name'],
'size': ss.size,
'description': ss.extra['description'],
'created': ss.extra['created'],
'status': ss.extra['status'],
'volume_id': ss.extra['volume_id'],
})
response = Response(snapshot_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Retrieves list of volumes and updates the DB
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
volume_list_method = esh_driver.list_volumes
if AccountProvider.objects.filter(identity__uuid=identity_uuid):
# Instance list method changes when using the OPENSTACK provider
volume_list_method = esh_driver.list_all_volumes
try:
esh_volume_list = volume_list_method()
except MalformedResponseError:
return malformed_response(provider_id, identity_id)
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_volume_list = [
convert_esh_volume(volume, provider_uuid, identity_uuid, user)
for volume in esh_volume_list
]
serializer = VolumeSerializer(core_volume_list,
context={'request': request},
many=True)
response = Response(serializer.data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
"""
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_snapshots = esh_driver._connection.ex_list_snapshots()
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
snapshot_data = []
for ss in esh_snapshots:
snapshot_data.append({
'id': ss.id,
'name': ss.extra['name'],
'size': ss.size,
'description': ss.extra['description'],
'created': ss.extra['created'],
'status': ss.extra['status'],
'volume_id': ss.extra['volume_id'], })
response = Response(snapshot_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
identity = Identity.objects.get(uuid=identity_uuid)
try:
esh_instance_list = get_cached_instances(identity=identity)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
core_instance_list = [convert_esh_instance(esh_driver,
inst,
provider_uuid,
identity_uuid,
user)
for inst in esh_instance_list]
# TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={"request": request},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
# TODO: Decide how we should pass this in (I.E. GET query string?)
active = False
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_size_list = esh_driver.list_sizes()
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
all_size_list = [convert_esh_size(size, provider_uuid)
for size in esh_size_list]
if active:
all_size_list = [s for s in all_size_list if s.active()]
serialized_data = ProviderSizeSerializer(all_size_list, many=True).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
try:
request_user = request.user
logger.debug("filtered_machine_list")
filtered_machine_list = provider_filtered_machines(request,
provider_uuid,
identity_uuid,
request_user)
#logger.debug(filtered_machine_list)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except Exception as e:
logger.exception("Unexpected exception for user:%s"
% request_user)
return failure_response(status.HTTP_500_INTERNAL_SERVER_ERROR,
e.message)
#logger.debug(filtered_machine_list)
serialized_data = ProviderMachineSerializer(filtered_machine_list,
request_user=request.user,
many=True).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
# TODO: Decide how we should pass this in (I.E. GET query string?)
active = False
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(status.HTTP_409_CONFLICT, e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_size_list = esh_driver.list_sizes()
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
all_size_list = [
convert_esh_size(size, provider_uuid) for size in esh_size_list
]
if active:
all_size_list = [s for s in all_size_list if s.active()]
serialized_data = ProviderSizeSerializer(all_size_list, many=True).data
response = Response(serialized_data)
return response
def post(self, request, provider_uuid, identity_uuid):
"""
Creates a new volume and adds it to the DB
"""
user = request.user
driver = prepare_driver(request, provider_uuid, identity_uuid)
if not driver:
return invalid_creds(provider_uuid, identity_uuid)
data = request.data
missing_keys = valid_volume_post_data(data)
if missing_keys:
return keys_not_found(missing_keys)
# Pass arguments
name = data.get('name')
size = data.get('size')
# Optional fields
description = data.get('description')
image_id = data.get('image')
if image_id:
image = driver.get_machine(image_id)
image_size = image._connection.get_size(image._image)
if int(size) > image_size + 4:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Volumes created from images cannot exceed "
"more than 4GB greater than the size of "
"the image: %s GB" % image_size)
else:
image = None
snapshot_id = data.get('snapshot')
if snapshot_id:
snapshot = driver._connection.ex_get_snapshot(image_id)
else:
snapshot = None
try:
success, esh_volume = create_volume(driver, identity_uuid,
name, size, description,
snapshot=snapshot, image=image)
except OverQuotaError as oqe:
return over_quota(oqe)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
if not success:
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume creation failed. Contact support')
# Volume creation succeeded
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
return Response(serialized_data, status=status.HTTP_201_CREATED)
def get(self, request, provider_uuid, identity_uuid):
"""
Retrieves list of volumes and updates the DB
"""
user = request.user
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
volume_list_method = esh_driver.list_volumes
if AccountProvider.objects.filter(identity__uuid=identity_uuid):
# Instance list method changes when using the OPENSTACK provider
volume_list_method = esh_driver.list_all_volumes
try:
esh_volume_list = volume_list_method()
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception:
logger.exception("Uncaught Exception in Volume list method")
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume list method failed. Contact support')
core_volume_list = [convert_esh_volume(volume, provider_uuid,
identity_uuid, user)
for volume in esh_volume_list]
serializer = VolumeSerializer(core_volume_list,
context={'request': request}, many=True)
response = Response(serializer.data)
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Returns a list of all instances
"""
user = request.user
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
identity = Identity.objects.get(uuid=identity_uuid)
# Probably redundant
if not user.can_use_identity(identity.id):
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance_list = get_cached_instances(identity=identity)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
core_instance_list = [convert_esh_instance(esh_driver,
inst,
provider_uuid,
identity_uuid,
user)
for inst in esh_instance_list]
# TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={"request": request},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_uuid, identity_uuid):
"""
Returns a list of all instances
"""
user = request.user
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(status.HTTP_409_CONFLICT, e.message)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
identity = Identity.objects.get(uuid=identity_uuid)
# Probably redundant
if not user.can_use_identity(identity.id):
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance_list = get_cached_instances(identity=identity)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
core_instance_list = [
convert_esh_instance(esh_driver, inst, provider_uuid,
identity_uuid, user)
for inst in esh_instance_list
]
# TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={
"request": request
},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def post(self, request, provider_uuid, identity_uuid):
"""
Creates a new volume and adds it to the DB
"""
user = request.user
try:
membership = IdentityMembership.objects.get(
identity__uuid=identity_uuid,
member__memberships__user=user)
except:
return failure_response(
status.HTTP_409_CONFLICT,
"Identity %s is invalid -OR- User %s does not have the appropriate IdentityMembership." % (identity_uuid, user))
try:
driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not driver:
return invalid_creds(provider_uuid, identity_uuid)
data = request.data
missing_keys = valid_volume_post_data(data)
if missing_keys:
return keys_not_found(missing_keys)
# Pass arguments
name = data.get('name')
size = data.get('size')
# Optional fields
description = data.get('description')
image_id = data.get('image')
if image_id:
image = driver.get_machine(image_id)
image_size = image._connection.get_size(image._image)
if int(size) > image_size + 4:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Volumes created from images cannot exceed "
"more than 4GB greater than the size of "
"the image: %s GB" % image_size)
else:
image = None
snapshot_id = data.get('snapshot')
if snapshot_id:
snapshot = driver._connection.ex_get_snapshot(image_id)
else:
snapshot = None
try:
success, esh_volume = create_esh_volume(driver, user.username, identity_uuid,
name, size, description,
snapshot=snapshot, image=image)
except BaseHTTPError as http_error:
if 'Requested volume or snapshot exceed' in http_error.message:
return over_quota(http_error)
return failure_response(status.HTTP_400_BAD_REQUEST, http_error.message)
except OverQuotaError as oqe:
return over_quota(oqe)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
if not success:
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume creation failed. Contact support')
# Volume creation succeeded
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
return Response(serialized_data, status=status.HTTP_201_CREATED)
image = None
snapshot_id = data.get('snapshot')
if snapshot_id:
snapshot = driver._connection.ex_get_snapshot(image_id)
else:
snapshot = None
try:
success, esh_volume = create_volume(driver, identity_uuid,
name, size, description,
snapshot=snapshot, image=image)
except OverQuotaError, oqe:
return over_quota(oqe)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
if not success:
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume creation failed. Contact support')
# Volume creation succeeded
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
return Response(serialized_data, status=status.HTTP_201_CREATED)
class Volume(APIView):
def post(self, request, provider_uuid, identity_uuid):
"""
Creates a new volume and adds it to the DB
"""
user = request.user
try:
membership = IdentityMembership.objects.get(
identity__uuid=identity_uuid,
member__name=user.username)
except:
return failure_response(
status.HTTP_409_CONFLICT,
"Identity %s is invalid -OR- User %s does not have the appropriate IdentityMembership." % (identity_uuid, user))
try:
driver = prepare_driver(request, provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except Exception as e:
return failure_response(
status.HTTP_409_CONFLICT,
e.message)
if not driver:
return invalid_creds(provider_uuid, identity_uuid)
data = request.data
missing_keys = valid_volume_post_data(data)
if missing_keys:
return keys_not_found(missing_keys)
# Pass arguments
name = data.get('name')
size = data.get('size')
# Optional fields
description = data.get('description')
image_id = data.get('image')
if image_id:
image = driver.get_machine(image_id)
image_size = image._connection.get_size(image._image)
if int(size) > image_size + 4:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Volumes created from images cannot exceed "
"more than 4GB greater than the size of "
"the image: %s GB" % image_size)
else:
image = None
snapshot_id = data.get('snapshot')
if snapshot_id:
snapshot = driver._connection.ex_get_snapshot(image_id)
else:
snapshot = None
try:
success, esh_volume = create_esh_volume(driver, user.username, identity_uuid,
name, size, description,
snapshot=snapshot, image=image)
except BaseHTTPError as http_error:
if 'Requested volume or snapshot exceed' in http_error.message:
return over_quota(http_error)
return failure_response(status.HTTP_400_BAD_REQUEST, http_error.message)
except OverQuotaError as oqe:
return over_quota(oqe)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
if not success:
return failure_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume creation failed. Contact support')
# Volume creation succeeded
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
return Response(serialized_data, status=status.HTTP_201_CREATED)
else:
snapshot = None
try:
success, esh_volume = create_volume(driver,
identity_uuid,
name,
size,
description,
snapshot=snapshot,
image=image)
except OverQuotaError, oqe:
return over_quota(oqe)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except MalformedResponseError:
return malformed_response(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
if not success:
return failure_response(status.HTTP_500_INTERNAL_SERVER_ERROR,
'Volume creation failed. Contact support')
# Volume creation succeeded
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={
'request': request
}).data
return Response(serialized_data, status=status.HTTP_201_CREATED)