def remove_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None): pkgnames = [app.pkgname for app in apps] appnames = [app.appname for app in apps] # keep track of pkg, app and icon for setting them as meta self.new_pkgname = pkgnames[0] self.new_appname = appnames[0] self.new_iconname = iconnames[0] # temporary hack pkgnames = self._fix_pkgnames(pkgnames) task = packagekit.Task() task.remove_packages_async( pkgnames, False, # allow deps True, # autoremove None, # cancellable self._on_progress_changed, None, # progress data self._on_remove_ready, # callback ready task # callback data ) self.emit("transaction-started", pkgnames[0], appnames[0], 0, TransactionTypes.REMOVE)
def _do_install(self): """Run a PackageKit transaction to install given packages. Raise exception in case of error. """ client = packagekit.Client() client.set_interactive(False) # Refresh package cache from all enabled repositories results = client.refresh_cache(False, None, self.progress_callback, self) self._assert_success(results) # Resolve packages again to get the latest versions after refresh results = client.resolve(packagekit.FilterEnum.INSTALLED, tuple(self.package_names) + (None, ), None, self.progress_callback, self) self._assert_success(results) for package in results.get_package_array(): packages_resolved[package.get_name()] = package package_ids = [] for package_name in self.package_names: if package_name not in packages_resolved or \ not packages_resolved[package_name]: raise PackageException(_('packages not found')) package_ids.append(packages_resolved[package_name].get_id()) # Start package installation results = client.install_packages( packagekit.TransactionFlagEnum.ONLY_TRUSTED, package_ids + [None], None, self.progress_callback, self) self._assert_success(results)
def check_installed(package_names): """Return a boolean installed status of package. This operation is blocking and waits until the check is finished. """ def _callback(progress, progress_type, user_data): """Process progress updates on package resolve operation.""" pass client = packagekit.Client() response = client.resolve(packagekit.FilterEnum.INSTALLED, tuple(package_names) + (None, ), None, _callback, None) installed_package_names = [] for package in response.get_package_array(): if package.get_info() == packagekit.InfoEnum.INSTALLED: installed_package_names.append(package.get_name()) packages_resolved[package.get_name()] = package # When package names could not be resolved for package_name in package_names: if package_name not in packages_resolved: packages_resolved[package_name] = None return set(installed_package_names) == set(package_names)
def update_cache(self): self.stack.set_visible_child_name("refresh_page") self.spinner.start() task = packagekit.Task() task.refresh_cache_async(True, Gio.Cancellable(), self.on_cache_update_progress, (None, ), self.on_cache_update_finished, (None, ))
def __init__(self): GObject.GObject.__init__(self) self.t = None self.task = None self.error = "" self.warning = "" self.providers = [] self.previous_status = "" self.previous_role = "" self.previous_icon = "" self.previous_target = "" self.previous_package = "" self.previous_percent = 0 self.total_size = 0 self.already_transferred = 0 self.aur_updates_checked = False self.aur_updates_pkgs = [] self.localdb = None self.syncdbs = None self.transID = None self.cancelTransaction = None self._current_pkg_to_installed = None self._current_pkg_to_removed = None self.client = packagekit.Client() self.lastedSearch = {} self.status_dir = Gio.file_new_for_path( "/var/lib/PackageKit/transactions.db") self.monitor = self.status_dir.monitor_file(Gio.FileMonitorFlags.NONE, None) self.oldCacheAge = self.client.get_cache_age() self.module = None if self.monitor: self.monitorID = self.monitor.connect("changed", self._changed)
def _get_package_details(self, pkgs): pkgsId = [] for pkg in pkgs: if (not (pkg.get_id() in pkgsId)): pkgsId.append(pkg.get_id()) try: task = packagekit.Task() result = task.get_details_sync(pkgsId, None, self._progress_pcb, None) except GObject.GError: e = sys.exc_info()[1] return None pkgsDetails = result.get_details_array() if not pkgsDetails: return None resultDetails = [] currVal = 0 for pkg in pkgs: for details in pkgsDetails: if (pkg.get_id() == details.get_property("package-id")): resultDetails.append((pkg, details)) break if (len(resultDetails) == currVal): resultDetails.append((pkg, None)) currVal = currVal + 1 return resultDetails
def execute_action(self, action, applist, filters=1): self._debug("Executing action %s for %s" % (action, applist)) self.progress = 0 self.installer = packagekit.Client() self.count = len(applist) self.result['status'] = {'status': -1, 'msg': ''} self.result['data'] = [] processedPkg = [] #1.- If the app doesn't exist cancel the action for app_info in applist: if app_info['package'] not in processedPkg: processedPkg.append(app_info['package']) if action == 'remove': filters = 2 app = self._resolve_App(app_info['package'], filters) if app: if action == 'install': self._install_App(app) self.result['data'].append( {'package': app_info['package']}) if action == 'remove': self._remove_App(app) self.result['data'].append( {'package': app_info['package']}) if action == 'pkginfo': res = self._get_info(app_info, app) self.result['data'].append(res) if action == 'policy': self._set_status(0) self.result['data'].append({'id': app.get_id()}) self.progress = self.progress + (self.partial_progress / self.count) self.progress = 100 return (self.result)
def run(self): """run the dialog, and if reload was pressed run cache update""" res = self.dialog.run() self.dialog.hide() if res == Gtk.ResponseType.APPLY: self._pktask = packagekit.Task() self._pdia = ProgressDialog(self.parent) self._loop = GObject.MainLoop() self._pdia.show_all() self.parent.set_sensitive(False) try: self._pktask.refresh_cache_async( False, # force None, # GCancellable self.on_pktask_progress, (None, ), # user data self.on_pktask_finish, (None, )) except Exception as e: print("Error while requesting cache refresh: {}".format(e)) self._loop.run() self._pdia.hide() self.parent.set_sensitive(True) return res
def install_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None): pkgnames = [app.pkgname for app in apps] appnames = [app.appname for app in apps] # keep track of pkg, app and icon for setting them as meta self.new_pkgname = pkgnames[0] self.new_appname = appnames[0] self.new_iconname = iconnames[0] # temporary hack pkgnames = self._fix_pkgnames(pkgnames) LOG.debug("Installing multiple packages: " + str(pkgnames)) task = packagekit.Task() task.install_packages_async( pkgnames, None, # cancellable self._on_progress_changed, None, # progress data self._on_install_ready, # GAsyncReadyCallback task # ready data ) self.emit("transaction-started", pkgnames[0], appnames[0], 0, TransactionTypes.INSTALL)
def __init__(self): super(PackagekitInfo, self).__init__() self.client = packagekit.Client() self.client.set_locale(make_locale_string()) self._cache = {} # temporary hack for decent testing self._notfound_cache = [] self._repocache = {} self.distro = get_distro()
def __init__(self): super(PackagekitTransactionsWatcher, self).__init__() self.client = packagekit.Client() bus = dbus.SystemBus() proxy = bus.get_object('org.freedesktop.PackageKit', '/org/freedesktop/PackageKit') daemon = dbus.Interface(proxy, 'org.freedesktop.PackageKit') daemon.connect_to_signal("TransactionListChanged", self._on_transactions_changed) queued = daemon.GetTransactionList() self._on_transactions_changed(queued)
def _install(self): """Run a PackageKit transaction to install given packages.""" package_ids = [ packages_resolved[package_name].get_id() for package_name in self.package_names ] client = packagekit.Client() client.set_interactive(False) client.install_packages(packagekit.TransactionFlagEnum.ONLY_TRUSTED, package_ids + [None], None, self.progress_callback, self)
def __init__(self): super(PackagekitInfo, self).__init__() self.pkclient = packagekit.Client() self.pkclient.set_locale(make_locale_string()) self._cache_pkg_filter_none = {} # temporary hack for decent testing self._cache_pkg_filter_newest = {} # temporary hack for decent testing self._cache_details = {} # temporary hack for decent testing self._notfound_cache_pkg = [] self._repocache = {} self._ready = False self.distro = get_distro() self._pkgs_cache = {}
def on_driver_changes_apply(self, button): self.pk_task = packagekit.Task() installs = [] removals = [] for pkg in self.driver_changes: if pkg.is_installed: removals.append(self.get_package_id(pkg.installed)) # The main NVIDIA package is only a metapackage. # We need to collect its dependencies, so that # we can uninstall the driver properly. if 'nvidia' in pkg.shortname: for dep in self.get_dependencies(self.apt_cache, pkg.shortname, 'nvidia'): dep_pkg = self.apt_cache[dep] if dep_pkg.is_installed: removals.append( self.get_package_id(dep_pkg.installed)) else: installs.append(self.get_package_id(pkg.candidate)) self.cancellable = Gio.Cancellable() try: if removals: installs_pending = False if installs: installs_pending = True self.pk_task.remove_packages_async( removals, False, # allow deps True, # autoremove self.cancellable, # cancellable self.on_driver_changes_progress, (None, ), # progress data self.on_driver_changes_finish, # callback ready installs_pending # callback data ) if installs: self.pk_task.install_packages_async( installs, self.cancellable, # cancellable self.on_driver_changes_progress, (None, ), # progress data self.on_driver_changes_finish, # GAsyncReadyCallback False # ready data ) self.button_driver_revert.set_sensitive(False) self.button_driver_apply.set_sensitive(False) self.scrolled_window_drivers.set_sensitive(False) except Exception as e: print("Warning: install not completed successfully: {}".format(e))
def __init__(self, use_cache=True): self._use_cache = use_cache self._cache = None self._update_callback = None self._client = PackageKitGlib.Client() self._client.get_old_transactions_async( 0, None, # cancellable lambda *args, **kwargs: None, None, # progress callback self._transactions_received, None)
def __init__(self): GObject.GObject.__init__(self) InstallBackend.__init__(self) # transaction details for setting as meta self.new_pkgname, self.new_appname, self.new_iconname = '', '', '' # this is public exposed self.pending_transactions = {} self.client = packagekit.Client() self.pkginfo = get_pkg_info() self.pkginfo.open() self._transactions_watcher = PackagekitTransactionsWatcher() self._transactions_watcher.connect('lowlevel-transactions-changed', self._on_lowlevel_transactions_changed)
def _get_package_details(self, packageid, cache=USE_CACHE): LOG.debug("package_details %s", packageid) #, self._cache.keys() if cache and (packageid in self._cache_details.keys()): return self._cache_details[packageid] task = packagekit.Task() try: result = task.get_details_sync((packageid,), None, self._on_progress_changed, None) except GObject.GError as e: return None pkgs = result.get_details_array() if not pkgs: LOG.debug("no details found for %s", packageid) return None packageid = pkgs[0].get_property('package-id') self._cache_details[packageid] = pkgs[0] LOG.debug("returning package details for %s", packageid) return pkgs[0]
def _get_info(self, app_info, app): app_info['version'] = app.get_version() app_info['arch'] = app.get_id().split(';')[2] pkTask = packagekit.Task() results = [] self._set_status(0) #Only get size and depends if we don't have the data if not app_info['size']: app_info_pool = pool() threads = [] th = threading.Thread(target=self._th_get_details, args=(pkTask, app_info_pool, app)) threads.append(th) th.start() #Get depends disabled per time-costing #th=threading.Thread(target=self._th_get_depends, args = (pkTask,app_info_pool,app)) #threads.append(th) #th.start() for thread in threads: try: thread.join() except: pass while app_info_pool.qsize(): data = app_info_pool.get() app_info.update(data) #Get status try: info = app.get_info() state = info.to_string(info) if state != app_info['state'] and state != 'available' and app_info[ 'state'] == 'installed': app_info['updatable'] = 1 else: app_info['state'] = state self._debug("State: %s" % state) except Exception as e: self._debug("State: not available (%s)" % e) pass #self._debug("INFO: %s"%app_info) return (app_info)
def main(args): if len(args) < 2: print 'Usage: %s [search|resolve] ' % args[0] return -1 client = packagekit.Client() if args[1] == 'search': if len(args) < 3: print "Nothing to search" return -1 result = client.search_names(0, [ args[2], ], None, progress_cb, None) pkgs = result.get_package_array() for p in pkgs: print p.get_name() elif args[1] == 'install': client.install_packages(False, [ args[2], ], None, progress_cb, None) elif args[1] == 'remove': client.remove_packages( [ args[2], ], False, # allow_deps False, # autoremove None, # cancelable progress_cb, None) elif args[1] == 'resolve': result = client.resolve(0, (args[2], ), None, progress_cb, None) pkgs = result.get_package_array() for p in pkgs: print "*", p.get_name(), p.get_version() else: print "Unknown command: ", args[1]
def _fill_package_cache_from_cache(self, force = False): """Build a package-cache, to allow fast searching of packages.""" # we never want source packages pfilter = 1 << packagekit.FilterEnum.NOT_SOURCE #if only_newest: #pfilter |= 1 << packagekit.FilterEnum.NOT_INSTALLED if force or not self._pkgs_cache: self_ready = False self._pkgs_cache = {} """ Use PackageKit cache to make loading the package cache faster. To get fresh data, we need to run _update_package_cache later. """ fp = gio.File.new_for_path("/var/lib/PackageKit/system.package-list") if fp.query_exists(None): pksack = packagekit.PackageSack() pksack.add_packages_from_file (fp) array = pksack.get_array() for pkg in array: self._add_package_to_cache(pkg) if self._pkgs_cache: self._ready = True
def get_role_description(self, role=None): role = role if role is not None else self._trans.get_property('role') return self.meta_data.get('sc_appname', packagekit.role_enum_to_string(role))
def get_section(self, pkgname): # FIXME: things are fuzzy here - group-section association p = self._get_one_package(pkgname) if p: return packagekit.group_enum_to_string(p.get_property('group'))
def get_status_description(self, status=None): if status is None: status = self._trans.get_property('status') return packagekit.info_enum_to_localised_present(status)
def __init__(self): super(PackagekitInfo, self).__init__() self.client = packagekit.Client() self._cache = {} # temporary hack for decent testing self._notfound_cache = [] self.distro = get_distro()
def role_enum_to_localised_present (role): return packagekit.role_enum_to_localised_present(role)
if node.nodeType == node.TEXT_NODE: rc.append(node.data) return ''.join(rc) #getText(point.childNodes) distversion = subprocess.Popen("lsb_release -d", stdout=subprocess.PIPE, shell=True).stdout.read() dom = xml.dom.minidom.parseString(document) groups = dom.getElementsByTagName("group") for group in groups: group_dist = group.getAttribute("distversion") if group_dist in distversion: print "MATCH!! %s" % group_dist else: print distversion print group_dist exit(1) client = packagekit.Client() result = client.search_names(0, [ "rpm", ], None, progress_cb, None) pkgs = result.get_package_array() for p in pkgs: print p.get_name()
def status_enum_to_localised_text (status): return packagekit.info_enum_to_localised_present(status)
def get_role_description(self, role=None): role = role if role is not None else self._trans.get_property('role') return self.meta_data.get('sc_appname', packagekit.role_enum_to_localised_present(role))
def get_status_description(self, status=packagekit.StatusEnum.UNKNOWN): if status is packagekit.StatusEnum.UNKNOWN: status = self._trans.get_property('status') return packagekit.info_enum_to_localised_present(status)
def __init__(self, progress_publisher=None): super().__init__(progress_publisher=progress_publisher) self.packagekit_client = PackageKitGlib.Client().new()
def get_status_description(self, status=None): status = status if status is not None else self._trans.get_property('status') return packagekit.status_enum_to_string(status)
and progress.props.package != None): sys.stderr.write("%d\n" % progress.props.percentage) sys.stderr.flush() set_debugging(True) package = sys.argv[1] repo = sys.argv[2] try: repo_gpg_id = sys.argv[3] except: repo_gpg_id = None # get PackageKit client pk = PackageKitGlib.Client() refresh_cache_needed = False # install repository key if repo_gpg_id: debugprint("Signature key supplied") debugprint("pk.install_signature") try: res = pk.install_signature(PackageKitGlib.SigTypeEnum.GPG, repo_gpg_id, '', None, progress, None) refresh_cache_needed = True debugprint("pk.install_signature succeeded") except GLib.GError: debugprint("pk.install_signature failed") sys.exit(1)
def get_status_description(self, status=packagekit.StatusEnum.UNKNOWN): if status is packagekit.StatusEnum.UNKNOWN: status = self._trans.get_property('status') return packagekit.status_enum_to_string(status) # TODO: Localize!