#!/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 2008 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

import cPickle

import errno

import os

import urllib

import urllib2

import httplib

import shutil

import sys

import time

import types

# import uuid           # XXX interesting 2.5 module

import pkg.catalog as catalog

import pkg.updatelog as updatelog

import pkg.fmri

import pkg.manifest as manifest

import pkg.misc as misc

import pkg.version as version

import pkg.client.imageconfig as imageconfig

import pkg.client.imageplan as imageplan

import pkg.client.retrieve as retrieve

import pkg.client.filelist as filelist

import pkg.portable as portable

from pkg.misc import versioned_urlopen

from pkg.client.imagetypes import *

img_user_prefix = ".org.opensolaris,pkg"

img_root_prefix = "var/pkg"

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/catalog

               Directory containing catalogs for URIs of interest.  Filename is

               the escaped URI of the catalog.

          $IROOT/file

               Directory containing file hashes of installed packages.

          $IROOT/pkg

               Directory containing manifests and states of installed packages.

          $IROOT/index

               Directory containing reverse-index databases.

          $IROOT/cfg_cache

               File containing image's cached configuration.

          $IROOT/state

               File containing image's opaque state.

        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?"""

        def __init__(self):

                self.cfg_cache = None

                self.type = None

                self.root = None

                self.imgdir = None

                self.img_prefix = None

                self.repo_uris = []

                self.filter_tags = {}

                self.catalogs = {}

                self.attrs = {}

                self.link_actions = None

                self.installed_pkg_cache = None

                self.attrs["Policy-Require-Optional"] = False

                self.attrs["Policy-Pursue-Latest"] = True

                self.imageplan = None # valid after evaluation succceds

                # contains a dictionary w/ key = pkgname, value is miminum

                # frmi.XXX  Needs rewrite using graph follower

                self.optional_dependencies = {}

        def find_root(self, d):

                # Ascend from the given directory d to find first

                # encountered image.

                startd = d

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

                d = os.path.realpath(d)

                while True:

                        if os.path.isdir(os.path.join(d, img_user_prefix)):

                                # XXX Look at image file to determine filter

                                # tags and repo URIs.

                                self.type = IMG_USER

                                self.root = d

                                self.img_prefix = img_user_prefix

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

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

                                return

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

                                # 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.

                                self.type = IMG_ENTIRE

                                self.root = d

                                self.img_prefix = img_root_prefix

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

                                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 ValueError, "directory %s not contained within an image" % startd

        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()

                if os.path.isfile("%s/cfg_cache" % self.imgdir):

                        ic.read("%s/cfg_cache" % self.imgdir)

                self.cfg_cache = ic

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

        # operation.

        def mkdirs(self):

                if not os.path.isdir(self.imgdir + "/catalog"):

                        os.makedirs(self.imgdir + "/catalog")

                if not os.path.isdir(self.imgdir + "/file"):

                        os.makedirs(self.imgdir + "/file")

                if not os.path.isdir(self.imgdir + "/pkg"):

                        os.makedirs(self.imgdir + "/pkg")

                if not os.path.isdir(self.imgdir + "/index"):

                        os.makedirs(self.imgdir + "/index")

        def set_attrs(self, type, root, is_zone, auth_name, auth_url,

            ssl_key = None, ssl_cert = None):

                self.type = type

                self.root = root

                if self.type == IMG_USER:

                        self.img_prefix = img_user_prefix

                else:

                        self.img_prefix = img_root_prefix

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

                self.mkdirs()

                self.cfg_cache = imageconfig.ImageConfig()

                if is_zone:

                        self.cfg_cache.filters["opensolaris.zone"] = "nonglobal"

                self.cfg_cache.authorities[auth_name] = {}

                self.cfg_cache.authorities[auth_name]["prefix"] = auth_name

                self.cfg_cache.authorities[auth_name]["origin"] = \

                    misc.url_affix_trailing_slash(auth_url)

                self.cfg_cache.authorities[auth_name]["mirrors"] = []

                self.cfg_cache.authorities[auth_name]["ssl_key"] = ssl_key

                self.cfg_cache.authorities[auth_name]["ssl_cert"] = ssl_cert

                self.cfg_cache.preferred_authority = auth_name

                self.cfg_cache.write("%s/cfg_cache" % self.imgdir)

        def is_liveroot(self):

                return self.root == "/"

        def is_zone(self):

		zone = self.cfg_cache.filters.get("opensolaris.zone", "")

		return zone == "nonglobal"

        def get_root(self):

                return self.root

        def gen_authorities(self):

                if not self.cfg_cache:

                        raise RuntimeError, "empty ImageConfig"

                if not self.cfg_cache.authorities:

                        raise RuntimeError, "no defined authorities"

                for a in self.cfg_cache.authorities:

                        yield self.cfg_cache.authorities[a]

        def get_url_by_authority(self, authority = None):

                """Return the URL prefix associated with the given authority.

                For the undefined case, represented by None, return the

                preferred authority."""

                # XXX This function is a possible location to insert one or more

                # policies regarding use of mirror responses, etc.

                if authority == None:

                        authority = self.cfg_cache.preferred_authority

                try:

                        o = self.cfg_cache.authorities[authority]["origin"]

                except KeyError:

                        # If the authority that we're trying to get no longer

                        # exists, fall back to preferred authority.

                        authority = self.cfg_cache.preferred_authority

                        o = self.cfg_cache.authorities[authority]["origin"]

                return o.rstrip("/")

        def get_ssl_credentials(self, authority = None, origin = None):

                """Return a tuple containing (ssl_key, ssl_cert) for the

                specified authority prefix.  If the authority isn't specified,

                attempt to determine the authority by the given origin.  If

                neither is specified, use the preferred authority.

                """

                if authority is None:

                        if origin is None:

                                authority = self.cfg_cache.preferred_authority

                        else:

                                auths = self.cfg_cache.authorities

                                for pfx, auth in auths.iteritems():

                                        if auth["origin"] == origin:

                                                authority = pfx

                                                break

                                else:

                                        return None

                try:

                        authent = self.cfg_cache.authorities[authority]

                except KeyError:

                        authority = self.cfg_cache.preferred_authority

                        authent = self.cfg_cache.authorities[authority]

                return (authent["ssl_key"], authent["ssl_cert"])

        def get_default_authority(self):

                return self.cfg_cache.preferred_authority

        def has_authority(self, auth_name):

                return auth_name in self.cfg_cache.authorities

        def delete_authority(self, auth_name):

                if not self.has_authority(auth_name):

                        raise KeyError, "no such authority '%s'" % auth_name

                self.cfg_cache.delete_authority(auth_name)

                self.cfg_cache.write("%s/cfg_cache" % self.imgdir)

        def get_authority(self, auth_name):

                if not self.has_authority(auth_name):

                        raise KeyError, "no such authority '%s'" % auth_name

                return self.cfg_cache.authorities[auth_name]

        def split_authority(self, auth):

                prefix = auth["prefix"]

                update_dt = None

                try:

                        cat = self.catalogs[prefix]

                except KeyError:

                        cat = None

                if cat:

                        update_dt = cat.last_modified()

                        if update_dt:

                                update_dt = catalog.ts_to_datetime(update_dt)

                return (prefix, auth["origin"], auth["ssl_key"],

                    auth["ssl_cert"], update_dt)

        def set_preferred_authority(self, auth_name):

                if not self.has_authority(auth_name):

                        raise KeyError, "no such authority '%s'" % auth_name

                self.cfg_cache.preferred_authority = auth_name

                self.cfg_cache.write("%s/cfg_cache" % self.imgdir)

        def set_authority(self, auth_name, origin_url = None, ssl_key = None,

            ssl_cert = None, mirrors = []):

                auths = self.cfg_cache.authorities

                if auth_name in auths:

                        # If authority already exists, only update non-NULL

                        # values passed to set_authority

                        if origin_url:

                                auths[auth_name]["origin"] = \

                                    misc.url_affix_trailing_slash(origin_url)

                        if ssl_key:

                                auths[auth_name]["ssl_key"] = ssl_key

                        if ssl_cert:

                                auths[auth_name]["ssl_cert"] = ssl_cert

                        if mirrors:

                                auths[auth_name]["mirrors"] = mirrors

                else:

                        auths[auth_name] = {}

                        auths[auth_name]["prefix"] = auth_name

                        auths[auth_name]["origin"] = \

                            misc.url_affix_trailing_slash(origin_url)

                        auths[auth_name]["mirrors"] = mirrors

                        auths[auth_name]["ssl_key"] = ssl_key

                        auths[auth_name]["ssl_cert"] = ssl_cert

                self.cfg_cache.write("%s/cfg_cache" % self.imgdir)

        def get_matching_fmris(self, patterns, matcher = None,

            constraint = None, counthash = None):

                """Iterate through all catalogs, looking for packages matching

                'pattern', based on the function in 'matcher' and the versioning

                constraint described by 'constraint'.  If 'matcher' is None,

                uses fmri subset matching as the default.  Returns a list of

                (catalog, fmri) pairs.  If 'counthash' is a dictionary, instead

                store the number of matched fmris for each package name which

                was matched."""

                # XXX Do we want to recognize regex (some) metacharacters and

                # switch automatically to the regex matcher?

                # XXX If the patterns contain an authority, we could reduce the

                # number of catalogs searched by only looking at catalogs whose

                # authorities match FMRIs in the pattern.

                # Check preferred authority first, if package isn't found here,

                # then check all authorities.

                cat = self.catalogs[self.cfg_cache.preferred_authority]

                m = cat.get_matching_fmris(patterns, matcher,

                    constraint, counthash)

                for k, c in self.catalogs.items():

                        if k == self.cfg_cache.preferred_authority:

                                continue

                        m.extend(c.get_matching_fmris(patterns, matcher,

                            constraint, counthash))

                ips = [ ip for ip in self.gen_installed_pkgs() if ip not in m ]

                m.extend(catalog.extract_matching_fmris(ips, patterns,

                    matcher, constraint, counthash))

                if not m:

                        raise KeyError, "packages matching '%s' not found in catalog or image" \

                            % patterns

                return m

        def verify(self, fmri, progresstracker, **args):

                """ generator that returns any errors in installed pkgs

                as tuple of action, list of errors"""

                for act in self.get_manifest(fmri, filtered = True).actions:

                        errors = act.verify(self, pkg_fmri=fmri, **args)

                        progresstracker.verify_add_progress(fmri)

                        actname = act.distinguished_name()

                        if errors:

                                progresstracker.verify_yield_error(actname,

                                    errors)

                                yield (actname, errors)

        def gen_installed_actions(self):

                """ generates actions in installed image """

                for fmri in self.gen_installed_pkgs():

                        for act in self.get_manifest(fmri, filtered = True).actions:

                                yield act

        def get_link_actions(self):

                """ return a dictionary of hardlink action lists indexed by

                target """

                if self.link_actions != None:

                        return self.link_actions

                d = {}

                for act in self.gen_installed_actions():

                        if act.name == "hardlink":

                                t = act.get_target_path()

                                if t in d:

                                        d[t].append(act)

                                else:

                                        d[t] = [act]

                self.link_actions = d

                return d

        def has_manifest(self, fmri):

                mpath = fmri.get_dir_path()

                local_mpath = "%s/pkg/%s/manifest" % (self.imgdir, mpath)

                if (os.path.exists(local_mpath)):

                        return True

                return False

        def _fetch_manifest(self, fmri):

                """Perform steps necessary to get manifest from remote host

                and write resulting contents to disk.  Helper routine for

                get_manifest.  Does not filter the results, caller must do

                that.  """

                m = manifest.Manifest()

                m.set_fmri(self, fmri)

                fmri_dir_path = os.path.join(self.imgdir, "pkg",

                    fmri.get_dir_path())

                mpath = os.path.join(fmri_dir_path, "manifest")

                ipath = os.path.join(fmri_dir_path, "index")

                # Get manifest as a string from the remote host, then build

                # it up into an in-memory manifest, then write the finished

                # representation to disk.

                mcontent = retrieve.get_manifest(self, fmri)

                m.set_content(mcontent)

                # Write the originating authority into the manifest.

                # Manifests prior to this change won't contain this information.

                # In that case, the client attempts to re-download the manifest

                # from the depot.

                if not fmri.has_authority():

                        m["authority"] = self.get_default_authority()

                else:

                        m["authority"] = fmri.get_authority()

                try:

                        m.store(mpath, ipath)

                except EnvironmentError, e:

                        if e.errno not in (errno.EROFS, errno.EACCES):

                                raise

                return m

        def _valid_manifest(self, fmri, manifest):