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):
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):
if self.parameters.get('MaxResults'):
raise UnknownParameter(parameter='MaxResults')
if self.parameters.get('NextToken'):
raise UnknownParameter(parameter='NextToken')
filters = parseFilters(self.parameters)
if not validateEc2Filters(filters, self.available_filters):
raise InvalidFilter
tags = []
if filters:
INSTANCES = False
VOLUMES = False
if filters.get('key'):
for key in filters['key']:
if key != 'Name':
raise InvalidFilter #TODO
del filters['key']
if filters.get('resource-id'):
for filter in filters['resource-id']:
if filter.startswith('vol-') and (
not filters.get('resource-type')
or filters.get('resource-type') == 'volume'):
tags.append(
get_volume_name_tag(self.cluster_manager,
filter[4:]))
elif filter.startswith('i-') and (
not filters.get('resource-type')
or filters.get('resource-type') == 'instance'):
tags.append(
get_instance_name_tag(self.cluster_manager,
filter[2:]))
elif filters.get('resource-type'):
for filter in filters['resource-type']:
if filter == 'instance':
tags.append(get_instance_tags(self.cluster_manager))
elif filter == 'volume':
tags.append(get_volume_tags(self.cluster_manager))
del filters['resource-type']
else:
tags = get_instance_tags(
self.cluster_manager) + get_volume_tags(
self.cluster_manager)
if filters.get('value'):
tags = [
tag for tag in tags if tag['value'] in filters['value']
]
else: # jeżeli nie podano zadnych filtrów to zwracamy wszystkie
tags = get_instance_tags(self.cluster_manager) + get_volume_tags(
self.cluster_manager)
return {'tags': tags}
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):
if self.parameters.get('MaxResults'):
raise UnknownParameter(parameter='MaxResults')
if self.parameters.get('NextToken'):
raise UnknownParameter(parameter='NextToken')
filters = parseFilters(self.parameters)
if not validateEc2Filters(filters, self.available_filters):
raise InvalidFilter
tags = []
if filters:
INSTANCES = False
VOLUMES = False
if filters.get('key'):
for key in filters['key']:
if key != 'Name':
raise InvalidFilter #TODO
del filters['key']
if filters.get('resource-id'):
for filter in filters['resource-id']:
if filter.startswith('vol-') and (not filters.get('resource-type') or filters.get('resource-type') == 'volume'):
tags.append(get_volume_name_tag(self.cluster_manager, filter[4:]))
elif filter.startswith('i-') and (not filters.get('resource-type') or filters.get('resource-type') == 'instance'):
tags.append(get_instance_name_tag(self.cluster_manager, filter[2:]))
elif filters.get('resource-type'):
for filter in filters['resource-type']:
if filter == 'instance':
tags.append(get_instance_tags(self.cluster_manager))
elif filter == 'volume':
tags.append(get_volume_tags(self.cluster_manager))
del filters['resource-type']
else:
tags = get_instance_tags(self.cluster_manager) + get_volume_tags(self.cluster_manager)
if filters.get('value'):
tags = [tag for tag in tags if tag['value'] in filters['value']]
else: # jeżeli nie podano zadnych filtrów to zwracamy wszystkie
tags = get_instance_tags(self.cluster_manager) + get_volume_tags(self.cluster_manager)
return {'tags':tags}
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
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}
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'])
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}
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'])
