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

import gettext # XXX Temporary workaround

import itertools

import os

import sys

import time

from threading import Thread

from urllib2 import URLError

try:

        import gobject

        import gtk

        import gtk.glade

        import pygtk

        pygtk.require("2.0")

except ImportError:

        sys.exit(1)

import pkg.client.bootenv as bootenv

import pkg.client.history as history

import pkg.client.imageplan as imageplan

import pkg.client.progress as progress

import pkg.fmri as fmri

import pkg.client.indexer as indexer

import pkg.search_errors as search_errors

from pkg.misc import TransferTimedOutException

from pkg.misc import CLIENT_DEFAULT_MEM_USE_KB

import pkg.gui.enumerations as enumerations

import pkg.gui.filelist as filelist

import pkg.gui.thread as guithread

from pkg.gui.filelist import CancelException

class InstallUpdate(progress.ProgressTracker):

        def __init__(self, install_list, parent, \

            image_update = False, ips_update = False):

                # XXX Workaround as BE is using msg(_("message")) 

                # which bypasses the self._ mechanism the GUI is using

                gettext.install("pkg","/usr/lib/locale")

                progress.ProgressTracker.__init__(self)

                self.gui_thread = guithread.ThreadRun()

                self.install_list = install_list

                self.update_list = None

                self.parent = parent

                self.image_update = image_update

                self.ips_update = ips_update

                self.ip = None

                self.progress_stop_timer_thread = False

                self.progress_stop_timer_running = False                

                w_tree_createplan = gtk.glade.XML(parent.gladefile, "createplandialog")

                w_tree_installupdate = gtk.glade.XML(parent.gladefile, "installupdate")

                w_tree_downloadingfiles = \

                    gtk.glade.XML(parent.gladefile, "downloadingfiles")

                w_tree_installingdialog = \

                    gtk.glade.XML(parent.gladefile, "installingdialog") 

                w_tree_networkdown = gtk.glade.XML(parent.gladefile, "networkdown")

                self.w_createplan_dialog = \

                    w_tree_createplan.get_widget("createplandialog")                    

                self.w_createplan_progressbar = \

                    w_tree_createplan.get_widget("createplanprogress") 

                self.w_createplan_textview = \

                    w_tree_createplan.get_widget("createplantextview")

                self.w_createplan_label = \

                    w_tree_createplan.get_widget("packagedependencies")

                self.w_createplancancel_button = \

                    w_tree_createplan.get_widget("cancelcreateplan")

                self.w_installupdate_dialog = w_tree_installupdate.get_widget("installupdate")

                self.w_summary_label = w_tree_installupdate.get_widget("packagenamelabel3")

                self.w_review_treeview = w_tree_installupdate.get_widget("treeview1")

                self.w_downloadingfiles_dialog = \

                    w_tree_downloadingfiles.get_widget("downloadingfiles")

                self.w_download_textview = \

                    w_tree_downloadingfiles.get_widget("downloadtextview")

                self.w_download_progressbar = \

                    w_tree_downloadingfiles.get_widget("downloadprogress")

                self.w_installing_dialog = \

                    w_tree_installingdialog.get_widget("installingdialog")

                self.w_installingdialog_label = \

                    w_tree_installingdialog.get_widget("packagedependencies3")                    

                self.w_installingdialog_expander = \

                    w_tree_installingdialog.get_widget("expander4")                     

                self.w_installing_textview = \

                    w_tree_installingdialog.get_widget("installingtextview")

                self.w_installing_progressbar = \

                    w_tree_installingdialog.get_widget("installingprogress")

                self.w_networkdown_dialog = w_tree_networkdown.get_widget("networkdown")

                self.w_createplan_progressbar.set_pulse_step(0.1)

                installed_updated_column = gtk.TreeViewColumn('Installed/Updated')

                self.w_review_treeview.append_column(installed_updated_column)

                cell = gtk.CellRendererText()

                installed_updated_column.pack_start(cell, True)

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

                self.w_review_treeview.expand_all()

                try:

                        dic_createplan = \

                            {

                                "on_cancelcreateplan_clicked": \

                                    self.__on_cancelcreateplan_clicked,

                            }

                        dic_installupdate = \

                            {

                                "on_cancel_button_clicked": \

                                    self.__on_cancel_button_clicked,

                                "on_next_button_clicked":self.__on_next_button_clicked,

                            }

                        dic_downloadingfiles = \

                            {

                                "on_canceldownload_clicked": \

                                    self.__on_cancel_download_clicked,

                            }

                        dic_networkdown = \

                            {

                                "on_networkdown_close_clicked": \

                                    self.__on_networkdown_close_clicked,

                            }

                        w_tree_createplan.signal_autoconnect(dic_createplan)

                        w_tree_installupdate.signal_autoconnect(dic_installupdate)

                        w_tree_downloadingfiles.signal_autoconnect(dic_downloadingfiles)

                        w_tree_networkdown.signal_autoconnect(dic_networkdown)

                except AttributeError, error:

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

                            Check installupdate.py signals') \

                            % error

                if image_update or ips_update:

                        list_of_packages = install_list

                else:

                        list_of_packages = self.__prepare_list_of_packages()

                # XXX Hidden until progress will give information about fmri                        

                self.w_installingdialog_expander.hide()

                pulse_t = Thread(target = self.__progressdialog_progress_pulse)

                thread = Thread(target = self.__plan_the_install_updateimage, \

                    args = (list_of_packages, ))

                pulse_t.start()

                thread.start()

                self.w_createplan_label.set_text(\

                    self.parent._("Checking package dependencies..."))

                self.w_createplancancel_button.set_sensitive(True)           

                self.w_createplan_dialog.run()

        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'''

                self.ip.image.history.operation_result = \

                    history.RESULT_CANCELED

                self.w_createplan_label.set_text(\

                    self.parent._("Canceling..."))

                self.w_createplancancel_button.set_sensitive(False)                    

                self.gui_thread.cancel()

        def __on_cancel_button_clicked(self, widget):

                '''Handler for signal send by cancel button, which is available for the 

                user after evaluation stage on the dialog showing what will be installed

                or updated'''

                self.ip.image.history.operation_result = \

                    history.RESULT_CANCELED

                self.gui_thread.cancel()

                self.w_installupdate_dialog.destroy()

        def __on_next_button_clicked(self, widget):

                '''Handler for signal send by next button, which is available for the 

                user after evaluation stage on the dialog showing what will be installed

                or updated'''

                download_thread = Thread(target = self.__download_stage, args = ())

                download_thread.start()

        def __on_cancel_download_clicked(self, widget):

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

                download stage.'''

                self.ip.image.history.operation_result = \

                    history.RESULT_CANCELED

                self.gui_thread.cancel()

                self.w_downloadingfiles_dialog.destroy()

        def __on_networkdown_close_clicked(self, widget):

                '''Handler for signal send by close button on the dialog showing that

                there was some problem with the network connection.'''

                self.ip.image.history.operation_result = \

                    history.RESULT_FAILED_TRANSPORT

                self.gui_thread.cancel()

                self.w_networkdown_dialog.destroy()

        def __update_createplan_progress(self, action):

                buf = self.w_createplan_textview.get_buffer()

                textiter = buf.get_end_iter()

                buf.insert(textiter, action)

        def __progressdialog_progress_pulse(self):

                while not self.progress_stop_timer_thread:

                        gobject.idle_add(self.w_createplan_progressbar.pulse)

                        time.sleep(0.1)

        def __update_download_progress(self, cur_bytes, total_bytes):

                prog = float(cur_bytes)/total_bytes

                self.w_download_progressbar.set_fraction(prog)

                a = str(cur_bytes/1024)

                b = str(total_bytes/1024)

                c = "Downloaded: " + a + " / " + b + " KB"

                self.w_download_progressbar.set_text(c)

        def __update_install_progress(self, current, total):

                prog = float(current)/total

                self.w_installing_progressbar.set_fraction(prog)

        def __update_install_pulse(self):

                while not self.progress_stop_timer_thread:

                        self.progress_stop_timer_running = True

                        gobject.idle_add(self.w_installing_progressbar.pulse)

                        time.sleep(0.1)

                self.progress_stop_timer_running = False

        def __prepare_list_of_packages(self):

                ''' This method return the dictionary of 

                images and newest marked packages'''

                fmri_to_install_update = {}

                for row in self.install_list:

                        if row[enumerations.MARK_COLUMN]:

                                image = row[enumerations.IMAGE_OBJECT_COLUMN]

                                packages = row[enumerations.PACKAGE_OBJECT_COLUMN]

                                im = fmri_to_install_update.get(image)

                                # XXX Hack to be bug to bug compatible - incorporations

                                pkg_name = packages[0].get_name()

                                if im:

                                        im.append(pkg_name)

                                else:

                                        fmri_to_install_update[image] = [pkg_name, ]

                return fmri_to_install_update

        def __plan_the_install_updateimage(self, list_of_packages):

                '''Function which plans the image'''

                self.gui_thread.run()

                filters = []

                verbose = False

                noexecute = False

                for image in list_of_packages:

                        # Take a list of packages, specified in pkg_list, and attempt

                        # to assemble an appropriate image plan.  This is a helper

                        # routine for some common operations in the client.

                        #

                        # This method checks all authorities for a package match;

                        # however, it defaults to choosing the preferred authority

                        # when an ambiguous package name is specified.  If the user

                        # wishes to install a package from a non-preferred authority,

                        # the full FMRI that contains an authority should be used

                        # to name the package.

                        pkg_list = list_of_packages.get(image)

                        error = 0

                        self.ip = imageplan.ImagePlan(image, self, filters = filters)

                        if self.image_update:

                                self.ip.image.history.operation_name = \

                                    "image-update"

                        else:

                                self.ip.image.history.operation_name = \

                                    "install"

                        self.__load_optional_dependencies(image)

                        for p in pkg_list:

                                try:

                                        conp = image.apply_optional_dependencies(p)

                                        matches = list(image.inventory([ conp ],

                                            all_known = True))

                                except (RuntimeError, InventoryException):

                                        # XXX Module directly printing.

                                        error = 1

                                        continue

                                pnames = {}

                                pmatch = []

                                npnames = {}

                                npmatch = []

                                for m, state in matches:

                                        if m.preferred_authority():

                                                pnames[m.get_pkg_stem()] = 1

                                                pmatch.append(m)

                                        else:

                                                npnames[m.get_pkg_stem()] = 1

                                                npmatch.append(m)

                                if len(pnames.keys()) > 1:

                                        # XXX Module directly printing.

                                        error = 1

                                        continue

                                elif len(pnames.keys()) < 1 and len(npnames.keys()) > 1:

                                        # XXX Module directly printing.

                                        error = 1

                                        continue

                                # matches is a list reverse sorted by version, so take

                                # the first; i.e., the latest.

                                if len(pmatch) > 0:

                                        self.ip.propose_fmri(pmatch[0])

                                else:

                                        self.ip.propose_fmri(npmatch[0])

                        if error != 0:

                                raise RuntimeError, "Unable to assemble image plan"

                        self.ip.image.history.operation_start_state = \

                            self.ip.get_plan()

                        try:

                                self.__evaluate(image)

                        except CancelException, e:

                                self.progress_stop_timer_thread = True

                                gobject.idle_add(self.w_createplan_dialog.hide)

                        else:

                                self.ip.image.history.operation_end_state = \

                                    self.ip.get_plan(full=False)

                        image.imageplan = self.ip

                return

        def __load_optional_dependencies(self, image):

                for b_fmri in image.gen_installed_pkgs():

                        if self.gui_thread.is_cancelled():

                                return

                        mfst = image.get_manifest(b_fmri, filtered = True)

                        for dep in mfst.gen_actions_by_type("depend"):

                                required, min_fmri, max_fmri = dep.parse(image)

                                if required == False:

                                        image.update_optional_dependency(min_fmri)

        def __evaluate(self, image):

                '''Code duplication from imageplan.evaluate()'''

                assert self.ip.state == imageplan.UNEVALUATED

                self.ip.progtrack.evaluate_start()

                outstring = ""

                # Operate on a copy, as it will be modified in flight.

                for f in self.ip.target_fmris[:]:

                        self.ip.progtrack.evaluate_progress()

                        try:

                                self.__evaluate_fmri(f, image)

                        except KeyError, e:

                                outstring += "Attemping to install %s causes:\n\t%s\n" % \

                                    (f.get_name(), e)

                        except NameError:

                                gobject.idle_add(self.__creating_plan_net_error)

                                return

                if outstring:

                        raise RuntimeError("No packages were installed because "

                            "package dependencies could not be satisfied\n" +

                            outstring)                        

                for f in self.ip.target_fmris:

                        self.ip.add_pkg_plan(f)

                        self.ip.progtrack.evaluate_progress()

                for f in self.ip.target_rem_fmris[:]:

                        self.ip.evaluate_fmri_removal(f)

                        self.ip.progtrack.evaluate_progress()

                # we now have a workable set of packages to add/upgrade/remove

                # now combine all actions together to create a synthetic single

                # step upgrade operation, and handle editable files moving from

                # package to package.  See theory comment in execute, below.

                self.ip.state = imageplan.EVALUATED_PKGS

                self.ip.removal_actions = [ (p, src, dest)

                                         for p in self.ip.pkg_plans

                                         for src, dest in p.gen_removal_actions()

                ]

                self.ip.update_actions = [ (p, src, dest)

                                        for p in self.ip.pkg_plans

                                        for src, dest in p.gen_update_actions()

                ]

                self.ip.install_actions = [ (p, src, dest)

                                         for p in self.ip.pkg_plans

                                         for src, dest in p.gen_install_actions()

                ]

                self.ip.progtrack.evaluate_progress()

                # iterate over copy of removals since we're modding list

                # keep track of deletion count so later use of index works

                named_removals = {}

                deletions = 0

                for i, a in enumerate(self.ip.removal_actions[:]):

                        # remove dir removals if dir is still in final image

                        if a[1].name == "dir" and \

                            os.path.normpath(a[1].attrs["path"]) in \

                            self.ip.get_directories():

                                del self.ip.removal_actions[i - deletions]

                                deletions += 1

                                continue

                        # store names of files being removed under own name

                        # or original name if specified

                        if a[1].name == "file":

                                attrs = a[1].attrs

                                fname = attrs.get("original_name",

                                    "%s:%s" % (a[0].origin_fmri.get_name(), attrs["path"]))

                                named_removals[fname] = \

                                    (i - deletions,

                                    id(self.ip.removal_actions[i-deletions][1]))

                self.ip.progtrack.evaluate_progress()

                for a in self.ip.install_actions:

                        # In order to handle editable files that move their path or

                        # change pkgs, for all new files with original_name attribute,

                        # make sure file isn't being removed by checking removal list.

                        # if it is, tag removal to save file, and install to recover

                        # cached version... caching is needed if directories

                        # are removed or don't exist yet.

                        if a[2].name == "file" and "original_name" in a[2].attrs and \

                            a[2].attrs["original_name"] in named_removals:

                                cache_name = a[2].attrs["original_name"]

                                index = named_removals[cache_name][0]

                                assert(id(self.ip.removal_actions[index][1]) ==

                                       named_removals[cache_name][1])

                                self.ip.removal_actions[index][1].attrs["save_file"] = \

                                    cache_name

                                a[2].attrs["save_file"] = cache_name

                self.ip.progtrack.evaluate_progress()

                # Go over update actions

                l_actions = self.ip.get_link_actions()

                l_refresh = []

                for a in self.ip.update_actions:

                        # for any files being updated that are the target of

                        # _any_ hardlink actions, append the hardlink actions

                        # to the update list so that they are not broken...

                        if a[2].name == "file":

                                path = a[2].attrs["path"]

                                if path in l_actions:

                                        l_refresh.extend([(a[0], l, l) for l in l_actions[path]])

                self.ip.update_actions.extend(l_refresh)

                # sort actions to match needed processing order

                self.ip.removal_actions.sort(key = lambda obj:obj[1], reverse=True)

                self.ip.update_actions.sort(key = lambda obj:obj[2])

                self.ip.install_actions.sort(key = lambda obj:obj[2])

                self.ip.progtrack.evaluate_done()

                self.ip.state = imageplan.EVALUATED_OK

        def __creating_plan_net_error(self):

                '''Helper method which shows the dialog informing user that there was

                problem with network connection'''

                self.progress_stop_timer_thread = True

                self.w_createplan_dialog.hide()

                self.w_networkdown_dialog.show()

        def __evaluate_fmri(self, pfmri, image):

                if self.gui_thread.is_cancelled():

                        raise CancelException

                gobject.idle_add(self.__update_createplan_progress, \

                    self.parent._("Evaluating: %s\n") % pfmri.get_fmri())

                self.ip.progtrack.evaluate_progress()

                m = image.get_manifest(pfmri)

                # [manifest] examine manifest for dependencies

                for a in m.actions:

                        if a.name != "depend":

                                continue

                        type = a.attrs["type"]