def get_nvs(spec): try: nvs = [] ts = rpm.TransactionSet() rpm_spec = ts.parseSpec(spec) name = rpm.expandMacro("%{name}") version = rpm.expandMacro("%{version}") nvs.append(name) nvs.append(version) for (filename, num, flags) in rpm_spec.sources: if num == 0 and flags == 1: # path # http://mirrors.n-ix.net/mariadb/mariadb-10.3.9/source/ source_link = '/'.join(filename.split("/")[:-1]) nvs.append(source_link) return nvs except: return None
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, name, hdr=None): if not hdr: ts = rpm.TransactionSet() mi = ts.dbMatch('name', name) if not mi: raise KeyError(name) try: hdr = next(mi) except StopIteration: raise KeyError(name) Pkg.__init__(self, name, '/', hdr) self.extracted = True # create a fake filename to satisfy some checks on the filename self.filename = '%s-%s-%s.%s.rpm' % \ (self.name, self[rpm.RPMTAG_VERSION], self[rpm.RPMTAG_RELEASE], self[rpm.RPMTAG_ARCH])
def get_rpm_header(pkg_obj): """The dnf python API does not provide the package rpm header: https://bugzilla.redhat.com/show_bug.cgi?id=1876606. So instead, we're getting the header directly from the rpm db. """ ts = rpm.TransactionSet() rpm_hdr_iter = ts.dbMatch('name', pkg_obj.name) for rpm_hdr in rpm_hdr_iter: # There might be multiple pkgs with the same name installed. if rpm_hdr[rpm.RPMTAG_VERSION] == pkg_obj.v and rpm_hdr[rpm.RPMTAG_RELEASE] == pkg_obj.r: # One might think that we could have used the package EVR for comparison, instead of version and release # separately, but there's a bug: https://bugzilla.redhat.com/show_bug.cgi?id=1876885. return rpm_hdr else: # Package not found in the rpm db loggerinst = logging.getLogger(__name__) loggerinst.critical( "Unable to find package '%s' in the rpm database." % pkg_obj.name)
def install_repo_rpm(self, url, package): print("Installing repo, via RPM, from: %s" % url) ts = rpm.TransactionSet() # trim the file name from the URL rpm_file = url[url.rindex('/') + 1:] mi = ts.dbMatch('name', package) if (mi): if len(mi) > 1: print("Ambiguous package name: %s" % package) else: print("INSTALLED: %s" % package) else: print("Package NOT installed: %s" % package) return dst_path = downloadFile(url) if not os.path.exists(dst_path): print "Error downloading file." return 1 # fetch the file and store locally if required fd = os.open(dst_path, os.O_RDONLY) ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) try: h = ts.hdrFromFdno(fd) except rpm.error, e: print(e) os.close(fd) ts.addInstall(h, rpm_file, 'i') ts.check() ts.order() ts.run(install_repo_rpm_callback, '')
def __init__(self, filename, dirname, header=None, is_source=False, extracted=False): self.filename = filename self.extracted = extracted self.dirname = self.dir_name(dirname) self.current_linenum = None self._req_names = -1 if header: self.header = header self.is_source = is_source else: # Create a package object from the file name ts = rpm.TransactionSet() # Don't check signatures here... ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) fd = os.open(filename, os.O_RDONLY) try: self.header = ts.hdrFromFdno(fd) finally: os.close(fd) self.is_source = not self.header[rpm.RPMTAG_SOURCERPM] self.name = self[rpm.RPMTAG_NAME] (self.requires, self.prereq, self.provides, self.conflicts, self.obsoletes, self.recommends, self.suggests, self.enhances, self.supplements) = self._gatherDepInfo() self.req_names = [x[0] for x in self.requires + self.prereq] self.files = self._gatherFilesInfo() self.config_files = [x.name for x in self.files.values() if x.is_config] self.doc_files = [x.name for x in self.files.values() if x.is_doc] self.ghost_files = [x.name for x in self.files.values() if x.is_ghost] self.noreplace_files = [x.name for x in self.files.values() if x.is_noreplace] self.missingok_files = [x.name for x in self.files.values() if x.is_missingok] if self.is_no_source: self.arch = 'nosrc' elif self.is_source: self.arch = 'src' else: self.arch = self.header.format('%{ARCH}')
def check_package(): print "Check if the package openldap-servers is installed" package = "openldap-servers-2.4.40-11.fc23.x86_64.rpm" ts = rpm.TransactionSet() mi = ts.dbMatch('name', package) if (len(mi) == 0): print "%s not found, Installing...." % package cmd = "yum -y localinstall /root/%s" % package stdout, return_code = run_cmd(cmd) if return_code == 0: print stdout else: print stdout print "%s package did not install" % package else: for h in mi: print "%s-%s-%s is already installed" % (h['name'], h['version'], h['release']) del mi, ts
def read_rpm(filename): rpm.addMacro("_dbpath", os.path.join(dirname(__file__), "fake_pkg_db")) rpm.addMacro("_topdir", dirname(__file__)) ts = rpm.TransactionSet( ".", rpm.RPMVSF_MASK_NODIGESTS | rpm.RPMVSF_MASK_NOSIGNATURES) fd = rpm.fd.open(filename) header = ts.hdrFromFdno(fd) # hdr[rpm.RPMTAG_NAME] = "test_rpm" # fo = os.fdopen(fd, "w+") # hdr.write(fd) print(header[rpm.RPMTAG_NAME]) files = rpm.files(header) payload = rpm.fd.open(fd, flags=header["payloadcompressor"]) archive = files.archive(payload, write=False) for t in archive: if t.fflags & rpm.RPMFILE_SPECFILE: od = os.open(t.name, os.O_RDWR | os.O_CREAT) archive.readto(od) print(t.name)
def main(args): rpmroot = '/' finalexit = 0 ts = rpm.TransactionSet(rpmroot) for package in args: error = 0 sigerror = 0 ts.setVSFlags(0) error = checkSig(ts, package) hdr = returnHdr(ts, package) if hdr == None: error = 100 print '%s: FAILED - None <None>' % package else: sigerror, (sigtype, sigdate, sigid) = getSigInfo(hdr) if sigid == 'None': email = '<None>' keyid = 'None' else: keyid = sigid[-8:] email = lookupKeyID(ts, keyid) if error != 0: if error == 103: msg = '%s: MISSING KEY - %s' % (package, keyid) print msg graylogBadRPM(msg) else: msg = '%s: FAILED - %s %s' % (package, keyid, email) print msg graylogBadRPM(msg) else: msg = '%s: %s - %s - %s' % (package, sigtype, keyid, email) print msg graylogBadRPM(msg) if error < sigerror: error = sigerror if error > finalexit: finalexit = error del hdr sys.exit(finalexit)
def __init__(self): self.ts = rpm.TransactionSet() self._methods = ['dbMatch', 'check', 'order', 'addErase', 'addInstall', 'run', 'IDTXload', 'IDTXglob', 'rollback', 'pgpImportPubkey', 'pgpPrtPkts', 'Debug', 'setFlags', 'setVSFlags', 'setProbFilter', 'hdrFromFdno'] self.tsflags = []
def __init__(self, root='/'): self.ts = rpm.TransactionSet(root) self._methods = ['check', 'order', 'addErase', 'addInstall', 'addReinstall', 'run', 'pgpImportPubkey', 'pgpPrtPkts', 'problems', 'setFlags', 'setVSFlags', 'setProbFilter', 'hdrFromFdno', 'next', 'clean'] self.tsflags = [] self.open = True
def __init__(self, name, prefix='/host', wildcard=False): """Construct rpm manager.""" self.name = name self._prefix = prefix _rpm.addMacro('_dbpath', Pathname('/var/lib/rpm/', prefix=prefix)) t = _rpm.TransactionSet() if wildcard: # wildcard's poorly supported. m = t.dbMatch() m.pattern('name', _rpm.RPMMIRE_GLOB, name) else: m = t.dbMatch('name', name) for hdr in m: self.package = hdr break else: self.package = None
def rpm_headers(dirname): """Iterate over the headers of the RPMs in a directory. :param dirname: a name of the directory :type dirname: unicode :return: a generator yielding the pairs (file name, RPM header) :rtype: generator[tuple[unicode, rpm.hdr]] """ filenames = glob.iglob(os.path.join(dirname, '*.rpm')) transaction = rpm.TransactionSet() for filename in filenames: try: with open(filename) as file_: header = transaction.hdrFromFdno(file_.fileno()) except (IOError, rpm.error): LOGGER.debug('Failed to read %s', filename, exc_info=True) continue yield filename, header
def checkPackage(name, version=False): logger.debug("About to check package %s", name) ts = rpm.TransactionSet() mi = ts.dbMatch('name', name) for h in mi: if version and "{0}-{1}".format(h['version'], h['release']) == version: logger.info("Installed version (%s) of %s is correct", version, name) return True elif version: logger.error( "Package %s is installed but the version is wrong (installed=%s-%s, expected=%s)", name, h['version'], h['release'], version) return False else: logger.info("Package %s is installed", name) return True logger.error("Package %s is NOT installed", name) return False
def loadFileProvides(self, fndict): # FIXME (20050321): Solaris rpm 4.1 hack if sys.platform[:5] == "sunos": rpm.addMacro("_dbPath", sysconf.get("rpm-root", "/")) ts = rpm.TransactionSet() else: ts = rpm.ts(sysconf.get("rpm-root", "/")) bfp = self.buildFileProvides for fn in fndict: mi = ts.dbMatch(1117, fn) # RPMTAG_BASENAMES try: h = mi.next() while h: i = mi.instance() if i in self._offsets: bfp(self._offsets[i], (RPMProvides, fn, None)) h = mi.next() except StopIteration: pass
def getHeaders(self, prog): # FIXME (20050321): Solaris rpm 4.1 hack if sys.platform[:5] == "sunos": rpm.addMacro("_dbPath", sysconf.get("rpm-root", "/")) ts = rpm.TransactionSet() else: ts = rpm.ts() for i, filename in enumerate(self._filenames): filepath = os.path.join(self._dir, filename) file = open(filepath) try: h = ts.hdrFromFdno(file.fileno()) except rpm.error, e: iface.error("%s: %s" % (os.path.basename(filepath), e)) else: yield (h, i) file.close() prog.add(1) prog.show()
def rpm_installed_version(name): """Get the installed version of a package with the given name. Args: name (str): Package name Returns: string: Version of the installed packaged, or None """ try: import rpm except ImportError: return False ts = rpm.TransactionSet() mi = ts.dbMatch('name', name) if mi: for h in mi: return h['version'] return None
def rpm_transactionset(root='/', readonly=True): """ Return rpm.TransactionSet object. :param root: RPM DB root dir :param readonly: Return read-only transaction set to pure query purpose :return: An instance of rpm.TransactionSet """ if not root.startswith('/'): root = os.path.abspath(root) ts = rpm.TransactionSet(root) if readonly: # see also: rpmUtils/transaction.py:initReadOnlyTransaction() ts.setVSFlags((rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS)) return ts
def _set_graphical_boot_args(self): """Set up the graphical boot.""" args = [] try: import rpm except ImportError: pass else: ts = rpm.TransactionSet(conf.target.system_root) # Only add "rhgb quiet" on non-s390, non-serial installs. if util.isConsoleOnVirtualTerminal() \ and (ts.dbMatch('provides', 'rhgb').count() or ts.dbMatch('provides', 'plymouth').count()): args = ["rhgb", "quiet"] self.boot_args.update(args)
def __init__(self, filename): self.log = Settings.get_logger() self._sections = {} self._section_list = [] self.filename = filename f = None try: f = open(filename, "r") self.lines = f.readlines() finally: f and f.close() ts = rpm.TransactionSet() self.spec_obj = ts.parseSpec(self.filename) self.name = self.get_from_spec('name') self.version = self.get_from_spec('version') self.release = self.get_from_spec('release') self.process_sections()
def get_package_and_component(file_=sys.argv[0]): """ Returns package and component names for file (by default for script itself). :param file_: filename :type file_: string :return: tuple containing package info and component name for the file :rtype: (PackageInfo, str) :raise RPMinfoError: if package and component for the file cannot be found """ import rpm ts = rpm.TransactionSet() mi = ts.dbMatch("basenames", file_) try: header = next(mi) except StopIteration: raise RPMinfoError("Cannot get package and component for file "+ "{0}".format(file_)) pkg_info = PackageInfo( decode_bytes(header["name"]), decode_bytes(header["version"]), decode_bytes(header["release"]), decode_bytes(header["epoch"]) if header["epoch"] else "0", decode_bytes(header["arch"]) ) # cuts the name from the NVR format: foo-blah-2.8.8-2.fc17.src.rpm srpm_name = decode_bytes(header["sourcerpm"]) name_end = len(srpm_name) try: name_end = srpm_name.rindex('-') name_end = srpm_name[:name_end].rindex('-') except ValueError: # expected exception pass component = srpm_name[:name_end] return (pkg_info, component)
def main(args): (options, args) = parseargs(args) mydir = args[0] rpmList = [] rpmList = getFileList(mydir, '.rpm', rpmList) verfile = {} pkgdict = {} # hold all of them - put them in (n,a) = [(e,v,r),(e1,v1,r1)] keepnum = int(options.keep)*(-1) # the number of items to keep if len(rpmList) == 0: errorprint('No files to process') sys.exit(1) ts = rpm.TransactionSet() if options.nocheck: ts.setVSFlags(~(rpm._RPMVSF_NOPAYLOAD)) else: ts.setVSFlags(~(rpm.RPMVSF_NOMD5|rpm.RPMVSF_NEEDPAYLOAD)) for pkg in rpmList: try: hdr = rpmUtils.miscutils.hdrFromPackage(ts, pkg) except rpmUtils.RpmUtilsError, e: msg = "Error opening pkg %s: %s" % (pkg, str(e)) errorprint(msg) continue pkgtuple = rpmUtils.miscutils.pkgTupleFromHeader(hdr) (n,a,e,v,r) = pkgtuple del hdr if (n,a) not in pkgdict: pkgdict[(n,a)] = [] pkgdict[(n,a)].append((e,v,r)) if pkgtuple not in verfile: verfile[pkgtuple] = [] verfile[pkgtuple].append(pkg)
def _rpm(): """ list all installed RPMs """ log.debug('Starting') ts = rpm.TransactionSet() mi = ts.dbMatch() rpms = {} for header in mi: # mi is not scriptable # so we iterate over it to create an object # that accepts indexes key = header[rpm.RPMTAG_NAME] rpms[key] = header log.debug('leaving') return rpms
def check_migration_version(): """ Verify that the command 'subscription-manager-migration' isn't too old. """ required_version = rpmUtils.miscutils.stringToVersion('1.14.2') err = "subscription-manager-migration not found" ts = rpm.TransactionSet() mi = ts.dbMatch('name', 'subscription-manager-migration') for h in mi: if rpmUtils.miscutils.compareEVR( rpmUtils.miscutils.stringToVersion(h['evr']), required_version) < 0: err = "%s-%s is too old" % (h['name'], h['evr']) else: err = None if err: print_error(err) sys.exit(1)
def __init__(self, queue, bodhi_workers_queue, bodhi_workers_count, main_thread, parent=None): super(PackagesWorker, self).__init__(parent) self.main_thread = main_thread self.queue = queue self.bodhi_workers_queue = bodhi_workers_queue self.bodhi_workers_count = bodhi_workers_count self.yb = yum.YumBase() cachedir = getCacheDir() self.yb.repos.setCacheDir(cachedir) # RPM Transactions self.rpmTS = rpm.TransactionSet()
def _read_existing_srpms(self): srpms = os.listdir(self._srpm_dir) ts = rpm.TransactionSet() for srpm in srpms: if not srpm.endswith('.rpm'): continue path = os.path.join(self._srpm_dir, srpm) try: fd = os.open(path, os.O_RDONLY) hdr = ts.hdrFromFdno(fd) nevr = (hdr['name'], hdr['epoch'], hdr['version'], hdr['release']) self._cache[nevr] = path except rpm.error as e: log.warn( "Unreadable rpm in srpm_dir: {}\nRPM error: {}".format( path, e.message)) finally: if fd: os.close(fd)
def analyze(rpmfile): """Analyse single RPM file""" if not os.path.exists(rpmfile): print("%s doesn't exists!" % rpmfile) return if rpmfile.endswith(".src.rpm") or not rpmfile.endswith(".rpm"): print("skipping %s" % os.path.basename(rpmfile)) return try: ts = rpm.TransactionSet() ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) fd = os.open(rpmfile, os.O_RDONLY) h = ts.hdrFromFdno(fd) os.close(fd) except Exception, exc: print(rpmfile, str(exc)) return
def _retrieve_expected_pkg_versions(expected_pkgs_dict): """Search for installed packages matching given pkg names and versions. Returns a dictionary: {pkg_name: [versions]}""" transaction = rpm.TransactionSet() pkgs = {} for pkg_name in expected_pkgs_dict: matched_pkgs = transaction.dbMatch("name", pkg_name) if not matched_pkgs: continue for header in matched_pkgs: if header['name'] == pkg_name: if pkg_name not in pkgs: pkgs[pkg_name] = [] pkgs[pkg_name].append(header['version']) return pkgs
def sync(dryrun=False, download=False): svn = SVN() topdir = _getpkgtopdir() # run svn info because svn st does not complain when topdir is not an # working copy svn.info(topdir or ".") specsdir = os.path.join(topdir, "SPECS/") sourcesdir = os.path.join(topdir, "SOURCES/") for path in (specsdir, sourcesdir): if not os.path.isdir(path): raise Error, "%s directory not found" % path specs = glob.glob(os.path.join(specsdir, "*.spec")) if not specs: raise Error, "no .spec files found in %s" % specsdir specpath = specs[0] # FIXME better way? try: rpm.addMacro("_topdir", os.path.abspath(topdir)) spec = rpm.TransactionSet().parseSpec(specpath) except rpm.error, e: raise Error, "could not load spec file: %s" % e
def _getReleaseVer(self, distroverpkg): '''Calculate the release version for the system. @param installroot: The value of the installroot option. @param distroverpkg: The value of the distroverpkg option. @return: The release version as a string (eg. '4' for FC4) ''' ts = rpm.TransactionSet('/') ts.setVSFlags(~(rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS)) idx = ts.dbMatch('provides', distroverpkg) # we're going to take the first one - if there is more than one of these # then the user needs a beating if idx.count() == 0: releasever = '$releasever' else: hdr = idx.next() releasever = hdr['version'] del hdr del idx del ts return releasever