def post_instance_action(self, request, pk=None):
user = request.user
instance_id = pk
instance = find_instance(instance_id)
identity = instance.created_by_identity
action_params = request.data
action = action_params.pop('action')
try:
result_obj = run_instance_action(user, identity, instance_id, action, action_params)
api_response = {
'result': 'success',
'message': 'The requested action <%s> was run successfully' % (action,),
'object': result_obj,
}
response = Response(api_response, status=status.HTTP_200_OK)
return response
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Instance %s no longer exists' % (dne.message,))
except InvalidCredsError:
return invalid_creds(identity)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except ProviderNotActive as pna:
return inactive_provider(pna)
except (OverQuotaError, OverAllocationError) as oqe:
return over_quota(oqe)
except SizeNotAvailable as snae:
return size_not_available(snae)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except InvalidCredsError:
return invalid_creds(identity)
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_instance_action(self, request, pk=None):
user = request.user
instance_id = pk
instance = find_instance(instance_id)
identity = instance.created_by_identity
action_params = dict(request.data)
action = action_params.pop('action')
if type(action) == list:
action = action[0]
try:
result_obj = run_instance_action(user, identity, instance_id, action, action_params)
api_response = {
'result': 'success',
'message': 'The requested action <%s> was run successfully' % (action,),
'object': result_obj,
}
response = Response(api_response, status=status.HTTP_200_OK)
return response
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except InstanceDoesNotExist as dne:
return failure_response(
status.HTTP_404_NOT_FOUND,
'Instance %s no longer exists' % (dne.message,))
except LibcloudInvalidCredsError:
return invalid_creds(identity)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except ProviderNotActive as pna:
return inactive_provider(pna)
except (OverQuotaError, OverAllocationError) as oqe:
return over_quota(oqe)
except SizeNotAvailable as snae:
return size_not_available(snae)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
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)
except ActionNotAllowed:
return failure_response(
status.HTTP_409_CONFLICT,
"The requested action %s has been explicitly "
"disabled on this provider." % 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, message))
def create(self, request):
user = request.user
data = request.data
try:
self.validate_input(user, data)
except Exception as exc:
return failure_response(status.HTTP_400_BAD_REQUEST, exc.message)
# Create a mutable dict and start modifying.
data = data.copy()
name = data.get('name')
identity_uuid = data.get('identity')
source_alias = data.get('source_alias')
size_alias = data.get('size_alias')
allocation_source_id = data.get('allocation_source_id')
boot_scripts = data.pop("scripts", [])
deploy = data.get('deploy')
extra = data.get('extra')
try:
identity = Identity.objects.get(uuid=identity_uuid)
allocation_source = AllocationSource.objects.get(
source_id=allocation_source_id)
core_instance = launch_instance(user, identity_uuid, size_alias,
source_alias, name, deploy,
**extra)
# Faking a 'partial update of nothing' to allow call to 'is_valid'
serialized_instance = InstanceSerializer(
core_instance,
context={'request': self.request},
data={},
partial=True)
if not serialized_instance.is_valid():
return Response(serialized_instance.errors,
status=status.HTTP_400_BAD_REQUEST)
instance = serialized_instance.save()
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
instance.change_allocation_source(allocation_source)
return Response(serialized_instance.data,
status=status.HTTP_201_CREATED)
except UnderThresholdError as ute:
return under_threshold(ute)
except (OverQuotaError, OverAllocationError) as oqe:
return over_quota(oqe)
except ProviderNotActive as pna:
return inactive_provider(pna)
except SizeNotAvailable as snae:
return size_not_available(snae)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except SecurityGroupNotCreated:
return connection_failure(identity)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except LibcloudInvalidCredsError:
return invalid_creds(identity)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def create(self, request):
user = request.user
data = request.data
try:
self.validate_input(user, data)
except Exception as exc:
return failure_response(
status.HTTP_400_BAD_REQUEST,
exc.message)
# Create a mutable dict and start modifying.
data = data.copy()
name = data.get('name')
identity_uuid = data.get('identity')
source_alias = data.get('source_alias')
size_alias = data.get('size_alias')
boot_scripts = data.pop("scripts", [])
deploy = data.get('deploy')
extra = data.get('extra')
try:
identity = Identity.objects.get(uuid=identity_uuid)
core_instance = launch_instance(
user, identity_uuid, size_alias, source_alias, name, deploy,
**extra)
# Faking a 'partial update of nothing' to allow call to 'is_valid'
serialized_instance = InstanceSerializer(
core_instance, context={'request': self.request},
data={}, partial=True)
if not serialized_instance.is_valid():
return Response(serialized_instance.errors,
status=status.HTTP_400_BAD_REQUEST)
instance = serialized_instance.save()
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
return Response(
serialized_instance.data, status=status.HTTP_201_CREATED)
except UnderThresholdError as ute:
return under_threshold(ute)
except (OverQuotaError, OverAllocationError) as oqe:
return over_quota(oqe)
except ProviderNotActive as pna:
return inactive_provider(pna)
except SizeNotAvailable as snae:
return size_not_available(snae)
except HypervisorCapacityError as hce:
return over_capacity(hce)
except SecurityGroupNotCreated:
return connection_failure(identity)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except InvalidCredsError:
return invalid_creds(identity)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
def perform_destroy(self, instance):
user = self.request.user
identity_uuid = instance.created_by_identity.uuid
identity = Identity.objects.get(uuid=identity_uuid)
try:
# Test that there is not an attached volume BEFORE we destroy
#NOTE: Although this is a task we are calling and waiting for response..
core_instance = destroy_instance(user, identity_uuid,
instance.provider_alias)
serialized_instance = InstanceSerializer(
core_instance,
context={'request': self.request},
data={},
partial=True)
if not serialized_instance.is_valid():
return Response(serialized_instance.data,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
except VolumeAttachConflict as exc:
message = exc.message
return failure_response(status.HTTP_409_CONFLICT, message)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except LibcloudInvalidCredsError:
return invalid_creds(identity)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def perform_destroy(self, instance):
user = self.request.user
identity_uuid = instance.created_by_identity.uuid
identity = Identity.objects.get(id=identity_uuid)
try:
# Test that there is not an attached volume BEFORE we destroy
#NOTE: Although this is a task we are calling and waiting for response..
core_instance = destroy_instance(
user,
identity_uuid,
instance.provider_alias)
serialized_instance = InstanceSerializer(
core_instance, context={
'request': self.request},
data={}, partial=True)
if not serialized_instance.is_valid():
return Response(serialized_instance.data,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
except VolumeAttachConflict as exc:
message = exc.message
return failure_response(status.HTTP_409_CONFLICT, message)
except (socket_error, ConnectionFailure):
return connection_failure(identity)
except InvalidCredsError:
return invalid_creds(identity)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
def perform_destroy(self, instance):
user = self.request.user
identity_uuid = str(instance.created_by_identity.uuid)
identity = Identity.objects.get(uuid=identity_uuid)
provider_uuid = str(identity.provider.uuid)
try:
# Test that there is not an attached volume and destroy is ASYNC
destroy_instance.delay(
instance.provider_alias, user, identity_uuid)
# NOTE: Task to delete has been queued, return 204
serializer = InstanceSerializer(
instance, context={
'request': self.request},
data={}, partial=True)
if not serializer.is_valid():
return Response("Errors encountered during delete: %s" % serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
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))
def perform_destroy(self, instance):
user = self.request.user
identity_uuid = str(instance.created_by_identity.uuid)
identity = Identity.objects.get(uuid=identity_uuid)
provider_uuid = str(identity.provider.uuid)
try:
# Test that there is not an attached volume and destroy is ASYNC
destroy_instance.delay(instance.provider_alias, user,
identity_uuid)
# NOTE: Task to delete has been queued, return 204
serializer = InstanceSerializer(instance,
context={'request': self.request},
data={},
partial=True)
if not serializer.is_valid():
return Response("Errors encountered during delete: %s" %
serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
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))
def destroy(self, request, pk=None):
user = self.request.user
try:
instance = Instance.objects.get(
Q(id=pk) if isinstance(pk, int) else Q(provider_alias=pk)
)
identity_uuid = str(instance.created_by_identity.uuid)
identity = Identity.objects.get(uuid=identity_uuid)
provider_uuid = str(identity.provider.uuid)
destroy_instance.delay(instance.provider_alias, user, identity_uuid)
# We must invalidate the cache while we still depend on api.v1.instance
invalidate_cached_instances(identity=identity)
serializer = InstanceSerializer(
instance,
context={'request': self.request},
data={},
partial=True
)
if not serializer.is_valid():
return Response(
"Errors encountered during delete: %s" % serializer.errors,
status=status.HTTP_400_BAD_REQUEST
)
return Response(status=status.HTTP_204_NO_CONTENT)
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))
def destroy(self, request, pk=None):
user = self.request.user
try:
instance = Instance.objects.get(
Q(id=pk) if isinstance(pk, int) else Q(provider_alias=pk)
)
identity_uuid = str(instance.created_by_identity.uuid)
identity = Identity.objects.get(uuid=identity_uuid)
provider_uuid = str(identity.provider.uuid)
destroy_instance.delay(instance.provider_alias, user, identity_uuid)
# We must invalidate the cache while we still depend on api.v1.instance
invalidate_cached_instances(identity=identity)
serializer = InstanceSerializer(
instance,
context={'request': self.request},
data={},
partial=True
)
if not serializer.is_valid():
return Response(
"Errors encountered during delete: %s" % serializer.errors,
status=status.HTTP_400_BAD_REQUEST
)
return Response(status=status.HTTP_204_NO_CONTENT)
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))