def register_task(self, taskman: Optional[TaskManager]):
self._taskman = taskman
if taskman:
self._taskman.register_task(
id_=self.task_id,
label=self.i18n['task.download_suggestions'],
icon_path=get_icon_path())
def run(self):
self.taskman.register_task(self.task_id, self.i18n['arch.task.mirrors'], get_icon_path())
self.logger.info("Refreshing mirrors")
handler = ProcessHandler()
try:
self.taskman.update_progress(self.task_id, 10, '')
success, output = handler.handle_simple(pacman.refresh_mirrors(self.root_password), output_handler=self._notify_output)
if success:
if self.sort_limit is not None and self.sort_limit >= 0:
self.taskman.update_progress(self.task_id, 50, self.i18n['arch.custom_action.refresh_mirrors.status.updating'])
try:
handler.handle_simple(pacman.sort_fastest_mirrors(self.root_password, self.sort_limit), output_handler=self._notify_output)
except:
self.logger.error("Could not sort mirrors by speed")
traceback.print_exc()
mirrors.register_sync(self.logger)
else:
self.logger.error("It was not possible to refresh mirrors")
except:
self.logger.error("It was not possible to refresh mirrors")
traceback.print_exc()
self.taskman.update_progress(self.task_id, 100, None)
self.taskman.finish_task(self.task_id)
self.logger.info("Finished")
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 = self.controller.read_installed(disk_loader=None, internet_available=self.internet_available,
only_apps=False, pkg_types=None, limit=-1).installed
self.task_man.update_progress(self.task_id, 0, self.i18n['arch.task.disk_cache.reading'])
saved = 0
pkgs = {p.name: p for p in installed if ((self.aur and p.repository == 'aur') or (self.repositories and p.repository != 'aur')) and not os.path.exists(p.get_disk_cache_path())}
self.to_index = len(pkgs)
self.progress = self.to_index * 2
self.update_prepared(None, add=False)
saved += disk.save_several(pkgs, 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 request_providers(providers_map: Dict[str, Set[str]], repo_map: Dict[str, str], watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
msg = "<p>{}.</p><p>{}.</p>".format(i18n['arch.dialog.providers.line1'],
i18n['arch.dialog.providers.line2'])
repo_icon_path = get_repo_icon_path()
aur_icon_path = get_icon_path()
form = FormComponent([], label='')
for dep, providers in providers_map.items():
opts = []
providers_list = [*providers]
providers_list.sort()
for p in providers_list:
repo = repo_map.get(p, 'aur')
opts.append(InputOption(label=p,
value=p,
icon_path=aur_icon_path if repo == 'aur' else repo_icon_path,
tooltip='{}: {}'.format(i18n['repository'].capitalize(), repo)))
form.components.append(SingleSelectComponent(label=bold(dep.lower()),
options=opts,
default_option=opts[0],
type_=SelectViewType.COMBO,
max_per_line=1))
if watcher.request_confirmation(title=i18n['arch.providers'].capitalize(),
body=msg,
components=[form],
confirmation_label=i18n['proceed'].capitalize(),
deny_label=i18n['cancel'].capitalize()):
return {s.get_selected() for s in form.components}
def run(self) -> None:
self.logger.info("Synchronizing databases")
self.taskman.register_task(self.task_id,
self.i18n['arch.sync_databases.substatus'],
get_icon_path())
if self.refresh_mirrors and self.refresh_mirrors.is_alive():
self.taskman.update_progress(
self.task_id, 0, self.i18n['arch.task.sync_databases.waiting'])
self.refresh_mirrors.join()
progress = 10
dbs = pacman.get_databases()
self.taskman.update_progress(self.task_id, progress, None)
if dbs:
inc = 90 / len(dbs)
try:
p = new_root_subprocess(['pacman', '-Syy'], self.root_password)
dbs_read, last_db = 0, None
for o in p.stdout:
line = o.decode().strip()
if line and line.startswith('downloading'):
db = line.split(' ')[1].strip()
if last_db is None or last_db != db:
last_db = db
dbs_read += 1
progress = dbs_read * inc
else:
progress += 0.25
self.taskman.update_progress(
self.task_id, progress,
self.i18n['arch.task.sync_sb.status'].format(db))
for o in p.stderr:
o.decode()
p.wait()
if p.returncode == 0:
database.register_sync(self.logger)
else:
self.logger.error("Could not synchronize database")
except:
self.logger.info("Error while synchronizing databases")
traceback.print_exc()
self.taskman.update_progress(self.task_id, 100, None)
self.taskman.finish_task(self.task_id)
self.logger.info("Finished")
def __init__(self, taskman: TaskManager, root_password: str, i18n: I18n,
logger: logging.Logger, create_config: CreateConfigFile):
super(RefreshMirrors, self).__init__(daemon=True)
self.taskman = taskman
self.i18n = i18n
self.logger = logger
self.root_password = root_password
self.task_id = "arch_mirrors"
self.create_config = create_config
self.refreshed = False
self.task_name = self.i18n['arch.task.mirrors']
self.taskman.register_task(self.task_id, self.task_name,
get_icon_path())
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.task_man.update_progress(self.task_id, 1, '')
self.logger.info("Checking already cached package data")
cache_dirs = [fpath for fpath in glob.glob('{}/*'.format(self.installed_cache_dir)) if os.path.isdir(fpath)]
not_cached_names = None
if cache_dirs: # if there are cache data
installed_names = pacman.list_installed_names()
cached_pkgs = {cache_dir.split('/')[-1] for cache_dir in cache_dirs}
not_cached_names = installed_names.difference(cached_pkgs)
if not not_cached_names:
self.task_man.update_progress(self.task_id, 100, '')
self.task_man.finish_task(self.task_id)
tf = time.time()
time_msg = '{0:.2f} seconds'.format(tf - ti)
self.logger.info('Finished: no package data to cache ({})'.format(time_msg))
return
self.logger.info('Pre-caching installed Arch packages data to disk')
installed = self.controller.read_installed(disk_loader=None, internet_available=self.internet_available,
only_apps=False, pkg_types=None, limit=-1, names=not_cached_names,
wait_disk_cache=False).installed
self.task_man.update_progress(self.task_id, 0, self.i18n['arch.task.disk_cache.reading'])
saved = 0
pkgs = {p.name: p for p in installed if ((self.aur and p.repository == 'aur') or (self.repositories and p.repository != 'aur')) and not os.path.exists(p.get_disk_cache_path())}
self.to_index = len(pkgs)
self.progress = self.to_index * 2
self.update_prepared(None, add=False)
# overwrite == True because the verification already happened
saved += disk.save_several(pkgs, when_prepared=self.update_prepared, after_written=self.update_indexed, overwrite=True)
self.task_man.update_progress(self.task_id, 100, None)
self.task_man.finish_task(self.task_id)
tf = time.time()
time_msg = '{0:.2f} seconds'.format(tf - ti)
self.logger.info('Finished: pre-cached data of {} Arch packages to the disk ({})'.format(saved, time_msg))
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 __init__(self, taskman: TaskManager, root_password: str, i18n: I18n,
logger: logging.Logger, refresh_mirrors: RefreshMirrors,
create_config: CreateConfigFile):
super(SyncDatabases, self).__init__(daemon=True)
self.task_man = taskman
self.i18n = i18n
self.taskman = taskman
self.task_id = "arch_dbsync"
self.root_password = root_password
self.refresh_mirrors = refresh_mirrors
self.logger = logger
self.create_config = create_config
self.task_name = self.i18n['arch.sync_databases.substatus']
self.taskman.register_task(self.task_id, self.task_name,
get_icon_path())
self.synchronized = False
def __init__(self,
context: ApplicationContext,
taskman: TaskManager,
create_config: Optional[CreateConfigFile] = None,
arch_config: Optional[dict] = None):
super(AURIndexUpdater, self).__init__(daemon=True)
self.http_client = context.http_client
self.i18n = context.i18n
self.logger = context.logger
self.taskman = taskman
self.task_id = 'index_aur'
self.create_config = create_config
self.config = arch_config
self.taskman.register_task(self.task_id,
self.i18n['arch.task.aur.index.status'],
get_icon_path())
def run(self):
if not self.optimizations:
self.logger.info(
"Arch packages compilation optimizations are disabled")
if os.path.exists(CUSTOM_MAKEPKG_FILE):
self.logger.info(
"Removing custom 'makepkg.conf' -> '{}'".format(
CUSTOM_MAKEPKG_FILE))
os.remove(CUSTOM_MAKEPKG_FILE)
self.logger.info('Finished')
else:
if self.task_man:
self.task_man.register_task(
self.task_id, self.i18n['arch.task.optimizing'].format(
bold('makepkg.conf')), get_icon_path())
self.optimize()
def __init__(self,
i18n: I18n,
logger: logging.Logger,
taskman: TaskManager,
create_config: Optional[CreateConfigFile] = None):
super(ArchCompilationOptimizer, self).__init__(daemon=True)
self.logger = logger
self.i18n = i18n
self.re_compress_xz = re.compile(r'#?\s*COMPRESSXZ\s*=\s*.+')
self.re_compress_zst = re.compile(r'#?\s*COMPRESSZST\s*=\s*.+')
self.re_build_env = re.compile(r'\s+BUILDENV\s*=.+')
self.re_ccache = re.compile(r'!?ccache')
self.taskman = taskman
self.task_id = 'arch_make_optm'
self.create_config = create_config
self.taskman.register_task(
self.task_id,
self.i18n['arch.task.optimizing'].format(bold('makepkg.conf')),
get_icon_path())
def __init__(self, taskman: TaskManager, i18n: I18n,
logger: logging.Logger, controller: "ArchManager",
internet_available: bool, aur_indexer: Thread,
create_config: CreateConfigFile):
super(ArchDiskCacheUpdater, self).__init__(daemon=True)
self.logger = logger
self.taskman = taskman
self.task_id = 'arch_cache_up'
self.i18n = i18n
self.indexed = 0
self.indexed_template = self.i18n[
'arch.task.disk_cache.indexed'] + ': {}/ {}'
self.to_index = 0
self.progress = 0 # progress is defined by the number of packages prepared and indexed
self.controller = controller
self.internet_available = internet_available
self.installed_hash_path = '{}/installed.sha1'.format(ARCH_CACHE_PATH)
self.installed_cache_dir = '{}/installed'.format(ARCH_CACHE_PATH)
self.aur_indexer = aur_indexer
self.create_config = create_config
self.taskman.register_task(self.task_id,
self.i18n['arch.task.disk_cache'],
get_icon_path())
def run(self) -> None:
self.taskman.update_progress(
self.task_id, 0, self.i18n['task.waiting_task'].format(
bold(self.create_config.task_name)))
self.create_config.join()
self.taskman.update_progress(
self.task_id, 0, self.i18n['task.waiting_task'].format(
bold(self.refresh_mirrors.task_name)))
self.refresh_mirrors.join()
self.taskman.update_progress(self.task_id, 1,
self.i18n['arch.task.checking_settings'])
arch_config = self.create_config.config
aur_supported = aur.is_supported(arch_config)
if not self.is_enabled(arch_config, aur_supported):
self.taskman.update_progress(self.task_id, 100,
self.i18n['arch.task.disabled'])
self.taskman.finish_task(self.task_id)
return
shoud_sync = self.refresh_mirrors.refreshed or (database.should_sync(
arch_config, aur_supported, None, self.logger))
if not shoud_sync:
self.taskman.update_progress(
self.task_id, 100,
self.i18n['arch.sync_databases.substatus.synchronized'])
self.taskman.finish_task(self.task_id)
self.synchronized = True
return
self.logger.info("Synchronizing databases")
self.taskman.register_task(self.task_id,
self.i18n['arch.sync_databases.substatus'],
get_icon_path())
progress = 10
dbs = pacman.get_databases()
self.taskman.update_progress(self.task_id, progress, None)
if dbs:
inc = 90 / len(dbs)
try:
p = new_root_subprocess(['pacman', '-Syy'], self.root_password)
dbs_read, last_db = 0, None
for o in p.stdout:
line = o.decode().strip()
if line:
self.task_man.update_output(self.task_id, line)
if line.startswith('downloading'):
db = line.split(' ')[1].strip()
if last_db is None or last_db != db:
last_db = db
dbs_read += 1
progress = dbs_read * inc
else:
progress += 0.25
self.taskman.update_progress(
self.task_id, progress,
self.i18n['arch.task.sync_sb.status'].format(
db))
for o in p.stderr:
line = o.decode().strip()
if line:
self.task_man.update_output(self.task_id, line)
p.wait()
if p.returncode == 0:
database.register_sync(self.logger)
self.synchronized = True
else:
self.logger.error("Could not synchronize database")
except:
self.logger.info("Error while synchronizing databases")
traceback.print_exc()
self.taskman.update_progress(self.task_id, 100, None)
self.taskman.finish_task(self.task_id)
self.logger.info("Finished")
