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

#

'''Transfer IPS checkpoint. Sub-class of the checkpoint class'''

import abc

import copy

import gettext

import locale

import os

import shutil

import pkg.client.api as api

import pkg.client.api_errors as api_errors

import pkg.client.image as image

import pkg.client.progress as progress

import pkg.client.publisher as publisher

import pkg.misc as misc

from pkg.fmri import PkgFmri

from pkg.client import global_settings

from pkg.client.api import IMG_TYPE_ENTIRE, IMG_TYPE_PARTIAL

from solaris_install import PKG5_API_VERSION

from solaris_install.engine.checkpoint import AbstractCheckpoint as Checkpoint

from solaris_install.engine import InstallEngine

from solaris_install.transfer.info import Args

from solaris_install.transfer.info import Destination

from solaris_install.transfer.info import Facet

from solaris_install.transfer.info import Image

from solaris_install.transfer.info import ImType

from solaris_install.transfer.info import IPSSpec

from solaris_install.transfer.info import Mirror

from solaris_install.transfer.info import Origin

from solaris_install.transfer.info import Property

from solaris_install.transfer.info import Publisher

from solaris_install.transfer.info import Software

from solaris_install.transfer.info import Source

from solaris_install.transfer.info import ACTION, CONTENTS, \

PURGE_HISTORY, APP_CALLBACK, IPS_ARGS, UPDATE_INDEX, REJECT_LIST

from solaris_install.transfer.prog import ProgressMon

LICENSE_ACCEPTED = "automatically accepted"

LICENSE_NOT_DISP = "not displayed"

PKG_CLIENT_NAME = "transfer module"

global_settings.client_name = PKG_CLIENT_NAME

misc.setlocale(locale.LC_ALL, "")

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

class AbstractIPS(Checkpoint):

    '''Subclass for transfer IPS checkpoint'''

    __metaclass__ = abc.ABCMeta

    # Variables associated with the package image

    DEF_REPO_URI = "http://pkg.opensolaris.org/release"

    # Variables used in calculating the image size

    DEFAULT_PROG_EST = 10

    DEFAULT_SIZE = 1000

    DEFAULT_PKG_NUM = 5

    # Variables used to check system version info

    SYSTEM_IMAGE = "/"

    ENT_PKG = ["entire"]

    SYSTEM_CLIENT_NAME = "host"

    INFO_NEEDED = api.PackageInfo.ALL_OPTIONS

    # Action variables

    CREATE = "create"

    EXISTING = "use_existing"

    UPDATE = "update"

    def __init__(self, name, zonename=None, show_stdout=False):

        super(AbstractIPS, self).__init__(name)

        # attributes per image

        self.dst = None

        self.img_action = self.CREATE

        self.index = False

        self.src = None   # [(pub_name, [origin], [mirror])]

        self.image_args = {}

        self.completeness = IMG_TYPE_ENTIRE

        self.is_zone = False

        self.zonename = zonename

        self.show_stdout = show_stdout

        self.facets = {}

        self.properties = {}

        # To be used for progress reporting

        self.distro_size = 0

        self.give_progress = False

        # Handle for the progress monitor

        self.pmon = None

        # handle for the ips api

        self.api_inst = None

        # Determines whether a dry run occurs

        self.dry_run = False

        # Flag to cancel whatever action is going on.

        self._cancel_event = False

        # Set the progress tracker for IPS operations.

        if self.show_stdout:

            try:

            except progress.ProgressTrackerException:

        else:

        # local attributes used to create the publisher.

        self._publ = None

        self._origin = []

        self._mirror = []

        self._add_publ = []

        self._add_origin = []

        self._add_mirror = []

        self._image_args = {}

        # list for holding package plans (publisher, package, version)

        self._package_dict = {}

        # publisher list to hold a reference between publishers and

        # origins/mirrors

        self.publisher_list = list()

        # List to hold dictionaries of transfer actions

        self._transfer_list = []

    def get_size(self):

        '''Compute the size of the transfer specified.'''

        self._parse_input()

        self._validate_input()

        num_pkgs = 0

        for trans in self._transfer_list:

            num_pkgs += len(trans.get(CONTENTS))

        return self.DEFAULT_SIZE * (num_pkgs / self.DEFAULT_PKG_NUM)

    def get_progress_estimate(self):

        '''Returns an estimate of the time this checkpoint will

           take.

        '''

        if self.distro_size == 0:

            self.distro_size = self.get_size()

        progress_estimate = \

            int((float(self.distro_size) / self.DEFAULT_SIZE) * \

                self.DEFAULT_PROG_EST)

        self.give_progress = True

        return progress_estimate

    def cancel(self):

        '''Cancel the transfer in progress'''

        self._cancel_event = True

        if self.api_inst:

            self.api_inst.cancel()

    def execute(self, dry_run=False):

        '''Execute method for the IPS checkpoint module. Will read the

           input parameters and perform the specified transfer.

        '''

        self.logger.debug("=== Executing %s Checkpoint ===" % self.name)

        try:

            if self.give_progress:

                self.logger.report_progress("Beginning IPS transfer", 0)

            self.dry_run = dry_run

            # Read the parameters from the DOC and put into the

            # local attributes.

            self._parse_input()

            # Validate the attributes

            self._validate_input()

            # Get the handle to the IPS image api.

            if not self.dry_run:

                self.get_ips_api_inst()

            # Perform the transferring of the bit/updating of the image.

            self._transfer()

            if not self.dry_run:

                # Check to see that the entire package on the host system

                # matches the package in the target image, if the entire

                # package is included in the package list.  Log a warning

                # message if the versions don't match.

                # If it isn't found in the package list or on the system,

                # this isn't an error. Continue with the installation.

                for trans_val in self._transfer_list:

                    if trans_val.get(ACTION) == "install":

                        for pkg in trans_val.get(CONTENTS):

                            if "entire" in pkg:

                                sysinst = api.ImageInterface(self.SYSTEM_IMAGE,

                                                       PKG5_API_VERSION,

                                                       self.prog_tracker,

                                                       False,

                                                       self.SYSTEM_CLIENT_NAME)

                                installer_entire_info = \

                                     sysinst.info(fmri_strings=self.ENT_PKG,

                                                  local=True,

                                                  info_needed=self.INFO_NEEDED)

                                target_entire_info = self.api_inst.info(

                                                  fmri_strings=self.ENT_PKG,

                                                  local=True,

                                                  info_needed=self.INFO_NEEDED)

                                if not installer_entire_info[

                                    api.ImageInterface.INFO_FOUND] or \

                                    not target_entire_info[

                                    api.ImageInterface.INFO_FOUND]:

                                    continue

                                installer_entire_pi = \

                                    installer_entire_info[ \

                                        api.ImageInterface.INFO_FOUND][0]

                                target_entire_pi = \

                                    target_entire_info[ \

                                        api.ImageInterface.INFO_FOUND][0]

                                if installer_entire_pi.branch != \

                                    target_entire_pi.branch:

                                    self.logger.warning("Version mismatch: ")

                                    self.logger.warning(

                                        "Installer build version: %s" %

                                        (installer_entire_pi.fmri))

                                    self.logger.warning(

                                        "Target build version: %s" %

                                        (target_entire_pi.fmri))

            self.check_cancel_event()

        except api_errors.CatalogRefreshException, cre:

            #  Handle CatalogRefreshException especially since it doesn't

            #  pretty-print it's contents in a __str__() impl.

            raise RuntimeError(self.catalog_failures_to_str(cre))

        finally:

            self._cleanup()

    @abc.abstractmethod

    def _parse_input(self):

        '''This method is required to be implemented by all subclasses.'''

        raise NotImplementedError

    def _validate_input(self):

        '''Do whatever validation is necessary on the attributes.'''

        self.logger.debug("Validating IPS input")

        # dst is required

        if self.dst is None:

            raise ValueError("IPS destination must be specified")

        if self.img_action not in (self.EXISTING, self.CREATE, self.UPDATE):

            raise ValueError("The IPS action is not valid: %s" %

                              self.img_action)

        self.logger.debug("Destination: %s", self.dst)

        self.logger.debug("Image action: %s", self.img_action)

        if self.completeness == "full":

            self.completeness = IMG_TYPE_ENTIRE

            self.logger.debug("Image Type: full")

        elif self.completeness == "partial":

            self.completeness = IMG_TYPE_PARTIAL

            self.logger.debug("Image Type: partial")

        if self.is_zone:

            self.logger.debug("Image Variant: zone")

            # For images of type zone, we need the zonename so that

            # we can construct the linked image name when attaching

            # it to the parent image.

            if not self.zonename:

                raise ValueError("For images of type 'zone', a zonename "

                                 "must be provided.")

        not_allowed = set(["prefix", "repo_uri", "origins", "mirrors"])

        img_args = set(self.image_args.keys())

        overlap = list(not_allowed & img_args)

        if overlap:

            raise ValueError("The following components may be specified "

                             "with the source component of the manifest but "

                             "are invalid as args: " + str(overlap))

        self.prog_tracker = self.image_args.get("progtrack", self.prog_tracker)

        invalid_prefix_uri = None

        if self.img_action == self.CREATE:

            # Set the image args we always want set.

            self.set_image_args()

        elif not self.dry_run and not self._publ:

            # It's either None or empty string, so fail

            # Should always have index 0 since DTD won't allow otherwise, but

            # should ignore in case of dry_run since unlikely to be set.

            invalid_prefix_uri = self._origin[0]

        if invalid_prefix_uri is None:

            for idx, element in enumerate(self._add_publ):

                if not element:

                    # It's either None or empty string, so fail

                    # Should always have index 0 since DTD won't allow

                    # otherwise.

                    invalid_prefix_uri = self._add_origin[idx][0]

                    break

        if invalid_prefix_uri is not None:

            raise ValueError(

                "Only the publisher being used for image creation can have\n"

                "its prefix auto-discovered, please specify the prefix for\n"

                "the publisher with the URI:\n  %s"

                % invalid_prefix_uri)

    def _transfer(self):

        '''If an update of the image has been specified, the publishers of the

           existing image are examined.  If a matching publisher is found, the

           origins and mirrors (if present) are reset to the desired entries.

           All other publishers in the image are removed and the new additional

           publishers are added.  Then properties are set, if specified and the

           transfer specific operations of install, uninstall and purge history

           are performed.

           If creation of the image has been specified, the additional

           publishers are added to the image, properties are set and the

           transfer specific operations of install, uninstall and purge history

           are performed.

        '''

        if self.give_progress and self.distro_size != 0:

            # Start up the ProgressMon to report progress

            # while the actual transfer is taking place.

            self.pmon = ProgressMon(logger=self.logger)

            self.pmon.startmonitor(self.dst, self.distro_size, 0, 100)

        if self.img_action == self.EXISTING and self._publ \

           and not self.dry_run:

            # See what publishers/origins/mirrors we have

            self.logger.debug("Updating the publishers")

            pub_list = self.api_inst.get_publishers(duplicate=True)

            self.logger.info("Setting post-install publishers to:")

            self.print_repository_uris()

            # Look to see if the publisher in _publ is already in the Image

            if self.api_inst.has_publisher(prefix=self._publ):

                # update the publisher

                pub = self.api_inst.get_publisher(prefix=self._publ,

                                                  duplicate=True)

                self.logger.debug("Updating publisher information for " \

                                  "%s" % str(self._publ))

                repository = pub.repository

                repository.reset_origins()

                repository.reset_mirrors()

                for origin in self._origin:

                    repository.add_origin(origin)

                if self._mirror is not None:

                    for mirror in self._mirror:

                        repository.add_mirror(mirror)

                self.api_inst.update_publisher(pub=pub, refresh_allowed=False,

                                               search_first=True)

            else:

                # create a new publisher and set it to the highest ranked

                # publisher

                if self._mirror:

                    repo = publisher.Repository(mirrors=self._mirror,

                                                origins=self._origin)

                else:

                    repo = publisher.Repository(origins=self._origin)

                pub = publisher.Publisher(prefix=self._publ, repository=repo)

                self.api_inst.add_publisher(pub=pub, refresh_allowed=False,

                                            search_first=True)

            # the highest ranking publisher has been set.  Walk the other

            # publishers in the list and remove them.

            for pub in self.api_inst.get_publishers(duplicate=True)[1:]:

                self.api_inst.remove_publisher(prefix=pub.prefix)

        # Add specified publishers/origins/mirrors to the image.

        for idx, element in enumerate(self._add_publ):

            # If this publisher doesn't already exist, add it.  (In dry_run

            # mode, api_inst is not initialized so always add these publishers

            # as additionals because we know they won't be pre-existing.)

            if self.dry_run or not self.api_inst.has_publisher(prefix=element):

                self.logger.debug("Adding additional publisher %s" % \

                                  str(element))

                if self._add_mirror[idx]:

                    repo = publisher.Repository(mirrors=self._add_mirror[idx],

                                                origins=self._add_origin[idx])

                else:

                    repo = publisher.Repository(origins=self._add_origin[idx])

                pub = publisher.Publisher(prefix=element, repository=repo)

                if not self.dry_run:

                    self.api_inst.add_publisher(pub=pub, refresh_allowed=False)

            # Else update the existing publisher with this spec

            else:

                self.logger.debug("Updating publisher information for " \

                                  "%s" % str(element))

                pub = self.api_inst.get_publisher(prefix=element,

                                                  duplicate=True)

                repository = pub.repository

                if self._add_origin[idx]:

                    for origin in self._add_origin[idx]:

                        if not repository.has_origin(origin):

                            repository.add_origin(origin)

                if self._add_mirror[idx]:

                    for mirror in self._add_mirror[idx]:

                        if not repository.has_mirror(mirror):

                            repository.add_mirror(mirror)

                self.api_inst.update_publisher(pub=pub, refresh_allowed=False)

        # Get the publisher information of what the image is set with now.

        # Re-set publisher_list to that list, so that it can be used later

        # to be printed out

        if not self.dry_run:

            pub_list = self.api_inst.get_publishers(duplicate=True)

            pub_list_for_print = list()

            for pub in pub_list:

                repo = pub.repository

                origin_uris = list()

                mirror_uris = list()

                if repo.origins:

                    for origin in repo.origins:

                        origin_uris.append(origin.uri)

                if repo.mirrors:

                    for mirror in repo.mirrors:

                        mirror_uris.append(mirror.uri)

                pub_list_for_print.append((pub.prefix, origin_uris,

                    mirror_uris))

            self.publisher_list = pub_list_for_print

        if self.dry_run:

            self.logger.debug("Dry Run: publishers updated")

        self.check_cancel_event()

        if self.properties and not self.dry_run:

            # Update properties if needed.

            self.logger.debug("Updating image properties")

            img = self.api_inst.img

            for prop in self.properties.keys():

                if prop == "preferred-publisher":

                    # Can't set preferred-publisher via set_property, you

                    # must use set_preferred_publisher

                    img.set_highest_ranked_publisher(

                        prefix=self.properties[prop])

                else:

                    if isinstance(self.properties[prop], bool):

                        self.properties[prop] = str(self.properties[prop])

                    img.set_property(prop, self.properties[prop])

        # Refresh publishers now that we've set the publishers,  otherwise

        # avoid/unavoid will not work and will cause install failures

        if not self.dry_run:

            self.api_inst.refresh(immediate=True)

        # Perform the transfer specific operations.

        for trans_val in self._transfer_list:

            if trans_val.get(ACTION) == "install":

                self.check_cancel_event()

                callback = trans_val.get(APP_CALLBACK)

                if trans_val.get(CONTENTS):

                    self.logger.info("Installing packages from:")

                    self.print_repository_uris()