Пример #1
0
    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 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))
Пример #3
0
    def post(self, request, provider_uuid, identity_uuid, format=None):
        """
        Instance Class:
        Launches an instance based on the params
        Returns a single instance

        Parameters: machine_alias, size_alias, username

        TODO: Create a 'reverse' using the instance-id to pass
        the URL for the newly created instance
        I.e: url = "/provider/1/instance/1/i-12345678"
        """
        data = request.data
        user = request.user
        # Check the data is valid
        missing_keys = valid_post_data(data)
        if missing_keys:
            return keys_not_found(missing_keys)
        # Pass these as args
        size_alias = data.pop("size_alias")
        allocation_source_id = data.pop("allocation_source_id", None)
        machine_alias = data.pop("machine_alias")
        hypervisor_name = data.pop("hypervisor", None)
        if hypervisor_name:
            # Previous method passed this with 'None' but that fails now.
            # This check will only add the ex_ value if it is 'truthy'.
            data['ex_hypervisor_name'] = hypervisor_name
        deploy = data.pop("deploy", True)
        if type(deploy) in [str, unicode] and deploy.lower() == "false":
            deploy = False
        elif not isinstance(deploy, bool):
            deploy = True
        boot_scripts = data.pop("scripts", [])
        try:
            logger.debug(data)
            if not settings.USE_ALLOCATION_SOURCE:
                allocation_source = None
            else:
                allocation_source = AllocationSource.objects.get(
                    source_id=allocation_source_id)
            core_instance = launch_instance(user,
                                            identity_uuid,
                                            size_alias,
                                            machine_alias,
                                            deploy=deploy,
                                            **data)
        except UnderThresholdError as ute:
            return under_threshold(ute)
        except OverQuotaError as oqe:
            return over_quota(oqe)
        except OverAllocationError as oae:
            return over_quota(oae)
        except SizeNotAvailable as snae:
            return size_not_available(snae)
        except SecurityGroupNotCreated:
            return connection_failure(provider_uuid, identity_uuid)
        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))

        serializer = InstanceSerializer(core_instance,
                                        context={"request": request},
                                        data=data)
        if serializer.is_valid():
            instance = serializer.save()
            if boot_scripts:
                _save_scripts_to_instance(instance, boot_scripts)
            instance.change_allocation_source(allocation_source)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)
Пример #4
0
    def post(self, request, provider_uuid, identity_uuid, format=None):
        """
        Instance Class:
        Launches an instance based on the params
        Returns a single instance

        Parameters: machine_alias, size_alias, username

        TODO: Create a 'reverse' using the instance-id to pass
        the URL for the newly created instance
        I.e: url = "/provider/1/instance/1/i-12345678"
        """
        data = request.data
        user = request.user
        # Check the data is valid
        missing_keys = valid_post_data(data)
        if missing_keys:
            return keys_not_found(missing_keys)
        # Pass these as args
        size_alias = data.pop("size_alias")
        machine_alias = data.pop("machine_alias")
        hypervisor_name = data.pop("hypervisor", None)
        if hypervisor_name:
            # Previous method passed this with 'None' but that fails now.
            # This check will only add the ex_ value if it is 'truthy'.
            data['ex_hypervisor_name'] = hypervisor_name
        deploy = data.pop("deploy", True)
        if type(deploy) in [str, unicode] and deploy.lower() == "false":
            deploy = False
        elif not isinstance(deploy, bool):
            deploy = True
        boot_scripts = data.pop("scripts", [])
        try:
            logger.debug(data)
            core_instance = launch_instance(
                user, identity_uuid,
                size_alias, machine_alias,
                deploy=deploy, **data)
        except UnderThresholdError as ute:
            return under_threshold(ute)
        except OverQuotaError as oqe:
            return over_quota(oqe)
        except OverAllocationError as oae:
            return over_quota(oae)
        except SizeNotAvailable as snae:
            return size_not_available(snae)
        except SecurityGroupNotCreated:
            return connection_failure(provider_uuid, identity_uuid)
        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))

        serializer = InstanceSerializer(core_instance,
                                        context={"request": request},
                                        data=data)
        if serializer.is_valid():
            instance = serializer.save()
            if boot_scripts:
                _save_scripts_to_instance(instance, boot_scripts)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)
Пример #5
0
    def post(self, request, provider_uuid, identity_uuid, format=None):
        """
        Instance Class:
        Launches an instance based on the params
        Returns a single instance

        Parameters: machine_alias, size_alias, username

        TODO: Create a 'reverse' using the instance-id to pass
        the URL for the newly created instance
        I.e: url = "/provider/1/instance/1/i-12345678"
        """
        data = request.data
        user = request.user
        # Check the data is valid
        missing_keys = valid_post_data(data)
        if missing_keys:
            return keys_not_found(missing_keys)
        identity = Identity.shared_with_user(user, is_leader=True).filter(uuid=identity_uuid).first()
        if not identity:
            failure_msg = "User %s does not have permission to POST with this identity. Promote user to leader or use a different Identity." % (user,)
            return failure_response(status.HTTP_403_FORBIDDEN, failure_msg)
        # Pass these as args
        size_alias = data.pop("size_alias")
        allocation_source_uuid = data.pop("allocation_source_uuid",None)
        machine_alias = data.pop("machine_alias")
        hypervisor_name = data.pop("hypervisor", None)
        if hypervisor_name:
            # Previous method passed this with 'None' but that fails now.
            # This check will only add the ex_ value if it is 'truthy'.
            data['ex_hypervisor_name'] = hypervisor_name
        deploy = data.pop("deploy", True)
        if type(deploy) in [str, unicode] and deploy.lower() == "false":
            deploy = False
        elif not isinstance(deploy, bool):
            deploy = True
        boot_scripts = data.pop("scripts", [])
        try:
            logger.debug(data)
            allocation_source = AllocationSource.objects.get(
                uuid=allocation_source_uuid)
            core_instance = launch_instance(
                user, identity_uuid,
                size_alias, machine_alias,
                deploy=deploy,
                allocation_source=allocation_source,
                **data)
        except UnderThresholdError as ute:
            return under_threshold(ute)
        except OverQuotaError as oqe:
            return over_quota(oqe)
        except OverAllocationError as oae:
            return over_quota(oae)
        except AllocationBlacklistedError as e:
            return failure_response(
                status.HTTP_403_FORBIDDEN,
                e.message)
        except Unauthorized:
            return invalid_creds(provider_uuid, identity_uuid)
        except SizeNotAvailable as snae:
            return size_not_available(snae)
        except SecurityGroupNotCreated:
            return connection_failure(provider_uuid, identity_uuid)
        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))

        serializer = InstanceSerializer(core_instance,
                                        context={"request": request},
                                        data=data)
        if serializer.is_valid():
            instance = serializer.save()
            if boot_scripts:
                _save_scripts_to_instance(instance, boot_scripts)
            instance.change_allocation_source(allocation_source)
            logger.info("DEBUG- Instance launch completed - Returning instance %s (%s) to user %s" % (instance, instance.created_by_identity, request.user))
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)