Beispiel #1
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()
Beispiel #2
0
 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])
Beispiel #3
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])
Beispiel #4
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])
Beispiel #5
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()
Beispiel #6
0
    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'] = '******'
Beispiel #7
0
    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'] = '******'
Beispiel #8
0
    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
Beispiel #9
0
    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
Beispiel #10
0
    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
Beispiel #11
0
    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
Beispiel #12
0
    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
Beispiel #13
0
    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}
Beispiel #14
0
    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'])
Beispiel #15
0
        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:
Beispiel #16
0
    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'])
Beispiel #17
0
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
Beispiel #18
0
    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}