#!/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 2008 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

import getopt

import os

import sys

import time

import locale

import gettext

import pango

from threading import Thread

from threading import Timer

try:

        import gobject

        gobject.threads_init()        

        import gtk

        import gtk.glade

        import pygtk

        pygtk.require("2.0")

except ImportError:

        sys.exit(1)

import pkg.client.image as image

import pkg.client.api as api

import pkg.client.api_errors as api_errors

import pkg.client.progress as progress

import pkg.gui.beadmin as beadm

IMAGE_DIRECTORY_DEFAULT = "/"   # Image default directory

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

CLIENT_API_VERSION = 4          # API version

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

EX_DISC_QUOTA_EXCEEDED = 49     # Disc quota exceeded exception

#UM Row Model

(

UM_ID,

UM_INSTALL_MARK,

UM_STATUS,

UM_NAME,

UM_REBOOT,

UM_LATEST_VER,

UM_SIZE,

UM_FMRI,

) = range(8)

#UPDATE STEPS

(

UPDATE_EVAL,

UPDATE_DOWNLOAD,

UPDATE_INSTALL,

UPDATE_INDEX,

) = range(4)

#UPDATE TYPES

(

UPDATE_ACTIVE,

UPDATE_INACTIVE,

UPDATE_DONE,

) = range(3)

class GUIProgressTracker(progress.ProgressTracker):

        """ This progress tracker is designed for Gnome GUI's

        The parent must provide a number of callback methods to render progress

        in the GUI context. """

        def __init__(self, parent):

                progress.ProgressTracker.__init__(self)

                self.parent = parent

                locale.setlocale(locale.LC_ALL, '')

                self._ = gettext.gettext

                self.act_started = False

                self.ind_started = False

                self.last_print_time = 0

                self.dl_started = False

                self.dl_cur_pkg = None

        def reset(self):

                progress.ProgressTracker.reset(self)

                self.act_started = False

                self.ind_started = False

                self.last_print_time = 0

                self.dl_started = False

        def cat_output_start(self):

                catstr = self._("Fetching catalog: '%s' ..." % (self.cat_cur_catalog))

                gobject.idle_add(self.parent.output, "%s" % catstr)

        def cat_output_done(self):

                gobject.idle_add(self.parent.output_done, self._("Fetching catalog"))

        def eval_output_start(self):

                s = self._("Creating Plan ... ")

                gobject.idle_add(self.parent.output, "%s" % s)

        def eval_output_progress(self):

                if (time.time() - self.last_print_time) >= 0.10:

                        self.last_print_time = time.time()

                else:

                        return

                gobject.idle_add(self.parent.progress_pulse)

        def eval_output_done(self):

                gobject.idle_add(self.parent.output_done, self._("Creating Plan"))

                self.last_print_time = 0

        def ver_output(self):

                if self.ver_cur_fmri != None:

                        if (time.time() - self.last_print_time) >= 0.10:

                                self.last_print_time = time.time()

                        else:

                                return

                        gobject.idle_add(self.parent.progress_pulse)

                        gobject.idle_add(self.parent.output, \

                else:

                        gobject.idle_add(self.parent.output, "")

                        self.last_print_time = 0

        def ver_output_error(self, actname, errors):

                gobject.idle_add(self.parent.output_done, self._("Verifying"))

        def dl_output(self):

                gobject.idle_add(self.parent.dl_progress, 

                        self.dl_started, self.dl_cur_pkg, \

                        self.dl_cur_npkgs, self.dl_goal_npkgs, \

                        self.dl_cur_nfiles, self.dl_goal_nfiles, \

                        self.dl_cur_nbytes / 1024.0 / 1024.0, \

                        self.dl_goal_nbytes / 1024.0 / 1024.0)

                if not self.dl_started:

                        self.dl_started = True

        def dl_output_done(self):

                self.dl_cur_pkg = self._("Completed")

                self.dl_output()

                gobject.idle_add(self.parent.output_done, self._("Download"))

        def act_output(self):

                if (time.time() - self.last_print_time) >= 0.05:

                        self.last_print_time = time.time()

                else:

                        return

                gobject.idle_add(self.parent.act_progress, self.act_started, \

                        self.act_phase, self.act_cur_nactions, self.act_goal_nactions)

                if not self.act_started:

                        self.act_started = True

        def act_output_done(self):

                self.act_output()

                gobject.idle_add(self.parent.output_done, self._("Install"))

        def ind_output(self):

                if (time.time() - self.last_print_time) >= IND_DELAY:

                        self.last_print_time = time.time()

                else:

                        return

                gobject.idle_add(self.parent.ind_progress, self.ind_started, \

                        self.ind_phase, self.ind_cur_nitems, self.ind_goal_nitems)

                if not self.ind_started:

                        self.ind_started = True

        def ind_output_done(self):

                self.act_output()

                gobject.idle_add(self.parent.output_done, self._("Index"))

class Updatemanager:

        def __init__(self):

                try:

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

                except KeyError:

                        self.application_dir = "/"

                locale.setlocale(locale.LC_ALL, '')

                # UpdateManager can call BE Management Dialog that uses the

                # packagemanager.glade file, so we wanta  single domain for strings from

                # updatemanager.glade and packagemanager.glade

                for module in (gettext, gtk.glade):

                            "/usr/share/locale")

                # Required for pkg strings used in pkg API

                self._ = gettext.gettext                

                # 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_FMRI                        

                        )

                self.progress_stop_thread = False

                self.initial_active = 0

                self.initial_default = 0

                self.last_select_time = 0

                self.size_thread_running = False

                self.cancelled = False

                self.fmri_description = None

                self.install = False

                self.install_error = False

                self.done_icon = None

                self.blank_icon = None

                self.update_stage = UPDATE_EVAL

                self.toggle_counter = 0

                self.selection_timer = None

                self.package_selection = None

                self.cur_pkg = None

                self.show_all_opts = False

                self.show_install_updates_only = False

                self.do_refresh = False

                self.ua_start = 0

                # Progress Dialog

                self.gladefile = 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_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_progressinfo_expander_label = \

                        w_xmltree_progress.get_widget("progressinfo_expander_label")

                self.w_progress_install_vbox = \

                        w_xmltree_progress.get_widget("progress_install_vbox")

                self.w_progress_eval_img = \

                        w_xmltree_progress.get_widget("progress_eval_img")

                self.w_progress_eval_label = \

                        w_xmltree_progress.get_widget("progress_eval_label")

                self.w_progress_download_img = \

                        w_xmltree_progress.get_widget("progress_download_img")

                self.w_progress_download_label = \

                        w_xmltree_progress.get_widget("progress_download_label")

                self.w_progress_install_img = \

                        w_xmltree_progress.get_widget("progress_install_img")

                self.w_progress_install_label = \

                        w_xmltree_progress.get_widget("progress_install_label")

                self.w_progress_index_img = \

                        w_xmltree_progress.get_widget("progress_index_img")

                self.w_progress_index_label = \

                        w_xmltree_progress.get_widget("progress_index_label")

                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_scrolledwindow = w_xmltree_um.get_widget("um_scrolledwindow")

                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_delete_button = w_xmltree_um.get_widget("cancel_button")

                # ua_confirm_dialog

                w_xmltree_ua = gtk.glade.XML(self.gladefile, "ua_confirm_dialog")

                self.w_ua_confirm_dialog = \

                        w_xmltree_ua.get_widget("ua_confirm_dialog")

                self.w_ua_be_name_entry = \

                        w_xmltree_ua.get_widget("ua_be_name_entry")

                self.w_ua_proceed_button = \

                        w_xmltree_ua.get_widget("ua_proceed_button")

                self.w_ua_cancel_button = \

                        w_xmltree_ua.get_widget("ua_cancel_button")                

                self.details_cache = {}

                try:

                        dic = \

                            {

                                "on_um_dialog_close": \

                                    self.__on_um_dialog_close,

                                "on_cancel_button_clicked": \

                                    self.__on_cancel_button_clicked,

                                "on_install_button_clicked": \

                                    self.__on_install_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_progress = \

                            {

                                "on_progresscancel_clicked": \

                                    self.__on_progresscancel_clicked,

                                "on_progressok_clicked": \

                                    self.__on_progressok_clicked,

                            }

                        w_xmltree_progress.signal_autoconnect(dic_progress)

                        dic_ua = \

                            {

                                "on_ua_cancel_button_clicked": \

                                    self.__on_ua_cancel_button_clicked,

                                "on_ua_proceed_button_clicked": \

                                    self.__on_ua_proceed_button_clicked,

                            }

                        w_xmltree_ua.signal_autoconnect(dic_ua)

                except AttributeError, error:

                        print self._('GUI will not respond to any event! %s. \

                            Check updatemanager.py signals') \

                            % error

                self.pr = GUIProgressTracker(self)

                self.api_obj = None

                self.w_um_dialog.show_all()

        def __set_cancel_state(self, status):

                if self.install_error:

                        return

                if status:

                        gobject.idle_add(self.w_progress_cancel.grab_focus)

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

        def __progress_step(self, type_step, img, label, str_step):

                if type_step == UPDATE_ACTIVE:

                        self.__progress_active_step(img, label, str_step)

                elif type_step == UPDATE_DONE:

                        self.__progress_done_step(img, label, str_step)

                else:

                        self.__progress_inactive_step(img, label, str_step)

        def __progress_steps(self, eval_type, evaluate, dl_type, download, install_type, \

                install, index_type, index):                        

                self.__progress_step(eval_type, self.w_progress_eval_img, \

                        self.w_progress_eval_label, evaluate)

                self.__progress_step(dl_type, self.w_progress_download_img, \

                        self.w_progress_download_label,download)

                self.__progress_step(install_type, self.w_progress_install_img, \

                        self.w_progress_install_label, install)

                self.__progress_step(index_type, self.w_progress_index_img, \

                        self.w_progress_index_label, index)

        def __progress_steps_start(self):

                self.__progress_steps(\

                        UPDATE_ACTIVE, self._("Evaluate"), \

                        UPDATE_INACTIVE, self._("Download"), \

                        UPDATE_INACTIVE, self._("Install"), \

                        UPDATE_INACTIVE, self._("Index"))

        def __progress_steps_download(self):

                self.__progress_steps(\

                        UPDATE_DONE, self._("Evaluate"), \

                        UPDATE_ACTIVE, self._("Download"), \

                        UPDATE_INACTIVE, self._("Install"), \

                        UPDATE_INACTIVE, self._("Index"))

        def __progress_steps_install(self):

                self.__progress_steps(\

                        UPDATE_DONE, self._("Evaluate"), \

                        UPDATE_DONE, self._("Download"), \

                        UPDATE_ACTIVE, self._("Install"), \

                        UPDATE_INACTIVE, self._("Index"))

        def __progress_steps_index(self):

                self.__progress_steps(\

                        UPDATE_DONE, self._("Evaluate"), \

                        UPDATE_DONE, self._("Download"), \

                        UPDATE_DONE, self._("Install"), \

                        UPDATE_ACTIVE, self._("Index"))

        def __progress_steps_done(self):

                self.__progress_steps(\

                        UPDATE_DONE, self._("Evaluate"), \

                        UPDATE_DONE, self._("Download"), \

                        UPDATE_DONE, self._("Install"), \

                        UPDATE_DONE, self._("Index"))

        def __progress_cancel_eval(self):

                self.__progress_cancel_step(self.w_progress_eval_img, \

                        self.w_progress_eval_label, self._("Evaluate - canceling..."))

        def __progress_cancel_download(self):

                self.__progress_cancel_step(self.w_progress_download_img, \

                        self.w_progress_download_label, self._("Download - canceling..."))

        def __progress_error_eval(self):

                self.__progress_error_step(self.w_progress_eval_img, \

                        self.w_progress_eval_label, self._("Evaluate - failed"))

        def __progress_error_download(self):

                self.__progress_error_step(self.w_progress_download_img, \

                        self.w_progress_download_label, self._("Download - failed"))

        def __progress_error_install(self):

                self.__progress_error_step(self.w_progress_install_img, \

                        self.w_progress_install_label, self._("Install - failed"))

        def __progress_error_index(self):

                self.__progress_error_step(self.w_progress_index_img, \

                        self.w_progress_index_label, self._("Index - failed"))

        @staticmethod

        def __progress_active_step(widget_image, widget_label, str_step):

                widget_label.set_markup("<b>%s</b>" % str_step)

                widget_image.set_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_MENU) 

        def __progress_inactive_step(self, widget_image, widget_label, str_step):

                widget_label.set_text("%s" % str_step)

                widget_image.set_from_pixbuf(self.blank_icon)

        def __progress_done_step(self, widget_image, widget_label, str_step):

                widget_label.set_markup("<b>%s</b>" % str_step)                

                widget_image.set_from_pixbuf(self.done_icon)

        def __progress_error_step(self, widget_image, widget_label, str_step):

                widget_label.set_markup("<b>%s</b>" % str_step)

                widget_image.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)

                # On error open the Details panel and make sure the Window is visible

                # to the user, even if it has been minimized

                self.w_progressinfo_expander.set_expanded(True)

                self.w_progress_cancel.set_sensitive(True)

                self.w_um_dialog.present()

        @staticmethod

        def __progress_cancel_step(widget_image, widget_label, str_step):

                widget_label.set_markup("<b>%s</b>" % str_step)

                widget_image.set_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_MENU) 

        def __set_initial_selection(self):

                if len(self.um_list) == 0:

                        return                

                self.w_um_treeview.set_cursor(0, None)

        def __remove_installed(self, installed_fmris):

                model = self.w_um_treeview.get_model()

                iter_next = model.get_iter_first()

                installed_fmris_dic = dict([(k, None) for k in installed_fmris])

                while iter_next != None:

                        if model.get_value(iter_next, UM_NAME) in installed_fmris_dic:

                                self.um_list.remove(iter_next)

                                self.toggle_counter -= 1

                        else:

                                iter_next = model.iter_next(iter_next)

        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)