def _execute(self): resourceIds = parseSequenceArguments(self.parameters, 'ResourceId.') tagNames = parseSequenceArguments(self.parameters, 'Tag.', '.Key') tagValue = self.parameters.get('Tag.0.Value') if not resourceIds: raise MissingParameter(parameter='ResourceId.X') if not tagNames: raise MissingParameter(parameter='Tag.X.Key') if len(tagNames) != 1: raise InvalidFilter if tagNames[0] != 'Name': raise InvalidFilter # here we have only one tag called Name # TODO checking if tagValue was given for resource in resourceIds: if resource.startswith('i-'): instance_id = parseID(resource, Entity.instance) if not instance_id: raise InvalidInstanceID.Malformed try: instance = self.cluster_manager.user.vm.get_by_id( {'vm_id': instance_id}) except CLMException, error: raise InvalidInstanceID.NotFound(image_id=instance_id) if tagValue and tagValue != 'i-' + instance['vm_id']: continue self.cluster_manager.user.vm.edit({ 'vm_id': instance_id, 'name': 'i-' + instance_id, 'description': instance['description'] }) elif resource.startswith('vol-'): volume_id = parseID(resource, Entity.volume) if not volume_id: raise InvalidVolumeID.Malformed try: volume = self.cluster_manager.user.storage_image.get_by_id( {'storage_image_id': volume_id}) except CLMException, error: raise InvalidVolume.NotFound()
def _execute(self): try: volume_id = self.parameters['VolumeId'] volume_id = parseID(volume_id, Entity.volume) if not volume_id: raise InvalidParameterValue volume_id = int(volume_id) except KeyError, error: raise MissingParameter(parameter=error.args[0])
def _execute(self): try: instance_id = parseID(self.parameters['InstanceId'], Entity.instance) if not instance_id: raise InvalidParameterValue instance_id = int(instance_id) public_ip = self.parameters['PublicIp'] except KeyError, error: raise MissingParameter(parameter=error.args[0])
def _execute(self): try: try: volume_id_ec2 = self.parameters['VolumeId'] volume_id = parseID(volume_id_ec2, Entity.volume) if not volume_id: raise InvalidParameterValue volume_id = int(volume_id) except KeyError, error: raise InvalidVolumeID.Malformed try: instance_id_ec2 = self.parameters['InstanceId'] instance_id = parseID(instance_id_ec2, Entity.instance) if not instance_id: raise InvalidParameterValue instance_id = int(instance_id) except KeyError, error: raise MissingParameter(parameter=error.args[0])
def _execute(self): resourceIds = parseSequenceArguments(self.parameters, 'ResourceId.') tagNames = parseSequenceArguments(self.parameters, 'Tag.', '.Key') tagValue = self.parameters.get('Tag.0.Value') if not resourceIds: raise MissingParameter(parameter='ResourceId.X') if not tagNames: raise MissingParameter(parameter='Tag.X.Key') if len(tagNames) != 1: raise InvalidFilter if tagNames[0] != 'Name': raise InvalidFilter # here we have only one tag called Name # TODO checking if tagValue was given for resource in resourceIds: if resource.startswith('i-'): instance_id = parseID(resource, Entity.instance) if not instance_id: raise InvalidInstanceID.Malformed try: instance = self.cluster_manager.user.vm.get_by_id({'vm_id':instance_id}) except CLMException, error: raise InvalidInstanceID.NotFound(image_id=instance_id) if tagValue and tagValue != 'i-' + instance['vm_id']: continue self.cluster_manager.user.vm.edit({'vm_id' : instance_id, 'name' : 'i-' + instance_id, 'description':instance['description']}) elif resource.startswith('vol-'): volume_id = parseID(resource, Entity.volume) if not volume_id: raise InvalidVolumeID.Malformed try: volume = self.cluster_manager.user.storage_image.get_by_id({'storage_image_id':volume_id}) except CLMException, error: raise InvalidVolume.NotFound()
def _execute(self): try: image_id = self.parameters['ImageId'] image_id = parseID(image_id, Entity.image) if not image_id: raise InvalidAMIID.Malformed image_id = int(image_id) except KeyError: raise MissingParameter(parameter='ImageId') except ValueError: raise InvalidAMIID.Malformed instance_type = self.parameters.get('InstanceType', 'm1.small') key_name = self.parameters.get('KeyName') user_data = self.parameters.get('UserData', None) template_id = None for template in self.cluster_manager.user.template.get_list(): if template.get('ec2name') == ec2names.get(instance_type): dir(template) template_id = int(template['template_id']) break machine = { 'count': int(self.parameters.get('MinCount', 1)), 'description': 'created by EC2 API', 'image_id': image_id, 'name': 'noname', 'template_id': template_id if template_id is not None else 1, 'public_ip_id': None, 'iso_list': None, 'disk_list': None, 'vnc': None, 'user_data': user_data } if key_name: try: key = self.cluster_manager.user.key.get({'name': key_name}) except CLMException, error: if error.status == 'ssh_key_get': raise InvalidKeyPair.NotFound(key_name=key_name) machine['ssh_key'] = key['data'] machine['ssh_username'] = '******'
def _execute(self): try: image_id = self.parameters['ImageId'] image_id = parseID(image_id, Entity.image) if not image_id: raise InvalidAMIID.Malformed image_id = int(image_id) except KeyError: raise MissingParameter(parameter='ImageId') except ValueError: raise InvalidAMIID.Malformed instance_type = self.parameters.get('InstanceType', 'm1.small') key_name = self.parameters.get('KeyName') user_data = self.parameters.get('UserData', None) template_id = None for template in self.cluster_manager.user.template.get_list(): if template.get('ec2name') == ec2names.get(instance_type): dir(template) template_id = int(template['template_id']) break machine = { 'count': int(self.parameters.get('MinCount', 1)), 'description': 'created by EC2 API', 'image_id': image_id, 'name': 'noname', 'template_id': template_id if template_id is not None else 1, 'public_ip_id':None, 'iso_list': None, 'disk_list':None, 'vnc':None, 'user_data' : user_data } if key_name: try: key = self.cluster_manager.user.key.get({'name':key_name}) except CLMException, error: if error.status == 'ssh_key_get': raise InvalidKeyPair.NotFound(key_name=key_name) machine['ssh_key'] = key['data'] machine['ssh_username'] = '******'
def _execute(self): try: image_id = parseID(self.parameters['ImageId'], Entity.image) if not image_id: raise InvalidParameterValue image_id = int(image_id) except KeyError: raise MissingParameter(parameter='ImageId') except ValueError: raise InvalidAMIID.Malformed try: none = self.cluster_manager.user.system_image.delete({'system_image_id':image_id}) except CLMException, error: if error.status == 'image_get' or error.status == 'image_unavailable': raise InvalidAMIID.NotFound(image_id=image_id) if error.status == 'image_delete': raise InternalError raise UndefinedError
def _execute(self): try: volume_id = self.parameters['VolumeId'] volume_id = parseID(volume_id, Entity.volume) if not volume_id: raise InvalidParameterValue volume_id = int(volume_id) except KeyError: raise MissingParameter(parameter='VolumeId') except ValueError: raise InvalidVolumeID.Malformed(image_id=volume_id) try: self.cluster_manager.user.storage_image.delete({'storage_image_id' : volume_id}) except CLMException, error: if error.status == 'image_get' or error.status == 'image_permission': raise InvalidVolume.NotFound if error.status == 'image_attached': raise VolumeInUse raise UndefinedError
def _execute(self): try: image_id = parseID(self.parameters['ImageId'], Entity.image) if not image_id: raise InvalidParameterValue image_id = int(image_id) except KeyError: raise MissingParameter(parameter='ImageId') except ValueError: raise InvalidAMIID.Malformed try: none = self.cluster_manager.user.system_image.delete( {'system_image_id': image_id}) except CLMException, error: if error.status == 'image_get' or error.status == 'image_unavailable': raise InvalidAMIID.NotFound(image_id=image_id) if error.status == 'image_delete': raise InternalError raise UndefinedError
def _execute(self): instance_ids = [] for param, value in self.parameters.iteritems(): if param.startswith('InstanceId'): try: value = parseID(value, Entity.instance) if not value: raise InvalidParameterValue instance_ids.append(int(value)) except ValueError: raise InvalidInstanceID.Malformed(image_id=value) if not instance_ids: raise MissingParameter(parameter='InstanceId') try: none = self.cluster_manager.user.vm.destroy({'vm_ids': instance_ids}) except CLMException, error: if error.status == 'vm_get' or error.status == 'user_permission': raise InvalidInstanceID.NotFound(image_id=0) # TODO wykrywanie który instance jest zly print error.status raise InternalError # destroy should throw no exception, however, we check and raise InternalError just in case
def _execute(self): instance_ids = [] for param, value in self.parameters.iteritems(): if param.startswith('InstanceId'): try: value = parseID(value, Entity.instance) if not value: raise InvalidParameterValue instance_ids.append(int(value)) except ValueError: raise InvalidInstanceID.Malformed(image_id=value) if not instance_ids: raise MissingParameter(parameter='InstanceId') try: none = self.cluster_manager.user.vm.destroy( {'vm_ids': instance_ids}) except CLMException, error: if error.status == 'vm_get' or error.status == 'user_permission': raise InvalidInstanceID.NotFound( image_id=0) # TODO wykrywanie który instance jest zly print error.status raise InternalError # destroy should throw no exception, however, we check and raise InternalError just in case
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'])
try: volume_id = self.parameters['VolumeId'] volume_id = parseID(volume_id, Entity.volume) if not volume_id: raise InvalidParameterValue volume_id = int(volume_id) except KeyError, error: raise MissingParameter(parameter=error.args[0]) except ValueError, error: raise InvalidParameterValue instance_id_ec2 = self.parameters.get('InstanceId') instance_id = instance_id_ec2 if instance_id_ec2: instance_id = parseID(instance_id_ec2, Entity.instance) if not instance_id: raise InvalidParameterValue instance_id = int(instance_id) try: self.cluster_manager.user.storage_image.detach({ 'storage_image_id' : volume_id, 'vm_id' : instance_id }) except CLMException, error: if error.status == 'storage_image_detach': raise UndefinedError if error.status == 'image_get': raise InvalidVolume.NotFound if error.status == 'user_permission' or error.status == 'vm_get': raise InvalidInstanceID.NotFound(image_id=instance_id) else: try:
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'])
class RunInstances(Action): def _execute(self): try: image_id = self.parameters['ImageId'] image_id = parseID(image_id, Entity.image) if not image_id: raise InvalidAMIID.Malformed image_id = int(image_id) except KeyError: raise MissingParameter(parameter='ImageId') except ValueError: raise InvalidAMIID.Malformed instance_type = self.parameters.get('InstanceType', 'm1.small') key_name = self.parameters.get('KeyName') user_data = self.parameters.get('UserData', None) template_id = None for template in self.cluster_manager.user.template.get_list(): if template.get('ec2name') == ec2names.get(instance_type): dir(template) template_id = int(template['template_id']) break machine = { 'count': int(self.parameters.get('MinCount', 1)), 'description': 'created by EC2 API', 'image_id': image_id, 'name': 'noname', 'template_id': template_id if template_id is not None else 1, 'public_ip_id': None, 'iso_list': None, 'disk_list': None, 'vnc': None, 'user_data': user_data } if key_name: try: key = self.cluster_manager.user.key.get({'name': key_name}) except CLMException, error: if error.status == 'ssh_key_get': raise InvalidKeyPair.NotFound(key_name=key_name) machine['ssh_key'] = key['data'] machine['ssh_username'] = '******' device_mapping_counter = 1 volumes = [] # EC2 passes data about volumes by BlockDeviceMapping.X.VirtualName parameter # where X starts with 1 and step is also 1 while True: volume = self.parameters.get('BlockDeviceMapping.' + str(device_mapping_counter) + '.VirtualName') if volume is None: break volume = parseID(volume, Entity.volume) if volume is None: raise InvalidParameterValue device_mapping_counter += 1 try: volumes.append(int(volume)) except ValueError: raise InvalidVolumeID.Malformed if volumes: machine['disk_list'] = volumes instances = [] # as far as I know here we have problem detecting if image_get regard volume or AMI # TODO load volumes from CLM and check on EC2 server if specified volume exists try: instances = self.cluster_manager.user.vm.create(machine) except CLMException, error: if error.status == 'vm_create': raise InternalError # we have not enough information to determine what happened if error.status == 'image_get' or error.status == 'image_permission': raise InvalidAMIID.NotFound(image_id=image_id) if error.status == 'user_cpu_limit': raise ResourceLimitExceeded(resource="CPU") if error.status == 'user_memory_limit': raise ResourceLimitExceeded(resource="RAM") if error.status == 'user_storage_limit': raise ResourceLimitExceeded(resource="Storage") if error.status == 'image_unavailable': raise InvalidAMIID.Unavailable print error.status # TODO jak sie wyjasni to sie usunie 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}