def prepare(self, task_manager: TaskManager, root_password: str,
internet_available: bool):
ti = time.time()
self.logger.info("Initializing")
taskman = task_manager if task_manager else TaskManager(
) # empty task manager to prevent null pointers
create_config = CreateConfigFile(
taskman=taskman,
configman=self.configman,
i18n=self.i18n,
task_icon_path=get_path('img/logo.svg'),
logger=self.logger)
create_config.start()
if self.managers:
internet_on = self.context.is_internet_available()
prepare_tasks = []
for man in self.managers:
if man not in self._already_prepared and self._can_work(man):
t = Thread(target=man.prepare,
args=(taskman, root_password, internet_on),
daemon=True)
t.start()
prepare_tasks.append(t)
self._already_prepared.append(man)
for t in prepare_tasks:
t.join()
tf = time.time()
self.logger.info("Finished. Took {0:.2f} seconds".format(tf - ti))
def prepare(self, task_manager: TaskManager, root_password: str,
internet_available: bool):
if self.managers:
internet_on = internet.is_available()
taskman = task_manager if task_manager else TaskManager(
) # empty task manager to prevent null pointers
for man in self.managers:
if man not in self._already_prepared and self._can_work(man):
man.prepare(taskman, root_password, internet_on)
self._already_prepared.append(man)
def update_database(self, root_password: str,
watcher: ProcessWatcher) -> bool:
db_updater = DatabaseUpdater(i18n=self.i18n,
http_client=self.context.http_client,
logger=self.context.logger,
watcher=watcher,
taskman=TaskManager())
res = db_updater.download_databases()
return res
def suggestions_downloader(self) -> AppImageSuggestionsDownloader:
if not self._suggestions_downloader:
file_url = self.context.get_suggestion_url(self.__module__)
self._suggestions_downloader = AppImageSuggestionsDownloader(taskman=TaskManager(),
i18n=self.context.i18n,
http_client=self.context.http_client,
logger=self.context.logger,
file_url=file_url)
if self._suggestions_downloader.is_custom_local_file_mapped():
self.logger.info(f"Local AppImage suggestions file mapped: {file_url}")
return self._suggestions_downloader
def list_suggestions(self, limit: int, filter_installed: bool) -> Optional[List[PackageSuggestion]]:
if limit == 0:
return
connection = self._get_db_connection(DATABASE_APPS_FILE)
if connection:
self.suggestions_downloader.taskman = TaskManager()
suggestions = tuple(self.suggestions_downloader.read())
if not suggestions:
self.logger.warning("Could not read AppImage suggestions")
return
else:
self.logger.info("Mapping AppImage suggestions")
try:
if filter_installed:
installed = {i.name.lower() for i in self.read_installed(disk_loader=None,
connection=connection).installed}
else:
installed = None
sugs_map = {}
for s in suggestions:
lsplit = s.split('=')
name = lsplit[1].strip()
if limit < 0 or len(sugs_map) < limit:
if not installed or not name.lower() in installed:
sugs_map[name] = SuggestionPriority(int(lsplit[0]))
else:
break
cursor = connection.cursor()
cursor.execute(query.FIND_APPS_BY_NAME_FULL.format(','.join([f"'{s}'" for s in sugs_map.keys()])))
res = []
for t in cursor.fetchall():
app = AppImage(*t, i18n=self.i18n)
res.append(PackageSuggestion(app, sugs_map[app.name.lower()]))
self.logger.info(f"Mapped {len(res)} AppImage suggestions")
return res
except:
traceback.print_exc()
finally:
connection.close()
def index_apps(self, root_password: Optional[str], watcher: Optional[ProcessWatcher],
taskman: Optional[TaskManager] = None, deb_config: Optional[dict] = None,
check_expiration: bool = False) -> bool:
_config = deb_config if deb_config else self.configman.get_config()
_taskman = taskman if taskman else TaskManager()
map_apps = MapApplications(taskman=_taskman, app_indexer=self.app_indexer,
i18n=self._i18n, logger=self._log, deb_config=deb_config,
app_mapper=self.app_mapper, check_expiration=check_expiration,
watcher=watcher)
map_apps.start()
gen_app_index = UpdateApplicationIndex(taskman=_taskman, app_indexer=self.app_indexer,
i18n=self._i18n, logger=self._log,
mapping_apps=map_apps)
gen_app_index.start()
map_apps.join()
self._update_apps_index(map_apps.apps)
gen_app_index.join()
return True
def synchronize_packages(self, root_password: Optional[str], watcher: ProcessWatcher) -> bool:
return SynchronizePackages(i18n=self._i18n, logger=self._log, root_password=root_password, watcher=watcher,
aptitude=self.aptitude, taskman=TaskManager()).run()
def taskman(self) -> TaskManager:
if self._taskman is None:
self._taskman = TaskManager()
return self._taskman
def list_suggestions(self, limit: int,
filter_installed: bool) -> List[PackageSuggestion]:
res = []
connection = self._get_db_connection(DATABASE_APPS_FILE)
if connection:
suggestions = AppImageSuggestionsDownloader(
appimage_config=self.configman.get_config(),
logger=self.logger,
i18n=self.i18n,
http_client=self.http_client,
taskman=TaskManager()).read()
if not suggestions:
self.logger.warning("Could not read suggestions")
return res
else:
self.logger.info("Mapping suggestions")
try:
if filter_installed:
installed = {
i.name.lower()
for i in self.read_installed(
disk_loader=None,
connection=connection).installed
}
else:
installed = None
sugs_map = {}
for s in suggestions:
lsplit = s.split('=')
name = lsplit[1].strip()
if limit <= 0 or len(sugs_map) < limit:
if not installed or not name.lower() in installed:
sugs_map[name] = SuggestionPriority(
int(lsplit[0]))
else:
break
cursor = connection.cursor()
cursor.execute(
query.FIND_APPS_BY_NAME_FULL.format(','.join(
["'{}'".format(s) for s in sugs_map.keys()])))
for t in cursor.fetchall():
app = AppImage(*t,
i18n=self.i18n,
custom_actions=self.custom_app_actions)
res.append(
PackageSuggestion(app, sugs_map[app.name.lower()]))
self.logger.info("Mapped {} suggestions".format(len(res)))
except:
traceback.print_exc()
finally:
connection.close()
return res