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 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):
"""
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 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, 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 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 _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
