def readkeys(self, keys=[]): rpm.addMacro('_dbpath', self.dbdir) for key in keys: try: self.readkey(key) except KeyError, e: print e
def getTransactionSet(): '''Factory function for the module-level transaction set''' global __transactionSet if __transactionSet: return __transactionSet if not os.path.exists(DB_PATH): os.makedirs(DB_PATH) rpm.addMacro("_dependency_whiteout", WHITEOUT) #rpm.addMacro("_dbpath", DB_PATH) __transactionSet = rpm.TransactionSet(consts.HOST_ROOT) #Apply some rpm magic to tell the transaction set to not #check the signatures of the RPM files. # #NOTE: in future versions of the rpm python bindings, these flags will be #rpm.RPMVSF_NOSIGNATURES, rpm.RPMVSF_NODIGESTS __transactionSet.setVSFlags(~(rpm.RPMVSF_NORSA | rpm.RPMVSF_NODSA)) # XXX This needs to be fixed eventually. # we're using a 32bit rpm lib to install 64bit rpms. The following # flag silences the resulting error. __transactionSet.setProbFilter(rpm.RPMPROB_FILTER_IGNOREARCH) return __transactionSet
def bin_step(self): #what is rpm name? #send it the easyblock object rpmfilename = get_pkg_name(self) #get that rpm rpmfilenameurl = "http://cc.ottbioinfo.ca/eb/generic/%(rpmfilename)s" % { "rpmfilename": rpmfilename } #install that rpm rpmpath = self.obtain_file(rpmfilenameurl) if rpmpath: self.log.info("Installing rpm %s" % rpmpath) rpm.addMacro('_dbpath', '/easybuild/rpm') ts = rpm.TransactionSet() ts.addInstall(rpmpath, rpmpath, 'u') ts.check() self.log.info("starting run") rpmtrans = RPMTrans() res = ts.run(rpmtrans.callback, '') if res is None: self.log.info("rpm install success") self.skip = True self.cfg['skipsteps'].append('package') else: pprint(res) else: self.log.info("no rpm found, skipping")
def rpm_get_all_pkgfiles(unpackdir): rpmfiles = {} try: rpm.addMacro("_dbpath", unpackdir + "/rootfs/var/lib/rpm") ts = rpm.TransactionSet() mi = ts.dbMatch() rpmfiles = {} for h in mi: fs = h['FILENAMES'] for f in fs: rpmfiles[f] = h['name'] except: try: sout = subprocess.check_output( ['chroot', unpackdir + '/rootfs', 'rpm', '-qal']) for l in sout.splitlines(): l = l.strip() l = l.decode('utf8') rpmfiles[l] = True except Exception as err: raise ValueError("could not get file list from RPM database: " + str(err)) return (rpmfiles)
def rpm_get_all_packages(unpackdir): rpms = {} try: rpm.addMacro("_dbpath", unpackdir + "/rootfs/var/lib/rpm") ts = rpm.TransactionSet() mi = ts.dbMatch() if mi.count() == 0: raise Exception for h in mi: rpms[h['name']] = { 'version': h['version'], 'release': h['release'], 'arch': h['arch'] } except: try: sout = subprocess.check_output([ 'chroot', unpackdir + '/rootfs', 'rpm', '--queryformat', '%{NAME} %{VERSION} %{RELEASE} %{ARCH}\n', '-qa' ]) for l in sout.splitlines(): l = l.strip() l = l.decode('utf8') (name, vers, rel, arch) = re.match('(\S*)\s*(\S*)\s*(\S*)\s*(.*)', l).group(1, 2, 3, 4) rpms[name] = {'version': vers, 'release': rel, 'arch': arch} except: raise ValueError("could not get package list from RPM database: " + str(err)) return (rpms)
def getTransactionSet(): '''Factory function for the module-level transaction set''' global __transactionSet if __transactionSet: return __transactionSet if not os.path.exists(DB_PATH): os.makedirs(DB_PATH) rpm.addMacro("_dependency_whiteout", WHITEOUT) #rpm.addMacro("_dbpath", DB_PATH) __transactionSet = rpm.TransactionSet(consts.HOST_ROOT) #Apply some rpm magic to tell the transaction set to not #check the signatures of the RPM files. # #NOTE: in future versions of the rpm python bindings, these flags will be #rpm.RPMVSF_NOSIGNATURES, rpm.RPMVSF_NODIGESTS __transactionSet.setVSFlags(~(rpm.RPMVSF_NORSA|rpm.RPMVSF_NODSA)) # XXX This needs to be fixed eventually. # we're using a 32bit rpm lib to install 64bit rpms. The following # flag silences the resulting error. __transactionSet.setProbFilter(rpm.RPMPROB_FILTER_IGNOREARCH) return __transactionSet
def run(self): # Push user-supplied macro definitions for spec parsing for macro in self.opts.define: rpm.addMacro(macro[0], macro[1]) pkg_errors = False for pkgspec in self.opts.packages: try: if self.opts.srpm: self._src_deps(pkgspec) elif self.opts.spec: self._spec_deps(pkgspec) elif pkgspec.endswith('.src.rpm') or pkgspec.endswith('nosrc.rpm'): self._src_deps(pkgspec) elif pkgspec.endswith('.spec'): self._spec_deps(pkgspec) else: self._remote_deps(pkgspec) except dnf.exceptions.Error as e: logger.error(e) pkg_errors = True # Pop user macros so they don't affect future rpm calls for macro in self.opts.define: rpm.delMacro(macro[0]) if pkg_errors: raise dnf.exceptions.Error(_("Some packages could not be found."))
def getTS(new=False): if sysconf.get("rpm-extra-macros"): for key, value in sysconf.get("rpm-extra-macros").items(): rpm.addMacro(key, str(value)) rpm_root = os.path.abspath(sysconf.get("rpm-root", "/")) if not hasattr(getTS, "ts") or getTS.root != rpm_root: getTS.root = rpm_root if sysconf.get("rpm-dbpath"): rpm.addMacro('_dbpath', "/" + sysconf.get("rpm-dbpath")) getTS.ts = rpm.ts(getTS.root) if not sysconf.get("rpm-check-signatures", False): if hasattr(rpm, '_RPMVSF_NOSIGNATURES'): getTS.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) else: raise Error, _("rpm requires checking signatures") rpm_dbpath = sysconf.get("rpm-dbpath", "var/lib/rpm") dbdir = rpm_join_dbpath(getTS.root, rpm_dbpath) if not os.path.isdir(dbdir): try: os.makedirs(dbdir) except (OSError), e: raise Error, _("Could not create rpm-root at %s: %s") \ % (dbdir, unicode(e)) if not os.path.isfile(os.path.join(dbdir, "Packages")): try: getTS.ts.initDB() except (rpm.error, OSError): raise Error, _("Couldn't initizalize rpm database at %s") \ % getTS.root else: iface.warning(_("Initialized new rpm database at %s") % getTS.root)
def testNetSharedPath(self): # CNY-3503 p = self.addRPMComponent('netshared:rpm=1.0-1', 'netshared-1.0-1.noarch.rpm') util.mkdirChain(self.cfg.root + '/etc/rpm/') #self.updatePkg('netshared:rpm=1.0-1') #self.verifyFile(self.rootDir + '/local/shouldexist') ##self.verifyFile(self.rootDir + '/excluded/shouldnotexist') self.resetRoot() util.mkdirChain(self.cfg.root + '/etc/rpm/') util.mkdirChain(self.cfg.root + '/excluded') self.writeFile(self.cfg.root + '/excluded/shouldnotexist', 'unmanaged') # inside the method to let @conary_test.rpm keep the import conditional import rpm rpm.addMacro('_netsharedpath', '/excluded:/usr/local') try: self.updatePkg('netshared:rpm=1.0-1') finally: rpm.delMacro('_netsharedpath') self.verifyFile(self.rootDir + '/local/shouldexist') self.verifyFile(self.rootDir + '/excluded/shouldnotexist', 'unmanaged') self.erasePkg(self.rootDir, 'netshared:rpm')
def getTS(new=False): if sysconf.get("rpm-extra-macros"): for key, value in sysconf.get("rpm-extra-macros").items(): rpm.addMacro(key, str(value)) rpm_root = os.path.abspath(sysconf.get("rpm-root", "/")) if not hasattr(getTS, "ts") or getTS.root != rpm_root: getTS.root = rpm_root if sysconf.get("rpm-dbpath"): rpm.addMacro('_dbpath', "/" + sysconf.get("rpm-dbpath")) getTS.ts = rpm.ts(getTS.root) #if not sysconf.get("rpm-check-signatures", False): # getTS.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES) rpm_dbpath = sysconf.get("rpm-dbpath", "var/lib/rpm") dbdir = rpm_join_dbpath(getTS.root, rpm_dbpath) if not os.path.isdir(dbdir): try: os.makedirs(dbdir) except (OSError), e: raise Error, _("Could not create rpm-root at %s: %s") \ % (dbdir, unicode(e)) if not os.path.isfile(os.path.join(dbdir, "Packages")): try: getTS.ts.initDB() except (rpm.error, OSError): raise Error, _("Couldn't initizalize rpm database at %s") \ % getTS.root else: iface.warning( _("Initialized new rpm database at %s") % getTS.root)
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() bfp = self.buildFileProvides for i, filename in enumerate(self._filenames): if i not in self._offsets: continue filepath = os.path.join(self._dir, filename) file = open(filepath) try: h = ts.hdrFromFdno(file.fileno()) except rpm.error, e: file.close() iface.error("%s: %s" % (os.path.basename(filepath), e)) else: file.close() # FIXME (20050321): Solaris rpm 4.1 hack f = h[1027] # RPMTAG_OLDFILENAMES if f == None: f = [] for fn in f: fn = fndict.get(fn) if fn: bfp(self._offsets[i], (RPMProvides, fn, None))
def _check_invalid_url(self, pkg, rpm): """Check if specfile has an invalid url.""" # grab sources and patches from parsed spec object to get # them with macros expanded for URL checking spec_obj = None rpm.addMacro('_sourcedir', pkg.dirName()) try: transaction_set = rpm.TransactionSet() spec_obj = transaction_set.parseSpec(str(self._spec_file)) except (ValueError, rpm.error): # errors logged above already pass rpm.delMacro('_sourcedir') if spec_obj: for src in spec_obj.sources: (url, num, flags) = src (scheme, netloc) = urlparse(url)[0:2] if flags & 1: # rpmspec.h, rpm.org ticket #123 srctype = 'Source' else: srctype = 'Patch' tag = '%s%s' % (srctype, num) if scheme and netloc: continue elif srctype == 'Source' and tarball_regex.search(url): self.output.add_info('W', pkg, 'invalid-url', '%s:' % tag, url)
def install(self): progressQ.send_message(_('Starting package installation process')) # Add the rpm macros to the global transaction environment for macro in self.rpmMacros: rpm.addMacro(macro[0], macro[1]) if self.install_device: self._setupMedia(self.install_device) try: self.checkSoftwareSelection() self._download_location = self._pick_download_location() except packaging.PayloadError as e: if errors.errorHandler.cb(e) == errors.ERROR_RAISE: _failure_limbo() pkgs_to_download = self._base.transaction.install_set log.info('Downloading packages.') progressQ.send_message(_('Downloading packages')) progress = DownloadProgress() try: self._base.download_packages(pkgs_to_download, progress) except dnf.exceptions.DownloadError as e: msg = 'Failed to download the following packages: %s' % str(e) exc = packaging.PayloadInstallError(msg) if errors.errorHandler.cb(exc) == errors.ERROR_RAISE: _failure_limbo() log.info('Downloading packages finished.') pre_msg = _("Preparing transaction from installation source") progressQ.send_message(pre_msg) queue_instance = multiprocessing.Queue() process = multiprocessing.Process(target=do_transaction, args=(self._base, queue_instance)) process.start() (token, msg) = queue_instance.get() while token not in ('post', 'quit'): if token == 'install': msg = _("Installing %s") % msg progressQ.send_message(msg) (token, msg) = queue_instance.get() if token == 'quit': _failure_limbo() post_msg = _("Performing post-installation setup tasks") progressQ.send_message(post_msg) process.join() self._base.close() if os.path.exists(self._download_location): log.info("Cleaning up downloaded packages: %s", self._download_location) shutil.rmtree(self._download_location) else: # Some installation sources, such as NFS, don't need to download packages to # local storage, so the download location might not always exist. So for now # warn about this, at least until the RFE in bug 1193121 is implemented and # we don't have to care about clearing the download location ourselves. log.warning("Can't delete nonexistent download location: %s", self._download_location)
def __init__(self, path, check_package_name=True, defines=None): self.macros = dict(defines) if defines else {} # _topdir defaults to $HOME/rpmbuild # If present, it needs to be applied once at the beginning if '_topdir' in self.macros: rpm.addMacro('_topdir', self.macros['_topdir']) # '%dist' in the host (where we build the source package) # might not match '%dist' in the chroot (where we build # the binary package). We must override it on the host, # otherwise the names of packages in the dependencies won't # match the files actually produced by mock. if 'dist' not in self.macros: self.macros['dist'] = "" with rpm_macros(self.macros): self.path = path with open(path) as spec: self.spectext = spec.readlines() self.spec = parse_spec_quietly(path) if check_package_name: file_basename = os.path.basename(path).split(".")[0] if file_basename != self.name(): raise SpecNameMismatch( "spec file name '%s' does not match package name '%s'" % (path, self.name()))
def run(self): rpmlog = dnf.yum.rpmtrans.RPMTransaction(self.base) # Push user-supplied macro definitions for spec parsing for macro in self.opts.define: rpm.addMacro(macro[0], macro[1]) pkg_errors = False for pkgspec in self.opts.packages: pkgspec = self._download_remote_file(pkgspec) try: if self.opts.srpm: self._src_deps(pkgspec) elif self.opts.spec: self._spec_deps(pkgspec) elif pkgspec.endswith('.src.rpm') or pkgspec.endswith('nosrc.rpm'): self._src_deps(pkgspec) elif pkgspec.endswith('.spec'): self._spec_deps(pkgspec) else: self._remote_deps(pkgspec) except dnf.exceptions.Error as e: for line in rpmlog.messages(): logger.error(_("RPM: {}").format(line)) logger.error(e) pkg_errors = True # Pop user macros so they don't affect future rpm calls for macro in self.opts.define: rpm.delMacro(macro[0]) if pkg_errors: raise dnf.exceptions.Error(_("Some packages could not be found."))
def compare_rpm_files(path1, path2, source=None): try: import rpm except ImportError: logger.info("Python module rpm not found.") return [] differences = [] # compare headers with make_temp_directory() as rpmdb_dir: rpm.addMacro("_dbpath", rpmdb_dir) ts = rpm.TransactionSet() ts.setVSFlags(-1) header1 = get_rpm_header(path1, ts) header2 = get_rpm_header(path2, ts) difference = Difference.from_unicode( header1, header2, path1, path2, source="header") if difference: differences.append(difference) # extract cpio archive with extract_rpm_payload(path1) as archive1: with extract_rpm_payload(path2) as archive2: differences.extend(debbindiff.comparators.compare_files( archive1, archive2, source=get_source(archive1, archive2))) return differences
def generateinternaldatabase(self): rpmdb = collections.defaultdict(list) rpmdb_path = self._rpmdb_file_name try: rpm.addMacro("_dbpath", rpmdb_path) ts = rpm.TransactionSet() mi = ts.dbMatch() except Exception as e: print("Error opening rpmdb -> {0}".format(e)) return for header in mi: _package = "{0}-{1}-{2}".format(header['name'], header['version'], header['release']) _installdate = header.sprintf("%{INSTALLTID:date}") for _fileinfo in header.fiFromHeader(): _path = _fileinfo[0] _sha256 = _fileinfo[12] _rpmentry = rpmEntry(_package, _installdate, _path, _sha256) if _sha256 == "0000000000000000000000000000000000000000000000000000000000000000": continue try: rpmdb[_path].append(_rpmentry) except: pass return rpmdb
def srpmNameFromSpec( spec ): h = spec.sourceHeader if buildType() == "rpm": rpm.addMacro( 'NAME', h['name'] ) else: rpm.addMacro( 'NAME', mappkgname.map_package(h['name'])[0] ) rpm.addMacro( 'VERSION', h['version'] ) rpm.addMacro( 'RELEASE', h['release'] ) rpm.addMacro( 'ARCH', 'src' ) # There doesn't seem to be a macro for the name of the source # rpm, but the name appears to be the same as the rpm name format. # Unfortunately expanding that macro gives us a leading 'src' that we # don't want, so we strip that off if buildType() == "rpm": srpmname = os.path.basename( rpm.expandMacro( rpmfilenamepat ) ) else: srpmname = os.path.basename( rpm.expandMacro( "%{NAME}_%{VERSION}-%{RELEASE}.dsc" ) ) rpm.delMacro( 'NAME' ) rpm.delMacro( 'VERSION' ) rpm.delMacro( 'RELEASE' ) rpm.delMacro( 'ARCH' ) # HACK: rewrite %dist if it appears in the filename return srpmname.replace( chroot_dist, host_dist )
def __init__(self, path, target="rpm", map_name=None, dist=""): if target == "rpm": self.rpmfilenamepat = rpm.expandMacro("%_build_name_fmt") self.srpmfilenamepat = rpm.expandMacro("%_build_name_fmt") self.map_arch = identity # '%dist' in the host (where we build the source package) # might not match '%dist' in the chroot (where we build # the binary package). We must override it on the host, # otherwise the names of packages in the dependencies won't # match the files actually produced by mock. self.dist = dist else: self.rpmfilenamepat = "%{NAME}_%{VERSION}-%{RELEASE}_%{ARCH}.deb" self.srpmfilenamepat = "%{NAME}_%{VERSION}-%{RELEASE}.dsc" self.map_arch = map_arch_deb self.dist = "" rpm.addMacro("dist", self.dist) if map_name: self.map_package_name = map_name else: self.map_package_name = identity_list self.path = os.path.join(SPECDIR, os.path.basename(path)) with open(path) as spec: self.spectext = spec.readlines() self.spec = rpm.ts().parseSpec(path)
def compare_rpm_files(path1, path2, source=None): try: import rpm except ImportError: logger.info("Python module rpm not found.") return [] differences = [] # compare headers with make_temp_directory() as rpmdb_dir: rpm.addMacro("_dbpath", rpmdb_dir) ts = rpm.TransactionSet() ts.setVSFlags(-1) header1 = get_rpm_header(path1, ts) header2 = get_rpm_header(path2, ts) difference = Difference.from_unicode(header1, header2, path1, path2, source="header") if difference: differences.append(difference) # extract cpio archive with extract_rpm_payload(path1) as archive1: with extract_rpm_payload(path2) as archive2: differences.extend( debbindiff.comparators.compare_files(archive1, archive2, source=get_source( archive1, archive2))) return differences
def _load_installed_packages(self): """Visit rpmdb and load data from installed packages.""" log.info("reading installed packages.") if self._rpm_dbpath is not None: rpm.addMacro("_dbpath", self._rpm_dbpath) for pkg in rpm.ts().dbMatch(): # TODO Load capabilities information in the same manner # Media.list_medias() will return. pkgdict = {} for attr in ( "name", "version", "release", "arch", "epoch", "size", "group", "summary", "installtime", "disttag", "distepoch", ): value = pkg[attr] if type(value) is list and len(value) == 0: value = "" pkgdict[attr] = value if type(pkg["installtime"]) is list: pkgdict["installtime"] = pkg["installtime"][0] if pkgdict["epoch"] is None: pkgdict["epoch"] = 0 self._on_package_data(pkgdict) rpm.delMacro("_dbpath")
def rpm_macros(**keys): for key, value in keys.iteritems(): log.debug('setting...') log.debug(key + ' ' + value) rpm.addMacro(key, value) yield for key, value in keys.iteritems(): rpm.delMacro(key)
def __init__(self): self.dbdir = mkdtemp(prefix='oscrpmdb') self.imported = {} rpm.addMacro('_dbpath', self.dbdir) self.ts = rpm.TransactionSet() self.ts.initDB() self.ts.openDB() self.ts.setVSFlags(0)
def _sync_macros(s): """Makes all macros present in a string up-to-date in rpm context""" _, macros = _expand_macros(s) for macro in macros: MacroHelper.purge_macro(macro) value = _get_macro_value(macro) if value and MacroHelper.expand(value): rpm.addMacro(macro, value)
def rpmspec(self): if not self._rpmspec: rpm.addMacro('_sourcedir', os.path.dirname(os.path.realpath(self.fn))) try: self._rpmspec = rpm.spec(self.fn) except ValueError, e: raise Exception("Error parsing spec: {0}".format(e))
def test_get_macros(self): rpm.addMacro('test_macro', 'test_macro value') macros = MacroHelper.dump() macros = MacroHelper.filter(macros, name='test_macro', level=-1) assert len(macros) == 1 assert macros[0]['name'] == 'test_macro' assert macros[0]['value'] == 'test_macro value' assert macros[0]['level'] == -1
def test_get_macros(self): rpm.addMacro("test_macro", "test_macro value") macros = MacroHelper.dump() macros = MacroHelper.filter(macros, name="test_macro") assert len(macros) == 1 assert macros[0]["name"] == "test_macro" assert macros[0]["value"] == "test_macro value" assert macros[0]["level"] == -1
def update_macros(): ''' Update build macros from mock target configuration. ''' macros = ['%dist', '%rhel', '%fedora', '%_build_arch', '%_arch'] for macro in macros: expanded = Mock.get_macro(macro, self, flags) if not expanded.startswith('%'): rpm.delMacro(macro[1:]) rpm.addMacro(macro[1:], expanded)
def __init__(self, specFileName): self.specFileName = specFileName rpm.addMacro('_ipv6', '1') ts = rpm.ts() self.spec = ts.parseSpec(specFileName) self.header = self.spec.header() self.sources = self.spec.sources() ts.clean()
def test_get_macros(self): rpm.addMacro('test_macro', 'test_macro value') macros = MacroHelper.dump() macros = MacroHelper.filter(macros, name='test_macro') assert len(macros) == 1 assert macros[0]['name'] == 'test_macro' assert macros[0]['value'] == 'test_macro value' assert macros[0]['level'] == -1
def getHeader(self, pkg): # 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", "/")) mi = ts.dbMatch(0, pkg.loaders[self]) return mi.next()
def compare_rpm_headers(path1, path2): # compare headers with get_temporary_directory() as rpmdb_dir: rpm.addMacro("_dbpath", rpmdb_dir) ts = rpm.TransactionSet() ts.setVSFlags(-1) header1 = get_rpm_header(path1, ts) header2 = get_rpm_header(path2, ts) return Difference.from_text(header1, header2, path1, path2, source="header")
def rpmspec(self): if not self._rpmspec: if not RPM_AVAILABLE: raise exception.RpmModuleNotAvailable() rpm.addMacro("_sourcedir", os.path.dirname(os.path.realpath(self.fn))) try: self._rpmspec = rpm.spec(self.fn) except ValueError, e: raise exception.SpecFileParseError(spec_fn=self.fn, error=e.args[0])
def load_rpmspec(self): if not RPM_AVAILABLE: raise exception.RpmModuleNotAvailable() rpm.addMacro('_sourcedir', os.path.dirname(os.path.realpath(self.fn))) try: self._rpmspec = rpm.spec(self.fn) except ValueError as e: raise exception.SpecFileParseError(spec_fn=self.fn, error=e.args[0])
def get_package_ver(self, path, package): rpm.addMacro("_dbpath", path + '/var/lib/rpm') ts = rpm.TransactionSet() package_vers = list() mi = ts.dbMatch( 'name', package ) for h in mi: ver = "%s-%s.%s" % (h['VERSION'], h['RELEASE'], h['ARCH']) package_vers.extend([ver]) return package_vers
def rpm_macros(macros): """Context manager to add and remove all macros in the dictionary""" if macros is None: macros = OrderedDict() for key, value in macros.items(): rpm.addMacro(key, value) yield for key, _ in reversed(macros.items()): rpm.delMacro(key)
def __init__(self, path, sources_location='', download=True): self.path = path self.download = download self.sources_location = sources_location # Read the content of the whole SPEC file rpm.addMacro("_sourcedir", self.sources_location) self._read_spec_content() # Load rpm information self.set_extra_version_separator('') self._update_data()
def __init__(self, path, sources_location='', download=True): self.path = path self.download = download self.sources_location = sources_location # Read the content of the whole SPEC file rpm.addMacro("_sourcedir", self.sources_location) self._read_spec_content() # Load rpm information self.spc = rpm.spec(self.path) self.patches = self._get_initial_patches_list() self._update_data()
def readkeys(self, keys=[]): rpm.addMacro('_dbpath', self.dbdir) for key in keys: try: self.readkey(key) except KeyError as e: print(e) if not len(self.imported): raise KeyError('', "no key imported") rpm.delMacro("_dbpath")
def _realSetup(self, testname): rpm.addMacro("_dbpath",testutils.DBPATH) repackagedir = "/tmp/testrepackage" rpm.addMacro("_repackage_dir", repackagedir) if TestGenTransactionSat1.setupflag != 0: return testutils.createDataDirs() testutils.rebuildRpmDatabase(testname) testutils.rebuildRepackageDir(testname) TestGenTransactionSat1.setupflag = 1
def __init__(self, path, check_package_name=True, defines=None): self.macros = OrderedDict(defines) if defines else OrderedDict() # _topdir defaults to $HOME/rpmbuild # If present, it needs to be applied once at the beginning if '_topdir' in self.macros: rpm.addMacro('_topdir', self.macros['_topdir']) # '%dist' in the host (where we build the source package) # might not match '%dist' in the chroot (where we build # the binary package). We must override it on the host, # otherwise the names of packages in the dependencies won't # match the files actually produced by mock. if 'dist' not in self.macros: self.macros['dist'] = "" hardcoded_macros = OrderedDict([('_specdir', os.path.dirname(path))]) with rpm_macros(append_macros(self.macros, hardcoded_macros)): self.path = os.path.join(specdir(), os.path.basename(path)) with open(path) as spec: self.spectext = spec.readlines() with tempfile.TemporaryFile() as nullfh: try: # collect all output to stderr then filter out # errors about missing sources errcpy = os.dup(2) try: os.dup2(nullfh.fileno(), 2) self.spec = rpm.ts().parseSpec(path) finally: os.dup2(errcpy, 2) os.close(errcpy) except ValueError as exn: nullfh.seek(0, os.SEEK_SET) for line in nullfh: line = line.strip() if not line.endswith(': No such file or directory'): print >> sys.stderr, line exn.args = (exn.args[0].rstrip() + ' ' + path, ) raise if check_package_name: file_basename = os.path.basename(path).split(".")[0] if file_basename != self.name(): raise SpecNameMismatch( "spec file name '%s' does not match package name '%s'" % (path, self.name())) self.rpmfilenamepat = rpm.expandMacro('%_build_name_fmt') self.srpmfilenamepat = rpm.expandMacro('%_build_name_fmt')
def rpm_macros(*macros): """ Context manager to add and remove stacked RPM macro 'environments'. Macro definitions which occur later in 'macros' override definitions made earlier. """ for macro in macros: for key, value in macro.items(): rpm.addMacro(key, value) yield for macro in reversed(macros): for key in macro.keys(): rpm.delMacro(key)
def install(self): progressQ.send_message(_('Starting package installation process')) # Add the rpm macros to the global transaction environment for macro in self.rpmMacros: rpm.addMacro(macro[0], macro[1]) if self.install_device: self._setupMedia(self.install_device) try: self.checkSoftwareSelection() self._pick_download_location() except packaging.PayloadError as e: if errors.errorHandler.cb(e) == errors.ERROR_RAISE: _failure_limbo() pkgs_to_download = self._base.transaction.install_set log.info('Downloading pacakges.') progressQ.send_message(_('Downloading packages')) progress = DownloadProgress() try: self._base.download_packages(pkgs_to_download, progress) except dnf.exceptions.DownloadError as e: msg = 'Failed to download the following packages: %s' % str(e) exc = packaging.PayloadInstallError(msg) if errors.errorHandler.cb(exc) == errors.ERROR_RAISE: _failure_limbo() log.info('Downloading packages finished.') pre_msg = _("Preparing transaction from installation source") progressQ.send_message(pre_msg) queue = multiprocessing.Queue() process = multiprocessing.Process(target=do_transaction, args=(self._base, queue)) process.start() (token, msg) = queue.get() while token not in ('post', 'quit'): if token == 'install': msg = _("Installing %s") % msg progressQ.send_message(msg) (token, msg) = queue.get() if token == 'quit': _failure_limbo() post_msg = _("Performing post-installation setup tasks") progressQ.send_message(post_msg) process.join()
def files_from_pkg(basename, pkg, specpath): # should be able to build this from the files sections - can't find how # to get at them from the spec object res = "" files = rpmextra.files_from_spec(basename, specpath) for filename in files.get(pkg.header['name'], []): # Debian packages must not contain compiled Python files. # Instead, the python2 helper arranges to compile these # files when they are installed. if os.path.splitext(filename)[1] in [".pyc", ".pyo"]: continue rpm.addMacro("_libdir", "usr/lib") rpm.addMacro("_bindir", "usr/bin") # deb just wants relative paths src = rpm.expandMacro(filename).lstrip("/") rpm.delMacro("_bindir") rpm.delMacro("_libdir") rpm.addMacro("_libdir", "/usr/lib") rpm.addMacro("_bindir", "/usr/bin") dst = rpm.expandMacro(filename) # destination paths should be directories, not files. # if the file is foo and the path is /usr/bin/foo, the # package will end up install /usr/bin/foo/foo if not dst.endswith("/"): dst = os.path.dirname(dst) rpm.delMacro("_bindir") rpm.delMacro("_libdir") res += "%s %s\n" % (src, dst) return res
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