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)
if not esh_driver:
return invalid_creds(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 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_current():
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)
if not esh_driver:
return invalid_creds(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 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)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
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 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)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
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 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 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 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)
except ProviderNotActive as pna:
return inactive_provider(pna)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except ObjectDoesNotExist:
return invalid_provider_identity(provider_uuid, identity_uuid)
except Exception as e:
logger.exception("Unexpected exception for user:%s"
% request_user)
return failure_response(status.HTTP_409_CONFLICT,
e.message)
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, machine_id):
"""
Details view for specific machine
(Lookup using the given provider/identity)
"""
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)
# TODO: Need to determine that identity_uuid is ALLOWED to
# see machine_id. if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_uuid, user)
serialized_data = ProviderMachineSerializer(
core_machine,
request_user=request.user).data
response = Response(serialized_data)
return response
def get(self, request, provider_uuid, identity_uuid, machine_id):
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)
# TODO: Need to determine that identity_uuid is ALLOWED to
# see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_uuid, user)
if not core_machine:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Could not retrieve machine with ID = %s" % machine_id)
if not core_machine.application_version.application.icon:
return None
app_icon = core_machine.application_version.application.icon
image_name, image_ext = os.path.splitext(app_icon.name)
return Response(app_icon.file)
def get(self, request, provider_uuid, identity_uuid, machine_id):
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)
# TODO: Need to determine that identity_uuid is ALLOWED to
# see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(
esh_driver, esh_machine, provider_uuid, user
)
if not core_machine:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Could not retrieve machine with ID = %s" % machine_id
)
if not core_machine.application_version.application.icon:
return None
app_icon = core_machine.application_version.application.icon
return Response(app_icon.file)
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
)
except ProviderNotActive as pna:
return inactive_provider(pna)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except LibcloudBadResponseError:
return malformed_response(provider_uuid, identity_uuid)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except ObjectDoesNotExist:
return invalid_provider_identity(provider_uuid, identity_uuid)
except Exception as e:
logger.exception("Unexpected exception for user:%s" % request_user)
return failure_response(status.HTTP_409_CONFLICT, e.message)
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, machine_id):
"""
Details view for specific machine
(Lookup using the given provider/identity)
"""
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)
# TODO: Need to determine that identity_uuid is ALLOWED to
# see machine_id. if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(
esh_driver, esh_machine, provider_uuid, user
)
serialized_data = ProviderMachineSerializer(
core_machine, request_user=request.user
).data
response = Response(serialized_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.shared_with_user(user).get(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 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.shared_with_user(user).get(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 _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
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_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 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)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
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))
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)
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 LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
"Instance %s does not exist" % instance_id)
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 = None
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_uuid, identity_uuid,
user)
if not core_instance:
logger.warn("Unable to find core instance %s." % (instance_id))
core_instance = CoreInstance.objects.filter(
provider_alias=instance_id).first()
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 LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
def post(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, Attempt a specific instance action,
including necessary parameters.
"""
# Service-specific call to action
action_params = request.data
if not action_params.get('action', None):
return failure_response(
status.HTTP_400_BAD_REQUEST,
'POST request to /action require a BODY with \'action\'.')
result_obj = None
user = request.user
identity = Identity.objects.get(uuid=identity_uuid)
action = action_params['action']
try:
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, "Instance",
instance_id)
result_obj = run_instance_action(user, identity, instance_id,
action, action_params)
result_obj = _further_process_result(request, action, result_obj)
api_response = {
'result':
'success',
'message':
'The requested action <%s> was run successfully' %
(action_params['action'], ),
'object':
result_obj,
}
response = Response(api_response, status=status.HTTP_200_OK)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Instance %s no longer exists' % (dne.message, ))
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except OverQuotaError as oqe:
return over_quota(oqe)
except OverAllocationError as oae:
return over_quota(oae)
except SizeNotAvailable as snae:
return size_not_available(snae)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except VolumeMountConflict as vmc:
return mount_failed(vmc)
except NotImplemented:
return failure_response(
status.HTTP_409_CONFLICT,
"The requested action %s is not available on this provider." %
action_params['action'])
except ActionNotAllowed:
return failure_response(
status.HTTP_409_CONFLICT,
"The requested action %s has been explicitly "
"disabled on this provider." % action_params['action'])
except Exception as exc:
logger.exception("Exception occurred processing InstanceAction")
message = exc.message
if message.startswith('409 Conflict'):
return failure_response(status.HTTP_409_CONFLICT, message)
return failure_response(
status.HTTP_403_FORBIDDEN,
"The requested action %s encountered "
"an irrecoverable exception: %s" %
(action_params['action'], message))
def post(self, request, provider_uuid, identity_uuid, format=None):
"""
Instance Class:
Launches an instance based on the params
Returns a single instance
Parameters: machine_alias, size_alias, username
TODO: Create a 'reverse' using the instance-id to pass
the URL for the newly created instance
I.e: url = "/provider/1/instance/1/i-12345678"
"""
data = request.data
user = request.user
# Check the data is valid
missing_keys = valid_post_data(data)
if missing_keys:
return keys_not_found(missing_keys)
identity = Identity.shared_with_user(
user, is_leader=True).filter(uuid=identity_uuid).first()
if not identity:
failure_msg = "User %s does not have permission to POST with this identity. Promote user to leader or use a different Identity." % (
user, )
return failure_response(status.HTTP_403_FORBIDDEN, failure_msg)
# Pass these as args
size_alias = data.pop("size_alias")
allocation_source_uuid = data.pop("allocation_source_uuid", None)
machine_alias = data.pop("machine_alias")
hypervisor_name = data.pop("hypervisor", None)
if hypervisor_name:
# Previous method passed this with 'None' but that fails now.
# This check will only add the ex_ value if it is 'truthy'.
data['ex_hypervisor_name'] = hypervisor_name
deploy = data.pop("deploy", True)
if type(deploy) in [str, unicode] and deploy.lower() == "false":
deploy = False
elif not isinstance(deploy, bool):
deploy = True
boot_scripts = data.pop("scripts", [])
try:
logger.debug(data)
allocation_source = AllocationSource.objects.get(
uuid=allocation_source_uuid)
core_instance = launch_instance(
user,
identity_uuid,
size_alias,
machine_alias,
deploy=deploy,
allocation_source=allocation_source,
**data)
except UnderThresholdError as ute:
return under_threshold(ute)
except OverQuotaError as oqe:
return over_quota(oqe)
except OverAllocationError as oae:
return over_quota(oae)
except Unauthorized as auth_invalid:
return invalid_creds(provider_uuid, identity_uuid)
except SizeNotAvailable as snae:
return size_not_available(snae)
except SecurityGroupNotCreated:
return connection_failure(provider_uuid, identity_uuid)
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))
serializer = InstanceSerializer(core_instance,
context={"request": request},
data=data)
if serializer.is_valid():
instance = serializer.save()
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
instance.change_allocation_source(allocation_source)
logger.info(
"DEBUG- Instance launch completed - Returning instance %s (%s) to user %s"
% (instance, instance.created_by_identity, request.user))
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
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)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
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))
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)
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 LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Instance %s no longer exists' % (dne.message, ))
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
try:
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_uuid,
identity_uuid, user)
if not core_instance:
logger.warn("Unable to find core instance %s." % (instance_id))
core_instance = CoreInstance.objects.filter(
provider_alias=instance_id).first()
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 LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
def post(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, Attempt a specific instance action,
including necessary parameters.
"""
# Service-specific call to action
action_params = request.data
if not action_params.get('action', None):
return failure_response(
status.HTTP_400_BAD_REQUEST,
'POST request to /action require a BODY with \'action\'.')
result_obj = None
user = request.user
identity = Identity.objects.get(uuid=identity_uuid)
action = action_params['action']
try:
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, "Instance", instance_id)
result_obj = run_instance_action(user, identity, instance_id, action, action_params)
result_obj = _further_process_result(request, action, result_obj)
api_response = {
'result': 'success',
'message': 'The requested action <%s> was run successfully' % (action_params['action'],),
'object': result_obj,
}
response = Response(api_response, status=status.HTTP_200_OK)
return response
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except ProviderNotActive as pna:
return inactive_provider(pna)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Instance %s no longer exists' % (instance_id,))
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except OverQuotaError as oqe:
return over_quota(oqe)
except OverAllocationError as oae:
return over_quota(oae)
except AllocationBlacklistedError as e:
return failure_response(
status.HTTP_403_FORBIDDEN,
e.message)
except SizeNotAvailable as snae:
return size_not_available(snae)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except VolumeMountConflict as vmc:
return mount_failed(vmc)
except NotImplemented:
return failure_response(
status.HTTP_409_CONFLICT,
"The requested action %s is not available on this provider."
% action_params['action'])
except ActionNotAllowed:
return failure_response(
status.HTTP_409_CONFLICT,
"The requested action %s has been explicitly "
"disabled on this provider." % action_params['action'])
except Exception as exc:
logger.exception("Exception occurred processing InstanceAction")
message = exc.message
if message.startswith('409 Conflict'):
return failure_response(
status.HTTP_409_CONFLICT,
message)
return failure_response(
status.HTTP_403_FORBIDDEN,
"The requested action %s encountered "
"an irrecoverable exception: %s"
% (action_params['action'], message))
def post(self, request, provider_uuid, identity_uuid, format=None):
"""
Instance Class:
Launches an instance based on the params
Returns a single instance
Parameters: machine_alias, size_alias, username
TODO: Create a 'reverse' using the instance-id to pass
the URL for the newly created instance
I.e: url = "/provider/1/instance/1/i-12345678"
"""
data = request.data
user = request.user
# Check the data is valid
missing_keys = valid_post_data(data)
if missing_keys:
return keys_not_found(missing_keys)
identity = Identity.shared_with_user(user, is_leader=True).filter(uuid=identity_uuid).first()
if not identity:
failure_msg = "User %s does not have permission to POST with this identity. Promote user to leader or use a different Identity." % (user,)
return failure_response(status.HTTP_403_FORBIDDEN, failure_msg)
# Pass these as args
size_alias = data.pop("size_alias")
allocation_source_uuid = data.pop("allocation_source_uuid",None)
machine_alias = data.pop("machine_alias")
hypervisor_name = data.pop("hypervisor", None)
if hypervisor_name:
# Previous method passed this with 'None' but that fails now.
# This check will only add the ex_ value if it is 'truthy'.
data['ex_hypervisor_name'] = hypervisor_name
deploy = data.pop("deploy", True)
if type(deploy) in [str, unicode] and deploy.lower() == "false":
deploy = False
elif not isinstance(deploy, bool):
deploy = True
boot_scripts = data.pop("scripts", [])
try:
logger.debug(data)
allocation_source = AllocationSource.objects.get(
uuid=allocation_source_uuid)
core_instance = launch_instance(
user, identity_uuid,
size_alias, machine_alias,
deploy=deploy,
allocation_source=allocation_source,
**data)
except UnderThresholdError as ute:
return under_threshold(ute)
except OverQuotaError as oqe:
return over_quota(oqe)
except OverAllocationError as oae:
return over_quota(oae)
except AllocationBlacklistedError as e:
return failure_response(
status.HTTP_403_FORBIDDEN,
e.message)
except Unauthorized:
return invalid_creds(provider_uuid, identity_uuid)
except SizeNotAvailable as snae:
return size_not_available(snae)
except SecurityGroupNotCreated:
return connection_failure(provider_uuid, identity_uuid)
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))
serializer = InstanceSerializer(core_instance,
context={"request": request},
data=data)
if serializer.is_valid():
instance = serializer.save()
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
instance.change_allocation_source(allocation_source)
logger.info("DEBUG- Instance launch completed - Returning instance %s (%s) to user %s" % (instance, instance.created_by_identity, request.user))
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
