Пример #1
0
def install_files():
    list_files_to_install = get_from_config("images", "list_files_to_install", dist)
    if not os.path.isfile(list_files_to_install):
        clean_and_exit("Error reading file " + list_files_to_install)

    dir_origin = get_from_config("images", "dir_files_to_install", dist)
    if not os.path.isdir(dir_origin):
        clean_and_exit("Error reading directory " + dir_origin)

    with open(list_files_to_install, "r") as file_to_read:
        for line in file_to_read:
            orig, dest, perm = line.rstrip().split()
            path_orig = dir_origin + "/" + orig
            path_dest = work_dir + "/" + dest
            file_perm = int(perm, 8)  # tell int to use base 8
            final_file = path_dest + orig

            if not os.path.isfile(path_orig):
                clean_and_exit("Error reading file " + path_orig)

            if not os.path.isdir(path_dest):
                os.makedirs(path_dest)
            shutil.copy(path_orig, path_dest)
            os.chmod(final_file, file_perm)

            if ("etc/init.d" in dest):
                run_chroot(["chroot", work_dir, "update-rc.d", orig, "defaults"])

        # Empty hostname
        os.remove(work_dir + "/etc/hostname")
        run_chroot(["chroot", work_dir, "touch", "/etc/hostname"])
Пример #2
0
def do_ssh(hosts, command):
    hosts_l = [
        full_hostname(host) for host in ClusterShell.NodeSet.NodeSet(hosts)
    ]
    hosts = ClusterShell.NodeSet.NodeSet('')
    hosts.updaten(hosts_l)

    os.environ["SSHPASS"] = \
        value_from_file(get_from_config("common", "master_passwd_file"),
                        "IMMPASSWORD")
    imm_user = \
        value_from_file(get_from_config("common", "master_passwd_file"),
                        "IMMUSER")

    task = ClusterShell.Task.task_self()
    task.set_info("ssh_user", imm_user)
    task.set_info("ssh_path", "/usr/bin/sshpass -e /usr/bin/ssh")
    task.set_info("ssh_options", "-oBatchMode=no")
    task.shell(command, nodes=hosts.__str__())
    task.resume()

    for buf, nodes in task.iter_buffers():
        print "---\n%s:\n---\n %s" \
              % (ClusterShell.NodeSet.fold(",".join(nodes)),
                 buf)
Пример #3
0
def getmac(hosts):
    install_cfg()
    imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(get_from_config("common", "master_passwd_file"), "PASSWD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    for host in nodeset:
        print "%s: " % host
        cmd = ["ipmitool", "-I", "lanplus", "-H", "imm" + host,
               "-U", imm_user, "-E", "fru", "print", "0"]

        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
        # The data we want is in line 15
        line = proc.stdout.readlines()[14]
        full_mac = line.split(":")[1].strip().upper()
        mac_address1 = "{0}:{1}:{2}:{3}:{4}:{5}".format(full_mac[0:2],
                                                        full_mac[2:4],
                                                        full_mac[4:6],
                                                        full_mac[6:8],
                                                        full_mac[8:10],
                                                        full_mac[10:12])

        mac_address2 = "{0}:{1}:{2}:{3}:{4}:{5}".format(full_mac[12:14],
                                                        full_mac[14:16],
                                                        full_mac[16:18],
                                                        full_mac[18:20],
                                                        full_mac[20:22],
                                                        full_mac[22:24])

        print "ETH0's MAC address is {0}\n" \
              "ETH1's MAC address is {1}\n".format(mac_address1, mac_address2)
Пример #4
0
def install_files():
    list_files_to_install = get_from_config("images", "list_files_to_install",
                                            dist)
    if not os.path.isfile(list_files_to_install):
        logging.warning("{0} is not a file!".format(list_files_to_install))

    else:
        dir_origin = get_from_config("images", "dir_files_to_install", dist)
        if not os.path.isdir(dir_origin):
            logging.warning("{0} is not a directory!".format(dir_origin))

        with open(list_files_to_install, "r") as file_to_read:
            for line in file_to_read:
                orig, dest, perm = line.rstrip().split()
                path_orig = dir_origin + "/" + orig
                path_dest = work_dir + "/" + dest
                file_perm = int(perm, 8)  # tell int to use base 8
                final_file = path_dest + orig

                if not os.path.isfile(path_orig):
                    logging.warning("{0} is not a file!".format(path_orig))

                if not os.path.isdir(path_dest):
                    os.makedirs(path_dest)
                shutil.copy(path_orig, path_dest)
                os.chmod(final_file, file_perm)

                if ("etc/init.d" in dest):
                    run_chroot(
                        ["chroot", work_dir, "update-rc.d", orig, "defaults"])

    # Empty hostname
    os.remove(work_dir + "/etc/hostname")
    run_chroot(["chroot", work_dir, "touch", "/etc/hostname"])
Пример #5
0
def do_connect(host, j=False, f=False):
    nodeset = ClusterShell.NodeSet.NodeSet(host)
    if (len(nodeset) != 1):
        clara_exit('Only one host allowed for this command')

    pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
    if pat.match(host):
        logging.debug(
            "The host is an IP adddres: {0}. Using ipmitool without conman.".
            format(host))
        do_connect_ipmi(host)
    else:
        conmand = get_from_config("ipmi", "conmand")
        port = int(get_from_config("ipmi", "port"))
        if (len(conmand) == 0):
            clara_exit("You must set the configuration paramenter 'conmand'")
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((conmand, port))
            os.environ["CONMAN_ESCAPE"] = '!'

            cmd = ["conman"]
            if j:
                cmd = cmd + ["-j"]
            if f:
                cmd = cmd + ["-f"]
            cmd = cmd + ["-d", conmand, host]
            run(cmd)
        except socket.error as e:
            logging.debug(
                "Conman not running. Message on connect: Errno {0} - {1}".
                format(e.errno, e.strerror))
            do_connect_ipmi(host)

        s.close()
Пример #6
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global work_dir, src_list, dist
    dist = get_from_config("common", "default_distribution")
    if dargs['<dist>'] is not None:
        dist = dargs["<dist>"]
    if dist not in get_from_config("common", "allowed_distributions"):
        clara_exit("{0} is not a know distribution".format(dist))
    if dargs['<chroot_dir>'] is not None:
        work_dir = dargs['<chroot_dir>']
    else:
        work_dir = get_from_config("chroot", "trg_dir", dist)

    src_list = work_dir + "/etc/apt/sources.list"
    # Not executed in the following cases
    # - the program dies because of a signal
    # - os._exit() is invoked directly
    # - a Python fatal error is detected (in the interpreter)
    atexit.register(clean_and_exit)

    if dargs['create']:
        base_install()
        system_install()
        install_files()
        install_https_apt()
        remove_files()
        run_script_post_creation()
    elif dargs['edit']:
        edit(dargs['<chroot_dir>'])
    elif dargs['install']:
        install_packages(dargs['<packages>'])
    elif dargs['remove']:
        remove_packages(dargs['<packages>'])
Пример #7
0
def do_connect(host, j=False, f=False):
    nodeset = ClusterShell.NodeSet.NodeSet(host)
    if (len(nodeset) != 1):
        clara_exit('Only one host allowed for this command')

    pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
    if pat.match(host):
        logging.debug("The host is an IP adddres: {0}. Using ipmitool without conman.".format(host))
        ipmi_do(host, True, "sol", "activate")
    else:
        conmand = get_from_config("ipmi", "conmand")
        port = int(get_from_config("ipmi", "port"))
        if (len(conmand) == 0):
            clara_exit("You must set the paramenter 'conmand' in the configuration file")
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((conmand, port))
            os.environ["CONMAN_ESCAPE"] = '!'

            cmd = ["conman"]
            if j:
                cmd = cmd + ["-j"]
            if f:
                cmd = cmd + ["-f"]
            cmd = cmd + ["-d", conmand, host]
            run(cmd)
        except socket.error as e:
            logging.debug("Conman not running. Message on connect: {0}" % e)
            ipmi_do(host, True, "sol", "activate")

        s.close()
Пример #8
0
def do_reprepro(action, package=None, flags=None):
    repo_dir = get_from_config("repo", "repo_dir", dist)
    reprepro_config = repo_dir + '/conf/distributions'

    if not os.path.isfile(reprepro_config):
        clara_exit(
            "There is not configuration for the local repository for {0}. Run first 'clara repo init <dist>'"
            .format(dist))

    list_flags = ['--silent', '--ask-passphrase']
    if conf.ddebug:
        list_flags = ['-V', '--ask-passphrase']

    if flags is not None:
        list_flags.append(flags)

    cmd = ['reprepro'] + list_flags + \
         ['--basedir', get_from_config("repo", "repo_dir", dist),
         '--outdir', get_from_config("repo", "mirror_local", dist),
         action, dist]

    if package is not None:
        cmd.append(package)

    run(cmd)
Пример #9
0
def ipmi_do(hosts, *cmd):

    imm_user = value_from_file(get_from_config("common", "master_passwd_file"),
                               "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(
        get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)

    p = multiprocessing.Pool(parallel)
    result_map = {}

    for host in nodeset:

        pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
        if not pat.match(host):
            prefix = get_from_config("ipmi", "prefix")
            host = prefix + host

        ipmitool = [
            "ipmitool", "-I", "lanplus", "-H", host, "-U", imm_user, "-E",
            "-e!"
        ]
        ipmitool.extend(cmd)
        logging.debug("ipmi/ipmi_do: {0}".format(" ".join(ipmitool)))
        result_map[host] = p.apply_async(ipmi_run, (ipmitool, ))

    p.close()
    p.join()

    for host, result in result_map.items():
        print host, result.get()
Пример #10
0
def main():
    dargs = docopt.docopt(__doc__)

    global dist
    dist = get_from_config("common", "distribution")
    if dargs["--dist"] is not None:
        dist = dargs["--dist"]
    if dist not in get_from_config("common", "distributions"):
        sys.exit("{0} is not a know distribution".format(dist))

    if dargs['key']:
        do_key()
    if dargs['init']:
        do_init()
    elif dargs['sync']:
        if dargs['create']:
            do_sync('create')
        else:
            do_sync()
    elif dargs['add']:
        for elem in dargs['<file>']:
            if elem.endswith(".deb"):
                do_package('includedeb', elem)
            elif elem.endswith(".changes"):
                do_package('include', elem)
            elif elem.endswith(".dsc"):
                do_package('includedsc', elem)
            else:
                sys.exit("File is not a *.deb *.dsc or *.changes")
    elif dargs['del']:
        for elem in dargs['<name>']:
            do_package('removesrc', elem)
Пример #11
0
def push(image, dist):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
        if (squashfs_file == "" or squashfs_file == None):
            image_name = dist + "_image.squashfs"
            squashfs_file = "/var/lib/clara/images/" + image_name
    else:
        squashfs_file = image

    if not os.path.isfile(squashfs_file):
        clara_exit("{0} doesn't exist.".format(squashfs_file))

    # Send files where they will be used
    sftp_mode = has_config_value("images", "hosts", dist)
    dargs = docopt.docopt(__doc__)
    if sftp_mode:
        sftp_user = get_from_config("images", "sftp_user", dist)
        sftp_private_key = get_from_config("images", "sftp_private_key", dist)
        sftp_passphrase = get_from_config_or("images", "sftp_passphrase", dist,
                                             None)
        sftp_hosts = get_from_config("images", "hosts", dist).split(',')
        sftp_client = sftp.Sftp(sftp_hosts, sftp_user, sftp_private_key,
                                sftp_passphrase)
        sftp_client.upload([squashfs_file], os.path.dirname(squashfs_file),
                           0o755)
    else:
        clara_exit("Hosts not found for the image {0}".format(squashfs_file))
Пример #12
0
def system_install():
    package_file = get_from_config("images", "package_file", dist)
    if os.path.isfile(package_file):
        shutil.copy(package_file, work_dir + "/tmp/packages.file")
    else:
        clean_and_exit("Error copying file " + package_file)

    preseed_file = get_from_config("images", "preseed_file", dist)
    if os.path.isfile(preseed_file):
        shutil.copy(preseed_file, work_dir + "/tmp/preseed.file")
    else:
        clean_and_exit("Error copying file " + preseed_file)

    mount_chroot()
    run_chroot(["chroot", work_dir, "apt-get", "update"])
    pkgs = get_from_config("images", "important_packages", dist).split(',')
    run_chroot(["chroot", work_dir, "apt-get", "install", "--yes", "--force-yes"] + pkgs)
    run_chroot(["chroot", work_dir, "apt-get", "update"])
    run_chroot(["chroot", work_dir, "aptitude", "reinstall", "~i ?not(?priority(required))"])
    run_chroot(["chroot", work_dir, "/usr/lib/dpkg/methods/apt/update", "/var/lib/dpkg/"])
    run_chroot(["chroot", work_dir, "debconf-set-selections", "/tmp/preseed.file"])
    for i in range(0, 2):
        part1 = subprocess.Popen(["cat", work_dir + "/tmp/packages.file"],
                                 stdout=subprocess.PIPE)
        part2 = subprocess.Popen(["chroot", work_dir, "dpkg", "--set-selections"],
                                 stdin=part1.stdout, stdout=subprocess.PIPE)
        part1.stdout.close()  # Allow part1 to receive a SIGPIPE if part2 exits.
        output = part2.communicate()[0]
        run_chroot(["chroot", work_dir, "apt-get", "dselect-upgrade", "-u", "--yes", "--force-yes"])
    run_chroot(["chroot", work_dir, "apt-get", "clean"])
    run_chroot(["chroot", work_dir, "/etc/init.d/rsyslog", "stop"])
    umount_chroot()
Пример #13
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    # Use the value provided by the user in the command line
    if dargs['--p'] is not None and dargs['--p'].isdigit():
        _opts['parallel'] = int(dargs['--p'])
    # Read the value from the config file and use 1 if it hasn't been set
    elif has_config_value("ipmi", "parallel"):
        _opts['parallel']= int(get_from_config("ipmi", "parallel"))
    else:
        logging.debug("parallel hasn't been set in config.ini, using 1 as default")

    if dargs['connect']:
        do_connect(dargs['<host>'], dargs['-j'], dargs['-f'])
    elif dargs['deconnect']:
        ipmi_do(dargs['<hostlist>'], "sol", "deactivate")
    elif dargs['status']:
        ipmi_do(dargs['<hostlist>'], "power", "status")
    elif dargs['setpwd']:
        imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
        imm_pwd = value_from_file(get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
        ipmi_do(dargs['<hostlist>'], "user", "set", "name", "2", imm_user)
        ipmi_do(dargs['<hostlist>'], "user", "set", "password", "2", imm_pwd)
    elif dargs['getmac']:
        getmac(dargs['<hostlist>'])
    elif dargs['on']:
        ipmi_do(dargs['<hostlist>'], "power", "on")
    elif dargs['off']:
        ipmi_do(dargs['<hostlist>'], "power", "off")
    elif dargs['soft']:
        ipmi_do(dargs['<hostlist>'], "power", "soft")
    elif dargs['reboot']:
        ipmi_do(dargs['<hostlist>'], "chassis", "power", "reset")
    elif dargs['blink']:
        ipmi_do(dargs['<hostlist>'], "chassis", "identify", "1")
    elif dargs['bios']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootparam", "set", "bootflag", "force_bios")
    elif dargs['immdhcp']:
        ipmi_do(dargs['<hostlist>'], "lan", "set", "1", "ipsrc", "dhcp")
    elif dargs['pxe']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "pxe")
    elif dargs['disk']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "disk")
    elif dargs['reset']:
        response = raw_input('Do you really want to restart BMC interface? (N/y) ')
        if response in ('Y', 'y'):
            ipmi_do(dargs['<hostlist>'], "mc", "reset", "cold")
    elif dargs['sellist']:
        ipmi_do(dargs['<hostlist>'], "sel", "list")
    elif dargs['selclear']:
        ipmi_do(dargs['<hostlist>'], "sel", "clear")
    elif dargs['ping']:
        do_ping(dargs['<hostlist>'])
    elif dargs['ssh']:
        do_ssh(dargs['<hostlist>'], dargs['<command>'])
    elif dargs['command']:
        ipmi_do(dargs['<hostlist>'], *dargs['<command>'])
Пример #14
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global parallel
    # Read the value from the config file and use 1 if it hasn't been set
    try:
        parallel = int(get_from_config("ipmi", "parallel"))
    except:
        logging.warning(
            "parallel hasn't been set in config.ini, using 1 as value")
        parallel = 1
    # Use the value provided by the user in the command line
    if dargs['--p'] is not None and dargs['--p'].isdigit():
        parallel = int(dargs['--p'])

    if dargs['connect']:
        do_connect(dargs['<host>'], dargs['-j'], dargs['-f'])
    elif dargs['deconnect']:
        ipmi_do(dargs['<hostlist>'], "sol", "deactivate")
    elif dargs['status']:
        ipmi_do(dargs['<hostlist>'], "power", "status")
    elif dargs['setpwd']:
        imm_user = value_from_file(
            get_from_config("common", "master_passwd_file"), "IMMUSER")
        imm_pwd = value_from_file(
            get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
        ipmi_do(dargs['<hostlist>'], "user", "set", "name", "2", imm_user)
        ipmi_do(dargs['<hostlist>'], "user", "set", "password", "2", imm_pwd)
    elif dargs['getmac']:
        getmac(dargs['<hostlist>'])
    elif dargs['on']:
        ipmi_do(dargs['<hostlist>'], "power", "on")
    elif dargs['off']:
        ipmi_do(dargs['<hostlist>'], "power", "off")
    elif dargs['reboot']:
        ipmi_do(dargs['<hostlist>'], "chassis", "power", "reset")
    elif dargs['blink']:
        ipmi_do(dargs['<hostlist>'], "chassis", "identify", "1")
    elif dargs['bios']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootparam", "set", "bootflag",
                "force_bios")
    elif dargs['immdhcp']:
        ipmi_do(dargs['<hostlist>'], "lan", "set", "1", "ipsrc", "dhcp")
    elif dargs['pxe']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "pxe")
    elif dargs['disk']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "disk")
    elif dargs['reset']:
        ipmi_do(dargs['<hostlist>'], "mc", "reset", "cold")
    elif dargs['sellist']:
        ipmi_do(dargs['<hostlist>'], "sel", "list")
    elif dargs['selclear']:
        ipmi_do(dargs['<hostlist>'], "sel", "clear")
    elif dargs['ping']:
        do_ping(dargs['<hostlist>'])
    elif dargs['ssh']:
        do_ssh(dargs['<hostlist>'], dargs['<command>'])
Пример #15
0
def geninitrd(path):
    if (path is None):
        trg_dir = get_from_config("images", "trg_dir", dist)
    else:
        trg_dir = path

    if not os.path.isdir(trg_dir):
        os.makedirs(trg_dir)

    squashfs_file = get_from_config("images", "trg_img", dist)
    if not os.path.isfile(squashfs_file):
        clara_exit("The image {0} does not exist!".format(squashfs_file))

    if conf.ddebug:
        run(["unsquashfs", "-li", "-f", "-d", work_dir, squashfs_file])
    else:
        run(["unsquashfs", "-f", "-d", work_dir, squashfs_file])

    mount_chroot()

    # Install the kernel in the image
    kver = get_from_config("images", "kver", dist)
    if len(kver) == 0:
        clara_exit("kver hasn't be set in config.ini")
    else:
        run_chroot(["chroot", work_dir, "apt-get", "update"])
        run_chroot([
            "chroot", work_dir, "apt-get", "install",
            "--no-install-recommends", "--yes", "--force-yes",
            "linux-image-" + kver
        ])

    # Install packages from 'packages_initrd'
    packages_initrd = get_from_config("images", "packages_initrd", dist)
    if len(packages_initrd) == 0:
        logging.warning("packages_initrd hasn't be set in config.ini")
    else:
        pkgs = packages_initrd.split(',')
        run_chroot([
            "chroot", work_dir, "apt-get", "install",
            "--no-install-recommends", "--yes", "--force-yes"
        ] + pkgs)

    # Generate the initrd in the image
    run_chroot(
        ["chroot", work_dir, "mkinitramfs", "-o", "/tmp/initrd-" + kver, kver])
    umount_chroot()

    # Copy the initrd out of the chroot
    shutil.copy(work_dir + "/tmp/initrd-" + kver, trg_dir + "/initrd-" + kver)
    os.chmod(trg_dir + "/initrd-" + kver, 0o644)
    logging.info("Initrd available at " + trg_dir + "/initrd-" + kver)

    # Copy vmlinuz out of the chroot
    shutil.copy(work_dir + "/boot/vmlinuz-" + kver,
                trg_dir + "/vmlinuz-" + kver)
    logging.info("vmlinuz available at " + trg_dir + "/vmlinuz-" + kver)
Пример #16
0
def ipmi_do(hosts, cmd):
    install_cfg()
    imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(get_from_config("common", "master_passwd_file"), "PASSWD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    for host in nodeset:
        print "%s: " % host
        run(["ipmitool", "-I", "lanplus", "-H", "imm" + host,
             "-U", imm_user, "-E", cmd])
Пример #17
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global dist
    dist = get_from_config("common", "default_distribution")
    if dargs["<dist>"] is not None:
        dist = dargs["<dist>"]
    if dist not in get_from_config("common", "allowed_distributions"):
        clara_exit("{0} is not a know distribution".format(dist))

    trackers = get_from_config("p2p", "trackers", dist)
    seeders = get_from_config("p2p", "seeders", dist)

    tracking_service = get_from_config("p2p", "tracking_service", dist)
    seeding_service = get_from_config("p2p", "seeding_service", dist)

    if dargs['status']:
        init_status = get_from_config("p2p", "init_status")
        clush(trackers, init_status.format(tracking_service))
        clush(seeders, init_status.format(seeding_service))
    elif dargs['restart']:
        init_stop = get_from_config("p2p", "init_stop")
        clush(seeders, init_stop.format(seeding_service))
        clush(trackers, init_stop.format(tracking_service))
        time.sleep(1)
        init_start = get_from_config("p2p", "init_start")
        clush(trackers, init_start.format(tracking_service))
        clush(seeders, init_start.format(seeding_service))
    elif dargs['mktorrent']:
        mktorrent(dargs['--image'])
Пример #18
0
def genimg(image, work_dir, dist):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
        if (squashfs_file == "" or squashfs_file == None):
            image_name = dist + "_image.squashfs"
            squashfs_file = "/var/lib/clara/images/" + image_name
            if os.path.isfile(squashfs_file):
                os.rename(squashfs_file, squashfs_file + ".old")
                logging.info(
                    "Previous image renamed to {0}.".format(squashfs_file +
                                                            ".old"))

    else:
        path_to_image = os.path.dirname(image)
        if not os.path.isdir(path_to_image) and len(path_to_image) != 0:
            os.makedirs(path_to_image)
        squashfs_file = image

    if os.path.isfile(squashfs_file):
        os.rename(squashfs_file, squashfs_file + ".old")
        logging.info("Previous image renamed to {0}.".format(squashfs_file +
                                                             ".old"))

    logging.info("Creating image at {0}".format(squashfs_file))

    if not os.path.exists(os.path.dirname(squashfs_file)):
        logging.info("Creating local directory path",
                     os.path.dirname(squashfs_file))
        os.makedirs(os.path.dirname(squashfs_file))

    if conf.ddebug:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend",
            "-info"
        ])
    else:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"
        ])

    os.chmod(squashfs_file, 0o755)

    sftp_mode = has_config_value("images", "hosts", dist)
    dargs = docopt.docopt(__doc__)
    if sftp_mode and not dargs['--no-sync']:
        sftp_user = get_from_config("images", "sftp_user", dist)
        sftp_private_key = get_from_config("images", "sftp_private_key", dist)
        sftp_passphrase = get_from_config_or("images", "sftp_passphrase", dist,
                                             None)
        sftp_hosts = get_from_config("images", "hosts", dist).split(',')
        sftp_client = sftp.Sftp(sftp_hosts, sftp_user, sftp_private_key,
                                sftp_passphrase)
        sftp_client.upload([squashfs_file], os.path.dirname(squashfs_file),
                           0o755)
Пример #19
0
def install_cfg():
    passwd_file = get_from_config("common", "master_passwd_file")
    if not os.path.isfile(passwd_file) and os.path.isfile(passwd_file + ".enc"):
        password = value_from_file(get_from_config("common", "master_passwd_file"), "PASSPHRASE")

        if len(password) > 20:
            cmd = ['openssl', 'aes-256-cbc', '-d', '-in', passwd_file + ".enc",
                   '-out', passwd_file, '-k', password]
            run(cmd)
            os.chmod(passwd_file, 0o400)
        else:
            sys.exit('There was some problem reading the PASSPHRASE')
Пример #20
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global dist
    dist = get_from_config("common", "default_distribution")
    if dargs["<dist>"] is not None:
        dist = dargs["<dist>"]
    if dist not in get_from_config("common", "allowed_distributions"):
        clara_exit("{0} is not a know distribution".format(dist))

    if dargs['key']:
        do_key()
    if dargs['init']:
        do_init()
    elif dargs['sync']:
        if dargs['all']:
            do_sync('all')
        else:
            do_sync(dargs['<dist>'], dargs['<suites>'])
    elif dargs['add']:
        for elem in dargs['<file>']:
            if elem.endswith(".deb"):
                do_reprepro('includedeb', elem, dargs['--reprepro-flags'])
            elif elem.endswith(".changes"):
                do_reprepro('include', elem, dargs['--reprepro-flags'])
            elif elem.endswith(".dsc"):
                do_reprepro('includedsc', elem, dargs['--reprepro-flags'])
            else:
                clara_exit("File is not a *.deb *.dsc or *.changes")
    elif dargs['del']:
        for elem in dargs['<name>']:
            do_reprepro('remove', elem)
            do_reprepro('removesrc', elem)
    elif dargs['list']:
        if dargs['all']:
            do_reprepro_cmd(['dumpreferences'])
        else:
            do_reprepro('list')
    elif dargs['search']:
        do_reprepro_cmd(['ls', dargs['<keyword>']])
    elif dargs['copy']:
        if dargs['<from-dist>'] not in get_from_config(
                "common", "allowed_distributions"):
            clara_exit("{0} is not a know distribution".format(
                dargs['<from-dist>']))
        do_reprepro_cmd(
            ['copy', dist, dargs['<from-dist>'], dargs['<package>']])
    elif dargs['jenkins']:
        arch = dargs['--source']
        if arch is None:
            arch = "amd64"
        copy_jenkins(dargs['<job>'], arch, dargs['--reprepro-flags'])
Пример #21
0
def do_connect_ipmi(host):

    imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "USER")
    os.environ["IPMI_PASSWORD"] = value_from_file(get_from_config("common", "master_passwd_file"), "IMMPASSWORD")

    pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
    if not pat.match(host):
        host = full_hostname(host)

    ipmitool = ["ipmitool", "-I", "lanplus", "-H", host, "-U", imm_user, "-E", "-e!", "sol", "activate"]
    logging.debug("ipmi/ipmi_do: {0}".format(" ".join(ipmitool)))
    run(ipmitool)
Пример #22
0
def do_key():
    key = get_from_config("repo", "gpg_key")
    fnull = open(os.devnull, 'w')
    cmd = ['gpg', '--list-secret-keys', key]
    logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
    retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
    fnull.close()

    # We import the key if it hasn't been imported before
    if retcode != 0:
        file_stored_key = get_from_config("repo", "stored_enc_key")
        if os.path.isfile(file_stored_key):
            password = value_from_file(
                get_from_config("common", "master_passwd_file"), "ASUPASSWD")

            if len(password) > 20:
                fdesc, temp_path = tempfile.mkstemp(prefix="tmpClara")
                cmd = [
                    'openssl', 'aes-256-cbc', '-d', '-in', file_stored_key,
                    '-out', temp_path, '-k', password
                ]
                logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
                retcode = subprocess.call(cmd)

                if retcode != 0:
                    os.close(fdesc)
                    os.remove(temp_path)
                    clara_exit('Command failed {0}'.format(" ".join(cmd)))
                else:
                    logging.info("Trying to import key {0}".format(key))
                    fnull = open(os.devnull, 'w')
                    cmd = [
                        'gpg', '--allow-secret-key-import', '--import',
                        temp_path
                    ]
                    logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
                    retcode = subprocess.call(cmd)
                    fnull.close()
                    os.close(fdesc)
                    os.remove(temp_path)
                    if retcode != 0:
                        logging.info(
                            "\nThere was a problem with the import, make sure the key you imported "
                            "from {0} is the same you have in your configuration: {1}"
                            .format(file_stored_key, key))

            else:
                clara_exit(
                    'There was some problem reading the value of ASUPASSWD')
        else:
            clara_exit('Unable to read:  {0}'.format(file_stored_key))
    else:
        logging.info("GPG key was already imported.")
Пример #23
0
def mktorrent(image):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
    else:
        squashfs_file = image
    trackers_port = get_from_config("p2p", "trackers_port", dist)
    trackers_schema = get_from_config("p2p", "trackers_schema", dist)
    seeding_service = get_from_config("p2p", "seeding_service", dist)
    init_stop = get_from_config("p2p", "init_stop", dist)
    init_start = get_from_config("p2p", "init_start", dist)

    # trackers is a dictionary with pairs nodeset and torrent file
    trackers = {}
    for e in get_from_config("p2p", "trackers", dist).split(";"):
        k, v = e.split(":")
        trackers[k] = v

    # seeders in the config file is a dictionary with pairs nodeset and torrent file
    seeders_dict = {}
    for e in get_from_config("p2p", "seeders", dist).split(";"):
        k, v = e.split(":")
        seeders_dict[k] = v
    seeders = ",".join(seeders_dict.keys())

    if not os.path.isfile(squashfs_file):
        clara_exit("{0} doesn't exist".format(squashfs_file))

    # Remove old torrent files
    for f in trackers.values():
        if os.path.isfile(f):
            os.remove(f)

    clush(seeders, init_stop.format(seeding_service))

    sftp_mode = has_config_value("p2p", "sftp_user", dist)
    if sftp_mode:
        sftp_user = get_from_config("p2p", "sftp_user", dist)
        sftp_private_key = get_from_config("p2p", "sftp_private_key", dist)
        sftp_passphrase = get_from_config_or("p2p", "sftp_passphrase", dist, None)
        sftp_client = sftp.Sftp(seeders.split(','), sftp_user, sftp_private_key, sftp_passphrase)

    for e in trackers.keys():
        announce = []
        for t in list(ClusterShell.NodeSet.NodeSet(e)):
            announce.append("{0}://{1}:{2}/announce".format(trackers_schema, t, trackers_port))
        run(["/usr/bin/mktorrent", "-a", ",".join(announce), "-o", trackers[e], squashfs_file])
        if sftp_mode:
            sftp_client.upload([trackers[e]], os.path.dirname(trackers[e]))

    clush(seeders, init_start.format(seeding_service))
Пример #24
0
def mktorrent(image):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
    else:
        squashfs_file = image
    seeders = get_from_config("p2p", "seeders", dist)
    trackers_port = get_from_config("p2p", "trackers_port", dist)
    trackers_schema = get_from_config("p2p", "trackers_schema", dist)
    seeding_service = get_from_config("p2p", "seeding_service", dist)
    init_stop = get_from_config("p2p", "init_stop", dist)
    init_start = get_from_config("p2p", "init_start", dist)

    # trackers is a dictionary with pairs nodeset and torrent file
    trackers = {}
    for e in get_from_config("p2p", "trackers", dist).split(";"):
        k, v = e.split(":")
        trackers[k] = v

    if not os.path.isfile(squashfs_file):
        clara_exit("The file {0} doesn't exist".format(squashfs_file))

    # Remove old torrent files
    for f in trackers.values():
        if os.path.isfile(f):
            os.remove(f)

    clush(seeders, init_stop.format(seeding_service))

    for e in trackers.keys():
        announce = []
        for t in list(ClusterShell.NodeSet.NodeSet(e)):
            announce.append("{0}://{1}:{2}/announce".format(trackers_schema, t, trackers_port))
        run(["/usr/bin/mktorrent", "-a", ",".join(announce), "-o", trackers[e], squashfs_file])

    clush(seeders, init_start.format(seeding_service))
Пример #25
0
def do_sync(selected_dist, input_suites=[]):

    suites = []
    # Sync everything
    if selected_dist == 'all':
        for d in get_from_config("common", "allowed_distributions").split(","):
            suites = suites + get_from_config("repo", "suites", d).split(",")
    else:
        # Only sync suites related to the selected distribution
        if len(input_suites) == 0:
            suites = get_from_config("repo", "suites",
                                     selected_dist).split(",")
        # User selected one or several suites, check that they are valid
        else:
            for s in input_suites:
                if s not in get_from_config("repo", "suites",
                                            selected_dist).split(","):
                    clara_exit(
                        "{0} is not a valid suite from distribution {1}.\n"
                        "Valid suites are: {2}".format(
                            s, selected_dist,
                            get_from_config("repo", "suites", selected_dist)))
            suites = input_suites

    logging.debug("The suites to sync are: {0}.".format(" ".join(suites)))

    # Read /etc/clara/repos.ini
    if not os.path.isfile('/etc/clara/repos.ini'):
        clara_exit("File /etc/clara/repos.ini not found.")
    repos = ConfigParser.ConfigParser()
    repos.read("/etc/clara/repos.ini")

    for s in suites:

        extra = []
        if conf.ddebug:  # if extra debug for 3rd party software
            extra = ['--debug']

        final_dir = get(repos, s, "mirror_root") + "/" + s
        run(['debmirror'] + extra + [
            "--diff=none", "--nosource", "--ignore-release-gpg",
            "--ignore-missing-release", "--method={0}".format(
                get(repos, s, "method")),
            "--arch={0}".format(get(repos, s, "archs")), "--host={0}".format(
                get(repos, s, "server")), "--root={0}".format(
                    get(repos, s, "mirror_dir")), "--dist={0}".format(
                        get(repos, s, "suite_name")), "--section={0}".format(
                            get(repos, s, "sections")), final_dir
        ])
Пример #26
0
def install_https_apt():
    try:
        list_https_repos = get_from_config("chroot", "list_https_repos",
                                           dist).split(",")
    except:
        list_https_repos = None
    if not list_https_repos:
        logging.warning("list_https_repos is not specified in config.ini")
    else:
        # Install https transport for apt
        run_chroot(["chroot", work_dir, "apt-get", "update"])
        run_chroot([
            "chroot", work_dir, "apt-get", "install",
            "--no-install-recommends", "--yes", "--force-yes",
            "apt-transport-https", "openssl"
        ])
        # Add https sources in apt config
        with open(src_list, 'a') as fsources:
            for line in list_https_repos:
                fsources.write(line + '\n')
        # Add ssl keys
        apt_ssl_key_source = get_from_config("chroot", "apt_ssl_key", dist)
        apt_ssl_crt_source = get_from_config("chroot", "apt_ssl_crt", dist)
        path_dest = "/etc/ssl/"
        apt_ssl_key = path_dest + "private/" + os.path.basename(
            apt_ssl_key_source)
        apt_ssl_crt = path_dest + "certs/" + os.path.basename(
            apt_ssl_crt_source)
        if not os.path.isfile(apt_ssl_key_source):
            logging.warning("{0} is not a file!".format(apt_ssl_key_source))
        if not os.path.isfile(apt_ssl_crt_source):
            logging.warning("{0} is not a file!".format(apt_ssl_crt_source))
        if not os.path.isdir(path_dest):
            os.makedirs(path_dest)
        shutil.copy(apt_ssl_key_source, work_dir + apt_ssl_key)
        os.chmod(work_dir + apt_ssl_key, 0600)
        shutil.copy(apt_ssl_crt_source, work_dir + apt_ssl_crt)
        os.chmod(work_dir + apt_ssl_crt, 0644)
        # Add apt config for ssl key
        with open(work_dir + "/etc/apt/apt.conf.d/52ssl", 'w') as apt_conf_ssl:
            apt_conf_ssl.write("""#
# Configuration for apt over https, for secured repository
#
Acquire::https::SslCert "{0}";
Acquire::https::SslKey  "{1}";
Acquire::https::Verify-Peer "false";
""".format(apt_ssl_crt, apt_ssl_key))
        # Finally update packages database
        run_chroot(["chroot", work_dir, "apt-get", "update"])
Пример #27
0
def do_sync(option=''):
    local = get_from_config("repo", "local_modules", dist).split(',')
    remote = get_from_config("repo", "remote_modules", dist).split(',')

    for elem in range(0, len(local)):
        if os.path.isdir(get_from_config("repo", "mirror_root", dist) +
                         "/" + local[elem]) or (option == 'create'):

            run(['rsync',
                 '-az', '--stats', '--human-readable', '--force', '--delete',
                 '--ignore-errors',
                 get_from_config("repo", "server", dist) + '::' + remote[elem],
                 get_from_config("repo", "mirror_root", dist) + '/' + local[elem]])
        else:
            sys.exit('Local repository not found. '
                     'Please run: \n\tclara repo sync create')
Пример #28
0
    def fake_getfromconfig(section, value, dist=''):
        if section == "repo" and value == "repo_dir":
            return repo_path
        if section == "repo" and value == "mirror_local":
            return mirror_path

        return get_from_config(section, value, dist)
Пример #29
0
def genimg(image):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
    else:
        path_to_image = os.path.dirname(image)
        if not os.path.isdir(path_to_image) and len(path_to_image) != 0:
            os.makedirs(path_to_image)
        squashfs_file = image

    if os.path.isfile(squashfs_file):
        os.rename(squashfs_file, squashfs_file + ".old")
        logging.info("Previous image renamed to {0}.".format(squashfs_file +
                                                             ".old"))

    logging.info("Creating image at {0}".format(squashfs_file))
    run_chroot(["chroot", work_dir, "apt-get", "clean"])
    if conf.ddebug:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend",
            "-info"
        ])
    else:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"
        ])

    os.chmod(squashfs_file, 0o755)
Пример #30
0
def extract_image():
    squashfs_file = get_from_config("images", "trg_img", dist)
    if not os.path.isfile(squashfs_file):
        sys.exit("The image {0} does not exist!".format(squashfs_file))

    print "Extracting {0} to {1} ...".format(squashfs_file, work_dir)
    run(["unsquashfs", "-f", "-d", work_dir, squashfs_file])
Пример #31
0
def umount_chroot():
    if os.path.ismount(work_dir + "/proc/sys/fs/binfmt_misc"):
        run(["chroot", work_dir, "umount", "/proc/sys/fs/binfmt_misc"])

    if os.path.ismount(work_dir + "/sys"):
        run(["chroot", work_dir, "umount", "/sys"])

    if os.path.ismount(work_dir + "/proc"):
        run(["chroot", work_dir, "umount", "/proc"])
    try:
        extra_bind_mounts = get_from_config("chroot", "extra_bind_mounts",
                                            dist).split(",")
    except:
        extra_bind_mounts = None
    if not extra_bind_mounts:
        logging.warning("extra_bind_mounts is not specified in config.ini")
    else:
        for mounts_params in extra_bind_mounts:
            mountpoint = work_dir + mounts_params.split(" ")[1]
            with open("/proc/mounts", "r") as file_to_read:
                for line in file_to_read:
                    if mountpoint in line:
                        run(["umount", mountpoint])
    time.sleep(1)  # Wait one second so the system has time to unmount
    with open("/proc/mounts", "r") as file_to_read:
        for line in file_to_read:
            if work_dir in line:
                clara_exit("Something went wrong when umounting in the chroot")
Пример #32
0
    def fake_getfromconfig(section, value, dist=''):
        if section == "p2p" and value == "seeders":
            return "seeders1,seeders2:{}".format(seed_file)
        if section == "images" and value == "trg_dir":
            return torrent_dir

        return get_from_config(section, value, dist)
Пример #33
0
def remove_files():
    files_to_remove = get_from_config("images", "files_to_remove",
                                      dist).split(',')
    for f in files_to_remove:
        if os.path.isfile(work_dir + "/" + f):
            os.remove(work_dir + "/" + f)
    os.remove(work_dir + "/usr/sbin/policy-rc.d")
Пример #34
0
def base_install():
    # Step 1 - Debootstrap
    src_list = work_dir + "/etc/apt/sources.list"
    apt_pref = work_dir + "/etc/apt/preferences.d/00custompreferences"
    apt_conf = work_dir + "/etc/apt/apt.conf.d/99nocheckvalid"
    dpkg_conf = work_dir + "/etc/dpkg/dpkg.cfg.d/excludes"
    etc_host = work_dir + "/etc/hosts"

    run(["debootstrap", get_from_config("images", "debiandist", dist), work_dir,
         get_from_config("images", "debmirror", dist) + "/debian"])

    # Step 2 - Mirror setup
    list_repos = get_from_config("images", "list_repos", dist).split(",")
    with open(src_list, 'w') as fsources:
        for line in list_repos:
            fsources.write(line + '\n')

    with open(apt_pref, 'w') as fapt:
        fapt.write("""Package: *
Pin: release o={0}
Pin-Priority: 5000

Package: *
Pin: release o={1}
Pin-Priority: 6000
""".format(dist, get_from_config("common", "origin", dist)))

    with open(apt_conf, 'w') as fconf:
        fconf.write('Acquire::Check-Valid-Until "false";\n')

    lists_hosts = get_from_config("images", "etc_hosts", dist).split(",")
    if (len(lists_hosts) % 2 != 0):
        print "WARNING: the option etc_hosts is malformed or missing an argument"
    with open(etc_host, 'w') as fhost:
        for elem in range(0, len(lists_hosts), 2):
            fhost.write("{0} {1}\n".format(lists_hosts[elem], lists_hosts[elem+1]))

    with open(dpkg_conf, 'w') as fdpkg:
        fdpkg.write("""# Drop locales except French
path-exclude=/usr/share/locale/*
path-include=/usr/share/locale/fr/*
path-include=/usr/share/locale/locale.alias

# Drop manual pages
# (We keep manual pages in the image)
## path-exclude=/usr/share/man/*
""")
Пример #35
0
def main():
    dargs = docopt.docopt(__doc__)

    trackers = get_from_config("p2p", "trackers")
    seeders = get_from_config("p2p", "seeders")

    if dargs['status']:
        clush(trackers, "service mldonkey-server status")
        clush(seeders, "service ctorrent status")
    elif dargs['restart']:
        clush(seeders, "service ctorrent stop")
        clush(trackers, "service mldonkey-server stop")
        time.sleep(1)
        clush(trackers, "service mldonkey-server start")
        clush(seeders, "service ctorrent start")
    elif dargs['mktorrent']:
        mktorrent(dargs['--image'])
Пример #36
0
def list_all_repos(dist):
    list_repos_nonsplitted = get_from_config("images", "list_repos", dist)
    if ';' in list_repos_nonsplitted:
        separator = ';'
    else:
        separator = ','
    list_repos = list_repos_nonsplitted.split(separator)
    return list_repos
Пример #37
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global keep_chroot_dir
    keep_chroot_dir = False
    # Not executed in the following cases
    # - the program dies because of a signal
    # - os._exit() is invoked directly
    # - a Python fatal error is detected (in the interpreter)
    atexit.register(clean_and_exit)

    global dist
    dist = get_from_config("common", "default_distribution")
    if dargs['<dist>'] is not None:
        dist = dargs["<dist>"]
    if dist not in get_from_config("common", "allowed_distributions"):
        clara_exit("{0} is not a know distribution".format(dist))

    global work_dir
    if dargs['repack']:
        work_dir = dargs['<directory>']
    else:
        tmpdir = get_from_config_or("images", "tmp_dir", dist, "/tmp")
        work_dir = tempfile.mkdtemp(prefix="tmpClara", dir=tmpdir)

    if dargs['create']:
        if dargs["--keep-chroot-dir"]:
            keep_chroot_dir = True
        base_install()
        install_files()
        system_install()
        remove_files()
        run_script_post_creation()
        genimg(dargs['<image>'])
    elif dargs['repack']:
        genimg(dargs['--image'])
    elif dargs['unpack']:
        extract_image(dargs['--image'])
    elif dargs['initrd']:
        geninitrd(dargs['--output'])
    elif dargs['edit']:
        edit(dargs['<image>'])
    elif dargs['push']:
        push(dargs['<image>'])
Пример #38
0
def init_config():
	passwd_file = get_from_config("common", "master_passwd_file")
	if os.path.isfile(passwd_file):
		imm_user = value_from_file(passwd_file, "IMMUSER")
		os.environ["IPMI_PASSWORD"] = value_from_file(passwd_file, "IMMPASSWORD")
		return imm_user
	else:
	        print "%s not found. Please check config." % passwd_file
		sys.exit(1)
Пример #39
0
def genimg():
    squashfs_file = get_from_config("images", "trg_img", dist)
    if os.path.isfile(squashfs_file):
        os.rename(squashfs_file, squashfs_file + ".old")
        print("Previous image renamed to {0}.".format(squashfs_file + ".old"))

    print "Creating image at {0}".format(squashfs_file)
    run_chroot(["chroot", work_dir, "apt-get", "clean"])
    run(["mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"])
    os.chmod(squashfs_file, 0o755)
Пример #40
0
def do_key():
    key = get_from_config("repo", "gpg_key")
    fnull = open(os.devnull, 'w')
    cmd = ['gpg', '--list-secret-keys', key]
    logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
    retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
    fnull.close()

    # We import the key if it hasn't been imported before
    if retcode != 0:
        file_stored_key = get_from_config("repo", "stored_enc_key")
        if os.path.isfile(file_stored_key):
            password = value_from_file(get_from_config("common", "master_passwd_file"), "ASUPASSWD")

            if len(password) > 20:
                fdesc, temp_path = tempfile.mkstemp(prefix="tmpClara")
                cmd = ['openssl', 'aes-256-cbc', '-d', '-in', file_stored_key, '-out', temp_path, '-k', password]
                logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
                retcode = subprocess.call(cmd)

                if retcode != 0:
                    os.close(fdesc)
                    os.remove(temp_path)
                    clara_exit('Command failed {0}'.format(" ".join(cmd)))
                else:
                    logging.info("Trying to import key {0}".format(key))
                    fnull = open(os.devnull, 'w')
                    cmd = ['gpg', '--allow-secret-key-import', '--import', temp_path]
                    logging.debug("repo/do_key: {0}".format(" ".join(cmd)))
                    retcode = subprocess.call(cmd)
                    fnull.close()
                    os.close(fdesc)
                    os.remove(temp_path)
                    if retcode != 0:
                        logging.info("\nThere was a problem with the import, make sure the key you imported "
                              "from {0} is the same you have in your configuration: {1}".format(file_stored_key, key))

            else:
                clara_exit('There was some problem reading the value of ASUPASSWD')
        else:
            clara_exit('Unable to read:  {0}'.format(file_stored_key))
    else:
        logging.info("GPG key was already imported.")
Пример #41
0
def get(config, section, value):

    # If the value is not in the override section, look in "repos" from the config.ini
    if config.has_option(section, value):
        return config.get(section, value).strip()
    else:
        try:
            return get_from_config("repo", value)
        except:
            clara_exit("Value '{0}' not found in section '{1}'".format(value, section))
Пример #42
0
def run_script_post_creation():
    script = get_from_config("chroot", "script_post_creation", dist)
    if len(script) == 0:
        logging.warning("script_post_creation hasn't be set in the config.ini")
    elif not os.path.isfile(script):
        logging.warning("File {0} not found!".format(script))
    else:
        # Copy the script into the chroot and make sure it's executable
        shutil.copy(script, work_dir + "/tmp/script")
        os.chmod(work_dir + "/tmp/script", 0o755)
        run_chroot(["chroot", work_dir, "bash", "/tmp/script"])
Пример #43
0
def get_encryption_key():

    master_passwd_file = get_from_config("common", "master_passwd_file")

    if os.path.isfile(master_passwd_file):
        password = value_from_file(master_passwd_file, "ASUPASSWD")
        if len(password) > 20:
            return password
        else:
            clara_exit("There was some problem reading the value of ASUPASSWD")
    else:
        clara_exit("Unable to read: {0}".format(master_passwd_file))
Пример #44
0
def do_init():
    repo_dir = get_from_config("repo", "repo_dir", dist)
    reprepro_config = repo_dir + '/conf/distributions'

    if not os.path.isfile(reprepro_config):
        if not os.path.isdir(repo_dir + '/conf'):
            os.makedirs(repo_dir + '/conf')

        freprepro = open(reprepro_config, 'w')
        freprepro.write("""Origin: {0}
Label: {1}
Suite: {1}
Codename: {1}
Version: {2}
Architectures: amd64 source
Components: main contrib non-free
UDebComponents: main
SignWith: {3}
Description: Depot Local {4}
DebIndices: Packages Release . .gz .bz2
DscIndices: Sources Release . .gz .bz2
""".format(get_from_config("common", "origin", dist),
            dist,
            get_from_config("repo", "version", dist),
            get_from_config("repo", "gpg_key", dist),
            get_from_config("repo", "clustername", dist)))
        freprepro.close()

    os.chdir(repo_dir)
    run(['reprepro', '--ask-passphrase', '--basedir', repo_dir,
         '--outdir', get_from_config("repo", "mirror_local", dist),
         'export', dist])
Пример #45
0
def copy_jenkins(job, arch, flags=None):
    repo_dir = get_from_config("repo", "repo_dir", dist)
    reprepro_config = repo_dir + '/conf/distributions'

    if not os.path.isfile(reprepro_config):
        clara_exit(
            "There is not configuration for the local repository for {0}. Run first 'clara repo init <dist>'"
            .format(dist))

    list_flags = ['--silent', '--ask-passphrase']
    if conf.ddebug:
        list_flags = ['-V', '--ask-passphrase']

    if flags is not None:
        list_flags.append(flags)

    if not job.endswith("-binaries"):
        job = job + "-binaries"

    jenkins_dir = get_from_config("repo", "jenkins_dir")
    path = os.path.join(jenkins_dir, job,
                        "configurations/builds/lastSuccessfulBuild/archive/")

    if not os.path.isdir(path):
        clara_exit(
            "The job {} doesn't exists or needs to be build.".format(job))

    for f in os.listdir(path):
        if f.endswith("_{0}.changes".format(arch)):
            changesfile = os.path.join(path + f)

    if changesfile is None:
        clara_exit("Not changes files was found in {0}".format(path))

    cmd = ['reprepro'] + list_flags + \
         ['--basedir', get_from_config("repo", "repo_dir", dist),
         '--outdir', get_from_config("repo", "mirror_local", dist),
         "include", dist, changesfile]

    run(cmd)
Пример #46
0
def do_key():
    fnull = open(os.devnull, 'w')
    cmd = ['gpg', '--list-secret-keys', get_from_config("repo", "gpg_key")]
    retcode = subprocess.call(cmd, stdout=fnull)
    fnull.close()

    # We import the key if it hasn't been imported before
    if retcode != 0:
        file_stored_key = get_from_config("repo", "stored_enc_key")
        if os.path.isfile(file_stored_key):
            password = value_from_file(get_from_config("common", "master_passwd_file"), "PASSPHRASE")

            if len(password) > 20:
                fdesc, temp_path = tempfile.mkstemp()
                cmd = ['openssl', 'aes-256-cbc', '-d', '-in', file_stored_key,
                       '-out', temp_path, '-k', password]
                retcode = subprocess.call(cmd)

                if retcode != 0:
                    os.close(fdesc)
                    os.remove(temp_path)
                    sys.exit('Command failed {0}'.format(" ".join(cmd)))
                else:
                    fnull = open(os.devnull, 'w')
                    cmd = ['gpg', '--allow-secret-key-import',
                           '--import', temp_path]
                    retcode = subprocess.call(cmd, stdout=fnull)
                    fnull.close()
                    os.close(fdesc)
                    os.remove(temp_path)
                    if retcode != 0:
                        sys.exit('Command failed {0}'.format(" ".join(cmd)))

            else:
                sys.exit('There was some problem reading the PASSPHRASE')
        else:
            sys.exit('Unable to read:  {0}'.format(file_stored_key))
    else:
        print "GPG key was already imported."
Пример #47
0
def geninitrd():
    trg_dir = get_from_config("images", "trg_dir", dist)
    if not os.path.isdir(trg_dir):
        sys.exit("Directory {0} does not exist!".format(trg_dir))

    mkinitrfs = get_from_config("images", "mkinitramfs", dist)
    if not os.path.isfile(mkinitrfs):
        sys.exit("{0} does not exist!".format(mkinitrfs))

    initramfsc = get_from_config("images", "initramfs-config", dist)
    if not os.path.isdir(initramfsc):
        sys.exit("Directory {0} does not exist!".format(initramfsc))

    kver = get_from_config("images", "kver", dist)
    # Generate the initrd
    run([mkinitrfs, "-d", initramfsc, "-o", trg_dir + "/initrd-" + kver, kver])
    os.chmod(trg_dir + "/initrd-" + kver, 0o644)
    print "Initrd generated in " + trg_dir + "/initrd-" + kver

    # Copy kernel into right directory
    shutil.copy("/boot/vmlinuz-" + kver, trg_dir + "/linux-" + kver)
    print "Kernel copied in " + trg_dir + "/linux-" + kver
Пример #48
0
def main():
    dargs = docopt.docopt(__doc__)

    global work_dir
    if dargs['repack']:
        work_dir = dargs['<directory>']
    else:
        work_dir = tempfile.mkdtemp()

    global dist
    dist = get_from_config("common", "distribution")
    if dargs["--dist"] is not None:
        dist = dargs["--dist"]
    if dist not in get_from_config("common", "distributions"):
        sys.exit("{0} is not a know distribution".format(dist))

    if dargs['genimg']:
        base_install()
        system_install()
        install_files()
        remove_files()
        genimg()
    elif dargs['repack']:
        genimg()
    elif dargs['unpack']:
        extract_image()
        print "Modify the image at {0} and then run:\n " \
              "\tclara images repack {0}".format(work_dir)
    elif dargs['apply_config2img']:
        extract_image()
        system_install()
        install_files()
    elif dargs['initrd']:
        geninitrd()
    elif dargs['editimg']:
        editimg(dargs['<image>'])

    if not dargs['unpack']:
        shutil.rmtree(work_dir)
Пример #49
0
def edit(image, work_dir, dist):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
        if (squashfs_file == "" or squashfs_file == None):
            image_name = dist + "_image.squashfs"
            squashfs_file = "/var/lib/clara/images/" + image_name
    else:
        squashfs_file = image

    if not os.path.isfile(squashfs_file):
        clara_exit("{0} doesn't exist.".format(squashfs_file))

    # Extract the image.
    logging.info("Extracting {0} to {1} ...".format(squashfs_file, work_dir))
    if conf.ddebug:
        run(["unsquashfs", "-li", "-f", "-d", work_dir, squashfs_file])
    else:
        run(["unsquashfs", "-f", "-d", work_dir, squashfs_file])

    # Work in the image
    os.chdir(work_dir)
    logging.info(
        "Entering into a bash shell to edit the image. ^d when you have finished."
    )
    os.putenv("PROMPT_COMMAND",
              "echo -ne  '\e[1;31m({0}) clara images> \e[0m'".format(dist))
    pty.spawn(["/bin/bash"])

    save = raw_input('Save changes made in the image? (N/y)')
    logging.debug("Input from the user: '******'".format(save))
    if save not in ('Y', 'y'):
        clara_exit(
            "Changes ignored. The image {0} hasn't been modified.".format(
                squashfs_file))

    # Rename old image and recreate new one
    os.rename(squashfs_file, squashfs_file + ".old")
    if conf.ddebug:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend",
            "-info"
        ])
    else:
        run([
            "mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"
        ])

    os.chmod(squashfs_file, 0o755)
    logging.info("\nPrevious image renamed to {0}."
                 "\nThe image has been repacked at {1}".format(
                     squashfs_file + ".old", squashfs_file))
Пример #50
0
def getmac(hosts):
    imm_user = value_from_file(get_from_config("common", "master_passwd_file"),
                               "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(
        get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    for host in nodeset:

        pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
        if not pat.match(host):
            prefix = get_from_config("ipmi", "prefix")
            host = prefix + host

        logging.info("{0}: ".format(host))
        cmd = [
            "ipmitool", "-I", "lanplus", "-H", host, "-U", imm_user, "-E",
            "fru", "print", "0"
        ]

        logging.debug("ipmi/getmac: {0}".format(" ".join(cmd)))

        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
        # The data we want is in line 15
        lines = proc.stdout.readlines()
        if (len(lines) < 14):
            clara_exit("The host {0} can't be reached".format(host))
        full_mac = lines[14].split(":")[1].strip().upper()
        mac_address1 = "{0}:{1}:{2}:{3}:{4}:{5}".format(
            full_mac[0:2], full_mac[2:4], full_mac[4:6], full_mac[6:8],
            full_mac[8:10], full_mac[10:12])

        mac_address2 = "{0}:{1}:{2}:{3}:{4}:{5}".format(
            full_mac[12:14], full_mac[14:16], full_mac[16:18], full_mac[18:20],
            full_mac[20:22], full_mac[22:24])

        logging.info("  eth0's MAC address is {0}\n"
                     "  eth1's MAC address is {1}".format(
                         mac_address1, mac_address2))
Пример #51
0
def getmac(hosts):
    imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    for host in nodeset:

        pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
        if not pat.match(host):
            host = "imm" + host

        logging.info("{0}: ".format(host))
        cmd = ["ipmitool", "-I", "lanplus", "-H", host,
               "-U", imm_user, "-E", "fru", "print", "0"]

        logging.debug("ipmi/getmac: {0}".format(" ".join(cmd)))

        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
        # The data we want is in line 15
        lines = proc.stdout.readlines()
        if (len(lines) < 14):
            clara_exit("The host {0} can't be reached".format(host))
        full_mac = lines[14].split(":")[1].strip().upper()
        mac_address1 = "{0}:{1}:{2}:{3}:{4}:{5}".format(full_mac[0:2],
                                                        full_mac[2:4],
                                                        full_mac[4:6],
                                                        full_mac[6:8],
                                                        full_mac[8:10],
                                                        full_mac[10:12])

        mac_address2 = "{0}:{1}:{2}:{3}:{4}:{5}".format(full_mac[12:14],
                                                        full_mac[14:16],
                                                        full_mac[16:18],
                                                        full_mac[18:20],
                                                        full_mac[20:22],
                                                        full_mac[22:24])

        logging.info("  eth0's MAC address is {0}\n"
                     "  eth1's MAC address is {1}".format(mac_address1, mac_address2))
Пример #52
0
def do_reprepro(action, package=None, flags=None):
    repo_dir = get_from_config("repo", "repo_dir", dist)
    reprepro_config = repo_dir + '/conf/distributions'

    if not os.path.isfile(reprepro_config):
        clara_exit("There is not configuration for the local repository for {0}. Run first 'clara repo init <dist>'".format(dist))

    list_flags = ['--silent', '--ask-passphrase']
    if conf.ddebug:
        list_flags = ['-V', '--ask-passphrase']

    if flags is not None:
        list_flags.append(flags)

    cmd = ['reprepro'] + list_flags + \
         ['--basedir', get_from_config("repo", "repo_dir", dist),
         '--outdir', get_from_config("repo", "mirror_local", dist),
         action, dist]

    if package is not None:
        cmd.append(package)

    run(cmd)
Пример #53
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    if dargs['connect']:
        do_connect(dargs['<host>'], dargs['-j'], dargs['-f'])
    elif dargs['deconnect']:
        ipmi_do(dargs['<hostlist>'], "sol", "deactivate")
    elif dargs['status']:
        ipmi_do(dargs['<hostlist>'], "power", "status")
    elif dargs['setpwd']:
        imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
        imm_pwd = value_from_file(get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
        ipmi_do(dargs['<hostlist>'], "user", "set", "name", "2", imm_user)
        ipmi_do(dargs['<hostlist>'], "user", "set", "password", "2", imm_pwd)
    elif dargs['getmac']:
        getmac(dargs['<hostlist>'])
    elif dargs['on']:
        ipmi_do(dargs['<hostlist>'], "power", "on")
    elif dargs['off']:
        ipmi_do(dargs['<hostlist>'], "power", "off")
    elif dargs['reboot']:
        ipmi_do(dargs['<hostlist>'], "chassis", "power", "reset")
    elif dargs['blink']:
        ipmi_do(dargs['<hostlist>'], "chassis", "identify", "1")
    elif dargs['bios']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootparam", "set", "bootflag", "force_bios")
    elif dargs['immdhcp']:
        ipmi_do(dargs['<hostlist>'], "lan", "set", "1", "ipsrc", "dhcp")
    elif dargs['pxe']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "pxe")
    elif dargs['disk']:
        ipmi_do(dargs['<hostlist>'], "chassis", "bootdev", "disk")
    elif dargs['reset']:
        ipmi_do(dargs['<hostlist>'], "mc", "reset", "cold")
    elif dargs['ping']:
        do_ping(dargs['<hostlist>'])
Пример #54
0
def ipmi_do(hosts, pty=False, *cmd):
    command = []
    if not isinstance(pty, bool):
        command.append(pty)
        pty = False
    command.extend(cmd)
    imm_user = value_from_file(get_from_config("common", "master_passwd_file"), "IMMUSER")
    os.environ["IPMI_PASSWORD"] = value_from_file(get_from_config("common", "master_passwd_file"), "IMMPASSWORD")
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    for host in nodeset:

        pat = re.compile("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")
        if not pat.match(host):
            host = "imm" + host

        ipmitool = ["ipmitool", "-I", "lanplus", "-H", host, "-U", imm_user, "-E", "-e!"]
        ipmitool.extend(command)

        logging.debug("ipmi/ipmi_do: {0}".format(" ".join(ipmitool)))

        if pty:
            run(ipmitool)
        else:
            os.system("echo -n '%s: ' ;" % host + " ".join(ipmitool))
Пример #55
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__)

    global dist
    dist = get_from_config("common", "default_distribution")
    if dargs["<dist>"] is not None:
        dist = dargs["<dist>"]
    if dist not in get_from_config("common", "allowed_distributions"):
        clara_exit("{0} is not a know distribution".format(dist))

    if dargs['key']:
        do_key()
    if dargs['init']:
        do_init()
    elif dargs['sync']:
        if dargs['all']:
            do_sync('all')
        else:
            do_sync(dargs['<dist>'], dargs['<suites>'])
    elif dargs['add']:
        for elem in dargs['<file>']:
            if elem.endswith(".deb"):
                do_reprepro('includedeb', elem, dargs['--reprepro-flags'])
            elif elem.endswith(".changes"):
                do_reprepro('include', elem, dargs['--reprepro-flags'])
            elif elem.endswith(".dsc"):
                do_reprepro('includedsc', elem, dargs['--reprepro-flags'])
            else:
                clara_exit("File is not a *.deb *.dsc or *.changes")
    elif dargs['del']:
        for elem in dargs['<name>']:
            do_reprepro('remove', elem)
            do_reprepro('removesrc', elem)
    elif dargs['list']:
        do_reprepro('list')
Пример #56
0
def do_sync(selected_dist, input_suites=[]):
    info_suites = {}  # Contains all the information
    suite_dist = {}  # Contains the pairs suite - webdir
    all_suites = []  # Contains a list with all the suites names

    for distribution in get_from_config("common", "allowed_distributions").split(","):
        elements = get_from_config("repo", "info_suites", distribution).split(",")
        tmp_info_suites = {}

        for e in elements:
            k, v = e.split(":")
            all_suites.append(k)
            suite_dist[k] = distribution
            tmp_info_suites[k] = v

        info_suites[distribution] = tmp_info_suites

    suites = []
    if selected_dist == 'all':  # We sync everything
        suites = all_suites
    elif len(input_suites) == 0:  # We only sync suites related to the default distribution
        suites = info_suites[selected_dist].keys()
    else:  # If we select one or several suites, we check that are valid
        for s in input_suites:
            if s not in all_suites:
                clara_exit("{0} is not a valid suite. Valid suites are: {1}".format(s, " ".join(all_suites)))
            suites = input_suites

    logging.debug("The suites to sync are: {0}.".format(" ".join(suites)))
    for s in suites:
        mirror_root = get_from_config("repo", "mirror_root", suite_dist[s])
        dm_server = get_from_config("repo", "server", suite_dist[s])
        dm_root = info_suites[suite_dist[s]][s]

        suite_name = s
        if s in ["wheezy-security", "jessie-security"]:
            suite_name = s.split("-")[0] + "/updates"

        archs = get_from_config("repo", "archs", suite_dist[s])
        sections = get_from_config("repo", "sections", suite_dist[s])

        extra = []
        if conf.ddebug:  # if extra debug for 3rd party software
            extra = ['--debug']

        run(['debmirror'] + extra + ["--diff=none", "--method=http",
             "--nosource", "--ignore-release-gpg", "--ignore-missing-release",
             "--arch={0}".format(archs),
             "--host={0}".format(dm_server),
             "--root={0}".format(dm_root),
             "--dist={0}".format(suite_name),
             "--section={0}".format(sections),
              mirror_root + "/" + s])
Пример #57
0
def do_connect(hosts):
    nodeset = ClusterShell.NodeSet.NodeSet(hosts)
    if (len(nodeset) != 1):
	    sys.exit('Only one host allowed for this command')
    else:
            try:
                cmd = ["service", "conman", "status"]
                retcode = subprocess.call(cmd, stdout=DEVNULL, stderr=STDOUT)
            except OSError, e:
                if (e.errno == errno.ENOENT):
                    sys.exit("Binary not found, check your path and/or retry as root."
                             "You were trying to run:\n {0}".format(" ".join(cmd)))

            if retcode == 0:  # if conman is running
                os.environ["CONMAN_ESCAPE"] = '!'
                conmand = value_from_file(get_from_config("nodes", "conmand"))
                run(["conman", "-d", conmand, hosts])
            elif retcode == 1 or retcode == 3:  # if conman is NOT running
                ipmi_do(hosts, ["sol", "activate"], pty=True)
            else:
                sys.exit('E: ' + ' '.join(cmd))
Пример #58
0
def editimg(image):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
    else:
        squashfs_file = image

    if not os.path.isfile(squashfs_file):
        sys.exit("The image file {0} doesn't exist.".format(squashfs_file))

    # Extract the image.
    print "Extracting {0} to {1} ...".format(squashfs_file, work_dir)
    run(["unsquashfs", "-f", "-d", work_dir, squashfs_file])
    # Work in the image
    os.chdir(work_dir)
    print "Entering into a bash shell to edit the image. ^d when you have finished"
    os.putenv("PROMPT_COMMAND", "echo -ne  '\e[1;31m clara images> \e[0m'")
    pty.spawn(["/bin/bash"])
    # Rename old image and recreate new one
    os.rename(squashfs_file, squashfs_file + ".old")
    print("Previous image renamed to {0}.".format(squashfs_file + ".old"))
    print "Recreating image at {0}".format(squashfs_file)
    run(["mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"])
    os.chmod(squashfs_file, 0o755)
Пример #59
0
def mktorrent(image):
    ml_path = "/var/lib/mldonkey"
    trg_dir = get_from_config("images", "trg_dir")
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img")
    else:
        squashfs_file = image
    seeders = get_from_config("p2p", "seeders")
    trackers = get_from_config("p2p", "trackers")
    trackers_port = get_from_config("p2p", "trackers_port")
    trackers_schema = get_from_config("p2p", "trackers_schema")

    if not os.path.isfile(squashfs_file):
        sys.exit("The file {0} doesn't exist".format(squashfs_file))

    if os.path.isfile(trg_dir + "/image.torrent"):
        os.remove(trg_dir + "/image.torrent")

    clush(seeders, "service ctorrent stop")
    clush(trackers, "service mldonkey-server stop")

    for files in ["torrents/old", "torrents/seeded", "torrents/tracked"]:
        clush(trackers, "rm -f {0}/{1}/*".format(ml_path, files))

    clush(trackers, "ln -sf {0} {1}/incoming/files/".format(squashfs_file, ml_path))

    clush(trackers, "awk 'BEGIN{verb=1}; / tracked_files = / {verb=0}; /^$/ {verb=1}; {if (verb==1) print}' /var/lib/mldonkey/bittorrent.ini > /var/lib/mldonkey/bittorrent.ini.new")
    clush(trackers, "mv {0}/bittorrent.ini.new {0}/bittorrent.ini".format(ml_path))

    announce = []
    for t in list(ClusterShell.NodeSet.NodeSet(trackers)):
        announce.append("{0}://{1}:{2}/announce".format(trackers_schema, t, trackers_port))
    run(["/usr/bin/mktorrent", "-a", ",".join(announce), "-o", trg_dir + "/image.torrent", squashfs_file])
    clush(trackers, "ln -sf {0}/image.torrent {1}/torrents/seeded/".format(trg_dir, ml_path))

    clush(trackers, "service mldonkey-server start")
    clush(seeders, "service ctorrent start")
Пример #60
0
def main():
    logging.debug(sys.argv)
    dargs = docopt.docopt(__doc__, options_first=True)

    target_dist = dargs["<dist>"]
    if target_dist not in target_dists.keys():
        sys.exit("Unknown target dist {0}".format(target_dist))

    # Create a temp directory
    work_dir = tempfile.mkdtemp(prefix="tmpRebuild")

    if dargs["source"]:
        dsc_file = dargs["<dsc_file>"]

        # Check dsc file exists
        if not os.path.isfile(dsc_file):
            sys.exit("The file {0} doesn't exist".format(dsc_file))

        # Find out versioning
        name, full_version = os.path.basename(dsc_file)[:-4].split("_")
        if "-" in full_version:
            upstream_version, debian_version = full_version.rsplit("-", 1)
        else:  # Binary package
            upstream_version, debian_version = full_version, ""

        print_info(name, full_version, upstream_version, debian_version)

        dirname = os.path.dirname(dsc_file)
        copy_files_to_workdir(os.path.join(dirname, name + "_" + upstream_version + "*"), work_dir)

    elif dargs["repo"]:
        origin_dist = dargs["<origin_dist>"]
        package_name = dargs["<package_name>"]

        if origin_dist not in target_dists.keys():
            sys.exit("Unknown origin dist {0}".format(origin_dist))

        if not isinstance(package_name, str):
            clara_exit("Package name {0} is not a string".format(package_name))

        # Check if the source package exists in the reprepro of origin_dist
        cmd = ["clara", "repo", "list", origin_dist]
        logging.debug(" ".join(cmd))
        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
        lines_proc = proc.stdout.readlines()
        found_package = False
        for line in lines_proc:
            if "|source: {} ".format(package_name) in line:
                found_package = True
                break

        # If we fail to find the package, we list what's available and exit
        if not found_package:
            logging.info("Package {0} not found. The available packages in {1} are:".format(package_name, origin_dist))
            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
            lines_proc = proc.stdout.readlines()
            for l in lines_proc:
                if "|source: " in l:
                    logging.info(l.split(":")[1])

            clara_exit("Select an available package and re-run clara.")

        # Look for the files and copy them to the temp directory
        area = "main"
        if "non-free" in line:
            area = "non-free"

        if package_name.startswith("lib"):
            package_dir = package_name[0:4] + "/" + package_name
        else:
            package_dir = package_name[0] + "/" + package_name

        # Note this is the path from the *origin* dist
        repo_path_pool = get_from_config("build", "repo_path_pool", origin_dist)
        repo_path_pool = repo_path_pool + "{0}/{1}".format(area, package_dir)
        full_version = line.split(" ")[-1].strip()
        upstream_version, debian_version = full_version.split("-")
        name = package_name

        print_info(name, full_version, upstream_version, debian_version)

        copy_files_to_workdir(os.path.join(repo_path_pool, name + "_" + upstream_version + "*"), work_dir)

    # Common code: append the calibre tag and build the package
    os.chdir(work_dir)

    cmd = ["dpkg-source", "-x", "{0}_{1}.dsc".format(name, full_version)]
    logging.debug(" ".join(cmd))
    p = subprocess.call(cmd)

    path = "{0}-{1}".format(name, upstream_version)
    os.chdir(path)

    # Check if the debian version already appends the calibre tag
    tag = target_dists[target_dist]
    debian_version_re = r"(.*)\+{0}([\.\+])(\d)".format(tag)
    debian_version_p = re.compile(debian_version_re)
    debian_version_m = debian_version_p.match(debian_version)
    if debian_version_m:
        calibre_dump_s = debian_version_m.group(3)
        try:
            calibre_dump = int(calibre_dump_s) + 1
        except ValueError:
            # calibre_dump_s was probably not an integer so start with 1
            logging.info("Unable to handle calibre dump '{0}', restarting with 1".format(calibre_dump_s))
            calibre_dump = 1
        debian_version = debian_version_m.group(1)
        sep = debian_version_m.group(2)
        new_full_version = upstream_version + "-" + debian_version + "+" + tag + sep + str(calibre_dump)
    else:
        logging.info("Tag {0} not found in Debian version, appending new one".format(tag))
        new_full_version = full_version + "+" + tag + "+1"

    # Bump the version, adding "+target_dist+1"
    cmd = ["dch", "--force-distribution", "-D", target_dist, "-v", new_full_version, "Rebuild for " + target_dist + "."]
    logging.debug(" ".join(cmd))
    p = subprocess.call(cmd)

    # Recreate the source package
    os.chdir(work_dir)
    if "-" in new_full_version:
        cmd = ["dpkg-source", "-b", path]
    else:  # Native
        cmd = ["dpkg-source", "-b", "{0}-{1}".format(name, new_full_version)]

    logging.debug(" ".join(cmd))
    p = subprocess.call(cmd)

    # And build with cowbuilder
    cowbuilder_bin = get_from_config("build", "cowbuilder_bin", target_dist)
    if not os.path.isfile(cowbuilder_bin):
        sys.exit("The file {0} doesn't exist".format(cowbuilder_bin))

    cmd = [cowbuilder_bin, "--build", "{0}_{1}.dsc".format(name, new_full_version)]
    logging.debug(" ".join(cmd))
    p = subprocess.call(cmd)

    # Remove work directory
    shutil.rmtree(work_dir)

    repo_bin_dir = get_from_config("build", "repo_bin_dir", target_dist)
    repo_src_dir = get_from_config("build", "repo_src_dir", target_dist)

    dsc_file = "{0}_{1}.dsc".format(name, new_full_version)
    dsc_path = os.path.join(repo_bin_dir, dsc_file)
    changes_file = "{0}_{1}_amd64.changes".format(name, new_full_version)
    changes_path = os.path.join(repo_bin_dir, changes_file)
    orig_file = "{0}_{1}.orig.tar.gz".format(name, upstream_version)
    debian_file = "{0}_{1}.debian.tar.gz".format(name, new_full_version)

    logging.info(
        """
Commands you are supposed to run then:
-------------8<-----------------------
unset DISPLAY
eval $(gpg-agent --daemon)
clara repo del {0} {1}
clara repo add {0} {2}
clara repo add {0} {3}
cp -v {4}/{{{5},{6},{7}}} {8}/
#-------------8<-----------------------
""".format(
            target_dist, name, dsc_path, changes_path, repo_bin_dir, dsc_file, orig_file, debian_file, repo_src_dir
        )
    )