926N/A

39N/A

2453N/Afrom collections import namedtuple, defaultdict

342N/Afrom functools import reduce

1516N/A

1636N/Aimport errno

1386N/Aimport fnmatch

838N/Aimport hashlib

39N/Aimport os

51N/Aimport re

2073N/Aimport six

2144N/Aimport tempfile

1066N/Afrom itertools import groupby, chain, product, repeat

1231N/Afrom operator import itemgetter

2453N/Afrom six.moves import zip

1352N/A

1890N/Aimport pkg.actions as actions

296N/Aimport pkg.client.api_errors as apx

39N/Aimport pkg.facet as facet

1713N/Aimport pkg.fmri as fmri

1713N/Aimport pkg.misc as misc

39N/Aimport pkg.portable as portable

39N/Aimport pkg.variant as variant

39N/Aimport pkg.version as version

39N/A

39N/Afrom pkg.misc import EmptyDict, EmptyI, expanddirs, PKG_FILE_MODE, PKG_DIR_MODE

205N/Afrom pkg.actions.attribute import AttributeAction

39N/Afrom pkg.actions.directory import DirectoryAction

205N/A

39N/Adef _compile_fnpats(fn_pats):

39N/A """Private helper function that returns a compiled version of a

39N/A

39N/A return dict(

39N/A (key, [

39N/A re.compile(fnmatch.translate(pat), re.IGNORECASE).match

39N/A for pat in pats

39N/A ])

39N/A for (key, pats) in six.iteritems(fn_pats)

39N/A )

39N/A

39N/A

39N/Adef _attr_matches(action, attr_match):

39N/A """Private helper function: given an action, return True if any of its

39N/A

39N/A if not attr_match:

39N/A return True

39N/A

48N/A for (attr, matches) in six.iteritems(attr_match):

48N/A if attr in action.attrs:

48N/A for match in matches:

48N/A for attrval in action.attrlist(attr):

48N/A if match(attrval):

59N/A return True

48N/A return False

2073N/A

2073N/A

39N/Aclass ManifestDifference(

39N/A namedtuple("ManifestDifference", "added changed removed")):

567N/A

838N/A __slots__ = []

838N/A

838N/A __state__desc = tuple([

1890N/A [ ( actions.generic.NSG, actions.generic.NSG ) ],

2453N/A [ ( actions.generic.NSG, actions.generic.NSG ) ],

2608N/A [ ( actions.generic.NSG, actions.generic.NSG ) ],

39N/A ])

39N/A

39N/A __state__commonize = frozenset([

1431N/A actions.generic.NSG,

1431N/A ])

39N/A

227N/A @staticmethod

315N/A def getstate(obj, je_state=None):

315N/A """Returns the serialized state of this object in a format

1352N/A return misc.json_encode(ManifestDifference.__name__,

1352N/A tuple(obj),

1352N/A ManifestDifference.__state__desc,

1352N/A commonize=ManifestDifference.__state__commonize,

1431N/A je_state=je_state)

1431N/A

429N/A @staticmethod

315N/A def fromstate(state, jd_state=None):

1352N/A """Allocate a new object using previously serialized state

1352N/A

1352N/A # decode serialized state into python objects

39N/A state = misc.json_decode(ManifestDifference.__name__,

926N/A state,

926N/A ManifestDifference.__state__desc,

203N/A commonize=ManifestDifference.__state__commonize,

203N/A jd_state=jd_state)

203N/A

203N/A return ManifestDifference(*state)

1045N/A

1045N/Aclass Manifest(object):

72N/A """A Manifest is the representation of the actions composing a specific

72N/A

2144N/A def __init__(self, pfmri=None):

72N/A self.fmri = pfmri

59N/A

72N/A self._cache = {}

72N/A self._absent_cache = []

72N/A self.actions = []

72N/A self.actions_bytype = {}

59N/A self.attributes = {} # package-wide attributes

72N/A self.signatures = EmptyDict

72N/A self.excludes = EmptyI

72N/A if pfmri is not None:

202N/A if not isinstance(pfmri, fmri.PkgFmri):

72N/A pfmri = fmri.PkgFmri(pfmri)

72N/A self.publisher = pfmri.publisher

59N/A else:

1713N/A self.publisher = None

59N/A

838N/A def __str__(self):

2240N/A r = ""

838N/A if "pkg.fmri" not in self.attributes and self.fmri != None:

838N/A r += "set name=pkg.fmri value={0}\n".format(self.fmri)

838N/A

926N/A for act in sorted(self.actions):

838N/A r += "{0}\n".format(act)

838N/A return r

2240N/A

2240N/A def as_lines(self):

2284N/A """A generator function that returns the unsorted manifest

838N/A

2240N/A if "pkg.fmri" not in self.attributes and self.fmri != None:

2240N/A yield "set name=pkg.fmri value={0}\n".format(self.fmri)

2240N/A

2240N/A for act in self.actions:

2240N/A yield "{0}\n".format(act)

2240N/A

2240N/A def tostr_unsorted(self):

2240N/A return "".join((l for l in self.as_lines()))

2240N/A

2317N/A def difference(self, origin, origin_exclude=EmptyI,

2240N/A self_exclude=EmptyI):

2240N/A """Return three lists of action pairs representing origin and

2240N/A # XXX Do we need to find some way to assert that the keys are

2240N/A # all unique?

2240N/A

2240N/A if isinstance(origin, EmptyFactoredManifest):

2284N/A # No origin was provided, so nothing has been changed or

2284N/A # removed; only added. In addition, this doesn't need

2284N/A # to be sorted since the caller likely already does

2284N/A # (such as pkgplan/imageplan).

2240N/A return ManifestDifference(

2240N/A [(None, a) for a in self.gen_actions(

2284N/A excludes=self_exclude)], [], [])

2284N/A

2284N/A def hashify(v):

838N/A """handle key values that may be lists"""

838N/A if type(v) is not list:

838N/A return v

838N/A return tuple(v)

838N/A

838N/A def dictify(mf, excludes):

838N/A # Transform list of actions into a dictionary keyed by

926N/A # action key attribute, key attribute and mediator, or

838N/A # id if there is no key attribute.

838N/A for a in mf.gen_actions(excludes=excludes):

838N/A if (a.name == "link" or

838N/A a.name == "hardlink") and \

838N/A a.attrs.get("mediator"):

838N/A akey = (a.name, tuple([

838N/A a.attrs[a.key_attr],

845N/A a.attrs.get("mediator-version"),

845N/A a.attrs.get("mediator-implementation")

926N/A ]))

838N/A else:

845N/A akey = (a.name, hashify(a.attrs.get(

845N/A a.key_attr, id(a))))

845N/A yield (akey, a)

838N/A

845N/A sdict = dict(dictify(self, self_exclude))

845N/A odict = dict(dictify(origin, origin_exclude))

838N/A

926N/A sset = set(six.iterkeys(sdict))

203N/A oset = set(six.iterkeys(odict))

315N/A

838N/A added = [(None, sdict[i]) for i in sset - oset]

203N/A removed = [(odict[i], None) for i in oset - sset]

838N/A changed = [

48N/A (odict[i], sdict[i])

48N/A for i in oset & sset

48N/A if odict[i].different(sdict[i])

48N/A ]

48N/A

838N/A # XXX Do changed actions need to be sorted at all? This is

203N/A # likely to be the largest list, so we might save significant

48N/A # time by not sorting. Should we sort above? Insert into a

203N/A # sorted list?

72N/A

181N/A # singlesort = lambda x: x[0] or x[1]

72N/A addsort = itemgetter(1)

181N/A remsort = itemgetter(0)

46N/A removed.sort(key=remsort, reverse=True)

181N/A added.sort(key=addsort)

237N/A changed.sort(key=addsort)

46N/A

2453N/A return ManifestDifference(added, changed, removed)

2453N/A

2453N/A @staticmethod

2453N/A def comm(compare_m):

2339N/A """Like the unix utility comm, except that this function

2453N/A

2339N/A # Must specify at least one manifest.

2339N/A assert compare_m

2339N/A dups = []

2339N/A

2339N/A # construct list of dictionaries of actions in each

2339N/A # manifest, indexed by unique key and variant combination

2453N/A m_dicts = []

2453N/A for m in compare_m:

2453N/A m_dict = {}

2453N/A for a in m.gen_actions():

2453N/A # The unique key for each action is based on its

2453N/A # type, key attribute, and unique variants set

2453N/A # on the action.

2453N/A try:

2453N/A key = set(a.attrlist(a.key_attr))

2453N/A if (a.name == "link" or

2453N/A a.name == "hardlink") and \

2453N/A a.attrs.get("mediator"):

2339N/A for v in ("mediator-version",

2453N/A "mediator-implementation"):

2453N/A key.update([

2453N/A "{0}={1}".format(v,

2453N/A a.attrs.get(v))])

2453N/A key.update(

2453N/A "{0}={1}".format(v, a.attrs[v])

2453N/A for v in a.get_varcet_keys()[0]

2453N/A )

2453N/A

2453N/A key = tuple(key)

2453N/A except KeyError:

2453N/A # If there is no key attribute for the

2453N/A # action, then fallback to the object

2453N/A # id for the action as its identifier.

2453N/A key = (id(a),)

2453N/A

2453N/A # catch duplicate actions here...

2453N/A if m_dict.setdefault((a.name, key), a) != a:

2453N/A dups.append((m_dict[(a.name, key)], a))

2453N/A

2453N/A m_dicts.append(m_dict)

2453N/A

2453N/A if dups:

2453N/A raise ManifestError(duplicates=dups)

2453N/A

2453N/A # construct list of key sets in each dict

2453N/A m_sets = [

2453N/A set(m.keys())

2339N/A for m in m_dicts

2339N/A ]

2339N/A

2339N/A common_keys = reduce(lambda a, b: a & b, m_sets)

2339N/A

2453N/A # determine which common_keys have common actions

2453N/A for k in common_keys.copy():

2453N/A for i in range(len(m_dicts) - 1):

2453N/A if m_dicts[i][k].different(

2453N/A m_dicts[i + 1][k]):

2339N/A common_keys.remove(k)

2453N/A break

2453N/A return tuple(

2453N/A [

2453N/A [m_dicts[i][k] for k in m_sets[i] - common_keys]

2339N/A for i in range(len(m_dicts))

2453N/A ]

2453N/A +

2453N/A [

2453N/A [ m_dicts[0][k] for k in common_keys ]

2453N/A ]

2339N/A )

2339N/A

2339N/A def combined_difference(self, origin, ov=EmptyI, sv=EmptyI):

2339N/A """Where difference() returns three lists, combined_difference()

2608N/A return list(chain(*self.difference(origin, ov, sv)))

2608N/A

2608N/A def humanized_differences(self, other, ov=EmptyI, sv=EmptyI):

2339N/A """Output expects that self is newer than other. Use of sets

2453N/A

2339N/A l = self.difference(other, ov, sv)

2540N/A out = ""

2339N/A

2339N/A for src, dest in chain(*l):

2339N/A if not src:

2339N/A out += "+ {0}\n".format(str(dest))

2339N/A elif not dest:

2339N/A out += "- {0}\n" + str(src)

2339N/A else:

2339N/A out += "{0} -> {1}\n".format(src, dest)

2339N/A return out

2339N/A

2453N/A def _gen_dirs_to_str(self):

2453N/A """Generate contents of dircache file containing all dirctories

2453N/A

2453N/A def gen_references(a):

2453N/A for d in expanddirs(a.directory_references()):

2453N/A yield d

2608N/A

2608N/A dirs = self._actions_to_dict(gen_references)

2608N/A for d in dirs:

2453N/A for v in dirs[d]:

2453N/A a = DirectoryAction(path=d, **v)

2453N/A yield str(a) + "\n"

2453N/A

2453N/A def _gen_mediators_to_str(self):

2453N/A """Generate contents of mediatorcache file containing all

2453N/A

2453N/A def gen_references(a):

2453N/A if (a.name == "link" or a.name == "hardlink") and \

2453N/A "mediator" in a.attrs:

2453N/A yield (a.attrs.get("mediator"),

2453N/A a.attrs.get("mediator-priority"),

2453N/A a.attrs.get("mediator-version"),

2453N/A a.attrs.get("mediator-implementation"))

2453N/A

2453N/A mediators = self._actions_to_dict(gen_references)

2453N/A for mediation, mvariants in six.iteritems(mediators):

2453N/A values = {

2453N/A "mediator-priority": mediation[1],

2453N/A "mediator-version": mediation[2],

2453N/A "mediator-implementation": mediation[3],

2453N/A }

2453N/A for mvariant in mvariants:

2453N/A a = "set name=pkg.mediator " \

2453N/A "value={0} {1} {2}\n".format(mediation[0],

2453N/A " ".join((

2453N/A "=".join(t)

2453N/A for t in six.iteritems(values)

2453N/A if t[1]

2453N/A )),

2453N/A " ".join((

2453N/A "=".join(t)

838N/A for t in six.iteritems(mvariant)

838N/A ))

2608N/A )

2608N/A yield a

2608N/A

2608N/A def _gen_attrs_to_str(self):

838N/A """Generate set action supplemental data containing all facets

838N/A

838N/A emit_variants = "pkg.variant" not in self

838N/A emit_facets = "pkg.facet" not in self

342N/A emit_sizes = "pkg.size" not in self and "pkg.csize" not in self

926N/A

838N/A if not any((emit_variants, emit_facets, emit_sizes)):

838N/A # Package already has these attributes.

2608N/A return

2608N/A

2608N/A # List of possible variants and possible values for them.

2608N/A variants = defaultdict(set)

926N/A

838N/A # Seed with declared set of variants as actions may be common to

838N/A # both and so will not be tagged with variant.

838N/A for name in self.attributes:

838N/A if name[:8] == "variant.":

838N/A variants[name] = set(self.attributes[name])

926N/A

2453N/A # List of possible facets and under what variant combinations

2453N/A # they were seen.

2453N/A facets = defaultdict(set)

2608N/A

2453N/A # Unique (facet, value) (variant, value) combinations.

2453N/A refs = defaultdict(lambda: defaultdict(int))

2453N/A

2453N/A for a in self.gen_actions():

2453N/A name = a.name

926N/A attrs = a.attrs

615N/A if name == "set":

615N/A if attrs["name"][:12] == "pkg.variant":

615N/A emit_variants = False

615N/A elif attrs["name"][:9] == "pkg.facet":

615N/A emit_facets = False

926N/A

615N/A afacets = []

615N/A avariants = []

838N/A for attr, val in six.iteritems(attrs):

111N/A if attr[:8] == "variant.":

111N/A variants[attr].add(val)

111N/A avariants.append((attr, val))

111N/A elif attr[:6] == "facet.":

111N/A afacets.append((attr, val))

111N/A

111N/A for name, val in afacets:

111N/A # Facet applicable to this particular variant

113N/A # combination.

926N/A varkey = tuple(sorted(avariants))

838N/A facets[varkey].add(name)

926N/A

113N/A # This *must* be sorted to ensure reproducible set

113N/A # action generation for sizes and to ensure each

113N/A # combination is actually unique.

113N/A varcetkeys = tuple(sorted(chain(afacets, avariants)))

113N/A refs[varcetkeys]["csize"] += misc.get_pkg_otw_size(a)

113N/A if name == "signature":

113N/A refs[varcetkeys]["csize"] += \

113N/A a.get_action_chain_csize()

113N/A refs[varcetkeys]["size"] += a.get_size()

111N/A

1500N/A # Prevent scope leak.

1432N/A afacets = avariants = attrs = varcetkeys = None

1542N/A

1970N/A if emit_variants:

2073N/A # Unnecessary if we can guarantee all variants will be

2073N/A # declared at package level. Omit the "variant." prefix

2073N/A # from attribute values since that's implicit and can be

2073N/A # added back when the action is parsed.

2073N/A yield "{0}\n".format(AttributeAction(None,

2073N/A name="pkg.variant",

1542N/A value=sorted(v[8:] for v in variants)))

146N/A

1432N/A # Emit a set action for every variant used with possible values

1432N/A # if one does not already exist.

50N/A for name in variants:

1432N/A # merge_facets needs the variant values sorted and this

1432N/A # is desirable when generating the variant attr anyway.

1432N/A variants[name] = sorted(variants[name])

51N/A if name not in self.attributes:

1636N/A yield "{0}\n".format(AttributeAction(None,

1432N/A name=name, value=variants[name]))

1507N/A

51N/A if emit_facets:

1500N/A # Get unvarianted facet set.

591N/A cfacets = facets.pop((), set())

1970N/A

1970N/A # For each variant combination, remove unvarianted

1970N/A # facets since they are common to all variants.

591N/A for varkey, fnames in facets.items():

1542N/A fnames.difference_update(cfacets)

1970N/A if not fnames:

1970N/A # No facets unique to this combo;

1970N/A # discard.

2073N/A del facets[varkey]

1500N/A

2073N/A # If all possible variant combinations supported by the

2073N/A # package have at least one facet, then the intersection

1713N/A # of facets for all variants can be merged with the

1713N/A # common set.

2073N/A merge_facets = len(facets) > 0

2073N/A if merge_facets:

2073N/A # Determine unique set of variant combinations

1713N/A # seen for faceted actions.

2608N/A vcombos = set((

2608N/A tuple(

2613N/A vpair[0]

2284N/A for vpair in varkey

2073N/A )

2073N/A for varkey in facets

1713N/A ))

2073N/A

2073N/A # For each unique variant combination, determine

2073N/A # if the cartesian product of all variant values

1713N/A # supported by the package for the combination

1713N/A # has been seen. In other words, if the

2073N/A # combination is ((variant.arch,)) and the

2073N/A # package supports (i386, sparc), then both

2073N/A # (variant.arch, i386) and (variant.arch, sparc)

1500N/A # must exist. This code assumes variant values

1500N/A # for each variant are already sorted.

1500N/A for pair in chain.from_iterable(

1500N/A product(*(

1500N/A tuple((name, val)

2613N/A for val in variants[name])

51N/A for name in vcombo)

1500N/A )

1500N/A for vcombo in vcombos

1500N/A ):

1500N/A if pair not in facets:

1500N/A # If any combination the package

1500N/A # supports has not been seen for

1500N/A # one or more facets, then some

2073N/A # facets are unique to one or

2073N/A # more combinations.

2073N/A merge_facets = False

2073N/A break

2073N/A

2073N/A if merge_facets:

1890N/A # Merge the facets common to all variants if safe;

1500N/A # if we always merged them, then facets only

2073N/A # used by a single variant (think i386-only or

2073N/A # sparc-only content) would be seen unvarianted

2073N/A # (that's bad).

1500N/A vfacets = list(facets.values())

1500N/A vcfacets = vfacets[0].intersection(*vfacets[1:])

1500N/A

1500N/A if vcfacets:

926N/A # At least one facet is shared between

1500N/A # all variant combinations; move the

2026N/A # common ones to the unvarianted set.

2608N/A cfacets.update(vcfacets)

2608N/A

2608N/A # Remove facets common to all combos.

2608N/A for varkey, fnames in facets.items():

1500N/A fnames.difference_update(vcfacets)

2026N/A if not fnames:

2026N/A # No facets unique to

2026N/A # this combo; discard.

2026N/A del facets[varkey]

2073N/A

2026N/A # Omit the "facet." prefix from attribute values since

2026N/A # that's implicit and can be added back when the action

1500N/A # is parsed.

1500N/A val = sorted(f[6:] for f in cfacets)

1500N/A if not val:

1500N/A # If we don't do this, action stringify will

1500N/A # emit this as "set name=pkg.facet" which is

123N/A # then transformed to "set name=name

1500N/A # value=pkg.facet". Not what we wanted, but is

1500N/A # expected for historical reasons.

877N/A val = ""

1500N/A

1500N/A # Always emit an action enumerating the list of facets

1500N/A # common to all variants, even if there aren't any.

1500N/A # That way if there are also no variant-specific facets,

1500N/A # package operations will know that no facets are used

1500N/A # by the package instead of having to scan the whole

1500N/A # manifest.

1500N/A yield "{0}\n".format(AttributeAction(None,

1500N/A name="pkg.facet.common", value=val))

1500N/A

1500N/A # Now emit a pkg.facet action for each variant

1500N/A # combination containing the list of facets unique to

1500N/A # that combination.

1500N/A for varkey, fnames in six.iteritems(facets):

39N/A # A unique key for each combination is needed,

1500N/A # and using a hash obfuscates that interface

1500N/A # while giving us a reliable way to generate

1500N/A # a reproducible, unique identifier. The key

1500N/A # string below looks like this before hashing:

1500N/A # variant.archi386variant.debug.osnetTrue...

838N/A key = hashlib.sha1(

1500N/A "".join("{0}{1}".format(*v) for v in varkey)

1500N/A ).hexdigest()

1500N/A

1500N/A # Omit the "facet." prefix from attribute values

1500N/A # since that's implicit and can be added back

1500N/A # when the action is parsed.

2238N/A act = AttributeAction(None,

2238N/A name="pkg.facet.{0}".format(key),

2238N/A value=sorted(f[6:] for f in fnames))

2238N/A attrs = act.attrs

1500N/A # Tag action with variants.

1500N/A for v in varkey:

2238N/A attrs[v[0]] = v[1]

2238N/A yield "{0}\n".format(act)

2238N/A

2238N/A # Emit pkg.[c]size attribute for [compressed] size of package

2238N/A # for each facet/variant combination.

2238N/A csize = 0

39N/A size = 0

956N/A for varcetkeys in refs:

956N/A rcsize = refs[varcetkeys]["csize"]

956N/A rsize = refs[varcetkeys]["size"]

956N/A

1431N/A if not varcetkeys:

1431N/A # For unfaceted/unvarianted actions, keep a

956N/A # running total so a single [c]size action can

956N/A # be generated.

956N/A csize += rcsize

956N/A size += rsize

956N/A continue

956N/A

941N/A if emit_sizes and (rcsize > 0 or rsize > 0):

1007N/A # Only emit if > 0; actions may be

1007N/A # faceted/variant without payload.

1007N/A

1007N/A # A unique key for each combination is needed,

1007N/A # and using a hash obfuscates that interface

1007N/A # while giving us a reliable way to generate

1007N/A # a reproducible, unique identifier. The key

1007N/A # string below looks like this before hashing:

1007N/A # facet.docTruevariant.archi386...

1007N/A key = hashlib.sha1(

1007N/A "".join("{0}{1}".format(*v) for v in varcetkeys)

1007N/A ).hexdigest()

1007N/A

1007N/A # The sizes are abbreviated in the name of byte

1100N/A # conservation.

1407N/A act = AttributeAction(None,

941N/A name="pkg.sizes.{0}".format(key),

941N/A value=["csz={0}".format(rcsize),

144N/A "sz={0}".format(rsize)])

941N/A attrs = act.attrs

1100N/A for v in varcetkeys:

1100N/A attrs[v[0]] = v[1]

1100N/A yield "{0}\n".format(act)

1100N/A

1100N/A if emit_sizes:

1100N/A act = AttributeAction(None, name="pkg.sizes.common",

1100N/A value=["csz={0}".format(csize),

1100N/A "sz={0}".format(size)])

1100N/A yield "{0}\n".format(act)

1100N/A

941N/A def _actions_to_dict(self, references):

941N/A """create dictionary of all actions referenced explicitly or

941N/A

941N/A refs = {}

941N/A # build a dictionary containing all actions tagged w/

941N/A # variants

941N/A for a in self.actions:

941N/A v, f = a.get_varcet_keys()

941N/A variants = dict((name, a.attrs[name]) for name in v + f)

941N/A for ref in references(a):

941N/A if ref not in refs:

941N/A refs[ref] = [variants]

941N/A elif variants not in refs[ref]:

429N/A refs[ref].append(variants)

941N/A

941N/A # remove any tags if any entries are always delivered (NULL)

941N/A for ref in refs:

941N/A if {} in refs[ref]:

941N/A refs[ref] = [{}]

429N/A continue

941N/A # could collapse refs where all variants are present

941N/A # (the current logic only collapses them if at least

941N/A # one reference is delivered without a facet or

941N/A # variant)

941N/A return refs

1007N/A

1007N/A def get_directories(self, excludes):

1234N/A """ return a list of directories implicitly or

1007N/A

1007N/A if self.excludes == excludes:

1007N/A excludes = EmptyI

1007N/A assert excludes == EmptyI or self.excludes == EmptyI

1007N/A try:

1007N/A alist = self._cache["manifest.dircache"]

1007N/A except KeyError:

1007N/A # generate actions that contain directories

1007N/A alist = self._cache["manifest.dircache"] = [

1007N/A actions.fromstr(s.rstrip())

1007N/A for s in self._gen_dirs_to_str()

1007N/A ]

1007N/A

1007N/A s = set([

1007N/A a.attrs["path"]

1007N/A for a in alist

1007N/A if not excludes or a.include_this(excludes,

1007N/A publisher=self.publisher)

1007N/A ])

1007N/A

1007N/A return list(s)

1007N/A

1007N/A def gen_facets(self, excludes=EmptyI, patterns=EmptyI):

1007N/A """A generator function that returns the supported facet

941N/A

941N/A if self.excludes == excludes:

144N/A excludes = EmptyI

144N/A assert excludes == EmptyI or self.excludes == EmptyI

1472N/A

1472N/A try:

1472N/A facets = self["pkg.facet"]

1472N/A except KeyError:

1352N/A facets = None

1516N/A

1890N/A if facets is not None and excludes == EmptyI:

1890N/A # No excludes? Then use the pre-determined set of

1890N/A # facets.

1890N/A for f in misc.yield_matching("facet.", facets, patterns):

1890N/A yield f

1352N/A return

1472N/A

1352N/A # If different excludes were specified, then look for pkg.facet

1352N/A # actions containing the list of facets.

1352N/A found = False

1352N/A seen = set()

1352N/A for a in self.gen_actions_by_type("set", excludes=excludes):

1352N/A if a.attrs["name"][:10] == "pkg.facet.":

1352N/A # Either a pkg.facet.common action or a

2073N/A # pkg.facet.X variant-specific action.

1352N/A found = True

429N/A val = a.attrlist("value")

429N/A if len(val) == 1 and val[0] == "":

144N/A # No facets.

1386N/A continue

1386N/A

1386N/A for f in misc.yield_matching("facet.", (

1636N/A "facet.{0}".format(n)

1636N/A for n in val

1636N/A ), patterns):

1636N/A if f in seen:

2073N/A # Prevent duplicates; it's

1636N/A # possible a given facet may be

2073N/A # valid for more than one unique

1636N/A # variant combination that's

1636N/A # allowed by current excludes.

1636N/A continue

1386N/A

1636N/A seen.add(f)

1636N/A yield f

1636N/A

1636N/A if not found:

2073N/A # Fallback to sifting actions to yield possible.

1636N/A facets = self._get_varcets(excludes=excludes)[1]

2284N/A for f in misc.yield_matching("facet.", facets, patterns):

1636N/A yield f

1636N/A

1636N/A def gen_variants(self, excludes=EmptyI, patterns=EmptyI):

1386N/A """A generator function that yields a list of tuples of the form

315N/A

315N/A if self.excludes == excludes:

315N/A excludes = EmptyI

1636N/A assert excludes == EmptyI or self.excludes == EmptyI

1636N/A

1636N/A try:

1636N/A variants = self["pkg.variant"]

1636N/A except KeyError:

1636N/A variants = None

2073N/A

1636N/A if variants is not None and excludes == EmptyI:

2073N/A # No excludes? Then use the pre-determined set of

1636N/A # variants.

1636N/A for v in misc.yield_matching("variant.", variants,

144N/A patterns):

838N/A yield v, self.attributes.get(v, [])

838N/A return

838N/A

926N/A # If different excludes were specified, then look for

926N/A # pkg.variant action containing the list of variants.

926N/A found = False

926N/A variants = defaultdict(set)

838N/A for a in self.gen_actions_by_type("set", excludes=excludes):

1231N/A aname = a.attrs["name"]

1231N/A if aname == "pkg.variant":

2091N/A val = a.attrlist("value")

1231N/A if len(val) == 1 and val[0] == "":

1231N/A # No variants.

1231N/A return

1231N/A for v in val:

1231N/A found = True

205N/A # Ensure variant entries exist (debug

257N/A # variants may not) via defaultdict.

257N/A variants["variant.{0}".format(v)]

257N/A elif aname[:8] == "variant.":

205N/A for v in a.attrlist("value"):

205N/A found = True

1461N/A variants[aname].add(v)

1461N/A

1461N/A if not found:

1461N/A # Fallback to sifting actions to get possible.

1461N/A variants = self._get_varcets(excludes=excludes)[0]

1461N/A

1461N/A for v in misc.yield_matching("variant.", variants, patterns):

1461N/A yield v, variants[v]

1461N/A

1461N/A def gen_mediators(self, excludes=EmptyI):

1461N/A """A generator function that yields tuples of the form (mediator,

1044N/A

1044N/A if self.excludes == excludes:

1044N/A excludes = EmptyI

1044N/A assert excludes == EmptyI or self.excludes == EmptyI

1044N/A try:

1044N/A alist = self._cache["manifest.mediatorcache"]

2286N/A except KeyError:

1044N/A # generate actions that contain mediators

1044N/A alist = self._cache["manifest.mediatorcache"] = [

205N/A actions.fromstr(s.rstrip())

838N/A for s in self._gen_mediators_to_str()

838N/A ]

205N/A

296N/A ret = defaultdict(set)

296N/A for attrs in (

838N/A act.attrs

296N/A for act in alist

296N/A if not excludes or act.include_this(excludes)):

296N/A med_ver = attrs.get("mediator-version")

296N/A if med_ver:

296N/A try:

296N/A med_ver = version.Version(med_ver)

296N/A except version.VersionError:

1461N/A # Consider this mediation unavailable

296N/A # if it can't be parsed for whatever

205N/A # reason.

838N/A continue

205N/A

48N/A ret[attrs["value"]].add((

956N/A attrs.get("mediator-priority"),

2054N/A med_ver,

2054N/A attrs.get("mediator-implementation"),

2054N/A ))

2054N/A

2054N/A for m in ret:

2054N/A yield m, ret[m]

2054N/A

956N/A def gen_actions(self, attr_match=None, excludes=EmptyI):

2073N/A """Generate actions in manifest through ordered callable list"""

2073N/A

2073N/A if self.excludes == excludes:

2073N/A excludes = EmptyI

2073N/A assert excludes == EmptyI or self.excludes == EmptyI

1386N/A

2073N/A if attr_match:

2073N/A attr_match = _compile_fnpats(attr_match)

2073N/A

2073N/A pub = self.publisher

2073N/A for a in self.actions:

2073N/A for c in excludes:

2073N/A if not c(a, publisher=pub):

2073N/A break

956N/A else:

2608N/A # These conditions are split by performance.

2608N/A if not attr_match:

2608N/A yield a

956N/A elif _attr_matches(a, attr_match):

2073N/A yield a

2073N/A

2073N/A def gen_actions_by_type(self, atype, attr_match=None, excludes=EmptyI):

2144N/A """Generate actions in the manifest of type "type"

2144N/A

2073N/A if self.excludes == excludes:

2073N/A excludes = EmptyI

2073N/A assert excludes == EmptyI or self.excludes == EmptyI

2073N/A

2073N/A if attr_match:

2608N/A attr_match = _compile_fnpats(attr_match)

2608N/A

2631N/A pub = self.publisher

2073N/A for a in self.actions_bytype.get(atype, []):

956N/A for c in excludes:

956N/A if not c(a, publisher=pub):

2073N/A break

956N/A else:

956N/A # These conditions are split by performance.

956N/A if not attr_match:

956N/A yield a

956N/A elif _attr_matches(a, attr_match):

2073N/A yield a

956N/A

967N/A def gen_actions_by_types(self, atypes, attr_match=None, excludes=EmptyI):

967N/A """Generate actions in the manifest of types "atypes"

2073N/A

956N/A for atype in atypes:

956N/A for a in self.gen_actions_by_type(atype,

956N/A attr_match=attr_match, excludes=excludes):

2073N/A yield a

1507N/A

956N/A def gen_key_attribute_value_by_type(self, atype, excludes=EmptyI):

956N/A """Generate the value of the key attribute for each action

956N/A

967N/A return (

967N/A a.attrs.get(a.key_attr)

2631N/A for a in self.gen_actions_by_type(atype, excludes=excludes)

956N/A )

956N/A

2631N/A def duplicates(self, excludes=EmptyI):

2631N/A """Find actions in the manifest which are duplicates (i.e.,

2073N/A

2073N/A def fun(a):

956N/A """Return a key on which actions can be sorted."""

956N/A return a.name, a.attrs.get(a.key_attr, id(a))

2073N/A

956N/A alldups = []

956N/A acts = [a for a in self.gen_actions(excludes=excludes)]

967N/A

967N/A for k, g in groupby(sorted(acts, key=fun), fun):

967N/A glist = list(g)

967N/A dups = set()

967N/A for i in range(len(glist) - 1):

1507N/A if glist[i].different(glist[i + 1]):

1507N/A dups.add(glist[i])

1507N/A dups.add(glist[i + 1])

967N/A if dups:

1507N/A alldups.append((k, dups))

956N/A return alldups

1507N/A

956N/A def __content_to_actions(self, content):

956N/A """Parse manifest content, stripping line-continuation

1507N/A

956N/A accumulate = ""

956N/A lineno = 0

956N/A errors = []

956N/A

2073N/A if isinstance(content, six.string_types):

1386N/A # Get an iterable for the string.

2144N/A content = content.splitlines()

2144N/A

2144N/A for l in content:

956N/A lineno += 1

1507N/A l = l.lstrip()

956N/A if l.endswith("\\"): # allow continuation chars

1386N/A accumulate += l[0:-1] # elide backslash

1386N/A continue

1386N/A elif accumulate:

1386N/A l = accumulate + l

1386N/A accumulate = ""

956N/A

956N/A if not l or l[0] == "#": # ignore blank lines & comments

956N/A continue

1507N/A

2073N/A try:

1386N/A yield actions.fromstr(l)

2453N/A except actions.ActionError as e:

2453N/A # Accumulate errors and continue so that as

2453N/A # much of the action data as possible can be

2453N/A # parsed.

2453N/A e.fmri = self.fmri

2453N/A e.lineno = lineno

2453N/A errors.append(e)

2453N/A

2453N/A if errors:

2453N/A raise apx.InvalidPackageErrors(errors)

956N/A

2453N/A def set_content(self, content=None, excludes=EmptyI, pathname=None,

2453N/A signatures=False):

2453N/A """Populate the manifest with actions.

2035N/A

2035N/A assert content is not None or pathname is not None

2475N/A assert not (content and pathname)

2475N/A

2475N/A self.actions = []

2475N/A self.actions_bytype = {}

2035N/A self.attributes = {}

2453N/A self._cache = {}

2453N/A self._absent_cache = []

2453N/A

2453N/A # So we could build up here the type/key_attr dictionaries like

1507N/A # sdict and odict in difference() above, and have that be our

2453N/A # main datastore, rather than the simple list we have now. If

956N/A # we do that here, we can even assert that the "same" action

956N/A # can't be in a manifest twice. (The problem of having the same

956N/A # action more than once in packages that can be installed

956N/A # together has to be solved somewhere else, though.)

956N/A if pathname:

2339N/A try:

2453N/A with open(pathname, "rb") as mfile:

2339N/A content = mfile.read()

2453N/A except EnvironmentError as e:

2453N/A raise apx._convert_error(e)

2453N/A if isinstance(content, six.string_types):

2453N/A if signatures:

2613N/A # Generate manifest signature based upon

2613N/A # input content, but only if signatures

2613N/A # were requested. In order to interoperate with

2613N/A # older clients, we must use sha-1 here.

2613N/A self.signatures = {

2613N/A "sha-1": self.hash_create(content)

2453N/A }

2453N/A content = self.__content_to_actions(content)

2453N/A

2453N/A for action in content:

2453N/A self.add_action(action, excludes)

2453N/A self.excludes = excludes

2453N/A # Make sure that either no excludes were provided or that both

2453N/A # variants and facet excludes were or that variant, facet and

2453N/A # hydrate excludes were.

2339N/A assert len(self.excludes) != 1

956N/A

956N/A def exclude_content(self, excludes):

956N/A """Remove any actions from the manifest which should be

956N/A

956N/A self.set_content(content=self.actions, excludes=excludes)

956N/A

956N/A def add_action(self, action, excludes):

1507N/A """Performs any needed transformations on the action then adds

2073N/A

956N/A attrs = action.attrs

956N/A aname = action.name

956N/A

956N/A # XXX handle legacy transition issues; not needed once support

956N/A # for upgrading images from older releases (< build 151) has

956N/A # been removed.

956N/A if "opensolaris.zone" in attrs and \

1507N/A "variant.opensolaris.zone" not in attrs:

956N/A attrs["variant.opensolaris.zone"] = \

956N/A attrs["opensolaris.zone"]

956N/A

2613N/A if aname == "set" and attrs["name"] == "authority":

2613N/A # Translate old action to new.

2613N/A attrs["name"] = "publisher"

2613N/A

956N/A if excludes and not action.include_this(excludes,

2073N/A publisher=self.publisher):

956N/A return

956N/A

956N/A self.actions.append(action)

956N/A try:

956N/A self.actions_bytype[aname].append(action)

956N/A except KeyError:

956N/A self.actions_bytype.setdefault(aname, []).append(action)

956N/A

956N/A # add any set actions to attributes

956N/A if aname == "set":

956N/A self.fill_attributes(action)

2453N/A

2453N/A def fill_attributes(self, action):

2453N/A """Fill attribute array w/ set action contents."""

2453N/A try:

2453N/A keyvalue = action.attrs["name"]

2453N/A if keyvalue[:10] == "pkg.sizes.":

2453N/A # To reduce manifest bloat, size and csize

956N/A # are set on a single action so need splitting

956N/A # into separate attributes.

956N/A attrval = action.attrlist("value")

956N/A for entry in attrval:

2073N/A szname, szval = entry.split("=", 1)

956N/A if szname == "sz":

956N/A szname = "pkg.size"

956N/A elif szname == "csz":

956N/A szname = "pkg.csize"

956N/A else:

956N/A # Skip unknowns.

956N/A continue

956N/A

1507N/A self.attributes.setdefault(szname, 0)

1507N/A self.attributes[szname] += int(szval)

956N/A return

956N/A except (KeyError, TypeError, ValueError):

956N/A # ignore broken set actions

956N/A pass

1507N/A

956N/A # Ensure facet and variant attributes are always lists.

2054N/A if keyvalue[:10] == "pkg.facet.":

2054N/A # Possible facets list is spread over multiple actions.

956N/A val = action.attrlist("value")

956N/A if len(val) == 1 and val[0] == "":

956N/A # No facets.

956N/A val = []

956N/A

956N/A seen = self.attributes.setdefault("pkg.facet", [])

956N/A for f in val:

956N/A entry = "facet.{0}".format(f)

956N/A if entry not in seen:

956N/A # Prevent duplicates; it's possible a

956N/A # given facet may be valid for more than

956N/A # one unique variant combination that's

956N/A # allowed by current excludes.

956N/A seen.append(f)

956N/A return

956N/A elif keyvalue == "pkg.variant":

956N/A val = action.attrlist("value")

1376N/A if len(val) == 1 and val[0] == "":

1376N/A # No variants.

1376N/A val = []

1376N/A

1376N/A self.attributes[keyvalue] = [

956N/A "variant.{0}".format(v)

2073N/A for v in val

2073N/A ]

956N/A return

956N/A elif keyvalue[:8] == "variant.":

956N/A self.attributes[keyvalue] = action.attrlist("value")

956N/A return

956N/A

956N/A if keyvalue == "fmri":

956N/A # Ancient manifest compatibility.

2026N/A keyvalue = "pkg.fmri"

2026N/A self.attributes[keyvalue] = action.attrs["value"]

2026N/A

2026N/A @staticmethod

2026N/A def search_dict(file_path, excludes, return_line=False,

956N/A log=None):

956N/A """Produces the search dictionary for a specific manifest.

1507N/A

956N/A if log is None:

956N/A log = lambda x: None

2073N/A

2073N/A try:

2073N/A file_handle = open(file_path, "rb")

2073N/A except EnvironmentError as e:

2073N/A if e.errno != errno.ENOENT:

2073N/A raise

2073N/A log((_("{fp}:\n{e}").format(

2073N/A fp=file_path, e=e)))

1507N/A return {}

2054N/A cur_pos = 0

964N/A line = file_handle.readline()

964N/A action_dict = {}

2054N/A def __handle_list(lst, cp):

964N/A """Translates what actions.generate_indices produces

1045N/A

1045N/A for action_name, subtype, tok, full_value in lst:

1045N/A if action_name == "set":

1045N/A if full_value is None:

1045N/A full_value = tok

1045N/A else:

1045N/A if full_value is None:

1045N/A full_value = subtype

1713N/A if full_value is None:

1505N/A full_value = action_name

1045N/A if isinstance(tok, list):

1352N/A __handle_list([

1352N/A (action_name, subtype, t,

964N/A full_value)

964N/A for t in tok

2608N/A ], cp)

2608N/A else:

2608N/A if (tok, action_name, subtype,

2608N/A full_value) in action_dict:

2608N/A action_dict[(tok, action_name,

2608N/A subtype, full_value)

2608N/A ].append(cp)

2608N/A else:

2608N/A action_dict[(tok, action_name,

2054N/A subtype, full_value)] = [cp]

2284N/A while line:

2284N/A l = line.strip()

2284N/A if l and l[0] != "#":

2284N/A try:

2284N/A action = actions.fromstr(l)

2453N/A except actions.ActionError as e:

2284N/A log((_("{fp}:\n{e}").format(

2284N/A fp=file_path, e=e)))

2284N/A else:

2284N/A if not excludes or \

2284N/A action.include_this(excludes):

2284N/A if "path" in action.attrs:

2284N/A np = action.attrs["path"].lstrip(os.path.sep)

2284N/A action.attrs["path"] = \

2284N/A np

try:

inds = action.generate_indices()

except KeyError as k:

log(_("{fp} contains "

"an action which is"

" missing the "

"expected attribute"

": {at}.\nThe "

"action is:"

"{act}").format(

fp=file_path,

at=k.args[0],

act=l

))

else:

arg = cur_pos