Python rpm.TransactionSet() Examples

def __init__(self, *args, **kwargs):
        ReviewBot.ReviewBot.__init__(self, *args, **kwargs)

        self.no_review = False
        self.force = False

        self.ts = rpm.TransactionSet()
        self.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES)

        # reports of source submission
        self.reports = []
        # textual report summary for use in accept/decline message
        # or comments
        self.text_summary = ''

        self.session = DB.db_session()

        self.dblogger = LogToDB(self.session)

        self.logger.addFilter(self.dblogger)

        self.commentapi = CommentAPI(self.apiurl)

        self.current_request = None 

def get_rpm_info(path):
    ts = rpm.TransactionSet()

    # disable signature checks, we might not have the key or the file might be unsigned
    # pre 4.15 RPM needs to use the old name of the bitmask
    try:
        vsflags = rpm.RPMVSF_MASK_NOSIGNATURES
    except AttributeError:
        vsflags = rpm._RPMVSF_NOSIGNATURES
    ts.setVSFlags(vsflags)

    with open(path) as rpmfile:
        rpmhdr = ts.hdrFromFdno(rpmfile)

    name = rpmhdr[rpm.RPMTAG_NAME].decode('ascii')
    epoch = rpmhdr[rpm.RPMTAG_EPOCHNUM]
    version = rpmhdr[rpm.RPMTAG_VERSION].decode('ascii')
    release = rpmhdr[rpm.RPMTAG_RELEASE].decode('ascii')
    arch = rpmhdr[rpm.RPMTAG_ARCH].decode('ascii')

    return (name, epoch, version, release, arch) 

def yieldSrpmHeaders(srpms, plainRpmOk=0):
    import rpm
    ts = rpm.TransactionSet('/')
    # When RPM > 4.14.90 is common we can use RPMVSF_MASK_NOSIGNATURES, RPMVSF_MASK_NODIGESTS
    # pylint: disable=protected-access
    flags = (rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS)
    ts.setVSFlags(flags)
    for srpm in srpms:
        srpm = host_file(srpm)
        try:
            fd = os.open(srpm, os.O_RDONLY)
        except OSError as e:
            raise exception.Error("Cannot find/open srpm: %s. Error: %s"
                                  % (srpm, e))
        try:
            hdr = ts.hdrFromFdno(fd)
        except rpm.error as e:
            raise exception.Error(
                "Cannot find/open srpm: %s. Error: %s" % (srpm, e))
        finally:
            os.close(fd)

        if not plainRpmOk and hdr[rpm.RPMTAG_SOURCEPACKAGE] != 1:
            raise exception.Error("File is not an srpm: %s." % srpm)

        yield hdr 

def _get_rpms(self):
        # TODO: External dep!
        import rpm

        chroot_os = os.path.join(self.dest, "rootfs")
        ts = rpm.TransactionSet(chroot_os)
        ts.setVSFlags((rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS))
        image_rpms = []
        for hdr in ts.dbMatch():  # No sorting
            if hdr['name'] == 'gpg-pubkey':
                continue
            else:
                foo = "{0}-{1}-{2}-{3}-{4}".format(hdr['name'],
                                                   hdr['epochnum'],
                                                   hdr['version'],
                                                   hdr['release'],
                                                   hdr['arch'])
                image_rpms.append(foo)
        return image_rpms 

def __init__(self, *args, **kwargs):
        cmdln.Cmdln.__init__(self, args, kwargs)
        self.ts = rpm.TransactionSet()
        self.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) 

def get_rpm_list(tags=None, separator=';'):
    """
    Return a list of RPMs in the format expected by parse_rpm_output.
    """
    if tags is None:
        tags = image_component_rpm_tags
    ts = rpm.TransactionSet()
    mi = ts.dbMatch()
    rpms = []
    for h in mi:
        rpms.append(separator.join([h.sprintf("%%{%s}" % tag) for tag in tags]))
    return rpms 

def openshift_installed():
        ''' check if openshift is installed '''
        import rpm

        transaction_set = rpm.TransactionSet()
        rpmquery = transaction_set.dbMatch("name", "atomic-openshift")

        return rpmquery.count() > 0

    # Disabling too-many-branches.  This is a yaml dictionary comparison function
    # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements 

def openshift_installed():
        ''' check if openshift is installed '''
        import rpm

        transaction_set = rpm.TransactionSet()
        rpmquery = transaction_set.dbMatch("name", "atomic-openshift")

        return rpmquery.count() > 0

    # Disabling too-many-branches.  This is a yaml dictionary comparison function
    # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements 

def newest_kernel_and_initrd():
    ts = rpm.TransactionSet()
    p = max(ts.dbMatch('name', 'kernel'))
    k = [ x for x in p['filenames']
         if fnmatch.fnmatch(x, '/boot/vmlinuz-*') ][0]
    #The initrd is not owned by the kernel rpm but generated in the %post script   
    i = '/boot/initrd-%s.img' % k[len('/boot/vmlinuz-'):]
    return (k, i) 

def get_package_ver(self, path, package):
        rpm.addMacro("_dbpath", path + '/var/lib/rpm')
        ts = rpm.TransactionSet()
        versions = list()

        try:
            mi = ts.dbMatch('name', package)
            for h in mi:
                version = "%s-%s.%s" % (h['VERSION'], h['RELEASE'], h['ARCH'])
                versions.append(version)
        except rpm.error:
            return []

        return versions 

def getCapsuleKeysFromTarget(self):
        txnSet = rpm.TransactionSet(self.root)
        matchIter = txnSet.dbMatch()
        headersByKey = {}
        for rpmlibHeader in matchIter:
            nevra = rpmhelper.NEVRA.fromHeader(rpmlibHeader)
            if nevra.name.startswith('gpg-pubkey') and not nevra.arch:
                # Skip fake packages that RPM/yum uses to hold PGP keys
                continue
            digest = self._digest(rpmlibHeader)
            key = capsules.PartialTuple((nevra, digest))
            headersByKey[key] = rpmlibHeader
        return headersByKey 

def testTestSuiteRpmLockOverride(self):
        import rpm
        class simpleCallback:
            def __init__(self):
                self.fdnos = {}

            def callback(self, what, amount, total, mydata, wibble):
                if what == rpm.RPMCALLBACK_INST_OPEN_FILE:
                    hdr, path = mydata
                    fd = os.open(path, os.O_RDONLY)
                    nvr = '%s-%s-%s' % (hdr['name'],
                                        hdr['version'],
                                        hdr['release'])
                    self.fdnos[nvr] = fd
                    return fd

        def go(root):
            ts = rpm.TransactionSet(root)
            ts.setVSFlags(~(rpm.RPMVSF_NORSA|rpm.RPMVSF_NODSA))
            ts.initDB()
            rpmloc = resources.get_archive() + '/epoch-1.0-1.i386.rpm'
            fdno = os.open(rpmloc, os.O_RDONLY)
            hdr = ts.hdrFromFdno(fdno)
            os.close(fdno)
            ts.addInstall(hdr, (hdr, rpmloc), 'u')
            ts.check()
            ts.order()
            cb = simpleCallback()
            ts.run(cb.callback,'')
            ts.closeDB()
        d = tempfile.mkdtemp()
        os.chmod(d, 0777)
        try:
            go(d + '/root1')
            util.rmtree(d + '/root1')
            go(d + '/root2')
            self.assertTrue(os.path.exists(d+'/root2/normal'))
        finally:
            util.rmtree(d)