def __init__(self, env, work_dir, get_deb_path, pbuilder="pbuilder",
              test=lambda env: True):
     self._env = env
     self._as_root = cmd_env.PrefixCmdEnv(["sudo"], env)
     self._work_dir = work_dir
     self._test = test
     self._bind_mount_dir = os.path.join(work_dir, "bind-mount")
     self._repo_dir = os.path.join(
         self._bind_mount_dir, "debian-repository")
     self._test_dir = os.path.join(self._bind_mount_dir, "test")
     # Remember to fix clean step when fix this -- don't want to clean chroot
     # self._chroot_dir = os.path.join(self._work_dir, "chroot")
     #self._chroot_base = "/var/cache/pbuilder/base.cow"
     self._chroot_base = "/var/cache/pbuilder/base.tgz"
     self._build_dir = os.path.join(self._work_dir, "build")
     self._in_test_dir = cmd_env.PrefixCmdEnv(
         cmd_env.in_dir(self._test_dir), self._env)
     self._output_file = os.path.join(self._test_dir, "output")
     self._get_deb_path = get_deb_path
     self._pbuilder = pbuilder
     # cowbuilder
     # self._pbuilder_args = ["--basepath", self._chroot_base,
     #                        "--buildplace", self._build_dir]
     self._pbuilder_args = ["--basetgz", self._chroot_base,
                            "--buildplace", self._build_dir]
def main(argv):
    parser = optparse.OptionParser("in_chroot [options] command args...")
    parser.allow_interspersed_args = False
    parser.add_option("-d", "--chroot-dir", dest="chroot_dir",
                      help="Chroot directory to use")
    parser.add_option("-s", "--su", "--sudo", dest="as_superuser",
                      default=False, action="store_true",
                      help="Run command as superuser instead of normal user")
    parser.add_option("--user", dest="user",
                      help="User to run the command as")
    parser.add_option("-X", dest="forward_x11",
                      default=False, action="store_true",
                      help="Forward X11 access")
    parser.add_option("-A", dest="forward_ssh_agent",
                      default=False, action="store_true",
                      help="Forward SSH agent")
    parser.add_option("-v", dest="verbose", default=False, action="store_true",
                      help="Verbose: print commands executed")
    options, args = parser.parse_args(argv)

    basic_env = cmd_env.BasicEnv()
    if options.verbose:
        basic_env = cmd_env.VerboseWrapper(basic_env)

    if options.chroot_dir is None:
        options.chroot_dir, cwd_in_chroot = get_chroot_from_cwd()
    else:
        options.chroot_dir = os.path.realpath(options.chroot_dir)
        cwd_in_chroot = get_cwd_in_chroot(options.chroot_dir)

    if len(args) == 0:
        parser.error("No command name given")

    # TODO: use xsudo?
    as_root = cmd_env.PrefixCmdEnv(["sudo"], basic_env)

    if options.user is None:
        # TODO: use SUDO_USER/SUDO_UID when invoked through sudo
        options.user = "******" % os.getuid()
    if options.as_superuser:
        options.user = None
    in_chroot = cmd_env.chroot_and_sudo_env(
        options.chroot_dir, as_root, os.environ,
        user=options.user,
        do_forward_x11=options.forward_x11,
        do_forward_ssh_agent=options.forward_ssh_agent)

    in_chroot = cmd_env.bash_login_env(in_chroot)

    if cwd_in_chroot is not None:
        in_chroot = cmd_env.PrefixCmdEnv(cmd_env.in_dir(cwd_in_chroot),
                                         in_chroot)
    if "TERM" in os.environ:
        in_chroot = cmd_env.PrefixCmdEnv(
            ["env", "TERM=%s" % os.environ["TERM"]], in_chroot)

    in_chroot.cmd(args, fork=False)
Beispiel #3
0
 def do_make(dest):
     self._build_env.cmd(
         cmd_env.in_dir(nacl_dir) +
         ["./scons", "MODE=nacl_extra_sdk", "extra_sdk_update",
          "USE_PATH=1",
          "naclsdk_mode=custom:%s" %
          os.path.join(dest, self._prefix.lstrip("/")),
          "naclsdk_validate=0",
          "--verbose"])
Beispiel #4
0
 def __init__(self, source_dir, build_dir, prefix, install_dir, env_vars):
     self._env = cmd_env.VerboseWrapper(cmd_env.BasicEnv())
     self._source_dir = source_dir
     self._build_dir = build_dir
     self._prefix = prefix
     self._install_dir = install_dir
     self._build_env = cmd_env.PrefixCmdEnv(
         cmd_env.in_dir(self._build_dir), EnvVarEnv(env_vars, self._env))
     self._args = {"prefix": self._prefix,
                   "source_dir": self._source_dir}
    def create_debian_repository(self, log):
        in_repo = cmd_env.PrefixCmdEnv(cmd_env.in_dir(self._repo_dir),
                                       self._env)
        dist = "dists/custom"
        main = os.path.join(dist, "main")
        # TODO: use linux32 as described in pbuilder docs
        # arch_code = "i386"
        arch_code = "amd64"
        arch = os.path.join(main, "binary-%s" % arch_code)
        in_repo.cmd(["mkdir", "-p", arch])
        in_repo.cmd(["mkdir", "-p", os.path.join(main, "source")])
        self._env.cmd(["cp", self._get_deb_path(),
                       os.path.join(self._repo_dir, arch)])
        in_repo.cmd(cmd_env.write_file_cmd("apt-ftparchive.conf", """\
Dir {
  ArchiveDir %(repo_dir)s;
  CacheDir %(repo_dir)s;
};

BinDirectory "dists/custom/main/binary-%(arch_code)s" {
  Packages "dists/custom/main/binary-%(arch_code)s/Packages";
  Contents "dists/custom/Contents-%(arch_code)s";
  SrcPackages "dists/custom/main/source/Sources";
};

Tree "dists/custom" {
  Sections "main";
  Architectures "%(arch_code)s source";
};

TreeDefault {
  BinCacheDB "$(DIST)/packages-$(ARCH).db"
};
""" % dict(repo_dir=os.path.abspath(self._repo_dir),
           arch_code=arch_code)))
        in_repo.cmd(cmd_env.write_file_cmd("apt-custom-release.conf", """\
APT::FTPArchive::Release::Origin "testdeb";
APT::FTPArchive::Release::Label "testdeb";
APT::FTPArchive::Release::Suite "custom";
APT::FTPArchive::Release::Codename "custom";
APT::FTPArchive::Release::Architectures "%(arch_code)s source";
APT::FTPArchive::Release::Components "main";
APT::FTPArchive::Release::Description "Custom debian packages for testdeb";
""" % dict(arch_code=arch_code)))
        OutputToGzipFileEnv(in_repo, os.path.join(arch, "Packages.gz")).cmd(
            ["apt-ftparchive",
             "--db", os.path.join(dist, "packages-%s.db" % arch_code),
             "packages", arch])
        in_repo.cmd(["apt-ftparchive", "generate", "apt-ftparchive.conf"])
        release.OutputToFileEnv(in_repo, os.path.join(dist, "Release")).cmd(
            ["apt-ftparchive", "--config-file", "apt-custom-release.conf",
             "release", dist])
        in_repo.cmd(["gpg", "--output", os.path.join(dist, "Release.gpg"),
                     "-ba", os.path.join(dist, "Release")])
Beispiel #6
0
def make_source_dist_easy_install_test_step(env, install_dir,
                                            source_dir,
                                            test_cmd, expected_version):
    tester = EasyInstallTester(
        env,
        install_dir,
        project_name=".",
        test_cmd=test_cmd,
        expected_version=expected_version,
        easy_install_cmd=(cmd_env.in_dir(source_dir) +
                          ["python", "setup.py", "easy_install"]))
    return tester.easy_install_test
Beispiel #7
0
def make_source_dist_easy_install_test_step(env, install_dir, source_dir,
                                            test_cmd, expected_version,
                                            python_version):
    python = "python%d.%d" % python_version
    tester = EasyInstallTester(
        env,
        install_dir,
        project_name=".",
        test_cmd=test_cmd,
        expected_version=expected_version,
        easy_install_cmd=(cmd_env.in_dir(source_dir) +
                          [python, "setup.py", "easy_install"]),
        python=python)
    return tester.easy_install_test