From a92e0440c3226ed5d72e1e6cf5df4182bf8df0b6 Mon Sep 17 00:00:00 2001 From: Vinicius Moreira Date: Mon, 28 Feb 2022 16:26:42 -0300 Subject: [PATCH] [flatpak] improvement: removed some unneeded API calls when listing updates (cli/tray) --- CHANGELOG.md | 3 ++ bauh/gems/flatpak/controller.py | 65 +++++++++++++++++---------------- bauh/gems/flatpak/worker.py | 21 +---------- 3 files changed, 38 insertions(+), 51 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 832e524b..d60fc245 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). - removing the "%U" parameter before launching applications to prevent error messages - minor code refactoring +- Flatpak + - cli/tray: removed some unneeded API calls when listing updates [#234](https://github.com/vinifmor/bauh/issues/234) + - UI - upgrade summary dialog size - displaying tips for some custom actions (on mouse hover) diff --git a/bauh/gems/flatpak/controller.py b/bauh/gems/flatpak/controller.py index 94cb8a8b..3a11f1a5 100644 --- a/bauh/gems/flatpak/controller.py +++ b/bauh/gems/flatpak/controller.py @@ -27,7 +27,7 @@ from bauh.gems.flatpak import flatpak, SUGGESTIONS_FILE, CONFIG_FILE, UPDATES_IG from bauh.gems.flatpak.config import FlatpakConfigManager from bauh.gems.flatpak.constants import FLATHUB_API_URL from bauh.gems.flatpak.model import FlatpakApplication -from bauh.gems.flatpak.worker import FlatpakAsyncDataLoader, FlatpakUpdateLoader +from bauh.gems.flatpak.worker import FlatpakAsyncDataLoader DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.000Z' RE_INSTALL_REFS = re.compile(r'\d+\)\s+(.+)') @@ -50,28 +50,34 @@ class FlatpakManager(SoftwareManager): def get_managed_types(self) -> Set["type"]: return {FlatpakApplication} - def _map_to_model(self, app_json: dict, installed: bool, disk_loader: DiskCacheLoader, internet: bool = True) -> FlatpakApplication: + def _map_to_model(self, app_json: dict, installed: bool, disk_loader: Optional[DiskCacheLoader], internet: bool = True) -> Tuple[FlatpakApplication, Optional[FlatpakAsyncDataLoader]]: app = FlatpakApplication(**app_json, i18n=self.i18n) app.installed = installed api_data = self.api_cache.get(app_json['id']) + if app.runtime and app.latest_version is None: + app.latest_version = app.version + expired_data = api_data and api_data.get('expires_at') and api_data['expires_at'] <= datetime.utcnow() + data_loader: Optional[FlatpakAsyncDataLoader] = None + if not api_data or expired_data: if not app.runtime: if disk_loader: disk_loader.fill(app) # preloading cached disk data if internet: - FlatpakAsyncDataLoader(app=app, api_cache=self.api_cache, manager=self, - context=self.context, category_cache=self.category_cache).start() + data_loader = FlatpakAsyncDataLoader(app=app, api_cache=self.api_cache, manager=self, + context=self.context, category_cache=self.category_cache) + data_loader.start() else: app.fill_cached_data(api_data) app.status = PackageStatus.READY - return app + return app, data_loader def _get_search_remote(self) -> str: remotes = flatpak.list_remotes() @@ -109,7 +115,7 @@ class FlatpakManager(SoftwareManager): if len(apps_found) > len(already_read): for app_found in apps_found: if app_found['id'] not in already_read: - res.new.append(self._map_to_model(app_found, False, disk_loader)) + res.new.append(self._map_to_model(app_found, False, disk_loader)[0]) res.total = len(res.installed) + len(res.new) return res @@ -117,7 +123,8 @@ class FlatpakManager(SoftwareManager): def _add_updates(self, version: Version, output: list): output.append(flatpak.list_updates_as_str(version)) - def read_installed(self, disk_loader: Optional[DiskCacheLoader], limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None, internet_available: bool = None) -> SearchResult: + def read_installed(self, disk_loader: Optional[DiskCacheLoader], limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None, + internet_available: bool = None, wait_async_data: bool = False) -> SearchResult: version = flatpak.get_version() updates = [] @@ -136,14 +143,18 @@ class FlatpakManager(SoftwareManager): update_map = updates[0] models = {} + data_loaders: Optional[List[FlatpakAsyncDataLoader]] = [] if wait_async_data else None if installed: for app_json in installed: - model = self._map_to_model(app_json=app_json, installed=True, - disk_loader=disk_loader, internet=internet_available) + model, loader = self._map_to_model(app_json=app_json, installed=True, + disk_loader=disk_loader, internet=internet_available) model.update = False models[model.get_update_id(version)] = model + if loader and data_loaders is not None: + data_loaders.append(loader) + if update_map: for update_id in update_map['full']: model_with_update = models.get(update_id) @@ -188,6 +199,10 @@ class FlatpakManager(SoftwareManager): if model.get_update_ignore_key() in ignored: model.updates_ignored = True + if data_loaders: + for loader in data_loaders: + loader.join() + return SearchResult([*models.values()], None, len(models)) def downgrade(self, pkg: FlatpakApplication, root_password: Optional[str], watcher: ProcessWatcher) -> bool: @@ -475,7 +490,7 @@ class FlatpakManager(SoftwareManager): current_key = '{}:{}:{}'.format(p['id'], p['name'], p['branch']) if current_key != pkg_key and (not installed_by_level or current_key not in installed_by_level): new_installed.append(self._map_to_model(app_json=p, installed=True, - disk_loader=disk_loader, internet=net_available)) + disk_loader=disk_loader, internet=net_available)[0]) return TransactionResult(success=installed, installed=new_installed, removed=[]) else: @@ -499,27 +514,15 @@ class FlatpakManager(SoftwareManager): def list_updates(self, internet_available: bool) -> List[PackageUpdate]: updates = [] - installed = self.read_installed(None, internet_available=internet_available).installed + installed = self.read_installed(None, internet_available=internet_available, wait_async_data=True).installed - to_update = [p for p in installed if p.update and not p.is_update_ignored()] - - if to_update: - loaders = [] - - for app in to_update: - if app.is_application(): - loader = FlatpakUpdateLoader(app=app, http_client=self.context.http_client) - loader.start() - loaders.append(loader) - - for loader in loaders: - loader.join() - - for app in to_update: - updates.append(PackageUpdate(pkg_id='{}:{}:{}'.format(app.id, app.branch, app.installation), - pkg_type='Flatpak', - name=app.name, - version=app.version)) + if installed: + for p in installed: + if isinstance(p, FlatpakApplication) and p.update and not p.is_update_ignored(): + updates.append(PackageUpdate(pkg_id=f'{p.id}:{p.branch}:{p.installation}', + pkg_type='Flatpak', + name=p.name, + version=p.latest_version)) return updates @@ -560,7 +563,7 @@ class FlatpakManager(SoftwareManager): app_json = flatpak.search(cli_version, appid, remote_level, app_id=True) if app_json: - model = PackageSuggestion(self._map_to_model(app_json[0], False, None), priority) + model = PackageSuggestion(self._map_to_model(app_json[0], False, None)[0], priority) self.suggestions_cache.add(appid, model) res.append(model) else: diff --git a/bauh/gems/flatpak/worker.py b/bauh/gems/flatpak/worker.py index 80d48885..529c4afc 100644 --- a/bauh/gems/flatpak/worker.py +++ b/bauh/gems/flatpak/worker.py @@ -6,7 +6,6 @@ from bauh.api.abstract.cache import MemoryCache from bauh.api.abstract.context import ApplicationContext from bauh.api.abstract.controller import SoftwareManager from bauh.api.abstract.model import PackageStatus -from bauh.api.http import HttpClient from bauh.gems.flatpak.constants import FLATHUB_API_URL, FLATHUB_URL from bauh.gems.flatpak.model import FlatpakApplication @@ -14,7 +13,7 @@ from bauh.gems.flatpak.model import FlatpakApplication class FlatpakAsyncDataLoader(Thread): def __init__(self, app: FlatpakApplication, manager: SoftwareManager, context: ApplicationContext, api_cache: MemoryCache, category_cache: MemoryCache): - super(FlatpakAsyncDataLoader, self).__init__(daemon=True) + super(FlatpakAsyncDataLoader, self).__init__() self.app = app self.manager = manager self.http_client = context.http_client @@ -96,21 +95,3 @@ class FlatpakAsyncDataLoader(Thread): if self.persist: self.manager.cache_to_disk(pkg=self.app, icon_bytes=None, only_icon=False) - - -class FlatpakUpdateLoader(Thread): - - def __init__(self, app: FlatpakApplication, http_client: HttpClient): - super(FlatpakUpdateLoader, self).__init__(daemon=True) - self.app = app - self.http_client = http_client - - def run(self): - try: - data = self.http_client.get_json('{}/apps/{}'.format(FLATHUB_API_URL, self.app.id)) - - if data and data.get('currentReleaseVersion'): - self.app.version = data['currentReleaseVersion'] - self.app.latest_version = self.app.version - except: - traceback.print_exc()