#!/usr/bin/python2.4

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

import getopt

import os

import subprocess

import sys

import time

import locale

import gettext

import pango

from threading import Thread

from threading import Timer

try:

        import gnome

        import gobject

        gobject.threads_init()        

        import gtk

        import gtk.glade

        import pygtk

        pygtk.require("2.0")

except ImportError:

        sys.exit(1)

import pkg.client.api as api

import pkg.portable as portable

import pkg.client.progress as progress

import pkg.gui.beadmin as beadm

import pkg.gui.installupdate as installupdate

import pkg.gui.enumerations as enumerations

import pkg.gui.misc as gui_misc

import pkg.misc as misc

from pkg.client import global_settings

# Put _() in the global namespace

import __builtin__

__builtin__._ = gettext.gettext

IMAGE_DIRECTORY_DEFAULT = "/"   # Image default directory

IMAGE_DIR_COMMAND = "svcprop -p update/image_dir svc:/application/pkg/update"

PKG_ICON_LOCATION = "usr/share/package-manager/icons"

ICON_LOCATION = "usr/share/update-manager/icons"

CHECK_FOR_UPDATES = "/usr/lib/pm-checkforupdates"

PKG_CLIENT_NAME = "updatemanager" # API client name

SELECTION_CHANGE_LIMIT = 0.5    # Time limit in seconds to cancel selection updates

IND_DELAY = 0.05                # Time delay for printing index progress

UPDATES_FETCH_DELAY = 200       # Time to wait before fetching updates, allows gtk main

                                # loop time to start and display main UI

#UM Row Model

(

UM_ID,

UM_INSTALL_MARK,

UM_STATUS,

UM_NAME,

UM_REBOOT,

UM_LATEST_VER,

UM_SIZE,

UM_STEM,

) = range(8)

class Updatemanager:

        def __init__(self):

                global_settings.client_name = PKG_CLIENT_NAME

                try:

                        self.application_dir = os.environ["UPDATE_MANAGER_ROOT"]

                except KeyError:

                        self.application_dir = "/"

                misc.setlocale(locale.LC_ALL, "")

                for module in (gettext, gtk.glade):

                        module.bindtextdomain("pkg", os.path.join(

                            self.application_dir,

                            "usr/share/locale"))

                        module.textdomain("pkg")

                gui_misc.init_for_help(self.application_dir)

                # Duplicate ListStore setup in get_updates_to_list()

                self.um_list = \

                    gtk.ListStore(

                        gobject.TYPE_INT,         # UM_ID

                        gobject.TYPE_BOOLEAN,     # UM_INSTALL_MARK

                        gtk.gdk.Pixbuf,           # UM_STATUS

                        gobject.TYPE_STRING,      # UM_NAME

                        gtk.gdk.Pixbuf,           # UM_REBOOT

                        gobject.TYPE_STRING,      # UM_LATEST_VER

                        gobject.TYPE_STRING,      # UM_SIZE

                        gobject.TYPE_STRING,      # UM_STEM                        

                        )

                self.progress_stop_thread = False

                self.last_select_time = 0

                self.user_rights = portable.is_admin()

                self.fmri_description = None

                self.image_dir_arg = None

                self.toggle_counter = 0

                self.selection_timer = None

                self.package_selection = None

                self.update_all_proceed = False

                self.ua_be_name = None

                self.application_path = None

                self.icon_theme = gtk.IconTheme()

                pkg_icon_location = os.path.join(self.application_dir, PKG_ICON_LOCATION)

                self.icon_theme.append_search_path(pkg_icon_location)

                icon_location = os.path.join(self.application_dir, ICON_LOCATION)

                self.icon_theme.append_search_path(icon_location)

                self.ua_start = 0

                self.pylintstub = None

                self.api_obj = None

                self.release_notes_url = "http://www.opensolaris.org"

                # Progress Dialog

                self.gladefile = os.path.join(self.application_dir,

                    "usr/share/update-manager/updatemanager.glade")

                w_xmltree_progress = gtk.glade.XML(self.gladefile, "progressdialog")

                self.w_progress_dialog = w_xmltree_progress.get_widget("progressdialog")

                self.w_progress_dialog.connect('delete-event', lambda stub1, stub2: True)

                self.w_progressinfo_label = w_xmltree_progress.get_widget("progressinfo")

                self.w_progressinfo_separator = w_xmltree_progress.get_widget(

                    "progressinfo_separator")                

                self.w_progressinfo_expander = \

                    w_xmltree_progress.get_widget("progressinfo_expander")

                self.w_progressinfo_textview = \

                    w_xmltree_progress.get_widget("progressinfo_textview")

                infobuffer = self.w_progressinfo_textview.get_buffer()

                infobuffer.create_tag("bold", weight=pango.WEIGHT_BOLD)

                self.w_progress_install_vbox = \

                    w_xmltree_progress.get_widget("progress_install_vbox")

                self.w_progress_closeon_finish_chk = \

                    w_xmltree_progress.get_widget("closeon_finish_checkbutton")

                self.w_progress_cancel = w_xmltree_progress.get_widget("progresscancel")

                self.w_progress_ok = w_xmltree_progress.get_widget("progressok")

                self.w_progressbar = w_xmltree_progress.get_widget("progressbar")

                # UM Dialog

                w_xmltree_um = gtk.glade.XML(self.gladefile, "um_dialog")

                self.w_um_dialog = w_xmltree_um.get_widget("um_dialog")

                self.w_um_dialog.connect("destroy", self.__on_um_dialog_close)

                self.w_um_intro_label = w_xmltree_um.get_widget("um_intro_label")

                self.w_um_install_button = w_xmltree_um.get_widget("um_install_button")

                self.w_um_updateall_button = \

                    w_xmltree_um.get_widget("um_updateall_button")

                self.w_um_expander = w_xmltree_um.get_widget("um_expander")

                self.w_um_expander.set_expanded(True)

                self.w_progress_dialog.set_transient_for(self.w_um_dialog)

                self.w_um_treeview = w_xmltree_um.get_widget("um_treeview")  

                self.w_um_textview = w_xmltree_um.get_widget("um_textview")  

                infobuffer = self.w_um_textview.get_buffer()

                infobuffer.create_tag("bold", weight=pango.WEIGHT_BOLD)

                self.w_select_checkbox = w_xmltree_um.get_widget("selectall_checkbutton")

                self.w_um_cancel_button = w_xmltree_um.get_widget("cancel_button")

                self.w_um_close_button = w_xmltree_um.get_widget("close_button")

                # UM Completed Dialog

                w_xmltree_um_completed = gtk.glade.XML(self.gladefile, 

                    "um_completed_dialog")

                self.w_um_completed_dialog = w_xmltree_um_completed.get_widget(

                    "um_completed_dialog")

                self.w_um_completed_dialog .connect("destroy", self.__on_um_dialog_close)

                self.w_um_completed_time_label = w_xmltree_um_completed.get_widget(

                    "um_completed_time_label")

                self.w_um_completed_release_label = w_xmltree_um_completed.get_widget(

                    "um_completed_release_label")

                self.w_um_completed_linkbutton = w_xmltree_um_completed.get_widget(

                    "um_completed_linkbutton")

                self.details_cache = {}

                try:

                        dic = \

                            {

                                "on_um_dialog_close": \

                                    self.__on_um_dialog_close,

                                "on_cancel_button_clicked": \

                                    self.__on_cancel_button_clicked,

                                "on_close_button_clicked": \

                                    self.__on_cancel_button_clicked,

                                "on_help_button_clicked": \

                                    self.__on_help_button_clicked,

                                "on_um_updateall_button_clicked": \

                                    self.__on_updateall_button_clicked,

                                "on_um_expander_activate": \

                                    self.__on_um_expander_activate,

                                "on_selectall_checkbutton_toggled": \

                                    self.__on_selectall_checkbutton_toggled,

                            }

                        w_xmltree_um.signal_autoconnect(dic)

                        dic_completed = \

                            {

                                "on_um_complete_close_button_clicked": \

                                     self.__on_um_dialog_close,

                                "on_um_completed_linkbutton_clicked": \

                                     self.__on_um_completed_linkbutton_clicked,

                            }

                        w_xmltree_um_completed.signal_autoconnect(dic_completed)

                except AttributeError, error:

                        print _("GUI will not respond to any event! %s. "

                            "Check updatemanager.py signals") % error

                self.pr = progress.NullProgressTracker()

                self.w_um_dialog.show_all()

                self.w_um_dialog.resize(620, 500)

        def __set_cancel_state(self, status):

                if status:

                        gobject.idle_add(self.w_progress_cancel.grab_focus)

                gobject.idle_add(self.w_progress_cancel.set_sensitive, status)

        def __set_initial_selection(self):

                self.__selectall_toggle(True)

                if len(self.um_list) == 0:

                        self.__display_noupdates()

                else:

                        self.w_um_treeview.set_cursor(0, None)

                        if self.update_all_proceed:

                                self.__on_updateall_button_clicked(None)

                                self.update_all_proceed = False

        def __mark_cell_data_default_function(self, column, renderer, model, itr, data):

                if itr:

                        if model.get_value(itr, UM_STATUS) != None:

                                self.__set_renderer_active(renderer, False)

                        else:

                                self.__set_renderer_active(renderer, True)

        @staticmethod

        def __set_renderer_active(renderer, active):

                if active:

                        renderer.set_property("sensitive", True)

                        renderer.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE)

                else:

                        renderer.set_property("sensitive", False)

                        renderer.set_property("mode", gtk.CELL_RENDERER_MODE_INERT)

        def __get_icon_pixbuf(self, icon_name, size=16):

                return gui_misc.get_icon(self.icon_theme, icon_name, size)

        def __get_selected_fmris(self):

                model = self.w_um_treeview.get_model()

                iter_next = model.get_iter_first()

                list_of_selected_fmris = []

                while iter_next != None:

                        if model.get_value(iter_next, UM_INSTALL_MARK):

                                list_of_selected_fmris.append(model.get_value(iter_next,

                                    UM_NAME))

                        iter_next = model.iter_next(iter_next)

                return list_of_selected_fmris

        def init_tree_views(self):

                model = self.w_um_treeview.get_model()

                toggle_renderer = gtk.CellRendererToggle()

                toggle_renderer.connect('toggled', self.__active_pane_toggle, model)

                column = gtk.TreeViewColumn("", toggle_renderer,

                    active = UM_INSTALL_MARK)

                column.set_cell_data_func(toggle_renderer,

                    self.__mark_cell_data_default_function, None)                    

                toggle_renderer.set_property("activatable", True)

                column.set_expand(False)

                # Show Cancel, Update All only

                self.w_select_checkbox.hide()

                self.w_um_install_button.hide()

                self.w_um_intro_label.set_text(_(

                    "Updates are available for the following packages.\n"

                    "Click Update All to create a new boot environment and "

                    "install all packages into it."))

                render_pixbuf = gtk.CellRendererPixbuf()

                column = gtk.TreeViewColumn()

                column.pack_start(render_pixbuf, expand = False)

                column.add_attribute(render_pixbuf, "pixbuf", UM_STATUS)

                column.set_title("   ")

                # Hiding Status column for now

                #self.w_um_treeview.append_column(column)

                name_renderer = gtk.CellRendererText()

                column = gtk.TreeViewColumn(_("Name"), name_renderer,

                    text = UM_NAME)

                column.set_cell_data_func(name_renderer, self.__cell_data_function, None)

                column.set_expand(True)

                self.w_um_treeview.append_column(column)

                column = gtk.TreeViewColumn()

                render_pixbuf = gtk.CellRendererPixbuf()

                column.pack_start(render_pixbuf, expand = True)

                column.add_attribute(render_pixbuf, "pixbuf", UM_REBOOT)

                # Hiding Reboot required column for now

                # self.w_um_treeview.append_column(column)

                version_renderer = gtk.CellRendererText()

                version_renderer.set_property('xalign', 0.0)

                column = gtk.TreeViewColumn(_("Latest Version"), version_renderer,

                    text = UM_LATEST_VER) 

                column.set_cell_data_func(version_renderer,

                    self.__cell_data_function, None)

                column.set_expand(True)

                self.w_um_treeview.append_column(column)

                size_renderer = gtk.CellRendererText()

                size_renderer.set_property('xalign', 0.0)

                column = gtk.TreeViewColumn(_("Size (Meg)"), size_renderer,

                    text = UM_SIZE)

                column.set_cell_data_func(size_renderer, self.__cell_data_function, None)

                column.set_expand(True)

                # XXX Hiding Size as it takes too long to fetch at the minute

                #self.w_um_treeview.append_column(column)

                #Added selection listener

                self.package_selection = self.w_um_treeview.get_selection()

                self.package_selection.set_mode(gtk.SELECTION_SINGLE)

                self.package_selection.connect("changed",

                    self.__on_package_selection_changed, None)

                # Setup Icons

                self.w_um_dialog.set_icon(self.__get_icon_pixbuf("UM_package", 36))

        def __get_image_path(self):

                '''This function gets the image path or the default'''

                if self.image_dir_arg != None:

                        return self.image_dir_arg

                try:

                        image_directory = os.environ["PKG_IMAGE"]

                except KeyError:

                        image_directory = \

                            os.popen(IMAGE_DIR_COMMAND).readline().rstrip()

                        if len(image_directory) == 0:

                                image_directory = IMAGE_DIRECTORY_DEFAULT

                return image_directory

        def get_updates_to_list(self):

                '''This function fetches a list of the updates

                        that are available to list'''

                # MUST match self.um_list ListStore setup in __init__

                um_list = \

                    gtk.ListStore(

                        gobject.TYPE_INT,         # UM_ID

                        gobject.TYPE_BOOLEAN,     # UM_INSTALL_MARK

                        gtk.gdk.Pixbuf,           # UM_STATUS

                        gobject.TYPE_STRING,      # UM_NAME

                        gtk.gdk.Pixbuf,           # UM_REBOOT

                        gobject.TYPE_STRING,      # UM_LATEST_VER

                        gobject.TYPE_STRING,      # UM_SIZE

                        gobject.TYPE_STRING,      # UM_STEM                        

                        )

                # Use check_for_updates to determine whether updates

                # are available

                return_code = subprocess.call([CHECK_FOR_UPDATES,

                    self.__get_image_path()])

                if return_code == enumerations.NO_UPDATES_AVAILABLE:

                        self.progress_stop_thread = True

                        gobject.idle_add(self.__display_noupdates)

                        return

                self.api_obj = self.__get_api_obj()

                image_obj = self.api_obj.img

                count = 0

                pkg_upgradeable = None

                for pkg, state in sorted(misc.get_inventory_list(

                    image_obj, [], all_known = True, all_versions = False)):

                        while gtk.events_pending():

                                gtk.main_iteration(False)

                                pkg_upgradeable = pkg

                        # Allow testing by listing uninstalled packages, -u option

                        add_package = False

                        if pkg_upgradeable != None and not state["upgradable"]:

                                add_package = pkg_upgradeable.is_same_pkg(pkg)

                                if list_uninstalled:

                                        add_package = not add_package

                        if add_package:

                                count += 1

                                # XXX: Would like to caputre if package for upgrade is

                                # incorporated, could then indicate this to user

                                # and take action when doing install to run image-update.

                                #if state["incorporated"]:

                                #        incState = _("Inc")

                                #else:

                                #        incState = "--"

                                pkg_name = gui_misc.get_pkg_name(pkg.get_name())

                                um_list.insert(count, [count, False, None,

                                    pkg_name, None, pkg.get_version(), None,

                                    pkg.get_pkg_stem()])

                if debug:

                        print _("count: %d") % count

                self.progress_stop_thread = True

                gobject.idle_add(self.w_um_treeview.set_model, um_list)

                self.um_list = um_list                

                gobject.idle_add(self.__set_initial_selection)

                # XXX: Currently this will fetch the sizes but it really slows down the

                # app responsiveness - until we get caching I think we should just hide

                # the size column

                # gobject.timeout_add(1000, self.__setup_sizes)

        def __get_api_obj(self):

                if self.api_obj == None:

                        self.api_obj = gui_misc.get_api_object(self.__get_image_path(),

                            progress.NullProgressTracker(), self.w_um_dialog)

                return self.api_obj

        def __display_nopermissions(self):

                self.w_um_intro_label.set_markup(

                    _("<b>You do not have sufficient permissions.</b>"

                    "\n\nPlease restart pm-updatemanager using pfexec."))

                self.__setup_display()

        def __display_noupdates(self):

                self.w_um_intro_label.set_markup(_("<b>No Updates available.</b>"))

                self.__setup_display()

        def __setup_display(self):

                self.w_um_treeview.hide()

                self.w_um_expander.hide()

                self.w_um_install_button.set_sensitive(False)

                self.w_um_updateall_button.hide()

                self.w_um_cancel_button.hide()

                self.w_um_close_button.show()

                self.w_select_checkbox.set_active(False)

                self.w_select_checkbox.set_sensitive(False)

                self.w_um_dialog.present()

                self.w_um_dialog.resize(420, 100)

        def __get_info_from_name(self, name, local):

                if self.fmri_description != name:

                        return None

                if self.__get_api_obj() == None:

                        return None

                ret = self.__get_api_obj().info([name], local,

                    (api.PackageInfo.ALL_OPTIONS -

                    frozenset([api.PackageInfo.LICENSES])) -

                    api.PackageInfo.ACTION_OPTIONS)

                pis = ret[api.ImageInterface.INFO_FOUND]

                if len(pis) == 1:

                        return pis[0]

                else:

                        return None

        def __get_details_from_name(self, name):                        

                info = self.__get_info_from_name(name, False)

                if info is not None:

                        return self.__update_details_from_info(name, info)

                else:

                        return None

        def __update_details_from_info(self, name, info):

                local_info = self.__get_info_from_name(name, True)

                categories = _("None")

                if info.category_info_list:

                        verbose = len(info.category_info_list) > 1

                        categories = ""

                        categories += info.category_info_list[0].__str__(verbose)

                        if len(info.category_info_list) > 1:

                                for ci in info.category_info_list[1:]:

                                        categories += ", " + ci.__str__(verbose)

                try:

                        installed_ver = "%s-%s" % (local_info.version, local_info.branch)

                except AttributeError:

                        installed_ver = ""

                ver = "%s-%s" % (info.version, info.branch)