def test_cost_assignment(self): r = hawkey.Repo("fog", cost=500) self.assertEqual(500, r.cost) r.cost = 300 self.assertEqual(300, r.cost) r2 = hawkey.Repo("blizzard") self.assertEqual(1000, r2.cost)
def test_cost_assignment(self): r = hawkey.Repo("fog") r.cost = 300 self.assertEqual(300, r.cost) r2 = hawkey.Repo("blizzard") self.assertEqual(1000, r2.cost) with self.assertRaises(TypeError): r2.cost = '4'
def get_repo(repo_dir, repo_descriptor, download=False): """ Obtain hawkey Repo either by loading from disk, or downloading from Koji. :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 """ h = librepo.Handle() repo_path = os.path.join(repo_dir, str(repo_descriptor)) if download: h.destdir = repo_path shutil.rmtree(repo_path, ignore_errors=True) os.makedirs(os.path.join(repo_path, 'cache')) h.repotype = librepo.LR_YUMREPO h.urls = [repo_descriptor.url if download else repo_path] h.local = not download h.yumdlist = ['primary', 'filelists', 'group', 'group_gz'] result = librepo.Result() try: result = h.perform(result) except librepo.LibrepoException as e: if e.args[0] == librepo.LRE_NOURL: return None raise repodata = result.yum_repo repo = hawkey.Repo(str(repo_descriptor)) repo.repomd_fn = repodata['repomd'] repo.primary_fn = repodata['primary'] repo.filelists_fn = repodata['filelists'] return repo
def add_repo_to_sack(repoid, repo_result, sack): repodata = repo_result.yum_repo repo = hawkey.Repo(repoid) repo.repomd_fn = repodata['repomd'] repo.primary_fn = repodata['primary'] repo.filelists_fn = repodata['filelists'] sack.load_yum_repo(repo, load_filelists=True)
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 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 get_repo_mock(repo_dir, descriptor, download=False): if 'copr' in str(type(descriptor)).lower(): repo = hawkey.Repo(str(descriptor)) path = os.path.join(testdir, 'repos', 'copr_repo', 'repodata') repo.repomd_fn = os.path.join(path, 'repomd.xml') repo.primary_fn = os.path.join(path, 'primary.xml') repo.filelists_fn = os.path.join(path, 'filelists.xml') return repo return get_repo(repo_dir, descriptor, download)
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 _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 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 __init__(self, *args): support.TestCase.__init__(self, *args) self.base = support.MockBase() self.sack = self.base.sack # load the testing repo repo = support.MockRepo('drpm', '/tmp/dnf-cache') self.base.repos[repo.id] = repo repo.baseurl = ['file://%s/%s' % (support.repo_dir(), repo.id)] repo.load() # add it to sack hrepo = hawkey.Repo(repo.id) hrepo.repomd_fn = repo.repomd_fn hrepo.primary_fn = repo.primary_fn hrepo.filelists_fn = repo.filelists_fn hrepo.presto_fn = repo.presto_fn self.sack.load_yum_repo(hrepo, load_filelists=True, load_presto=True)
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
def fetch_repo(repo, base_path=None, cache_ttl=3600): """ Fetch remote metadata for a list of Repos into {base_path}/{repo.url hash}/ and return a hawkey.Repo configured with local repodata. :param repo: RPM repository to fetch (Repo named tuple) :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: hawkey.Repo pointing to local repodata ready to be loaded """ if not base_path: base_path = helpers.get_default_cache_base_path() repodata_url = "%s/repodata" % repo.url repo_path = os.path.join(base_path, helpers.repo_dir(repo.id, repo.url)) log.info("Fetching %s into %s", repodata_url, repo_path) helpers.ensure_dir(repo_path) # fetch remote repodata files repomd = helpers.cached_remote_fetch(repo_path, repodata_url, 'repomd.xml', cache_ttl=cache_ttl, return_data=True) primary_fn, filelists_fn = parse_repomd(repomd) helpers.cached_remote_fetch(repo_path, repodata_url, primary_fn, cache_ttl=cache_ttl) helpers.cached_remote_fetch(repo_path, repodata_url, filelists_fn, cache_ttl=cache_ttl) # consturct hawkey.Repo pointing to local metadata hrepo = hawkey.Repo(repo.id) hrepo.repomd_fn = os.path.join(repo_path, 'repomd.xml') hrepo.primary_fn = os.path.join(repo_path, primary_fn) hrepo.filelists_fn = os.path.join(repo_path, filelists_fn) return hrepo
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) expanded = 0
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 as_hawkey_repo(self): repo = hawkey.Repo(self.name) repo.repomd_fn = self.repomd_fn repo.primary_fn = self.primary_fn repo.filelists_fn = self.filelists_fn return repo
def test_str_assignment(self): r = hawkey.Repo('fog') with self.assertRaises(TypeError): r.repomd_fn = 3 r.repomd_fn = 'rain' self.assertEqual(r.repomd_fn, 'rain')
def test_create(self): r = hawkey.Repo("fog") self.assertIsNotNone(r) self.assertRaises(TypeError, hawkey.Repo) self.assertRaises(TypeError, hawkey.Repo, 3) self.assertRaises(TypeError, hawkey.Repo, rain="pouring")
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 if total_to_download != downloaded: finished = False
def _init_hawkey_repo(self): hrepo = hawkey.Repo(self.id) hrepo.cost = self.cost hrepo.priority = self.priority return hrepo
def get_hawkey_repo(reponame, repoinfo): repo = hawkey.Repo(reponame) repo.repomd_fn = repoinfo['repomd'] repo.primary_fn = repoinfo['primary'] repo.filelists_fn = repoinfo['filelists'] return repo