~ubuntu-core-dev/update-manager/main

# UpdatesAvailable.py

# -*- Mode: Python; indent-tabs-mode: nil; tab-width: 4; coding: utf-8 -*-

#

#  Copyright (c) 2004-2013 Canonical

#                2004 Michiel Sikkes

#                2005 Martin Willemoes Hansen

#                2010 Mohamed Amine IL Idrissi

#

#  Author: Michiel Sikkes <michiel@eyesopened.nl>

#          Michael Vogt <mvo@debian.org>

#          Martin Willemoes Hansen <mwh@sysrq.dk>

#          Mohamed Amine IL Idrissi <ilidrissiamine@gmail.com>

#          Alex Launi <alex.launi@canonical.com>

#          Michael Terry <michael.terry@canonical.com>

#          Dylan McCall <dylanmccall@ubuntu.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

from __future__ import absolute_import, print_function

import gi

gi.require_version("Gtk", "3.0")

from gi.repository import GLib

from gi.repository import Gtk

from gi.repository import Gdk

from gi.repository import GObject

from gi.repository import Gio

from gi.repository import Pango

import warnings

warnings.filterwarnings("ignore", "Accessed deprecated property",

                        DeprecationWarning)

import apt_pkg

import os

import re

import logging

import time

import threading

from gettext import gettext as _

from gettext import ngettext

from .Core.utils import humanize_size

from .Core.AlertWatcher import AlertWatcher

from .Core.UpdateList import UpdateSystemGroup

from .Dialogs import InternalDialog

from DistUpgrade.DistUpgradeCache import NotEnoughFreeSpaceError

from .ChangelogViewer import ChangelogViewer

from .UnitySupport import UnitySupport

#import pdb

# FIXME:

# - kill "all_changes" and move the changes into the "Update" class

# - screen reader does not read update toggle state

# - screen reader does not say "Downloaded" for downloaded updates

# list constants

(LIST_NAME, LIST_UPDATE_DATA, LIST_SIZE, LIST_TOGGLE_ACTIVE,

 LIST_SENSITIVE) = range(5)

# NetworkManager enums

from .Core.roam import NetworkManagerHelper

class UpdateData():

    def __init__(self, groups, group, item):

        self.groups = groups if groups else []

        self.group = group

        self.item = item

class CellAreaPackage(Gtk.CellAreaBox):

    """This CellArea lays our package cells side by side, without allocating

       width for a cell if it isn't present (like icons for header labels).

       We assume that the last cell should be expanded to fill remaining space,

       and other cells have a fixed width.

    """

    def __init__(self, indent_toplevel=False):

        Gtk.CellAreaBox.__init__(self)

        self.indent_toplevel = indent_toplevel

        self.column = None

        self.cached_cell_size = {}

    def do_foreach_alloc(self, context, widget, cell_area_in, bg_area_in,

                         callback):

        cells = []

        def gather(cell, data):

            cells.append(cell)

        self.foreach(gather, None)

        cell_is_hidden = {}

        # Record the space required by each cell

        for cell_number, cell in enumerate(cells):

            # Detect if this cell should be allocated space

            if isinstance(cell, Gtk.CellRendererPixbuf):

                gicon = cell.get_property("gicon")

                hide_cell = gicon is None

            else:

                hide_cell = False

            cell_is_hidden[cell_number] = hide_cell

            if not hide_cell and cell_number not in self.cached_cell_size:

                min_size, natural_size = cell.get_preferred_width(widget)

                self.cached_cell_size[cell_number] = natural_size

        cell_area = cell_area_in.copy()

        bg_area = bg_area_in.copy()

        spacing = self.get_property("spacing")

        cell_start = self.get_cell_start(widget)

        orig_end = cell_area.width + cell_area.x

        cur_path = self.get_current_path_string()

        depth = Gtk.TreePath.new_from_string(cur_path).get_depth()

        # And finally, start handling each cell

        extra_cell_width = 0

        cell_area.x = cell_start

        cell_area.width = 0

        last_cell_number = len(cells) - 1

        for cell_number, cell in enumerate(cells):

            is_last_cell = cell_number == last_cell_number

            cell_size = self.cached_cell_size.get(cell_number, 0)

            if cell_area.width > 0 and extra_cell_width == 0:

                cell_area.x += cell_area.width + spacing

            if cell_number == 0:

                # The first cell is affected by its depth in the tree

                if not cell_is_hidden[1] and self.indent_toplevel:

                    # if not a header, align with header rows

                    depth += 1

                if depth > 1:

                    indent = max(0, depth - 1)

                    indent_size = cell_size * indent

                    if depth == 2:

                        indent_extra = spacing

                    elif depth == 3:

                        indent_extra = spacing + 1

                    else:

                        indent_extra = spacing * indent

                    cell_area.x += indent_size + indent_extra

            if is_last_cell:

                cell_size = max(cell_size, orig_end - cell_area.x)

            if not cell_is_hidden[cell_number]:

                cell_area.width = cell_size + extra_cell_width

                extra_cell_width = 0

            else:

                cell_area.width = 0

                extra_cell_width = cell_size + spacing

            if callback(cell, cell_area.copy(), bg_area.copy()):

                return

    def do_event(self, context, widget, event, cell_area, flags):

        # This override is just to trick our parent implementation into

        # allowing clicks on toggle cells when they are where the expanders

        # usually are.  It doesn't expect that, so we expand the cell_area

        # here to be equivalent to bg_area.

        cell_start = self.get_cell_start(widget)

        cell_area.width = cell_area.width + cell_area.x - cell_start

        cell_area.x = cell_start

        return Gtk.CellAreaBox.do_event(self, context, widget, event,

                                        cell_area, flags)

    def get_cell_start(self, widget):

        if not self.column:

            return 0

        else:

            val = GObject.Value()

            val.init(int)

            widget.style_get_property("horizontal-separator", val)

            h_sep = val.get_int()

            widget.style_get_property("grid-line-width", val)

            line_width = val.get_int()

            cell_start = self.column.get_x_offset() - h_sep - line_width

            if not self.indent_toplevel:  # i.e. if no headers

                widget.style_get_property("expander-size", val)

                spacing = self.get_property("spacing")

                # Hardcode 4 because GTK+ hardcodes 4 internally

                cell_start = cell_start + val.get_int() + 4 + spacing

            return cell_start

class UpdatesAvailable(InternalDialog):

    APP_INSTALL_ICONS_PATH = "/usr/share/app-install/icons"

    def __init__(self, window_main, header=None, desc=None,

                 need_reboot=False):

        InternalDialog.__init__(self, window_main)

        self.window_main = window_main

        self.datadir = window_main.datadir

        self.cache = window_main.cache

        self.custom_header = header

        self.custom_desc = desc

        self.need_reboot = need_reboot

        content_ui_path = os.path.join(self.datadir,

                                       "gtkbuilder/UpdateManager.ui")

        self._load_ui(content_ui_path, "pane_updates_available")

        self.set_content_widget(self.pane_updates_available)

        self.dl_size = 0

        self.connected = True

        # Used for inhibiting power management

        self.sleep_cookie = None

        self.settings = Gio.Settings.new("com.ubuntu.update-manager")

        # Special icon theme for looking up app-install-data icons

        self.app_icons = Gtk.IconTheme.get_default()

        self.app_icons.append_search_path(self.APP_INSTALL_ICONS_PATH)

        # Create Unity launcher quicklist

        # FIXME: instead of passing parent we really should just send signals

        self.unity = UnitySupport(parent=self)

        # setup the help viewer and disable the help button if there

        # is no viewer available

        #self.help_viewer = HelpViewer("update-manager")

        #if self.help_viewer.check() == False:

        #    self.button_help.set_sensitive(False)

        self.add_settings_button()

        self.button_close = self.add_button(Gtk.STOCK_CANCEL,

                                            self.window_main.close)

        self.button_install = self.add_button(_("Install Now"),

                                              self.on_button_install_clicked)

        self.focus_button = self.button_install

        # create text view

        self.textview_changes = ChangelogViewer()

        self.textview_changes.show()

        self.scrolledwindow_changes.add(self.textview_changes)

        changes_buffer = self.textview_changes.get_buffer()

        changes_buffer.create_tag("versiontag", weight=Pango.Weight.BOLD)

        # the treeview (move into it's own code!)

        self.store = Gtk.TreeStore(str, GObject.TYPE_PYOBJECT, str, bool, bool)

        self.treeview_update.set_model(None)

        self.image_restart.set_from_gicon(self.get_restart_icon(),

                                          Gtk.IconSize.BUTTON)

        restart_icon_renderer = Gtk.CellRendererPixbuf()

        restart_icon_renderer.set_property("xpad", 4)

        restart_icon_renderer.set_property("ypad", 2)

        restart_icon_renderer.set_property("stock-size", Gtk.IconSize.MENU)

        restart_icon_renderer.set_property("follow-state", True)

        restart_column = Gtk.TreeViewColumn(None, restart_icon_renderer)

        restart_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)

        restart_column.set_fixed_width(20)

        self.treeview_update.append_column(restart_column)

        restart_column.set_cell_data_func(restart_icon_renderer,

                                          self.restart_icon_renderer_data_func)

        self.pkg_cell_area = CellAreaPackage(False)

        pkg_column = Gtk.TreeViewColumn.new_with_area(self.pkg_cell_area)

        self.pkg_cell_area.column = pkg_column

        pkg_column.set_title(_("Install or remove"))

        pkg_column.set_property("spacing", 4)

        pkg_column.set_expand(True)

        self.treeview_update.append_column(pkg_column)

        pkg_toggle_renderer = Gtk.CellRendererToggle()

        pkg_toggle_renderer.set_property("ypad", 2)

        pkg_toggle_renderer.connect("toggled", self.on_update_toggled)

        pkg_column.pack_start(pkg_toggle_renderer, False)

        pkg_column.add_attribute(pkg_toggle_renderer,

                                 'active', LIST_TOGGLE_ACTIVE)

        pkg_column.add_attribute(pkg_toggle_renderer,

                                 'sensitive', LIST_SENSITIVE)

        pkg_column.set_cell_data_func(pkg_toggle_renderer,

                                      self.pkg_toggle_renderer_data_func)

        pkg_icon_renderer = Gtk.CellRendererPixbuf()

        pkg_icon_renderer.set_property("ypad", 2)

        pkg_icon_renderer.set_property("stock-size", Gtk.IconSize.MENU)

        pkg_column.pack_start(pkg_icon_renderer, False)

        pkg_column.set_cell_data_func(pkg_icon_renderer,

                                      self.pkg_icon_renderer_data_func)

        pkg_label_renderer = Gtk.CellRendererText()

        pkg_label_renderer.set_property("ypad", 2)

        pkg_label_renderer.set_property("ellipsize", Pango.EllipsizeMode.END)

        pkg_column.pack_start(pkg_label_renderer, True)

        pkg_column.set_cell_data_func(pkg_label_renderer,

                                      self.pkg_label_renderer_data_func)

        size_renderer = Gtk.CellRendererText()

        size_renderer.set_property("xpad", 6)

        size_renderer.set_property("ypad", 0)

        size_renderer.set_property("xalign", 1)

        # 1.0/1.2 == PANGO.Scale.SMALL. Constant is not (yet) introspected.

        size_renderer.set_property("scale", 1.0 / 1.2)

        size_column = Gtk.TreeViewColumn(_("Download"), size_renderer,

                                         text=LIST_SIZE)

        size_column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)

        size_column.add_attribute(size_renderer,

                                  'sensitive', LIST_SENSITIVE)

        self.treeview_update.append_column(size_column)

        self.treeview_update.set_headers_visible(True)

        self.treeview_update.set_headers_clickable(False)

        self.treeview_update.set_direction(Gtk.TextDirection.LTR)

        self.treeview_update.set_fixed_height_mode(False)

        self.treeview_update.set_expander_column(pkg_column)

        self.treeview_update.set_search_column(LIST_NAME)

        self.treeview_update.connect("button-press-event",

                                     self.on_treeview_button_press)

        # init show version

        self.show_versions = self.settings.get_boolean("show-versions")

        # init summary_before_name

        self.summary_before_name = self.settings.get_boolean(

            "summary-before-name")

        # expander

        self.expander_details.set_expanded(

            self.settings.get_boolean("show-details"))

        self.expander_details.connect("activate", self.pre_activate_details)

        self.expander_details.connect("notify::expanded",

                                      self.activate_details)

        self.expander_desc.connect("notify::expanded", self.activate_desc)

        # If auto-updates are on, change cancel label

        self.notifier_settings = Gio.Settings.new("com.ubuntu.update-notifier")

        self.notifier_settings.connect(

            "changed::auto-launch",

            lambda s, p: self.update_close_button())

        self.update_close_button()

        # Alert watcher

        self.alert_watcher = AlertWatcher()

        self.alert_watcher.connect("network-alert", self._on_network_alert)

        self.alert_watcher.connect("battery-alert", self._on_battery_alert)

        self.alert_watcher.connect("network-3g-alert",

                                   self._on_network_3g_alert)

    def stop(self):

        InternalDialog.stop(self)

        self._save_state()

    def start(self):

        InternalDialog.start(self)

        self.set_update_list(self.window_main.update_list)

        self.alert_watcher.check_alert_state()

        self._restore_state()

    def is_auto_update(self):

        update_days = apt_pkg.config.find_i(

            "APT::Periodic::Update-Package-Lists")

        return update_days >= 1

    def update_close_button(self):

        if self.is_auto_update():

            self.button_close.set_label(_("_Remind Me Later"))

            self.button_close.set_use_stock(False)

            self.button_close.set_use_underline(True)

        else:

            self.button_close.set_label(Gtk.STOCK_CANCEL)

            self.button_close.set_use_stock(True)

            self.button_close.set_use_underline(False)

    def install_all_updates(self, menu, menuitem, data):

        self.select_all_upgrades(None)

        self.on_button_install_clicked()

    def pkg_requires_restart(self, pkg):

        if pkg is None or pkg.candidate is None:

            return False

        restart_condition = pkg.candidate.record.get('Restart-Required')

        return restart_condition == 'system'

    def get_restart_icon(self):

        # FIXME: Non-standard, incorrect icon name (from app category).

        # Theme support for what we want seems to be lacking.

        restart_icon_names = ['view-refresh-symbolic',

                              'system-restart',

                              'system-reboot']

        return Gio.ThemedIcon.new_from_names(restart_icon_names)

    def restart_icon_renderer_data_func(self, cell_layout, renderer, model,

                                        iter, user_data):

        data = model.get_value(iter, LIST_UPDATE_DATA)

        sensitive = model.get_value(iter, LIST_SENSITIVE)

        path = model.get_path(iter)

        renderer.set_sensitive(sensitive)

        requires_restart = False

        if data.item and data.item.pkg:

            requires_restart = self.pkg_requires_restart(data.item.pkg)

        elif data.group:

            if not self.treeview_update.row_expanded(path):

                # A package in the group requires restart

                for group_item in data.group.items:

                    if group_item.pkg and self.pkg_requires_restart(

                            group_item.pkg):

                        requires_restart = True

                        break

        if requires_restart:

            gicon = self.get_restart_icon()

        else:

            gicon = None

        renderer.set_property("gicon", gicon)

    def pkg_toggle_renderer_data_func(self, cell_layout, renderer, model,

                                      iter, user_data):

        data = model.get_value(iter, LIST_UPDATE_DATA)

        activatable = False

        inconsistent = False

        if data.item:

            activatable = data.item.pkg.name not in self.list.held_back

            inconsistent = False

            renderer.set_sensitive(data.item.sensitive)

        elif data.group:

            activatable = True

            inconsistent = data.group.selection_is_inconsistent()

        elif data.groups:

            activatable = True

            inconsistent = False

            saw_install = None

            for group in data.groups:

                for item in group.items:

                    this_install = item.is_selected()

                    if saw_install is not None and saw_install != this_install:

                        inconsistent = True

                        break

                    saw_install = this_install

                if inconsistent:

                    break

        # The "active" attribute is already set via LIST_TOGGLE_ACTIVE in the

        # tree model, so we don't set it here.

        renderer.set_property("activatable", activatable)

        renderer.set_property("inconsistent", inconsistent)

    def pkg_icon_renderer_data_func(self, cell_layout, renderer, model,

                                    iter, user_data):

        data = model.get_value(iter, LIST_UPDATE_DATA)

        gicon = None

        if data.group:

            gicon = self.get_app_install_icon(data.group.icon)

        elif data.item:

            gicon = self.get_app_install_icon(data.item.icon)

        renderer.set_property("gicon", gicon)

    def get_app_install_icon(self, icon):

        """Any application icon is coming from app-install-data's desktop

           files, which refer to icons from app-install-data's icon directory.

           So we look them up here."""

        if not isinstance(icon, Gio.ThemedIcon):

            return icon  # shouldn't happen

        info = self.app_icons.choose_icon(icon.get_names(), 16,

                                          Gtk.IconLookupFlags.FORCE_SIZE)

        if info is not None:

            return Gio.FileIcon.new(Gio.File.new_for_path(info.get_filename()))

        else:

            return icon  # Assume it's in one of the user's themes

    def pkg_label_renderer_data_func(self, cell_layout, renderer, model,

                                     iter, user_data):

        data = model.get_value(iter, LIST_UPDATE_DATA)

        sensitive = model.get_value(iter, LIST_SENSITIVE)

        name = GLib.markup_escape_text(model.get_value(iter, LIST_NAME))

        renderer.set_sensitive(sensitive)

        if data.group:

            markup = name

        elif data.item:

            markup = name

        else:  # header

            markup = "<b>%s</b>" % name

        renderer.set_property("markup", markup)

    def set_changes_buffer(self, changes_buffer, text, name, srcpkg):

        changes_buffer.set_text("")

        lines = text.split("\n")

        if len(lines) == 1:

            changes_buffer.set_text(text)

            return

        for line in lines:

            end_iter = changes_buffer.get_end_iter()

            version_match = re.match(

                r'^%s \((.*)\)(.*)\;.*$' % re.escape(srcpkg), line)

            #bullet_match = re.match("^.*[\*-]", line)

            author_match = re.match("^.*--.*<.*@.*>.*$", line)

            if version_match:

                version = version_match.group(1)

                #upload_archive = version_match.group(2).strip()

                version_text = _("Version %s: \n") % version

                changes_buffer.insert_with_tags_by_name(end_iter, version_text,

                                                        "versiontag")

            elif (author_match):

                pass

            else:

                changes_buffer.insert(end_iter, line + "\n")

    def on_treeview_update_cursor_changed(self, widget):

        path = widget.get_cursor()[0]

        # check if we have a path at all

        if path is None:

            return

        model = widget.get_model()

        iter = model.get_iter(path)

        # set descr

        data = model.get_value(iter, LIST_UPDATE_DATA)

        item = data.item

        if (item is None and data.group is not None

                and data.group.core_item is not None):

            item = data.group.core_item

        if (item is None or item.pkg is None

                or item.pkg.candidate is None

                or item.pkg.candidate.description is None):

            changes_buffer = self.textview_changes.get_buffer()

            changes_buffer.set_text("")

            desc_buffer = self.textview_descr.get_buffer()

            desc_buffer.set_text("")

            self.notebook_details.set_sensitive(False)

            return

        long_desc = item.pkg.candidate.description

        self.notebook_details.set_sensitive(True)

        # do some regular expression magic on the description

        # Add a newline before each bullet

        p = re.compile(r'^(\s|\t)*(\*|0|-)', re.MULTILINE)

        long_desc = p.sub('\n*', long_desc)

        # replace all newlines by spaces

        p = re.compile(r'\n', re.MULTILINE)

        long_desc = p.sub(" ", long_desc)

        # replace all multiple spaces by newlines

        p = re.compile(r'\s\s+', re.MULTILINE)

        long_desc = p.sub("\n", long_desc)

        long_desc = ("Package: %s\n%s" %

                     (item.pkg.name, long_desc))

        desc_buffer = self.textview_descr.get_buffer()

        desc_buffer.set_text(long_desc)

        # now do the changelog

        name = item.pkg.name

        if name is None:

            return

        changes_buffer = self.textview_changes.get_buffer()

        # check if we have the changes already and if so, display them

        # (even if currently disconnected)

        if name in self.cache.all_changes:

            changes = self.cache.all_changes[name]

            srcpkg = self.cache[name].candidate.source_name

            self.set_changes_buffer(changes_buffer, changes, name, srcpkg)

        # if not connected, do not even attempt to get the changes

        elif not self.connected:

            changes_buffer.set_text(

                _("No network connection detected, you can not download "

                  "changelog information."))

        # else, get it from the entwork

        elif self.expander_details.get_expanded():

            lock = threading.Lock()

            lock.acquire()

            changelog_thread = threading.Thread(

                target=self.cache.get_news_and_changelog, args=(name, lock))

            changelog_thread.start()

            changes_buffer.set_text("%s\n" %

                                    _("Downloading list of changes..."))