def _execute(self):
key_names = parseSequenceArguments( self.parameters, prefix = 'KeyName.' )
filters = parseFilters( self.parameters )
if not validateEc2Filters( filters, self.available_filters ):
raise InvalidFilter
key_pairs = []
if key_names:
for key_name in key_names:
key_pairs.append( self.cluster_manager.user.key.get({'name':key_name}) )
else:
key_pairs = self.cluster_manager.user.key.get_list();
result = []
for key_pair in key_pairs:
result.append({'key-name' : key_pair['name'],
'fingerprint' : key_pair['fingerprint']
})
result = applyEc2Filters( result, filters )
print 'result:',result
return {
'key_pairs': result
}
def _execute(self):
public_ips = parseSequenceArguments(self.parameters, prefix='PublicIp.')
filters = parseFilters(self.parameters)
filters_ok = validateEc2Filters(filters, self.available_filters)
if not filters_ok:
raise InvalidFilter
result = []
addresses = self.cluster_manager.user.public_ip.get_list()
if public_ips:
addresses = [address for address in addresses if address['address'] in public_ips]
for address in addresses:
vm_id = None
lease_id = address['lease_id']
if lease_id:
instances = self.cluster_manager.user.vm.get_list()
for instance in instances:
for lease in instance['leases']:
if lease['lease_id'] == lease_id:
vm_id = instance['vm_id']
break
result.append({
'domain': 'standard',
'instance-id': vm_id,
'public-ip': address['address'],
})
result = applyEc2Filters(result , filters)
return {'addresses': result}
def _execute(self):
try:
filters = parseFilters(self.parameters)
endpoint = self.parameters['Endpoint']
except KeyError:
raise MissingParameter(parameter='Endpoint')
cms = getClusterManagers(endpoint, self.cluster_manager)
cms = applyEc2Filters(cms, filters)
return cms
def _execute(self):
GROUP_ACCESS = image_access['group']
PRIVATE_ACCESS = image_access['private']
PUBLIC_ACCESS = image_access['public']
filters = parseFilters( self.parameters )
if not validateEc2Filters( filters, self.available_filters ):
raise InvalidFilter
image_ids = []
for param, value in self.parameters.iteritems():
if param.startswith('ImageId'):
image_id = parseID(value, Entity.image)
if not image_id:
raise InvalidParameterValue
image_ids.append( image_id )
images = []
for access in (PRIVATE_ACCESS, PUBLIC_ACCESS):
access_images = self.cluster_manager.user.system_image.get_list({
'access': access,
})
for image in access_images:
if image_ids and str(image.get('image_id')) not in image_ids:
continue
images.append({
'description': image.get('description').replace('<', ' '),
'image-id': image.get('image_id'),
'is_public': 'true' if access == PUBLIC_ACCESS else 'false',
'name': image['name'],
'owner_id': image.get('user_id'),
'platform': PLATFORM.get(image.get('platform')),
'state': STATE.get(image.get('state')),
})
# listowanie obrazów grupowych - one są zwracane w innej strukturze
access_images = self.cluster_manager.user.system_image.get_list({'access': GROUP_ACCESS})
for images_dict in access_images:
for image in images_dict['images']:
if image_ids and str(image.get('image_id')) not in image_ids:
continue
images.append({
'description': image.get('description').replace('<', ' '),
'image-id': image.get('image_id'),
'is_public': 'true' if access == PUBLIC_ACCESS else 'false',
'name': image['name'],
'owner_id': image.get('user_id'),
'platform': PLATFORM.get(image.get('platform')),
'state': STATE.get(image.get('state')),
})
if filters.get('state'):
for state in filters['state']:
state = [k for k,v in STATE.iteritems() if v == STATE.get(state) ] # ?? wymaga testu
del filters['state']
images = applyEc2Filters(images, filters)
# filtry TODO:
# is-public
return {'images': images}
class DescribeVolumes(Action):
translation_filters = {'size' : 'size',
'volume-id' : 'volumeId',
'status' : 'status'}
available_filters = ['size', 'volume-id', 'status']
def _execute(self):
volume_ids = []
try:
for param, value in self.parameters.iteritems():
if param.startswith('VolumeId'):
volume_ids.append(value)
except ValueError:
raise InvalidParameterValue
if volume_ids:
volume_ids = parseIDs(volume_ids, Entity.volume)
if not volume_ids:
raise InvalidParameterValue
volumes = []
filters = parseFilters(self.parameters)
if not validateEc2Filters(filters, self.available_filters):
raise InvalidFilter
# if extra arguments weren't given
clm_volumes = []
if not volume_ids:
clm_volumes += self.cluster_manager.user.storage_image.get_list()
# and if they were
else:
try:
for volume_id in volume_ids:
clm_volumes.append(self.cluster_manager.user.storage_image.get_by_id({'storage_image_id':volume_id}))
except CLMException, error:
if error.status == 'image_get':
raise InvalidVolume.NotFound
else:
raise UndefinedError
for clm_volume in clm_volumes:
create_time = clm_volume['creation_date']
volume = {
'attachTime': None,
'createTime': parseClmDate(create_time),
'size': clm_volume['size'] / SIZE_RATIO,
'status': get_volume_status(clm_volume['state']),
'volume-id': clm_volume['storage_image_id'],
}
volumes.append(volume)
if filters.get('size'):
for size in filters['size']:
size = str(int(size) / SIZE_RATIO)
if filters.get('status'):
for state in filters['status']:
state = [k for k, v in STATE.iteritems() if v == STATE.get(state) ] # ?? wymaga testu
# attachment.attach-time - sprawdź
# attachment.delete-on-termination - ?
# attachment.device - nie
# attachment.instance-id - tak
# attachment.status - tak
# availability-zone- ?
# create-time - chyba tak
# size - TEST
# snapshot-id - nie
# status - tak TEST
# creating | available | in-use | deleting | deleted | error
# tag-key- ?
# volume-id - tak TEST
# volume-type - nie
volumes = applyEc2Filters(volumes, filters)
return {
'volumes': volumes,
}
class DescribeInstances(Action):
available_filters = ['image-id', 'instance-id', 'reservation-id']
def _execute(self):
filters = parseFilters(self.parameters)
if not validateEc2Filters(filters, self.available_filters):
raise InvalidFilter
clm_instances = []
counter = 1
while True: # first we parse arguments provided in request
instance_id = self.parameters.get('InstanceId.' + str(counter),
None)
if instance_id is None: # if there no such argument then break
break
instance_id = parseID(instance_id, Entity.instance)
if instance_id is None:
raise InvalidParameterValue
counter += 1
try:
instance = int(instance_id)
except ValueError:
raise InvalidParameterValue
clm_instances.append({'vm_id': instance})
# if we didn't provide specific IDs then use a whole list of user's VMs
if not clm_instances:
clm_instances = self.cluster_manager.user.vm.get_list()
ec2_instances = []
try:
for clm_instance in clm_instances:
clm_instance = self.cluster_manager.user.vm.get_by_id(
{'vm_id': clm_instance['vm_id']})
if clm_instance['state'] == vm_states['closed']:
raise InvalidInstanceID.NotFound(
image_id=clm_instance['vm_id'])
privateIpAddress = None
if clm_instance['leases']:
privateIpAddress = clm_instance['leases'][0].get('address')
ec2_instance = {
'image-id': clm_instance['image_id'],
'instance-id': clm_instance['vm_id'],
'instanceState': {
'code': CLM_STATES[clm_instance['state']][0],
'name': CLM_STATES[clm_instance['state']][1]
}, # TODO odpowiednia data!
'launchTime': parseClmDate(clm_instance['start_time']),
'template_name': clm_instance['template_name'],
'ownerId': clm_instance['user_id'],
'placement': {
'availabilityZone': self.cluster_manager.name
},
'privateIpAddress': privateIpAddress,
'reservation-id': clm_instance['reservation_id'],
}
public_ip = clm_instance['leases'][0]['public_ip']
ec2_instance['ipAddress'] = public_ip.get(
'ip') if public_ip else None
ec2_instances.append(ec2_instance)
except CLMException, error:
if error.status == 'vm_get' or error.status == 'user_permission':
raise InvalidInstanceID.NotFound(
image_id=clm_instance['vm_id'])
owner_id = None
if ec2_instances:
owner_id = ec2_instances[0]['ownerId']
# availability-zone - rozważyć
# block-device-mapping.attach-time - ?
# block-device-mapping.delete-on-termination - ?
# block-device-mapping.device-name - ?
# block-device-mapping.status - ?
# block-device-mapping.volume-id - ?
# client-token - ?
# dns-name - ?
# image-id - wspieramy - OK
# instance-id - wspieramy - OK
# instance-lifecycle - ?
# instance-state-code - możemy wspierać
# instance-state-name - będziemy wspierać
# instance-type - będziemy wspierać
# ip-address - będziemy wspierać
# key-name - ?
# launch-index - ?
# launch-time - możemy
# monitoring-state - ?
# placement-group-name - ?
# platform - możemy?
# private-ip-address - przydałoby się
# product-code - ?
# product-code.type - ?
# reason - ?
# reservation-id - ??
# tag-key - ?
# tag-value - ?
# virtualization-type - chyba mamy tlyko jeden typ
# vpc-id - ?
# hypervisor - ? chyba tylko 1
# association.public-ip - nie wiem?
reservation_filter = None
if filters and filters.get('reservation-id'):
reservation_filter = {'reservation-id': filters['reservation-id']}
del filters['reservation-id']
ec2_instances = applyEc2Filters(ec2_instances, filters)
reservationsIds = []
for ec2_instance in ec2_instances:
reservationId = int(ec2_instance['reservation-id'])
if reservationId not in reservationsIds:
reservationsIds.append(reservationId)
reservations = []
for reservation in reservationsIds:
reservations.append({
'reservation-id':
reservation,
'ownerId':
owner_id,
'instances': [
instance for instance in ec2_instances
if instance['reservation-id'] == reservation
]
})
if reservation_filter:
reservations = applyEc2Filters(reservations, reservation_filter)
return {'reservations': reservations}
def _execute(self):
GROUP_ACCESS = image_access['group']
PRIVATE_ACCESS = image_access['private']
PUBLIC_ACCESS = image_access['public']
filters = parseFilters(self.parameters)
if not validateEc2Filters(filters, self.available_filters):
raise InvalidFilter
image_ids = []
for param, value in self.parameters.iteritems():
if param.startswith('ImageId'):
image_id = parseID(value, Entity.image)
if not image_id:
raise InvalidParameterValue
image_ids.append(image_id)
images = []
for access in (PRIVATE_ACCESS, PUBLIC_ACCESS):
access_images = self.cluster_manager.user.system_image.get_list({
'access':
access,
})
for image in access_images:
if image_ids and str(image.get('image_id')) not in image_ids:
continue
images.append({
'description':
image.get('description').replace('<', ' '),
'image-id':
image.get('image_id'),
'is_public':
'true' if access == PUBLIC_ACCESS else 'false',
'name':
image['name'],
'owner_id':
image.get('user_id'),
'platform':
PLATFORM.get(image.get('platform')),
'state':
STATE.get(image.get('state')),
})
# listowanie obrazów grupowych - one są zwracane w innej strukturze
access_images = self.cluster_manager.user.system_image.get_list(
{'access': GROUP_ACCESS})
for images_dict in access_images:
for image in images_dict['images']:
if image_ids and str(image.get('image_id')) not in image_ids:
continue
images.append({
'description':
image.get('description').replace('<', ' '),
'image-id':
image.get('image_id'),
'is_public':
'true' if access == PUBLIC_ACCESS else 'false',
'name':
image['name'],
'owner_id':
image.get('user_id'),
'platform':
PLATFORM.get(image.get('platform')),
'state':
STATE.get(image.get('state')),
})
if filters.get('state'):
for state in filters['state']:
state = [
k for k, v in STATE.iteritems() if v == STATE.get(state)
] # ?? wymaga testu
del filters['state']
images = applyEc2Filters(images, filters)
# filtry TODO:
# is-public
return {'images': images}
