Beispiel #1
0
def transfer_into_tarball(path, arc_name, tb):
    fns = [arc_name]
    util.print_iterable(fns,
        header="Adding the following to your tarball %s"
               % (util.quote(tb.name)))
    print("Please wait...")
    tb.add(path, arc_name, recursive=False)
Beispiel #2
0
def modify(name, root, cfg):
    rpms = expand_rpms(cfg.get('rpms'))
    if not rpms:
        return
    util.print_iterable(rpms,
                        header=("Installing the following rpms"
                                " in module %s" % (util.quote(name))))
    util.ensure_dir(util.abs_join(root, 'tmp'))
    cleanup_fns = []
    for fn in rpms:
        cp_to = util.abs_join(root, 'tmp', os.path.basename(fn))
        util.copy(fn, cp_to)
        cleanup_fns.append(cp_to)
    real_fns = []
    for fn in rpms:
        real_fns.append(os.path.join('/tmp', os.path.basename(fn)))
    cmd = ['chroot', root,
           'yum', '--nogpgcheck', '-y',
           'localinstall']
    cmd.extend(real_fns)
    try:
        util.subp(cmd, capture=False)
    finally:
        # Ensure cleaned up
        for fn in cleanup_fns:
            util.del_file(fn)
Beispiel #3
0
 def download(self):
     (cache_pth, exists_there) = self._check_cache()
     if exists_there:
         return cache_pth
     print("Downloading from: %s" % (util.quote(self.where_from)))
     util.ensure_dirs([os.path.dirname(cache_pth)])
     print("To: %s" % (util.quote(cache_pth)))
     util.download_url(self.where_from, cache_pth)
     try:
         meta_js = {
             'cached_on': util.time_rfc2822(),
             'from': self.where_from,
             'root_file': self.root_file,
         }
         util.write_file("%s.json" % (cache_pth),
                         "%s\n" % (json.dumps(meta_js, indent=4)))
         return self._adjust_real_root(cache_pth)
     except:
         util.del_file(cache_pth)
         raise
Beispiel #4
0
def extract_into(tmp_file_name, fs_type, config):
    with util.tempdir() as tdir:
        # Download the image
        # TODO (make this a true module that can be changed...)
        tb_down = tar_ball.TarBallDownloader(dict(config['download']))
        arch_fn = tb_down.download()

        # Extract it
        devname = create_loopback(tmp_file_name, PART_OFFSET)
        with cmd_undo(['losetup', '-d', devname]):
            # Mount it
            root_dir = os.path.join(tdir, 'mnt')
            os.makedirs(root_dir)
            util.subp(['mount', devname, root_dir])
            # Extract it
            with cmd_undo(['umount', root_dir]):
                print("Extracting 'root' tarball %s to %s." % 
                                        (util.quote(arch_fn), 
                                         util.quote(root_dir)))
                util.subp(['tar', '-xzf', arch_fn, '-C', root_dir])
                # Fixup the fstab
                fix_fstab(root_dir, fs_type)
Beispiel #5
0
def format_blank(tmp_file_name, size, fs_type):
    print("Creating the image output file %s (scratch-version)." 
              % (util.quote(tmp_file_name)))
    with open(tmp_file_name, 'w+') as o_fh:
        o_fh.truncate(0)
        cmd = ['qemu-img', 'create', '-f', 
               'raw', tmp_file_name, size]
        util.subp(cmd)
    
    # Run fdisk on it
    print("Creating a partition table in %s."
          % (util.quote(tmp_file_name)))

    devname = create_loopback(tmp_file_name)
    with cmd_undo(['losetup', '-d', devname]):
        # These are commands to fdisk that will get activated (in order)
        fdisk_in = [
            'n',
            'p',
            '1',
            '1',
            '',
            'w'
        ]
        cmd = ['fdisk', devname]
        util.subp(cmd, data="\n".join(fdisk_in),
                  rcs=[0, 1])
    
    print("Creating a filesystem of type %s in %s." 
          % (util.quote(fs_type), 
             util.quote(tmp_file_name)))

    devname = create_loopback(tmp_file_name, PART_OFFSET)

    # Get a filesystem on it
    with cmd_undo(['losetup', '-d', devname]):
        cmd = ['mkfs.%s' % (fs_type), devname]
        util.subp(cmd)
Beispiel #6
0
 def _adjust_real_root(self, arch_path):
     if self.root_file:
         print("Oh you really meant %s, finding that file..." % (util.quote(self.root_file)))
         # Extract and then copy over the right file...
         with util.tempdir() as tdir:
             arch_dir = os.path.join(tdir, 'archive')
             os.makedirs(arch_dir)
             util.subp(['tar', '-xzf', arch_path, '-C', arch_dir])
             root_gz = util.find_file(self.root_file, arch_dir)
             if not root_gz:
                 raise RuntimeError(("Needed file %r not found in"
                                     " extracted contents of %s") 
                                     % (self.root_file, arch_path))
             else:
                 util.copy(root_gz, arch_path)
     return arch_path
Beispiel #7
0
def modify(name, root, cfg):
    user_names = cfg.get("add_users")
    if not user_names:
        return
    util.print_iterable(user_names, header="Adding the following sudo users in module %s" % (util.quote(name)))
    for uname in user_names:
        cmd = ["chroot", root, "useradd", "-m", str(uname)]
        util.subp(cmd, capture=False)
        if os.path.isfile(os.path.join(root, "etc", "sudoers")):
            with open(os.path.join(root, "etc", "sudoers"), "a") as fh:
                new_entry = "%s ALL=(ALL) ALL" % (uname)
                fh.write("%s\n" % (new_entry))
Beispiel #8
0
def main():
    parser = optparse.OptionParser()
    parser.add_option("-s", '--size', dest="size",
                      metavar="SIZE",
                      help="image size (qemu-img understandable)")
    parser.add_option("-o", '--output', dest="file_name",
                      metavar="FILE",
                      help="output filename")
    parser.add_option('--fs-type', dest="fs_type",
                      metavar="FILESYSTEM",
                      default='ext4',
                      help=("filesystem type to create"
                            ' (default: %default)'))
    parser.add_option('-c', '--config',
                      metavar='FILE',
                      dest='config',
                      action='store',
                      default=os.path.join(os.getcwd(), "build.yaml"),
                      help=("yaml config file"
                           " (default: %default)"))
    parser.add_option('-x', '--compress',
                      dest='compress',
                      action='store_true',
                      default=False,
                      help=("compress the created image set"
                           " (default: %default)"))
    parser.add_option('--strip',
                      dest='strip_parts',
                      action='store_false',
                      default=True,
                      help=("strip the image partition table"
                           " (default: %default)"))
    (options, _args) = parser.parse_args()
    
    # Ensure options are ok
    if not options.size:
        parser.error("Option -s is required")
    if not options.file_name:
        parser.error("Option -o is required")
    if not options.config:
        parser.error("Option -c is required")

    full_fn = os.path.abspath(options.file_name)
    final_format = 'qcow2'

    config = {}
    with open(options.config, 'r') as fh:
        config = util.load_yaml(fh.read())

    print("Loaded builder config from %s:" % (util.quote(options.config)))
    print(json.dumps(config, sort_keys=True, indent=4))
    with tempfile.NamedTemporaryFile(suffix='.raw') as tfh:
        tmp_file_name = tfh.name
        format_blank(tmp_file_name, options.size, options.fs_type)
        extract_into(tmp_file_name, options.fs_type, config)

        (ran, fails) = activate_modules(tmp_file_name, config)
        if len(fails):
            fail_am = util.quote(str(len(fails)), quote_color='red')
        else:
            fail_am = '0'
        print("Ran %s modules with %s failures." % (len(ran), fail_am))
        if len(fails):
            print(("Not performing scratch to final image"
                   " conversion due to %s failures!!") % (fail_am))
            return len(fails)

        print("Converting %s to final file %s." %
              (util.quote(tmp_file_name), util.quote(full_fn)))
        ec2_convert(tmp_file_name, full_fn, final_format,
                    options.strip_parts, options.compress)
        return 0