コード例 #1
0
ファイル: rpm_utils.py プロジェクト: tflink/checkb
def cmpNEVR(nevr1, nevr2):
    '''Compare two RPM version identifiers in NEVR format.

    :param str nevr1: RPM identifier in N(E)VR format
    :param str nevr2: RPM identifier in N(E)VR format
    :return: ``-1``/``0``/``1`` if ``nevr1 < nevr2`` / ``nevr1 == nevr2`` /
             ``nevr1 > nevr2``
    :rtype: int
    :raise CheckbValueError: if name in ``nevr1`` doesn't match name in
                                ``nevr2``
    '''
    rpmver1 = hawkey.split_nevra(nevr1 + '.noarch')
    rpmver2 = hawkey.split_nevra(nevr2 + '.noarch')

    if rpmver1.name != rpmver2.name:
        raise exc.CheckbValueError("Name in nevr1 doesn't match name in "
                                   "nevr2: %s, %s" % (nevr1, nevr2))

    # sack is needed for the comparison, because it can be influence the
    # comparison (for example epoch can be set to be ignored). A default empty
    # sack should match Fedora customs
    sack = hawkey.Sack()

    # we need evr_cmp to return int so we can use it as comparison function
    # in python's sorted
    return int(rpmver1.evr_cmp(rpmver2, sack))
コード例 #2
0
ファイル: test_nevra.py プロジェクト: Xake/hawkey
    def test_evr_cmp(self):
        sack = hawkey.Sack()
        n1 = hawkey.split_nevra("jay-3:3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-4.10-4.fc3.x86_64")
        self.assertGreater(n1.evr_cmp(n2, sack), 0)
        self.assertLess(n2.evr_cmp(n1, sack), 0)

        n1 = hawkey.split_nevra("jay-3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-3.10-5.fc3.x86_64")
        self.assertLess(n1.evr_cmp(n2, sack), 0)
コード例 #3
0
ファイル: test_nevra.py プロジェクト: regeciovad/libhif
    def test_evr_cmp(self):
        sack = hawkey.Sack()
        n1 = hawkey.split_nevra("jay-3:3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-4.10-4.fc3.x86_64")
        self.assertGreater(n1.evr_cmp(n2, sack), 0)
        self.assertLess(n2.evr_cmp(n1, sack), 0)

        n1 = hawkey.split_nevra("jay-3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-3.10-5.fc3.x86_64")
        self.assertLess(n1.evr_cmp(n2, sack), 0)
コード例 #4
0
def sack_has_nevra_greater_or_equal(base, nevra):
    nevra = hawkey.split_nevra(nevra)
    pkgs = base.sack.query().filterm(name=nevra.name).latest().run()

    if len(pkgs) == 0:
        # Odd... the only way I can imagine this happen is if we fast-track a
        # brand new package from Koji which hasn't hit the updates repo yet.
        # Corner-case, but let's be nice.
        print(f"couldn't find package {nevra.name}; assuming not graduated")
        return False

    nevra_latest = hawkey.split_nevra(str(pkgs[0]))
    return nevra_latest >= nevra
コード例 #5
0
    def read_dump_file(filename):
        if filename.endswith(".gz"):
            fobj = gzip.GzipFile(filename)
        else:
            fobj = open(filename)

        if ucd(fobj.readline()) != DEBUG_VERSION:
            logger.error(_("Bad dnf debug file: %s"), filename)
            raise dnf.exceptions.Error

        skip = True
        pkgs = {}
        for line in fobj:
            line = ucd(line)
            if skip:
                if line == "%%%%RPMDB\n":
                    skip = False
                continue

            if not line or line[0] != " ":
                break

            pkg_spec = line.strip()
            nevra = hawkey.split_nevra(pkg_spec)
            pkgs[(nevra.name, nevra.arch)] = [
                "install",
                ucd(nevra.name),
                ucd(nevra.arch),
                ucd(nevra.epoch),
                ucd(nevra.version),
                ucd(nevra.release)
            ]

        return pkgs
コード例 #6
0
ファイル: debug.py プロジェクト: rpm5/dnf-plugins-extras
    def read_dump_file(filename):
        if filename.endswith(".gz"):
            fobj = gzip.GzipFile(filename)
        else:
            fobj = open(filename)

        if ucd(fobj.readline()) != DEBUG_VERSION:
            dnfpluginsextras.logger.error(_("Bad dnf debug file: %s"), filename)
            raise dnf.exceptions.Error

        skip = True
        pkgs = {}
        for line in fobj:
            line = ucd(line)
            if skip:
                if line == "%%%%RPMDB\n":
                    skip = False
                continue

            if not line or line[0] != " ":
                break

            pkg_spec = line.strip()
            nevra = hawkey.split_nevra(pkg_spec)
            pkgs[(nevra.name, nevra.arch)] = ["install", ucd(nevra.name),
                                              ucd(nevra.arch),
                                              ucd(nevra.epoch),
                                              ucd(nevra.version),
                                              ucd(nevra.release)]

        return pkgs
コード例 #7
0
 def _create_package_matcher(self, nevra_str):
     """Create a new instance of dnf.package.Package matcher."""
     nevra = split_nevra(nevra_str)
     attrs = {'name': nevra.name,
              'epoch': nevra.epoch,
              'version': nevra.version,
              'release': nevra.release,
              'arch': nevra.arch}
     return ObjectMatcher(Package, attrs)
コード例 #8
0
ファイル: support.py プロジェクト: zde/dnf
 def __init__(self, nevra, repo=None):
     self.header = None
     self.location = "%s.rpm" % nevra
     self.baseurl = None
     self.repo = repo
     self.reponame = None if repo is None else repo.id
     self.str = nevra
     (self.name, self.epoch, self.version, self.release, self.arch) = hawkey.split_nevra(nevra)
     self.evr = "%(epoch)d:%(version)s-%(release)s" % vars(self)
     self.pkgtup = (self.name, self.arch, str(self.epoch), self.version, self.release)
コード例 #9
0
    def test_split_nevra(self):
        self.assertRaises(hawkey.ValueException, hawkey.split_nevra, "no.go")
        self.assertRaises(hawkey.ValueException, hawkey.split_nevra, "")

        nevra = hawkey.split_nevra("eyes-8:1.2.3-4.fc18.x86_64")
        self.assertEqual(nevra.name, "eyes")
        self.assertEqual(nevra.epoch, 8)
        self.assertEqual(nevra.version, "1.2.3")
        self.assertEqual(nevra.release, "4.fc18")
        self.assertEqual(nevra.arch, "x86_64")
コード例 #10
0
ファイル: download.py プロジェクト: evilkost/dnf-plugins-core
 def _get_query_source(self, pkg_spec):
     """"Return a query to match a source rpm file name."""
     pkg_spec = pkg_spec[:-4]  # skip the .rpm
     nevra = hawkey.split_nevra(pkg_spec)
     q = self.base.sack.query()
     q = q.available()
     q = q.latest()
     q = q.filter(name=nevra.name, version=nevra.version,
                  release=nevra.release, arch=nevra.arch)
     return q
コード例 #11
0
ファイル: test_util.py プロジェクト: Xake/hawkey
    def test_split_nevra(self):
        self.assertRaises(hawkey.ValueException, hawkey.split_nevra, "no.go")
        self.assertRaises(hawkey.ValueException, hawkey.split_nevra, "")

        nevra = hawkey.split_nevra("eyes-8:1.2.3-4.fc18.x86_64")
        self.assertEqual(nevra.name, "eyes")
        self.assertEqual(nevra.epoch, 8)
        self.assertEqual(nevra.version, "1.2.3")
        self.assertEqual(nevra.release, "4.fc18")
        self.assertEqual(nevra.arch, "x86_64")
コード例 #12
0
    def test_cmp(self):
        pkg2 = base.by_name_repo(self.sack, "fool", "main")
        # if nevra matches the packages are equal:
        self.assertEqual(self.pkg1, pkg2)

        # if the name doesn't match they are not equal:
        pkg2 = base.by_name_repo(self.sack, "hello", "main")
        self.assertNotEqual(self.pkg1, pkg2)

        # if nevr matches, but not arch, they are not equal:
        pkg1 = hawkey.split_nevra("semolina-2-0.x86_64").to_query(self.sack)[0]
        pkg2 = hawkey.split_nevra("semolina-2-0.i686").to_query(self.sack)[0]
        self.assertNotEqual(pkg1, pkg2)
        # however evr_cmp compares only the evr part:
        self.assertEqual(pkg1.evr_cmp(pkg2), 0)

        pkg1 = hawkey.split_nevra("jay-6.0-0.x86_64").to_query(self.sack)[0]
        pkg2 = hawkey.split_nevra("jay-5.0-0.x86_64").to_query(self.sack)[0]
        self.assertLess(pkg2, pkg1)
        self.assertGreater(pkg1.evr_cmp(pkg2), 0)
コード例 #13
0
ファイル: test_package.py プロジェクト: pombredanne/libhif
    def test_cmp(self):
        pkg2 = base.by_name_repo(self.sack, "fool", "main")
        # if nevra matches the packages are equal:
        self.assertEqual(self.pkg1, pkg2)

        # if the name doesn't match they are not equal:
        pkg2 = base.by_name_repo(self.sack, "hello", "main")
        self.assertNotEqual(self.pkg1, pkg2)

        # if nevr matches, but not arch, they are not equal:
        pkg1 = hawkey.split_nevra("semolina-2-0.x86_64").to_query(self.sack)[0]
        pkg2 = hawkey.split_nevra("semolina-2-0.i686").to_query(self.sack)[0]
        self.assertNotEqual(pkg1, pkg2)
        # however evr_cmp compares only the evr part:
        self.assertEqual(pkg1.evr_cmp(pkg2), 0)

        pkg1 = hawkey.split_nevra("jay-6.0-0.x86_64").to_query(self.sack)[0]
        pkg2 = hawkey.split_nevra("jay-5.0-0.x86_64").to_query(self.sack)[0]
        self.assertLess(pkg2, pkg1)
        self.assertGreater(pkg1.evr_cmp(pkg2), 0)
コード例 #14
0
ファイル: download.py プロジェクト: wgwoods/dnf-plugins-core
 def _get_query_source(self, pkg_spec):
     """"Return a query to match a source rpm file name."""
     pkg_spec = pkg_spec[:-4]  # skip the .rpm
     nevra = hawkey.split_nevra(pkg_spec)
     q = self.base.sack.query()
     q = q.available()
     q = q.latest()
     q = q.filter(name=nevra.name,
                  version=nevra.version,
                  release=nevra.release,
                  arch=nevra.arch)
     return q
コード例 #15
0
 def nevra(self, *args):
     args_len = len(args)
     if args_len == 3:
         return self.filter(name=args[0], evr=args[1], arch=args[2])
     if args_len == 1:
         nevra = hawkey.split_nevra(args[0])
     elif args_len == 5:
         nevra = args
     else:
         raise TypeError("nevra() takes 1, 3 or 5 str params")
     return self.filter(
         name=nevra.name, epoch=nevra.epoch, version=nevra.version,
         release=nevra.release, arch=nevra.arch)
コード例 #16
0
ファイル: download.py プロジェクト: rbuj/dnf-plugins-core
 def _get_query_source(self, pkg_spec):
     """Return a query to match a source rpm file name."""
     pkg_spec = pkg_spec[:-4]  # skip the .rpm
     nevra = hawkey.split_nevra(pkg_spec)
     q = self.base.sack.query()
     q = q.available()
     q = q.latest()
     q = q.filter(name=nevra.name, version=nevra.version,
                  release=nevra.release, arch=nevra.arch)
     if len(q.run()) == 0:
         msg = _("No package " + pkg_spec + " available.")
         raise dnf.exceptions.PackageNotFoundError(msg)
     return q
コード例 #17
0
ファイル: query.py プロジェクト: hutarova/dnf
 def nevra(self, *args):
     args_len = len(args)
     if args_len == 3:
         return self.filter(name=args[0], evr=args[1], arch=args[2])
     if args_len == 1:
         nevra = hawkey.split_nevra(args[0])
     elif args_len == 5:
         nevra = args
     else:
         raise TypeError("nevra() takes 1, 3 or 5 str params")
     return self.filter(
         name=nevra.name, epoch=nevra.epoch, version=nevra.version, release=nevra.release, arch=nevra.arch
     )
コード例 #18
0
ファイル: support.py プロジェクト: lkundrak/dnf
 def __init__(self, nevra, repo=None):
     self.baseurl = None
     self.chksum = (None, None)
     self.downloadsize = None
     self.header = None
     self.location = '%s.rpm' % nevra
     self.repo = repo
     self.reponame = None if repo is None else repo.id
     self.str = nevra
     (self.name, self.epoch, self.version, self.release, self.arch) = \
         hawkey.split_nevra(nevra)
     self.evr = '%(epoch)d:%(version)s-%(release)s' % vars(self)
     self.pkgtup = (self.name, self.arch, str(self.epoch), self.version,
                    self.release)
コード例 #19
0
 def __init__(self, nevra, repo=None):
     self.baseurl = None
     self.chksum = (None, None)
     self.downloadsize = None
     self.header = None
     self.location = '%s.rpm' % nevra
     self.repo = repo
     self.reponame = None if repo is None else repo.id
     self.str = nevra
     (self.name, self.epoch, self.version, self.release, self.arch) = \
         hawkey.split_nevra(nevra)
     self.evr = '%(epoch)d:%(version)s-%(release)s' % vars(self)
     self.pkgtup = (self.name, self.arch, str(self.epoch), self.version,
                    self.release)
コード例 #20
0
ファイル: download.py プロジェクト: sedrubal/dnf-plugins-core
 def _get_query_source(self, pkg_spec):
     """Return a query to match a source rpm file name."""
     pkg_spec = pkg_spec[:-4]  # skip the .rpm
     nevra = hawkey.split_nevra(pkg_spec)
     q = self.base.sack.query()
     q = q.available()
     q = q.latest()
     q = q.filter(name=nevra.name,
                  version=nevra.version,
                  release=nevra.release,
                  arch=nevra.arch)
     if len(q.run()) == 0:
         msg = _("No package %s available.") % (pkg_spec)
         raise dnf.exceptions.PackageNotFoundError(msg)
     return q
コード例 #21
0
def _match(ent, patterns):
    try:
        n = hawkey.split_nevra(ent)
    except hawkey.ValueException:
        return False
    for name in (
        '%s' % n.name,
        '%s.%s' % (n.name, n.arch),
        '%s-%s' % (n.name, n.version),
        '%s-%s-%s' % (n.name, n.version, n.release),
        '%s-%s-%s.%s' % (n.name, n.version, n.release, n.arch),
        '%s:%s-%s-%s.%s' % (n.epoch, n.name, n.version, n.release, n.arch),
        '%s-%s:%s-%s.%s' % (n.name, n.epoch, n.version, n.release, n.arch),
    ):
        for pat in patterns:
            if fnmatch.fnmatch(name, pat):
                return True
    return False
コード例 #22
0
def map_installed_rpms_to_modules():
    """
    Map installed modular packages to the module streams they come from.
    """
    modules = get_modules()
    # empty on RHEL 7 because of no modules
    if not modules:
        return {}
    # create a reverse mapping from the RPMS to module streams
    # key: tuple of 4 strings representing a NVRA (name, version, release, arch) of an RPM
    # value: tuple of 2 strings representing a module and its stream
    rpm_streams = {}
    for module in modules:
        for rpm in module.getArtifacts():
            nevra = hawkey.split_nevra(rpm)
            rpm_key = (nevra.name, nevra.version, nevra.release, nevra.arch)
            rpm_streams[rpm_key] = (module.getName(), module.getStream())
    return rpm_streams
コード例 #23
0
def _match(ent, patterns):
    try:
        n = hawkey.split_nevra(ent.lstrip('!'))
    except hawkey.ValueException:
        return False
    for name in (
            '%s' % n.name,
            '%s.%s' % (n.name, n.arch),
            '%s-%s' % (n.name, n.version),
            '%s-%s-%s' % (n.name, n.version, n.release),
            '%s-%s-%s.%s' % (n.name, n.version, n.release, n.arch),
            '%s:%s-%s-%s.%s' % (n.epoch, n.name, n.version, n.release, n.arch),
            '%s-%s:%s-%s.%s' % (n.name, n.epoch, n.version, n.release, n.arch),
    ):
        for pat in patterns:
            if fnmatch.fnmatch(name, pat):
                return True
    return False
コード例 #24
0
ファイル: test_nevra.py プロジェクト: bitwiseworks/libdnf-os2
    def test_evr_cmp(self):
        sack = hawkey.Sack()
        n1 = hawkey.split_nevra("jay-3:3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-4.10-4.fc3.x86_64")
        self.assertGreater(n1.evr_cmp(n2, sack), 0)
        self.assertLess(n2.evr_cmp(n1, sack), 0)

        n1 = hawkey.split_nevra("jay-3.10-4.fc3.x86_64")
        n2 = hawkey.split_nevra("jay-3.10-5.fc3.x86_64")
        self.assertLess(n1.evr_cmp(n2, sack), 0)

        n1 = hawkey.split_nevra('pungi-4.0.14-3.fc24.src')
        n2 = hawkey.split_nevra('pungi-4.0.7-1.fc24.src')
        self.assertFalse(n1 < n2)
コード例 #25
0
ファイル: py3query.py プロジェクト: collinanderson/portingdb
    def run(self, args):
        if self.opts.help_cmd:
            print(self.parser.format_help())
            return

        reponame = self.opts.py3query_repo
        self.base_query = self.base.sack.query()
        self.pkg_query = self.base_query.filter(reponame=reponame)
        self.src_query = self.base_query.filter(reponame=reponame + '-source').filter(arch=['src'])

        # python_versions: {package: set of Python versions}
        python_versions = collections.defaultdict(set)
        # rpm_pydeps: {package: set of dep names}
        rpm_pydeps = collections.defaultdict(set)
        # dep_versions: {dep name: Python version}
        dep_versions = collections.defaultdict(set)
        for n, seeds in SEED_PACKAGES.items():
            provides = sorted(self.all_provides(reponame, seeds), key=str)

            # This effectively includes packages that still need
            # Python 3.4 while Rawhide only provides Python 3.5
            provides += sorted(seeds)

            for dep in progressbar(provides, 'Getting py{} requires'.format(n)):
                dep_versions[str(dep)] = n
                for pkg in self.whatrequires(dep):
                    python_versions[pkg].add(n)
                    rpm_pydeps[pkg].add(str(dep))

        # srpm_names: {package: srpm name}
        # by_srpm_name: {srpm name: set of packages}
        srpm_names = {}
        by_srpm_name = collections.defaultdict(set)
        for pkg in progressbar(python_versions.keys(), 'Getting SRPMs'):
            srpm_name = hawkey.split_nevra(pkg.sourcerpm).name
            srpm_names[pkg] = srpm_name
            by_srpm_name[srpm_name].add(pkg)

        # deps_of_pkg: {package: set of packages}
        deps_of_pkg = collections.defaultdict(set)
        all_provides = {str(r): r for p in python_versions for r in p.provides
                        if not str(r).startswith(PROVIDES_BLACKLIST)}
        for pkg in progressbar(sorted(python_versions.keys()), 'Getting requirements'):
            reqs = set()
            for provide in pkg.provides:
                reqs.update(self.whatrequires(provide))
            for req in reqs:
                if req in python_versions.keys():
                    deps_of_pkg[req].add(pkg)

        # deps_of_pkg: {srpm name: info}
        json_output = dict()
        for name in progressbar(by_srpm_name, 'Generating output'):
            pkgs = sorted(by_srpm_name[name])
            r = json_output[name] = {}
            set_status(r, pkgs, python_versions)
            r['rpms'] = {format_rpm_name(p):
                         {str(d): dep_versions[d] for d in rpm_pydeps[p]}
                        for p in pkgs}
            r['deps'] = sorted(set(srpm_names[d]
                                   for p in pkgs
                                   for d in deps_of_pkg.get(p, '')
                                   if srpm_names[d] != name))

        # add Bugzilla links
        if self.opts.fetch_bugzilla:
            bar = iter(progressbar(['connecting', 'tracker', 'individual'],
                                   'Getting bugs'))

            next(bar)
            bz = bugzilla.RHBugzilla(BUGZILLA_URL)

            next(bar)
            include_fields = ['id', 'depends_on', 'blocks', 'component',
                              'status', 'resolution']
            trackers = bz.getbugs(TRACKER_BUG_IDS,
                                  include_fields=include_fields)
            all_ids = [b for t in trackers for b in t.depends_on]

            next(bar)
            bugs = bz.getbugs(all_ids, include_fields=include_fields)
            bar.close()

            def bug_namegetter(bug):
                return '{bug.id} {bug.status} {bug.component}'.format(bug=bug)

            for bug in progressbar(bugs, 'Merging bugs',
                                   namegetter=bug_namegetter):
                r = json_output.get(bug.component, {})
                url = '{bug.weburl}#{bug.status}'.format(bug=bug)
                status = bug.status
                if bug.resolution:
                    status += ' ' + bug.resolution
                r.setdefault('links', {})['bug'] = [bug.weburl, status]
                inprogress_statuses = ('ASSIGNED', 'POST', 'MODIFIED', 'ON_QA')
                inprogress_resolutions = ('CURRENTRELEASE', 'RAWHIDE',
                                          'ERRATA', 'NEXTRELEASE')

                if r.get('status') == 'idle' and bug.status != 'NEW':
                    r['status'] = 'in-progress'
                elif r.get('status') == 'idle' and bug.status == 'NEW' and \
                        any(tb in bug.blocks for tb in MISPACKAGED_TRACKER_BUG_IDS):
                    r['status'] = "mispackaged"
                    r['note'] = ('There is a problem in Fedora packaging, ' +
                                 'not necessarily with the software itself. ' +
                                 'See the linked Fedora bug.')

        # Print out output

        if self.opts.output:
            with open(self.opts.output, 'w') as f:
                json.dump(json_output, f, indent=2, sort_keys=True)
        else:
            json.dump(json_output, sys.stdout, indent=2, sort_keys=True)
            sys.stdout.flush()
コード例 #26
0
 def test_nevra_to_query(self):
     nevra = hawkey.split_nevra("baby-6:5.0-11.x86_64")
     q = nevra.to_query(self.sack)
     self.assertLength(q, 1)
     pkg = str(q[0])
     self.assertEqual(pkg, "baby-6:5.0-11.x86_64")
コード例 #27
0
ファイル: py3query.py プロジェクト: mldulaney/portingdb
    def run(self, args):
        if self.opts.help_cmd:
            print(self.parser.format_help())
            return

        self.base_query = self.base.sack.query()
        self.pkg_query = self.base_query.filter(reponame='rawhide')
        self.src_query = self.base_query.filter(reponame='rawhide-source').filter(arch=['src'])

        # python_versions: {package: set of Python versions}
        python_versions = collections.defaultdict(set)
        # rpm_pydeps: {package: set of dep names}
        rpm_pydeps = collections.defaultdict(set)
        # dep_versions: {dep name: Python version}
        dep_versions = collections.defaultdict(set)
        for n, seeds in SEED_PACKAGES.items():
            provides = sorted(self.all_provides(seeds), key=str)

            # This effectively includes packages that still need
            # Python 3.4 while Rawhide only provides Python 3.5
            provides += sorted(seeds)

            for dep in progressbar(provides, 'Getting py{} requires'.format(n)):
                dep_versions[str(dep)] = n
                for pkg in self.whatrequires(dep):
                    python_versions[pkg].add(n)
                    rpm_pydeps[pkg].add(str(dep))

        # srpm_names: {package: srpm name}
        # by_srpm_name: {srpm name: set of packages}
        srpm_names = {}
        by_srpm_name = collections.defaultdict(set)
        for pkg in progressbar(python_versions.keys(), 'Getting SRPMs'):
            srpm_name = hawkey.split_nevra(pkg.sourcerpm).name
            srpm_names[pkg] = srpm_name
            by_srpm_name[srpm_name].add(pkg)

        # deps_of_pkg: {package: set of packages}
        deps_of_pkg = collections.defaultdict(set)
        all_provides = {str(r): r for p in python_versions for r in p.provides
                        if not str(r).startswith(PROVIDES_BLACKLIST)}
        for pkg in progressbar(sorted(python_versions.keys()), 'Getting requirements'):
            reqs = set()
            for provide in pkg.provides:
                reqs.update(self.whatrequires(provide))
            for req in reqs:
                if req in python_versions.keys():
                    deps_of_pkg[req].add(pkg)

        # deps_of_pkg: {srpm name: info}
        json_output = dict()
        for name in progressbar(by_srpm_name, 'Generating output'):
            pkgs = sorted(by_srpm_name[name])
            r = json_output[name] = {}
            if is_ported(pkgs, python_versions):
                r['status'] = 'released'
            else:
                r['status'] = 'idle'
            r['rpms'] = {format_rpm_name(p):
                         {str(d): dep_versions[d] for d in rpm_pydeps[p]}
                        for p in pkgs}
            r['deps'] = sorted(set(srpm_names[d]
                                   for p in pkgs
                                   for d in deps_of_pkg.get(p, '')
                                   if srpm_names[d] != name))

        if self.opts.output:
            with open(self.opts.output, 'w') as f:
                json.dump(json_output, f, indent=2, sort_keys=True)
        else:
            json.dump(json_output, sys.stdout, indent=2, sort_keys=True)
            sys.stdout.flush()
コード例 #28
0
ファイル: query.py プロジェクト: hutarova/dnf
def is_nevra(pattern):
    try:
        hawkey.split_nevra(pattern)
    except hawkey.ValueException:
        return False
    return True
コード例 #29
0
ファイル: queries.py プロジェクト: PaulReiber/dnf
def available_by_nevra(sack, pattern):
    try:
        installed = hawkey.split_nevra(pattern).to_query(sack)
    except hawkey.ValueException:
        return sack.query().filter(empty=True)
    return installed.filter(reponame__neq=hawkey.SYSTEM_REPO_NAME)
コード例 #30
0
ファイル: rpm_utils.py プロジェクト: tflink/checkb
def rpmformat(rpmstr, fmt='nvr', end_arch=False):
    '''
    Parse and convert an RPM package version string into a different format.
    String identifiers: N - name, E - epoch, V - version, R - release, A -
    architecture.

    :param str rpmstr: string to be manipulated in a format of N(E)VR
                       (``foo-1.2-3.fc20`` or ``bar-4:1.2-3.fc20``) or N(E)VRA
                       (``foo-1.2-3.fc20.x86_64`` or ``bar-4:1.2-3.fc20.i686``)
    :param str fmt: desired format of the string to be returned. Allowed options
                    are: ``nvr``, ``nevr``, ``nvra``, ``nevra``, ``n``, ``e``,
                    ``v``, ``r``, ``a``. If arch is not present in ``rpmstr``
                    but requested in ``fmt``, ``noarch`` is used. Epoch is
                    provided only when specifically requested (e.g.
                    ``fmt='nevr'``) **and** being non-zero; otherwise it's
                    supressed (the only exception is ``fmt='e'``, where you
                    receive ``0`` for zero epoch).
    :param bool end_arch: set this to ``True`` if ``rpmstr`` ends with an
                          architecture identifier (``foo-1.2-3.fc20.x86_64``).
                          It's not possible to reliably distinguish that case
                          automatically.
    :return: string based on the specified format, or integer if ``fmt='e'``
    :raise CheckbValueError: if ``fmt`` value is not supported
    '''
    fmt = fmt.lower()
    supported_formats = [
        'nvr', 'nevr', 'nvra', 'nevra', 'n', 'e', 'v', 'r', 'a'
    ]
    if fmt not in supported_formats:
        raise exc.CheckbValueError("Format '%s' not in supported formats "
                                   "(%s)" %
                                   (fmt, ', '.join(supported_formats)))

    # add arch if not present
    if not end_arch:
        rpmstr += '.noarch'

    # split rpmstr
    nevra = hawkey.split_nevra(rpmstr)

    # return simple fmt
    if len(fmt) == 1:
        return {
            'n': nevra.name,
            'e': nevra.epoch,
            'v': nevra.version,
            'r': nevra.release,
            'a': nevra.arch
        }[fmt]

    # return complex fmt
    evr = nevra.evr()
    # supress epoch if appropriate
    if 'e' not in fmt or nevra.epoch == 0:
        evr = evr[evr.find(':') + 1:]  # remove 'epoch:' from the beginning

    result = '%s-%s' % (nevra.name, evr)

    # append arch if requested
    if 'a' in fmt:
        result += '.' + nevra.arch

    return result
コード例 #31
0
ファイル: test_util.py プロジェクト: Xake/hawkey
 def test_nevra_to_query(self):
     nevra = hawkey.split_nevra("baby-6:5.0-11.x86_64")
     q = nevra.to_query(self.sack)
     self.assertLength(q, 1)
     pkg = str(q[0])
     self.assertEqual(pkg, "baby-6:5.0-11.x86_64")
コード例 #32
0
    def run(self, args):
        if self.opts.help_cmd:
            print(self.parser.format_help())
            return

        reponame = self.opts.py3query_repo
        self.base_query = self.base.sack.query()
        self.pkg_query = self.base_query.filter(reponame=reponame)
        self.src_query = self.base_query.filter(reponame=reponame +
                                                '-source').filter(arch=['src'])

        # python_versions: {package: set of Python versions}
        python_versions = collections.defaultdict(set)
        # rpm_pydeps: {package: set of dep names}
        rpm_pydeps = collections.defaultdict(set)
        # dep_versions: {dep name: Python version}
        dep_versions = collections.defaultdict(set)
        for n, seeds in SEED_PACKAGES.items():
            provides = sorted(self.all_provides(reponame, seeds), key=str)

            # This effectively includes packages that still need
            # Python 3.4 while Rawhide only provides Python 3.5
            provides += sorted(seeds)

            for dep in progressbar(provides,
                                   'Getting py{} requires'.format(n)):
                dep_versions[str(dep)] = n
                for pkg in self.whatrequires(dep):
                    python_versions[pkg].add(n)
                    rpm_pydeps[pkg].add(str(dep))

        # srpm_names: {package: srpm name}
        # by_srpm_name: {srpm name: set of packages}
        srpm_names = {}
        by_srpm_name = collections.defaultdict(set)
        for pkg in progressbar(python_versions.keys(), 'Getting SRPMs'):
            srpm_name = hawkey.split_nevra(pkg.sourcerpm).name
            srpm_names[pkg] = srpm_name
            by_srpm_name[srpm_name].add(pkg)

        # deps_of_pkg: {package: set of packages}
        deps_of_pkg = collections.defaultdict(set)
        all_provides = {
            str(r): r
            for p in python_versions for r in p.provides
            if not str(r).startswith(PROVIDES_BLACKLIST)
        }
        for pkg in progressbar(sorted(python_versions.keys()),
                               'Getting requirements'):
            reqs = set()
            for provide in pkg.provides:
                reqs.update(self.whatrequires(provide))
            for req in reqs:
                if req in python_versions.keys():
                    deps_of_pkg[req].add(pkg)

        # deps_of_pkg: {srpm name: info}
        json_output = dict()
        for name in progressbar(by_srpm_name, 'Generating output'):
            pkgs = sorted(by_srpm_name[name])
            r = json_output[name] = {}
            set_status(r, pkgs, python_versions)
            r['rpms'] = {
                format_rpm_name(p):
                {str(d): dep_versions[d]
                 for d in rpm_pydeps[p]}
                for p in pkgs
            }
            r['deps'] = sorted(
                set(srpm_names[d] for p in pkgs
                    for d in deps_of_pkg.get(p, '') if srpm_names[d] != name))

        # add Bugzilla links
        if self.opts.fetch_bugzilla:
            bar = iter(
                progressbar(['connecting', 'tracker', 'individual'],
                            'Getting bugs'))

            next(bar)
            bz = bugzilla.RHBugzilla(BUGZILLA_URL)

            next(bar)
            include_fields = [
                'id', 'depends_on', 'blocks', 'component', 'status',
                'resolution'
            ]
            trackers = bz.getbugs(TRACKER_BUG_IDS,
                                  include_fields=include_fields)
            all_ids = [b for t in trackers for b in t.depends_on]

            next(bar)
            bugs = bz.getbugs(all_ids, include_fields=include_fields)
            bar.close()

            def bug_namegetter(bug):
                return '{bug.id} {bug.status} {bug.component}'.format(bug=bug)

            for bug in progressbar(bugs,
                                   'Merging bugs',
                                   namegetter=bug_namegetter):
                r = json_output.get(bug.component, {})
                url = '{bug.weburl}#{bug.status}'.format(bug=bug)
                status = bug.status
                if bug.resolution:
                    status += ' ' + bug.resolution
                r.setdefault('links', {})['bug'] = [bug.weburl, status]
                inprogress_statuses = ('ASSIGNED', 'POST', 'MODIFIED', 'ON_QA')
                inprogress_resolutions = ('CURRENTRELEASE', 'RAWHIDE',
                                          'ERRATA', 'NEXTRELEASE')

                if r.get('status') == 'idle' and bug.status != 'NEW':
                    r['status'] = 'in-progress'
                elif r.get('status') == 'idle' and bug.status == 'NEW' and \
                        any(tb in bug.blocks for tb in MISPACKAGED_TRACKER_BUG_IDS):
                    r['status'] = "mispackaged"
                    r['note'] = ('There is a problem in Fedora packaging, ' +
                                 'not necessarily with the software itself. ' +
                                 'See the linked Fedora bug.')

        # Print out output

        if self.opts.output:
            with open(self.opts.output, 'w') as f:
                json.dump(json_output, f, indent=2, sort_keys=True)
        else:
            json.dump(json_output, sys.stdout, indent=2, sort_keys=True)
            sys.stdout.flush()
コード例 #33
0
def is_nevra(pattern):
    try:
        hawkey.split_nevra(pattern)
    except hawkey.ValueException:
        return False
    return True
コード例 #34
0
ファイル: py3query.py プロジェクト: dreua/portingdb
def get_srpm_name(pkg):
    return hawkey.split_nevra(pkg.sourcerpm).name if pkg.sourcerpm else pkg.name