def read_installed(self, disk_loader: DiskCacheLoader, limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None, internet_available: bool = None) -> SearchResult: version = flatpak.get_version() updates = [] if internet_available: thread_updates = Thread(target=self._add_updates, args=(version, updates)) thread_updates.start() else: thread_updates = None installed = flatpak.list_installed(version) models = [] if installed: if thread_updates: thread_updates.join() for app_json in installed: model = self._map_to_model(app_json=app_json, installed=True, disk_loader=disk_loader, internet=internet_available) if version >= '1.5.0': model.update = '{}/{}'.format(app_json['id'], app_json['branch']) in updates[0] if updates else None else: model.update = app_json['ref'] in updates[0] if updates else None models.append(model) return SearchResult(models, None, len(models))
def read_installed(self, disk_loader: DiskCacheLoader, limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None, internet_available: bool = None) -> SearchResult: version = flatpak.get_version() updates = [] if internet_available: thread_updates = Thread(target=self._add_updates, args=(version, updates)) thread_updates.start() else: thread_updates = None installed = flatpak.list_installed(version) models = [] if installed: update_map = None if thread_updates: thread_updates.join() update_map = updates[0] for app_json in installed: model = self._map_to_model(app_json=app_json, installed=True, disk_loader=disk_loader, internet=internet_available) model.update = None models.append(model) if update_map and (update_map['full'] or update_map['partial']): if version >= '1.4.0': update_id = '{}/{}/{}'.format(app_json['id'], app_json['branch'], app_json['installation']) if update_map['full'] and update_id in update_map['full']: model.update = True if update_map['partial']: for partial in update_map['partial']: partial_data = partial.split('/') if app_json['id'] in partial_data[0] and\ app_json['branch'] == partial_data[1] and\ app_json['installation'] == partial_data[2]: partial_model = model.gen_partial(partial.split('/')[0]) partial_model.update = True models.append(partial_model) else: model.update = '{}/{}'.format(app_json['installation'], app_json['ref']) in update_map['full'] if models: ignored = self._read_ignored_updates() if ignored: for model in models: if model.get_update_ignore_key() in ignored: model.updates_ignored = True return SearchResult(models, None, len(models))
def install(self, pkg: FlatpakApplication, root_password: str, disk_loader: DiskCacheLoader, watcher: ProcessWatcher) -> TransactionResult: flatpak_config = self.configman.get_config() install_level = flatpak_config['installation_level'] if install_level is not None: self.logger.info( "Default Flaptak installation level defined: {}".format( install_level)) if install_level not in ('user', 'system'): watcher.show_message( title=self.i18n['error'].capitalize(), body=self.i18n['flatpak.install.bad_install_level.body']. format(field=bold('installation_level'), file=bold(CONFIG_FILE)), type_=MessageType.ERROR) return TransactionResult(success=False, installed=[], removed=[]) pkg.installation = install_level else: user_level = watcher.request_confirmation( title=self.i18n['flatpak.install.install_level.title'], body=self.i18n['flatpak.install.install_level.body'].format( bold(pkg.name)), confirmation_label=self.i18n['no'].capitalize(), deny_label=self.i18n['yes'].capitalize()) pkg.installation = 'user' if user_level else 'system' remotes = flatpak.list_remotes() handler = ProcessHandler(watcher) if pkg.installation == 'user' and not remotes['user']: handler.handle_simple(flatpak.set_default_remotes('user')) elif pkg.installation == 'system' and not remotes['system']: if user.is_root(): handler.handle_simple(flatpak.set_default_remotes('system')) else: valid, user_password = watcher.request_root_password() if not valid: watcher.print('Operation aborted') return TransactionResult(success=False, installed=[], removed=[]) else: if not handler.handle_simple( flatpak.set_default_remotes( 'system', user_password))[0]: watcher.show_message( title=self.i18n['error'].capitalize(), body=self. i18n['flatpak.remotes.system_flathub.error'], type_=MessageType.ERROR) watcher.print("Operation cancelled") return TransactionResult(success=False, installed=[], removed=[]) # retrieving all installed so it will be possible to know the additional installed runtimes after the operation succeeds flatpak_version = flatpak.get_version() installed = flatpak.list_installed(flatpak_version) installed_by_level = { '{}:{}:{}'.format(p['id'], p['name'], p['branch']) for p in installed if p['installation'] == pkg.installation } if installed else None if not self._make_exports_dir(handler.watcher): return TransactionResult(success=False, installed=[], removed=[]) installed, output = handler.handle_simple( flatpak.install(str(pkg.id), pkg.origin, pkg.installation)) if not installed and 'error: No ref chosen to resolve matches' in output: ref_opts = RE_INSTALL_REFS.findall(output) if ref_opts and len(ref_opts) > 1: view_opts = [ InputOption(label=o, value=o.strip()) for o in ref_opts if o ] ref_select = SingleSelectComponent(type_=SelectViewType.RADIO, options=view_opts, default_option=view_opts[0], label='') if watcher.request_confirmation( title=self.i18n['flatpak.install.ref_choose.title'], body=self.i18n['flatpak.install.ref_choose.body']. format(bold(pkg.name)), components=[ref_select], confirmation_label=self.i18n['proceed'].capitalize(), deny_label=self.i18n['cancel'].capitalize()): ref = ref_select.get_selected() installed, output = handler.handle_simple( flatpak.install(ref, pkg.origin, pkg.installation)) pkg.ref = ref pkg.runtime = 'runtime' in ref else: watcher.print('Aborted by the user') return TransactionResult.fail() else: return TransactionResult.fail() if installed: try: fields = flatpak.get_fields(str(pkg.id), pkg.branch, ['Ref', 'Branch']) if fields: pkg.ref = fields[0] pkg.branch = fields[1] except: traceback.print_exc() if installed: new_installed = [pkg] current_installed = flatpak.list_installed(flatpak_version) current_installed_by_level = [ p for p in current_installed if p['installation'] == pkg.installation ] if current_installed else None if current_installed_by_level and (not installed_by_level or len(current_installed_by_level) > len(installed_by_level) + 1): pkg_key = '{}:{}:{}'.format(pkg.id, pkg.name, pkg.branch) net_available = self.context.is_internet_available() for p in current_installed_by_level: 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)) return TransactionResult(success=installed, installed=new_installed, removed=[]) else: return TransactionResult.fail()
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, required_runtimes = list(), dict() thread_updates, thread_runtimes = None, None if internet_available: thread_updates = Thread(target=self._add_updates, args=(version, updates)) thread_updates.start() if version >= VERSION_1_12: thread_runtimes = Thread(target=self._fill_required_runtime_updates, args=(required_runtimes,)) thread_runtimes.start() installed = flatpak.list_installed(version) update_map = None if thread_updates: thread_updates.join() update_map = updates[0] models = {} data_loaders: Optional[List[FlatpakAsyncDataLoader]] = [] if wait_async_data else None if installed: for app_json in installed: 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) if model_with_update: model_with_update.update = True else: # it is a new component that must be installed update_id_split = update_id.split('/') new_app = FlatpakApplication(id=update_id_split[0], branch=update_id_split[1], installation=update_id_split[2], name=update_id_split[0].split('.')[-1].strip(), version=update_id_split[1], arch='x86_64' if self.context.is_system_x86_64() else 'x86', origin=update_id_split[3] if len(update_id_split) == 4 else None) new_app.update_component = True # mark as "update component" new_app.installed = True # faking the "installed" status to be displayed as an update new_app.update = True new_app.update_ref() models[update_id] = new_app if version >= VERSION_1_2: for partial_update_id in update_map['partial']: partial_data = partial_update_id.split('/') for model in models.values(): if model.installation == partial_data[2] and model.branch == partial_data[1]: if model.id == partial_data[0]: model.update = True break elif model.id in partial_data[0]: partial_model = model.gen_partial(partial_data[0]) partial_model.update = True models[partial_update_id] = partial_model break if thread_runtimes: thread_runtimes.join() if required_runtimes: for installation in ('system', 'user'): installation_runtimes = required_runtimes.get(installation) if installation_runtimes: for ref, origin in installation_runtimes: ref_split = ref.split('/') models[f'{installation}.'] = FlatpakApplication(id=ref_split[1], ref=ref, origin=origin, name=ref_split[1], version=ref_split[-1], latest_version=ref_split[-1], runtime=True, installation=installation, installed=False, update_component=True, update=True) if models: ignored = self._read_ignored_updates() if ignored: for model in models.values(): 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))