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))
def patch(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request},
partial=True)
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
driver_class = esh_driver.__class__
update_metadata.s(driver_class,
provider,
identity,
esh_instance.id,
data,
replace_metadata=False).apply()
instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
if not can_use_instance(user, instance_id, leader_required=True):
return member_action_forbidden(user.username, instance_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(
core_instance, data=data,
context={"request": request}, partial=True)
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
driver_class = esh_driver.__class__
update_metadata.s(driver_class, provider, identity, esh_instance.id,
data, replace_metadata=False).apply()
instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def _multi_create(
self, user, identity_uuid, size_alias, source_alias, name, deploy,
allocation_source, project, boot_scripts, extra
):
"""
1. Launch multiple instances
2. Serialize the launched instances
3. Return a list of serialized instances
"""
core_instances = launch_instance(
user,
identity_uuid,
size_alias,
source_alias,
name,
deploy,
allocation_source=allocation_source,
**extra
)
serialized_data = []
# Serialize all instances launched
for core_instance in core_instances:
# 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():
logger.error(
"multi-instance-launch, serialized instance is invalid, {}".
format(serialized_instance)
)
instance = serialized_instance.save()
instance.project = project
instance.save()
if boot_scripts:
_save_scripts_to_instance(instance, boot_scripts)
instance.change_allocation_source(allocation_source)
# append to result
serialized_data.append(serialized_instance.data)
# return a list of instances in the response
return Response(serialized_data, status=status.HTTP_201_CREATED)
def put(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.data
# Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except LibcloudInvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT, str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request})
identity = Identity.objects.get(uuid=identity_uuid)
if serializer.is_valid():
logger.info('metadata = %s' % data)
#NOTE: We shouldn't allow 'full replacement' of metadata..
# We should also validate against potentional updating of 'atmo-used metadata'
update_metadata.s(esh_driver.__class__,
esh_driver.provider,
esh_driver.identity,
esh_instance.id,
data,
replace_metadata=False).apply()
new_instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
new_instance = _save_scripts_to_instance(
new_instance, boot_scripts)
serializer = InstanceSerializer(new_instance,
context={"request": request})
invalidate_cached_instances(identity=identity)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, provider_uuid, identity_uuid, instance_id):
"""Authentication Required, update metadata about the instance"""
user = request.user
data = request.DATA
# Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_uuid, identity_uuid)
if not esh_driver:
return invalid_creds(provider_uuid, identity_uuid)
try:
esh_instance = esh_driver.get_instance(instance_id)
except (socket_error, ConnectionFailure):
return connection_failure(provider_uuid, identity_uuid)
except InvalidCredsError:
return invalid_creds(provider_uuid, identity_uuid)
except Exception as exc:
logger.exception("Encountered a generic exception. "
"Returning 409-CONFLICT")
return failure_response(status.HTTP_409_CONFLICT,
str(exc.message))
if not esh_instance:
return instance_not_found(instance_id)
# Gather the DB related item and update
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_uuid, identity_uuid,
user)
serializer = InstanceSerializer(core_instance, data=data,
context={"request": request})
identity = Identity.objects.get(uuid=identity_uuid)
provider = identity.provider
if serializer.is_valid():
logger.info('metadata = %s' % data)
#NOTE: We shouldn't allow 'full replacement' of metadata..
# We should also validate against potentional updating of 'atmo-used metadata'
update_metadata.s(driver_class, provider, identity, esh_instance.id,
data, replace_metadata=False).apply()
new_instance = serializer.save()
boot_scripts = data.pop('boot_scripts', [])
if boot_scripts:
new_instance = _save_scripts_to_instance(new_instance,
boot_scripts)
serializer = InstanceSerializer(
new_instance,
context={"request": request})
invalidate_cached_instances(identity=identitty)
response = Response(serializer.data)
logger.info('data = %s' % serializer.data)
response['Cache-Control'] = 'no-cache'
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def 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)
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)
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)
