#!/usr/bin/python

#

# 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.

#

from collections import namedtuple

import errno

import operator

import os

import traceback

from pkg.client import global_settings

logger = global_settings.logger

import pkg.actions

import pkg.catalog

import pkg.client.actuator   as actuator

import pkg.client.indexer    as indexer

import pkg.client.api_errors as api_errors

import pkg.client.pkgplan    as pkgplan

import pkg.client.pkg_solver as pkg_solver

import pkg.fmri

import pkg.manifest          as manifest

import pkg.search_errors     as se

import pkg.version

import sys

from pkg.client.debugvalues import DebugValues

UNEVALUATED       = 0 # nothing done yet

EVALUATED_PKGS    = 1 # established fmri changes

EVALUATED_OK      = 2 # ready to execute

PREEXECUTED_OK    = 3 # finished w/ preexecute

PREEXECUTED_ERROR = 4 # whoops

EXECUTED_OK       = 5 # finished execution

EXECUTED_ERROR    = 6 # failed

class ImagePlan(object):

        """ImagePlan object contains the plan for changing the image...

        there are separate routines for planning the various types of

        image modifying operations; evaluation (comparing manifests

        and buildig lists of removeal, install and update actions

        and their execution is all common code"""

        PLANNED_NOTHING   = "no-plan"

        PLANNED_INSTALL   = "install"

        PLANNED_UNINSTALL = "uninstall"

        PLANNED_UPDATE    = "image-update"

        PLANNED_FIX       = "fix"

        PLANNED_VARIANT   = "change-variant"

        def __init__(self, image, progtrack, check_cancel, noexecute=False):

                self.image = image

                self.pkg_plans = []

                self.state = UNEVALUATED

                self.__progtrack = progtrack

                self.__noexecute = noexecute

                self.__fmri_changes = [] # install  (None, fmri)

                                         # update   (oldfmri, newfmri)

                                         # remove   (oldfmri, None)

                                         # reinstall(oldfmri, oldfmri)

                # Used to track users and groups that are part of operation.

                self.added_groups = {}

                self.removed_groups = {}

                self.added_users = {}

                self.removed_users = {}

                self.update_actions  = []

                self.removal_actions = []

                self.install_actions = []

                # The set of processed target object directories known to be

                # valid (those that are not symlinks and thus are valid for

                # use during installation).  This is used by the pkg.actions

                # classes during install() operations.

                self.valid_directories = set()

                # A place to keep info about saved_files; needed by file action.

                self.saved_files = {}

                self.__target_install_count = 0

                self.__target_update_count  = 0

                self.__target_removal_count = 0

                self.__directories = None  # implement ref counting

                self.__symlinks = None     # for dirs and links and

                self.__hardlinks = None    # hardlinks

                self.__cached_actions = {} 

                self.__old_excludes = image.list_excludes()

                self.__new_excludes = self.__old_excludes

                self.__check_cancelation = check_cancel

                self.__actuators = None

                self.update_index = True

                self.__preexecuted_indexing_error = None

                self._planned_op = self.PLANNED_NOTHING

                self.__pkg_solver = None

                self.__new_variants = None

                self.__new_facets = None

                self.__variant_change = False

                self.__references = {} # dict of fmri -> pattern

        def __str__(self):

                if self.state == UNEVALUATED:

                        s = "UNEVALUATED:\n"

                        return s

                s = "%s\n" % self.__pkg_solver 

                if self.state < EVALUATED_PKGS:

                        return s

                s += "Package version changes:\n"

                for pp in self.pkg_plans:

                        s += "%s -> %s\n" % (pp.origin_fmri, pp.destination_fmri)

                if self.__actuators:

                        s = s + "Actuators:\n%s\n" % self.__actuators

                if self.__old_excludes != self.__new_excludes:

                        s = s + "Variants/Facet changes: %s -> %s\n" % (self.__old_excludes,

                            self.__new_excludes)

                return s

        def __verbose_str(self):

                s = str(self)

                if self.state == EVALUATED_PKGS:

                        return s

                s = s + "Actions being removed:\n"

                for pplan, o_action, ignore in self.removal_actions:

                        s = s + "\t%s:%s\n" % ( pplan.origin_fmri, o_action)

                s = s + "\nActions being updated:\n"

                for pplan, o_action, d_action in self.update_actions:

                        s = s + "\t%s:%s -> %s%s\n" % ( 

                            pplan.origin_fmri, o_action,

                            pplan.destination_fmri, d_action )

                s = s + "\nActions being installed:\n"

                for pplan, ignore, d_action in self.removal_actions:

                        s = s + "\t%s:%s\n" % ( pplan.destination_fmri, d_action)

                return s

        @property

        def planned_op(self):

                """Returns a constant value indicating the type of operation

                planned."""

                return self._planned_op

        def show_failure(self, verbose):

                """Here's where extensive messaging needs to go"""

                if self.__pkg_solver:

                        logger.info(_("Planning for %s failed: %s\n") % 

                            (self._planned_op, self.__pkg_solver.gen_failure_report(verbose)))

        def __plan_op(self, op):

                """Private helper method used to mark the start of a planned

                operation."""

                self._planned_op = op

                self._image_lm = self.image.get_last_modified()

        def plan_install(self, pkgs_to_install):

                """Determine the fmri changes needed to install the specified pkgs"""

                self.__plan_op(self.PLANNED_INSTALL)

                # get ranking of publishers

                pub_ranks = self.image.get_publisher_ranks()

                # build installed dict

                installed_dict = ImagePlan.__fmris2dict(self.image.gen_installed_pkgs())

                # build installed publisher dictionary

                installed_pubs = dict((

                                (f.pkg_name, f.get_publisher()) 

                                for f in installed_dict.values()

                                ))

                proposed_dict, self.__references = self.match_user_fmris(pkgs_to_install, 

                    True, pub_ranks, installed_pubs)

                # instantiate solver

                self.__pkg_solver = pkg_solver.PkgSolver(

                    self.image.get_catalog(self.image.IMG_CATALOG_KNOWN),

                    installed_dict, 

                    pub_ranks,

                    self.image.get_variants(),

                    self.__progtrack)

                # Solve... will raise exceptions if no solution is found 

                new_vector = self.__pkg_solver.solve_install([], proposed_dict, 

                    self.__new_excludes)

                self.__fmri_changes = [ 

                        (a, b)

                        for a, b in ImagePlan.__dicts2fmrichanges(installed_dict, 

                            ImagePlan.__fmris2dict(new_vector))

                        if a != b

                        ]

                self.state = EVALUATED_PKGS

        def plan_uninstall(self, pkgs_to_uninstall, recursive_removal=False):

                self.__plan_op(self.PLANNED_UNINSTALL)

                proposed_dict, self.__references = self.match_user_fmris(pkgs_to_uninstall, 

                    False, None, None)

                # merge patterns together

                proposed_removals = set([

                                f 

                                for each in proposed_dict.values()

                                for f in each

                                ])

                # build installed dict

                installed_dict = dict([

                        (f.pkg_name, f)

                        for f in self.image.gen_installed_pkgs()

                        ])

                # instantiate solver

                self.__pkg_solver = pkg_solver.PkgSolver(

                    self.image.get_catalog(self.image.IMG_CATALOG_KNOWN),

                    installed_dict, 

                    self.image.get_publisher_ranks(),

                    self.image.get_variants(),

                    self.__progtrack)

                new_vector = self.__pkg_solver.solve_uninstall([], 

                    proposed_removals, recursive_removal, self.__new_excludes)

                self.__fmri_changes = [ 

                        (a, b)

                        for a, b in ImagePlan.__dicts2fmrichanges(installed_dict, 

                            ImagePlan.__fmris2dict(new_vector))

                        if a != b

                        ]

                self.state = EVALUATED_PKGS

        @staticmethod

        def __fmris2dict(fmri_list):

                return  dict([

                        (f.pkg_name, f)

                        for f in fmri_list

                        ])

        @staticmethod

        def __dicts2fmrichanges(olddict, newdict):

                return [

                        (olddict.get(k, None), newdict.get(k, None))

                        for k in set(olddict.keys() + newdict.keys())

                        ]

        def plan_update(self):

                """Determine the fmri changes needed to update all

                pkgs"""

                self.__plan_op(self.PLANNED_UPDATE)

                # build installed dict

                installed_dict = dict([

                        (f.pkg_name, f)

                        for f in self.image.gen_installed_pkgs()

                        ])

                # instantiate solver

                self.__pkg_solver = pkg_solver.PkgSolver(

                    self.image.get_catalog(self.image.IMG_CATALOG_KNOWN),

                    installed_dict, 

                    self.image.get_publisher_ranks(),

                    self.image.get_variants(),

                    self.__progtrack)

                new_vector = self.__pkg_solver.solve_update([],  self.__new_excludes)

                self.__fmri_changes = [ 

                        (a, b)

                        for a, b in ImagePlan.__dicts2fmrichanges(installed_dict, 

                            ImagePlan.__fmris2dict(new_vector))

                        if a != b

                        ]

                self.state = EVALUATED_PKGS

        def plan_fix(self, pkgs_to_fix):

                """Create the list of pkgs to fix"""

                self.__plan_op(self.PLANNED_FIX)

                # XXX complete this

        def plan_change_varcets(self, variants, facets):

                """Determine the fmri changes needed to change

                the specified variants/facets"""

                self.__plan_op(self.PLANNED_VARIANT)

                if variants == None and facets == None: # nothing to do

                        self.state = EVALUATED_PKGS

                        return

                self.__variant_change = True

                # build installed dict

                installed_dict = dict([

                        (f.pkg_name, f)

                        for f in self.image.gen_installed_pkgs()

                        ])

                # instantiate solver

                self.__pkg_solver = pkg_solver.PkgSolver(

                    self.image.get_catalog(self.image.IMG_CATALOG_KNOWN),

                    installed_dict, 

                    self.image.get_publisher_ranks(),

                    self.image.get_variants(),

                    self.__progtrack)

                self.__new_excludes = self.image.list_excludes(variants, facets)

                new_vector = self.__pkg_solver.solve_change_varcets([],

                    variants, facets, self.__new_excludes)

                self.__new_variants = variants

                self.__new_facets   = facets

                self.__fmri_changes = [ 

                        (a, b)

                        for a, b in ImagePlan.__dicts2fmrichanges(installed_dict, 

                            ImagePlan.__fmris2dict(new_vector))              

                        ]

                self.state = EVALUATED_PKGS

                return

        def reboot_needed(self):

                """Check if evaluated imageplan requires a reboot"""

                assert self.state >= EVALUATED_OK

                return self.__actuators.reboot_needed()

        def get_plan(self, full=True):

                if full:

                        return str(self)

                output = ""

                for t in self.__fmri_changes:

                        output += "%s -> %s\n" % t

                return output

        def display(self):

                if DebugValues["plan"]:

                        logger.info(self.__verbose_str())

                else:

                        logger.info(str(self))

        def gen_new_installed_pkgs(self):

                """ generates all the fmris in the new set of installed pkgs"""

                assert self.state >= EVALUATED_PKGS

                fmri_set = set(self.image.gen_installed_pkgs())

                for p in self.pkg_plans:

                        p.update_pkg_set(fmri_set)

                for pfmri in fmri_set:

                        yield pfmri

        def gen_new_installed_actions(self):

                """generates actions in new installed image"""

                assert self.state >= EVALUATED_PKGS

                for pfmri in self.gen_new_installed_pkgs():

                        m = self.image.get_manifest(pfmri)

                        for act in m.gen_actions(self.__new_excludes):

                                yield act

        def gen_new_installed_actions_bytype(self, atype):

                """generates actions in new installed image"""

                assert self.state >= EVALUATED_PKGS

                for pfmri in self.gen_new_installed_pkgs():

                        m = self.image.get_manifest(pfmri)

                        for act in m.gen_actions_by_type(atype,

                            self.__new_excludes):

                                yield act

        def get_directories(self):

                """ return set of all directories in target image """

                # always consider var and var/pkg fixed in image....

                # XXX should be fixed for user images

                if self.__directories == None:

                        dirs = set(["var",

                                    "var/pkg",

                                    "var/sadm",

                                    "var/sadm/install"])

                        for pfmri in self.gen_new_installed_pkgs():

                                m = self.image.get_manifest(pfmri)

                                for d in m.get_directories(self.__new_excludes):

                                        dirs.add(os.path.normpath(d))

                        self.__directories = dirs

                return self.__directories

        def __get_symlinks(self):

                """ return a set of all symlinks in target image"""

                if self.__symlinks == None:

                        self.__symlinks = set((

                                        a.attrs["path"]

                                        for a in self.gen_new_installed_actions_bytype("link")

                                        ))

                return self.__symlinks

        def __get_hardlinks(self):

                """ return a set of all hardlinks in target image"""

                if self.__hardlinks == None:

                        self.__hardlinks = set((

                                        a.attrs["path"]

                                        for a in self.gen_new_installed_actions_bytype("hardlink")

                                        ))

                return self.__hardlinks

        @staticmethod

        def default_keyfunc(name, act):

                """This is the default function used by get_actions when

                the caller provides no key."""

                attr_name = pkg.actions.types[name].key_attr

                return act.attrs[attr_name]

        @staticmethod

        def hardlink_keyfunc(name, act):

                """Keyfunc used in evaluate when calling get_actions

                for hardlinks."""

                return act.get_target_path()

        def get_actions(self, name, key=None):

                """Return a dictionary of actions of the type given by 'name'

                describing the target image.  If 'key' is given and not None,

                the dictionary's key will be the name of the action type's key

                attribute.  Otherwise, it's a callable taking an action as an

                argument which returns the key.  This dictionary is cached for

                quick future lookups."""

                if key is None:

                        key = self.default_keyfunc

                if (name, key) in self.__cached_actions:

                        return self.__cached_actions[(name, key)]

                d = {}

                for act in self.gen_new_installed_actions_bytype(name):

                        t = key(name, act)

                        d.setdefault(t, []).append(act)

                self.__cached_actions[(name, key)] = d

                return self.__cached_actions[(name, key)]

                """Return manifest for pfmri"""