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

#

import copy

import itertools

import os

import urllib

import pkg.actions as actions

import pkg.client.api as api

import pkg.flavor.base as base

import pkg.flavor.elf as elf_dep

import pkg.flavor.hardlink as hardlink

import pkg.flavor.script as script

import pkg.flavor.smf_manifest as smf_manifest

import pkg.fmri as fmri

import pkg.manifest as manifest

import pkg.portable as portable

import pkg.variant as variants

paths_prefix = "%s.path" % base.Dependency.DEPEND_DEBUG_PREFIX

files_prefix = "%s.file" % base.Dependency.DEPEND_DEBUG_PREFIX

reason_prefix = "%s.reason" % base.Dependency.DEPEND_DEBUG_PREFIX

class DependencyError(Exception):

        """The parent class for all dependency exceptions."""

        pass

class MultiplePackagesPathError(DependencyError):

                self.res = res

                self.source = source

        def __str__(self):

                return _("The file dependency %(src)s has paths which resolve "

                    "follows:\n%(acts)s") % {

                        "src":self.source,

                    }

class AmbiguousPathError(DependencyError):

        """This exception is used when multiple packages deliver a path which

        is depended upon."""

        def __init__(self, pkgs, source):

                self.pkgs = pkgs

                self.source = source

        def __str__(self):

                return _("The file dependency %(src)s depends on a path "

                    "delivered by multiple packages. Those packages "

                    "are:%(pkgs)s") % {

                        "src":self.source,

                        "pkgs":" ".join([str(p) for p in self.pkgs])

                    }

class UnresolvedDependencyError(DependencyError):

        """This exception is used when no package delivers a file which is

        depended upon."""

        def __init__(self, pth, file_dep, pvars):

                self.path = pth

                self.file_dep = file_dep

                self.pvars = pvars

        def __str__(self):

                return _("%(pth)s has unresolved dependency '%(dep)s' under "

                    "the following combinations of variants:\n%(combo)s") % \

                    {

                        "pth":self.path,

                        "dep":self.file_dep,

                        "combo":"\n".join([

                            " ".join([

                            ])

                            for grp in self.pvars.not_sat_set

                    ])}

class MissingPackageVariantError(DependencyError):

        """This exception is used when an action is tagged with a variant or

        variant value which the package is not tagged with."""

        def __init__(self, act_vars, pkg_vars, pth):

                self.act_vars = act_vars

                self.pkg_vars = pkg_vars

                self.path = pth

        def __str__(self):

                return _("The action delivering %(path)s is tagged with a "

                    "variant type or value not tagged on the package. "

                    "Dependencies on this file may fail to be reported.\n"

                    "The action's variants are: %(act)s\nThe package's "

                    "variants are: %(pkg)s") % {

                        "path": self.path,

                        "act": self.act_vars,

                        "pkg": self.pkg_vars

                    }

def list_implicit_deps(file_path, proto_dirs, dyn_tok_conv, kernel_paths,

    remove_internal_deps=True, convert=True):

        """Given the manifest provided in file_path, use the known dependency

        generators to produce a list of dependencies the files delivered by

        the manifest have.

        'file_path' is the path to the manifest for the package.

        'proto_dirs' is a list of paths to proto areas which hold the files that

        will be delivered by the package.

        'dyn_tok_conv' is the dictionary which maps the dynamic tokens, like

        $PLATFORM, to the values they should be expanded to.

        'kernel_paths' contains the run paths which kernel modules should use.

        'convert' determines whether PublishingDependencies will be transformed

        to DependencyActions prior to being returned.  This is primarily an

        option to facilitate testing and debugging."""

        m, missing_manf_files = __make_manifest(file_path, proto_dirs)

        pkg_vars = m.get_all_variants()

        deps, elist, missing, pkg_attrs = list_implicit_deps_for_manifest(m,

            proto_dirs, pkg_vars, dyn_tok_conv, kernel_paths)

        rid_errs = []

        if remove_internal_deps:

                deps, rid_errs = resolve_internal_deps(deps, m, proto_dirs,

                    pkg_vars)

        if convert:

                deps = convert_to_standard_dep_actions(deps)

        return deps, missing_manf_files + elist + rid_errs, missing, pkg_attrs

def convert_to_standard_dep_actions(deps):

        """Convert pkg.base.Dependency objects to

        pkg.actions.dependency.Dependency objects."""

        res = []

        for d in deps:

                tmp = []

                for c in d.dep_vars.not_sat_set:

                        attrs = d.attrs.copy()

                        attrs.update(c)

                        tmp.append(actions.depend.DependencyAction(**attrs))

                if not tmp:

                        tmp.append(actions.depend.DependencyAction(**d.attrs))

                res.extend(tmp)

        return res

def resolve_internal_deps(deps, mfst, proto_dirs, pkg_vars):

        """Given a list of dependencies, remove those which are satisfied by

        others delivered by the same package.

        'deps' is a list of Dependency objects.

        'mfst' is the Manifest of the package that delivered the dependencies

        found in deps.

        'proto_dir' is the path to the proto area which holds the files that

        will be delivered by the package.

        'pkg_vars' are the variants that this package was published against."""

        res = []

        errs = []

        delivered = {}

        delivered_bn = {}

        for a in mfst.gen_actions_by_type("file"):

                pvars = a.get_variant_template()

                if not pvars:

                        pvars = pkg_vars

                else:

                        if not pvars.issubset(pkg_vars):

                                # This happens when an action in a package is

                                # tagged with a variant type or value which the

                                # package has not been tagged with.

                                errs.append(

                                    MissingPackageVariantError(pvars, pkg_vars,

                                        a.attrs["path"]))

                        pvars.merge_unknown(pkg_vars)

                pvc = variants.VariantCombinations(pvars, satisfied=True)

                p = a.attrs["path"]

                bn = os.path.basename(p)

                delivered_bn.setdefault(bn, copy.copy(pvc))

        for d in deps:

                if etype is None:

                        continue

                pvars.simplify(pkg_vars)

                d.dep_vars = pvars

                res.append(d)

        return res, errs

def no_such_file(action, **kwargs):

        """Function to handle dispatch of files not found on the system."""

        return [], [base.MissingFile(action.attrs["path"])], {}

# Dictionary which maps codes from portable.get_file_type to the functions which

# find dependencies for those types of files.

dispatch_dict = {

    portable.ELF: elf_dep.process_elf_dependencies,

    portable.EXEC: script.process_script_deps,

    portable.SMF_MANIFEST: smf_manifest.process_smf_manifest_deps,

    portable.UNFOUND: no_such_file

}

def list_implicit_deps_for_manifest(mfst, proto_dirs, pkg_vars, dyn_tok_conv,

    kernel_paths):

        """For a manifest, produce the list of dependencies generated by the

        files it installs.

        'mfst' is the Manifest of the package that delivered the dependencies

        found in deps.

        'proto_dirs' are the paths to the proto areas which hold the files that

        will be delivered by the package.

        'pkg_vars' are the variants that this package was published against.

        'dyn_tok_conv' is the dictionary which maps the dynamic tokens, like

        $PLATFORM, to the values they should be expanded to.

        'kernel_paths' contains the run paths which kernel modules should use.

        Returns a tuple of three lists.

        'deps' is a list of dependencies found for the given Manifest.

        'elist' is a list of errors encountered while finding dependencies.

        'missing' is a dictionary mapping a file type that isn't recognized by

        portable.get_file_type to a file which produced that filetype.

        'pkg_attrs' is a dictionary containing metadata that was gathered

        during dependency analysis. Typically these would get turned into

        AttributeActions for that package. """

        deps = []

        elist = []

        missing = {}

        pkg_attrs = {}

        act_list = list(mfst.gen_actions_by_type("file"))

        file_types = portable.get_file_type(act_list)

        for i, file_type in enumerate(file_types):

                a = act_list[i]

                try:

                        func = dispatch_dict[file_type]

                except KeyError:

                        if file_type not in missing:

                                missing[file_type] = \

                                    a.attrs[portable.PD_LOCAL_PATH]

                else:

                        try:

                                ds, errs, attrs = func(action=a,

                                    pkg_vars=pkg_vars,

                                    dyn_tok_conv=dyn_tok_conv,

                                    kernel_paths=kernel_paths)

                                deps.extend(ds)

                                elist.extend(errs)

                                __update_pkg_attrs(pkg_attrs, attrs)

                        except base.DependencyAnalysisError, e:

                                elist.append(e)

        for a in mfst.gen_actions_by_type("hardlink"):

                deps.extend(hardlink.process_hardlink_deps(a, pkg_vars))

        return deps, elist, missing, pkg_attrs

def __update_pkg_attrs(pkg_attrs, new_attrs):

        """Update the pkg_attrs dictionary with the contents of new_attrs."""

        for key in new_attrs:

                pkg_attrs.setdefault(key, []).extend(new_attrs[key])

def __make_manifest(fp, basedirs=None, load_data=True):

        """Given the file path, 'fp', return a Manifest for that path."""

        m = manifest.Manifest()

        fh = open(fp, "rb")

        acts = []

        missing_files = []

        accumulate = ""

        for l in fh:

                l = l.strip()

                if l.endswith("\\"):

                        accumulate += l[0:-1]

                        continue

                elif accumulate:

                        l = accumulate + l

                        accumulate = ""

                if not l or l[0] == '#':

                        continue

                try:

                        a, local_path, used_bd = actions.internalizestr(l,

                            basedirs=basedirs,

                            load_data=load_data)

                        if local_path:

                                assert portable.PD_LOCAL_PATH not in a.attrs

                                a.attrs[portable.PD_LOCAL_PATH] = local_path

                                a.attrs[portable.PD_PROTO_DIR] = used_bd

                                a.attrs[portable.PD_PROTO_DIR_LIST] = basedirs

                        acts.append(a)

                except actions.ActionDataError, e:

                        new_a, local_path, used_bd = actions.internalizestr(

                            l, basedirs=basedirs, load_data=False)

                        if new_a.name == "license":

                                acts.append(new_a)

                        else:

                                path = e.path

                                # If the path was not set, then parse the

                                # action, without trying to load the data and

                                # use the path defined in the action.

                                if not path:

                                        path = new_a.attrs["path"]

                                missing_files.append(base.MissingFile(path))

        fh.close()

        m.set_content(content=acts)

        return m, missing_files

def choose_name(fp, mfst):

        """Find the package name for this manifest. If it's defined in a set

        action in the manifest, use that. Otherwise use the basename of the

        path to the manifest as the name.

        'fp' is the path to the file for the manifest.

        'mfst' is the Manifest object."""

        if mfst is None:

                return urllib.unquote(os.path.basename(fp))

        name = mfst.get("pkg.fmri", mfst.get("fmri", None))

        if name is not None:

                return name

        return urllib.unquote(os.path.basename(fp))

def helper(lst, file_dep, dep_vars, orig_dep_vars):

        """Creates the depend actions from lst for the dependency and determines

        which variants have been accounted for.

        'lst' is a list of fmri, variants pairs. The fmri a package which can

        satisfy the dependency. The variants are the variants under which it

        satisfies the dependency.

        'file_dep' is the dependency that needs to be satisfied.

        'dep_vars' is the variants under which 'file_dep' has not yet been

        satisfied.

        'orig_dep_vars' is the original set of variants under which the

        dependency must be satisfied."""

        res = []

        vars = []

        errs = set()

        for pfmri, delivered_vars in lst:

                # If the pfmri package isn't present under any of the variants

                # where the dependency is, skip it.

                if not orig_dep_vars.intersects(delivered_vars,

                    only_not_sat=True):

                        continue

                vc = orig_dep_vars.intersection(delivered_vars)

                vc.mark_all_as_satisfied()

                for found_vars, found_fmri in vars:

                        # Because we don't have the concept of one-of

                        # dependencies, depending on a file which is delivered

                        # in multiple packages under a set of variants

                        # prevents automatic resolution of dependencies.

                        if found_fmri != pfmri and \

                            found_vars.intersects(delivered_vars):

                                errs.add(found_fmri)

                                errs.add(pfmri)

                # Find the variants under which pfmri is relevant.

                action_vars = vc

                # Mark the variants as satisfied so it's possible to know if

                # all variant combinations have been covered.

                dep_vars.mark_as_satisfied(delivered_vars)

                attrs = file_dep.attrs.copy()

                # Add this package as satisfying the dependency.

                res.append((actions.depend.DependencyAction(**attrs),

                    action_vars))

                vars.append((action_vars, pfmri))

        if errs:

                # If any packages are in errs, then more than one file delivered

                # the same path under some configuaration of variants. This

                # situation is unresolvable.

                raise AmbiguousPathError(errs, file_dep)

        return res, dep_vars

def make_paths(file_dep):

        """Find all the possible paths which could satisfy the dependency

        'file_dep'."""

        rps = file_dep.attrs.get(paths_prefix, [""])

        files = file_dep.attrs[files_prefix]

        if isinstance(files, basestring):

                files = [files]

        if isinstance(rps, basestring):

                rps = [rps]

        return [os.path.join(rp, f) for rp in rps for f in files]