コード例 #1
0
 def testOriginMatcherSimple(self):
     test_pkgs = set()
     for pkg in self.cache:
         if pkg.candidate and pkg.candidate.origins:
             if [l.archive for l in pkg.candidate.origins
                     if l.archive == "lucid-security"]:
                 test_pkgs.add(pkg.name)
     self.assertTrue(len(test_pkgs) > 0)
     ul = UpdateList(None, dist="lucid")
     for pkgname in test_pkgs:
         pkg = self.cache[pkgname]
         self.assertTrue(ul._is_security_update(pkg),
                         "pkg '%s' is not in lucid-security" % pkg.name)
コード例 #2
0
 def testOriginMatcherSimple(self):
     test_pkgs = set()
     for pkg in self.cache:
         if pkg.candidate and pkg.candidate.origins:
             if [l.archive for l in pkg.candidate.origins
                     if l.archive == "xenial-security"]:
                 test_pkgs.add(pkg.name)
     self.assertTrue(len(test_pkgs) > 0)
     ul = UpdateList(None, dist="xenial")
     for pkgname in test_pkgs:
         pkg = self.cache[pkgname]
         self.assertTrue(ul._is_security_update(pkg),
                         "pkg '%s' is not in xenial-security" % pkg.name)
コード例 #3
0
    def testOriginMatcherWithVersionInUpdatesAndSecurity(self):
        # empty dpkg status
        self.cache.open(apt.progress.base.OpProgress())
        
        # find test packages set
        test_pkgs = set()
        for pkg in self.cache:
            # only test on native arch
            if ":" in pkg.name:
                continue
            if pkg.candidateOrigin:
                for v in pkg.candidateOrigin:
                    if (v.archive == "lucid-updates" and
                        len(pkg._pkg.version_list) > 2):
                        test_pkgs.add(pkg.name)
        self.assert_(len(test_pkgs) > 0,
                     "no suitable test package found that has a version in both -security and -updates and where -updates is newer")

        # now test if versions in -security are detected
        ul = UpdateList(None)
        matcher = ul.initMatcher("lucid")
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assertEqual(self.cache.matchPackageOrigin(pkg, matcher),
                             matcher[("lucid-security","Ubuntu")],
                             "package '%s' from lucid-updates contains also a (not yet installed) security updates, but it is not labeled as such" % pkg.name)

        # now check if it marks the version with -update if the -security
        # version is installed
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            # FIXME: make this more inteligent (picking the versin from
            #        -security
            sec_ver = pkg._pkg.version_list[1]
            self.dpkg_status.write("Package: %s\n"
                              "Status: install ok installed\n"
                              "Installed-Size: 1\n"
                              "Version: %s\n"
                              "Description: foo\n\n"
                              % (pkg.name, sec_ver.ver_str))
            self.dpkg_status.flush()
        self.cache.open()
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assert_(pkg._pkg.current_ver != None,
                         "no package '%s' installed" % pkg.name)
            self.assertEqual(self.cache.matchPackageOrigin(pkg, matcher),
                             matcher[("lucid-updates","Ubuntu")],
                             "package '%s' (%s) from lucid-updates is labeld '%s' even though we have marked this version as installed already" % (pkg.name, pkg.candidateVersion, self.cache.matchPackageOrigin(pkg, matcher).description))
コード例 #4
0
 def fillstore(self):
     # populate the list
     self.list = UpdateList(self)
     self.list.update(self.cache)
     origin_list = sorted(self.list.pkgs,
                          key=operator.attrgetter("importance"),
                          reverse=True)
     for (i, origin) in enumerate(origin_list):
         self.checkbox_tree_updates.append(origin.description,
                                           selected=True)
         for pkg in self.list.pkgs[origin]:
             self.checkbox_tree_updates.addItem(pkg.name,
                                                (i, snackArgs['append']),
                                                pkg,
                                                selected=True)
コード例 #5
0
 def testOriginMatcherSimple(self):
     test_pkgs = set()
     for pkg in self.cache:
         if pkg.candidate and pkg.candidate.origins:
             if [l.archive for l in pkg.candidate.origins
                 if l.archive == "lucid-security"]:
                 test_pkgs.add(pkg.name)
     self.assertTrue(len(test_pkgs) > 0)
     ul = UpdateList(None)
     matcher = ul.initMatcher("lucid")
     for pkgname in test_pkgs:
         pkg = self.cache[pkgname]
         self.assertEqual(self.cache.matchPackageOrigin(pkg, matcher),
                          matcher[("lucid-security","Ubuntu")],
                          "pkg '%s' is not in lucid-security but in '%s' instead" % (pkg.name, self.cache.matchPackageOrigin(pkg, matcher).description))
コード例 #6
0
ファイル: snippet.py プロジェクト: szabo92/gistable
def apt_check():
    apt_pkg.init()
    cache = apt_pkg.Cache(apt.progress.base.OpProgress())
    depcache = apt_pkg.DepCache(cache)
    if depcache.broken_count > 0:
        raise SystemExit("Error: BrokenCount > 0")
    try:
        from UpdateManager.Core.UpdateList import UpdateList
        ul = UpdateList(None)
    except ImportError:
        ul = None
    # This mimics an upgrade but will never remove anything
    depcache.upgrade(True)
    if depcache.del_count > 0:
        # Unmark (clean) all changes from the given depcache
        depcache.init()
    depcache.upgrade()
    with apt.Cache() as aptcache:
        for pkg in cache.packages:
            if not depcache.marked_install(pkg) and \
                    not depcache.marked_upgrade(pkg):
                continue
            inst_ver = pkg.current_ver
            cand_ver = depcache.get_candidate_ver(pkg)
            if cand_ver == inst_ver:
                continue
            security = False
            phased = False
            if isSecurityUpgrade(cand_ver):
                security = True
            elif inst_ver:
                # Check for security updates that are masked by a candidate
                # version from another repo (-proposed or -updates)
                for ver in pkg.version_list:
                    if apt_pkg.version_compare(ver.ver_str, inst_ver.ver_str) \
                            > 0 and isSecurityUpgrade(ver):
                        security = True
                        break
            if ul is not None and \
                    ul._is_ignored_phased_update(aptcache[pkg.name]):
                phased = True
            yield Upgrade(
                package=pkg.name,
                installed=inst_ver.ver_str if inst_ver else None,
                candidate=cand_ver.ver_str,
                security=security,
                phased=phased,
            )
コード例 #7
0
    def fillstore(self):
	# populate the list
	self.list = UpdateList(self)
	self.list.update(self.cache)
	origin_list = self.list.pkgs.keys()
	origin_list.sort(lambda x,y: cmp(x.importance, y.importance))
	origin_list.reverse()
	for (i, origin) in enumerate(origin_list):
            self.checkbox_tree_updates.append(origin.description, selected=True)
	    for pkg in self.list.pkgs[origin]:
                self.checkbox_tree_updates.addItem(pkg.name, 
						   (i, snackArgs['append']),
						   pkg,
						   selected = True)
コード例 #8
0
 def fillstore(self):
     # populate the list
     self.list = UpdateList(self)
     self.list.update(self.cache)
     origin_list = sorted(
         self.list.pkgs, key=operator.attrgetter("importance"),
         reverse=True)
     for (i, origin) in enumerate(origin_list):
         self.checkbox_tree_updates.append(origin.description,
                                           selected=True)
         for pkg in self.list.pkgs[origin]:
             self.checkbox_tree_updates.addItem(pkg.name,
                                                (i, snackArgs['append']),
                                                pkg,
                                                selected=True)
コード例 #9
0
    def testOriginMatcherWithVersionInUpdatesAndSecurity(self):
        # empty dpkg status
        self.cache.open(apt.progress.base.OpProgress())

        # find test packages set
        test_pkgs = set()
        for pkg in self.cache:
            # only test on native arch
            if ":" in pkg.name:
                continue
            # check if the candidate origin is -updates (but not also
            # -security, often packages are available in both)
            if pkg.candidate is not None:
                # ensure that the origin is not in -updates and -security
                is_in_updates = False
                is_in_security = False
                had_security = False
                for v in pkg.candidate.origins:
                    # test if the package is not in both updates and security
                    if v.archive == "xenial-updates":
                        is_in_updates = True
                    elif v.archive == "xenial-security":
                        is_in_security = True
                # ensure that the package actually has any version in -security
                for v in pkg.versions:
                    for (pkgfile, _unused) in v._cand.file_list:
                        o = apt.package.Origin(pkg, pkgfile)
                        if o.archive == "xenial-security":
                            had_security = True
                            break
                if (is_in_updates and
                        not is_in_security and
                        had_security and
                        len(pkg._pkg.version_list) > 2):
                    test_pkgs.add(pkg.name)
        self.assertTrue(len(test_pkgs) > 0,
                        "no suitable test package found that has a version in "
                        "both -security and -updates and where -updates is "
                        "newer")

        # now test if versions in -security are detected
        ul = UpdateList(None, dist="xenial")
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assertTrue(ul._is_security_update(pkg),
                            "package '%s' from xenial-updates contains also a "
                            "(not yet installed) security update, but it is "
                            "not labeled as such" % pkg.name)

        # now check if it marks the version with -update if the -security
        # version is installed
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            # FIXME: make this more inteligent (picking the version from
            #        -security
            sec_ver = pkg._pkg.version_list[1]
            self.dpkg_status.write("Package: %s\n"
                                   "Status: install ok installed\n"
                                   "Installed-Size: 1\n"
                                   "Version: %s\n"
                                   "Architecture: all\n"
                                   "Description: foo\n\n"
                                   % (pkg.name, sec_ver.ver_str))
            self.dpkg_status.flush()
        self.cache.open()
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assertIsNotNone(pkg._pkg.current_ver,
                                 "no package '%s' installed" % pkg.name)
            candidate_version = getattr(pkg.candidate, "version", None)
            self.assertFalse(ul._is_security_update(pkg),
                             "package '%s' (%s) from xenial-updates is "
                             "labelled as a security update even though we "
                             "have marked this version as installed already" %
                             (pkg.name, candidate_version))
コード例 #10
0
ファイル: apt_check.py プロジェクト: pombreda/OnionScraper
def run(options=None):

    # we are run in "are security updates installed automatically?"
    # question mode
    if options.security_updates_unattended:
        res = apt_pkg.config.find_i("APT::Periodic::Unattended-Upgrade", 0)
        #print(res)
        sys.exit(res)

    # get caches
    try:
        cache = apt_pkg.Cache(apt.progress.base.OpProgress())
    except SystemError as e:
        sys.stderr.write("E: "+ _("Error: Opening the cache (%s)") % e)
        sys.exit(-1)
    depcache = apt_pkg.DepCache(cache)

    # read the synaptic pins too
    if os.path.exists(SYNAPTIC_PINFILE):
        depcache.read_pinfile(SYNAPTIC_PINFILE)
        depcache.init()

    if depcache.broken_count > 0:
        sys.stderr.write("E: "+ _("Error: BrokenCount > 0"))
        sys.exit(-1)

    # do the upgrade (not dist-upgrade!)
    try:
        saveDistUpgrade(cache,depcache)
    except SystemError as e:
        sys.stderr.write("E: "+ _("Error: Marking the upgrade (%s)") % e)
        sys.exit(-1)

    # analyze the ugprade
    upgrades = 0
    security_updates = 0

    # we need another cache that has more pkg details
    with apt.Cache() as aptcache:
        for pkg in cache.packages:
            # skip packages that are not marked upgraded/installed
            if not (depcache.marked_install(pkg) or depcache.marked_upgrade(pkg)):
                continue
            # check if this is really a upgrade or a false positive
            # (workaround for ubuntu #7907)
            inst_ver = pkg.current_ver
            cand_ver = depcache.get_candidate_ver(pkg)
            if cand_ver == inst_ver:
                continue
            # check for security upgrades
            if isSecurityUpgrade(cand_ver):
                upgrades += 1
                security_updates += 1
                continue

            # check to see if the update is a phased one
            try:
                from UpdateManager.Core.UpdateList import UpdateList
                ul = UpdateList(None)
                ignored = ul._is_ignored_phased_update(aptcache[pkg.name])
                if ignored:
                    depcache.mark_keep(pkg)
                    continue
            except ImportError:
                pass

            upgrades = upgrades + 1	

            # now check for security updates that are masked by a 
            # canidate version from another repo (-proposed or -updates)
            for ver in pkg.version_list:
                if (inst_ver and apt_pkg.version_compare(ver.ver_str, inst_ver.ver_str) <= 0):
                    #print("skipping '%s' " % ver.VerStr)
                    continue
                if isSecurityUpgrade(ver):
                    security_updates += 1
                    break

    # print the number of upgrades
    if options and options.show_package_names:
        write_package_names(sys.stderr, cache, depcache)
    elif options and options.readable_output:
        write_human_readable_summary(sys.stdout, upgrades, security_updates)
    else:
        # print the number of regular upgrades and the number of 
        # security upgrades
        sys.stderr.write("%s;%s" % (upgrades,security_updates))

    # return the number of upgrades (if its used as a module)
    return(upgrades,security_updates)
コード例 #11
0
class UpdateManagerText(object):
    DEBUG = False

    def __init__(self, datadir):
        self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
        self.button_bar = ButtonBar(self.screen, ((_("Cancel"), "cancel"),
                                                  (_("Install"), "ok")),
                                    compact=True)
        self.textview_changes = Textbox(72, 8, _("Changelog"), True, True)
        self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
        self.checkbox_tree_updates.setCallback(self.checkbox_changed)
        self.layout = GridForm(self.screen, _("Updates"), 1, 5)
        self.layout.add(self.checkbox_tree_updates, 0, 0)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 1)
        self.layout.add(self.textview_changes, 0, 2)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 3)
        self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
        self.screen.suspend()
        if not self.DEBUG:
            apt_pkg.pkgsystem_lock()
        self.openCache()
        print(_("Building Updates List"))
        self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print(
                _("""
A normal upgrade can not be calculated, please run:
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu"""))
            sys.exit(1)
        self.screen.resume()


#    def restoreScreen(self):
#        self.screen.finish()

    def openCache(self):
        # open cache
        progress = apt.progress.text.OpProgress()
        if hasattr(self, "cache"):
            self.cache.open(progress)
            self.cache._initDepCache()
        else:
            self.cache = MyCache(progress)
            self.actiongroup = apt_pkg.ActionGroup(self.cache._depcache)
        # lock the cache
        self.cache.lock = True

    def fillstore(self):
        # populate the list
        self.list = UpdateList(self)
        self.list.update(self.cache)
        origin_list = sorted(self.list.pkgs,
                             key=operator.attrgetter("importance"),
                             reverse=True)
        for (i, origin) in enumerate(origin_list):
            self.checkbox_tree_updates.append(origin.description,
                                              selected=True)
            for pkg in self.list.pkgs[origin]:
                self.checkbox_tree_updates.addItem(pkg.name,
                                                   (i, snackArgs['append']),
                                                   pkg,
                                                   selected=True)

    def updateSelectionStates(self):
        """
        helper that goes over the cache and updates the selection
        states in the UI based on the cache
        """
        for pkg in self.cache:
            if pkg not in self.checkbox_tree_updates.item2key:
                continue
            # update based on the status
            if pkg.marked_upgrade or pkg.marked_install:
                self.checkbox_tree_updates.setEntryValue(pkg, True)
            else:
                self.checkbox_tree_updates.setEntryValue(pkg, False)
        self.updateUI()

    def updateUI(self):
        self.layout.draw()
        self.screen.refresh()

    def get_news_and_changelog(self, pkg):
        changes = ""
        name = pkg.name

        # if we don't have it, get it
        if (name not in self.cache.all_changes
                and name not in self.cache.all_news):
            self.textview_changes.setText(_("Downloading changelog"))
            lock = threading.Lock()
            lock.acquire()
            changelog_thread = threading.Thread(
                target=self.cache.get_news_and_changelog, args=(name, lock))
            changelog_thread.start()
            # this lock should never take more than 2s even with network down
            while lock.locked():
                time.sleep(0.03)

        # build changes from NEWS and changelog
        if name in self.cache.all_news:
            changes += self.cache.all_news[name]
        if name in self.cache.all_changes:
            changes += self.cache.all_changes[name]

        return changes

    def checkbox_changed(self):
        # item is either a apt.package.Package or a str (for the headers)
        pkg = self.checkbox_tree_updates.getCurrent()
        descr = ""
        if hasattr(pkg, "name"):
            need_refresh = False
            name = pkg.name
            if self.options.show_description:
                descr = getattr(pkg.candidate, "description", None)
            else:
                descr = self.get_news_and_changelog(pkg)
            # check if it is a wanted package
            selected = self.checkbox_tree_updates.getEntryValue(pkg)[1]
            marked_install_upgrade = pkg.marked_install or pkg.marked_upgrade
            if not selected and marked_install_upgrade:
                need_refresh = True
                pkg.mark_keep()
            if selected and not marked_install_upgrade:
                if not (name in self.list.held_back):
                    # FIXME: properly deal with "fromUser" here
                    need_refresh = True
                    pkg.mark_install()
            # fixup any problems
            if self.cache._depcache.broken_count:
                need_refresh = True
                Fix = apt_pkg.ProblemResolver(self.cache._depcache)
                Fix.resolve_by_keep()
            # update the list UI to reflect the cache state
            if need_refresh:
                self.updateSelectionStates()
        self.textview_changes.setText(descr)
        self.updateUI()

    def main(self, options):
        self.options = options
        res = self.layout.runOnce()
        self.screen.finish()
        button = self.button_bar.buttonPressed(res)
        if button == "ok":
            self.screen.suspend()
            res = self.cache.commit(apt.progress.text.AcquireProgress(),
                                    apt.progress.base.InstallProgress())
コード例 #12
0
    def testOriginMatcherWithVersionInUpdatesAndSecurity(self):
        # empty dpkg status
        self.cache.open(apt.progress.base.OpProgress())

        # find test packages set
        test_pkgs = set()
        for pkg in self.cache:
            # only test on native arch
            if ":" in pkg.name:
                continue
            # check if the candidate origin is -updates (but not also
            # -security, often packages are available in both)
            if pkg.candidate is not None:
                # ensure that the origin is not -updates and -security
                is_in_updates = False
                is_in_security = False
                for v in pkg.candidate.origins:
                    # test if the package is not in both updates and security
                    if v.archive == "lucid-updates":
                        is_in_updates = True
                    elif v.archive == "lucid-security":
                        is_in_security = True
                if (is_in_updates and
                        not is_in_security and
                        len(pkg._pkg.version_list) > 2):
                    test_pkgs.add(pkg.name)
        self.assertTrue(len(test_pkgs) > 0,
                        "no suitable test package found that has a version in "
                        "both -security and -updates and where -updates is "
                        "newer")

        # now test if versions in -security are detected
        ul = UpdateList(None, dist="lucid")
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assertTrue(ul._is_security_update(pkg),
                            "package '%s' from lucid-updates contains also a "
                            "(not yet installed) security updates, but it is "
                            "not labeled as such" % pkg.name)

        # now check if it marks the version with -update if the -security
        # version is installed
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            # FIXME: make this more inteligent (picking the versin from
            #        -security
            sec_ver = pkg._pkg.version_list[1]
            self.dpkg_status.write("Package: %s\n"
                                   "Status: install ok installed\n"
                                   "Installed-Size: 1\n"
                                   "Version: %s\n"
                                   "Architecture: all\n"
                                   "Description: foo\n\n"
                                   % (pkg.name, sec_ver.ver_str))
            self.dpkg_status.flush()
        self.cache.open()
        for pkgname in test_pkgs:
            pkg = self.cache[pkgname]
            self.assertIsNotNone(pkg._pkg.current_ver,
                                 "no package '%s' installed" % pkg.name)
            candidate_version = getattr(pkg.candidate, "version", None)
            self.assertFalse(ul._is_security_update(pkg),
                             "package '%s' (%s) from lucid-updates is "
                             "labelled as a security update even though we "
                             "have marked this version as installed already" %
                             (pkg.name, candidate_version))
コード例 #13
0
class UpdateManagerText(object):
    DEBUG = False

    def __init__(self, datadir):
	self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
	self.button_bar = ButtonBar(self.screen, 
				    ( (_("Cancel"), "cancel"),
				      (_("Install"), "ok")), 
				    compact = True)
	self.textview_changes = Textbox(72, 8, "Changelog", True, True)
	self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
	self.checkbox_tree_updates.setCallback(self.checkbox_changed)
	self.layout = GridForm(self.screen, "Updates", 1, 5)
	self.layout.add(self.checkbox_tree_updates, 0, 0)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 1)
	self.layout.add(self.textview_changes, 0, 2)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 3)
	self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
	self.screen.suspend()
	if not self.DEBUG:
            apt_pkg.PkgSystemLock()
	self.openCache()
	print _("Building Updates List")
	self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print _("""
A normal upgrade can not be calculated, please run: 
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu""")
            sys.exit(1)
	self.screen.resume()

#    def restoreScreen(self):
#        self.screen.finish()
    
    def openCache(self):
	# open cache
        progress = apt.progress.OpTextProgress()
        if hasattr(self, "cache"):
            self.cache.open(progress)
            self.cache._initDepCache()
        else:
            self.cache = MyCache(progress)
	    self.actiongroup = apt_pkg.GetPkgActionGroup(self.cache._depcache)
	# lock the cache
        self.cache.lock = True
	    
    def fillstore(self):
	# populate the list
	self.list = UpdateList(self)
	self.list.update(self.cache)
	origin_list = self.list.pkgs.keys()
	origin_list.sort(lambda x,y: cmp(x.importance, y.importance))
	origin_list.reverse()
	for (i, origin) in enumerate(origin_list):
            self.checkbox_tree_updates.append(origin.description, selected=True)
	    for pkg in self.list.pkgs[origin]:
                self.checkbox_tree_updates.addItem(pkg.name, 
						   (i, snackArgs['append']),
						   pkg,
						   selected = True)

    def updateSelectionStates(self):
        """ 
        helper that goes over the cache and updates the selection 
        states in the UI based on the cache
        """
        for pkg in self.cache:
            if not self.checkbox_tree_updates.item2key.has_key(pkg):
                continue
            # update based on the status
            if pkg.markedUpgrade or pkg.markedInstall:
                self.checkbox_tree_updates.setEntryValue(pkg, True)
            else:
                self.checkbox_tree_updates.setEntryValue(pkg, False)
        self.updateUI()

    def updateUI(self):
        self.layout.draw()
        self.screen.refresh()
        
    def get_news_and_changelog(self, pkg):
        changes = ""
	name = pkg.name
        
        # if we don't have it, get it
        if (not self.cache.all_changes.has_key(name) and
            not self.cache.all_news.has_key(name)):
            self.textview_changes.setText(_("Downloading changelog"))
            lock = thread.allocate_lock()
            lock.acquire()
            thread.start_new_thread(self.cache.get_news_and_changelog,(name,lock))
            # this lock should never take more than 2s even with network down
            while lock.locked():
                time.sleep(0.03)

        # build changes from NEWS and changelog
        if self.cache.all_news.has_key(name):
            changes += self.cache.all_news[name]
        if self.cache.all_changes.has_key(name):
            changes += self.cache.all_changes[name]

	return changes

    def checkbox_changed(self):
        # item is either a apt.package.Package or a str (for the headers)
	pkg = self.checkbox_tree_updates.getCurrent()
	descr = ""
	if hasattr(pkg, "name"):
                need_refresh = False
		name = pkg.name
                if self.options.show_description:
                    descr = pkg.description
                else:
                    descr = self.get_news_and_changelog(pkg)
		# check if it is a wanted package
		selected = self.checkbox_tree_updates.getEntryValue(pkg)[1]
                marked_install_upgrade = pkg.markedInstall or pkg.markedUpgrade
		if not selected and marked_install_upgrade:
                    need_refresh = True
                    pkg.markKeep()
                if selected and not marked_install_upgrade:
                    if not (name in self.list.held_back):
                        # FIXME: properly deal with "fromUser" here
                        need_refresh = True
                        pkg.markInstall()
                # fixup any problems
                if self.cache._depcache.BrokenCount:
                    need_refresh = True
                    Fix = apt_pkg.GetPkgProblemResolver(self.cache._depcache)
                    Fix.ResolveByKeep()
                # update the list UI to reflect the cache state
                if need_refresh:
                    self.updateSelectionStates()
	self.textview_changes.setText(descr)
	self.updateUI()

    def main(self, options):
        self.options = options
        res = self.layout.runOnce()
	self.screen.finish()
	button = self.button_bar.buttonPressed(res)
	if button == "ok":
		self.screen.suspend()
		res = self.cache.commit(apt.progress.text.AcquireProgress(),
					apt.progress.base.InstallProgress())
コード例 #14
0
def run(options=None):

    # we are run in "are security updates installed automatically?"
    # question mode
    if options.security_updates_unattended:
        res = apt_pkg.config.find_i("APT::Periodic::Unattended-Upgrade", 0)
        #print(res)
        sys.exit(res)

    # get caches
    try:
        cache = apt_pkg.Cache(apt.progress.base.OpProgress())
    except SystemError as e:
        sys.stderr.write("E: "+ _("Error: Opening the cache (%s)") % e)
        sys.exit(-1)
    depcache = apt_pkg.DepCache(cache)

    # read the synaptic pins too
    if os.path.exists(SYNAPTIC_PINFILE):
        depcache.read_pinfile(SYNAPTIC_PINFILE)
        depcache.init()

    if depcache.broken_count > 0:
        sys.stderr.write("E: "+ _("Error: BrokenCount > 0"))
        sys.exit(-1)

    # do the upgrade (not dist-upgrade!)
    try:
        saveDistUpgrade(cache,depcache)
    except SystemError as e:
        sys.stderr.write("E: "+ _("Error: Marking the upgrade (%s)") % e)
        sys.exit(-1)

    # analyze the ugprade
    upgrades = 0
    security_updates = 0

    # we need another cache that has more pkg details
    with apt.Cache() as aptcache:
        for pkg in cache.packages:
            # skip packages that are not marked upgraded/installed
            if not (depcache.marked_install(pkg) or depcache.marked_upgrade(pkg)):
                continue
            # check if this is really a upgrade or a false positive
            # (workaround for ubuntu #7907)
            inst_ver = pkg.current_ver
            cand_ver = depcache.get_candidate_ver(pkg)
            if cand_ver == inst_ver:
                continue
            # check for security upgrades
            if isSecurityUpgrade(cand_ver):
                upgrades += 1
                security_updates += 1
                continue

            # check to see if the update is a phased one
            try:
                from UpdateManager.Core.UpdateList import UpdateList
                ul = UpdateList(None)
                ignored = ul._is_ignored_phased_update(aptcache[pkg.name])
                if ignored:
                    depcache.mark_keep(pkg)
                    continue
            except ImportError:
                pass

            upgrades = upgrades + 1

            # now check for security updates that are masked by a
            # canidate version from another repo (-proposed or -updates)
            for ver in pkg.version_list:
                if (inst_ver and apt_pkg.version_compare(ver.ver_str, inst_ver.ver_str) <= 0):
                    #print("skipping '%s' " % ver.VerStr)
                    continue
                if isSecurityUpgrade(ver):
                    security_updates += 1
                    break

    # print the number of upgrades
    if options and options.show_package_names:
        write_package_names(sys.stderr, cache, depcache)
    elif options and options.readable_output:
        write_human_readable_summary(sys.stdout, upgrades, security_updates)
    else:
        # print the number of regular upgrades and the number of
        # security upgrades
        sys.stderr.write("%s;%s" % (upgrades, security_updates))

    # return the number of upgrades (if its used as a module)
    return(upgrades, security_updates)