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 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): request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing") try: self._validate_data(request_user, request_data) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: user_allocation_source = self._create_user_allocation_source( request_data) serialized_user_allocation_source = UserAllocationSourceSerializer( user_allocation_source, context={'request': self.request}) return Response(serialized_user_allocation_source.data, status=status.HTTP_201_CREATED) except Exception as exc: logger.exception( "Encountered exception while assigning Allocation source %s to User %s" % (request_data['allocation_source_name'], request_data['username'])) return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def delete(self, request): request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing") try: self._validate_data(request_user, request_data, delete=True) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: self._delete_user_allocation_source(request_data) return Response( status=status.HTTP_200_OK) except Exception as exc: logger.exception( "Encountered exception while removing User %s from Allocation source %s " % (request_data['username']), request_data['allocation_source_name']) return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def retrieve(self, request, pk=None): """ Retrieve a signed token for a web desktop view. """ if not request.user.is_authenticated(): raise PermissionDenied client = request.query_params.get('client') valid_guac = client == "guacamole" and settings.GUACAMOLE_ENABLED valid_webdesktop = client == "web_desktop" if not (valid_guac or valid_webdesktop): return failure_response( status.HTTP_400_BAD_REQUEST, 'Invalid or missing "client" query paramater') instance = self.get_queryset().filter(provider_alias=pk).first() if not instance: return failure_response( status.HTTP_404_NOT_FOUND, 'Instance %s not found / no longer exists' % pk) token = None token_url = None try: if client == 'guacamole': token, token_url = self.guacamole_token(instance.ip_address) else: token, token_url = self.web_desktop_token(instance.ip_address) except: logger.exception("Atmosphere failed to retrieve web token") return HttpResponse("Atmosphere failed to retrieve web token", status=500) return Response({'token': token, 'token_url': token_url})
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 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 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 create(self, request): request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing") if not request_data['action']: return failure_response(status.HTTP_400_BAD_REQUEST, "Command name is missing") try: self._validate_user(request_data,request_user) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) action = str(request_data['action']) if action=='create_allocation_source': return self.create_allocation_source(request_data,request_user) elif action=='change_renewal_strategy': return self.change_renewal_strategy(request_data,request_user) elif action=='change_allocation_source_name': return self.change_allocation_source_name(request_data,request_user) elif action=='change_compute_allowed': return self.change_allocation_source_compute_allowed(request_data,request_user) else: return failure_response(status.HTTP_400_BAD_REQUEST, "Incorrect command name")
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 create(self, request): request_user = request.user request_data = request.data if not request_data.items(): return failure_response( status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing" ) try: self._validate_data(request_user, request_data) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: instance_allocation_source = self._create_instance_allocation_source( request_data, request_user ) serialized_instance_allocation_source = InstanceAllocationSourceSerializer( instance_allocation_source, context={'request': self.request} ) return Response( serialized_instance_allocation_source.data, status=status.HTTP_201_CREATED ) except Exception as exc: logger.exception( "Encountered exception while assigning Allocation source %s to Instance %s" % ( request_data['allocation_source_name'], request_data['instance_id'] ) ) 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 create(self, request): request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing") if not request_data['action']: return failure_response(status.HTTP_400_BAD_REQUEST, "Command name is missing") try: self._validate_user(request_data, request_user) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) action = str(request_data['action']) if action == 'create_allocation_source': return self.create_allocation_source(request_data, request_user) elif action == 'change_renewal_strategy': return self.change_renewal_strategy(request_data, request_user) elif action == 'change_allocation_source_name': return self.change_allocation_source_name(request_data, request_user) elif action == 'change_compute_allowed': return self.change_allocation_source_compute_allowed( request_data, request_user) else: return failure_response(status.HTTP_400_BAD_REQUEST, "Incorrect command name")
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 list(self, request, *args, **kwargs): """ Force an abnormal behavior when no query_params are passed """ query_params = self.request.query_params if not query_params.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "The reporting API should be accessed via the query parameters:" " ['start_date', 'end_date', 'provider_id']") try: results = super(ReportingViewSet, self).list(request, *args, **kwargs) except ValueError: return failure_response(status.HTTP_400_BAD_REQUEST, 'Invalid filter parameters') return results
def perform_destroy(self, allocation_source, request=None): if not hasattr(self, 'request'): self.request = request request_user = self.request.user request_data = {} request_data['allocation_source_name'] = allocation_source.name # validate user try: self._validate_user(request_user) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) # validate patched fields and update allocation source model try: self._validate_params(request_data) # create payload payload = {} payload['allocation_source_name'] = str(request_data['allocation_source_name']) payload['delete_date'] = str(timezone.now().strftime("%Y-%m-%dT%H:%M:%S+00:00")) EventTable.create_event( 'allocation_source_removed', payload, payload['allocation_source_name']) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = allocation_source serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response( serialized_allocation_source.data, status=status.HTTP_200_OK) except Exception as exc: logger.exception( "Encountered exception while removing Allocation Source") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def change_renewal_strategy(self, request_data, request_user): try: self._validate_for_change_renewal_strategy(request_user, request_data) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._change_renewal_strategy(request_data) serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response(serialized_allocation_source.data, status=status.HTTP_201_CREATED) except Exception as exc: logger.exception( "Encountered exception while changing renewal strategy") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def change_allocation_source_compute_allowed(self, request_data, request_user): try: self._validate_for_change_allocation_source_compute_allowed(request_user, request_data) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._change_allocation_source_compute_allowed(request_data) serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response(serialized_allocation_source.data, status=status.HTTP_201_CREATED) except Exception as exc: logger.exception("Encountered exception while changing renewal strategy") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def list(self, request, *args, **kwargs): """ Force an abnormal behavior when no query_params are passed """ query_params = self.request.query_params if not query_params.items(): return failure_response( status.HTTP_400_BAD_REQUEST, "The reporting API should be accessed via the query parameters:" " ['start_date', 'end_date', 'provider_id']") try: results = super(ReportingViewSet, self).list(request, *args, **kwargs) except ValueError: return failure_response(status.HTTP_400_BAD_REQUEST, 'Invalid filter parameters') return results
def retrieve(self, *args, **kwargs): instance = self.get_object() params = self.request.query_params try: instance_metrics = get_instance_metrics(instance, params) except Exception as exc: logger.exception("Failed to retrieve instance metrics") return failure_response(status.HTTP_409_CONFLICT, str(exc.message)) return Response(instance_metrics)
def create(self, request): """ Create allocation source and fire respective events """ if not hasattr(self, 'request'): self.request = request request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Request Data is missing") try: self._validate_user(request_user) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: self._validate_params(request_data) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._create_allocation_source(request_data) # CHANGE SERIALIZER CLASS serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response( serialized_allocation_source.data, status=status.HTTP_201_CREATED) except Exception as exc: logger.exception( "Encountered exception while creating Allocation Source") 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 perform_destroy(self, allocation_source, request=None): if not hasattr(self, 'request'): self.request = request request_user = self.request.user request_data = {} request_data['allocation_source_name'] = allocation_source.name # validate user try: self._validate_user(request_user) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) # validate patched fields and update allocation source model try: self._validate_params(request_data) # create payload payload = {} payload['allocation_source_name'] = str( request_data['allocation_source_name']) payload['delete_date'] = str( timezone.now().strftime("%Y-%m-%dT%H:%M:%S+00:00")) EventTable.create_event('allocation_source_removed', payload, payload['allocation_source_name']) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = allocation_source serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response(serialized_allocation_source.data, status=status.HTTP_200_OK) except Exception as exc: logger.exception( "Encountered exception while removing Allocation Source") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def remove_user(self, request, pk=None): group = self.lookup_group(pk) data = request.data del_user = data.pop('username') user = AtmosphereUser.objects.filter(username=del_user) if not user.count(): return failure_response(409, "Username %s does not exist" % del_user) user = user[0] group.user_set.remove(user) serialized_data = GroupSerializer(group, context={'request': request}).data return Response(serialized_data)
def create(self, *args, **kwargs): user = self.request.user data = self.request.data missing_keys = self.check_missing_keys(data, self.required_keys) if missing_keys: return failure_response( status.HTTP_400_BAD_REQUEST, "Missing required POST data variables : %s" % missing_keys) # Inject SERVER_URL settings data['server'] = settings.SERVER_URL result = self._email(user, data) return result
def retrieve(self, request, pk=None): """ Retrieve a signed token for a web desktop view. """ if not request.user.is_authenticated(): raise PermissionDenied client = request.query_params.get('client') valid_guac = client == "guacamole" and settings.GUACAMOLE_ENABLED valid_webdesktop = client == "web_desktop" if not (valid_guac or valid_webdesktop): return failure_response( status.HTTP_400_BAD_REQUEST, 'Invalid or missing "client" query paramater') instance = self.get_queryset().filter(provider_alias=pk).first() if not instance: return failure_response( status.HTTP_404_NOT_FOUND, 'Instance %s not found / no longer exists' % pk) token = None token_url = None try: if client == 'guacamole': token, token_url = self.guacamole_token(instance.ip_address) else: token, token_url = self.web_desktop_token(instance.ip_address) except: logger.exception("Atmosphere failed to retrieve web token") return HttpResponse( "Atmosphere failed to retrieve web token", status=500) return Response({ 'token': token, 'token_url': token_url })
def create(self, request): """ Create allocation source and fire respective events """ if not hasattr(self, 'request'): self.request = request request_user = request.user request_data = request.data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Request Data is missing") try: self._validate_user(request_user) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: self._validate_params(request_data) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._create_allocation_source(request_data) # CHANGE SERIALIZER CLASS serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response(serialized_allocation_source.data, status=status.HTTP_201_CREATED) except Exception as exc: logger.exception( "Encountered exception while creating Allocation Source") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def remove_user(self, request, pk=None): group = self.lookup_group(pk) data = request.data del_user = data.pop('username') user = AtmosphereUser.objects.filter(username=del_user) if not user.count(): return failure_response(409, "Username %s does not exist" % del_user) user = user[0] group.user_set.remove(user) serialized_data = GroupSerializer(group, context={ 'request': request }).data return Response(serialized_data)
def delete(self, request): request_user = request.user request_data = request.data if not request_data.items(): return failure_response( status.HTTP_400_BAD_REQUEST, "Reuquest Data is missing" ) try: self._validate_data(request_user, request_data, delete=True) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: self._delete_user_allocation_source(request_data) return Response(status=status.HTTP_200_OK) except Exception as exc: logger.exception( 'Encountered exception while removing User %s from Allocation source %s', request_data['username'], request_data['allocation_source_name'] ) return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def update(self, request, pk, *args, **fields): if not hasattr(self, 'request'): self.request = request request_user = request.user request_data = request.data request_data['source_id'] = pk request_data['allocation_source_name'] = AllocationSource.objects.filter(uuid=pk).last().name # check for data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Request Data is missing") # validate user try: self._validate_user(request_user) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) # validate patched fields and update allocation source model try: self._validate_params(request_data) # create payload payload = {} payload['allocation_source_name'] = request_data['allocation_source_name'] # events to call events = [] # if 'name' in request_data: # payload_name = payload.copy() # payload_name['name'] = request_data['name'] # events.append(( # 'allocation_source_name_changed', # payload_name)) if 'renewal_strategy' in request_data: payload_renewal_strategy = payload.copy() payload_renewal_strategy['renewal_strategy'] = request_data['renewal_strategy'] events.append(( 'allocation_source_renewal_strategy_changed', payload_renewal_strategy)) if 'compute_allowed' in request_data: payload_compute_allowed = payload.copy() payload_compute_allowed['compute_allowed'] = request_data['compute_allowed'] events.append(( 'allocation_source_compute_allowed_changed', payload_compute_allowed)) except Exception as exc: return failure_response( status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._update_allocation_source( events, request_data) serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response( serialized_allocation_source.data, status=status.HTTP_200_OK) except Exception as exc: logger.exception( "Encountered exception while updating Allocation Source") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
def update(self, request, pk, *args, **fields): if not hasattr(self, 'request'): self.request = request request_user = request.user request_data = request.data request_data['source_id'] = pk request_data[ 'allocation_source_name'] = AllocationSource.objects.filter( uuid=pk).last().name # check for data if not request_data.items(): return failure_response(status.HTTP_400_BAD_REQUEST, "Request Data is missing") # validate user try: self._validate_user(request_user) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) # validate patched fields and update allocation source model try: self._validate_params(request_data) # create payload payload = {} payload['allocation_source_name'] = request_data[ 'allocation_source_name'] # events to call events = [] # if 'name' in request_data: # payload_name = payload.copy() # payload_name['name'] = request_data['name'] # events.append(( # 'allocation_source_name_changed', # payload_name)) if 'renewal_strategy' in request_data: payload_renewal_strategy = payload.copy() payload_renewal_strategy['renewal_strategy'] = request_data[ 'renewal_strategy'] events.append(('allocation_source_renewal_strategy_changed', payload_renewal_strategy)) if 'compute_allowed' in request_data: payload_compute_allowed = payload.copy() payload_compute_allowed['compute_allowed'] = request_data[ 'compute_allowed'] events.append(('allocation_source_compute_allowed_changed', payload_compute_allowed)) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message) try: allocation_source = self._update_allocation_source( events, request_data) serialized_allocation_source = AllocationSourceSerializer( allocation_source, context={'request': self.request}) return Response(serialized_allocation_source.data, status=status.HTTP_200_OK) except Exception as exc: logger.exception( "Encountered exception while updating Allocation Source") return failure_response(status.HTTP_409_CONFLICT, str(exc.message))