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)
