def resume_instance(esh_driver, esh_instance, provider_id, identity_id, user, restore_ip=True, update_meta=True): """ raise OverQuotaError, OverAllocationError, InvalidCredsError """ from service.tasks.driver import update_metadata check_quota(user.username, identity_id, esh_instance.size, resuming=True) admin_capacity_check(provider_id, esh_instance.id) if restore_ip: restore_network(esh_driver, esh_instance, identity_id) if update_meta: update_instance_metadata(esh_driver, esh_instance, data={'tmp_status': 'networking'}, replace=False) esh_driver.resume_instance(esh_instance) if restore_ip: restore_ips(esh_driver, esh_instance) if update_meta: #Run this task only when instance moves from suspended --> active update_metadata.s( esh_driver.__class__, esh_driver.provider, esh_driver.identity, esh_instance.id, {'tmp_status': ''}).apply_async(countdown=30) update_status(esh_driver, esh_instance.id, provider_id, identity_id, user)
def remove_ips(esh_driver, esh_instance, update_meta=True): """ Returns: (floating_removed, fixed_removed) """ from service.tasks.driver import update_metadata network_manager = esh_driver._connection.get_network_manager() # Delete the Floating IP result = network_manager.disassociate_floating_ip(esh_instance.id) logger.info("Removed Floating IP for Instance %s - Result:%s" % (esh_instance.id, result)) if update_meta: driver_class = esh_driver.__class__ provider = esh_driver.provider identity = es_driver.identity metadata={'public-ip': '', 'public-hostname': ''} update_metadata.s(driver_class, identity, esh_instance.id, metadata, replace_metadata=False).apply() # Fixed instance_ports = network_manager.list_ports(device_id=esh_instance.id) if instance_ports: fixed_ip_port = instance_ports[0] fixed_ips = fixed_ip_port.get('fixed_ips', []) if fixed_ips: fixed_ip = fixed_ips[0]['ip_address'] result = esh_driver._connection.ex_remove_fixed_ip( esh_instance, fixed_ip) logger.info("Removed Fixed IP %s - Result:%s" % (fixed_ip, result)) return (True, True) return (True, False)
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 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)