Пример #1
0
 def setup_class(cls):
     if not cls.extract_path.exists:
         cls.extract_path.create()
         print("downloading AUR metadata to {0}".format(cls.extract_path))
         download("http://aur3.org/" + cls.tar_filename,
                  cls.extract_path.join(cls.tar_filename))
         print("extracting")
         # using :mod:`tarfile` fails with symlink errors (???)
         execute("tar xf " + cls.tar_filename, cwd=cls.extract_path.absolute)
     else:
         print("using existing metadata from {0}".format(cls.extract_path))
Пример #2
0
    def from_pkgbuild(cls, pkgbuild_path, source_timeout=5, **kwargs):
        """Create a :class:`PackageMetadata` object from a **PKGBUILD**.

        This method simply uses bash to do what bash was created to do: and that
        is parse bash scripts. Parsing a PKGBUILD in any language other than
        bash *will* inevitably break on some packages, as many packagers and
        maintainers use parameter expansion, command substitution, and in some
        cases, even conditionally assign package-critical metadata.

        Unfortunately, using bash to source a PKGBUILD has been reported to
        hang on certain 3rd party (i.e., AUR) packages, and blindly sourcing
        an untrusted PKGBUILD is a security hazard anyway. This method takes
        a couple of precautions in light of this:

            1. Fakeroot is used for each call to bash.
            2. The bash subprocess is killed if runtime exceeds
               **source_timeout** (default is 5 seconds).

        Any additional keyword arguments passed will override any variables with
        the same name in the PKGBUILD.
        """
        def filter_variables(line):
            return len(line.strip()) == len(line) and "=" in line

        def parse_array(string):
            array_item_re = "\[\d+\]=\"(.+?)\""
            return re.findall(array_item_re, string) or string

        # Not really necessary to use fakeroot on the first call to bash, but
        # it can't hurt, can it? On my machine, it doesn't slow things down
        # all that much.
        out1 = execute("fakeroot bash -c set", stdout=PIPE).stdout
        out2 = execute("fakeroot bash -c '. {0}; set'".format(pkgbuild_path),
                       stdout=PIPE, timeout=source_timeout).stdout
        dicts = map(lambda out: dict(map(lambda line: line.split("=", 1),
                                       filter(filter_variables,
                                              out.strip().split("\n")))),
                    (out2, out1))
        result = {k: parse_array(v) for k, v in dicts[0].items() if k in
                  set.difference(*map(set, dicts))}

        if "PIPESTATUS" in result:
            result.pop("PIPESTATUS")
        result.update(kwargs)
        return cls(**result)
Пример #3
0
 def sync(self, package):
     if (self.config.deptest_before_sync and
         execute("pacman -T " + package, stdout=PIPE).returncode != 0):
             raise DeferToNextBackend
     proc = self.pass_through(CAPABS.SYNC, as_root=True,
                              args=(package,), stdout=None, stderr=PIPE)
     if "target not found" not in proc.stderr:
         sys.stderr.write(proc.stderr)
     if proc.returncode != 0:
         raise DeferToNextBackend
Пример #4
0
def deptest(*dependencies):
    return map(Dependency.from_depstring, filter(None,
               execute("pacman -T " + " ".join(map(str, dependencies)),
                       stdout=PIPE).stdout.split()))