name : SoftwareProperties.py # software-properties backend # # Copyright (c) 2004-2018 Canonical Ltd. # 2004-2005 Michiel Sikkes # # Author: Michiel Sikkes <michiel@eyesopened.nl> # Michael Vogt <mvo@debian.org> # Sebastian Heinlein <glatzor@ubuntu.com> # Andrea Azzarone <andrea.azzarone@canonical.com> # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA import apt_pkg import copy from hashlib import md5 import re import os import glob import shutil import threading import atexit import tempfile import pathlib try: from string import maketrans except ImportError: maketrans = str.maketrans import stat try: import queue except ImportError: import Queue as queue from tempfile import NamedTemporaryFile from xml.sax.saxutils import escape try: from configparser import ConfigParser except ImportError: from ConfigParser import ConfigParser from gettext import gettext as _ import aptsources import aptsources.distro import softwareproperties from .AptAuth import AptAuth from aptsources.sourceslist import (SourcesList, SourceEntry, Deb822SourceEntry) from softwareproperties.shortcuthandler import InvalidShortcutException from softwareproperties.shortcuts import shortcut_handler from gi.repository import Gio class SoftwareProperties(object): # directory containing channels CHANNEL_PATH="/usr/share/app-install/channels/" # release upgrades policy RELEASE_UPGRADES_CONF = "/etc/update-manager/release-upgrades" #RELEASE_UPGRADES_CONF = "/tmp/release-upgrades" ( RELEASE_UPGRADES_NORMAL, RELEASE_UPGRADES_LTS, RELEASE_UPGRADES_NEVER ) = list(range(3)) release_upgrades_policy_map = { RELEASE_UPGRADES_NORMAL : 'normal', RELEASE_UPGRADES_LTS : 'lts', RELEASE_UPGRADES_NEVER : 'never', } def __init__(self, datadir=None, options=None, rootdir="/", deb822=False): """ Provides the core functionality to configure the used software repositories, the corresponding authentication keys and update automation """ self.popconfile = rootdir+"/etc/popularity-contest.conf" self.rootdir = rootdir if rootdir != "/": apt_pkg.config.set("Dir", rootdir) # FIXME: some saner way is needed here if datadir == None: datadir = "/usr/share/software-properties/" self.options = options self.datadir = datadir self.sourceslist = SourcesList(deb822=deb822) self.distro = aptsources.distro.get_distro() self.seen_server = [] self.modified_sourceslist = False self.reload_sourceslist() self.backup_sourceslist() self.backup_apt_conf() # FIXME: we need to store this value in a config option #self.custom_mirrors = ["http://adasdwww.de/ubuntu"] self.custom_mirrors= [] # Queue to push/pop results from threads self.myqueue = queue.Queue() # apt-key stuff self.apt_key = AptAuth(rootdir=rootdir) self.cancellable = Gio.Cancellable() atexit.register(self.wait_for_threads) def wait_for_threads(self): " wait for all running threads (PPA key fetchers) to exit " for t in threading.enumerate(): if t.ident != threading.current_thread().ident: t.join() def backup_apt_conf(self): """Backup all apt configuration options""" self.apt_conf_backup = {} for option in softwareproperties.CONF_MAP.keys(): value = apt_pkg.config.find_i(softwareproperties.CONF_MAP[option]) self.apt_conf_backup[option] = value def restore_apt_conf(self): """Restore the stored apt configuration""" for option in self.apt_conf_backup.keys(): apt_pkg.config.set(softwareproperties.CONF_MAP[option], str(self.apt_conf_backup[option])) self.write_config() def get_update_automation_level(self): """ Parse the apt cron configuration. Try to fit a predefined use case and return it. Special case: if the user made a custom configurtation, that we cannot represent it will return None """ if apt_pkg.config.find_i(softwareproperties.CONF_MAP["autoupdate"]) > 0: # Autodownload if apt_pkg.config.find_i(softwareproperties.CONF_MAP["unattended"]) == 1\ and os.path.exists("/usr/bin/unattended-upgrade"): return softwareproperties.UPDATE_INST_SEC elif apt_pkg.config.find_i(softwareproperties.CONF_MAP["autodownload"]) == 1 and \ apt_pkg.config.find_i(softwareproperties.CONF_MAP["unattended"]) == 0: return softwareproperties.UPDATE_DOWNLOAD elif apt_pkg.config.find_i(softwareproperties.CONF_MAP["unattended"]) == 0 and \ apt_pkg.config.find_i(softwareproperties.CONF_MAP["autodownload"]) == 0: return softwareproperties.UPDATE_NOTIFY else: return None elif apt_pkg.config.find_i(softwareproperties.CONF_MAP["unattended"]) == 0 and \ apt_pkg.config.find_i(softwareproperties.CONF_MAP["autodownload"]) == 0: return softwareproperties.UPDATE_MANUAL else: return None def set_update_automation_level(self, state): """ Set the apt periodic configurtation to the selected update automation level. To synchronize the cache update and the actual upgrading function, the upgrade function, e.g. unattended, will run every day, if enabled. """ if state == softwareproperties.UPDATE_INST_SEC: apt_pkg.config.set(softwareproperties.CONF_MAP["unattended"], str(1)) apt_pkg.config.set(softwareproperties.CONF_MAP["autodownload"], str(1)) elif state == softwareproperties.UPDATE_DOWNLOAD: apt_pkg.config.set(softwareproperties.CONF_MAP["autodownload"], str(1)) apt_pkg.config.set(softwareproperties.CONF_MAP["unattended"], str(0)) elif state == softwareproperties.UPDATE_NOTIFY: apt_pkg.config.set(softwareproperties.CONF_MAP["autodownload"], str(0)) apt_pkg.config.set(softwareproperties.CONF_MAP["unattended"], str(0)) else: apt_pkg.config.set(softwareproperties.CONF_MAP["autoupdate"], str(0)) apt_pkg.config.set(softwareproperties.CONF_MAP["unattended"], str(0)) apt_pkg.config.set(softwareproperties.CONF_MAP["autodownload"], str(0)) self.set_modified_config() def set_update_interval(self, days): """Set the interval in which we check for available updates""" # Only write the key if it has changed if not days == apt_pkg.config.find_i(softwareproperties.CONF_MAP["autoupdate"]): apt_pkg.config.set(softwareproperties.CONF_MAP["autoupdate"], str(days)) self.set_modified_config() def get_update_interval(self): """ Returns the interval of the apt periodic cron job """ return apt_pkg.config.find_i(softwareproperties.CONF_MAP["autoupdate"]) def get_release_upgrades_policy(self): """ return the release upgrade policy: RELEASE_UPGRADES_NORMAL, RELEASE_UPGRADES_LTS, RELEASE_UPGRADES_NEVER """ # default (if no option is set) is NORMAL if not os.path.exists(self.RELEASE_UPGRADES_CONF): return self.RELEASE_UPGRADES_NORMAL parser = ConfigParser() parser.read(self.RELEASE_UPGRADES_CONF) if parser.has_option("DEFAULT","Prompt"): type = parser.get("DEFAULT","Prompt").lower() for k, v in self.release_upgrades_policy_map.items(): if v == type: return k return self.RELEASE_UPGRADES_NORMAL def set_release_upgrades_policy(self, i): """ set the release upgrade policy: RELEASE_UPGRADES_NORMAL, RELEASE_UPGRADES_LTS, RELEASE_UPGRADES_NEVER """ # we are note using ConfigParser.write() as it removes comments if not os.path.exists(self.RELEASE_UPGRADES_CONF): with open(self.RELEASE_UPGRADES_CONF,"w") as f: f.write("[DEFAULT]\nPrompt=%s\n"% self.release_upgrades_policy_map[i]) return True with open(self.RELEASE_UPGRADES_CONF,"r") as f, NamedTemporaryFile(mode="w+") as out: for line in f: line = line.strip() if line.lower().startswith("prompt"): out.write("Prompt=%s\n" % self.release_upgrades_policy_map[i]) else: out.write(line+"\n") out.flush() shutil.copymode(self.RELEASE_UPGRADES_CONF, out.name) shutil.copy(out.name, self.RELEASE_UPGRADES_CONF) return True def get_popcon_participation(self): """ Will return True if the user wants to participate in the popularity contest. Otherwise it will return False. Special case: if no popcon is installed it will return False """ if os.path.exists(self.popconfile): with open(self.popconfile) as f: lines = f.read().split("\n") for line in lines: try: (key,value) = line.split("=") if key == "PARTICIPATE" and value.strip('"').lower() == "yes": return True except ValueError: continue return False def set_popcon_pariticipation(self, is_helpful): """ Enable or disable the participation in the popularity contest """ if is_helpful == True: value = "yes" else: value = "no" if os.path.exists(self.popconfile): # read the current config and replace the corresponding settings # FIXME: should we check the other values, too? with open(self.popconfile, "r") as popconfile: lines = [re.sub(r'^(PARTICIPATE=)(".+?")', '\\1"%s"' % value, line) for line in popconfile] else: # create a new popcon config file m = md5() with open("/dev/urandom", "rb") as f: m.update(f.read(1024)) id = m.hexdigest() lines = [] lines.append("MY_HOSTID=\"%s\"\n" % id) lines.append("PARTICIPATE=\"%s\"\n" % str(value)) lines.append("USE_HTTP=\"yes\"\n") with open(self.popconfile, "w") as f: f.writelines(lines) def get_source_code_state(self): """Return True if all distro componets are also available as source code. Otherwise return Flase. Special case: If the configuration cannot be represented return None""" if len(self.distro.source_code_sources) < 1: # we don't have any source code sources, so # uncheck the button self.distro.get_source_code = False return False else: # there are source code sources, so we check the button self.distro.get_source_code = True # check if there is a corresponding source code source for # every binary source. if not set the checkbutton to inconsistent templates = {} sources = [] sources.extend(self.distro.main_sources) sources.extend(self.distro.child_sources) for source in sources: if source.template in templates: for comp in source.comps: templates[source.template].add(comp) else: templates[source.template] = set(source.comps) # add fake http sources for the cdrom, since the sources # for the cdrom are only available in the internet if len(self.distro.cdrom_sources) > 0: templates[self.distro.source_template] = self.distro.cdrom_comps for source in self.distro.source_code_sources: if source.template not in templates or \ (source.template in templates and not \ (len(set(templates[source.template]) ^ set(source.comps)) == 0\ or (len(set(source.comps) ^ self.distro.enabled_comps) == 0))): self.distro.get_source_code = False return None break return True def print_source_entry(self, source): """Print the data of a source entry to the command line""" for (label, value) in [("URI:", source.uri), ("Comps:", source.comps), ("Enabled:", not source.disabled), ("Valid:", not source.invalid)]: print(" %s %s" % (label, value)) if source.template: for (label, value) in [("MatchURI:", source.template.match_uri), ("BaseURI:", source.template.base_uri)]: print(" %s %s" % (label, value)) print("\n") def massive_debug_output(self): """Print the complete sources.list""" print("START SOURCES.LIST:") for source in self.sourceslist: print(source.str()) print("END SOURCES.LIST\n") def change_main_download_server(self, server): """ change the main download server """ self.distro.default_server = server res = self.distro.change_server(server) self.set_modified_sourceslist() return res def enable_component(self, comp): """Enable a component of the distro""" self.distro.enable_component(comp) self.set_modified_sourceslist() def disable_component(self, comp): """Disable a component of the distro""" self.distro.disable_component(comp) self.set_modified_sourceslist() def _find_template_from_string(self, name): for template in self.distro.source_template.children: if template.name == name: return template def disable_child_source(self, template): """Enable a child repo of the distribution main repository""" if isinstance(template, str): template = self._find_template_from_string(template) for source in self.distro.child_sources: if source.template == template: self.sourceslist.remove(source) for source in self.distro.source_code_sources: if source.template == template: self.sourceslist.remove(source) self.set_modified_sourceslist() def enable_child_source(self, template): """Enable a child repo of the distribution main repository""" if isinstance(template, str): template = self._find_template_from_string(template) # Use the currently selected mirror only if the child source # did not override the server if template.base_uri == None: child_uri = self.distro.default_server else: child_uri = template.base_uri self.distro.add_source(uri=child_uri, dist=template.name) self.set_modified_sourceslist() def disable_source_code_sources(self): """Remove all distro source code sources""" sources = [] sources.extend(self.distro.main_sources) sources.extend(self.distro.child_sources) # remove all exisiting sources for source in self.distro.source_code_sources: self.sourceslist.remove(source) self.set_modified_sourceslist() def enable_source_code_sources(self): """Enable source code source for all distro sources""" sources = [] sources.extend(self.distro.main_sources) sources.extend(self.distro.child_sources) # remove all exisiting sources for source in self.distro.source_code_sources: self.sourceslist.remove(source) for source in sources: self.sourceslist.add("deb-src", source.uri, source.dist, source.comps, "Added by software-properties", self.sourceslist.index(source)+1, source.file, parent=source) for source in self.distro.cdrom_sources: self.sourceslist.add("deb-src", self.distro.source_template.base_uri, self.distro.source_template.name, source.comps, "Added by software-properties", self.sourceslist.index(source)+1, source.file, parent=source) self.set_modified_sourceslist() def backup_sourceslist(self): """Store a backup of the source.list in memory""" self.sourceslist_backup = [] for source in self.sourceslist.list: if isinstance(source, SourceEntry): source_bkp = SourceEntry(line=source.line,file=source.file) elif isinstance(source, Deb822SourceEntry): source_bkp = Deb822SourceEntry(section=source.line, file=source.file) else: raise TypeError(f"Unknown source: {source}") self.sourceslist_backup.append(source_bkp) def _find_source_from_string(self, line): # ensure that we have a current list, it might have been changed underneath # us self.reload_sourceslist() for source in self.sourceslist.list: if str(source) == line: return source return None def toggle_source_use(self, source): """Enable or disable the selected channel""" #FIXME cdroms need to disable the comps in the childs and sources if isinstance(source, str): source = self._find_source_from_string(source) source.disabled = not source.disabled self.set_modified_sourceslist() def replace_source_entry(self, old_entry, new_entry): # find and replace, then write for (index, entry) in enumerate(self.sourceslist.list): if str(entry) == old_entry: file = self.sourceslist.list[index].file if isinstance(entry, Deb822SourceEntry): self.sourceslist.list[index] = Deb822SourceEntry(new_entry, file) else: self.sourceslist.list[index] = SourceEntry(new_entry, file) self.set_modified_sourceslist() return True return False def revert(self): """Revert all settings to the state when software-properties was launched""" #FIXME: GPG keys are still missing self.restore_apt_conf() self.revert_sourceslist() def revert_sourceslist(self): """Restore the source list from the startup of the dialog""" self.sourceslist.list = [] for source in self.sourceslist_backup: if isinstance(source, SourceEntry): source_reset = SourceEntry(line=source.line,file=source.file) elif isinstance(source, Deb822SourceEntry): source_reset = Deb822SourceEntry(section=source.line, file=source.file) else: raise TypeError(f"Unknown source: {source}") self.sourceslist.list.append(source_reset) self.save_sourceslist() self.reload_sourceslist() def set_modified_sourceslist(self): """The sources list was changed and now needs to be saved and reloaded""" self.modified_sourceslist = True if self.options and self.options.massive_debug: self.massive_debug_output() self.save_sourceslist() self.reload_sourceslist() def set_modified_config(self): """Write the changed apt configuration to file""" self.write_config() def render_source(self, source): """Render a nice output to show the source in a treeview""" if source.template == None: if source.comment: comment = ( source.comment.replace("\n", " ").strip()[:80] + "[…]" if len(source.comment) > 80 else "" ) contents = "<b>%s</b> %s" % (escape(comment), source.dist) # Only show the components if there are more than one if len(source.comps) > 1: for c in source.comps: contents += " %s" % c if source.type in ("deb-src", "rpm-src"): contents += " %s" % _("(Source Code)") contents += "\n%s" % source.uri else: contents = "<b>%s %s</b>" % (source.uri, source.dist) for c in source.comps: contents += " %s" % c if source.type in ("deb-src", "rpm-src"): contents += " %s" % _("(Source Code)") return contents else: # try to make use of a corresponding template contents = "<b>%s</b>" % source.template.description if source.type in ("deb-src", "rpm-src"): contents += " (%s)" % _("Source Code") if source.comment: contents +=" %s" % source.comment if source.template.child == False: for comp in source.comps: if source.template.has_component(comp): # fixme: move something like this into distinfo.Template # (why not use a dictionary again?) for c in source.template.components: if c.name == comp: contents += "\n%s" % c.description else: contents += "\n%s" % comp return contents def get_comparable(self, source): """extract attributes to sort the sources""" cur_sys = 1 has_template = 1 has_comment = 1 is_source = 1 revert_numbers = maketrans("0123456789", "9876543210") if source.template: has_template = 0 desc = source.template.description if source.template.distribution == self.distro: cur_sys = 0 else: desc = "%s %s %s" % (source.uri, source.dist, source.comps) if source.comment: has_comment = 0 if source.type.find("src"): is_source = 0 return (cur_sys, has_template, has_comment, is_source, desc.translate(revert_numbers)) def get_isv_sources(self): """Return a list of sources that are not part of the distribution""" isv_sources = [] for source in self.sourceslist.list: if not source.invalid and\ (source not in self.distro.main_sources and\ source not in self.distro.cdrom_sources and\ source not in self.distro.child_sources and\ source not in self.distro.disabled_sources) and\ source not in self.distro.source_code_sources: isv_sources.append(source) return isv_sources def get_cdrom_sources(self): """Return the list of CDROM based distro sources""" return self.distro.cdrom_sources def get_comp_download_state(self, comp): """Return a tuple: the first value describes if a component is enabled in the Internet repositories. The second value describes if the first value is inconsistent.""" #FIXME: also return a correct inconsistent value return (comp.name in self.distro.download_comps, False) def get_comp_child_state(self, template): """Return a tuple: the first value describes if a component is enabled in one of the child source that matcth the given template. The second value describes if the first value is inconsistent.""" comps = [] for child in self.distro.child_sources: if child.template == template: comps.extend(child.comps) if len(comps) > 0 and \ len(self.distro.enabled_comps ^ set(comps)) == 0: # All enabled distro components are also enabled for the child source return (True, False) elif len(comps) > 0 and\ len(self.distro.enabled_comps ^ set(comps)) != 0: # A matching child source does exist but doesn't include all # enabled distro components return(False, True) else: # There is no corresponding child source at all return (False, False) def reload_sourceslist(self): self.sourceslist.refresh() self.sourceslist_visible=[] self.distro.get_sources(self.sourceslist) def write_config(self): """Write the current apt configuration to file""" # update the adept file as well if it is there conffiles = [self.rootdir+"/etc/apt/apt.conf.d/10periodic", self.rootdir+"/etc/apt/apt.conf.d/20auto-upgrades", self.rootdir+"/etc/apt/apt.conf.d/15adept-periodic-update"] # check (beforehand) if one exists, if not create one for f in conffiles: if os.path.isfile(f): break else: print("No config found, creating one") dirname = os.path.dirname(f) if not os.path.exists(dirname): pathlib.Path(dirname).mkdir(parents=True) with open(conffiles[0], "w") as f: f.write("") # ensure /etc/cron.daily/apt is executable ac = "/etc/cron.daily/apt" if os.path.exists(ac): perm = os.stat(ac)[stat.ST_MODE] if not (perm & stat.S_IXUSR): print("file '%s' not executable, fixing" % ac) os.chmod(ac, 0o755) # now update them for periodic in conffiles: # read the old content first content = [] if os.path.isfile(periodic): with open(periodic, "r") as f: content = f.readlines() cnf = apt_pkg.config.subtree("APT::Periodic") # then write a new file without the updated keys with open(periodic, "w") as f: for line in content: for key in cnf.list(): if line.find("APT::Periodic::%s" % (key)) >= 0: break else: f.write(line) # and append the updated keys for i in cnf.list(): f.write("APT::Periodic::%s \"%s\";\n" % (i, cnf.find_i(i))) def save_sourceslist(self): """Backup the existing sources.list files and write the current configuration""" self.sourceslist.backup(".save") self.sourceslist.save() def _get_channel_from_line(self, srcline): """ helper that checks if a given line is in the source list return the channel name or None if not found """ srcentry = SourceEntry(srcline) if os.path.exists(self.CHANNEL_PATH): for filename in glob.glob("%s/*.list" % self.CHANNEL_PATH): with open(filename) as f: for line in f: if line.strip().startswith("#"): continue if srcentry == SourceEntry(line): return os.path.splitext(os.path.basename(filename))[0] return None def check_and_add_key_for_channel_shortcut(self, shortcut): """ helper that adds the gpg key of the channel to the apt keyring *if* the channel is in /usr/share/app-install/channels """ srcline = shortcut.SourceEntry().line channel = self._get_channel_from_line(srcline) if channel: keyp = "%s/%s.key" % (self.CHANNEL_PATH, channel) self.add_key(keyp) return True return False def update_interface(self): " abstract interface to keep the UI alive " def expand_http_line(self, line): """ short cut - this: apt-add-repository http://packages.medibuntu.org free non-free same as apt-add-repository 'deb http://packages.medibuntu.org/ '$(lsb_release -cs)' free non-free' """ if not line.startswith("http"): return line repo = line.split()[0] try: areas = line.split(" ",1)[1] except IndexError: areas = "main" line = "deb %s %s %s" % ( repo, self.distro.codename, areas ) return line def add_source_from_line(self, line, enable_source_code=False): """ Add a source for the given line. """ try: shortcut = shortcut_handler(line.strip()) except InvalidShortcutException: return False return self.add_source_from_shortcut(shortcut, enable_source_code) def add_source_from_shortcut(self, shortcut, enable_source_code=False): """ Add a source with the given shortcut and add the signing key if the site is a known channel or the shortcut implementer adds it. """ deb_line = shortcut.SourceEntry().line file = shortcut.sourceparts_file deb_line = self.expand_http_line(deb_line) debsrc_entry_type = 'deb-src' if enable_source_code else '# deb-src' debsrc_line = debsrc_entry_type + deb_line[3:] new_deb_entry = SourceEntry(deb_line, file) new_debsrc_entry = SourceEntry(debsrc_line, file) if new_deb_entry.invalid or new_debsrc_entry.invalid: return False if not self.check_and_add_key_for_channel_shortcut(shortcut): shortcut.add_key() self.sourceslist.add(new_deb_entry.type, new_deb_entry.uri, new_deb_entry.dist, new_deb_entry.comps, comment=new_deb_entry.comment, file=new_deb_entry.file, architectures=new_deb_entry.architectures) self.sourceslist.add(debsrc_entry_type, new_debsrc_entry.uri, new_debsrc_entry.dist, new_debsrc_entry.comps, comment=new_debsrc_entry.comment, file=new_debsrc_entry.file, architectures=new_debsrc_entry.architectures) self.set_modified_sourceslist() if self.options and self.options.update: import apt cache = apt.Cache() cache.update(sources_list=new_debsrc_entry.file) return True def remove_source(self, source, remove_source_code=True): """Remove the given source""" if remove_source_code: if isinstance(source, str): # recall this method giving a SourceEntry as an argument source = self._find_source_from_string(source) self.remove_source(source, True) elif source is not None: self.remove_source(source, False) # remove the deb-src lines (enabled or not) associated to # this source entry source = copy.copy(source) source.type = 'deb-src' source.disabled = True self.remove_source(source, False) source.disabled = False self.remove_source(source, False) return # first find the source object if we got a string if isinstance(source, str): source = self._find_source_from_string(source) if source is None: return # if its a sources.list.d file and it contains only a single line # (the line that we just remove), then all references to that # file are gone and the file is not saved. we work around that # here if source.file != apt_pkg.config.find_file("Dir::Etc::sourcelist"): if source.file.endswith(".sources"): self.sourceslist.list.append(Deb822SourceEntry("", file=source.file)) else: self.sourceslist.list.append(SourceEntry("", file=source.file)) try: self.sourceslist.remove(source) except ValueError: # this exception is raised if trying to remove an entry that does # not exist. in this case we suppress the error because there's no # need to propagate it (the aim of this method is to ensure that # the given entries are not listed in the sourceslist) pass self.set_modified_sourceslist() def add_key(self, path): """Add a gnupg key to the list of trusted software vendors""" if not os.path.exists(path): return False try: res = self.apt_key.add(path) return res except: return False def add_key_from_data(self, keydata): "Add a gnupg key from a utf-8 data string (e.g. copy-n-paste)" tmp = tempfile.NamedTemporaryFile() tmp.write(keydata.encode("utf-8")) tmp.flush() return self.add_key(tmp.name) def remove_key(self, keyid): """Remove a gnupg key from the list of trusted software vendors""" try: self.apt_key.rm(keyid) return True except: return False def update_keys(self): """ Run apt-key update """ try: self.apt_key.update() return True except: return False def get_package_id(self, apt_cache, pkg): """ Return the PackageKit package id """ assert isinstance(pkg, apt_pkg.Package) cur_ver = pkg.current_ver if cur_ver: ver = cur_ver.ver_str arch = cur_ver.arch else: depcache = apt_pkg.DepCache(apt_cache) candidate = depcache.get_candidate_ver(pkg) ver = candidate.ver_str arch = candidate.arch return "%s;%s;%s;" % (pkg.name, ver, arch) @staticmethod def get_dependencies(apt_cache, package, pattern=None): """ Get the package dependencies, which can be filtered out by a pattern """ depcache = apt_pkg.DepCache(apt_cache) candidate = depcache.get_candidate_ver(package) dependencies = [] try: for dep_list in candidate.depends_list_str.get('Depends'): for dep_name, dep_ver, dep_op in dep_list: if dep_name.find(pattern) != -1: dependencies.append(apt_cache[dep_name]) except (KeyError, TypeError): return [] return dependencies if __name__ == "__main__": sp = SoftwareProperties() print(sp.get_release_upgrades_policy()) sp.set_release_upgrades_policy(0)