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

import pkg.client.bootenv as bootenv

import pkg.client.image as image

import pkg.client.api_errors as api_errors

import pkg.client.history as history

import pkg.misc as misc

import pkg.fmri as fmri

from pkg.client.imageplan import EXECUTED_OK

import threading

class ImageInterface(object):

        """This class presents an interface to images that clients may use.

        There is a specific order of methods which must be used to install

        or uninstall packages, or update an image. First, plan_install,

        plan_uninstall, or plan_update_all must be called. After that

        method completes successfully, describe may be called, and prepare

        must be called. Finally, execute_plan may be called to implement

        the previous created plan. The other methods do not hav an ordering

        imposed upon them, and may be used as needed. Cancel may only be

        invoked while a cancelable method is running."""

        # Constants used to reference specific values that info can return.

        INFO_FOUND = 0

        INFO_MISSING = 1

        INFO_MULTI_MATCH = 2

        INFO_ILLEGALS = 3

        # Private constants used for tracking which type of plan was made.

        __INSTALL = 1

        __UNINSTALL = 2

        __IMAGE_UPDATE = 3

        def __init__(self, img_path, version_id, progesstracker,

            cancel_state_callable, pkg_client_name):

                """Constructs an ImageInterface. img_path should point to an

                existing image. version_id indicates the version of the api

                the client is expecting to use. progesstracker is the

                progresstracker the client wants the api to use for UI

                callbacks. cancel_state_callable is a function which the client

                wishes to have called each time whether the operation can be

                canceled changes. It can raise VersionException and

                ImageNotFoundException."""

                if version_id not in compatible_versions:

                        raise api_errors.VersionException(CURRENT_API_VERSION,

                            version_id)

                # These variables are private and not part of the API.

                self.img = image.Image()

                self.img.history.client_name = pkg_client_name

                self.img.find_root(img_path)

                self.img.load_config()

                self.progresstracker = progesstracker

                self.cancel_state_callable = cancel_state_callable

                self.plan_type = None

                self.plan_desc = None

                self.prepared = False

                self.executed = False

                self.__can_be_canceled = False

                self.__canceling = False

                self.__activity_lock = threading.Lock()

        def plan_install(self, pkg_list, filters, refresh_catalogs=True,

            noexecute=False, verbose=False, update_index=True):

                """Contructs a plan to install the packages provided in

                pkg_list. pkg_list is a list of packages to install. filters

                is a list of filters to apply to the actions of the installed

                packages. refresh_catalogs controls whether the catalogs will

                automatically be refreshed. noexecute determines whether the

                history will be recorded after planning is finished. verbose

                controls whether verbose debugging output will be printed to the

                terminal. Its existence is temporary. It returns a tuple of

                two things. The first is a boolean which tells the client

                whether there is anything to do. The third is either None, or an

                exception which indicates partial success. It can raise

                InvalidCertException, PlanCreationException,

                NetworkUnavailableException, and InventoryException. The

                noexecute argument is included for compatibility with

                operational history. The hope is it can be removed in the

                future."""

                self.__activity_lock.acquire()

                try:

                        self.__set_can_be_canceled(True)

                        if self.plan_type is not None:

                                raise api_errors.PlanExistsException(

                                    self.plan_type)

                        try:

                                self.img.history.operation_name = "install"

                                # Verify validity of certificates before

                                # attempting network operations

                                if not self.img.check_cert_validity():

                                        raise api_errors.InvalidCertException()

                                self.img.load_catalogs(self.progresstracker)

                                exception_caught = None

                                if refresh_catalogs:

                                        try:

                                                self.img.retrieve_catalogs()

                                        except api_errors.CatalogRefreshException, e:

                                                if not e.succeeded:

                                                        raise

                                                exception_caught = e

                                        # Reload catalog. This picks up the

                                        # update from retrieve_catalogs.

                                        self.img.load_catalogs(

                                            self.progresstracker)

                                self.img.make_install_plan(pkg_list,

                                    self.progresstracker,

                                    self.__check_cancelation, noexecute,

                                    filters=filters, verbose=verbose)

                                assert self.img.imageplan

                                if self.__canceling:

                                        raise api_errors.CanceledException()

                                self.__set_can_be_canceled(False)

                                if not noexecute:

                                        self.plan_type = self.__INSTALL

                                self.plan_desc = PlanDescription(

                                    self.img.imageplan)

                                if self.img.imageplan.nothingtodo() or \

                                    noexecute:

                                        self.img.history.operation_result = \

                                            history.RESULT_NOTHING_TO_DO

                                self.img.imageplan.update_index = update_index

                                res = not self.img.imageplan.nothingtodo()

                        except api_errors.CanceledException:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_CANCELED

                                raise

                        except fmri.IllegalFmri:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_BAD_REQUEST

                                raise

                        except Exception:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_UNKNOWN

                                raise

                finally:

                        self.__activity_lock.release()

                return res, exception_caught

        def plan_uninstall(self, pkg_list, recursive_removal, noexecute=False,

            verbose=False, update_index=True):

                """Contructs a plan to uninstall the packages provided in

                pkg_list. pkg_list is a list of packages to install.

                recursive_removal controls whether recursive removal is

                allowed. noexecute determines whether the history will be

                recorded after planning is finished. verbose controls whether

                verbose debugging output will be printed to the terminal. Its

                existence is temporary. If there are things to do to complete

                the uninstall, it returns True, otherwise it returns False. It

                can raise NonLeafPackageException and PlanCreationException."""

                self.__activity_lock.acquire()

                try:

                        self.__set_can_be_canceled(True)

                        if self.plan_type is not None:

                                raise api_errors.PlanExistsException(

                                    self.plan_type)

                        try:

                                self.img.history.operation_name = "uninstall"

                                self.img.load_catalogs(self.progresstracker)

                                self.img.make_uninstall_plan(pkg_list,

                                    recursive_removal, self.progresstracker,

                                    self.__check_cancelation, noexecute,

                                    verbose=verbose)

                                assert self.img.imageplan

                                if self.__canceling:

                                        raise api_errors.CanceledException()

                                self.__set_can_be_canceled(False)

                                if not noexecute:

                                        self.plan_type = self.__UNINSTALL

                                self.plan_desc = PlanDescription(

                                    self.img.imageplan)

                                if noexecute:

                                        self.img.history.operation_result = \

                                            history.RESULT_NOTHING_TO_DO

                                self.img.imageplan.update_index = update_index

                                res = not self.img.imageplan.nothingtodo()

                        except api_errors.CanceledException:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_CANCELED

                                raise

                        except api_errors.NonLeafPackageException, e:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_CONSTRAINED

                                raise

                        except api_errors.PlanCreationException:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_BAD_REQUEST

                                raise

                        except fmri.IllegalFmri:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_BAD_REQUEST

                                raise

                        except Exception:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_UNKNOWN

                                raise

                finally:

                        self.__activity_lock.release()

                return res

        def plan_update_all(self, actual_cmd, refresh_catalogs=True,

            noexecute=False, force=False, verbose=False, update_index=True):

                """Creates a plan to update all packages on the system to the

                latest known versions. actual_cmd is the command used to start

                the client. It is used to determine the image to check whether

                SUNWipkg is up to date. refresh_catalogs controls whether the

                catalogs will automatically be refreshed. noexecute determines

                whether the history will be recorded after planning is finished.

                force controls whether update should proceed even if ipkg is not

                up to date. verbose controls whether verbose debugging output

                will be printed to the terminal. Its existence is temporary. It

                returns a tuple of three things. The first is a boolean which

                tells the client whether there is anything to do. The second

                tells whether the image is an opensolaris image. The third is

                either None, or an exception which indicates partial success.

                This is currently used to indicate a failure in refreshing

                catalogs. It can raise CatalogRefreshException,

                IpkgOutOfDateException, NetworkUnavailableException, and

                PlanCreationException."""

                self.__activity_lock.acquire()

                try:

                        self.__set_can_be_canceled(True)

                        if self.plan_type is not None:

                                raise api_errors.PlanExistsException(

                                    self.plan_type)

                        try:

                                self.img.history.operation_name = "image-update"

                                exception_caught = None

                                # Verify validity of certificates before

                                # attempting network operations

                                if not self.img.check_cert_validity():

                                        raise api_errors.InvalidCertException()

                                self.img.load_catalogs(self.progresstracker)

                                if refresh_catalogs:

                                        try:

                                                self.img.retrieve_catalogs()

                                        except api_errors.CatalogRefreshException, e:

                                                if not e.succeeded:

                                                        raise

                                                exception_caught = e

                                        # Reload catalog. This picks up the

                                        # update from retrieve_catalogs.

                                        self.img.load_catalogs(

                                            self.progresstracker)

                                # If we can find SUNWipkg and SUNWcs in the

                                # target image, then we assume this is a valid

                                # opensolaris image, and activate some

                                # special case behaviors.

                                opensolaris_image = True

                                fmris, notfound, illegals = \

                                    self.img.installed_fmris_from_args(

                                        ["SUNWipkg", "SUNWcs"])

                                assert(len(illegals) == 0)

                                if notfound:

                                        opensolaris_image = False

                                if opensolaris_image and not force:

                                        try:

                                                if not \

                                                    self.img.ipkg_is_up_to_date(

                                                    actual_cmd,

                                                    self.__check_cancelation,

                                                    noexecute,

                                                    refresh_catalogs):

                                                        self.img.history.operation_result = \

                                                            history.RESULT_FAILED_CONSTRAINED

                                                        raise api_errors.IpkgOutOfDateException()

                                        except api_errors.ImageNotFoundException:

                                                # We can't answer in this case,

                                                # so we proceed

                                                pass

                                pkg_list = [ ipkg.get_pkg_stem()

                                             for ipkg

                                             in self.img.gen_installed_pkgs() ]

                                self.img.make_install_plan(pkg_list,

                                    self.progresstracker,

                                    self.__check_cancelation,

                                    noexecute, verbose=verbose)

                                assert self.img.imageplan

                                if self.__canceling:

                                        self.__reset_unlock()

                                        raise api_errors.CanceledException()

                                self.__set_can_be_canceled(False)

                                if not noexecute:

                                        self.plan_type = self.__IMAGE_UPDATE

                                self.plan_desc = PlanDescription(

                                    self.img.imageplan)

                                if self.img.imageplan.nothingtodo() or \

                                    noexecute:

                                        self.img.history.operation_result = \

                                            history.RESULT_NOTHING_TO_DO

                                self.img.imageplan.update_index = update_index

                                res = not self.img.imageplan.nothingtodo()

                        except api_errors.CanceledException:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_CANCELED

                                raise

                        except api_errors.IpkgOutOfDateException:

                                self.__reset_unlock()

                                raise

                        except Exception:

                                self.__reset_unlock()

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_UNKNOWN

                                raise

                finally:

                        self.__activity_lock.release()

                return res, opensolaris_image, exception_caught

        def describe(self):

                """Returns None if no plan is ready yet, otherwise returns

                a PlanDescription"""

                return self.plan_desc

        def prepare(self):

                """Takes care of things which must be done before the plan

                can be executed. This includes downloading the packages to

                disk and preparing the indexes to be updated during

                execution. It can raise ProblematicPermissionsIndexException,

                and PlanMissingException. Should only be called once a

                plan_X method has been called."""

                self.__activity_lock.acquire()

                self.__set_can_be_canceled(True)

                try:

                        try:

                                if not self.img.imageplan:

                                        raise api_errors.PlanMissingException()

                                if self.prepared:

                                        raise api_errors.AlreadyPreparedException()

                                assert self.plan_type == self.__INSTALL or \

                                    self.plan_type == self.__UNINSTALL or \

                                    self.plan_type == self.__IMAGE_UPDATE

                                try:

                                        self.img.imageplan.preexecute()

                                except search_errors.ProblematicPermissionsIndexException, e:

                                        self.img.cleanup_downloads()

                                        raise api_errors.ProblematicPermissionsIndexException(e)

                                except Exception, e:

                                        self.img.cleanup_downloads()

                                        raise

                                if self.__canceling:

                                        self.img.cleanup_downloads()

                                        raise api_errors.CanceledException()

                                self.prepared = True

                        except Exception:

                                if self.img.history.operation_result:

                                        self.img.history.operation_result = \

                                            history.RESULT_FAILED_UNKNOWN

                                raise

                finally:

                        self.__set_can_be_canceled(False)

                        self.__activity_lock.release()

        def execute_plan(self):

                """Executes the plan. This is uncancelable one it begins. It

                can raise  CorruptedIndexException,

                ProblematicPermissionsIndexException, ImageplanStateException,

                ImageUpdateOnLiveImageException, and PlanMissingException.

                Should only be called after the prepare method has been

                called."""

                self.__activity_lock.acquire()

                self.__set_can_be_canceled(False)

                try:

                        if not self.img.imageplan:

                                raise api_errors.PlanMissingException()

                        if not self.prepared:

                                raise api_errors.PrematureExecutionException()

                        if self.executed:

                                raise api_errors.AlreadyExecutedException()

                        assert self.plan_type == self.__INSTALL or \

                            self.plan_type == self.__UNINSTALL or \

                            self.plan_type == self.__IMAGE_UPDATE

                        try:

                                be = bootenv.BootEnv(self.img.get_root())

                        except RuntimeError:

                                be = bootenv.BootEnvNull(self.img.get_root())

                        if self.plan_type is self.__IMAGE_UPDATE:

                                be.init_image_recovery(self.img)

                                if self.img.is_liveroot():

                                        self.img.history.operation_result = \

                                            history.RESULT_FAILED_BAD_REQUEST

                                        raise api_errors.ImageUpdateOnLiveImageException()

                        try:

                                self.img.imageplan.execute()

                                if self.plan_type is self.__IMAGE_UPDATE:

                                        be.activate_image()

                                else:

                                        be.activate_install_uninstall()

                                ret_code = 0

                        except RuntimeError, e:

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_UNKNOWN

                                if self.plan_type is self.__IMAGE_UPDATE:

                                        be.restore_image()

                                else:

                                        be.restore_install_uninstall()

                                self.img.cleanup_downloads()

                                raise

                        except search_errors.ProblematicPermissionsIndexException, e:

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_STORAGE

                                self.img.cleanup_downloads()

                                raise api_errors.ProblematicPermissionsIndexException(e)

                        except (search_errors.InconsistentIndexException,

                                search_errors.PartialIndexingException), e:

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_SEARCH

                                self.img.cleanup_downloads()

                                raise api_errors.CorruptedIndexException(e)

                        except Exception, e:

                                self.img.history.operation_result = \

                                    history.RESULT_FAILED_UNKNOWN

                                if self.plan_type is self.__IMAGE_UPDATE:

                                        be.restore_image()

                                else:

                                        be.restore_install_uninstall()

                                self.img.cleanup_downloads()

                                raise

                        if self.img.imageplan.state != EXECUTED_OK:

                                if self.plan_type is self.__IMAGE_UPDATE:

                                        be.restore_image()

                                else:

                                        be.restore_install_uninstall()

                                raise api_errors.ImageplanStateException(

                                    self.img.imageplan.state)

                        self.img.cleanup_downloads()

                        self.img.cleanup_cached_content()

                        self.img.history.operation_result = \

                            history.RESULT_SUCCEEDED

                        self.executed = True

                finally:

                        self.__activity_lock.release()

        def refresh(self, full_refresh, auths=None):

                """Refreshes the catalogs. full_refresh controls whether to do

                a full retrieval of the catalog from the authority or only

                update the existing catalog. auths is a list of authorities to

                refresh. Passing an empty list or using the default value means

                all known authorities will be refreshed. While it currently

                returns an image object, this is an expedient for allowing