def start_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user, restore_ip=True, update_meta=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ from service.tasks.driver import update_metadata #Don't check capacity because.. I think.. its already being counted. #admin_capacity_check(provider_uuid, esh_instance.id) if restore_ip: restore_network(esh_driver, esh_instance, identity_uuid) deploy_task = restore_ip_chain(esh_driver, esh_instance, redeploy=True) needs_fixing = esh_instance.extra['metadata'].get('iplant_suspend_fix') logger.info("Instance %s needs to hard reboot instead of start" % esh_instance.id) if needs_fixing: return _repair_instance_networking(esh_driver, esh_instance, provider_uuid, identity_uuid) esh_driver.start_instance(esh_instance) if restore_ip: deploy_task.apply_async(countdown=10) update_status(esh_driver, esh_instance.id, provider_uuid, identity_uuid, user) invalidate_cached_instances(identity=CoreIdentity.objects.get(uuid=identity_uuid))
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 start_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user, restore_ip=True, update_meta=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ from service.tasks.driver import update_metadata #Don't check capacity because.. I think.. its already being counted. #admin_capacity_check(provider_uuid, esh_instance.id) _permission_to_act(identity_uuid, "Start") if restore_ip: restore_network(esh_driver, esh_instance, identity_uuid) deploy_task = restore_ip_chain(esh_driver, esh_instance, redeploy=True) needs_fixing = esh_instance.extra['metadata'].get('iplant_suspend_fix') logger.info("Instance %s needs to hard reboot instead of start" % esh_instance.id) if needs_fixing: return _repair_instance_networking(esh_driver, esh_instance, provider_uuid, identity_uuid) esh_driver.start_instance(esh_instance) if restore_ip: deploy_task.apply_async(countdown=10) update_status(esh_driver, esh_instance.id, provider_uuid, identity_uuid, user) invalidate_cached_instances(identity=CoreIdentity.objects.get(uuid=identity_uuid))
def offload_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user, reclaim_ip=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ from service.tasks.driver import _update_status_log _permission_to_act(identity_uuid, "Shelve Offload") _update_status_log(esh_instance, "Shelve-Offloading Instance") if reclaim_ip: remove_ips(esh_driver, esh_instance) offloaded = esh_driver._connection.ex_shelve_offload_instance(esh_instance) if reclaim_ip: remove_network(esh_driver, identity_uuid) update_status( esh_driver, esh_instance.id, provider_uuid, identity_uuid, user) invalidate_cached_instances( identity=CoreIdentity.objects.get( uuid=identity_uuid)) return offloaded
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 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 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) 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 _complete_launch_instance(driver, identity, instance, user, token, password): from service import task # call async task to deploy to instance. task.deploy_init_task(driver, instance, identity, user.username, password, token) #Create the Core/DB for instance core_instance = convert_esh_instance( driver, instance, identity.provider.uuid, identity.uuid, user, token, password) #Update InstanceStatusHistory _first_update(driver, identity, core_instance, instance) #Invalidate and return invalidate_cached_instances(identity=identity) return core_instance
def _complete_launch_instance(driver, identity, instance, user, token, password, deploy=True): from service import task #Create the Core/DB for instance core_instance = convert_esh_instance( driver, instance, identity.provider.uuid, identity.uuid, user, token, password) # call async task to deploy to instance. task.deploy_init_task(driver, instance, identity, user.username, password, token, deploy=deploy) #Update InstanceStatusHistory _first_update(driver, identity, core_instance, instance) #Invalidate and return invalidate_cached_instances(identity=identity) return core_instance
def stop_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user, reclaim_ip=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ if reclaim_ip: remove_ips(esh_driver, esh_instance) stopped = esh_driver.stop_instance(esh_instance) if reclaim_ip: remove_network(esh_driver, identity_uuid) update_status(esh_driver, esh_instance.id, provider_uuid, identity_uuid, user) invalidate_cached_instances( identity=CoreIdentity.objects.get(uuid=identity_uuid))
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 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}, 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}) if serializer.is_valid(): logger.info('metadata = %s' % data) update_instance_metadata(esh_driver, esh_instance, data) serializer.save() new_instance = serializer.object 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.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 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 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}) if serializer.is_valid(): logger.info('metadata = %s' % data) update_instance_metadata(esh_driver, esh_instance, data) serializer.save() new_instance = serializer.object 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.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 stop_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user, reclaim_ip=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ _permission_to_act(identity_uuid, "Stop") if reclaim_ip: remove_ips(esh_driver, esh_instance) stopped = esh_driver.stop_instance(esh_instance) if reclaim_ip: remove_network(esh_driver, identity_uuid) update_status(esh_driver, esh_instance.id, provider_uuid, identity_uuid, user) invalidate_cached_instances( identity=CoreIdentity.objects.get(uuid=identity_uuid))
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) if not esh_instance: return instance_not_found(instance_id) #Test that there is not an attached volume BEFORE we destroy _check_volume_attachment(esh_driver, esh_instance) task.destroy_instance_task(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' 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 VolumeAttachConflict as exc: message = exc.message return failure_response(status.HTTP_409_CONFLICT, message) except ConnectionFailure: return connection_failure(provider_uuid, identity_uuid) except InvalidCredsError: return invalid_creds(provider_uuid, identity_uuid)
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 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 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)