def put(self, request, app_uuid, **kwargs): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA app = Application.objects.filter(uuid=app_uuid) if not app: return failure_response(status.HTTP_404_NOT_FOUND, "No Application with uuid %s" % app_uuid) app = app[0] if 'marked' in data: if data['marked'] == True: app_bookmark, _ = ApplicationBookmark.objects.get_or_create( application=app, user=user) serialized_data = ApplicationBookmarkSerializer( app_bookmark).data response = Response(serialized_data) return response elif data['marked'] == False: app_bookmark = ApplicationBookmark.objects.filter( application=app, user=user) app_bookmark.delete() return Response(status=status.HTTP_204_NO_CONTENT) else: return failure_response(status.HTTP_400_BAD_REQUEST, "'marked' should be True/False") return failure_response(status.HTTP_400_BAD_REQUEST, "Missing 'marked' in PUT data")
def get(self, request, provider_uuid, identity_uuid, action=None): """ """ if not action: return failure_response(status.HTTP_400_BAD_REQUEST, 'Action is not supported.') try: esh_driver = prepare_driver(request, provider_uuid, identity_uuid) except ProviderNotActive as pna: return inactive_provider(pna) except Exception as e: return failure_response(status.HTTP_409_CONFLICT, e.message) if not esh_driver: return invalid_creds(provider_uuid, identity_uuid) esh_meta = esh_driver.meta() try: if 'test_links' in action: test_links = esh_meta.test_links() return Response(test_links, status=status.HTTP_200_OK) except InvalidCredsError: logger.warn( 'Authentication Failed. Provider-id:%s Identity-id:%s' % (provider_uuid, identity_uuid)) return failure_response(status.HTTP_401_UNAUTHORIZED, 'Identity/Provider Authentication Failed') except NotImplemented as ne: logger.exception(ne) return failure_response( status.HTTP_404_NOT_FOUND, 'The requested resource %s is not available on this provider' % action)
def post(self, request, provider_uuid, identity_uuid): """ Creates a new AllocationRequest for a specific identity """ try: identity = Identity.objects.get(uuid=identity_uuid) membership = IdentityMembership.objects.get(identity=identity) except Identity.DoesNotExist: return failure_response(status.HTTP_400_BAD_REQUEST, "Identity not found.") except IdentityMembership.DoesNotExist: return failure_response(status.HTTP_400_BAD_REQUEST, "IdentityMembership not found.") data = request.DATA status_type = get_status_type() new_allocation = AllocationRequest(membership=membership, created_by=request.user, status=status_type) serializer = AllocationRequestSerializer(new_allocation, data=data, partial=True) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, provider_uuid, identity_uuid, machine_id): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA if 'vote' not in data: return failure_response(status.HTTP_400_BAD_REQUEST, "Vote missing from data") vote = data['vote'] core_machine = ProviderMachine.objects.filter( provider__uuid=provider_uuid, identifier=machine_id) if not core_machine: return failure_response( status.HTTP_400_BAD_REQUEST, "Machine id %s does not exist" % machine_id) app = core_machine[0].application if 'up' in vote: vote = ApplicationScore.upvote(app, user) elif 'down' in vote: vote = ApplicationScore.downvote(app, user) else: vote = ApplicationScore.novote(app, user) serialized_data = ApplicationScoreSerializer(vote).data return Response(serialized_data, status=status.HTTP_201_CREATED)
def get(self, request, provider_uuid, identity_uuid): """ Using provider and identity, getlist of machines TODO: Cache this request """ # TODO: Decide how we should pass this in (I.E. GET query string?) active = False user = request.user provider = Provider.objects.filter(uuid=provider_uuid) if not provider: return invalid_creds(provider_uuid, identity_uuid) esh_driver = get_admin_driver(provider[0]) esh_hypervisor_list = [] if not hasattr(esh_driver._connection, 'ex_list_hypervisor_nodes'): return failure_response( status.HTTP_404_NOT_FOUND, "The Hypervisor List cannot be retrieved for this provider.") try: esh_hypervisor_list =\ esh_driver._connection.ex_list_hypervisor_nodes() region_name = esh_driver._connection._ex_force_service_region for obj in esh_hypervisor_list: obj['service_region'] = region_name response = Response(esh_hypervisor_list) return response except (socket_error, ConnectionFailure): return connection_failure(provider_uuid, identity_uuid) except Exception as exc: return failure_response( status.HTTP_404_NOT_FOUND, "Error encountered retrieving hypervisor list:%s" % exc)
def get(self, request, provider_uuid, identity_uuid, hypervisor_id): """ Lookup the Hypervisor information (Lookup using the given provider/identity) Update on server DB (If applicable) """ user = request.user provider = Provider.objects.filter(uuid=provider_uuid) if not provider: return invalid_creds(provider_uuid, identity_uuid) esh_driver = get_admin_driver(provider[0]) if not esh_driver: return invalid_creds(provider_uuid, identity_uuid) hypervisor = {} if not hasattr(esh_driver._connection, 'ex_detail_hypervisor_node'): return failure_response( status.HTTP_404_NOT_FOUND, "Hypervisor Details cannot be retrieved for this provider.") try: hypervisor = esh_driver._connection\ .ex_detail_hypervisor_node(hypervisor_id) hypervisor['cpu_info'] = json.loads(hypervisor['cpu_info']) response = Response(hypervisor) return response except (socket_error, ConnectionFailure): return connection_failure(provider_uuid, identity_uuid) except Exception as exc: return failure_response( status.HTTP_404_NOT_FOUND, "Error encountered retrieving hypervisor details:%s" % exc)
def put(self, request, provider_id, identity_id, step_id): """ Update a specific step. NOTE: This may not affect an active step. """ user = request.user serialized_data = [] data = request.DATA.copy() try: step = fetch_step(identity_id, step_id) except CoreStep.DoesNotExist: return step_not_found(step_id) if not step: return step_not_found(step_id) if not user.is_staff and user != step.created_by: return failure_response( status.HTTP_400_BAD_REQUEST, "Only the step creator can update %s step." % step_id) required_fields(data, step) serializer = StepSerializer(step, data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) return 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 post(self, request, provider_uuid, identity_uuid, machine_id): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA logger.info("data = %s" % request.DATA) core_machine = ProviderMachine.objects.filter(provider__uuid=provider_uuid, identifier=machine_id) if not core_machine: return failure_response(status.HTTP_400_BAD_REQUEST, "Machine id %s does not exist" % machine_id) core_machine = core_machine.get() if core_machine.instance_source.created_by == request.user: return failure_response(status.HTTP_400_BAD_REQUEST, "You are NOT the owner of Machine id=%s " % machine_id) if "licenses" not in data or not isinstance(data["licenses"], list): return failure_response( status.HTTP_400_BAD_REQUEST, "Licenses missing from data. Expected a list of License IDs" " ex:[1,2,3,]" ) licenses = [] # Out with the old core_machine.licenses.all().delete() for license_id in data["licenses"]: license = License.objects.get(id=license_id) # In with the new core_machine.licenses.add(license) # Return the new set. licenses = core_machine.licenses.all() logger.info("licenses = %s" % licenses) serialized_data = LicenseSerializer(licenses, many=True).data return Response(serialized_data, status=status.HTTP_202_ACCEPTED)
def post(self, request, provider_id, identity_id): """ Create a new step. """ data = request.DATA.copy() valid, messages = validate_post(data) if not valid: return failure_response(status.HTTP_400_BAD_REQUEST, messages) if data.get("instance_alias"): instance = CoreInstance.objects.get( provider_alias=data["instance_alias"]) else: instance = None if data.get("flow_alias"): flow = CoreFlow.objects.get(alias=data["flow_alias"]) else: flow = None identity = CoreIdentity.objects.get(id=identity_id) step = CoreStep(alias=uuid1(), name=data["name"], script=data["script"], instance=instance, flow=flow, created_by=request.user, created_by_identity=identity) serializer = StepSerializer(step, data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def _update_machine(self, request, provider_uuid, identity_uuid, machine_id): # TODO: Determine who is allowed to edit machines besides # core_machine.owner 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_machine = esh_driver.get_machine(machine_id) core_machine = convert_esh_machine(esh_driver, esh_machine, provider_uuid, user) if not user.is_staff and user is not core_machine.application_version.application.created_by: logger.warn("%s is Non-staff/non-owner trying to update a machine" % (user.username)) return failure_response( status.HTTP_401_UNAUTHORIZED, "Only Staff and the machine Owner " "are allowed to change machine info." ) partial_update = True if request.method == "PATCH" else False serializer = ProviderMachineSerializer( core_machine, request_user=request.user, data=data, partial=partial_update ) if serializer.is_valid(): logger.info("metadata = %s" % data) update_machine_metadata(esh_driver, esh_machine, data) machine = serializer.save() if "created_by_identity" in request.DATA: identity = machine.created_by_identity update_application_owner(core_machine.application_version.application, identity) logger.info(serializer.data) return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid, identity_uuid, action=None): """ """ if not action: return failure_response( status.HTTP_400_BAD_REQUEST, 'Action is not supported.' ) try: esh_driver = prepare_driver(request, provider_uuid, identity_uuid) except ProviderNotActive as pna: return inactive_provider(pna) except Exception as e: return failure_response( status.HTTP_409_CONFLICT, e.message) if not esh_driver: return invalid_creds(provider_uuid, identity_uuid) esh_meta = esh_driver.meta() try: if 'test_links' in action: test_links = esh_meta.test_links() return Response(test_links, status=status.HTTP_200_OK) except LibcloudInvalidCredsError: logger.warn('Authentication Failed. Provider-id:%s Identity-id:%s' % (provider_uuid, identity_uuid)) return failure_response( status.HTTP_401_UNAUTHORIZED, 'Identity/Provider Authentication Failed') except NotImplemented as ne: logger.exception(ne) return failure_response( status.HTTP_404_NOT_FOUND, 'The requested resource %s is not available on this provider' % action)
def put(self, request, provider_id, identity_id, machine_id): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA esh_driver = prepare_driver(request, provider_id, identity_id) if not esh_driver: return invalid_creds(provider_id, identity_id) esh_machine = esh_driver.get_machine(machine_id) core_machine = convert_esh_machine(esh_driver, esh_machine, provider_id) if not user.is_staff\ and user is not core_machine.application.created_by: logger.error('Non-staff/non-owner trying to update a machine') return failure_response( status.HTTP_401_UNAUTHORIZED, 'Only Staff and the machine Owner ' + 'are allowed to change machine info.') core_machine.application.update(data) serializer = ProviderMachineSerializer(core_machine, data=data, partial=True) if serializer.is_valid(): logger.info('metadata = %s' % data) update_machine_metadata(esh_driver, esh_machine, data) serializer.save() logger.info(serializer.data) return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def post(self, request, provider_uuid, identity_uuid, volume_id=None): user = request.user data = request.DATA missing_keys = valid_launch_data(data) if missing_keys: return keys_not_found(missing_keys) source = None name = data.pop('name') size_id = data.pop('size') key_name = self._select_source_key(data) if not key_name: return failure_response( status.HTTP_400_BAD_REQUEST, 'Source could not be acquired. Did you send: [' 'snapshot_id/volume_id/image_id] ?') try: core_instance = create_bootable_volume(request.user, provider_uuid, identity_uuid, name, size_id, source_alias, source_hint=key_name, **data) except Exception, exc: message = exc.message return failure_response(status.HTTP_409_CONFLICT, message)
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 _update_application(self, request, app, **kwargs): data = request.DATA user = request.user data = request.DATA app_owner = app.created_by app_members = app.get_members() if user != app_owner and not Group.check_membership(user, app_members): return failure_response( status.HTTP_403_FORBIDDEN, "You are not the Application owner. " "This incident will be reported") #Or it wont.. Up to operations.. partial_update = True if request.method == 'PATCH' else False serializer = ApplicationSerializer(app, data=data, context={'request': request}, partial=partial_update) if serializer.is_valid(): logger.info('metadata = %s' % data) #TODO: Update application metadata on each machine? #update_machine_metadata(esh_driver, esh_machine, data) serializer.save() if 'created_by_identity' in data: identity = serializer.object.created_by_identity update_application_owner(serializer.object, identity) if 'boot_scripts' in data: _save_scripts_to_application(serializer.object, data.get('boot_scripts', [])) return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def post(self, request, provider_uuid, identity_uuid, volume_id=None): user = request.user data = request.data missing_keys = valid_launch_data(data) if missing_keys: return keys_not_found(missing_keys) source = None name = data.pop('name') size_id = data.pop('size') key_name = self._select_source_key(data) if not key_name: return failure_response( status.HTTP_400_BAD_REQUEST, 'Source could not be acquired. Did you send: [' 'snapshot_id/volume_id/image_id] ?') try: core_instance = create_bootable_volume( request.user, provider_uuid, identity_uuid, name, size_id, source_alias, source_hint=key_name, **data) except Exception as exc: message = exc.message return failure_response( status.HTTP_409_CONFLICT, message) serialized_data = InstanceSerializer(core_instance, context={'request': request}).data response = Response(serialized_data) return response
def post(self, request, provider_uuid, identity_uuid): """ Create a new step. """ data = request.DATA.copy() valid, messages = validate_post(data) if not valid: return failure_response( status.HTTP_400_BAD_REQUEST, messages) if data.get("instance_alias"): instance = CoreInstance.objects.get( provider_alias=data["instance_alias"]) else: instance = None if data.get("flow_alias"): flow = CoreFlow.objects.get(alias=data["flow_alias"]) else: flow = None identity = CoreIdentity.objects.get(uuid=identity_uuid) step = CoreStep(alias=uuid1(), name=data["name"], script=data["script"], instance=instance, flow=flow, created_by=request.user, created_by_identity=identity) serializer = StepSerializer(step, data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return failure_response( status.HTTP_400_BAD_REQUEST, serializer.errors)
def delete(self, request, provider_id, identity_id, group_name, format=None): """ Unshare the identity """ try: identity = Identity.objects.get(id=identity_id) except Identity.DoesNotExist: return failure_response( status.HTTP_404_NOT_FOUND, "Identity does not exist.") if not identity.can_share(user): logger.error("User %s cannot remove sharing from identity %s. " + "This incident will be reported" % (user, identity_id)) return failure_response( status.HTTP_401_UNAUTHORIZED, "User %s cannot remove sharing from identity %s. " + "This incident will be reported" % (user, identity_id)) group = Group.objects.get(name=group_name) id_member = identity.unshare(group) serializer = IdentitySerializer(id_member.identity) serialized_data = serializer.data return Response(serialized_data)
def _update_application(self, request, app, **kwargs): data = request.DATA user = request.user data = request.DATA app_owner = app.created_by app_members = app.get_members() if user != app_owner and not Group.check_membership(user, app_members): return failure_response(status.HTTP_403_FORBIDDEN, "You are not the Application owner. " "This incident will be reported") #Or it wont.. Up to operations.. partial_update = True if request.method == 'PATCH' else False serializer = ApplicationSerializer(app, data=data, context={'request': request}, partial=partial_update) if serializer.is_valid(): logger.info('metadata = %s' % data) #TODO: Update application metadata on each machine? #update_machine_metadata(esh_driver, esh_machine, data) serializer.save() if 'created_by_identity' in data: identity = serializer.object.created_by_identity update_application_owner(serializer.object, identity) if 'boot_scripts' in data: _save_scripts_to_application(serializer.object, data.get('boot_scripts',[])) return Response(serializer.data) return failure_response( status.HTTP_400_BAD_REQUEST, serializer.errors)
def put(self, request, provider_uuid, identity_uuid, step_id): """ Update a specific step. NOTE: This may not affect an active step. """ user = request.user serialized_data = [] data = request.DATA.copy() try: step = fetch_step(identity_uuid, step_id) except CoreStep.DoesNotExist: return step_not_found(step_id) if not step: return step_not_found(step_id) if not user.is_staff and user != step.created_by: return failure_response( status.HTTP_400_BAD_REQUEST, "Only the step creator can update %s step." % step_id) required_fields(data, step) serializer = StepSerializer(step, data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) return failure_response( status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid, identity_uuid): """ Using provider and identity, getlist of machines TODO: Cache this request """ provider = Provider.objects.filter(uuid=provider_uuid) if not provider: return invalid_creds(provider_uuid, identity_uuid) esh_driver = get_admin_driver(provider[0]) esh_hypervisor_list = [] if not hasattr(esh_driver._connection, 'ex_list_hypervisor_nodes'): return failure_response( status.HTTP_404_NOT_FOUND, "The Hypervisor List cannot be retrieved for this provider.") try: esh_hypervisor_list =\ esh_driver._connection.ex_list_hypervisor_nodes() region_name = esh_driver._connection._ex_force_service_region for obj in esh_hypervisor_list: obj['service_region'] = region_name response = Response(esh_hypervisor_list) return response except (socket_error, ConnectionFailure): return connection_failure(provider_uuid, identity_uuid) except Exception as exc: return failure_response( status.HTTP_404_NOT_FOUND, "Error encountered retrieving hypervisor list:%s" % exc)
def post(self, request, provider_id, identity_id, format=None): """ Create a new identity member (ADMINS & OWNERS GROUP LEADERS ONLY) """ user = request.user data = request.DATA try: identity = Identity.objects.get(id=identity_id) group_name = data['group'] group = Group.objects.get(name=group_name) prov_member = identity.provider.share(group) id_member = identity.share(group) except ObjectDoesNotExist as odne: return failure_response( status.HTTP_404_NOT_FOUND, '%s does not exist.' % odne.message.split()[0]) if not identity.can_share(user): logger.error("User %s cannot share identity %s. " + "This incident will be reported") return failure_response( status.HTTP_401_UNAUTHORIZED, "User %s cannot remove sharing from identity %s. " + "This incident will be reported" % (user, identity_id)) serializer = IdentitySerializer(id_member.identity) serialized_data = serializer.data return Response(serialized_data)
def get(self, request, instance_id): """ Authentication required, Retrieve a list of previously launched instances. """ params = request.query_params.copy() user = User.objects.filter(username=request.user) if user and len(user) > 0: user = user[0] else: return failure_response(status.HTTP_401_UNAUTHORIZED, "Request User %s not found" % user) emulate_name = params.pop("username", None) # Support for staff users to emulate a specific user history if user.is_staff and emulate_name: emulate_name = emulate_name[0] # Querystring conversion user = User.objects.filter(username=emulate_name) if user and len(user) > 0: user = user[0] else: return failure_response(status.HTTP_401_UNAUTHORIZED, "Emulated User %s not found" % emulate_name) # List of all instances matching user, instance_id core_instance = CoreInstance.objects.filter(created_by=user, provider_alias=instance_id).order_by("-start_date") if core_instance and len(core_instance) > 0: core_instance = core_instance[0] else: return failure_response(status.HTTP_401_UNAUTHORIZED, "Instance %s not found" % instance_id) status_history = core_instance.instancestatushistory_set.order_by("start_date") serialized_data = InstanceStatusHistorySerializer(status_history, many=True).data response = Response(serialized_data) response["Cache-Control"] = "no-cache" 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, 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_id, identity_id, machine_id): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA esh_driver = prepare_driver(request, provider_id, identity_id) if not esh_driver: return invalid_creds(provider_id, identity_id) esh_machine = esh_driver.get_machine(machine_id) core_machine = convert_esh_machine(esh_driver, esh_machine, provider_id) if not user.is_staff\ and user is not core_machine.application.created_by: logger.error('Non-staff/non-owner trying to update a machine') return failure_response( status.HTTP_401_UNAUTHORIZED, 'Only Staff and the machine Owner ' + 'are allowed to change machine info.') core_machine.application.update(data) serializer = ProviderMachineSerializer(core_machine, data=data, partial=True) if serializer.is_valid(): logger.info('metadata = %s' % data) update_machine_metadata(esh_driver, esh_machine, data) serializer.save() logger.info(serializer.data) return Response(serializer.data) return failure_response( status.HTTP_400_BAD_REQUEST, serializer.errors)
def _update_threshold(self, request, app, **kwargs): user = request.user data = request.DATA app_owner = app.created_by app_members = app.get_members() if user != app_owner and not Group.check_membership(user, app_members): return failure_response( status.HTTP_403_FORBIDDEN, "You are not the Application owner. " "This incident will be reported") #Or it wont.. Up to operations.. if kwargs.get('delete'): threshold = app.get_threshold() if threshold: threshold.delete() serializer = ApplicationThresholdSerializer(app.get_threshold()) return Response(serializer.data) partial_update = True if request.method == 'PATCH' else False serializer = ApplicationThresholdSerializer( app.threshold, data=data, context={'request': request}, partial=partial_update) if serializer.is_valid(): serializer.save() logger.info(serializer.data) return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid): try: provider = Provider.get_active(provider_uuid) except Provider.DoesNotExist: return failure_response( status.HTTP_404_NOT_FOUND, "The provider does not exist.") admin_driver = get_admin_driver(provider) if not admin_driver: return failure_response( status.HTTP_404_NOT_FOUND, "The driver cannot be retrieved for this provider.") if not hasattr(admin_driver._connection, "ex_hypervisor_statistics"): return failure_response( status.HTTP_404_NOT_FOUND, "Occupancy statistics cannot be retrieved for this provider.") try: stats = admin_driver._connection.ex_hypervisor_statistics() return Response(stats) except (socket_error, ConnectionFailure): return connection_failure(provider_uuid) except Exception as exc: return failure_response( status.HTTP_503_SERVICE_UNAVAILABLE, "Error occurred while retrieving statistics: %s" % exc)
def _update_threshold(self, request, app, **kwargs): user = request.user data = request.DATA app_owner = app.created_by app_members = app.get_members() if user != app_owner and not Group.check_membership(user, app_members): return failure_response(status.HTTP_403_FORBIDDEN, "You are not the Application owner. " "This incident will be reported") #Or it wont.. Up to operations.. if kwargs.get('delete'): threshold = app.get_threshold() if threshold: threshold.delete() serializer = ApplicationThresholdSerializer( app.get_threshold()) return Response(serializer.data) partial_update = True if request.method == 'PATCH' else False serializer = ApplicationThresholdSerializer( app.threshold, data=data, context={'request': request}, partial=partial_update) if serializer.is_valid(): serializer.save() logger.info(serializer.data) return Response(serializer.data) return failure_response( status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid, identity_uuid, hypervisor_id): """ Lookup the Hypervisor information (Lookup using the given provider/identity) Update on server DB (If applicable) """ provider = Provider.objects.filter(uuid=provider_uuid) if not provider: return invalid_creds(provider_uuid, identity_uuid) esh_driver = get_admin_driver(provider[0]) if not esh_driver: return invalid_creds(provider_uuid, identity_uuid) hypervisor = {} if not hasattr(esh_driver._connection, 'ex_detail_hypervisor_node'): return failure_response( status.HTTP_404_NOT_FOUND, "Hypervisor Details cannot be retrieved for this provider.") try: hypervisor = esh_driver._connection\ .ex_detail_hypervisor_node(hypervisor_id) hypervisor['cpu_info'] = json.loads(hypervisor['cpu_info']) response = Response(hypervisor) return response except (socket_error, ConnectionFailure): return connection_failure(provider_uuid, identity_uuid) except Exception as exc: return failure_response( status.HTTP_404_NOT_FOUND, "Error encountered retrieving hypervisor details:%s" % exc)
def delete(self, request, provider_id, identity_id, group_name, format=None): """ Unshare the identity """ try: identity = Identity.objects.get(id=identity_id) except Identity.DoesNotExist: return failure_response(status.HTTP_404_NOT_FOUND, "Identity does not exist.") if not identity.can_share(user): logger.error("User %s cannot remove sharing from identity %s. " + "This incident will be reported" % (user, identity_id)) return failure_response( status.HTTP_401_UNAUTHORIZED, "User %s cannot remove sharing from identity %s. " + "This incident will be reported" % (user, identity_id)) group = Group.objects.get(name=group_name) id_member = identity.unshare(group) serializer = IdentitySerializer(id_member.identity) serialized_data = serializer.data return Response(serialized_data)
def post(self, request, provider_uuid, identity_uuid, machine_id): """ TODO: Determine who is allowed to edit machines besides core_machine.owner """ user = request.user data = request.DATA if 'vote' not in data: return failure_response( status.HTTP_400_BAD_REQUEST, "Vote missing from data") vote = data['vote'] core_machine = ProviderMachine.objects.filter( provider__uuid=provider_uuid, identifier=machine_id) if not core_machine: return failure_response( status.HTTP_400_BAD_REQUEST, "Machine id %s does not exist" % machine_id) app = core_machine[0].application if 'up' in vote: vote = ApplicationScore.upvote(app, user) elif 'down' in vote: vote = ApplicationScore.downvote(app, user) else: vote = ApplicationScore.novote(app, user) serialized_data = ApplicationScoreSerializer(vote).data return Response(serialized_data, status=status.HTTP_201_CREATED)
def get(self, request, provider_id=None, identity_id=None): data = request.DATA params = request.QUERY_PARAMS.copy() user = User.objects.filter(username=request.user) if user and len(user) > 0: user = user[0] else: return failure_response(status.HTTP_401_UNAUTHORIZED, 'User not found') page = params.pop('page', None) emulate_name = params.pop('username', None) try: # Support for staff users to emulate a specific user history if user.is_staff and emulate_name: emualate_name = emulate_name[0] # Querystring conversion user = User.objects.get(username=emulate_name) # List of all instances created by user history_instance_list = CoreInstance.objects.filter( created_by=user).order_by("-start_date") #Filter the list based on query strings for filter_key, value in params.items(): if 'start_date' == filter_key: history_instance_list = history_instance_list.filter( start_date__gt=value) elif 'end_date' == filter_key: history_instance_list = history_instance_list.filter( Q(end_date=None) | Q(end_date__lt=value)) elif 'ip_address' == filter_key: history_instance_list = history_instance_list.filter( ip_address__contains=value) elif 'alias' == filter_key: history_instance_list = history_instance_list.filter( provider_alias__contains=value) except Exception as e: return failure_response( status.HTTP_400_BAD_REQUEST, 'Bad query string caused filter validation errors : %s' % (e,)) if page: paginator = Paginator(history_instance_list, 5) try: history_instance_page = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. history_instance_page = paginator.page(1) except EmptyPage: # Page is out of range. # deliver last page of results. history_instance_page = paginator.page(paginator.num_pages) serialized_data = \ PaginatedInstanceHistorySerializer( history_instance_page).data else: serialized_data = InstanceHistorySerializer(history_instance_list, many=True).data response = Response(serialized_data) response['Cache-Control'] = 'no-cache' return response
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 get(self, request): """ Authentication required, Retrieve a list of previously launched instances. """ data = request.DATA params = request.QUERY_PARAMS.copy() emulate_name = params.pop('username', None) user = request.user # Support for staff users to emulate a specific user history if user.is_staff and emulate_name: emualate_name = emulate_name[0] # Querystring conversion try: user = User.objects.get(username=emulate_name) except User.DoesNotExist: return failure_response( status.HTTP_401_UNAUTHORIZED, 'Emulated User %s not found' % emualte_name) try: # List of all instances created by user sort_by = params.get('sort_by', '') order_by = params.get('order_by', 'desc') history_instance_list = CoreInstance.objects.filter( created_by=user).order_by("-start_date") history_instance_list = _filter_instance_history( history_instance_list, params) history_instance_list = _sort_instance_history( history_instance_list, sort_by, 'desc' in order_by.lower()) except Exception as e: return failure_response( status.HTTP_400_BAD_REQUEST, 'Bad query string caused filter validation errors : %s' % (e, )) page = params.get('page') if page or len(history_instance_list) == 0: paginator = Paginator(history_instance_list, 20, allow_empty_first_page=True) else: paginator = Paginator(history_instance_list, len(history_instance_list), allow_empty_first_page=True) try: history_instance_page = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. history_instance_page = paginator.page(1) except EmptyPage: # Page is out of range. # deliver last page of results. history_instance_page = paginator.page(paginator.num_pages) serialized_data = PaginatedInstanceHistorySerializer( history_instance_page, context={ 'request': request }).data response = Response(serialized_data) response['Cache-Control'] = 'no-cache' return response
def post(self, request, provider_uuid, identity_uuid): """ Creates a new volume and adds it to the DB """ user = request.user driver = prepare_driver(request, provider_uuid, identity_uuid) if not driver: return invalid_creds(provider_uuid, identity_uuid) data = request.data missing_keys = valid_volume_post_data(data) if missing_keys: return keys_not_found(missing_keys) # Pass arguments name = data.get('name') size = data.get('size') # Optional fields description = data.get('description') image_id = data.get('image') if image_id: image = driver.get_machine(image_id) image_size = image._connection.get_size(image._image) if int(size) > image_size + 4: return failure_response( status.HTTP_400_BAD_REQUEST, "Volumes created from images cannot exceed " "more than 4GB greater than the size of " "the image: %s GB" % image_size) else: image = None snapshot_id = data.get('snapshot') if snapshot_id: snapshot = driver._connection.ex_get_snapshot(image_id) else: snapshot = None try: success, esh_volume = create_volume(driver, identity_uuid, name, size, description, snapshot=snapshot, image=image) except OverQuotaError as 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)
def get(self, request): """ Authentication required, Retrieve a list of previously launched instances. """ data = request.DATA params = request.QUERY_PARAMS.copy() emulate_name = params.pop('username', None) user = request.user # Support for staff users to emulate a specific user history if user.is_staff and emulate_name: emualate_name = emulate_name[0] # Querystring conversion try: user = User.objects.get(username=emulate_name) except User.DoesNotExist: return failure_response(status.HTTP_401_UNAUTHORIZED, 'Emulated User %s not found' % emualte_name) try: # List of all instances created by user sort_by = params.get('sort_by','') order_by = params.get('order_by','desc') history_instance_list = CoreInstance.objects.filter( created_by=user).order_by("-start_date") history_instance_list = _filter_instance_history( history_instance_list, params) history_instance_list = _sort_instance_history( history_instance_list, sort_by, 'desc' in order_by.lower()) except Exception as e: return failure_response( status.HTTP_400_BAD_REQUEST, 'Bad query string caused filter validation errors : %s' % (e,)) page = params.get('page') if page or len(history_instance_list) == 0: paginator = Paginator(history_instance_list, 20, allow_empty_first_page=True) else: paginator = Paginator(history_instance_list, len(history_instance_list), allow_empty_first_page=True) try: history_instance_page = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. history_instance_page = paginator.page(1) except EmptyPage: # Page is out of range. # deliver last page of results. history_instance_page = paginator.page(paginator.num_pages) serialized_data = PaginatedInstanceHistorySerializer( history_instance_page, context={'request':request}).data response = Response(serialized_data) response['Cache-Control'] = 'no-cache' return response
def post(self, request, provider_uuid, identity_uuid): """ Sends an e-mail to the admins to start the create_image process. """ #request.DATA is r/o #Copy allows for editing data = copy.deepcopy(request.DATA) data.update({'owner': data.get('created_for', request.user.username)}) if data.get('vis','public') != 'public': user_list = re.split(', | |\n', data.get('shared_with',"")) share_with_admins(user_list, data.get('provider')) share_with_self(user_list, request.user.username) user_list = [user for user in user_list if user] # Skips blanks #TODO: Remove duplicates as well.. data['shared_with'] = user_list logger.info(data) serializer = MachineRequestSerializer(data=data) if serializer.is_valid(): #Add parent machine to request machine_request = serializer.object instance = machine_request.instance if instance.source.is_machine(): machine_request.parent_machine = machine_request.instance\ .source.providermachine elif instance.source.is_volume(): return failure_response(status.HTTP_400_BAD_REQUEST, "Instance of booted volume can NOT be imaged." "Contact your Administrator for more information.") else: return failure_response(status.HTTP_400_BAD_REQUEST, "Instance source type cannot be determined." "Contact your Administrator for more information.") #NOTE: THIS IS A HACK -- While we enforce all images to go to iPlant Cloud - Tucson. # THIS CODE SHOULD BE REMOVED try: tucson_provider = Provider.objects.get(location='iPlant Cloud - Tucson') if machine_request.new_machine_provider.location != tucson_provider.location: machine_request.new_machine_provider = tucson_provider except: pass serializer.save() #Object now has an ID for links.. machine_request_id = serializer.object.id active_provider = machine_request.active_provider() auto_approve = active_provider.has_trait("Auto-Imaging") requestImaging(request, machine_request_id, auto_approve=auto_approve) if auto_approve: start_machine_imaging(machine_request) return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, provider_uuid, identity_uuid): """ Sends an e-mail to the admins to start the create_image process. """ try: return self._create_image(request, provider_uuid, identity_uuid) except ActionNotAllowed: return failure_response( status.HTTP_409_CONFLICT, "Machine Imaging has been " "explicitly disabled on this provider." ) except Exception as exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message)
def post(self, request, provider_uuid, identity_uuid): """ Sends an e-mail to the admins to start the create_image process. """ try: return self._create_image(request, provider_uuid, identity_uuid) except ActionNotAllowed: return failure_response( status.HTTP_409_CONFLICT, "Machine Imaging has been " "explicitly disabled on this provider.") except Exception, exc: return failure_response(status.HTTP_400_BAD_REQUEST, exc.message)
def _update_script(self, request, script_id): user = request.user data = request.DATA partial = True if request.method == "PATCH" else False # Step 1: Retrieve or 'Forbidden' on updating script scripts = get_scripts_for_user(user.username) try: script = scripts.get(id=script_id) except CoreBootScript.DoesNotExist: return failure_response(status.HTTP_404_NOT_FOUND, "BootScript of id %s does not exist." % script_id) serializer = BootScriptSerializer(script, data=data, partial=partial) if serializer.is_valid(): serializer.save() return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid, identity_uuid): """ Using provider and identity, getlist of machines TODO: Cache this request """ try: request_user = request.user logger.debug("filtered_machine_list") filtered_machine_list = provider_filtered_machines(request, provider_uuid, identity_uuid, request_user) #logger.debug(filtered_machine_list) except InvalidCredsError: return invalid_creds(provider_uuid, identity_uuid) except MalformedResponseError: return malformed_response(provider_uuid, identity_uuid) except (socket_error, ConnectionFailure): return connection_failure(provider_uuid, identity_uuid) except Exception as e: logger.exception("Unexpected exception for user:%s" % request_user) return failure_response(status.HTTP_500_INTERNAL_SERVER_ERROR, e.message) #logger.debug(filtered_machine_list) serialized_data = ProviderMachineSerializer(filtered_machine_list, request_user=request.user, many=True).data response = Response(serialized_data) return response
def post(self, request): """ """ user = request.user data = request.DATA if data.get('name') == 'Default': return Response("The 'Default' project name is reserved", status=status.HTTP_409_CONFLICT) #Default to creating for the 'user-group' if not data.get('owner'): data['owner'] = user.username elif not Group.check_access(user, data['owner']): return failure_response( status.HTTP_403_FORBIDDEN, "Current User: %s - Cannot assign project for group %s" % (user.username, data['owner'])) serializer = ProjectSerializer(data=data, context={"user": request.user}) if serializer.is_valid(): serializer.save() response = Response(serializer.data, status=status.HTTP_201_CREATED) return response else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_esh_instance(request, provider_uuid, identity_uuid, instance_id): esh_driver = prepare_driver(request, provider_uuid, identity_uuid) if not esh_driver: raise InvalidCredsError( "Provider_uuid && identity_uuid " "did not produce a valid combination") esh_instance = None 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: # End date everything try: core_inst = CoreInstance.objects.get( provider_alias=instance_id, source__provider__uuid=provider_uuid, created_by_identity__uuid=identity_uuid) core_inst.end_date_all() except CoreInstance.DoesNotExist: pass return esh_instance
def get(self, request, provider_id, identity_id, format=None): """ Return the credential information for this identity """ #Sanity checks: # User is authenticated user = request.user try: # User is a member of a group ( TODO: loop through all instead) group = user.group_set.get(name=user.username) # Group has access to the active, running provider provider = group.providers.get(id=provider_id, active=True, end_date=None) # Group has access to the identity on that provider identity = group.identities.get(provider=provider, id=identity_id) # All other members of the identity are visible id_members = CoreIdentityMembership.objects.filter( identity__id=identity_id) except ObjectDoesNotExist as odne: return failure_response( status.HTTP_404_NOT_FOUND, '%s does not exist.' % odne.message.split()[0]) id_list = [id_member.identity for id_member in id_members[:1]] serializer = IdentitySerializer(id_list, many=True) serialized_data = serializer.data return Response(serialized_data)
def get_esh_instance(request, provider_uuid, identity_uuid, instance_id): esh_driver = prepare_driver(request, provider_uuid, identity_uuid) if not esh_driver: raise LibcloudInvalidCredsError("Provider_uuid && identity_uuid " "did not produce a valid combination") esh_instance = None 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: # End date everything try: core_inst = CoreInstance.objects.get( provider_alias=instance_id, source__provider__uuid=provider_uuid, created_by_identity__uuid=identity_uuid) core_inst.end_date_all() except CoreInstance.DoesNotExist: pass return esh_instance
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) 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 (InstanceSource.DoesNotExist, 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, 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 _email_instance_owner(self, request, params): ''' OLD API ''' instance_token = params.get('token') username = params.get('userid') vm_info = params.get('vminfo') instance_name = params.get('name') instance = CoreInstance.objects.filter( provider_alias=vm_info['instance-id']) error_list = [] if not instance: error_list.append("The token %s did not match a core instance." % instance_token) instance = CoreInstance.objects.filter( ip_address=request.META['REMOTE_ADDR']) if not instance: error_list.append( "The IP Address %s did not match a core instance." % request.META['REMOTE_ADDR']) return failure_response(status.HTTP_404_NOT_FOUND, str(error_list)) instance = instance[0] ip_address = vm_info.get('public-ipv4', request.META.get('REMOTE_ADDR')) if ip_address: instance.ip_address = ip_address instance.save() launch_time = instance.start_date linuxusername = vm_info.get('linuxusername', instance.created_by) instance_id = vm_info.get('instance-id', instance.provider_alias) # Only send email if the provider isn't OpenStack. if instance.created_by_identity.provider.type.name != "OpenStack": send_instance_email(username, instance_id, instance_name, ip_address, launch_time, linuxusername)
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 (socket_error, 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) except Exception: logger.exception("Uncaught Exception in Volume list method") return failure_response( status.HTTP_500_INTERNAL_SERVER_ERROR, 'Volume list method failed. Contact support') 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 get(self, request, provider_uuid, identity_uuid): """ Using provider and identity, getlist of machines TODO: Cache this request """ try: request_user = request.user logger.debug("filtered_machine_list") filtered_machine_list = provider_filtered_machines( request, provider_uuid, identity_uuid, request_user) logger.debug(filtered_machine_list) except InvalidCredsError: return invalid_creds(provider_uuid, identity_uuid) except MalformedResponseError: return malformed_response(provider_uuid, identity_uuid) except Exception as e: logger.exception("Unexpected exception for user:%s" % request_user) return failure_response(status.HTTP_500_INTERNAL_SERVER_ERROR, e.message) logger.debug(filtered_machine_list) serialized_data = ProviderMachineSerializer(filtered_machine_list, request_user=request.user, many=True).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 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 _update_script(self, request, script_id): user = request.user data = request.DATA partial = True if request.method == 'PATCH' else False # Step 1: Retrieve or 'Forbidden' on updating script scripts = get_scripts_for_user(user.username) try: script = scripts.get(id=script_id) except CoreBootScript.DoesNotExist: return failure_response( status.HTTP_404_NOT_FOUND, "BootScript of id %s does not exist." % script_id) serializer = BootScriptSerializer(script, data=data, partial=partial) if serializer.is_valid(): serializer.save() return Response(serializer.data) return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def get(self, request, provider_uuid, identity_uuid, instance_id): """ Authentication Required, get instance details. """ user = request.user # NOTE: This 'Scheme' should be used across # the ENTIRE API v1 (Machines, Volumes, Sizes) # NOTE: Especially the part below, where you end date # all the things that are 'inactive' try: provider = Provider.objects.get(uuid=provider_uuid) if not provider.is_active(): raise ProviderNotActive(provider) except Provider.DoesNotExist: return invalid_creds(provider_uuid, identity_uuid) except ProviderNotActive as pna: return inactive_provider(pna) # Cleared provider testing -- ready for driver prep. try: esh_driver = prepare_driver(request, provider_uuid, identity_uuid) logger.info("InstanceQuery Looking for %s" % instance_id) esh_instance = esh_driver.get_instance(instance_id) logger.info("InstanceQuery Found instance %s" % esh_instance) except (socket_error, ConnectionFailure): logger.exception("Connection failure prevented InstanceQuery") return connection_failure(provider_uuid, identity_uuid) except LibcloudInvalidCredsError: logger.exception("Invalid credentialsprevented InstanceQuery") 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)) # NOTE: Especially THIS part below, where you end date all the # things that are 'inactive' if not esh_instance: try: core_inst = CoreInstance.objects.get( provider_alias=instance_id, source__provider__uuid=provider_uuid, created_by_identity__uuid=identity_uuid) core_inst.end_date_all() except CoreInstance.DoesNotExist: pass return instance_not_found(instance_id) core_instance = convert_esh_instance(esh_driver, esh_instance, provider_uuid, identity_uuid, user) serialized_data = InstanceSerializer(core_instance, context={ "request": request }).data response = Response(serialized_data) response['Cache-Control'] = 'no-cache' return response