Example #1
0
def analyze_state(pre, post):
    """
    Analyze state of packages.

    :param rpm.hdr pre: Header before
    :param rpm.hdr post: Header after
    :return: State
    :rtype: utils.State
    """
    if not pre and post:
        return State.installed
    if pre and not post:
        return State.removed
    if not pre and not post:
        return State.absent
    if pre["sha1header"] == post["sha1header"]:
        if pre.unload() == post.unload():
            return State.unchanged
        else:
            return State.reinstalled
    ver_cmp = rpm.versionCompare(pre, post)
    if ver_cmp < 0:
        return State.updated
    if ver_cmp > 0:
        return State.downgraded
    # In theory, it will never happen as sha1header should be different
    assert ver_cmp == 0
    # Most probably we just compare different packages
    assert False, "{!r} -> {!r}".format(hdr2nevra(pre), hdr2nevra(post))
Example #2
0
def analyze_state(pre, post):
    """
    Analyze state of packages.

    :param rpm.hdr pre: Header before
    :param rpm.hdr post: Header after
    :return: State
    :rtype: utils.State
    """
    if not pre and post:
        return State.installed
    if pre and not post:
        return State.removed
    if not pre and not post:
        return State.absent
    if pre["sha1header"] == post["sha1header"]:
        if pre.unload() == post.unload():
            return State.unchanged
        else:
            return State.reinstalled
    ver_cmp = rpm.versionCompare(pre, post)
    if ver_cmp < 0:
        return State.updated
    if ver_cmp > 0:
        return State.downgraded
    # In theory, it will never happen as sha1header should be different
    assert ver_cmp == 0
    # Most probably we just compare different packages
    assert False, "{!r} -> {!r}".format(hdr2nevra(pre), hdr2nevra(post))
    def _compare_version(vv1, vv2):
        """
        Compare versions of packages.

        The method compares versions (epoch, version, release, disttag) using
        the rpm module.

        :param vv1: version of first package
        :param vv2: version of second package
        :return: `0` if versions are identical
                 `1` if the first version is larger
                 `-1` if the first version is less
        """
        v1 = rpm.hdr()
        v2 = rpm.hdr()

        v1[rpm.RPMTAG_EPOCH] = vv1[0]
        v2[rpm.RPMTAG_EPOCH] = vv2[0]

        v1[rpm.RPMTAG_VERSION] = vv1[1]
        v2[rpm.RPMTAG_VERSION] = vv2[1]
        if vv1[2]:
            v1[rpm.RPMTAG_RELEASE] = vv1[2]
        if vv2[2]:
            v2[rpm.RPMTAG_RELEASE] = vv2[2]

        # check disttag, if true, add it
        if vv1[3] != '' and vv2[3]:
            v1[rpm.RPMTAG_DISTTAG] = vv1[3]
            v2[rpm.RPMTAG_DISTTAG] = vv2[3]

        eq = rpm.versionCompare(v1, v2)

        return eq
Example #4
0
def main(argv):
    if len(argv) < 2:
        sys.stderr.write("Usage: %s PACKAGE_NAME...\n" % (argv[0],))
        return 1

    ts = rpm.TransactionSet()
    ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS)
    fresh_rpms = {}
    for f in argv[1:]:
        if not os.path.exists(f):
            printError(f, "file was not found")
            continue
        try:
            h = readRpmHeader(ts, f)
        except IOError as e:
            printError(f, "I/O error ({0}: {1}".format(e.errno, e.strerror))
            continue
        except:
            printError(f, "Unexpected error")
            continue
        if h is None:
            continue

        name = h[rpm.RPMTAG_NAME]
        arch = h[rpm.RPMTAG_ARCH]
        if (name,arch not in fresh_rpms
                or rpm.versionCompare(h, fresh_rpms[name,arch]['header']) > 0):
            fresh_rpms[name,arch] = {'header': h, 'filename': f}

    for n, v in fresh_rpms.iteritems():
        print v['filename']

    return 0
def findpackageset(hdrlist, dbPath='/'):
    ts = rpm.TransactionSet(dbPath)
    ts.setVSFlags(~(rpm.RPMVSF_NORSA | rpm.RPMVSF_NODSA | rpm.RPMVSF_NOMD5))

    pkgDict = {}

    # go through and figure out which packages in the header list are
    # actually applicable for our architecture
    pkgDict = {}
    for h in hdrlist:
        score1 = rpm.archscore(h[rpm.RPMTAG_ARCH])
        if (score1):
            name = h[rpm.RPMTAG_NAME]
            if pkgDict.has_key(name):
                score2 = rpm.archscore(pkgDict[name][rpm.RPMTAG_ARCH])
                if (score1 < score2):
                    pkgDict[name] = h
            else:
                pkgDict[name] = h
    hdlist = pkgDict.values()

    pkgDict = {}
    # loop through packages and find ones which are a newer
    # version than what we have
    for pkg in hdlist:
        mi = ts.dbMatch('name', pkg[rpm.RPMTAG_NAME])
        for h in mi:
            val = rpm.versionCompare(h, pkg)
            if (val > 0):
                #                dEBUG("found older version of %(name)s" % h)
                pass
            elif (val < 0):
                #                dEBUG("found newer version of %(name)s" % h)
                # check if we already have this package in our dictionary
                addNewPackageToUpgSet(pkgDict, pkg)
            else:
                #                dEBUG("found same verison of %(name)s" % h)
                pass

    # handle obsoletes
    for pkg in hdlist:
        if pkg[rpm.RPMTAG_NAME] in pkgDict.keys():
            #            dEBUG("%(name)s is already selected" % pkg)
            continue

        if pkg[rpm.RPMTAG_OBSOLETENAME] is not None:
            for obs in pkg[rpm.RPMTAG_OBSOLETENAME]:
                mi = ts.dbMatch('name', obs)
                # FIXME: I should really iterate over all matches and verify
                # versioned obsoletes, but nothing in Red Hat Linux uses
                # them, so I'll optimize
                for h in mi:
                    #                    dEBUG("adding %(name)s to the upgrade set for obsoletes" % pkg)
                    addNewPackageToUpgSet(pkgDict, pkg)
                    break

    return pkgDict.values()
def cmp_RpmData_by_version(a, b):
    """ Wrapper function which passes the RPM headers in two RpmData objects
        to the rpm.versionCompare function.

    Returns:
    1 -- if the first RPM file is a newer version than the second.
    0 -- if both RPM files provide the same version of the package.
    -1 -- if the first RPM file is an older version than the second.
    """
    return rpm.versionCompare(a.header, b.header)
Example #7
0
 def __cmp__(self, other):
     if self.name != other.name:
         raise ValueError('Name mismatch %s != %s'
                          % (self.name, other.name))
     levr = "%d:%s-%s" % (self.epoch, self.version, self.release)
     if self.distepoch:
         levr += ":" + self.distepoch
     revr = "%d:%s-%s" % (other.epoch, other.version, other.release)
     if other.distepoch:
         revr += ":" + other.distepoch
     return rpm.versionCompare(levr, revr);
Example #8
0
def compareVersion(ha, hb):
    """Compares RPM header information epoch, version and release.
    
    Args:
      ha (rpm.hdr): RPM header object "a" in the comparison.
      hb (rpm.hdr): RPM header object "b" in the comparison.

    Returns:
      0 - If equal, -1 if ha < hb, +1 if ha > hb.
    """
    return rpm.versionCompare(ha, hb)
def comparePackageForUpgrade(updDict, h, pkg):
    val = rpm.versionCompare(h, pkg)
    if val > 0:
        #        dEBUG("found older version of %(name)s %(arch)s" % h)
        pass
    elif val < 0:
        #        dEBUG("found newer version of %(name)s %(arch)s" % h)
        # check if we already have this package in our dictionary
        addNewPackageToUpgSet(updDict, pkg)
    else:
        #        dEBUG("found same verison of %(name)s %(arch)s" % h)
        pass
Example #10
0
def comparePackageForUpgrade(updDict, h, pkg):
    val = rpm.versionCompare(h, pkg)
    if (val > 0):
        #        dEBUG("found older version of %(name)s %(arch)s" % h)
        pass
    elif (val < 0):
        #        dEBUG("found newer version of %(name)s %(arch)s" % h)
        # check if we already have this package in our dictionary
        addNewPackageToUpgSet(updDict, pkg)
    else:
        #        dEBUG("found same verison of %(name)s %(arch)s" % h)
        pass
def addNewPackageToUpgSet(pkgDict, pkg):
    """Check to see if there's already a pkg by the name of pkg already
       in our dictionary.  If not, add this one.  If there is, see if
       this one is 'newer' or has a 'better' arch."""
    name = pkg[rpm.RPMTAG_NAME]
    arch = pkg[rpm.RPMTAG_ARCH]
    if not pkgDict.has_key((name, arch)):
        # nope
        pkgDict[(name, arch)] = pkg
    else:
        # first check version
        val = rpm.versionCompare(pkgDict[(name, arch)], pkg)
        if val < 0:
            # we're newer, add this one
            pkgDict[(name, arch)] = pkg
Example #12
0
def addNewPackageToUpgSet(pkgDict, pkg):
    """Check to see if there's already a pkg by the name of pkg already
       in our dictionary.  If not, add this one.  If there is, see if
       this one is 'newer' or has a 'better' arch."""
    name = pkg[rpm.RPMTAG_NAME]
    arch = pkg[rpm.RPMTAG_ARCH]
    if not pkgDict.has_key((name, arch)):
        # nope
        pkgDict[(name, arch)] = pkg
    else:
        # first check version
        val = rpm.versionCompare(pkgDict[(name, arch)], pkg)
        if val < 0:
            # we're newer, add this one
            pkgDict[(name, arch)] = pkg
Example #13
0
    def _kexec_tools_version_supported(self):
        result = False
        min_version = self._get_min_kexec_tools_version()
        min_hdr = self._create_hdr(*min_version)
        if min_version is not None:
            pkgs = self.packager.queryPackages(
                patterns=(self._KEXEC_TOOLS_PKG,),
            )
            for package in pkgs:
                cur_hdr = self._create_hdr(
                    0,
                    package['version'],
                    package['release']
                )
                if rpm.versionCompare(cur_hdr, min_hdr) >= 0:
                    result = True
                    break

        return result
def addNewPackageToUpgSet(pkgDict, pkg):
    """Check to see if there's already a pkg by the name of pkg already
       in our dictionary.  If not, add this one.  If there is, see if
       this one is 'newer' or has a 'better' arch."""
    name = pkg[rpm.RPMTAG_NAME]
    if not pkgDict.has_key(name):
        # nope
        pkgDict[name] = pkg
    else:
        # first check version
        val = rpm.versionCompare(pkgDict[name], pkg)
        if val < 0:
            # we're newer, add this one
            pkgDict[name] = pkg
        elif val == 0:
            # same version, so check the architecture
            newscore = rpm.archscore(pkg[rpm.RPMTAG_ARCH])
            oldscore = pkgDict[name][rpm.RPMTAG_ARCH]
            if newscore and newscore < oldscore:
                # if the score is less, we're "better"
                pkgDict[name] = pkg
Example #15
0
def reboot_required():
    """
    Check if reboot required by comparing running kernel package's version
     with the newest installed kernel package's one.
    """
    boot_image_path = kernel_cmdline().get('BOOT_IMAGE')
    if boot_image_path is None:
        return None
    if is_debian():  # For apt-based distros.
        import apt_pkg
        apt_pkg.init()
        kernel_pkg = get_kernel_deb_package(boot_image_path)
        if kernel_pkg is not None:
            match = DEBIAN_KERNEL_PKG_NAME_RE.match(kernel_pkg.name)
            if match:
                name_parts = match.groups(
                )  # E.g. ('linux-image-4.4.0-', '174', '-generic')
                latest_kernel_pkg = get_latest_same_kernel_deb(
                    name_parts[0], name_parts[2])
                return apt_pkg.version_compare(
                    latest_kernel_pkg.installed.version,
                    kernel_pkg.installed.version) > 0
    elif is_amazon_linux2():  # For Amazon Linux 2.
        import rpm
        kernel_pkg = get_kernel_rpm_package(boot_image_path)
        if kernel_pkg is not None:
            ts = rpm.ts()
            # Find the newest kernel package.
            package_iterator = ts.dbMatch('name', 'kernel')
            if package_iterator.count() > 0:
                latest_kernel_pkg = sorted(
                    [package_header for package_header in package_iterator],
                    key=cmp_to_key(rpm.versionCompare),
                    reverse=True)[0]
                return rpm.versionCompare(latest_kernel_pkg, kernel_pkg) > 0
    return None
Example #16
0
quiet = False
if '-q' in args:
    args.remove('-q')
    quiet = True

if len(args) < 2:
    usage()
    sys.exit(42)

try:
    hdr1 = hdrfromstr(args[0])
    hdr2 = hdrfromstr(args[1])
except ValueError, ve:
    print >> sys.stderr, ve
    sys.exit(42)

ret = rpm.versionCompare(hdr1, hdr2)

if not quiet:
    if ret < 0:
        result = "is older than"
    elif ret == 0:
        result = "is equal to"
    else:
        result = "is newer than"

    print "'%s' %s '%s'" % (hdrtostr(hdr1), result, hdrtostr(hdr2))

sys.exit(ret)
Example #17
0
quiet = False
if "-q" in args:
    args.remove("-q")
    quiet = True

if len(args) < 2:
    usage()
    sys.exit(42)

try:
    hdr1 = hdrfromstr(args[0])
    hdr2 = hdrfromstr(args[1])
except ValueError, ve:
    print >> sys.stderr, ve
    sys.exit(42)

ret = rpm.versionCompare(hdr1, hdr2)

if not quiet:
    if ret < 0:
        result = "is older than"
    elif ret == 0:
        result = "is equal to"
    else:
        result = "is newer than"

    print "'%s' %s '%s'" % (hdrtostr(hdr1), result, hdrtostr(hdr2))

sys.exit(ret)
Example #18
0
 def __lt__(self, other):
     return rpm.versionCompare(self, other) < 0
 def __lt__(self, other):
     return rpm.versionCompare(self, other) < 0