def test_failed_load(self): sack = hawkey.Sack(cachedir=base.cachedir) self._conf = libdnf.conf.ConfigMain() repo_conf = libdnf.conf.ConfigRepo(self._conf) repo_conf.this.disown() # _repo will be the owner of _config repo = libdnf.repo.Repo("name", repo_conf) self.assertRaises(IOError, sack.load_repo, repo) sack = hawkey.Sack()
def package_version(self): """ Returns the version of the installed package. :returns: the package version :rtype: LooseVersion :raises AvailabilityError: on failure to obtain package version """ sack = hawkey.Sack() try: sack.load_system_repo() except IOError as e: # hawkey has been observed allowing an IOError to propagate to # caller with message "Failed calculating RPMDB checksum." # See: https://bugzilla.redhat.com/show_bug.cgi?id=1223914 raise AvailabilityError( "Could not determine package version for %s: %s" % (self.package.package_name, e)) query = hawkey.Query(sack).filter(name=self.package.package_name, latest=True) packages = query.run() if len(packages) != 1: raise AvailabilityError( "Could not determine package version for %s: unable to obtain package information from repo" % self.package.package_name) return LooseVersion(packages[0].version)
def cmpNEVR(nevr1, nevr2): '''Compare two RPM version identifiers in NEVR format. :param str nevr1: RPM identifier in N(E)VR format :param str nevr2: RPM identifier in N(E)VR format :return: ``-1``/``0``/``1`` if ``nevr1 < nevr2`` / ``nevr1 == nevr2`` / ``nevr1 > nevr2`` :rtype: int :raise CheckbValueError: if name in ``nevr1`` doesn't match name in ``nevr2`` ''' rpmver1 = hawkey.split_nevra(nevr1 + '.noarch') rpmver2 = hawkey.split_nevra(nevr2 + '.noarch') if rpmver1.name != rpmver2.name: raise exc.CheckbValueError("Name in nevr1 doesn't match name in " "nevr2: %s, %s" % (nevr1, nevr2)) # sack is needed for the comparison, because it can be influence the # comparison (for example epoch can be set to be ignored). A default empty # sack should match Fedora customs sack = hawkey.Sack() # we need evr_cmp to return int so we can use it as comparison function # in python's sorted return int(rpmver1.evr_cmp(rpmver2, sack))
def create(self, repo_id, repo_dir): """ Load repo from disk into memory as sack """ if not repo_dir: return None try: sack = hawkey.Sack(arch=self._for_arch) for arch in self._arches: log.debug('Loading repo {} for arch {} from disk into memory'. format(repo_id, arch)) arch_repo_dir = os.path.join(repo_dir, arch) h = librepo.Handle() h.local = True h.repotype = librepo.LR_YUMREPO h.urls = [arch_repo_dir] h.yumdlist = ['primary', 'filelists', 'group'] repodata = h.perform(librepo.Result()).yum_repo repo = hawkey.Repo('{}-{}'.format(repo_id, arch)) repo.repomd_fn = repodata['repomd'] repo.primary_fn = repodata['primary'] repo.filelists_fn = repodata['filelists'] sack.load_yum_repo(repo, load_filelists=True) log.debug('Repo {} successfully loaded into memory'.format(repo_id)) return sack except (librepo.LibrepoException, IOError): log.debug('Repo {} could not be loaded'.format(repo_id)) return None
def load_sack(self, arch=None, load_filelists=True, build_cache=True): hawkey_repos = [] for name, path in self.repodict.items(): self.log.info('downloading repo metadata from %s' % path) repoinfo, metadir = self.get_repo_metadata(reponame=name, repopath=path) repo = self.get_hawkey_repo(reponame=name, repoinfo=repoinfo) hawkey_repos.append(repo) self.metadirs.append(metadir) if metadir else None self.sack = hawkey.Sack(arch=arch) if arch else hawkey.Sack() for repo in hawkey_repos: self.sack.load_yum_repo(repo, load_filelists=load_filelists, build_cache=build_cache) self._installs.set_sack(self.sack)
def download_rpms(self): repodata_dir = os.path.join(self.photon_root, 'RPMS/repodata') process = subprocess.Popen(['mkdir', '-p', repodata_dir], stdout=self.output) retval = process.wait() import hawkey self.install_factor = 1 # Load the repo data sack = hawkey.Sack() repomd_filename = "repomd.xml" repomd_url = os.path.join(self.rpm_path, "repodata/repomd.xml") self.download_file(repomd_url, repodata_dir) # parse to the xml to get the primary and files list tree = ET.parse(os.path.join(repodata_dir, repomd_filename)) # TODO: Get the namespace dynamically from the xml file ns = {'ns': 'http://linux.duke.edu/metadata/repo'} primary_location = tree.find("./ns:data[@type='primary']/ns:location", ns).get("href"); filelists_location = tree.find("./ns:data[@type='filelists']/ns:location", ns).get("href"); primary_filename = os.path.basename(primary_location); filelists_filename = os.path.basename(filelists_location); self.download_file(os.path.join(self.rpm_path, primary_location), repodata_dir) self.download_file(os.path.join(self.rpm_path, filelists_location), repodata_dir) repo = hawkey.Repo("installrepo") repo.repomd_fn = os.path.join(repodata_dir, repomd_filename) repo.primary_fn = os.path.join(repodata_dir, primary_filename) repo.filelists_fn = os.path.join(repodata_dir, filelists_filename) sack.load_yum_repo(repo, load_filelists=True) progressbar_num_items = 0 self.rpms_tobeinstalled = [] selected_packages = self.install_config['packages'] for package in selected_packages: # Locate the package q = hawkey.Query(sack).filter(name=package) if (len(q) > 0): progressbar_num_items += q[0].size + q[0].size * self.install_factor self.rpms_tobeinstalled.append({'package': package, 'size': q[0].size, 'location': q[0].location, 'filename': os.path.basename(q[0].location)}) else: print >> sys.stderr, "Package %s not found in the repo" % package #self.exit_gracefully(None, None) self.progress_bar.update_num_items(progressbar_num_items) # Download the rpms for rpm in self.rpms_tobeinstalled: message = 'Downloading {0}...'.format(rpm['filename']) self.progress_bar.update_message(message) self.download_file(os.path.join(self.rpm_path, rpm['location']), os.path.join(self.photon_root, "RPMS")) self.progress_bar.increment(rpm['size']) # update the rpms path self.rpm_path = os.path.join(self.photon_root, "RPMS")
def test_evr_cmp(self): sack = hawkey.Sack() n1 = hawkey.split_nevra("jay-3:3.10-4.fc3.x86_64") n2 = hawkey.split_nevra("jay-4.10-4.fc3.x86_64") self.assertGreater(n1.evr_cmp(n2, sack), 0) self.assertLess(n2.evr_cmp(n1, sack), 0) n1 = hawkey.split_nevra("jay-3.10-4.fc3.x86_64") n2 = hawkey.split_nevra("jay-3.10-5.fc3.x86_64") self.assertLess(n1.evr_cmp(n2, sack), 0)
def _get_hawkey_sack(repo_info): hk_repo = hawkey.Repo("") hk_repo.filelists_fn = repo_info["filelists"] hk_repo.primary_fn = repo_info["primary"] hk_repo.repomd_fn = repo_info["repomd"] primary_sack = hawkey.Sack() primary_sack.load_repo(hk_repo, build_cache=False) return primary_sack
def test_evr_cmp(self): sack = hawkey.Sack() n1 = hawkey.split_nevra("jay-3:3.10-4.fc3.x86_64") n2 = hawkey.split_nevra("jay-4.10-4.fc3.x86_64") self.assertGreater(n1.evr_cmp(n2, sack), 0) self.assertLess(n2.evr_cmp(n1, sack), 0) n1 = hawkey.split_nevra("jay-3.10-4.fc3.x86_64") n2 = hawkey.split_nevra("jay-3.10-5.fc3.x86_64") self.assertLess(n1.evr_cmp(n2, sack), 0) n1 = hawkey.split_nevra('pungi-4.0.14-3.fc24.src') n2 = hawkey.split_nevra('pungi-4.0.7-1.fc24.src') self.assertFalse(n1 < n2)
def _get_hawkey_sack(repo_info): """ A function to pull in the repository sack from hawkey. Returns the sack. """ hk_repo = hawkey.Repo("") hk_repo.filelists_fn = repo_info["filelists"] hk_repo.primary_fn = repo_info["primary"] hk_repo.repomd_fn = repo_info["repomd"] primary_sack = hawkey.Sack() primary_sack.load_repo(hk_repo, build_cache=False) return primary_sack
def __init__(self, repos, packages, sack=None, arch=None): """ :param repos: An iterable of rpmdeplint.repodata.Repo instances :param packages: An iterable of rpm package paths. """ if sack is None: if arch is not None: self._sack = hawkey.Sack(make_cache_dir=True, arch=arch) else: self._sack = hawkey.Sack(make_cache_dir=True) else: self._sack = sack self.packages = [] #: list of hawkeye.Package to be tested for rpmpath in packages: package = self._sack.add_cmdline_package(rpmpath) self.packages.append(package) self.repos_by_name = {} #: mapping of (reponame, rpmdeplint.Repo) for repo in repos: repo.download_repodata() self._sack.load_yum_repo(repo=repo.as_hawkey_repo(), load_filelists=True) self.repos_by_name[repo.name] = repo
def fetch_repos_sack(repos, base_path=None, cache_ttl=3600): """ Fetch all repos using fetch_repo and load them into a hawkey.Sack. :param repos: a list of RPM repos to fetch (Repo named tuples) :param base_path: a base path to store local repodata cache in :param cache_ttl: time to live for local repodata cache (0 to disable) :return: a hawkey.Sack instance loaded with supplied repos """ sack = hawkey.Sack(make_cache_dir=True) for repo in repos: hrepo = fetch_repo(repo, base_path=base_path, cache_ttl=cache_ttl) log.info("Loading repository metadata: %s", repo.id) sack.load_repo(hrepo, load_filelists=True) return sack
def get_sack(): # hawkey sacks cannot be easily populated from within python and mocking # hawkey queries would be too complicated, therefore using real repos h = librepo.Handle() h.local = True h.repotype = librepo.LR_YUMREPO h.urls = ['repo'] h.yumdlist = ['primary'] repodata = h.perform(librepo.Result()).yum_repo repo = hawkey.Repo('test') repo.repomd_fn = repodata['repomd'] repo.primary_fn = repodata['primary'] sack = hawkey.Sack(arch='x86_64') sack.load_yum_repo(repo) return sack
def load_sack(repo_dir, repo_descriptor, download=False): """ Obtain hawkey Sack either by loading from disk, or downloading from Koji. Builds cache when downloading. :repo_dir: path to directory where the repo is/should be stored :repo_descriptor: which repo to obtain :download: whether to download or load locally """ cache_dir = os.path.join(repo_dir, str(repo_descriptor), 'cache') for_arch = get_config('dependency.resolve_for_arch') sack = hawkey.Sack(arch=for_arch, cachedir=cache_dir) repo = get_repo(repo_dir, repo_descriptor, download) if repo: sack.load_repo(repo, load_filelists=True, build_cache=download) return sack
def _load_sack(self, repo_descriptor, repo_path, build_cache=False): """ Load repo from disk into memory as sack. """ cache_dir = os.path.join(repo_path, 'cache') for_arch = get_config('dependency.resolve_for_arch') if build_cache: os.mkdir(cache_dir) sack = hawkey.Sack(arch=for_arch, cachedir=cache_dir) h = librepo.Handle() h.local = True # pylint:disable=no-member h.repotype = librepo.LR_YUMREPO h.urls = [repo_path] h.yumdlist = ['primary', 'filelists', 'group'] repodata = h.perform(librepo.Result()).yum_repo repo = hawkey.Repo(str(repo_descriptor)) repo.repomd_fn = repodata['repomd'] repo.primary_fn = repodata['primary'] repo.filelists_fn = repodata['filelists'] sack.load_yum_repo(repo, load_filelists=True, build_cache=build_cache) return sack
got_link = True if not got_link: print('Unable to find link') sys.exit(1) h.setopt(librepo.LRO_REPOTYPE, librepo.LR_YUMREPO) h.setopt(librepo.LRO_CHECKSUM, True) h.setopt(librepo.LRO_PROGRESSCB, dl_callback) h.setopt(librepo.LRO_YUMDLIST, ["group", "primary"]) h.setopt(librepo.LRO_INTERRUPTIBLE, True) h.perform(r) repo_info = r.getinfo(librepo.LRR_YUM_REPO) # Get primary primary_sack = hawkey.Sack() hk_repo = hawkey.Repo(repo) hk_repo.repomd_fn = repo_info['repomd'] hk_repo.primary_fn = repo_info['primary'] primary_sack.load_repo(hk_repo, load_filelists=False) # Get comps comps = libcomps.Comps() if 'group' in repo_info: ret = comps.fromxml_f(repo_info['group']) if ret == -1: print('Error parsing') break repos[repo] = (comps, primary_sack)
def test_evr_cmp(self): sack = hawkey.Sack() self.assertEqual(sack.evr_cmp("3:3.10-4", "3:3.10-4"), 0) self.assertLess(sack.evr_cmp("3.10-4", "3.10-5"), 0) self.assertGreater(sack.evr_cmp("3.11-4", "3.10-5"), 0) self.assertGreater(sack.evr_cmp("1:3.10-4", "3.10-5"), 0)
def test_unicoded_cachedir(self): # does not raise UnicodeEncodeError hawkey.Sack(cachedir=u"unicod\xe9")
def test_failed_load(self): sack = hawkey.Sack(cachedir=base.cachedir) repo = hawkey.Repo("name") self.assertRaises(IOError, sack.load_repo, repo) sack = hawkey.Sack()
def test_creation_dir(self): sack = hawkey.Sack() self.assertFalse(os.access(sack.cache_dir, os.F_OK)) sack = hawkey.Sack(make_cache_dir=True) self.assertTrue(os.access(sack.cache_dir, os.F_OK)) self.assertRaises(IOError, hawkey.Sack, "", make_cache_dir=True)
def test_deepcopy(self): sack = hawkey.Sack() self.assertRaises(NotImplementedError, copy.deepcopy, sack)
def test_creation(self): hawkey.Sack(arch="noarch") hawkey.Sack(arch="x86_64") self.assertRaises(hawkey.ArchException, hawkey.Sack, arch="") self.assertRaises(hawkey.ValueException, hawkey.Sack, arch="play")
import shutil from pprint import pprint import librepo op_name = sys.argv[1] if sys.argv[1] != "list": pkg_name = sys.argv[2] # Librepo Configurations MAIN_REPO = "/home/thejdeep/test_repo/" DESTDIR = "/home/thejdeep/test_repo/repodata/" PROGRESSBAR_LEN = 40 finished = False # Hawkey Configurations sack = hawkey.Sack() path = "/home/thejdeep/test_repo/repodata/%s" repo = hawkey.Repo("test") repo.repomd_fn = path % "repomd.xml" repo.primary_fn = path % "b6f6911f7d9fb63f001388f1ecd0766cec060c1d04c703c6a74969eadc24ec97-primary.xml.gz" repo.filelists_fn = path % "df5897ed6d3f87f2be4432543edf2f58996e5c9e6a7acee054f9dbfe513df4da-filelists.xml.gz" sack.load_repo(repo, load_filelists=True) #sack.load_system_repo() # Functions start def callback(data, total_to_download, downloaded): """Progress callback""" global finished
def test_creation(self): hawkey.Sack(arch="noarch") hawkey.Sack(arch="x86_64")
def test_creation_empty_sack(self): s = hawkey.Sack(make_cache_dir=True) q = hawkey.Query(s)
def test_all_arch(self): sack = hawkey.Sack(arch="x86_64") # greater than noarch as it has picked up the default architecture self.assertGreater(len(sack.list_arches()), 1) sack2 = hawkey.Sack(all_arch=True) self.assertEqual(len(sack2.list_arches()), 0)