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 _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 __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 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 __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 _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(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 __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 __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 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]
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 __init__(self, progress_publisher=None):
super().__init__(progress_publisher=progress_publisher)
self.packagekit_client = PackageKitGlib.Client().new()
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()
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()
