#!/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.

#

MIN_IND_ELEMENTS_BOUNCE = 5      # During indexing the progress will be progressive if 

                                 # the number of indexing elements is greater then this, 

                                 # otherwise it will bounce

import errno

import os

import sys

import time

import pango

import datetime

import traceback

import string

from threading import Thread

try:

        import gobject

        import gtk

        import gtk.glade

        import pygtk

        pygtk.require("2.0")

except ImportError:

        sys.exit(1)

nobe = False

try:

        import libbe as be

except ImportError:

        nobe = True

import pkg.client.progress as progress

import pkg.misc

import pkg.client.api_errors as api_errors

import pkg.gui.beadmin as beadm

import pkg.gui.misc as gui_misc

import pkg.gui.enumerations as enumerations

ERROR_FORMAT = "<span color = \"red\">%s</span>"

class InstallUpdate(progress.ProgressTracker):

        def __init__(self, list_of_packages, parent, api_o,

            ips_update = False, action = -1, be_name = None, 

            parent_name = "", pkg_list = None, main_window = None,

            icon_confirm_dialog = None, title = None, web_install = False):

                if action == -1:

                        return

                progress.ProgressTracker.__init__(self)

                self.web_install = web_install

                self.web_updates_list = None

                api_o.progresstracker = self

                self.api_o = api_o

                self.parent = parent

                self.be_list = None

                self.be_name = be_name

                self.parent_name = parent_name

                self.ipkg_ipkgui_list = pkg_list

                self.icon_confirm_dialog = icon_confirm_dialog

                self.title = title

                self.w_main_window = main_window

                self.ips_update = ips_update

                self.list_of_packages = list_of_packages

                self.act_phase_last = None

                self.action = action

                self.canceling = False

                self.current_stage_name = None

                self.ind_started = None

                self.ip = None

                self.operations_done = False

                self.prev_ind_phase = None

                self.prev_pkg = None

                self.progress_stop_timer_running = False

                self.proposed_be_name = None

                self.stages = {

                          1:[_("Preparing..."), _("Preparation")],

                          2:[_("Downloading..."), _("Download")],

                          3:[_("Installing..."), _("Install")],

                         }

                self.stop_bouncing_progress = False

                self.stopped_bouncing_progress = True

                self.update_list = {}

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

                    "usr/share/package-manager/packagemanager.glade")

                w_tree_dialog = gtk.glade.XML(gladefile, "createplandialog")

                w_tree_uaconfirm = gtk.glade.XML(gladefile, "ua_confirm_dialog")

                w_tree_removeconfirm = \

                    gtk.glade.XML(gladefile, "removeconfirmation")

                self.w_dialog = w_tree_dialog.get_widget("createplandialog")

                self.w_expander = w_tree_dialog.get_widget("expander3")

                self.w_cancel_button = w_tree_dialog.get_widget("cancelcreateplan")

                self.w_progressbar = w_tree_dialog.get_widget("createplanprogress")

                self.w_details_textview = w_tree_dialog.get_widget("createplantextview")

                self.w_removeconfirm_dialog = \

                    w_tree_removeconfirm.get_widget("removeconfirmation")

                w_removeproceed_button = w_tree_removeconfirm.get_widget("remove_proceed")

                w_remove_treeview = w_tree_removeconfirm.get_widget("removetreeview")

                w_stage2 = w_tree_dialog.get_widget("stage2")

                self.w_stages_box = w_tree_dialog.get_widget("stages_box")

                self.w_stage1_label = w_tree_dialog.get_widget("label_stage1")

                self.w_stage1_icon = w_tree_dialog.get_widget("icon_stage1")

                self.w_stage2_label = w_tree_dialog.get_widget("label_stage2")

                self.w_stage2_icon = w_tree_dialog.get_widget("icon_stage2")

                self.w_stage3_label = w_tree_dialog.get_widget("label_stage3")

                self.w_stage3_icon = w_tree_dialog.get_widget("icon_stage3")

                self.w_stages_label = w_tree_dialog.get_widget("label_stages")

                self.w_stages_icon = w_tree_dialog.get_widget("icon_stages")

                self.current_stage_label = self.w_stage1_label

                self.current_stage_icon = self.w_stage1_icon

                self.current_stage_label_done = None

                self.done_icon = gui_misc.get_icon(

                    self.parent.icon_theme, "progress_checkmark")

                blank_icon = gui_misc.get_icon(

                    self.parent.icon_theme, "progress_blank")

                self.w_stage1_icon.set_from_pixbuf(blank_icon)

                self.w_stage2_icon.set_from_pixbuf(blank_icon)

                self.w_stage3_icon.set_from_pixbuf(blank_icon)

                infobuffer = self.w_details_textview.get_buffer()

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

                infobuffer.create_tag("level1", left_margin=30, right_margin=10)

                infobuffer.create_tag("level2", left_margin=50, right_margin=10)

                self.w_ua_dialog = w_tree_uaconfirm.get_widget("ua_confirm_dialog")

                self.w_ua_error_label = w_tree_uaconfirm.get_widget(

                    "ua_confirm_error_label")

                self.w_ua_proceed_button = w_tree_uaconfirm.get_widget(

                    "ua_proceed_button")

                self.w_ua_be_name_entry = w_tree_uaconfirm.get_widget(

                    "ua_be_name_entry")

                self.w_ua_be_name_box = w_tree_uaconfirm.get_widget(

                    "ua_be_name_box")

                w_ua_proceed_button = w_tree_uaconfirm.get_widget("ua_proceed_button")

                self.w_progressbar.set_pulse_step(0.02)

                try:

                        dic_createplan = \

                            {

                                "on_cancelcreateplan_clicked": \

                                    self.__on_cancelcreateplan_clicked,

                                "on_createplandialog_delete_event": \

                                    self.__on_createplandialog_delete,

                            }

                        dic_uaconfirm = \

                            {

                                "on_ua_cancel_button_clicked": \

                                    self.__on_ua_cancel_button_clicked,

                                "on_ua_proceed_button_clicked": \

                                self.__on_ua_proceed_button_clicked,

                                "on_ua_be_name_entry_changed": \

                                self.__on_ua_be_name_entry_changed,

                                "on_ua_help_button_clicked": \

                                self.__on_ua_help_button_clicked,                                

                            }

                        dic_removeconfirm = \

                            {

                                "on_proceed_button_clicked": \

                                    self.__on_remove_proceed_button_clicked,

                                "on_cancel_button_clicked": \

                                self.__on_remove_cancel_button_clicked,

                            }

                        w_tree_dialog.signal_autoconnect(dic_createplan)

                        w_tree_uaconfirm.signal_autoconnect(dic_uaconfirm)

                        w_tree_removeconfirm.signal_autoconnect(dic_removeconfirm)

                except AttributeError, error:

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

                            "Check installupdate.py signals") \

                            % error

                self.w_dialog.set_transient_for(self.w_main_window)

                self.w_ua_dialog.set_transient_for(self.w_main_window)

                if self.icon_confirm_dialog != None:  

                        self.w_ua_dialog.set_icon(self.icon_confirm_dialog)

                if self.action == enumerations.REMOVE:

                        #We are not showing the download stage in the main stage list

                        self.stages[3] = [_("Removing..."), _("Remove")]

                        self.w_stage3_label.set_text(self.stages[3][1])

                        w_stage2.hide()

                        self.w_dialog.set_title(_("Remove"))

                        w_removeproceed_button.grab_focus()

                        cell = gtk.CellRendererText()

                        remove_column = gtk.TreeViewColumn('Removed')

                        remove_column.pack_start(cell, True)

                        remove_column.add_attribute(cell, 'text', 0)

                        w_remove_treeview.append_column(remove_column)

                        liststore = gtk.ListStore(str)

                        for sel_pkg in list_of_packages:

                                liststore.append([sel_pkg])

                        w_remove_treeview.set_model(liststore)

                        w_remove_treeview.expand_all()

                        self.w_removeconfirm_dialog.show()

                elif self.action == enumerations.IMAGE_UPDATE:

                        self.w_dialog.set_title(_("Update All"))

                        w_ua_proceed_button.grab_focus()

                        if not self.be_name:

                                if nobe or not "beVerifyBEName" in be.__dict__:

                                        self.w_ua_be_name_box.set_property(

                                            "visible", False)

                                else:

                                        self.__setup_be_list()

                                self.w_ua_dialog.show()

                        else:

                                self.proposed_be_name = self.be_name

                                self.__proceed_with_stages()

                else:

                        if self.title != None:

                                self.w_dialog.set_title(self.title)

                        else:

                                self.w_dialog.set_title(_("Install/Update"))

                        self.__proceed_with_stages()

        def __on_createplandialog_delete(self, widget, event):

                self.__on_cancelcreateplan_clicked(None)

                return True

        def __on_cancelcreateplan_clicked(self, widget):

                '''Handler for signal send by cancel button, which user might press during

                evaluation stage - while the dialog is creating plan'''

                if self.api_o.can_be_canceled():

                        self.canceling = True

                        Thread(target = self.api_o.cancel, args = ()).start()

                        cancel_txt = _("Canceling...")

                        txt = "<b>" + self.current_stage_label_done + " - " \

                            + cancel_txt + "</b>"

                        gobject.idle_add(self.current_stage_label.set_markup, txt)

                        gobject.idle_add(self.current_stage_icon.set_from_stock, 

                            gtk.STOCK_CANCEL, gtk.ICON_SIZE_MENU)

                        gobject.idle_add(self.w_stages_label.set_markup, cancel_txt)

                        self.w_cancel_button.set_sensitive(False)

                if self.operations_done:

                        self.w_dialog.hide()

                        if self.web_install:

                                gobject.idle_add(self.parent.update_package_list, 

                                    self.web_updates_list)

                                return

                        gobject.idle_add(self.parent.update_package_list, None)

        def __on_ua_help_button_clicked(self, widget):

                gui_misc.display_help(self.parent.application_dir, "update_all")

        def __on_ua_cancel_button_clicked(self, widget):

                self.w_ua_dialog.hide()

                if self.web_install:

                        gobject.idle_add(self.parent.update_package_list, 

                            self.web_updates_list)

                        return

                gobject.idle_add(self.parent.update_package_list, None)

        def __on_ua_proceed_button_clicked(self, widget):

                proposed_be_name = self.w_ua_be_name_entry.get_text()

                if proposed_be_name != "":

                        self.proposed_be_name = proposed_be_name

                self.w_ua_dialog.hide()

                self.__proceed_with_stages()

        def __setup_be_list(self):

                be_list = be.beList()

                error_code = None

                if len(be_list) > 1 and type(be_list[0]) == type(-1):

                        error_code = be_list[0]

                if error_code != None and error_code == 0:

                        self.be_list = be_list[1]

                elif error_code == None:

                        self.be_list = be_list

                # Now set proposed name in entry field.

                active_name = None

                for bee in self.be_list:

                        name = bee.get("orig_be_name")

                        if name:

                                if bee.get("active"):

                                        active_name = name

                                        break

                if active_name != None:

                        proposed_name = None

                        list = string.rsplit(active_name, '-', 1)

                        if len(list) == 1:

                                proposed_name = self.__construct_be_name(

                                    active_name, 0)

                        else:

                                try:

                                        i = int(list[1])

                                        proposed_name = self.__construct_be_name(

                                            list[0], i)

                                except ValueError:

                                        proposed_name = self.__construct_be_name(

                                            active_name, 0)

                        if proposed_name != None:

                                self.w_ua_be_name_entry.set_text(proposed_name)

        def __construct_be_name(self, name, i):

                in_use = True

                proposed_name = None

                while in_use:

                        i += 1

                        proposed_name = name + '-'  + str(i)

                        in_use = self.__is_be_name_in_use(proposed_name)

                return proposed_name

        def __is_be_name_in_use(self, name):

                in_use = False

                if name == "":

                        return in_use

                for bee in self.be_list:

                        be_name = bee.get("orig_be_name")

                        if be_name == name:

                                in_use = True

                                break

                return in_use

        def __is_be_name_valid(self, name):

                if name == "":

                        return True

                return be.beVerifyBEName(name) == 0

        def __validate_be_name(self, widget):

                name = widget.get_text()

                is_name_valid = self.__is_be_name_valid(name)

                self.w_ua_error_label.hide()

                error_str = None

                if is_name_valid:

                        is_name_in_use = self.__is_be_name_in_use(name)

                        if is_name_in_use:

                                error_str = ERROR_FORMAT % _("BE name is in use")

                else:

                        error_str = ERROR_FORMAT % _("BE name is invalid")

                if error_str != None:

                        self.w_ua_error_label.set_markup(error_str)

                        self.w_ua_error_label.show()

                self.w_ua_proceed_button.set_sensitive(error_str == None)

        def __on_ua_be_name_entry_changed(self, widget):

                self.__validate_be_name(widget)

        def __on_remove_cancel_button_clicked(self, widget):

                self.w_removeconfirm_dialog.hide()

        def __on_remove_proceed_button_clicked(self, widget):

                self.w_removeconfirm_dialog.hide()

                self.__proceed_with_stages()

        def __ipkg_ipkgui_uptodate(self):

                if self.ipkg_ipkgui_list == None:

                        return True

                upgrade_needed, cre = self.api_o.plan_install(

                    self.ipkg_ipkgui_list, filters = [])

                return not upgrade_needed

        def __proceed_with_stages(self):

                self.__start_stage_one()

                self.w_dialog.show()

                Thread(target = self.__proceed_with_stages_thread_ex, 

                    args = ()).start()

        def __proceed_with_stages_thread_ex(self):

                try:

                except api_errors.CertificateError:

                        self.stop_bouncing_progress = True

                        msg = _("Accessing this restricted repository failed."

                            "\nYou either need to register to access this repository,"

                            "\nthe certificate expired, or you need to accept the"

                            " repository\ncertificate.")

                        self.__g_error_stage(msg)

                        return

                except api_errors.PlanCreationException, e:

                        self.__g_error_stage(str(e))

                        return

                except api_errors.InventoryException, e:

                        msg = _("Inventory exception:\n")

                        if e.illegal:

                                for i in e.illegal:

                                        msg += "\tpkg:\t" + i +"\n"

                        self.__g_error_stage(msg)

                        return

                except api_errors.CatalogRefreshException, e:

                        msg = _("Please check the network "

                            "connection.\nIs the repository accessible?")

                        if e.message and len(e.message) > 0:

                                msg = e.message

                        self.__g_error_stage(msg)

                        return

                except api_errors.TransportError, ex:

                        msg = _("Please check the network "

                            "connection.\nIs the repository accessible?\n\n"

                            "%s") % str(ex)

                        self.__g_error_stage(msg)

                        return

                except api_errors.InvalidDepotResponseException, e:

                        msg = _("\nUnable to contact a valid package depot. "

                            "Please check your network\nsettings and "

                            "attempt to contact the server using a web "

                            "browser.\n\n%s") % str(e)

                        self.__g_error_stage(msg)

                        return

                except api_errors.IpkgOutOfDateException:

                        msg = _("pkg(5) appears to be out of "

                            "date and should be\nupdated before running "

                            "Update All.\nPlease update SUNWipkg package")

                        self.__g_error_stage(msg)

                        return

                except api_errors.NonLeafPackageException, nlpe:

                        msg = _("Cannot remove:\n\t%s\n"

                                "Due to the following packages that "

                                "depend on it:\n") % nlpe[0].get_name()

                        for pkg_a in nlpe[1]:

                                msg += "\t" + pkg_a.get_name() + "\n"

                        self.__g_error_stage(msg)

                        return

                except api_errors.ProblematicPermissionsIndexException, err:

                        msg = str(err)

                        msg += _("\nFailure of consistent use of pfexec or gksu when "

                            "running\n%s is often a source of this problem.") % \

                            self.parent_name

                        msg += _("\nTo rebuild index, please use the terminal command:")

                        msg += _("\n\tpfexec pkg rebuild-index")

                        self.__g_error_stage(msg)

                        return

                except api_errors.CorruptedIndexException:

                        msg = _("There was an error during installation. The search\n"

                            "index is corrupted. You might want try to fix this\n"

                            "problem by running command:\n"

                            "\tpfexec pkg rebuild-index")

                        self.__g_error_stage(msg)

                        return

                except api_errors.ImageUpdateOnLiveImageException:

                        msg = _("This is an Live Image. The install"

                            "\noperation can't be performed.")

                        self.__g_error_stage(msg)

                        return