Python EBSBlockDeviceType.snapshot_id方法代码示例

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
    def register_ebs_ami(self, snapshot_id, arch = 'x86_64', default_ephem_map = True,
                         img_name = None, img_desc = None):
        # register against snapshot
        try:
            aki=PVGRUB_AKIS[self.region.name][arch]
        except KeyError:
            raise Exception("Unable to determine pvgrub hd00 AKI for region (%s) arch (%s)" % (self.region.name, arch))

        if not img_name:
            rand_id = random.randrange(2**32)
            # These names need to be unique, hence the pseudo-uuid
            img_name='EBSHelper AMI - %s - uuid-%x' % (snapshot_id, rand_id)
        if not img_desc:
            img_desc='Created directly from volume snapshot %s' % (snapshot_id)

        self.log.debug("Registering snapshot (%s) as new EBS AMI" % (snapshot_id))
        ebs = EBSBlockDeviceType()
        ebs.snapshot_id = snapshot_id
        ebs.delete_on_termination = True
        block_map = BlockDeviceMapping()
        block_map['/dev/sda'] = ebs
        # The ephemeral mappings are automatic with S3 images
        # For EBS images we need to make them explicit
        # These settings are required to make the same fstab work on both S3 and EBS images
        if default_ephem_map:
            e0 = EBSBlockDeviceType()
            e0.ephemeral_name = 'ephemeral0'
            e1 = EBSBlockDeviceType()
            e1.ephemeral_name = 'ephemeral1'
            block_map['/dev/sdb'] = e0
            block_map['/dev/sdc'] = e1
        result = self.conn.register_image(name=img_name, description=img_desc,
                           architecture=arch,  kernel_id=aki,
                           root_device_name='/dev/sda', block_device_map=block_map)
        return str(result)

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
    def register_snap(self, snap_id, arch, name, aki=None, desc=None, ari=None,
                      pub=True, disk=False):
        """
        Register an EBS volume snapshot as an AMI. Returns the AMI ID. An arch,
        snapshot ID, and name for the AMI must be provided. Optionally
        a description, AKI ID, ARI ID and billing code may be specified too.
        disk is whether or not we are registering a disk image.
        """
        self.logger.info('Registering snap: %s' % (snap_id))
        snap = self.conn.get_all_snapshots([snap_id])[0]
        #Makes block device map
        ebs = EBSBlockDeviceType()
        ebs.snapshot_id = snap_id
        block_map = BlockDeviceMapping()

        if aki == None:
            raise Fedora_EC2Error('Need to specify an AKI')
        if disk:
            disk = '/dev/sda=%s' % snap_id
            root = '/dev/sda'
        else:
            disk = '/dev/sda1=%s' % snap_id
            root = '/dev/sda1'
        block_map[root] = ebs

        ami_id = self.conn.register_image(name=name, description=desc,
              image_location = '', architecture=arch, kernel_id=aki,
              ramdisk_id=ari,root_device_name=root, block_device_map=block_map)

        if not ami_id.startswith('ami-'):
            self._log_error('Could not register an AMI')
        self.logger.info('Registered an AMI: %s' % ami_id)
        return ami_id

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
    def register_ebs_ami(self, snapshot_id, arch="x86_64", default_ephem_map=True, img_name=None, img_desc=None):
        # register against snapshot
        try:
            aki = PVGRUB_AKIS[self.region.name][arch]
        except KeyError:
            raise Exception("Unable to find pvgrub hd00 AKI for %s, arch (%s)" % (self.region.name, arch))
        if not img_name:
            rand_id = random.randrange(2 ** 32)
            # These names need to be unique, hence the pseudo-uuid
            img_name = "EBSHelper AMI - %s - uuid-%x" % (snapshot_id, rand_id)
        if not img_desc:
            img_desc = "Created directly from volume snapshot %s" % snapshot_id

        self.log.debug("Registering %s as new EBS AMI" % snapshot_id)
        self.create_sgroup("ec2helper-vnc-ssh-%x" % random.randrange(2 ** 32), allow_vnc=True)
        ebs = EBSBlockDeviceType()
        ebs.snapshot_id = snapshot_id
        ebs.delete_on_termination = True
        block_map = BlockDeviceMapping()
        block_map["/dev/sda"] = ebs
        # The ephemeral mappings are automatic with S3 images
        # For EBS images we need to make them explicit
        # These settings are required to make the same fstab work on both S3
        # and EBS images
        if default_ephem_map:
            e0 = EBSBlockDeviceType()
            e0.ephemeral_name = "ephemeral0"
            e1 = EBSBlockDeviceType()
            e1.ephemeral_name = "ephemeral1"
            block_map["/dev/sdb"] = e0
            block_map["/dev/sdc"] = e1
        result = self.conn.register_image(
            name=img_name,
            description=img_desc,
            architecture=arch,
            kernel_id=aki,
            root_device_name="/dev/sda",
            block_device_map=block_map,
        )
        sleep(10)
        new_amis = self.conn.get_all_images([result])
        new_amis[0].add_tag("Name", resource_tag)

        return str(result)

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
 def parse_block_device_args(self, block_device_maps_args):
     block_device_map = BlockDeviceMapping()
     for block_device_map_arg in block_device_maps_args:
         parts = block_device_map_arg.split('=')
         if len(parts) > 1:
             device_name = parts[0]
             block_dev_type = EBSBlockDeviceType()
             value_parts = parts[1].split(':')
             if value_parts[0].startswith('snap'):
                 block_dev_type.snapshot_id = value_parts[0]
             else:
                 if value_parts[0].startswith('ephemeral'):
                     block_dev_type.ephemeral_name = value_parts[0]
             if len(value_parts) > 1:
                 block_dev_type.size = int(value_parts[1])
             if len(value_parts) > 2:
                 if value_parts[2] == 'true':
                     block_dev_type.delete_on_termination = True
             block_device_map[device_name] = block_dev_type
     return block_device_map

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
def create_image(args):
    AWSACCID = _getawsaccid()
    conn = boto.ec2.connect_to_region(args.region,aws_access_key_id=AWSAKEY,aws_secret_access_key=AWSSKEY)
    if args.snapshotid == "" or args.snapshotid is None:
        print 'You have to pass the snapshot ID used to create the image with --snapshotid="snapid"'
	raise SystemExit(1)
    else:
	namei = raw_input("Enter name of image: ")
	descr = raw_input("Enter a description for image: ")
	vtype = raw_input("Enter a virtualization type for image:[hvm|paravirtual] ")
        print "Creating image from snapshot %s ..." % args.snapshotid
	ebs = EBSBlockDeviceType()
	ebs.snapshot_id = args.snapshotid
	block_map = BlockDeviceMapping()
	block_map['/dev/sda1'] = ebs
	print vtype
	
	try:
	    if args.region == "eu-west-1":
		if vtype == "hvm":    
                    #ret = conn.register_image(name=namei,description=descr,architecture='x86_64',kernel_id='aki-71665e05',\
	#		root_device_name='/dev/sda1', block_device_map=block_map, virtualization_type='hvm')
                    ret = conn.register_image(name=namei,description=descr,architecture='x86_64',\
			root_device_name='/dev/sda1', block_device_map=block_map, virtualization_type='hvm')
		else:
                    ret = conn.register_image(name=namei,description=descr,architecture='x86_64',kernel_id='aki-71665e05',\
			root_device_name='/dev/sda1', block_device_map=block_map, virtualization_type='paravirtual')

	    else:
		if vtype == "hvm":    
                    ret = conn.register_image(name=namei,description=descr,architecture='x86_64',kernel_id='aki-b6aa75df',\
			root_device_name='/dev/sda1', block_device_map=block_map, virtualization_type='hvm')
		else:
                    ret = conn.register_image(name=namei,description=descr,architecture='x86_64',kernel_id='aki-b6aa75df',\
			root_device_name='/dev/sda1', block_device_map=block_map, virtualization_type='paravirtual')

	    print "Image creation successful"
	except EC2ResponseError:
	    print "Image creation error"

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
def make_ebs_based_image(ami_name, docker_image_name, fstype='ext3',
        mount_point=None, desc='', arch='x86_64', kernel=None, disk_size=10240):
    '''size of ebs is passed in Mb'''

    availability_zone = boto.utils.get_instance_metadata()[
        'placement']['availability-zone']
    instance_id = boto.utils.get_instance_metadata()['instance_id']

    # needs a ec2 connection here
    conn = boto.ec2.connection.EC2Connection()
    vol = conn.create_volume(disk_size, availability_zone)

    devpath = random.choice(
        [devp for devp in map(lambda x: '/dev/sd%s' % x, string.ascii_lowercase)
            if not os.path.exists(devp)]
        )

    vol.attach(instance_id, devpath)
    run('/sbin/mkfs -t %s %s' % (fstype, devpath))
    if mount_point is None:
        mount_point = tempfile.mkdtemp('ebs-based-mount-point')

    # copy files
    cid = dockerc.create_container(
        image=docker_image_name,
        command='/bin/bash',
        tty=True,
        volume=['dev']
        )

    export_fileobj = dockerc.export(cid)
    run('/bin/mount -t %s %s %s' % (fstype, devpath, mount_point))
    try:
        with tempfile.TemporaryFile() as fp:
            data = export_fileobj.read(2048)
            while data:
                fp.write(data)
                data = export_fileobj.read(2048)
            else:
                # if it goes well, seek to 0
                fp.seek(0)

        tar = tarfile.open(fileobj=fp)
        os.chdir(mount_point)
        tar.extractall()
        tar.close()
        os.chdir(os.pardir)
    finally:
        run('/bin/umount %s' % mount_point)

    vol.detach()
    snapshot = vol.create_snapshot('initial snapshot for ebs')
    ebs = EBSBlockDeviceType()
    ebs.snapshot_id = snapshot.id
    block_map = BlockDeviceMapping()
    block_map['/dev/sda1'] = ebs
    ami = conn.register_image(
        ami_name,
        description=desc,
        architecture=arch,
        kernel_id=kernel,
        root_device_name='dev/sda1',
        block_device_map=block_map
        )

    log.info('ebs-based ami: %s' % ami.id)

# 需要导入模块: from boto.ec2.blockdevicemapping import EBSBlockDeviceType [as 别名]
# 或者: from boto.ec2.blockdevicemapping.EBSBlockDeviceType import snapshot_id [as 别名]
def create_ami(region, snap_id, force=None, root_dev='/dev/sda1', zone_name=None,
               default_arch=None, default_type='t1.micro', security_groups=''):
    """
    Creates AMI image from given snapshot.

    Force option removes prompt request and creates new instance from
    created ami image.

    region, snap_id
        specify snapshot to be processed. Snapshot description in json
        format will be used to restore instance with same parameters.
        Will automaticaly process snapshots for same instance with near
        time (10 minutes or shorter), but for other devices (/dev/sdb,
        /dev/sdc, etc);
    force
        Run instance from ami after creation without confirmation. To
        enable set value to "RUN";
    default_arch
        architecture to use if not mentioned in snapshot description;
    default_type
        instance type to use if not mentioned in snapshot description.
        Used only if ``force`` is "RUN";
    security_groups
        list of AWS Security Groups names formatted as string separated
        with semicolon ';'. Used only if ``force`` is "RUN".
    """
    conn = get_region_conn(region)
    snap = conn.get_all_snapshots(snapshot_ids=[snap_id, ])[0]
    instance_id = get_snap_instance(snap)
    _device = get_snap_device(snap)
    snaps = conn.get_all_snapshots(owner='self')
    snapshots = [snp for snp in snaps if
        get_snap_instance(snp) == instance_id and
        get_snap_device(snp) != _device and
        abs(get_snap_time(snap) - get_snap_time(snp)) <= timedelta(minutes=10)]
    snapshot = sorted(snapshots, key=get_snap_time,
                      reverse=True) if snapshots else None
    # setup for building an EBS boot snapshot
    default_arch = default_arch or config.get('DEFAULT', 'ARCHITECTURE')
    arch = get_descr_attr(snap, 'Arch') or default_arch
    kernel = config.get(conn.region.name, 'KERNEL' + arch.upper())
    dev = re.match(r'^/dev/sda$', _device)  # if our instance encrypted
    if dev:
        kernel = config.get(conn.region.name, 'KERNEL_ENCR_' + arch.upper())
    ebs = EBSBlockDeviceType()
    ebs.snapshot_id = snap_id
    ebs.delete_on_termination = True
    block_map = BlockDeviceMapping()
    block_map[_device] = ebs
    sdb = BlockDeviceType()
    sdb.ephemeral_name = 'ephemeral0'
    block_map['/dev/sdb'] = sdb

    if snapshot:
        for s in snapshot:
            s_dev = get_snap_device(s)
            s_ebs = EBSBlockDeviceType()
            s_ebs.delete_on_termination = True
            s_ebs.snapshot_id = s.id
            block_map[s_dev] = s_ebs

    name = 'Created {0} using access key {1}'.format(timestamp(),
                                                     conn.access_key)
    name = name.replace(":", ".").replace(" ", "_")

    # create the new AMI all options from snap JSON description:
    wait_for(snap, '100%', limit=SNAP_TIME)
    result = conn.register_image(
        name=name,
        description=snap.description,
        architecture=get_descr_attr(snap, 'Arch') or default_arch,
        root_device_name=get_descr_attr(snap, 'Root_dev_name') or root_dev,
        block_device_map=block_map, kernel_id=kernel)
    sleep(2)
    image = conn.get_all_images(image_ids=[result, ])[0]
    wait_for(image, 'available', limit=10 * 60)
    add_tags(image, snap.tags)

    logger.info('The new AMI ID = {0}'.format(result))

    new_instance = None
    if force == 'RUN':
        instance_type = get_descr_attr(snap, 'Type') or default_type
        new_instance = launch_instance_from_ami(
            region, image.id, inst_type=instance_type,
            security_groups=security_groups, zone_name=zone_name)
    return image, new_instance