0N/A

0N/Aimport bisect

0N/Aimport os

0N/Aimport re

0N/Aimport sha

0N/Aimport shutil

0N/Aimport time

0N/Aimport urllib

0N/Afrom itertools import groupby

0N/A

0N/Aimport pkg.actions as actions

0N/Aimport pkg.fmri as fmri

0N/Aimport pkg.package as package

0N/Aimport pkg.client.retrieve as retrieve

0N/Aimport pkg.client.filter as filter

0N/A

0N/AACTION_DIR = 10

0N/AACTION_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 = []

self.attributes = {}

return

def __str__(self):

r = ""

if self.fmri != None:

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

for att in sorted(self.attributes.keys()):

r = r + "set %s = %s\n" % (att, self.attributes[att])

for act in self.actions:

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

return r

def difference(self, origin):

"""Return a list 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]

changed = [

(odict[i], sdict[i])

for i in oset & sset

if odict[i].different(sdict[i])

]

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

added.sort(key = addsort)

changed.sort(key = addsort)

return removed + added + changed

def display_differences(self, other):

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

l = self.difference(other)

for src, dest in l:

if not src:

print "+", dest

elif not dest:

print "-", src

else:

print "%s -> %s" % (src, dest)

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

if re.match("^\s*(#.*)?$", l):

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

null = Manifest()

if __name__ == "__main__":

m1 = Manifest()

x = """\

m1.set_content(x)

print m1

m2 = Manifest()

y = """\

m2.set_content(y)

print m2

m2.display_differences(m1)

print null

m2.display_differences(null)

print

m2.difference(m1)

m3 = Manifest()

t3 = """\

m3.set_content(t3)

m4 = Manifest()

t4 = """\

m4.set_content(t4)

print "\n" + 50 * "=" + "\n"

m4.difference(m3)

print "\n" + 50 * "=" + "\n"

m4.difference(null)

# Test the duplicate search. /bin shouldn't show up, since they're

# identical actions, but /usr should show up three times.

m5 = Manifest()

t5 = """\

m5.set_content(t5)

for kv, actions in m5.duplicates():

print kv

for a in actions:

print " %s" % a