home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / UpdateManager / UpdateManager.py < prev    next >
Encoding:
Python Source  |  2006-08-24  |  34.4 KB  |  955 lines
  1. # UpdateManager.py 
  2. #  
  3. #  Copyright (c) 2004-2006 Canonical
  4. #                2004 Michiel Sikkes
  5. #                2005 Martin Willemoes Hansen
  6. #  
  7. #  Author: Michiel Sikkes <michiel@eyesopened.nl>
  8. #          Michael Vogt <mvo@debian.org>
  9. #          Martin Willemoes Hansen <mwh@sysrq.dk>
  10. # 
  11. #  This program is free software; you can redistribute it and/or 
  12. #  modify it under the terms of the GNU General Public License as 
  13. #  published by the Free Software Foundation; either version 2 of the
  14. #  License, or (at your option) any later version.
  15. # 
  16. #  This program is distributed in the hope that it will be useful,
  17. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. #  GNU General Public License for more details.
  20. # 
  21. #  You should have received a copy of the GNU General Public License
  22. #  along with this program; if not, write to the Free Software
  23. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  24. #  USA
  25.  
  26. import pygtk
  27. pygtk.require('2.0')
  28. import gtk
  29. import gtk.gdk
  30. import gtk.glade
  31. try:
  32.     import gconf
  33. except:
  34.     import fakegconf as gconf
  35. import gobject
  36. import apt
  37. import apt_pkg
  38. import gettext
  39. import copy
  40. import string
  41. import sys
  42. import os
  43. import os.path
  44. import urllib2
  45. import re
  46. import locale
  47. import tempfile
  48. import pango
  49. import subprocess
  50. import pwd
  51. import time
  52. import thread
  53. import xml.sax.saxutils
  54. from Common.HelpViewer import HelpViewer
  55.  
  56. import dbus
  57. import dbus.service
  58. import dbus.glib
  59.  
  60. from gettext import gettext as _
  61.  
  62. from Common.utils import *
  63. from Common.SimpleGladeApp import SimpleGladeApp
  64. from DistUpgradeFetcher import DistUpgradeFetcher
  65. import GtkProgress
  66.  
  67. from MetaRelease import Dist, MetaRelease
  68.  
  69. #import pdb
  70.  
  71. # FIXME:
  72. # - kill "all_changes" and move the changes into the "Update" class
  73.  
  74. # list constants
  75. (LIST_INSTALL, LIST_CONTENTS, LIST_NAME, LIST_PKG) = range(4)
  76.  
  77. # actions for "invoke_manager"
  78. (INSTALL, UPDATE) = range(2)
  79.  
  80. SYNAPTIC_PINFILE = "/var/lib/synaptic/preferences"
  81.  
  82. CHANGELOGS_URI="http://changelogs.ubuntu.com/changelogs/pool/%s/%s/%s/%s_%s/changelog"
  83.  
  84.  
  85. class MyCache(apt.Cache):
  86.     def __init__(self, progress):
  87.         apt.Cache.__init__(self, progress)
  88.         self._initDepCache()
  89.         assert self._depcache.BrokenCount == 0 and self._depcache.DelCount == 0
  90.         self.all_changes = {}
  91.     def _initDepCache(self):
  92.         #apt_pkg.Config.Set("Debug::pkgPolicy","1")
  93.         #self.depcache = apt_pkg.GetDepCache(self.cache)
  94.         #self._depcache = apt_pkg.GetDepCache(self._cache)
  95.         self._depcache.ReadPinFile()
  96.         if os.path.exists(SYNAPTIC_PINFILE):
  97.             self._depcache.ReadPinFile(SYNAPTIC_PINFILE)
  98.         self._depcache.Init()
  99.     def clean(self):
  100.         self._initDepCache()
  101.     def saveDistUpgrade(self):
  102.         """ this functions mimics a upgrade but will never remove anything """
  103.         self._depcache.Upgrade(True)
  104.         if self._depcache.DelCount > 0:
  105.             self.clean()
  106.         assert self._depcache.BrokenCount == 0 and self._depcache.DelCount == 0
  107.         self._depcache.Upgrade()
  108.  
  109.     def get_changelog(self, name, lock):
  110.         # don't touch the gui in this function, it needs to be thread-safe
  111.         pkg = self[name]
  112.  
  113.     # get the src package name
  114.         srcpkg = pkg.sourcePackageName
  115.  
  116.         # assume "main" section 
  117.         src_section = "main"
  118.         # use the section of the candidate as a starting point
  119.         section = pkg._depcache.GetCandidateVer(pkg._pkg).Section
  120.  
  121.         # get the source version, start with the binaries version
  122.         binver = pkg.candidateVersion
  123.         #print "bin: %s" % binver
  124.         try:
  125.             # try to get the source version of the pkg, this differs
  126.             # for some (e.g. libnspr4 on ubuntu)
  127.             # this feature only works if the correct deb-src are in the 
  128.             # sources.list
  129.             # otherwise we fall back to the binary version number
  130.             srcrecords = apt_pkg.GetPkgSrcRecords()
  131.             srcrec = srcrecords.Lookup(srcpkg)
  132.             if srcrec:
  133.                 srcver = srcrecords.Version
  134.                 if apt_pkg.VersionCompare(binver, srcver) > 0:
  135.                     srcver = binver
  136.                 #print "srcver: %s" % srcver
  137.                 section = srcrecords.Section
  138.                 #print "srcsect: %s" % section
  139.         except SystemError, e:
  140.             srcver = binver
  141.  
  142.         l = section.split("/")
  143.         if len(l) > 1:
  144.             src_section = l[0]
  145.  
  146.         # lib is handled special
  147.         prefix = srcpkg[0]
  148.         if srcpkg.startswith("lib"):
  149.             prefix = "lib" + srcpkg[3]
  150.  
  151.         # stip epoch
  152.         l = string.split(srcver,":")
  153.         if len(l) > 1:
  154.             srcver = "".join(l[1:])
  155.  
  156.         try:
  157.             uri = CHANGELOGS_URI % (src_section,prefix,srcpkg,srcpkg, srcver)
  158.             # print "Trying: %s " % uri
  159.             changelog = urllib2.urlopen(uri)
  160.             #print changelog.read()
  161.             # do only get the lines that are new
  162.             alllines = ""
  163.             regexp = "^%s \((.*)\)(.*)$" % (re.escape(srcpkg))
  164.  
  165.             i=0
  166.             while True:
  167.                 line = changelog.readline()
  168.                 if line == "":
  169.                     break
  170.                 match = re.match(regexp,line)
  171.                 if match:
  172.                     # FIXME: the installed version can have a epoch, but th
  173.                     #        changelog does not have one, we do a dumb
  174.                     #        approach here and just strip it away, but I'm
  175.                     #        sure that this can lead to problems
  176.                     installed = pkg.installedVersion
  177.                     if installed and ":" in installed:
  178.                         installed = installed.split(":",1)[1]
  179.                     if installed and \
  180.                         apt_pkg.VersionCompare(match.group(1),installed)<=0:
  181.                         break
  182.                 # EOF (shouldn't really happen)
  183.                 alllines = alllines + line
  184.  
  185.             # Print an error if we failed to extract a changelog
  186.             if len(alllines) == 0:
  187.                 alllines = _("The list of changes is not available")
  188.             # only write if we where not canceld
  189.             if lock.locked():
  190.                 self.all_changes[name] = [alllines, srcpkg]
  191.         except urllib2.HTTPError:
  192.             if lock.locked():
  193.                 self.all_changes[name] = [_("The list of changes is not "
  194.                                             "available yet. Please try again "
  195.                                             "later."), srcpkg]
  196.         except IOError:
  197.             if lock.locked():
  198.                 self.all_changes[name] = [_("Failed to download the list "
  199.                                             "of changes. Please "
  200.                                             "check your Internet "
  201.                                             "connection."), srcpkg]
  202.         if lock.locked():
  203.             lock.release()
  204.  
  205. class UpdateList:
  206.   class UpdateOrigin:
  207.     def __init__(self, desc, importance):
  208.       self.packages = []
  209.       self.importance = importance
  210.       self.description = desc
  211.  
  212.   def __init__(self, parent_window):
  213.     # a map of packages under their origin
  214.     pipe = os.popen("lsb_release -c -s")
  215.     dist = pipe.read().strip()
  216.     del pipe
  217.  
  218.     templates = [("%s-security" % dist, "Ubuntu", _("Important security updates"
  219.                                                     " of Ubuntu"), 10),
  220.                  ("%s-updates" % dist, "Ubuntu", _("Recommended updates of "
  221.                                                    "Ubuntu"), 9),
  222.                  ("%s-proposed" % dist, "Ubuntu", _("Proposed updates for Ubuntu"), 8),
  223.                  ("%s-backports" % dist, "Ubuntu", _("Backports of Ubuntu"), 7),
  224.                  (dist, "Ubuntu", _("Updates of Ubuntu"), 6)]
  225.  
  226.     self.pkgs = {}
  227.     self.matcher = {}
  228.     self.num_updates = 0
  229.     self.parent_window = parent_window
  230.     for (origin, archive, desc, importance) in templates:
  231.         self.matcher[(origin, archive)] = self.UpdateOrigin(desc, importance)
  232.     self.unknown_origin = self.UpdateOrigin(_("Other updates"), -1)
  233.  
  234.   def update(self, cache):
  235.     held_back = []
  236.     broken = []
  237.  
  238.     # do the upgrade
  239.     cache.saveDistUpgrade()
  240.  
  241.     # sort by origin
  242.     for pkg in cache:
  243.       if pkg.markedUpgrade or pkg.markedInstall:
  244.         # TRANSLATORS: updates from an 'unknown' origin
  245.         originstr = _("Other updates")
  246.         for aorigin in pkg.candidateOrigin:
  247.           archive = aorigin.archive
  248.           origin = aorigin.origin
  249.         if self.matcher.has_key((archive,origin)) and aorigin.trusted:
  250.           origin_node = self.matcher[(archive,origin)]
  251.         else:
  252.           origin_node = self.unknown_origin
  253.         if not self.pkgs.has_key(origin_node):
  254.           self.pkgs[origin_node] = []
  255.         self.pkgs[origin_node].append(pkg)
  256.         self.num_updates = self.num_updates + 1
  257.       elif pkg.isUpgradable:
  258.           held_back.append(pkg.name)
  259.     for l in self.pkgs.keys():
  260.       self.pkgs[l].sort(lambda x,y: cmp(x.name,y.name))
  261.  
  262.     # check if we have held-back something
  263.     if cache._depcache.KeepCount > 0:
  264.       #print "WARNING, keeping packages"
  265.       msg = ("<big><b>%s</b></big>\n\n%s" % \
  266.             (_("Cannot install all available updates"),
  267.              _("Some updates require the removal of further software. "
  268.                "Use the function \"Mark All Upgrades\" of the package manager "
  269.            "\"Synaptic\" or run \"sudo apt-get dist-upgrade\" in a "
  270.            "terminal to update your system completely.")))
  271.       dialog = gtk.MessageDialog(self.parent_window, 0, gtk.MESSAGE_INFO,
  272.                                  gtk.BUTTONS_CLOSE,"")
  273.       dialog.set_default_response(gtk.RESPONSE_OK)
  274.       dialog.set_markup(msg)
  275.       dialog.set_title("")
  276.       dialog.vbox.set_spacing(6)
  277.       label = gtk.Label(_("The following updates will be skipped:"))
  278.       label.set_alignment(0.0,0.5)
  279.       dialog.set_border_width(6)
  280.       label.show()
  281.       dialog.vbox.pack_start(label)
  282.       scroll = gtk.ScrolledWindow()
  283.       scroll.set_size_request(-1,200)
  284.       scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
  285.       text = gtk.TextView()
  286.       text.set_editable(False)
  287.       text.set_cursor_visible(False)
  288.       buf = text.get_buffer()
  289.       held_back.sort()
  290.       buf.set_text("\n".join(held_back))
  291.       scroll.add(text)
  292.       dialog.vbox.pack_start(scroll)
  293.       scroll.show_all()
  294.       dialog.run()
  295.       dialog.destroy()
  296.  
  297.  
  298. class UpdateManagerDbusControler(dbus.service.Object):
  299.     """ this is a helper to provide the UpdateManagerIFace """
  300.     def __init__(self, parent, bus_name,
  301.                  object_path='/org/freedesktop/UpdateManagerObject'):
  302.         dbus.service.Object.__init__(self, bus_name, object_path)
  303.         self.parent = parent
  304.  
  305.     @dbus.service.method('org.freedesktop.UpdateManagerIFace')
  306.     def bringToFront(self):
  307.         self.parent.window_main.present()
  308.         return True
  309.  
  310. class UpdateManager(SimpleGladeApp):
  311.  
  312.   def __init__(self, datadir):
  313.     self.setupDbus()
  314.     gtk.window_set_default_icon_name("update-manager")
  315.  
  316.     self.datadir = datadir
  317.     SimpleGladeApp.__init__(self, datadir+"glade/UpdateManager.glade",
  318.                             None, domain="update-manager")
  319.  
  320.     self.image_logo.set_from_icon_name("update-manager", gtk.ICON_SIZE_DIALOG)
  321.     self.window_main.set_sensitive(False)
  322.     self.window_main.grab_focus()
  323.     self.button_close.grab_focus()
  324.  
  325.     self.packages = []
  326.     self.dl_size = 0
  327.  
  328.     # create text view
  329.     changes_buffer = self.textview_changes.get_buffer()
  330.     changes_buffer.create_tag("versiontag", weight=pango.WEIGHT_BOLD)
  331.  
  332.     # expander
  333.     self.expander_details.connect("notify::expanded", self.activate_details)
  334.  
  335.     # useful exit stuff
  336.     self.window_main.connect("delete_event", self.close)
  337.     self.button_close.connect("clicked", lambda w: self.exit())
  338.  
  339.     # the treeview (move into it's own code!)
  340.     self.store = gtk.ListStore(gobject.TYPE_BOOLEAN, str, str, gobject.TYPE_PYOBJECT)
  341.     self.treeview_update.set_model(self.store)
  342.     self.treeview_update.set_headers_clickable(True);
  343.  
  344.     tr = gtk.CellRendererText()
  345.     tr.set_property("xpad", 6)
  346.     tr.set_property("ypad", 6)
  347.     cr = gtk.CellRendererToggle()
  348.     cr.set_property("activatable", True)
  349.     cr.set_property("xpad", 6)
  350.     cr.connect("toggled", self.toggled)
  351.  
  352.     column_install = gtk.TreeViewColumn("Install", cr)
  353.     column_install.set_cell_data_func (cr, self.install_column_view_func)
  354.     column = gtk.TreeViewColumn("Name", tr, markup=LIST_CONTENTS)
  355.     column.set_cell_data_func (tr, self.package_column_view_func)
  356.     column.set_resizable(True)
  357.     major,minor,patch = gtk.pygtk_version
  358.     if (major >= 2) and (minor >= 5):
  359.       column_install.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  360.       column_install.set_fixed_width(30)
  361.       column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  362.       column.set_fixed_width(100)
  363.       #self.treeview_update.set_fixed_height_mode(True)
  364.  
  365.     self.treeview_update.append_column(column_install)
  366.     column_install.set_visible(True)
  367.     self.treeview_update.append_column(column)
  368.     self.treeview_update.set_search_column(LIST_NAME)
  369.     self.treeview_update.connect("button-press-event", self.show_context_menu)
  370.  
  371.  
  372.     # proxy stuff
  373.     # FIXME: move this into it's own function
  374.     SYNAPTIC_CONF_FILE = "%s/.synaptic/synaptic.conf" % pwd.getpwuid(0)[5]
  375.     if os.path.exists(SYNAPTIC_CONF_FILE):
  376.       cnf = apt_pkg.newConfiguration()
  377.       apt_pkg.ReadConfigFile(cnf, SYNAPTIC_CONF_FILE)
  378.       use_proxy = cnf.FindB("Synaptic::useProxy", False)
  379.       if use_proxy:
  380.         proxy_host = cnf.Find("Synaptic::httpProxy")
  381.         proxy_port = str(cnf.FindI("Synaptic::httpProxyPort"))
  382.         if proxy_host and proxy_port:
  383.       # FIXME: set the proxy for libapt here as well (e.g. for the
  384.       #        DistUpgradeFetcher
  385.           proxy_support = urllib2.ProxyHandler({"http":"http://%s:%s" % (proxy_host, proxy_port)})
  386.           opener = urllib2.build_opener(proxy_support)
  387.           urllib2.install_opener(opener)
  388.       # install a proxy environment too
  389.       if not os.environ.has_key("http_proxy"):
  390.           os.putenv("http_proxy",
  391.                 "http://%s:%s/" % (proxy_host, proxy_port))
  392.  
  393.     # setup the help viewer and disable the help button if there
  394.     # is no viewer available
  395.     self.help_viewer = HelpViewer("update-manager")
  396.     if self.help_viewer.check() == False:
  397.         self.button_help.set_sensitive(False)
  398.  
  399.     self.gconfclient = gconf.client_get_default()
  400.     # restore state
  401.     self.restore_state()
  402.     self.window_main.show()
  403.  
  404.   def header_column_func(self, cell_layout, renderer, model, iter):
  405.     pkg = model.get_value(iter, LIST_PKG)
  406.     if pkg == None:
  407.       renderer.set_property("sensitive", False)
  408.     else:
  409.       renderer.set_property("sensitive", True)
  410.  
  411.   def install_column_view_func(self, cell_layout, renderer, model, iter):
  412.     self.header_column_func(cell_layout, renderer, model, iter)
  413.     pkg = model.get_value(iter, LIST_PKG)
  414.     to_install = model.get_value(iter, LIST_INSTALL)
  415.     renderer.set_property("active", to_install)
  416.     # hide it if we are only a header line
  417.     renderer.set_property("visible", pkg != None)
  418.       
  419.   def package_column_view_func(self, cell_layout, renderer, model, iter):
  420.     self.header_column_func(cell_layout, renderer, model, iter)
  421.       
  422.   def setupDbus(self):
  423.     """ this sets up a dbus listener if none is installed alread """
  424.     # check if there is another g-a-i already and if not setup one
  425.     # listening on dbus
  426.     try:
  427.         bus = dbus.SessionBus()
  428.     except:
  429.         print "warning: could not initiate dbus"
  430.         return
  431.     proxy_obj = bus.get_object('org.freedesktop.UpdateManager', 
  432.                                '/org/freedesktop/UpdateManagerObject')
  433.     iface = dbus.Interface(proxy_obj, 'org.freedesktop.UpdateManagerIFace')
  434.     try:
  435.         iface.bringToFront()
  436.         #print "send bringToFront"
  437.         sys.exit(0)
  438.     except dbus.DBusException, e:
  439.          print "no listening object (%s) "% e
  440.          bus_name = dbus.service.BusName('org.freedesktop.UpdateManager',bus)
  441.          self.dbusControler = UpdateManagerDbusControler(self, bus_name)
  442.  
  443.  
  444.   def on_checkbutton_reminder_toggled(self, checkbutton):
  445.     self.gconfclient.set_bool("/apps/update-manager/remind_reload",
  446.                               not checkbutton.get_active())
  447.  
  448.   def close(self, widget, data=None):
  449.     if self.window_main.get_property("sensitive") is False:
  450.         return True
  451.     else:
  452.         self.exit()
  453.  
  454.   
  455.   def set_changes_buffer(self, changes_buffer, text, name, srcpkg):
  456.     changes_buffer.set_text("")
  457.     lines = text.split("\n")
  458.     if len(lines) == 1:
  459.       changes_buffer.set_text(text)
  460.       return
  461.     
  462.     for line in lines:
  463.       end_iter = changes_buffer.get_end_iter()
  464.       version_match = re.match(r'^%s \((.*)\)(.*)\;.*$' % re.escape(srcpkg), line)
  465.       #bullet_match = re.match("^.*[\*-]", line)
  466.       author_match = re.match("^.*--.*<.*@.*>.*$", line)
  467.       if version_match:
  468.         version = version_match.group(1)
  469.     upload_archive = version_match.group(2).strip()
  470.         version_text = _("Version %s: \n") % version
  471.         changes_buffer.insert_with_tags_by_name(end_iter, version_text, "versiontag")
  472.       elif (author_match):
  473.         pass
  474.       else:
  475.         changes_buffer.insert(end_iter, line+"\n")
  476.         
  477.  
  478.   def on_treeview_update_cursor_changed(self, widget):
  479.     tuple = widget.get_cursor()
  480.     path = tuple[0]
  481.     # check if we have a path at all
  482.     if path == None:
  483.       return
  484.     model = widget.get_model()
  485.     iter = model.get_iter(path)
  486.  
  487.     # set descr
  488.     pkg = model.get_value(iter, LIST_PKG)
  489.     if pkg == None or pkg.description == None:
  490.       changes_buffer = self.textview_changes.get_buffer()
  491.       changes_buffer.set_text("")
  492.       desc_buffer = self.textview_descr.get_buffer()
  493.       desc_buffer.set_text("")
  494.       self.notebook_details.set_sensitive(False)
  495.       return
  496.     long_desc = pkg.description
  497.     self.notebook_details.set_sensitive(True)
  498.     # Skip the first line - it's a duplicate of the summary
  499.     i = long_desc.find("\n")
  500.     long_desc = long_desc[i+1:]
  501.     # do some regular expression magic on the description
  502.     # Add a newline before each bullet
  503.     p = re.compile(r'^(\s|\t)*(\*|0|-)',re.MULTILINE)
  504.     long_desc = p.sub('\n*', long_desc)
  505.     # replace all newlines by spaces
  506.     p = re.compile(r'\n', re.MULTILINE)
  507.     long_desc = p.sub(" ", long_desc)
  508.     # replace all multiple spaces by newlines
  509.     p = re.compile(r'\s\s+', re.MULTILINE)
  510.     long_desc = p.sub("\n", long_desc)
  511.  
  512.     desc_buffer = self.textview_descr.get_buffer()
  513.     desc_buffer.set_text(long_desc)
  514.  
  515.     # now do the changelog
  516.     name = model.get_value(iter, LIST_NAME)
  517.     if name == None:
  518.       return
  519.  
  520.     changes_buffer = self.textview_changes.get_buffer()
  521.     
  522.     # check if we have the changes already
  523.     if self.cache.all_changes.has_key(name):
  524.       changes = self.cache.all_changes[name]
  525.       self.set_changes_buffer(changes_buffer, changes[0], name, changes[1])
  526.     else:
  527.       if self.expander_details.get_expanded():
  528.         lock = thread.allocate_lock()
  529.         lock.acquire()
  530.         t=thread.start_new_thread(self.cache.get_changelog,(name,lock))
  531.         changes_buffer.set_text(_("Downloading the list of changes..."))
  532.         button = self.button_cancel_dl_changelog
  533.         button.show()
  534.         id = button.connect("clicked",
  535.                             lambda w,lock: lock.release(), lock)
  536.         # wait for the dl-thread
  537.         while lock.locked():
  538.           time.sleep(0.05)
  539.           while gtk.events_pending():
  540.             gtk.main_iteration()
  541.         # download finished (or canceld, or time-out)
  542.         button.hide()
  543.         button.disconnect(id);
  544.  
  545.     if self.cache.all_changes.has_key(name):
  546.       changes = self.cache.all_changes[name]
  547.       self.set_changes_buffer(changes_buffer, changes[0], name, changes[1])
  548.  
  549.   def show_context_menu(self, widget, event):
  550.     """
  551.     Show a context menu if a right click was performed on an update entry
  552.     """
  553.     if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
  554.         menu = gtk.Menu()
  555.         item_select_none = gtk.MenuItem(_("Select _None"))
  556.         item_select_none.connect("activate", self.select_none_updgrades)
  557.         menu.add(item_select_none)
  558.         if self.list.num_updates == 0 or len(self.packages) == 0:
  559.             item_select_none.set_property("sensitive", False)
  560.         item_select_all = gtk.MenuItem(_("Select _All"))
  561.         item_select_all.connect("activate", self.select_all_updgrades)
  562.         menu.add(item_select_all)
  563.         if self.list.num_updates == len(self.packages) or\
  564.            self.list.num_updates == 0:
  565.             item_select_all.set_property("sensitive", False)
  566.         menu.popup(None, None, None, 0, event.time)
  567.         menu.show_all()
  568.         return True
  569.  
  570.   def select_all_updgrades(self, widget):
  571.     """
  572.     Select all updates
  573.     """
  574.     iter = self.store.get_iter_first()
  575.     while iter != None:
  576.         pkg = self.store.get_value(iter, LIST_PKG)
  577.         if pkg != None:
  578.             self.store.set_value(iter, LIST_INSTALL, True)
  579.             self.add_update(pkg)
  580.         iter = self.store.iter_next(iter)
  581.  
  582.   def select_none_updgrades(self, widget):
  583.     """
  584.     Select none updates
  585.     """
  586.     iter = self.store.get_iter_first()
  587.     while iter != None:
  588.         pkg = self.store.get_value(iter, LIST_PKG)
  589.         if pkg != None:
  590.             self.store.set_value(iter, LIST_INSTALL, False)
  591.             self.remove_update(pkg)
  592.         iter = self.store.iter_next(iter)
  593.  
  594.   def humanize_size(self, bytes):
  595.       """
  596.       Convert a given size in bytes to a nicer better readable unit
  597.       """
  598.       if bytes == 0:
  599.           # TRANSLATORS: download size is 0
  600.           return _("None")
  601.       elif bytes < 1024:
  602.           # TRANSLATORS: download size of very small updates
  603.           return _("1 KB")
  604.       elif bytes < 1024 * 1024:
  605.           # TRANSLATORS: download size of small updates, e.g. "250 KB"
  606.           return locale.format(_("%.0f KB"), bytes/1024)
  607.       else:
  608.           # TRANSLATORS: download size of updates, e.g. "2.3 MB"
  609.           return locale.format(_("%.1f MB"), bytes / 1024 / 1024)
  610.  
  611.   def remove_update(self, pkg):
  612.     name = pkg.name
  613.     if name in self.packages:
  614.       self.packages.remove(name)
  615.       self.dl_size -= pkg.packageSize
  616.       # TRANSLATORS: b stands for Bytes
  617.       self.label_downsize.set_markup(_("Download size: %s" % \
  618.                                      self.humanize_size(self.dl_size)))
  619.       if len(self.packages) == 0:
  620.         self.button_install.set_sensitive(False)
  621.  
  622.   def add_update(self, pkg):
  623.     name = pkg.name
  624.     if name not in self.packages:
  625.       self.packages.append(name)
  626.       self.dl_size += pkg.packageSize
  627.       self.label_downsize.set_markup(_("Download size: %s" % \
  628.                                      self.humanize_size(self.dl_size)))
  629.       if len(self.packages) > 0:
  630.         self.button_install.set_sensitive(True)
  631.  
  632.   def update_count(self):
  633.       """activate or disable widgets and show dialog texts correspoding to
  634.          the number of available updates"""
  635.       if self.list.num_updates == 0:
  636.           text_header= "<big><b>"+_("Your system is up-to-date")+"</b></big>"
  637.           text_download = ""
  638.           self.notebook_details.set_sensitive(False)
  639.           self.treeview_update.set_sensitive(False)
  640.           self.button_install.set_sensitive(False)
  641.           self.label_downsize.set_text=""
  642.           self.button_close.grab_default()
  643.           self.textview_changes.get_buffer().set_text("")
  644.           self.textview_descr.get_buffer().set_text("")
  645.       else:
  646.           text_header = "<big><b>" + \
  647.                         gettext.ngettext("You can install %s update",
  648.                                          "You can install %s updates", 
  649.                                          self.list.num_updates) % \
  650.                                         self.list.num_updates + "</b></big>"
  651.           text_download = _("Download size: %s") % self.humanize_size(self.dl_size)
  652.           self.notebook_details.set_sensitive(True)
  653.           self.treeview_update.set_sensitive(True)
  654.           self.button_install.grab_default()
  655.           self.treeview_update.set_cursor(1)
  656.       self.label_header.set_markup(text_header)
  657.       self.label_downsize.set_markup(text_download)
  658.  
  659.   def activate_details(self, expander, data):
  660.     expanded = self.expander_details.get_expanded()
  661.     self.vbox_updates.set_child_packing(self.expander_details,
  662.                                         expanded,
  663.                                         True,
  664.                                         0,
  665.                                         True)
  666.     self.gconfclient.set_bool("/apps/update-manager/show_details",expanded)
  667.     if expanded:
  668.       self.on_treeview_update_cursor_changed(self.treeview_update)
  669.  
  670.   def run_synaptic(self, id, action, lock):
  671.     try:
  672.       apt_pkg.PkgSystemUnLock()
  673.     except SystemError:
  674.       pass
  675.     cmd = ["gksu", "--desktop", "/usr/share/applications/synaptic.desktop", 
  676.            "--", "/usr/sbin/synaptic", "--hide-main-window",  
  677.            "--non-interactive", "--parent-window-id", "%s" % (id) ]
  678.     if action == INSTALL:
  679.       cmd.append("--progress-str")
  680.       cmd.append("%s" % _("Please wait, this can take some time."))
  681.       cmd.append("--finish-str")
  682.       cmd.append("%s" %  _("Update is complete"))
  683.       f = tempfile.NamedTemporaryFile()
  684.       for s in self.packages:
  685.         f.write("%s\tinstall\n" % s)
  686.       cmd.append("--set-selections-file")
  687.       cmd.append("%s" % f.name)
  688.       f.flush()
  689.       subprocess.call(cmd)
  690.       f.close()
  691.     elif action == UPDATE:
  692.       cmd.append("--update-at-startup")
  693.       subprocess.call(cmd)
  694.     else:
  695.       print "run_synaptic() called with unknown action"
  696.       sys.exit(1)
  697.     lock.release()
  698.  
  699.   def on_button_reload_clicked(self, widget):
  700.     #print "on_button_reload_clicked"
  701.     self.invoke_manager(UPDATE)
  702.  
  703.   def on_button_help_clicked(self, widget):
  704.     self.help_viewer.run()
  705.  
  706.   def on_button_install_clicked(self, widget):
  707.     #print "on_button_install_clicked"
  708.     self.invoke_manager(INSTALL)
  709.  
  710.   def invoke_manager(self, action):
  711.     # check first if no other package manager is runing
  712.  
  713.     # don't display apt-listchanges, we already showed the changelog
  714.     os.environ["APT_LISTCHANGES_FRONTEND"]="none"
  715.  
  716.     # Do not suspend during the update process
  717.     (dev, cookie) = self.inhibit_sleep()
  718.  
  719.     # set window to insensitive
  720.     self.window_main.set_sensitive(False)
  721.     self.window_main.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
  722.     lock = thread.allocate_lock()
  723.     lock.acquire()
  724.     t = thread.start_new_thread(self.run_synaptic,
  725.                                 (self.window_main.window.xid,action,lock))
  726.     while lock.locked():
  727.       while gtk.events_pending():
  728.         gtk.main_iteration()
  729.       time.sleep(0.05)
  730.     while gtk.events_pending():
  731.       gtk.main_iteration()
  732.     self.fillstore()
  733.  
  734.     # Allow suspend after synaptic is finished
  735.     if cookie != False:
  736.         self.allow_sleep(dev, cookie)
  737.     self.window_main.set_sensitive(True)
  738.     self.window_main.window.set_cursor(None)
  739.  
  740.   def inhibit_sleep(self):
  741.     """Send a dbus signal to gnome-power-manager to not suspend
  742.     the system"""
  743.     try:
  744.       bus = dbus.Bus(dbus.Bus.TYPE_SESSION)
  745.       devobj = bus.get_object('org.gnome.PowerManager', 
  746.                               '/org/gnome/PowerManager')
  747.       dev = dbus.Interface(devobj, "org.gnome.PowerManager")
  748.       cookie = dev.Inhibit('UpdateManager', 'Updating system')
  749.       return (dev, cookie)
  750.     except Exception, e:
  751.       print "could not send the dbus Inhibit signal: %s" % e
  752.       return (False, False)
  753.  
  754.   def allow_sleep(self, dev, cookie):
  755.     """Send a dbus signal to gnome-power-manager to allow a suspending
  756.     the system"""
  757.     dev.UnInhibit(cookie)
  758.  
  759.   def toggled(self, renderer, path):
  760.     """ a toggle button in the listview was toggled """
  761.     iter = self.store.get_iter(path)
  762.     pkg = self.store.get_value(iter, LIST_PKG)
  763.     if pkg is None:
  764.         return
  765.     if self.store.get_value(iter, LIST_INSTALL):
  766.       self.store.set_value(iter, LIST_INSTALL, False)
  767.       self.remove_update(pkg)
  768.     else:
  769.       self.store.set_value(iter, LIST_INSTALL, True)
  770.       self.add_update(pkg)
  771.  
  772.   def on_treeview_update_row_activated(self, treeview, path, column, *args):
  773.       """
  774.       If an update row was activated (by pressing space), toggle the 
  775.       install check box
  776.       """
  777.       self.toggled(None, path)
  778.  
  779.   def exit(self):
  780.     """ exit the application, save the state """
  781.     self.save_state()
  782.     gtk.main_quit()
  783.     sys.exit(0)
  784.  
  785.   def save_state(self):
  786.     """ save the state  (window-size for now) """
  787.     (x,y) = self.window_main.get_size()
  788.     self.gconfclient.set_pair("/apps/update-manager/window_size",
  789.                               gconf.VALUE_INT, gconf.VALUE_INT, x, y)
  790.  
  791.   def restore_state(self):
  792.     """ restore the state (window-size for now) """
  793.     expanded = self.gconfclient.get_bool("/apps/update-manager/show_details")
  794.     self.expander_details.set_expanded(expanded)
  795.     self.vbox_updates.set_child_packing(self.expander_details,
  796.                                         expanded,
  797.                                         True,
  798.                                         0,
  799.                                         True)
  800.     (x,y) = self.gconfclient.get_pair("/apps/update-manager/window_size",
  801.                                       gconf.VALUE_INT, gconf.VALUE_INT)
  802.     if x > 0 and y > 0:
  803.       self.window_main.resize(x,y)
  804.  
  805.   def fillstore(self):
  806.     # use the watch cursor
  807.     self.window_main.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
  808.  
  809.     # clean most objects
  810.     self.packages = []
  811.     self.dl_size = 0
  812.     self.store.clear()
  813.     self.initCache()
  814.     self.list = UpdateList(self.window_main)
  815.  
  816.     # fill them again
  817.     self.list.update(self.cache)
  818.     if self.list.num_updates > 0:
  819.       i=0
  820.       origin_list = self.list.pkgs.keys()
  821.       origin_list.sort(lambda x,y: cmp(x.importance,y.importance))
  822.       origin_list.reverse()
  823.       for origin in origin_list:
  824.         self.store.append([False,'<b><big>%s</big></b>' % origin.description,
  825.                            origin.description, None])
  826.         for pkg in self.list.pkgs[origin]:
  827.           name = xml.sax.saxutils.escape(pkg.name)
  828.           summary = xml.sax.saxutils.escape(pkg.summary)
  829.           contents = "<b>%s</b>\n<small>%s\n" % (name, summary)
  830.           if pkg.installedVersion != None:
  831.               contents += _("From version %s to %s") % \
  832.                            (pkg.installedVersion,
  833.                             pkg.candidateVersion)
  834.           else:
  835.               contents += _("Version %s") % pkg.candidateVersion
  836.           #TRANSLATORS: the b stands for Bytes
  837.           contents += " " + _("(Size: %s)") % self.humanize_size(pkg.packageSize)
  838.           contents += "</small>"
  839.  
  840.           iter = self.store.append([True, contents, pkg.name, pkg])
  841.           self.add_update(pkg)
  842.           i = i + 1
  843.  
  844.     self.update_count()
  845.     # use the normal cursor
  846.     self.window_main.window.set_cursor(None)
  847.     return False
  848.  
  849.   def dist_no_longer_supported(self, meta_release):
  850.     msg = "<big><b>%s</b></big>\n\n%s" % \
  851.           (_("Your distribution is not supported anymore"),
  852.        _("You will not get any further security fixes or critical "
  853.              "updates. "
  854.              "Upgrade to a later version of Ubuntu Linux. See "
  855.              "http://www.ubuntu.com for more information on "
  856.              "upgrading."))
  857.     dialog = gtk.MessageDialog(self.window_main, 0, gtk.MESSAGE_WARNING,
  858.                                gtk.BUTTONS_CLOSE,"")
  859.     dialog.set_title("")
  860.     dialog.set_markup(msg)
  861.     dialog.run()
  862.     dialog.destroy()
  863.     
  864.   def on_button_dist_upgrade_clicked(self, button):
  865.       #print "on_button_dist_upgrade_clicked"
  866.       fetcher = DistUpgradeFetcher(self, self.new_dist)
  867.       fetcher.run()
  868.       
  869.   def new_dist_available(self, meta_release, upgradable_to):
  870.     self.frame_new_release.show()
  871.     self.label_new_release.set_markup(_("<b>New distribution release '%s' is available</b>") % upgradable_to.version)
  872.     self.new_dist = upgradable_to
  873.     
  874.  
  875.   # fixme: we should probably abstract away all the stuff from libapt
  876.   def initCache(self): 
  877.     # get the lock
  878.     try:
  879.         apt_pkg.PkgSystemLock()
  880.     except SystemError, e:
  881.         pass
  882.         #d = gtk.MessageDialog(parent=self.window_main,
  883.         #                      flags=gtk.DIALOG_MODAL,
  884.         #                      type=gtk.MESSAGE_ERROR,
  885.         #                      buttons=gtk.BUTTONS_CLOSE)
  886.         #d.set_markup("<big><b>%s</b></big>\n\n%s" % (
  887.         #    _("Only one software management tool is allowed to "
  888.         #      "run at the same time"),
  889.         #    _("Please close the other application e.g. 'aptitude' "
  890.         #      "or 'Synaptic' first.")))
  891.         #print "error from apt: '%s'" % e
  892.         #d.set_title("")
  893.         #res = d.run()
  894.         #d.destroy()
  895.         #sys.exit()
  896.  
  897.     try:
  898.         progress = GtkProgress.GtkOpProgress(self.dialog_cacheprogress,
  899.                                              self.progressbar_cache,
  900.                                              self.label_cache,
  901.                                              self.window_main)
  902.         self.cache = MyCache(progress)
  903.     except AssertionError:
  904.         # we assert a clean cache
  905.         msg=("<big><b>%s</b></big>\n\n%s"% \
  906.              (_("Software index is broken"),
  907.               _("It is impossible to install or remove any software. "
  908.                 "Please use the package manager \"Synaptic\" or run "
  909.         "\"sudo apt-get install -f\" in a terminal to fix "
  910.         "this issue at first.")))
  911.         dialog = gtk.MessageDialog(self.window_main,
  912.                                    0, gtk.MESSAGE_ERROR,
  913.                                    gtk.BUTTONS_CLOSE,"")
  914.         dialog.set_markup(msg)
  915.         dialog.vbox.set_spacing(6)
  916.         dialog.run()
  917.         dialog.destroy()
  918.         sys.exit(1)
  919.     else:
  920.         progress.hide()
  921.  
  922.   def check_auto_update(self):
  923.       # Check if automatic update is enabled. If not show a dialog to inform
  924.       # the user about the need of manual "reloads"
  925.       remind = self.gconfclient.get_bool("/apps/update-manager/remind_reload")
  926.       if remind == False:
  927.           return
  928.  
  929.       update_days = apt_pkg.Config.FindI("APT::Periodic::Update-Package-Lists")
  930.       if update_days < 1:
  931.           self.dialog_manual_update.set_transient_for(self.window_main)
  932.           res = self.dialog_manual_update.run()
  933.           self.dialog_manual_update.hide()
  934.           if res == gtk.RESPONSE_YES:
  935.               self.on_button_reload_clicked(None)
  936.  
  937.  
  938.   def main(self, options):
  939.     gconfclient = gconf.client_get_default() 
  940.     self.meta = MetaRelease(options.devel_release)
  941.     self.meta.connect("dist_no_longer_supported",self.dist_no_longer_supported)
  942.  
  943.     # check if we are interessted in dist-upgrade information
  944.     # (we are not by default on dapper)
  945.     if options.check_dist_upgrades or \
  946.        gconfclient.get_bool("/apps/update-manager/check_dist_upgrades"):
  947.       self.meta.connect("new_dist_available",self.new_dist_available)
  948.     
  949.     while gtk.events_pending():
  950.       gtk.main_iteration()
  951.  
  952.     self.fillstore()
  953.     self.check_auto_update()
  954.     gtk.main()
  955.