REDROOM

Navigation

Breadcrumbs

/ / lib / python3 / dist-packages / softwareproperties

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 32.46 KB

//lib/python3/dist-packages/softwareproperties/SoftwareProperties.py

Text Base64

# 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 = "%s %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 = "%s %s" % (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 = "%s" % 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)
    self.get_source_code_state()

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)

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 2 × Files: 13

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
dbus DIR	-	drwxr-xr-x	2026-01-08 12:56:30	Edit Download recursive recursive
__pycache__ DIR	-	drwxr-xr-x	2026-01-08 12:56:22	Edit Download recursive recursive
AptAuth.py	2.96 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
cloudarchive.py	5.64 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
CountryInformation.py	1.95 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
distro.py	2.15 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
MirrorTest.py	7.28 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
ppa.py	9.30 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
shortcuthandler.py	28.39 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
shortcuts.py	1.58 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
SoftwareProperties.py	32.46 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
sourceslist.py	1.88 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
sourceutils.py	2.32 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
uri.py	1.77 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive
__init__.py	1.38 KB	lrw-r--r--	2025-07-02 21:17:38	Edit Download recursive recursive