332e3fd09754ad85800a736292a0ef8dfdca4c9eAki Tuomi

import bisect

import os

import sha

import shutil

import time

import urllib

import cPickle

from itertools import groupby, chain

import pkg.actions as actions

import pkg.fmri as fmri

import pkg.client.retrieve as retrieve

import pkg.client.filter as filter

ACTION_DIR = 10

ACTION_FILE = 20

ACTION_LINK = 50

ACTION_HARDLINK = 55

ACTION_DEVICE = 100

ACTION_USER = 200

ACTION_GROUP = 210

ACTION_SERVICE = 300

ACTION_RESTART = 310

ACTION_DEPEND = 400

DEPEND_REQUIRE = 0

DEPEND_OPTIONAL = 1

DEPEND_INCORPORATE =10

depend_str = { DEPEND_REQUIRE : "require",

DEPEND_OPTIONAL : "optional",

DEPEND_INCORPORATE : "incorporate"

}

class Manifest(object):

"""A Manifest is the representation of the actions composing a specific

def __init__(self):

self.img = None

self.fmri = None

self.actions = []

def __str__(self):

r = ""

if self.fmri != None:

r = r + "set fmri = %s\n" % self.fmri

for act in sorted(self.actions):

r = r + "%s\n" % act

return r

def difference(self, origin):

"""Return three lists of action pairs representing origin and

# XXX Do we need to find some way to assert that the keys are

# all unique?

sdict = dict(

((a.name, a.attrs.get(a.key_attr, id(a))), a)

for a in self.actions

)

odict = dict(

((a.name, a.attrs.get(a.key_attr, id(a))), a)

for a in origin.actions

)

sset = set(sdict.keys())

oset = set(odict.keys())

added = [(None, sdict[i]) for i in sset - oset]

removed = [(odict[i], None) for i in oset - sset]

# XXX for now, we force license actions to always be

# different to insure that existing license files for

# new versions are always installed

changed = [

(odict[i], sdict[i])

for i in oset & sset

if odict[i].different(sdict[i]) or i[0] == "license"

]

# XXX Do changed actions need to be sorted at all? This is

# likely to be the largest list, so we might save significant

# time by not sorting. Should we sort above? Insert into a

# sorted list?

# singlesort = lambda x: x[0] or x[1]

addsort = lambda x: x[1]

remsort = lambda x: x[0]

removed.sort(key = remsort, reverse = True)

added.sort(key = addsort)

changed.sort(key = addsort)

return (added, changed, removed)

def combined_difference(self, origin):

"""Where difference() returns three lists, combined_difference()

return list(chain(*self.difference(origin)))

def humanized_differences(self, other):

"""Output expects that self is newer than other. Use of sets

l = self.difference(other)

out = ""

for src, dest in chain(*l):

if not src:

out += "+ %s\n" % str(dest)

elif not dest:

out += "- %s\n" + str(src)

else:

out += "%s -> %s\n" % (src, dest)

return out

def filter(self, filters):

"""Filter out actions from the manifest based on filters."""

self.actions = [

a

for a in self.actions

if filter.apply_filters(a, filters)

]

def duplicates(self):

"""Find actions in the manifest which are duplicates (i.e.,

def fun(a):

"""Return a key on which actions can be sorted."""

return a.name, a.attrs.get(a.key_attr, id(a))

alldups = []

for k, g in groupby(sorted(self.actions, key = fun), fun):

glist = list(g)

dups = set()

for i in range(len(glist) - 1):

if glist[i].different(glist[i + 1]):

dups.add(glist[i])

dups.add(glist[i + 1])

if dups:

alldups.append((k, dups))

return alldups

def set_fmri(self, img, fmri):

self.img = img

self.fmri = fmri

@staticmethod

def make_opener(img, fmri, action):

def opener():

return retrieve.get_datastream(img, fmri, action.hash)

return opener

def set_content(self, str):

"""str is the text representation of the manifest"""

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

# sdict and odict in difference() above, and have that be our

# main datastore, rather than the simple list we have now. If

# we do that here, we can even assert that the "same" action

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

# action more than once in packages that can be installed

# together has to be solved somewhere else, though.)

for l in str.splitlines():

l = l.lstrip()

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

continue

try:

action = actions.fromstr(l)

except KeyError:

raise SyntaxError, \

"unknown action '%s'" % l.split()[0]

if action.attrs.has_key("path"):

np = action.attrs["path"].lstrip(os.path.sep)

action.attrs["path"] = np

if hasattr(action, "hash"):

action.data = \

self.make_opener(self.img, self.fmri, action)

if not self.actions:

self.actions.append(action)

else:

bisect.insort(self.actions, action)

return

def search_dict(self):

"""Return the dictionary used for searching."""

action_dict = {}

for a in self.actions:

for k, v in a.generate_indices().iteritems():

if isinstance(v, list):

if k in action_dict:

action_dict[k].update(

dict((i, True) for i in v))

else:

action_dict[k] = \

dict((i, True) for i in v)

else:

if k in action_dict:

action_dict[k][v] = True

else:

action_dict[k] = { v: True }

return action_dict

def pickle(self, file):

"""Pickle the indices of the manifest's actions to the 'file'.

cPickle.dump(self.search_dict(), file,

protocol = cPickle.HIGHEST_PROTOCOL)

def get(self, key, default):

if key not in self:

return default

return self[key]

def __getitem__(self, key):

"""Return the value for the package attribute 'key'. If no such

values = [

a.attrs["value"]

for a in self.actions

if a.name == "set" and a.attrs["name"] == key

]

if values:

return values[0]

return default

def __contains__(self, key):

for a in self.actions:

if a.name == "set" and a.attrs["name"] == key:

return True

return False

null = Manifest()