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 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)
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 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 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 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, 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, volume_id): """ Updates DB values for volume """ user = request.user data = request.DATA #Ensure volume exists esh_driver = prepare_driver(request, identity_id) esh_volume = esh_driver.get_volume(volume_id) if not esh_volume: errorObj = failureJSON([{'code': 404, 'message': 'Volume does not exist'}]) return Response(errorObj, status=status.HTTP_404_NOT_FOUND) core_volume = convert_esh_volume(esh_volume, provider_id, identity_id, user) serializer = VolumeSerializer(core_volume, data=data) if serializer.is_valid(): serializer.save() response = Response(serializer.data) return response else: return Response(serializer.errors, status=400)
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 get(self, request): """ """ user = request.user volumes = user.volume_set.filter(only_active(), provider__active=True, projects=None) serialized_data = VolumeSerializer(volumes, many=True, context={ "request": request }).data response = Response(serialized_data) return response
def get(self, request, project_id): """ """ user = request.user group = get_user_group(user.username) #TODO: Check that you have permission! projects = group.projects.get(id=project_id) volumes = projects.volumes.filter(only_current) serialized_data = VolumeSerializer(volumes, many=True, context={ "user": request.user }).data response = Response(serialized_data) return response
def get(self, request, provider_id, identity_id, volume_id): """ """ user = request.user 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) serialized_data = VolumeSerializer(core_volume).data response = Response(serialized_data) return response
def get(self, request, project_uuid): """ """ user = request.user group = get_user_group(user.username) project = get_group_project(group, project_uuid) if not project: return Response("Project with ID=%s does not exist" % project_uuid, status=status.HTTP_400_BAD_REQUEST) volumes = project.volumes.filter(only_current(), provider__active=True) serialized_data = VolumeSerializer(volumes, many=True, context={ "request": request }).data response = Response(serialized_data) return response
except OverQuotaError, 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) class Volume(APIView): """Details of specific volume on Identity.""" permission_classes = (ApiAuthRequired, ) 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)
def post(self, request, provider_id, identity_id, 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 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 failure_response( status.HTTP_400_BAD_REQUEST, 'Instance %s no longer exists' % (instance_id, )) action = action_params['action'] try: if 'volume' in action: volume_id = action_params.get('volume_id') if 'attach_volume' == action: mount_location = action_params.get('mount_location', None) if mount_location == 'null' or mount_location == 'None': mount_location = None device = action_params.get('device', None) if device == 'null' or device == 'None': device = None task.attach_volume_task(esh_driver, esh_instance.alias, volume_id, device, mount_location) elif 'detach_volume' == action: (result, error_msg) = task.detach_volume_task( esh_driver, esh_instance.alias, volume_id) if not result and error_msg: #Return reason for failed detachment return failure_response(status.HTTP_400_BAD_REQUEST, error_msg) #Task complete, convert the volume and return the object esh_volume = esh_driver.get_volume(volume_id) core_volume = convert_esh_volume(esh_volume, provider_id, identity_id, user) result_obj = VolumeSerializer(core_volume, context={ "request": request }).data elif 'resize' == action: size_alias = action_params.get('size', '') if type(size_alias) == int: size_alias = str(size_alias) resize_instance(esh_driver, esh_instance, size_alias, provider_id, identity_id, user) elif 'confirm_resize' == action: confirm_resize(esh_driver, esh_instance, provider_id, identity_id, user) elif 'revert_resize' == action: esh_driver.revert_resize_instance(esh_instance) elif 'redeploy' == action: redeploy_init(esh_driver, esh_instance, countdown=None) elif 'resume' == action: resume_instance(esh_driver, esh_instance, provider_id, identity_id, user) elif 'suspend' == action: suspend_instance(esh_driver, esh_instance, provider_id, identity_id, user) elif 'start' == action: start_instance(esh_driver, esh_instance, provider_id, identity_id, user) elif 'stop' == action: stop_instance(esh_driver, esh_instance, provider_id, identity_id, user) elif 'reset_network' == action: esh_driver.reset_network(esh_instance) elif 'console' == action: result_obj = esh_driver._connection.ex_vnc_console( esh_instance) elif 'reboot' == action: reboot_type = action_params.get('reboot_type', 'SOFT') reboot_instance(esh_driver, esh_instance, reboot_type) elif 'rebuild' == action: machine_alias = action_params.get('machine_alias', '') machine = esh_driver.get_machine(machine_alias) esh_driver.rebuild_instance(esh_instance, machine) else: return failure_response( status.HTTP_400_BAD_REQUEST, 'Unable to to perform action %s.' % (action)) #ASSERT: The action was executed successfully 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 ### Exception handling below.. except HypervisorCapacityError, hce: return over_capacity(hce)
description = data.get('description') try: success, esh_volume = create_volume(esh_driver, identity_id, name, size, description) except OverQuotaError, oqe: return over_quota(oqe) except InvalidCredsError: return invalid_creds(provider_id, identity_id) 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_id, identity_id, user) serialized_data = VolumeSerializer(core_volume).data return Response(serialized_data, status=status.HTTP_201_CREATED) class Volume(APIView): """ List all volumes """ @api_auth_token_required def get(self, request, provider_id, identity_id, volume_id): """ """ user = request.user esh_driver = prepare_driver(request, provider_id, identity_id) if not esh_driver: return invalid_creds(provider_id, identity_id)
def post(self, request, provider_uuid, identity_uuid): """ Updates DB values for volume """ user = request.user data = request.DATA missing_keys = valid_snapshot_post_data(data) if missing_keys: return keys_not_found(missing_keys) #Required size = data.get('size') volume_id = data.get('volume_id') display_name = data.get('display_name') #Optional description = data.get('description') metadata = data.get('metadata') snapshot_id = data.get('snapshot_id') #STEP 0 - Existence tests 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)) #TODO: Put quota tests at the TOP so we dont over-create resources! #STEP 1 - Reuse/Create snapshot if snapshot_id: snapshot = esh_driver._connection.get_snapshot(snapshot_id) if not snapshot: return failure_response( status.HTTP_400_BAD_REQUEST, "Snapshot %s not found. Process aborted." % snapshot_id) else: #Normal flow, create a snapshot from the volume if not esh_volume: return volume_not_found(volume_id) if esh_volume.extra['status'].lower() != 'available': return failure_response( status.HTTP_400_BAD_REQUEST, "Volume status must be 'available'. " "Did you detach the volume?") snapshot = esh_driver._connection.ex_create_snapshot( esh_volume, display_name, description) if not snapshot: return failure_response( status.HTTP_400_BAD_REQUEST, "Snapshot not created. Process aborted.") #STEP 2 - Create volume from snapshot try: success, esh_volume = create_volume(esh_driver, identity_uuid, display_name, size, description, metadata, snapshot=snapshot) 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) except OverQuotaError, oqe: return over_quota(oqe)
description = data.get('description') try: success, esh_volume = create_volume(esh_driver, identity_id, name, size, description) except OverQuotaError, oqe: return over_quota(oqe) except InvalidCredsError: return invalid_creds(provider_id, identity_id) 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_id, identity_id, user) serialized_data = VolumeSerializer(core_volume, context={ 'user': request.user }).data return Response(serialized_data, status=status.HTTP_201_CREATED) class Volume(APIView): """Details of specific volume on Identity.""" permission_classes = (ApiAuthRequired, ) def get(self, request, provider_id, identity_id, volume_id): """ """ user = request.user esh_driver = prepare_driver(request, provider_id, identity_id) if not esh_driver: return invalid_creds(provider_id, identity_id)