def delete(self, request, provider_id, identity_id, instance_id):
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
existing_instance = esh_driver.get_instance(instance_id)
if existing_instance:
#Instance will be deleted soon...
esh_instance = existing_instance
if esh_instance.extra\
and 'task' not in esh_instance.extra:
esh_instance.extra['task'] = 'queueing delete'
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
serialized_data = InstanceSerializer(core_instance).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
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):
"""
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 delete(self, request, provider_id, identity_id, instance_id):
"""Authentication Required, TERMINATE the instance.
Be careful, there is no going back once you've deleted an instance.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
existing_instance = esh_driver.get_instance(instance_id)
if existing_instance:
#Instance will be deleted soon...
esh_instance = existing_instance
if esh_instance.extra\
and 'task' not in esh_instance.extra:
esh_instance.extra['task'] = 'queueing delete'
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
serialized_data = InstanceSerializer(core_instance,
context={
'user': request.user
}).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
def get(self, request, provider_id, identity_id):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
instance_list_method = esh_driver.list_instances
if AccountProvider.objects.filter(identity__id=identity_id):
# Instance list method changes when using the OPENSTACK provider
instance_list_method = esh_driver.list_all_instances
try:
esh_instance_list = instance_list_method()
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_instance_list = [
convert_esh_instance(esh_driver, inst, provider_id, identity_id,
user) for inst in esh_instance_list
]
#TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={
'user': request.user
},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_uuid, identity_uuid, hypervisor_id):
"""
Lookup the Hypervisor information (Lookup using the given
provider/identity)
Update on server DB (If applicable)
"""
user = request.user
provider = Provider.objects.filter(uuid=provider_uuid)
if not provider:
return invalid_creds(provider_uuid, identity_uuid)
esh_driver = get_admin_driver(provider[0])
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
hypervisor = {}
if not hasattr(esh_driver._connection, 'ex_detail_hypervisor_node'):
return failure_response(
status.HTTP_404_NOT_FOUND,
"Hypervisor Details cannot be retrieved for this provider.")
try:
hypervisor = esh_driver._connection\
.ex_detail_hypervisor_node(hypervisor_id)
hypervisor['cpu_info'] = json.loads(hypervisor['cpu_info'])
response = Response(hypervisor)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except Exception as exc:
return failure_response(
status.HTTP_404_NOT_FOUND,
"Error encountered retrieving hypervisor details:%s" % exc)
def get(self, request, provider_uuid, identity_uuid, hypervisor_id):
"""
Lookup the Hypervisor information (Lookup using the given
provider/identity)
Update on server DB (If applicable)
"""
provider = Provider.objects.filter(uuid=provider_uuid)
if not provider:
return invalid_creds(provider_uuid, identity_uuid)
esh_driver = get_admin_driver(provider[0])
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
hypervisor = {}
if not hasattr(esh_driver._connection, 'ex_detail_hypervisor_node'):
return failure_response(
status.HTTP_404_NOT_FOUND,
"Hypervisor Details cannot be retrieved for this provider.")
try:
hypervisor = esh_driver._connection\
.ex_detail_hypervisor_node(hypervisor_id)
hypervisor['cpu_info'] = json.loads(hypervisor['cpu_info'])
response = Response(hypervisor)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except Exception as exc:
return failure_response(
status.HTTP_404_NOT_FOUND,
"Error encountered retrieving hypervisor details:%s" % exc)
def get(self, request, provider_uuid, identity_uuid, volume_id):
"""
"""
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_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_volume:
try:
source = InstanceSource.objects.get(
identifier=volume_id, provider__uuid=provider_uuid)
source.end_date = datetime.now()
source.save()
except CoreVolume.DoesNotExist:
pass
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={
'request': request
}).data
response = Response(serialized_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 put(self, request, provider_uuid, identity_uuid, volume_id):
"""
Updates DB values for volume
"""
user = request.user
data = request.DATA
#Ensure volume exists
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serializer = VolumeSerializer(core_volume,
data=data,
context={'request': request})
if serializer.is_valid():
serializer.save()
update_volume_metadata(esh_driver, esh_volume, data)
response = Response(serializer.data)
return response
else:
failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def delete(self, request, provider_uuid, identity_uuid, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
#Ensure volume exists
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
#Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = now()
core_volume.save()
#Return the object
serialized_data = VolumeSerializer(core_volume,
context={
'request': request
}).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):
"""
"""
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 delete(self, request, provider_uuid, identity_uuid, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
# Ensure volume exists
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
# Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = now()
core_volume.save()
# Return the object
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
response = Response(serialized_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, volume_id):
"""
"""
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_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_volume:
try:
source = InstanceSource.objects.get(
identifier=volume_id,
provider__uuid=provider_uuid)
source.end_date = datetime.now()
source.save()
except (InstanceSource.DoesNotExist, CoreVolume.DoesNotExist):
pass
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={'request': request}).data
response = Response(serialized_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):
"""
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_id, identity_id):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
instance_list_method = esh_driver.list_instances
if AccountProvider.objects.filter(identity__id=identity_id):
# Instance list method changes when using the OPENSTACK provider
instance_list_method = esh_driver.list_all_instances
try:
esh_instance_list = instance_list_method()
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_instance_list = [convert_esh_instance(esh_driver,
inst,
provider_id,
identity_id,
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 delete(self, request, provider_id, identity_id, instance_id):
"""Authentication Required, TERMINATE the instance.
Be careful, there is no going back once you've deleted an instance.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
existing_instance = esh_driver.get_instance(instance_id)
if existing_instance:
#Instance will be deleted soon...
esh_instance = existing_instance
if esh_instance.extra\
and 'task' not in esh_instance.extra:
esh_instance.extra['task'] = 'queueing delete'
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
else:
logger.warn("Unable to find core instance %s." % (instance_id))
serialized_data = InstanceSerializer(core_instance,
context={"request":request}).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
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):
"""
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):
"""
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, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
# NOTE: This 'Scheme' should be used across
# the ENTIRE API v1 (Machines, Volumes, Sizes)
# NOTE: Especially the part below, where you end date
# all the things that are 'inactive'
try:
provider = Provider.objects.get(uuid=provider_uuid)
if not provider.is_active():
raise ProviderNotActive(provider)
except Provider.DoesNotExist:
return invalid_creds(provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
# Cleared provider testing -- ready for driver prep.
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
logger.info("InstanceQuery Looking for %s" % instance_id)
esh_instance = esh_driver.get_instance(instance_id)
logger.info("InstanceQuery Found instance %s" % esh_instance)
except (socket_error, ConnectionFailure):
logger.exception("Connection failure prevented InstanceQuery")
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
logger.exception("Invalid credentialsprevented InstanceQuery")
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
# NOTE: Especially THIS part below, where you end date all the
# things that are 'inactive'
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
source__provider__uuid=provider_uuid,
created_by_identity__uuid=identity_uuid)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serialized_data = InstanceSerializer(core_instance,
context={
"request": request
}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def delete(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, TERMINATE the instance.
Be careful, there is no going back once you've deleted an instance.
"""
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_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. " "Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
try:
# Test that there is not an attached volume BEFORE we destroy
task.destroy_instance_task(user, esh_instance, identity_uuid)
invalidate_cached_instances(identity=Identity.objects.get(uuid=identity_uuid))
existing_instance = esh_driver.get_instance(instance_id)
if existing_instance:
# Instance will be deleted soon...
esh_instance = existing_instance
if esh_instance.extra and "task" not in esh_instance.extra:
esh_instance.extra["task"] = "queueing delete"
except VolumeAttachConflict as exc:
message = exc.message
return failure_response(status.HTTP_409_CONFLICT, message)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. " "Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
try:
core_instance = convert_esh_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user)
if core_instance:
core_instance.end_date_all()
else:
logger.warn("Unable to find core instance %s." % (instance_id))
serialized_data = InstanceSerializer(core_instance, context={"request": request}).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response["Cache-Control"] = "no-cache"
return response
except (Identity.DoesNotExist) as exc:
return failure_response(status.HTTP_400_BAD_REQUEST, "Invalid provider_uuid or identity_uuid.")
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
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, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
# NOTE: This 'Scheme' should be used across
# the ENTIRE API v1 (Machines, Volumes, Sizes)
# NOTE: Especially the part below, where you end date
# all the things that are 'inactive'
try:
provider = Provider.objects.get(uuid=provider_uuid)
if not provider.is_active():
raise ProviderNotActive(provider)
except Provider.DoesNotExist:
return invalid_creds(provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
# Cleared provider testing -- ready for driver prep.
try:
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
logger.info("Looking for %s" % instance_id)
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
# NOTE: Especially THIS part below, where you end date all the
# things that are 'inactive'
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
source__provider__uuid=provider_uuid,
created_by_identity__uuid=identity_uuid)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serialized_data = InstanceSerializer(
core_instance,
context={"request": request}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def put(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
# Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request})
identity = Identity.objects.get(uuid=identity_uuid)
if serializer.is_valid():
logger.info('metadata = %s' % data)
#NOTE: We shouldn't allow 'full replacement' of metadata..
# We should also validate against potentional updating of 'atmo-used metadata'
update_metadata.s(esh_driver.__class__,
esh_driver.provider,
esh_driver.identity,
esh_instance.id,
data,
replace_metadata=False).apply()
new_instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
new_instance = _save_scripts_to_instance(
new_instance, boot_scripts)
serializer = InstanceSerializer(new_instance,
context={"request": request})
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request},
partial=True)
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
driver_class = esh_driver.__class__
update_metadata.s(driver_class,
provider,
identity,
esh_instance.id,
data,
replace_metadata=False).apply()
instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.DATA
# Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance, data=data,
context={"request": request})
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
#NOTE: We shouldn't allow 'full replacement' of metadata..
# We should also validate against potentional updating of 'atmo-used metadata'
update_metadata.s(driver_class, provider, identity, esh_instance.id,
data, replace_metadata=False).apply()
new_instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
new_instance = _save_scripts_to_instance(new_instance,
boot_scripts)
serializer = InstanceSerializer(
new_instance,
context={"request": request})
invalidate_cached_instances(identity=identitty)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(
core_instance, data=data,
context={"request": request}, partial=True)
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
driver_class = esh_driver.__class__
update_metadata.s(driver_class, provider, identity, esh_instance.id,
data, replace_metadata=False).apply()
instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, provider_uuid, identity_uuid, volume_id):
"""
Updates DB values for volume
"""
user = request.user
data = request.data
# Ensure volume exists
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)
if not can_use_volume(user, volume_id, leader_required=True):
return member_action_forbidden(user.username, "Volume", volume_id)
try:
esh_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serializer = VolumeSerializer(core_volume, data=data,
context={'request': request})
if serializer.is_valid():
serializer.save()
_update_volume_metadata(
esh_driver, esh_volume, data)
response = Response(serializer.data)
return response
else:
failure_response(
status.HTTP_400_BAD_REQUEST,
serializer.errors)
def patch(self, request, provider_uuid, identity_uuid, volume_id):
"""
Updates DB values for volume
"""
user = request.user
data = request.data
# Ensure volume exists
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)
if not can_use_volume(user, volume_id, leader_required=True):
return member_action_forbidden(user.username, "Volume", volume_id)
try:
esh_volume = esh_driver.get_volume(volume_id)
except ConnectionFailure:
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serializer = VolumeSerializer(core_volume, data=data,
context={'request': request},
partial=True)
if serializer.is_valid():
serializer.save()
_update_volume_metadata(
esh_driver, esh_volume, data)
response = Response(serializer.data)
return response
else:
return failure_response(
status.HTTP_400_BAD_REQUEST,
serializer.errors)
def patch(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.DATA
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
#Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid, user)
serializer = InstanceSerializer(core_instance, data=data,
context={"request":request}, partial=True)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data,
replace=False)
serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
_save_scripts_to_instance(serializer.object, boot_scripts)
invalidate_cached_instances(identity=Identity.objects.get(uuid=identity_uuid))
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, provider_uuid, identity_uuid):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
provider = Provider.objects.filter(uuid=provider_uuid)
if not provider:
return invalid_creds(provider_uuid, identity_uuid)
esh_driver = get_admin_driver(provider[0])
esh_hypervisor_list = []
if not hasattr(esh_driver._connection, 'ex_list_hypervisor_nodes'):
return failure_response(
status.HTTP_404_NOT_FOUND,
"The Hypervisor List cannot be retrieved for this provider.")
try:
esh_hypervisor_list =\
esh_driver._connection.ex_list_hypervisor_nodes()
region_name = esh_driver._connection._ex_force_service_region
for obj in esh_hypervisor_list:
obj['service_region'] = region_name
response = Response(esh_hypervisor_list)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except Exception as exc:
return failure_response(
status.HTTP_404_NOT_FOUND,
"Error encountered retrieving hypervisor list:%s" % exc)
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={
"request": request
}).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
"""
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 _update_machine(self, request, provider_uuid, identity_uuid, machine_id):
# TODO: Determine who is allowed to edit machines besides
# core_machine.owner
user = request.user
data = request.DATA
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine, provider_uuid, user)
if not user.is_staff and user is not core_machine.application_version.application.created_by:
logger.warn("%s is Non-staff/non-owner trying to update a machine" % (user.username))
return failure_response(
status.HTTP_401_UNAUTHORIZED, "Only Staff and the machine Owner " "are allowed to change machine info."
)
partial_update = True if request.method == "PATCH" else False
serializer = ProviderMachineSerializer(
core_machine, request_user=request.user, data=data, partial=partial_update
)
if serializer.is_valid():
logger.info("metadata = %s" % data)
update_machine_metadata(esh_driver, esh_machine, data)
machine = serializer.save()
if "created_by_identity" in request.DATA:
identity = machine.created_by_identity
update_application_owner(core_machine.application_version.application, identity)
logger.info(serializer.data)
return Response(serializer.data)
return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def put(self, request, provider_uuid, identity_uuid, volume_id):
"""
Updates DB values for volume
"""
user = request.user
data = request.DATA
#Ensure volume exists
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serializer = VolumeSerializer(core_volume,
data=data,
context={'request': request})
if serializer.is_valid():
serializer.save()
update_volume_metadata(esh_driver, esh_volume, data)
response = Response(serializer.data)
return response
else:
failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def delete(self, request, provider_uuid, identity_uuid, snapshot_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
# Ensure volume exists
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)
if not can_use_snapshot(user, snapshot_id, leader_required=True):
return member_action_forbidden(user.username, "Snapshot", snapshot_id)
snapshot = esh_driver._connection.get_snapshot(snapshot_id)
if not snapshot:
return snapshot_not_found(snapshot_id)
delete_success = esh_driver._connection.ex_delete_snapshot(snapshot)
# NOTE: Always false until icehouse...
# return failure_response(
# status.HTTP_400_BAD_REQUEST,
# % snapshot_id)
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, provider_uuid, identity_uuid, action=None):
"""
"""
if not action:
return failure_response(status.HTTP_400_BAD_REQUEST,
'Action is not supported.')
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)
esh_meta = esh_driver.meta()
try:
if 'test_links' in action:
test_links = esh_meta.test_links()
return Response(test_links, status=status.HTTP_200_OK)
except InvalidCredsError:
logger.warn(
'Authentication Failed. Provider-id:%s Identity-id:%s' %
(provider_uuid, identity_uuid))
return failure_response(status.HTTP_401_UNAUTHORIZED,
'Identity/Provider Authentication Failed')
except NotImplemented as ne:
logger.exception(ne)
return failure_response(
status.HTTP_404_NOT_FOUND,
'The requested resource %s is not available on this provider' %
action)
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={"request":request}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get_esh_instance(request, provider_uuid, identity_uuid, instance_id):
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
raise LibcloudInvalidCredsError("Provider_uuid && identity_uuid "
"did not produce a valid combination")
esh_instance = None
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_instance:
# End date everything
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
source__provider__uuid=provider_uuid,
created_by_identity__uuid=identity_uuid)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return esh_instance
def delete(self, request, provider_id, identity_id, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
#Ensure volume exists
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_id, identity_id,
user)
#Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = datetime.now()
core_volume.save()
#Return the object
serialized_data = VolumeSerializer(
core_volume,
context={
'user': request.user
},
).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 delete(self, request, provider_id, identity_id, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
#Ensure volume exists
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_id,
identity_id, user)
#Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = datetime.now()
core_volume.save()
#Return the object
serialized_data = VolumeSerializer(core_volume,
context={'user':request.user},
).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
provider = Provider.objects.filter(uuid=provider_uuid)
if not provider:
return invalid_creds(provider_uuid, identity_uuid)
esh_driver = get_admin_driver(provider[0])
esh_hypervisor_list = []
if not hasattr(esh_driver._connection, 'ex_list_hypervisor_nodes'):
return failure_response(
status.HTTP_404_NOT_FOUND,
"The Hypervisor List cannot be retrieved for this provider.")
try:
esh_hypervisor_list =\
esh_driver._connection.ex_list_hypervisor_nodes()
region_name = esh_driver._connection._ex_force_service_region
for obj in esh_hypervisor_list:
obj['service_region'] = region_name
response = Response(esh_hypervisor_list)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except Exception as exc:
return failure_response(
status.HTTP_404_NOT_FOUND,
"Error encountered retrieving hypervisor list:%s" % exc)
def get(self, request, provider_uuid, identity_uuid, size_alias):
"""
Lookup the size information (Lookup using the given provider/identity)
Update on server DB (If applicable)
"""
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)
esh_size = esh_driver.get_size(size_alias)
if not esh_size:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Size %s not found' % (size_alias,))
core_size = convert_esh_size(esh_size, provider_uuid)
serialized_data = ProviderSizeSerializer(core_size).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid, volume_id):
"""
"""
user = request.user
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
try:
core_volume = CoreVolume.objects.get(
identifier=volume_id, provider__uuid=provider_uuid)
core_volume.end_date = datetime.now()
core_volume.save()
except CoreVolume.DoesNotExist:
pass
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_uuid,
identity_uuid, user)
serialized_data = VolumeSerializer(core_volume,
context={
'request': request
}).data
response = Response(serialized_data)
return response
def put(self, request, provider_id, identity_id, machine_id):
"""
TODO: Determine who is allowed to edit machines besides
core_machine.owner
"""
user = request.user
data = request.DATA
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine, provider_id)
if not user.is_staff\
and user is not core_machine.application.created_by:
logger.error('Non-staff/non-owner trying to update a machine')
return failure_response(
status.HTTP_401_UNAUTHORIZED,
'Only Staff and the machine Owner '
+ 'are allowed to change machine info.')
core_machine.application.update(data)
serializer = ProviderMachineSerializer(core_machine,
data=data, partial=True)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_machine_metadata(esh_driver, esh_machine, data)
serializer.save()
logger.info(serializer.data)
return Response(serializer.data)
return failure_response(
status.HTTP_400_BAD_REQUEST,
serializer.errors)
def put(self, request, provider_id, identity_id, machine_id):
"""
TODO: Determine who is allowed to edit machines besides
core_machine.owner
"""
user = request.user
data = request.DATA
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_id)
if not user.is_staff\
and user is not core_machine.application.created_by:
logger.error('Non-staff/non-owner trying to update a machine')
return failure_response(
status.HTTP_401_UNAUTHORIZED,
'Only Staff and the machine Owner ' +
'are allowed to change machine info.')
core_machine.application.update(data)
serializer = ProviderMachineSerializer(core_machine,
data=data,
partial=True)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_machine_metadata(esh_driver, esh_machine, data)
serializer.save()
logger.info(serializer.data)
return Response(serializer.data)
return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def put(self, request, provider_id, identity_id, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.DATA
#Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
#Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request})
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors, status=status.HTTP_400)
def get(self, request, provider_uuid, identity_uuid, action=None):
"""
"""
if not action:
return failure_response(
status.HTTP_400_BAD_REQUEST,
'Action is not supported.'
)
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)
esh_meta = esh_driver.meta()
try:
if 'test_links' in action:
test_links = esh_meta.test_links()
return Response(test_links, status=status.HTTP_200_OK)
except LibcloudInvalidCredsError:
logger.warn('Authentication Failed. Provider-id:%s Identity-id:%s'
% (provider_uuid, identity_uuid))
return failure_response(
status.HTTP_401_UNAUTHORIZED,
'Identity/Provider Authentication Failed')
except NotImplemented as ne:
logger.exception(ne)
return failure_response(
status.HTTP_404_NOT_FOUND,
'The requested resource %s is not available on this provider'
% action)
def get_esh_instance(request, provider_uuid, identity_uuid, instance_id):
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
raise InvalidCredsError(
"Provider_uuid && identity_uuid "
"did not produce a valid combination")
esh_instance = None
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_instance:
# End date everything
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
source__provider__uuid=provider_uuid,
created_by_identity__uuid=identity_uuid)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return esh_instance
def put(self, request, provider_id, identity_id, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.DATA
#Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
#Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data,
context={"request":request})
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors, status=status.HTTP_400)
def put(self, request, provider_id, identity_id, volume_id):
"""
Updates DB values for volume
"""
user = request.user
data = request.DATA
#Ensure volume exists
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_id,
identity_id, user)
serializer = VolumeSerializer(core_volume, data=data,
context={'request': request})
if serializer.is_valid():
serializer.save()
response = Response(serializer.data)
return response
else:
failure_response(
status.HTTP_400_BAD_REQUEST,
serializer.errors)
