def get(self, request, provider_id, identity_id):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
instance_list_method = esh_driver.list_instances
if AccountProvider.objects.filter(identity__id=identity_id):
# Instance list method changes when using the OPENSTACK provider
instance_list_method = esh_driver.list_all_instances
try:
esh_instance_list = instance_list_method()
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_instance_list = [
convert_esh_instance(esh_driver, inst, provider_id, identity_id,
user) for inst in esh_instance_list
]
#TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={
'user': request.user
},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
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 put(self, request, provider_id, identity_id, 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_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance,
data=data,
context={"request": request})
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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)
def get(self, request, provider_id=None, identity_id=None, action=None):
"""
"""
if not action:
errorObj = failureJSON([{
'code': 400,
'message': 'Action is not supported.'}])
return Response(errorObj, status=status.HTTP_400_BAD_REQUEST)
esh_driver = prepare_driver(request, identity_id)
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_id, identity_id))
errorObj = failureJSON([{
'code': 401,
'message': 'Identity/Provider Authentication Failed'}])
return Response(errorObj, status=status.HTTP_401_UNAUTHORIZED)
except NotImplemented, ne:
logger.exception(ne)
errorObj = failureJSON([{
'code': 404,
'message':
'The requested resource %s is not available on this provider'
% action}])
return Response(errorObj, status=status.HTTP_404_NOT_FOUND)
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 put(self, request, provider_id, identity_id, instance_id):
"""
TODO:
Options for put
- Instance status change (suspend,resume,etc.)
- DB changes (Name, tags)
"""
user = request.user
data = request.DATA
#Ensure item exists on the server first
esh_driver = prepare_driver(request, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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)
def put(self, request, provider_id, identity_id, instance_id):
"""
TODO:
Options for put
- Instance status change (suspend,resume,etc.)
- DB changes (Name, tags)
"""
user = request.user
data = request.DATA
#Ensure item exists on the server first
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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)
def delete(self, request, provider_id, identity_id, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
#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)
#Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = datetime.now()
core_volume.save()
#Return the object
serialized_data = VolumeSerializer(core_volume,
context={'user':request.user},
).data
response = Response(serialized_data)
return response
def delete(self, request, provider_id, identity_id, 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_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
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_id, identity_id,
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 InvalidCredsError:
return invalid_creds(provider_id, identity_id)
def patch(self, request, provider_id, identity_id, instance_id):
"""
"""
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_instance = esh_driver.get_instance(instance_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data, partial=True)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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 get(self, request, provider_id, identity_id):
"""
Returns a list of all instances
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
instance_list_method = esh_driver.list_instances
if AccountProvider.objects.filter(identity__id=identity_id):
# Instance list method changes when using the OPENSTACK provider
instance_list_method = esh_driver.list_all_instances
try:
esh_instance_list = instance_list_method()
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
core_instance_list = [convert_esh_instance(esh_driver,
inst,
provider_id,
identity_id,
user)
for inst in esh_instance_list]
#TODO: Core/Auth checks for shared instances
serialized_data = InstanceSerializer(core_instance_list,
context={"request":request},
many=True).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
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_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={"request":request}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id, volume_id):
"""
"""
user = request.user
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:
try:
core_volume = CoreVolume.objects.get(alias=volume_id,
provider__id=provider_id)
core_volume.end_date = datetime.now()
core_volume.save()
except CoreVolume.DoesNotExist:
pass
return volume_not_found(volume_id)
core_volume = convert_esh_volume(esh_volume, provider_id, identity_id,
user)
serialized_data = VolumeSerializer(core_volume,
context={
'request': request
}).data
response = Response(serialized_data)
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 delete(self, request, provider_id, identity_id, instance_id):
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
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_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
serialized_data = InstanceSerializer(core_instance).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
def patch(self, request, provider_id, identity_id, machine_id):
"""
TODO: Determine who is allowed to edit machines besides
coreMachine.owner
"""
user = request.user
data = request.DATA
esh_driver = prepare_driver(request, identity_id)
esh_machine = esh_driver.get_machine(machine_id)
coreMachine = convert_esh_machine(esh_driver, esh_machine, provider_id)
if not user.is_staff and user is not coreMachine.application.created_by:
logger.warn('%s is Non-staff/non-owner trying to update a machine'
% (user.username))
errorObj = failureJSON([{
'code': 401,
'message':
'Only Staff and the machine Owner '
+ 'are allowed to change machine info.'}])
return Response(errorObj, status=status.HTTP_401_UNAUTHORIZED)
coreMachine.application.update(request.DATA)
serializer = ProviderMachineSerializer(coreMachine,
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 Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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={'user': request.user},
)
if serializer.is_valid():
serializer.save()
response = Response(serializer.data)
return response
else:
failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
def get_core_instance(request, provider_id, identity_id, instance_id):
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
esh_instance = get_esh_instance(request, provider_id, identity_id, instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
return core_instance
def delete(self, request, provider_id, identity_id, volume_id):
"""
Destroys the volume and updates the DB
"""
user = request.user
#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)
#Delete the object, update the DB
esh_driver.destroy_volume(esh_volume)
core_volume.end_date = datetime.now()
core_volume.save()
#Return the object
serialized_data = VolumeSerializer(
core_volume,
context={
'user': request.user
},
).data
response = Response(serialized_data)
return response
def patch(self, request, provider_id, identity_id, instance_id):
"""
"""
user = request.user
data = request.DATA
#Ensure item exists on the server first
esh_driver = prepare_driver(request, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data, partial=True)
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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 get(self, request, provider_id, identity_id):
"""
Retrieves list of volumes and updates the DB
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
volume_list_method = esh_driver.list_volumes
if AccountProvider.objects.filter(identity__id=identity_id):
# Instance list method changes when using the OPENSTACK provider
volume_list_method = esh_driver.list_all_volumes
esh_volume_list = volume_list_method()
core_volume_list = [
convert_esh_volume(volume, provider_id, identity_id, user)
for volume in esh_volume_list
]
serializer = VolumeSerializer(core_volume_list,
context={'user': request.user},
many=True)
response = Response(serializer.data)
return response
def delete(self, request, provider_id, identity_id, instance_id):
user = request.user
esh_driver = prepare_driver(request, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
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_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
serialized_data = InstanceSerializer(core_instance).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
def get(self, request, provider_id, identity_id, action=None):
"""
"""
if not action:
return failure_response(status.HTTP_400_BAD_REQUEST,
'Action is not supported.')
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
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_id, identity_id))
return failure_response(status.HTTP_401_UNAUTHORIZED,
'Identity/Provider Authentication Failed')
except NotImplemented, ne:
logger.exception(ne)
return failure_response(
status.HTTP_404_NOT_FOUND,
'The requested resource %s is not available on this provider' %
action)
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
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_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={
"request": request
}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id, action=None):
"""
"""
if not action:
return failure_response(
status.HTTP_400_BAD_REQUEST,
'Action is not supported.'
)
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
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_id, identity_id))
return failure_response(
status.HTTP_401_UNAUTHORIZED,
'Identity/Provider Authentication Failed')
except NotImplemented, ne:
logger.exception(ne)
return failure_response(
status.HTTP_404_NOT_FOUND,
'The requested resource %s is not available on this provider'
% action)
def delete(self, request, provider_id, identity_id, 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_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
try:
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
task.destroy_instance_task(esh_instance, identity_id)
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_id, identity_id,
user)
if core_instance:
core_instance.end_date_all()
serialized_data = InstanceSerializer(core_instance,
context={
'user': request.user
}).data
response = Response(serialized_data, status=status.HTTP_200_OK)
response['Cache-Control'] = 'no-cache'
return response
except InvalidCredsError:
return invalid_creds(provider_id, identity_id)
def put(self, request, provider_id, identity_id, 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_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
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_id, identity_id, user)
serializer = InstanceSerializer(core_instance, data=data,
context={"request":request})
if serializer.is_valid():
logger.info('metadata = %s' % data)
update_instance_metadata(esh_driver, esh_instance, data)
serializer.save()
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)
def get_core_instance(request, provider_id, identity_id, instance_id):
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
esh_instance = get_esh_instance(request, provider_id, identity_id,
instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance, provider_id,
identity_id, user)
return core_instance
def provider_filtered_machines(request, provider_id,
identity_id, request_user=None):
"""
Return all filtered machines. Uses the most common,
default filtering method.
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
return list_filtered_machines(esh_driver, provider_id, request_user)
def get(self, request, provider_id, identity_id):
"""
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
serialized_data = []
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id):
"""
Returns all available URLs based on the user profile.
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
data = add_user_urls(request, provider_id, identity_id)
if request.user.is_staff:
add_staff_urls(request, provider_id, identity_id)
return Response(data)
def get(self, request, provider_id, identity_id, snapshot_id):
"""
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
snapshot = esh_driver._connection.get_snapshot(snapshot_id)
if not snapshot:
return snapshot_not_found(snapshot_id)
response = Response(snapshot)
return response
def get(self, request, provider_id, identity_id):
"""
Returns all available URLs based on the user profile.
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
data = add_user_urls(request, provider_id, identity_id)
if request.user.is_staff:
add_staff_urls(request, provider_id, identity_id)
return Response(data)
def get(self, request, provider_id, identity_id, snapshot_id):
"""
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
snapshot = esh_driver._connection.get_snapshot(snapshot_id)
if not snapshot:
return snapshot_not_found(snapshot_id)
response = Response(snapshot)
return response
def get(self, request, provider_id, identity_id, size_id):
"""
Lookup the size information (Lookup using the given provider/identity)
Update on server DB (If applicable)
"""
user = request.user
esh_driver = prepare_driver(request, identity_id)
eshSize = esh_driver.get_size(size_id)
coreSize = convert_esh_size(eshSize, provider_id)
serialized_data = ProviderSizeSerializer(coreSize).data
response = Response(serialized_data)
return response
def provider_filtered_machines(request,
provider_id,
identity_id,
request_user=None):
"""
Return all filtered machines. Uses the most common,
default filtering method.
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
return list_filtered_machines(esh_driver, provider_id, request_user)
def get(self, request, provider_id, identity_id, machine_id):
"""
Lookup the machine information
(Lookup using the given provider/identity)
Update on server (If applicable)
"""
esh_driver = prepare_driver(request, identity_id)
eshMachine = esh_driver.get_machine(machine_id)
coreMachine = convert_esh_machine(esh_driver, eshMachine, provider_id)
serialized_data = ProviderMachineSerializer(coreMachine).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id, size_id):
"""
Lookup the size information (Lookup using the given provider/identity)
Update on server DB (If applicable)
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
core_size = convert_esh_size(esh_driver.get_size(size_id), provider_id)
serialized_data = ProviderSizeSerializer(core_size).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id, volume_id):
"""
"""
user = request.user
esh_driver = prepare_driver(request, identity_id)
esh_volume = esh_driver.get_volume(volume_id)
if not esh_volume:
errorObj = failureJSON([{'code': 404,
'message': 'Volume does not exist'}])
return Response(errorObj, status=status.HTTP_404_NOT_FOUND)
core_volume = convert_esh_volume(esh_volume, provider_id, identity_id, user)
serialized_data = VolumeSerializer(core_volume).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id, volume_id):
"""
"""
user = request.user
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)
serialized_data = VolumeSerializer(core_volume).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id):
"""
Using provider and identity, getlist of machines
TODO: Cache this request
"""
user = request.user
esh_driver = prepare_driver(request, identity_id)
serialized_data = []
# esh_size_list = esh_driver.list_sizes()
# core_size_list = [convert_esh_size(size, provider_id, user)
# for size in esh_size_list]
# serialized_data = ProviderSizeSerializer(core_size_list,
# many=True).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id, machine_id):
"""
Lookup the machine information
(Lookup using the given provider/identity)
Update on server (If applicable)
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
#TODO: Need to determine that identity_id is ALLOWED to see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine, provider_id)
serialized_data = ProviderMachineSerializer(core_machine).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id):
data = request.DATA
user = User.objects.filter(username=request.user)
if user and len(user) > 0:
user = user[0]
else:
errorObj = failureJSON([{
'code': 401,
'message': 'User not found'}])
return Response(errorObj, status=status.HTTP_401_UNAUTHORIZED)
esh_driver = prepare_driver(request, identity_id)
# Historic Machines
all_machines_list = all_filtered_machines()
if all_machines_list:
history_machine_list =\
[m for m in all_machines_list if
m.application.created_by.username == user.username]
logger.warn(len(history_machine_list))
else:
history_machine_list = []
page = request.QUERY_PARAMS.get('page')
if page:
paginator = Paginator(history_machine_list, 5)
try:
history_machine_page = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
history_machine_page = paginator.page(1)
except EmptyPage:
# Page is out of range.
# deliver last page of results.
history_machine_page = paginator.page(paginator.num_pages)
serialized_data = \
PaginatedProviderMachineSerializer(
history_machine_page).data
else:
serialized_data = ProviderMachineSerializer(
history_machine_list).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id):
data = request.DATA
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.")
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
# Historic Machines
all_machines_list = all_filtered_machines()
if all_machines_list:
history_machine_list =\
[m for m in all_machines_list if
m.application.created_by.username == user.username]
else:
history_machine_list = []
page = request.QUERY_PARAMS.get('page')
if page or len(history_machine_list) == 0:
paginator = Paginator(history_machine_list,
5,
allow_empty_first_page=True)
else:
paginator = Paginator(history_machine_list,
len(histor_machine_list),
allow_empty_first_page=True)
try:
history_machine_page = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
history_machine_page = paginator.page(1)
except EmptyPage:
# Page is out of range.
# deliver last page of results.
history_machine_page = paginator.page(paginator.num_pages)
serialized_data = PaginatedProviderMachineSerializer(
history_machine_page, context={
'request': request
}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id):
"""
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
esh_driver = prepare_driver(request, identity_id)
esh_size_list = esh_driver.list_sizes()
all_size_list = [convert_esh_size(size, provider_id)
for size in esh_size_list]
if active:
all_size_list = [s for s in all_size_list if s.active()]
serialized_data = ProviderSizeSerializer(all_size_list, many=True).data
response = Response(serialized_data)
return response
def provider_filtered_machines(request, provider_id, identity_id):
"""
Return all filtered machines. Uses the most common,
default filtering method.
"""
esh_driver = prepare_driver(request, identity_id)
esh_machine_list = esh_driver.list_machines()
logger.info("Total machines from esh:%s" % len(esh_machine_list))
esh_machine_list = esh_driver.filter_machines(
esh_machine_list,
black_list=['eki-', 'eri-'])
core_machine_list = [convert_esh_machine(esh_driver, mach, provider_id)
for mach in esh_machine_list]
filtered_machine_list = filter(filter_core_machine, core_machine_list)
sorted_machine_list = sorted(filtered_machine_list,
cmp=compare_core_machines)
return sorted_machine_list
def get(self, request, provider_id, identity_id, machine_id):
"""
Lookup the machine information
(Lookup using the given provider/identity)
Update on server (If applicable)
"""
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
#TODO: Need to determine that identity_id is ALLOWED to see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_id)
serialized_data = ProviderMachineSerializer(core_machine).data
response = Response(serialized_data)
return response
def get_esh_instance(request, provider_id, identity_id, instance_id):
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
raise InvalidCredsError("Provider_id && identity_id "
"did not produce a valid combination")
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return esh_instance
return esh_instance
def get(self, request, provider_id, identity_id, machine_id):
"""
Details view for specific machine
(Lookup using the given provider/identity)
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
#TODO: Need to determine that identity_id is ALLOWED to see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_id, user)
serialized_data = ProviderMachineSerializer(
core_machine, request_user=request.user).data
response = Response(serialized_data)
return response
def get_esh_instance(request, provider_id, identity_id, instance_id):
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
raise InvalidCredsError(
"Provider_id && identity_id "
"did not produce a valid combination")
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
try:
core_inst = CoreInstance.objects.get(
provider_alias=instance_id,
provider_machine__provider__id=provider_id,
created_by_identity__id=identity_id)
core_inst.end_date_all()
except CoreInstance.DoesNotExist:
pass
return esh_instance
return esh_instance
def get(self, request, provider_id, identity_id, instance_id):
"""
Return the object belonging to this instance ID
TODO: Filter out instances you shouldnt see (permissions..)
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={"request":request}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def get(self, request, provider_id, identity_id, instance_id):
"""
Authentication Required, get instance details.
"""
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_instance = esh_driver.get_instance(instance_id)
if not esh_instance:
return instance_not_found(instance_id)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={'user':request.user}).data
response = Response(serialized_data)
response['Cache-Control'] = 'no-cache'
return response
def post(self, request, provider_id, identity_id):
"""
Creates a new volume and adds it to the DB
"""
user = request.user
driver = prepare_driver(request, provider_id, identity_id)
if not driver:
return invalid_creds(provider_id, identity_id)
data = request.DATA
missing_keys = valid_create_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_id,
name,
size,
description,
snapshot=snapshot,
image=image)
except OverQuotaError, oqe:
return over_quota(oqe)
def post(self, request, provider_id, identity_id, volume_id=None):
user = request.user
data = request.DATA
missing_keys = valid_launch_data(data)
if missing_keys:
return keys_not_found(missing_keys)
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
source = None
name = data.pop('name')
size_id = data.pop('size')
(source_type, get_source,
source_id) = self._select_source(esh_driver, data)
if not get_source:
return failure_response(
status.HTTP_400_BAD_REQUEST,
'Source could not be acquired. Did you send: ['
'snapshot_id/volume_id/image_id] ?')
source = get_source(source_id)
if not source:
return failure_response(
status.HTTP_404_NOT_FOUND,
"%s %s does not exist" % (source_type.title(), source_id))
size = esh_driver.get_size(size_id)
if not size:
return failure_response(status.HTTP_404_NOT_FOUND,
"Size %s does not exist" % (size_id, ))
esh_instance = boot_volume(esh_driver, identity_id, name, size, source,
source_type, **data)
core_instance = convert_esh_instance(esh_driver, esh_instance,
provider_id, identity_id, user)
serialized_data = InstanceSerializer(core_instance,
context={
'request': request
}).data
response = Response(serialized_data)
return response
def get(self, request, provider_id, identity_id, machine_id):
user = request.user
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
#TODO: Need to determine that identity_id is ALLOWED to see machine_id.
# if not covered by calling as the users driver..
esh_machine = esh_driver.get_machine(machine_id)
core_machine = convert_esh_machine(esh_driver, esh_machine,
provider_id, user)
if not core_machine:
return failure_response(
status.HTTP_400_BAD_REQUEST,
"Could not retrieve machine with ID = %s" % machine_id)
if not core_machine.application.icon:
return None
app_icon = core_machine.application.icon
image_name, image_ext = os.path.splitext(app_icon.name)
return Response(app_icon.file)
def get(self, request, provider_id, identity_id):
"""
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
esh_driver = prepare_driver(request, provider_id, identity_id)
if not esh_driver:
return invalid_creds(provider_id, identity_id)
esh_size_list = esh_driver.list_sizes()
all_size_list = [convert_esh_size(size, provider_id)
for size in esh_size_list]
if active:
all_size_list = [s for s in all_size_list if s.active()]
serialized_data = ProviderSizeSerializer(all_size_list, many=True).data
response = Response(serialized_data)
return response
