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

#

import copy

import itertools

import os

import re

import urllib

from collections import namedtuple

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

type_prefix = "%s.type" % base.Dependency.DEPEND_DEBUG_PREFIX

target_prefix = "%s.target" % base.Dependency.DEPEND_DEBUG_PREFIX

bypassed_prefix = "%s.bypassed" % base.Dependency.DEPEND_DEBUG_PREFIX

# A tag used to hold the product of the paths_prefix and files_prefix

# contents, used when bypassing dependency generation

fullpaths_prefix = "%s.fullpath" % base.Dependency.DEPEND_DEBUG_PREFIX

Entries = namedtuple("Entries", ["delivered", "installed"])

# This namedtuple is used to hold two items. The first, delivered, is used to

# hold items which are part of packages being delivered.  The second, installed,

# is used to hold items which are part of packages installed on the system.

class DependencyError(Exception):

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

        pass

class MultiplePackagesPathError(DependencyError):

        """This exception is used when a file dependency has paths which cause

        two or more packages to deliver files which fulfill the dependency under

        some combination of variants."""

        def __init__(self, res, source, vc):

                self.res = res

                self.source = source

                self.vc = vc

        def __str__(self):

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

                    "to multiple packages under this combination of "

                    "variants:\n%(vars)s\nThe actions are as "

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

                        "src":self.source,

                        "acts":"\n".join(["\t%s" % a for a in self.res]),

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

                            " ".join([

                                ("%s:%s" % (name, val)) for name, val in grp

                            ])

                            for grp in self.vc.sat_set])

                    }

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

                                ("%s:%s" % (name, val))

                                for name, val in sorted(grp)

                            ])

                            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, run_paths,

    remove_internal_deps=True, convert=True, ignore_bypass=False):

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

        'run_paths' contains the run paths that are used to find modules.

        'convert' determines whether PublishingDependencies will be transformed

        to DependencyActions prior to being returned.  This is primarily an

        option to facilitate testing and debugging.

        'ignore_bypass' determines whether to bypass generation of dependencies

        against certain files or directories.  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, run_paths,

            ignore_bypass=ignore_bypass)

        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 = {}

        files = Entries({}, {})

        links = Entries({}, {})

        # A fake pkg name is used because there is no requirement that a package

        # name itself to generate its dependencies.  Also, the name is entirely

        # a private construction which should not escape to the user.

        add_fmri_path_mapping(files.delivered, links.delivered,

            fmri.PkgFmri("INTERNAL@0-0", build_release="0"), mfst)

        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:

                etype, pvars = d.resolve_internal(

                    delivered_files=files.delivered,

                    delivered_base_names=delivered_bn, links=links,

                    resolve_links=resolve_links)

                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,

    run_paths, ignore_bypass=False):

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

        'run_paths' contains the run paths used to find modules, this is

        overridden by any manifest or action attributes setting

        'pkg.depend.runpath' (portable.PD_RUN_PATH)

        'ignore_bypass' set to True will prevent us from looking up any

        pkg.depend.bypass-generate attributes - this is primarily to aid

        debugging and testing.

        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)

        if portable.PD_RUN_PATH in mfst:

                # check for multiple values in a set attribute

                run_path_str = mfst[portable.PD_RUN_PATH]

                es = __verify_run_path(run_path_str)

                if es:

                        return deps, elist + es, missing, pkg_attrs

                run_paths = run_path_str.split(":")

        mf_bypass = []

        if portable.PD_BYPASS_GENERATE in mfst:

                mf_bypass = __makelist(mfst[portable.PD_BYPASS_GENERATE])

        for i, file_type in enumerate(file_types):

                a = act_list[i]

                a_run_paths = run_paths

                if portable.PD_RUN_PATH in a.attrs:

                        a_run_path_str = a.attrs[portable.PD_RUN_PATH]

                        es = __verify_run_path(a_run_path_str)

                        if es:

                                return deps, elist + es, missing, pkg_attrs

                        a_run_paths = a_run_path_str.split(":")

                bypass = __makelist(

                    a.attrs.get(portable.PD_BYPASS_GENERATE, mf_bypass))

                # If we're bypassing all depdendency generation, we can avoid

                # calling our dispatch_dict function altogether.

                if (".*" in bypass or "^.*$" in bypass) and not ignore_bypass:

                        pkg_attrs[bypassed_prefix] = "%s:.*" % a.attrs["path"]

                        continue

                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,

                                    run_paths=a_run_paths)

                                # prune out any dependencies on the files we've

                                # been asked to avoid creating dependencies on

                                if bypass and not ignore_bypass:

                                        ds = \

                                            __bypass_deps(ds, bypass, pkg_attrs)

                                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 __verify_run_path(run_path_str):

        """Verify we've been passed a single item and ensure it contains

        at least one non-null string."""

        if not isinstance(run_path_str, str):

                # require a colon separated string to potentially enforce

                # ordering in the future

                return [base.DependencyAnalysisError(

                    _("Manifest specified multiple values for %s rather "

                    "than a single colon-separated string.") %

                    portable.PD_RUN_PATH)]

        if set(run_path_str.split(":")) == set([""]):

                return [base.DependencyAnalysisError(

                    _("Manifest did not specify any entries for %s, expecting "

                    "a colon-separated string.") % portable.PD_RUN_PATH)]

        return []

def __makelist(value):

        """Given a value, return it if that value is a list, or if it's a

        string, return a single-element list of just that string."""

        if isinstance(value, list):

                return value

        elif isinstance(value, str):

                if value:

                        return [value]

                else:

                        return []

        else:

                raise ValueError("Value was not a string or a list")

def __bypass_deps(ds, bypass, pkg_attrs):

        """Return a list of dependencies, excluding any of those that should be

        bypassed.

        ds         the list of dependencies to operate on

        bypass     a list of paths on which we should not generate dependencies

        pkg_attrs  the set of package attributes for this manifest, produced as

                   a by-product of this dependency generation

        We support regular expressions as entries in the bypass list, matching

        one or more files.

        If a bypass-list entry is provided that does not contain one of the

        following characters: ["/", "*", "?"], it is assumed to be a filename,

        and expanded to the regular expression ".*/<entry>"

        All bypass-list entries are assumed to be regular expressions that are

        rooted at ^ and $.

        The special match-all wildcard ".*" is dealt with separately,

        by list_implicit_deps_for_manifest(..)

        """

        new_ds = []

        for dep in ds:

                full_paths = set(make_paths(dep))

                bypassed_files = set()

                bypass_regexps = []

                try:

                        for item in bypass:

                                # try to determine if this is a regexp,

                                # rather than a filename

                                if "*" in item or "?" in item:

                                        pass

                                # if it appears to be a filename, make it match

                                # all paths to that filename.

                                elif "/" not in item:

                                        item = ".*%s%s" % (os.path.sep, item)

                                # always anchor our regular expressions,

                                # otherwise, we get partial matches for files,

                                # eg. bypassing "foo.c" would otherwise also

                                # bypass "foo.cc"

                                if item:

                                        if not item.endswith("$"):

                                                item = item + "$"

                                        if not item.startswith("^"):

                                                item = "^" + item

                                        bypass_regexps.append(re.compile(item))

                except re.error, e:

                        raise base.InvalidDependBypassValue(item, e)

                for path in full_paths:

                        if path in bypass:

                                bypassed_files.add(path)

                                continue

                        for regexp in bypass_regexps:

                                if regexp.match(path):

                                        bypassed_files.add(path)

                if bypassed_files:

                        # remove the old runpath and basename entries from

                        # the dependency if they were present

                        dep.attrs.pop(files_prefix, None)

                        dep.attrs.pop(paths_prefix, None)

                        dep.base_names = []

                        dep.run_paths = []

                        # determine our new list of paths

                        full_paths = full_paths - bypassed_files

                        dep.full_paths = sorted(list(full_paths))

                        dep.attrs[fullpaths_prefix] = dep.full_paths

                        pkg_attrs[bypassed_prefix] = \

                            sorted(list(bypassed_files))

                        # only include the dependency if it still contains data

                        if full_paths:

                                new_ds.append(dep)

                else:

                        new_ds.append(dep)

        return new_ds