Python ec2utils.ec2_id_to_id函数代码示例

 def validate_ec2_id(val):
     if not validator.validate_str()(val):
         return False
     try:
         ec2utils.ec2_id_to_id(val)
     except exception.InvalidEc2Id:
         return False
     return True

 def reboot_instances(self, context, instance_id, **kwargs):
     """instance_id is a list of instance ids"""
     LOG.audit(_("Reboot instance %r"), instance_id, context=context)
     for ec2_id in instance_id:
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
         self.compute_api.reboot(context, instance_id=instance_id)
     return True

 def terminate_instances(self, context, instance_id, **kwargs):
     """Terminate each instance in instance_id, which is a list of ec2 ids.
     instance_id is a kwarg so its name cannot be modified."""
     LOG.debug(_("Going to start terminating instances"))
     for ec2_id in instance_id:
         instance_id = ec2utils.ec2_id_to_id(ec2_id)
         self.compute_api.delete(context, instance_id=instance_id)
     return True

 def associate_address(self, context, instance_id, public_ip, **kwargs):
     LOG.audit(_("Associate address %(public_ip)s to"
             " instance %(instance_id)s") % locals(), context=context)
     instance_id = ec2utils.ec2_id_to_id(instance_id)
     self.compute_api.associate_floating_ip(context,
                                            instance_id=instance_id,
                                            address=public_ip)
     return {'associateResponse': ["Address associated."]}

 def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
     volume_id = ec2utils.ec2_id_to_id(volume_id)
     instance_id = ec2utils.ec2_id_to_id(instance_id)
     msg = _("Attach volume %(volume_id)s to instance %(instance_id)s"
             " at %(device)s") % locals()
     LOG.audit(msg, context=context)
     self.compute_api.attach_volume(context,
                                    instance_id=instance_id,
                                    volume_id=volume_id,
                                    device=device)
     volume = self.volume_api.get(context, volume_id)
     return {'attachTime': volume['attach_time'],
             'device': volume['mountpoint'],
             'instanceId': ec2utils.id_to_ec2_id(instance_id),
             'requestId': context.request_id,
             'status': volume['attach_status'],
             'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}

 def _get_image(self, context, ec2_id):
     try:
         internal_id = ec2utils.ec2_id_to_id(ec2_id)
         return self.image_service.show(context, internal_id)
     except (exception.InvalidEc2Id, exception.ImageNotFound):
         try:
             return self.image_service.show_by_name(context, ec2_id)
         except exception.NotFound:
             raise exception.ImageNotFound(image_id=ec2_id)

 def update_volume(self, context, volume_id, **kwargs):
     volume_id = ec2utils.ec2_id_to_id(volume_id)
     updatable_fields = ['display_name', 'display_description']
     changes = {}
     for field in updatable_fields:
         if field in kwargs:
             changes[field] = kwargs[field]
     if changes:
         self.volume_api.update(context, volume_id, kwargs)
     return True

 def update_instance(self, context, instance_id, **kwargs):
     updatable_fields = ['display_name', 'display_description']
     changes = {}
     for field in updatable_fields:
         if field in kwargs:
             changes[field] = kwargs[field]
     if changes:
         instance_id = ec2utils.ec2_id_to_id(instance_id)
         self.compute_api.update(context, instance_id=instance_id, **kwargs)
     return True

 def describe_volumes(self, context, volume_id=None, **kwargs):
     if volume_id:
         volumes = []
         for ec2_id in volume_id:
             internal_id = ec2utils.ec2_id_to_id(ec2_id)
             volume = self.volume_api.get(context, internal_id)
             volumes.append(volume)
     else:
         volumes = self.volume_api.get_all(context)
     volumes = [self._format_volume(context, v) for v in volumes]
     return {'volumeSet': volumes}

 def detach_volume(self, context, volume_id, **kwargs):
     volume_id = ec2utils.ec2_id_to_id(volume_id)
     LOG.audit(_("Detach volume %s"), volume_id, context=context)
     volume = self.volume_api.get(context, volume_id)
     instance = self.compute_api.detach_volume(context, volume_id=volume_id)
     return {'attachTime': volume['attach_time'],
             'device': volume['mountpoint'],
             'instanceId': ec2utils.id_to_ec2_id(instance['id']),
             'requestId': context.request_id,
             'status': volume['attach_status'],
             'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}

 def test_describe_volumes(self):
     """Makes sure describe_volumes works and filters results."""
     vol1 = db.volume_create(self.context, {})
     vol2 = db.volume_create(self.context, {})
     result = self.cloud.describe_volumes(self.context)
     self.assertEqual(len(result['volumeSet']), 2)
     volume_id = ec2utils.id_to_ec2_id(vol2['id'], 'vol-%08x')
     result = self.cloud.describe_volumes(self.context,
                                          volume_id=[volume_id])
     self.assertEqual(len(result['volumeSet']), 1)
     self.assertEqual(
             ec2utils.ec2_id_to_id(result['volumeSet'][0]['volumeId']),
             vol2['id'])
     db.volume_destroy(self.context, vol1['id'])
     db.volume_destroy(self.context, vol2['id'])

 def get_console_output(self, context, instance_id, **kwargs):
     LOG.audit(_("Get console output for instance %s"), instance_id,
               context=context)
     # instance_id may be passed in as a list of instances
     if type(instance_id) == list:
         ec2_id = instance_id[0]
     else:
         ec2_id = instance_id
     instance_id = ec2utils.ec2_id_to_id(ec2_id)
     output = self.compute_api.get_console_output(
             context, instance_id=instance_id)
     now = datetime.datetime.utcnow()
     return {"InstanceId": ec2_id,
             "Timestamp": now,
             "output": base64.b64encode(output)}

    def _s3_parse_manifest(self, context, metadata, manifest):
        manifest = ElementTree.fromstring(manifest)
        image_format = 'ami'
        image_type = 'machine'

        try:
            kernel_id = manifest.find('machine_configuration/kernel_id').text
            if kernel_id == 'true':
                image_format = 'aki'
                image_type = 'kernel'
                kernel_id = None
        except Exception:
            kernel_id = None

        try:
            ramdisk_id = manifest.find('machine_configuration/ramdisk_id').text
            if ramdisk_id == 'true':
                image_format = 'ari'
                image_type = 'ramdisk'
                ramdisk_id = None
        except Exception:
            ramdisk_id = None

        try:
            arch = manifest.find('machine_configuration/architecture').text
        except Exception:
            arch = 'x86_64'

        # NOTE(yamahata):
        # EC2 ec2-budlne-image --block-device-mapping accepts
        # <virtual name>=<device name> where
        # virtual name = {ami, root, swap, ephemeral<N>}
        #                where N is no negative integer
        # device name = the device name seen by guest kernel.
        # They are converted into
        # block_device_mapping/mapping/{virtual, device}
        #
        # Do NOT confuse this with ec2-register's block device mapping
        # argument.
        mappings = []
        try:
            block_device_mapping = manifest.findall('machine_configuration/'
                                                    'block_device_mapping/'
                                                    'mapping')
            for bdm in block_device_mapping:
                mappings.append({'virtual': bdm.find('virtual').text,
                                 'device': bdm.find('device').text})
        except Exception:
            mappings = []

        properties = metadata['properties']
        properties['project_id'] = context.project_id
        properties['architecture'] = arch

        if kernel_id:
            properties['kernel_id'] = ec2utils.ec2_id_to_id(kernel_id)

        if ramdisk_id:
            properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)

        if mappings:
            properties['mappings'] = mappings

        metadata.update({'disk_format': image_format,
                         'container_format': image_format,
                         'status': 'queued',
                         'is_public': False,
                         'properties': properties})
        metadata['properties']['image_state'] = 'pending'
        image = self.service.create(context, metadata)
        return manifest, image

    def _s3_create(self, context, metadata):
        """Gets a manifext from s3 and makes an image"""

        image_path = tempfile.mkdtemp(dir=FLAGS.image_decryption_dir)

        image_location = metadata['properties']['image_location']
        bucket_name = image_location.split("/")[0]
        manifest_path = image_location[len(bucket_name) + 1:]
        bucket = self._conn(context).get_bucket(bucket_name)
        key = bucket.get_key(manifest_path)
        manifest = key.get_contents_as_string()

        manifest = ElementTree.fromstring(manifest)
        image_format = 'ami'
        image_type = 'machine'

        try:
            kernel_id = manifest.find("machine_configuration/kernel_id").text
            if kernel_id == 'true':
                image_format = 'aki'
                image_type = 'kernel'
                kernel_id = None
        except Exception:
            kernel_id = None

        try:
            ramdisk_id = manifest.find("machine_configuration/ramdisk_id").text
            if ramdisk_id == 'true':
                image_format = 'ari'
                image_type = 'ramdisk'
                ramdisk_id = None
        except Exception:
            ramdisk_id = None

        try:
            arch = manifest.find("machine_configuration/architecture").text
        except Exception:
            arch = 'x86_64'

        properties = metadata['properties']
        properties['owner_id'] = context.project_id
        properties['architecture'] = arch

        if kernel_id:
            properties['kernel_id'] = ec2utils.ec2_id_to_id(kernel_id)

        if ramdisk_id:
            properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)

        properties['is_public'] = False
        properties['type'] = image_type
        metadata.update({'disk_format': image_format,
                         'container_format': image_format,
                         'status': 'queued',
                         'is_public': True,
                         'properties': properties})
        metadata['properties']['image_state'] = 'pending'
        image = self.service.create(context, metadata)
        image_id = image['id']

        def delayed_create():
            """This handles the fetching and decrypting of the part files."""
            parts = []
            for fn_element in manifest.find("image").getiterator("filename"):
                part = self._download_file(bucket, fn_element.text, image_path)
                parts.append(part)

            # NOTE(vish): this may be suboptimal, should we use cat?
            encrypted_filename = os.path.join(image_path, 'image.encrypted')
            with open(encrypted_filename, 'w') as combined:
                for filename in parts:
                    with open(filename) as part:
                        shutil.copyfileobj(part, combined)

            metadata['properties']['image_state'] = 'decrypting'
            self.service.update(context, image_id, metadata)

            hex_key = manifest.find("image/ec2_encrypted_key").text
            encrypted_key = binascii.a2b_hex(hex_key)
            hex_iv = manifest.find("image/ec2_encrypted_iv").text
            encrypted_iv = binascii.a2b_hex(hex_iv)

            # FIXME(vish): grab key from common service so this can run on
            #              any host.
            cloud_pk = os.path.join(FLAGS.ca_path, "private/cakey.pem")

            decrypted_filename = os.path.join(image_path, 'image.tar.gz')
            self._decrypt_image(encrypted_filename, encrypted_key,
                                encrypted_iv, cloud_pk, decrypted_filename)

            metadata['properties']['image_state'] = 'untarring'
            self.service.update(context, image_id, metadata)

            unz_filename = self._untarzip_image(image_path, decrypted_filename)

            metadata['properties']['image_state'] = 'uploading'
            with open(unz_filename) as image_file:
                self.service.update(context, image_id, metadata, image_file)
            metadata['properties']['image_state'] = 'available'
            self.service.update(context, image_id, metadata)
#.........这里部分代码省略.........

    def _s3_parse_manifest(self, context, metadata, manifest):
        manifest = ElementTree.fromstring(manifest)
        image_format = "ami"
        image_type = "machine"

        try:
            kernel_id = manifest.find("machine_configuration/kernel_id").text
            if kernel_id == "true":
                image_format = "aki"
                image_type = "kernel"
                kernel_id = None
        except Exception:
            kernel_id = None

        try:
            ramdisk_id = manifest.find("machine_configuration/ramdisk_id").text
            if ramdisk_id == "true":
                image_format = "ari"
                image_type = "ramdisk"
                ramdisk_id = None
        except Exception:
            ramdisk_id = None

        try:
            arch = manifest.find("machine_configuration/architecture").text
        except Exception:
            arch = "x86_64"

        # NOTE(yamahata):
        # EC2 ec2-budlne-image --block-device-mapping accepts
        # <virtual name>=<device name> where
        # virtual name = {ami, root, swap, ephemeral<N>}
        #                where N is no negative integer
        # device name = the device name seen by guest kernel.
        # They are converted into
        # block_device_mapping/mapping/{virtual, device}
        #
        # Do NOT confuse this with ec2-register's block device mapping
        # argument.
        mappings = []
        try:
            block_device_mapping = manifest.findall("machine_configuration/" "block_device_mapping/" "mapping")
            for bdm in block_device_mapping:
                mappings.append({"virtual": bdm.find("virtual").text, "device": bdm.find("device").text})
        except Exception:
            mappings = []

        properties = metadata["properties"]
        properties["project_id"] = context.project_id
        properties["architecture"] = arch

        if kernel_id:
            properties["kernel_id"] = ec2utils.ec2_id_to_id(kernel_id)

        if ramdisk_id:
            properties["ramdisk_id"] = ec2utils.ec2_id_to_id(ramdisk_id)

        if mappings:
            properties["mappings"] = mappings

        metadata.update(
            {
                "disk_format": image_format,
                "container_format": image_format,
                "status": "queued",
                "is_public": False,
                "properties": properties,
            }
        )
        metadata["properties"]["image_state"] = "pending"
        image = self.service.create(context, metadata)
        return manifest, image