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=None):
if status is None:
status = self._trans.get_property('status')
return packagekit.info_enum_to_localised_present(status)
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_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):
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!
