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
