def run(self):
if not any([self.aur, self.repositories]):
return
ti = time.time()
self.task_man.register_task(self.task_id,
self.i18n['arch.task.disk_cache'],
get_icon_path())
self.logger.info('Pre-caching installed Arch packages data to disk')
installed = pacman.map_installed(repositories=self.repositories,
aur=self.aur)
self.task_man.update_progress(
self.task_id, 0, self.i18n['arch.task.disk_cache.reading'])
for k in ('signed', 'not_signed'):
installed[k] = {
p
for p in installed[k]
if not os.path.exists(ArchPackage.disk_cache_path(p))
}
saved = 0
pkgs = {*installed['signed'], *installed['not_signed']}
repo_map = {}
if installed['not_signed']:
repo_map.update({p: 'aur' for p in installed['not_signed']})
if installed['signed']:
repo_map.update(pacman.map_repositories(installed['signed']))
self.to_index = len(pkgs)
self.progress = self.to_index * 2
self.update_prepared(None, add=False)
saved += disk.save_several(pkgs,
repo_map,
when_prepared=self.update_prepared,
after_written=self.update_indexed)
self.task_man.update_progress(self.task_id, 100, None)
self.task_man.finish_task(self.task_id)
tf = time.time()
time_msg = 'Took {0:.2f} seconds'.format(tf - ti)
self.logger.info(
'Pre-cached data of {} Arch packages to the disk. {}'.format(
saved, time_msg))
def fill_providers_deps(
self, missing_deps: List[Tuple[str,
str]], provided_map: Dict[str,
Set[str]],
remote_repo_map: Dict[str, str], already_checked: Set[str],
remote_provided_map: Dict[str, Set[str]], deps_data: Dict[str,
dict],
aur_idx: Iterable[str], sort: bool, watcher: ProcessWatcher,
automatch_providers: bool) -> List[Tuple[str, str]]:
"""
:param missing_deps:
:param provided_map:
:param remote_repo_map:
:param already_checked:
:param remote_provided_map:
:param deps_data:
:param aur_idx:
:param sort:
:param watcher:
:param automatch_providers
:return: all deps sorted or None if the user declined the providers options
"""
deps_providers = map_providers(
{data[0]
for data in missing_deps if data[1] == '__several__'},
remote_provided_map)
if deps_providers:
all_providers = set()
for providers in deps_providers.values():
all_providers.update(providers)
providers_repos = pacman.map_repositories(all_providers)
selected_providers = confirmation.request_providers(
deps_providers, providers_repos, watcher, self.i18n)
if not selected_providers:
return
else:
providers_data = pacman.map_updates_data(
selected_providers
) # adding the chosen providers to re-check the missing deps
provided_map.update(
pacman.map_provided(remote=True, pkgs=selected_providers)
) # adding the providers as "installed" packages
providers_deps = self.map_missing_deps(
pkgs_data=providers_data,
provided_map=provided_map,
aur_index=aur_idx,
deps_checked=already_checked,
deps_data=deps_data,
sort=False,
remote_provided_map=remote_provided_map,
remote_repo_map=remote_repo_map,
watcher=watcher,
choose_providers=True,
automatch_providers=automatch_providers)
# cleaning the already mapped providers deps:
to_remove = []
for idx, dep in enumerate(missing_deps):
if dep[1] == '__several__':
to_remove.append(idx)
for idx, to_remove in enumerate(to_remove):
del missing_deps[to_remove - idx]
missing_deps.extend(((p, providers_repos.get(p, 'aur'))
for p in selected_providers))
for dep in providers_deps:
if dep not in missing_deps and dep[1] != '__several__':
missing_deps.append(dep)
deps_data.update(providers_data)
if not self.fill_providers_deps(
missing_deps=missing_deps,
provided_map=provided_map,
remote_repo_map=remote_repo_map,
already_checked=already_checked,
aur_idx=aur_idx,
remote_provided_map=remote_provided_map,
deps_data=deps_data,
sort=False,
watcher=watcher,
automatch_providers=automatch_providers):
return
if sort:
missing_to_sort = {
d[0]
for d in missing_deps if d[1] != '__several__'
}
return sorting.sort(missing_to_sort, deps_data,
provided_map)
return missing_deps
def summarize(self, pkgs: List[ArchPackage], root_password: str, arch_config: dict) -> UpgradeRequirements:
res = UpgradeRequirements([], [], [], [])
remote_provided_map = pacman.map_provided(remote=True)
remote_repo_map = pacman.map_repositories()
context = UpdateRequirementsContext(to_update={}, repo_to_update={}, aur_to_update={}, repo_to_install={},
aur_to_install={}, to_install={}, pkgs_data={}, cannot_upgrade={},
to_remove={}, installed_names=set(), provided_map={}, aur_index=set(),
arch_config=arch_config, root_password=root_password,
remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map)
self.__fill_aur_index(context)
aur_data = {}
aur_srcinfo_threads = []
for p in pkgs:
context.to_update[p.name] = p
if p.repository == 'aur':
context.aur_to_update[p.name] = p
t = Thread(target=self._fill_aur_pkg_update_data, args=(p, aur_data), daemon=True)
t.start()
aur_srcinfo_threads.append(t)
else:
context.repo_to_update[p.name] = p
if context.aur_to_update:
for t in aur_srcinfo_threads:
t.join()
self.logger.info("Filling updates data")
if context.repo_to_update:
context.pkgs_data.update(pacman.map_updates_data(context.repo_to_update.keys()))
if aur_data:
context.pkgs_data.update(aur_data)
self.__fill_provided_map(context)
if context.pkgs_data:
self._fill_conflicts(context)
try:
if not self._fill_to_install(context):
self.logger.info("The operation was cancelled by the user")
return
except PackageNotFoundException as e:
self.logger.error("Package '{}' not found".format(e.name))
return
if context.to_update:
installed_sizes = pacman.get_installed_size(list(context.to_update.keys()))
sorted_pkgs = []
if context.repo_to_update: # only sorting by name ( pacman already knows the best order to perform the upgrade )
sorted_pkgs.extend(context.repo_to_update.values())
sorted_pkgs.sort(key=lambda pkg: pkg.name)
if context.aur_to_update: # adding AUR packages in the end
sorted_aur = sorting.sort(context.aur_to_update.keys(), context.pkgs_data, context.provided_map)
for aur_pkg in sorted_aur:
sorted_pkgs.append(context.aur_to_update[aur_pkg[0]])
res.to_upgrade = [self._map_requirement(pkg, context, installed_sizes) for pkg in sorted_pkgs]
if context.to_remove:
res.to_remove = [p for p in context.to_remove.values()]
if context.cannot_upgrade:
res.cannot_upgrade = [d for d in context.cannot_upgrade.values()]
if context.to_install:
res.to_install = [self._map_requirement(p, context) for p in context.to_install.values()]
return res
def fill_providers_deps(
self, missing_deps: List[Tuple[str,
str]], provided_map: Dict[str,
Set[str]],
remote_repo_map: Dict[str, str], already_checked: Set[str],
remote_provided_map: Dict[str, Set[str]], deps_data: Dict[str,
dict],
aur_idx: Iterable[str], sort: bool, watcher: ProcessWatcher,
automatch_providers: bool, prefer_repository_provider: bool
) -> Optional[List[Tuple[str, str]]]:
"""
:param missing_deps:
:param provided_map:
:param remote_repo_map:
:param already_checked:
:param remote_provided_map:
:param deps_data:
:param aur_idx:
:param sort:
:param watcher:
:param automatch_providers
:param prefer_repository_provider
:return: all deps sorted or None if the user declined the providers options
"""
deps_providers = map_providers(
{data[0]
for data in missing_deps if data[1] == '__several__'},
remote_provided_map)
if deps_providers:
providers_repos = {}
repos_providers = set()
for providers in deps_providers.values():
for provider in providers:
if remote_repo_map.get(provider) == 'aur':
providers_repos[provider] = 'aur'
else:
repos_providers.add(provider)
providers_repos.update(pacman.map_repositories(repos_providers))
selected_providers = confirmation.request_providers(
deps_providers, providers_repos, watcher, self.i18n)
if not selected_providers:
return
else:
# adding the chosen providers for re-checking the missing dependencies
repo_selected, aur_selected = set(), set()
for provider in selected_providers:
if provider in repos_providers:
repo_selected.add(provider)
else:
aur_selected.add(provider)
providers_data = dict()
if repo_selected:
providers_data.update(
pacman.map_updates_data(repo_selected))
# adding the providers as "installed" packages
provided_map.update(
pacman.map_provided(remote=True, pkgs=repo_selected))
if aur_selected:
for pkgname, pkgdata in self.aur_client.gen_updates_data(
aur_selected):
providers_data[pkgname] = pkgdata
for provider in pkgdata[
'p']: # adding the providers as "installed" packages
currently_provided = provided_map.get(
provider, set())
provided_map[provider] = currently_provided
currently_provided.add(pkgname)
providers_deps = self.map_missing_deps(
pkgs_data=providers_data,
provided_map=provided_map,
aur_index=aur_idx,
deps_checked=already_checked,
deps_data=deps_data,
sort=False,
remote_provided_map=remote_provided_map,
remote_repo_map=remote_repo_map,
watcher=watcher,
choose_providers=True,
automatch_providers=automatch_providers,
prefer_repository_provider=prefer_repository_provider)
if providers_deps is None: # it means the user called off the installation process
return
# cleaning the already mapped providers deps:
to_remove = []
for idx, dep in enumerate(missing_deps):
if dep[1] == '__several__':
to_remove.append(idx)
for idx, to_remove in enumerate(to_remove):
del missing_deps[to_remove - idx]
missing_deps.extend(((p, providers_repos.get(p, 'aur'))
for p in selected_providers))
for dep in providers_deps:
if dep not in missing_deps and dep[1] != '__several__':
missing_deps.append(dep)
deps_data.update(providers_data)
if not self.fill_providers_deps(
missing_deps=missing_deps,
provided_map=provided_map,
remote_repo_map=remote_repo_map,
already_checked=already_checked,
aur_idx=aur_idx,
remote_provided_map=remote_provided_map,
deps_data=deps_data,
sort=False,
watcher=watcher,
automatch_providers=automatch_providers,
prefer_repository_provider=prefer_repository_provider):
return
if sort:
missing_to_sort = {
d[0]
for d in missing_deps if d[1] != '__several__'
}
return sorting.sort(missing_to_sort, deps_data,
provided_map)
return missing_deps
