#!/usr/bin/python2.4

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

import errno

import os

import platform

import shutil

import tempfile

import time

import urllib

from pkg.client import global_settings

logger = global_settings.logger

import pkg.Uuid25

import pkg.catalog

import pkg.client.api_errors            as api_errors

import pkg.client.constraint            as constraint

import pkg.client.history               as history

import pkg.client.imageconfig           as imageconfig

import pkg.client.imageplan             as imageplan

import pkg.client.imagestate            as imagestate

import pkg.client.pkgplan               as pkgplan

import pkg.client.progress              as progress

import pkg.client.publisher             as publisher

import pkg.client.transport.transport   as transport

import pkg.fmri

import pkg.manifest                     as manifest

import pkg.misc                         as misc

import pkg.portable                     as portable

import pkg.server.catalog

import pkg.variant                      as variant

import pkg.version

from pkg.client.debugvalues import DebugValues

from pkg.client.imagetypes import IMG_USER, IMG_ENTIRE

from pkg.misc import CfgCacheError, EmptyI, EmptyDict

img_user_prefix = ".org.opensolaris,pkg"

img_root_prefix = "var/pkg"

IMG_PUB_DIR = "publisher"

class Image(object):

        """An Image object is a directory tree containing the laid-down contents

        of a self-consistent graph of Packages.

        An Image has a root path.

        An Image of type IMG_ENTIRE does not have a parent Image.  Other Image

        types must have a parent Image.  The external state of the parent Image

        must be accessible from the Image's context, or duplicated within the

        Image (IMG_PARTIAL for zones, for instance).

        The parent of a user Image can be a partial Image.  The parent of a

        partial Image must be an entire Image.

        An Image of type IMG_USER stores its external state at self.root +

        ".org.opensolaris,pkg".

        An Image of type IMG_ENTIRE or IMG_PARTIAL stores its external state at

        self.root + "/var/pkg".

        An Image needs to be able to have a different repository set than the

        system's root Image.

        Directory layout

          $IROOT/file

               Directory containing file hashes of installed packages.

          $IROOT/pkg

               Directory containing manifests.

          $IROOT/index

               Directory containing search indices.

          $IROOT/cfg_cache

               File containing image's cached configuration.

          $IROOT/opaque

               File containing image's opaque state.

          $IROOT/publisher

                Directory containing publisher metadata.

        All of these directories and files other than state are considered

        essential for any image to be complete. To add a new essential file or

        subdirectory, the following steps should be done.

        If it's a directory, add it to the image_subdirs list below and it will

        be created automatically. The programmer must fill the directory as

        needed. If a file is added, the programmer is responsible for creating

        that file during image creation at an appropriate place and time.

        If a directory is required to be present in order for an image to be

        identifiable as such, it should go into required_subdirs instead.

        However, upgrade issues abound; this list should probably not change.

        Once those steps have been carried out, the change should be added

        to the test suite for image corruption (t_pkg_install_corrupt_image.py).

        This will likely also involve a change to

        SingleDepotTestCaseCorruptImage in testutils.py. Each of these files

        outline what must be updated.

        XXX Root path probably can't be absolute, so that we can combine or

        reuse Image contents.

        XXX Image file format?  Image file manipulation API?"""

        # Class constants

        IMG_CATALOG_KNOWN = "known"

        IMG_CATALOG_INSTALLED = "installed"

        # Please note that the values of these PKG_STATE constants should not

        # be changed as it would invalidate existing catalog data stored in the

        # image.  This means that if a constant is removed, the values of the

        # other constants should not change, etc.

        # This is a temporary, private state that is used to indicate that

        # a package with state PKG_STATE_INSTALLED was installed from a

        # publisher that was preferred at the time of installation.  It

        # will be obsolete in the near future when publishers are ranked

        # instead.

        __PKG_STATE_PREFERRED = 5

        # This state indicates that a package is present in a repository

        # catalog.

        PKG_STATE_KNOWN = 0

        # This is a transitory state used to indicate that a package is no

        # longer present in a repository catalog; it is only used to clear

        # PKG_STATE_KNOWN.

        PKG_STATE_UNKNOWN = 1

        # This state indicates that a package is installed.

        PKG_STATE_INSTALLED = 2

        # This is a transitory state used to indicate that a package is no

        # longer installed; it is only used to clear PKG_STATE_INSTALLED.

        PKG_STATE_UNINSTALLED = 3

        PKG_STATE_UPGRADABLE = 4

        # These states are used to indicate the package's related catalog

        # version.  This is helpful to consumers of the catalog data so that

        # they can be aware of what metadata may not immediately available

        # (require manifest retrieval) based on the catalog version.

        PKG_STATE_V0 = 6

        PKG_STATE_V1 = 7

        PKG_STATE_OBSOLETE = 8

        PKG_STATE_RENAMED = 9

        # Class properties

        required_subdirs = [ "file", "pkg" ]

        image_subdirs = required_subdirs + [ "index", IMG_PUB_DIR,

            "state/installed", "state/known" ]

        def __init__(self, root, user_provided_dir=False, progtrack=None,

            should_exist=True, imgtype=None, force=False):

                if should_exist:

                        assert(imgtype is None)

                        assert(not force)

                else:

                        assert(imgtype is not None)

                self.__init_catalogs()

                self.__upgraded = False

                self.arch_change = False

                self.attrs = {

                    "Policy-Require-Optional": False,

                    "Policy-Pursue-Latest": True

                }

                self.cfg_cache = None

                self.constraints = constraint.ConstraintSet()

                self.dl_cache_dir = None

                self.dl_cache_incoming = None

                self.history = history.History()

                self.imageplan = None # valid after evaluation succeeds

                self.img_prefix = None

                self.imgdir = None

                self.index_dir = None

                self.is_user_cache_dir = False

                self.new_variants = {}

                self.pkgdir = None

                self.root = root

                # Transport operations for this image

                self.transport = transport.Transport(self)

                if should_exist:

                        self.find_root(self.root, user_provided_dir,

                            progtrack)

                else:

                        if not force and self.image_type(self.root) != None:

                                raise api_errors.ImageAlreadyExists(self.root)

                        if not force and os.path.exists(self.root) and \

                            len(os.listdir(self.root)) > 0:

                                raise api_errors.CreatingImageInNonEmptyDir(

                                    self.root)

                        self.__set_dirs(root=self.root, imgtype=imgtype,

                            progtrack=progtrack)

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

                self.saved_files = {}

                self.state = imagestate.ImageState(self)

                self.type = None

                # right now we don't explicitly set dir/file modes everywhere;

                # set umask to proper value to prevent problems w/ overly

                # locked down umask.

                os.umask(0022)

        def _check_subdirs(self, sub_d, prefix):

                for n in self.required_subdirs:

                        if not os.path.isdir(os.path.join(sub_d, prefix, n)):

                                return False

                return True

        def __catalog_loaded(self, name):

                """Returns a boolean value indicating whether the named catalog

                has already been loaded.  This is intended to be used as an

                optimization function to determine which catalog to request."""

                return name in self.__catalogs

        def __init_catalogs(self):

                """Initializes default catalog state.  Actual data is provided

                on demand via get_catalog()"""

                # This is used to cache image catalogs.

                self.__catalogs = {}

                # This is used to keep track of what packages have been added

                # to IMG_CATALOG_KNOWN by set_pkg_state().

                self.__catalog_new_installs = set()

        def image_type(self, d):

                """Returns the type of image at directory: d; or None"""

                rv = None

                if os.path.isdir(os.path.join(d, img_user_prefix)) and \

                        os.path.isfile(os.path.join(d, img_user_prefix,

                            imageconfig.CFG_FILE)) and \

                            self._check_subdirs(d, img_user_prefix):

                        rv = IMG_USER

                elif os.path.isdir(os.path.join(d, img_root_prefix)) \

                         and os.path.isfile(os.path.join(d,

                             img_root_prefix, imageconfig.CFG_FILE)) and \

                             self._check_subdirs(d, img_root_prefix):

                        rv = IMG_ENTIRE

                return rv

        def find_root(self, d, exact_match=False, progtrack=None):

                # Ascend from the given directory d to find first

                # encountered image.  If exact_match is true, if the

                # image found doesn't match startd, raise an

                # ImageNotFoundException.

                startd = d

                # eliminate problem if relative path such as "." is passed in

                d = os.path.realpath(d)

                while True:

                        imgtype = self.image_type(d)

                        if imgtype == IMG_USER:

                                # XXX Look at image file to determine filter

                                # tags and repo URIs.

                                if exact_match and \

                                    os.path.realpath(startd) != \

                                    os.path.realpath(d):

                                        raise api_errors.ImageNotFoundException(

                                            exact_match, startd, d)

                                self.__set_dirs(imgtype=imgtype, root=d,

                                    progtrack=progtrack)

                                self.attrs["Build-Release"] = "5.11"

                                return

                        elif imgtype == IMG_ENTIRE:

                                # XXX Look at image file to determine filter

                                # tags and repo URIs.

                                # XXX Look at image file to determine if this

                                # image is a partial image.

                                if exact_match and \

                                    os.path.realpath(startd) != \

                                    os.path.realpath(d):

                                        raise api_errors.ImageNotFoundException(

                                            exact_match, startd, d)

                                self.__set_dirs(imgtype=imgtype, root=d,

                                    progtrack=progtrack)

                                self.attrs["Build-Release"] = "5.11"

                                return

                        # XXX follow symlinks or not?

                        oldpath = d

                        d = os.path.normpath(os.path.join(d, os.path.pardir))

                        # Make sure we are making progress and aren't in an

                        # infinite loop.

                        #

                        # (XXX - Need to deal with symlinks here too)

                        if d == oldpath:

                                raise api_errors.ImageNotFoundException(

                                    exact_match, startd, d)

        def __load_config(self):

                """Load this image's cached configuration from the default

                location."""

                # XXX Incomplete with respect to doc/image.txt description of

                # configuration.

                if self.root == None:

                        raise RuntimeError, "self.root must be set"

                ic = imageconfig.ImageConfig(self.root,

                    self._get_publisher_meta_dir())

                ic.read(self.imgdir)

                self.cfg_cache = ic

                for pub in self.gen_publishers(inc_disabled=True):

                        pub.transport = self.transport

        def save_config(self):

                # First, create the image directories if they haven't been, so

                # the cfg_cache can be written.

                self.mkdirs()

                self.cfg_cache.write(self.imgdir)

        # XXX mkdirs and set_attrs() need to be combined into a create

        # operation.

        def mkdirs(self):

                for sd in self.image_subdirs:

                        if os.path.isdir(os.path.join(self.imgdir, sd)):

                                continue

                        try:

                                os.makedirs(os.path.join(self.imgdir, sd))

                        except EnvironmentError, e:

                                if e.errno == errno.EACCES:

                                        raise api_errors.PermissionsException(

                                            e.filename)

                                if e.errno == errno.EROFS:

                                        raise api_errors.ReadOnlyFileSystemException(

                                            e.filename)

                                raise

        def __set_dirs(self, imgtype, root, progtrack=None):

                self.type = imgtype

                self.root = root

                if self.type == IMG_USER:

                        self.img_prefix = img_user_prefix

                else:

                        self.img_prefix = img_root_prefix

                # Change directory to the root of the image so that we can

                # remove any directories beneath us.  If we're changing the

                # image, don't chdir, as we're likely changing to a new BE

                # and want to be able to unmount it later.

                if not self.imgdir and os.path.isdir(root):

                        os.chdir(root)

                        # The specified root may have been a relative path.

                        self.root = os.getcwd()

                if not os.path.isabs(self.root):

                        self.root = os.path.abspath(self.root)

                self.imgdir = os.path.join(self.root, self.img_prefix)

                self.pkgdir = os.path.join(self.imgdir, "pkg")

                self.history.root_dir = self.imgdir

                if "PKG_CACHEDIR" in os.environ:

                        self.dl_cache_dir = os.path.normpath( \

                            os.environ["PKG_CACHEDIR"])

                        self.is_user_cache_dir = True

                else:

                        self.dl_cache_dir = os.path.normpath( \

                            os.path.join(self.imgdir, "download"))

                self.dl_cache_incoming = os.path.normpath(os.path.join(

                    self.dl_cache_dir, "incoming-%d" % os.getpid()))

                # Test if we have the permissions to create the cache

                # incoming directory in this hiearachy.  If not, we'll need to

                # move it somewhere else.

                try:

                        os.makedirs(self.dl_cache_incoming)

                except EnvironmentError, e:

                        if e.errno == errno.EACCES or e.errno == errno.EROFS:

                                self.dl_cache_incoming = tempfile.mkdtemp(

                                    prefix="incoming-%d-" % os.getpid())

                else:

                        os.removedirs(self.dl_cache_incoming)

                # Forcibly discard image catalogs so they can be re-loaded

                # from the new location if they are already loaded.  This

                # also prevents scribbling on image state information in

                # the wrong location.

                self.__init_catalogs()

                if not os.path.exists(os.path.join(self.imgdir,

                    imageconfig.CFG_FILE)):

                        # New images inherently use the newest image format.

                        # This must be set *before* creating the Publisher

                        # object so that the correct meta_root is set.

                        self.__upgraded = True

                else:

                        self.__upgraded = not os.path.exists(os.path.join(

                            self.imgdir, "catalog"))

                        self.__load_config()

                        self.__check_image(progtrack=progtrack)

        def __check_image(self, progtrack=None):

                """This does some basic sanity checks on the image structure

                and attempts to correct any errors it finds."""

                if not self.__upgraded:

                        self.__upgrade_image(progtrack=progtrack)

                        return

                # If the image has already been upgraded, first ensure that its

                # structure is valid.

                self.mkdirs()

                # Ensure structure for publishers is valid.

                for pub in self.gen_publishers():

                        pub.create_meta_root()

                # Once its structure is valid, then ensure state information

                # is intact.

                kdir = os.path.join(self.imgdir, "state",

                    self.IMG_CATALOG_KNOWN)

                kcattrs = os.path.join(kdir, "catalog.attrs")

                idir = os.path.join(self.imgdir, "state",

                    self.IMG_CATALOG_INSTALLED)

                icattrs = os.path.join(idir, "catalog.attrs")

                if not os.path.isfile(kcattrs) and os.path.isfile(icattrs):

                        # If the known catalog doesn't exist, but the installed

                        # catalog does, then copy the installed catalog to the

                        # known catalog directory so that state information can

                        # be preserved during the rebuild.

                        for fname in os.listdir(idir):

                                portable.copyfile(os.path.join(idir, fname),

                                    os.path.join(kdir, fname))

                        self.__rebuild_image_catalogs(progtrack=progtrack)

                if not os.path.exists(os.path.join(self.imgdir,

                    imageconfig.CFG_FILE)):

                        op = "image-create"

                else:

                        op = "image-set-attributes"

                # Create the publisher object before creating the image

                # so that if creation of the Publisher object fails, an

                # empty, useless image won't be left behind.

                repo = publisher.Repository()