49N/A

49N/A

51N/A

49N/Aimport inspect

49N/Aimport os

96N/A

237N/A__all__ = [

237N/A f[:-3]

237N/A for f in os.listdir(__path__[0])

462N/A if f.endswith(".py") and f != "__init__.py"

462N/A]

462N/A

462N/Atypes = {}

237N/Afor modname in __all__:

237N/A module = __import__("%s.%s" % (__name__, modname),

237N/A globals(), locals(), [modname])

237N/A

237N/A nvlist = inspect.getmembers(module, inspect.isclass)

237N/A

583N/A # Pull the class objects out of nvlist, keeping only those that are

136N/A # actually defined in this package.

96N/A classes = [

96N/A c[1]

96N/A for c in nvlist

237N/A if '.'.join(c[1].__module__.split('.')[:-1]) == __name__

96N/A ]

96N/A for cls in classes:

136N/A types[cls.name] = cls

96N/A

462N/Adel f, modname, module, nvlist, classes, c, cls

462N/A

96N/A

96N/Aclass ActionError(Exception):

462N/A """Base exception class for Action errors."""

462N/A

96N/A def __unicode__(self):

96N/A # To workaround python issues 6108 and 2517, this provides a

222N/A # a standard wrapper for this class' exceptions so that they

237N/A # have a chance of being stringified correctly.

237N/A return str(self)

237N/A

222N/A def __str__(self):

583N/A raise NotImplementedError()

222N/A

222N/Aclass UnknownActionError(ActionError):

222N/A def __init__(self, *args):

222N/A ActionError.__init__(self)

583N/A self.actionstr = args[0]

222N/A self.type = args[1]

462N/A

462N/A def __str__(self):

237N/A if hasattr(self, "fmri") and self.fmri is not None:

237N/A return _("unknown action type '%(type)s' in package "

583N/A "'%(fmri)s' in action '%(action)s'") % {

583N/A "type": self.type, "fmri": self.fmri,

583N/A "action": self.actionstr }

583N/A return _("unknown action type '%(type)s' in action "

583N/A "'%(action)s'") % { "type": self.type,

583N/A "action": self.actionstr }

222N/A

237N/Aclass MalformedActionError(ActionError):

237N/A def __init__(self, *args):

583N/A ActionError.__init__(self)

583N/A self.actionstr = args[0]

222N/A self.position = args[1]

237N/A self.errorstr = args[2]

583N/A

222N/A def __str__(self):

583N/A marker = " " * (4 + self.position) + "^"

if hasattr(self, "fmri") and self.fmri is not None:

return _("Malformed action in package '%(fmri)s' at "

"position: %(pos)d:\n %(action)s\n"

"%(marker)s") % { "fmri": self.fmri,

"pos": self.position, "action": self.actionstr,

"marker": marker }

return _("Malformed action at position: %(pos)d:\n "

"%(action)s\n%(marker)s") % { "pos": self.position,

"action": self.actionstr, "marker": marker }

class ActionDataError(ActionError):

"""Used to indicate that a file-related error occuring during action

def __init__(self, *args, **kwargs):

ActionError.__init__(self)

self.error = args[0]

self.path = kwargs.get("path", None)

def __str__(self):

return str(self.error)

class InvalidActionError(ActionError):

"""Used to indicate that attributes provided were invalid, or required

def __init__(self, *args):

ActionError.__init__(self)

self.actionstr = args[0]

self.errorstr = args[1]

def __str__(self):

if hasattr(self, "fmri") and self.fmri is not None:

return _("invalid action in package %(fmri)s: "

"%(action)s: %(error)s") % { "fmri": self.fmri,

"action": self.actionstr, "error": self.errorstr }

return _("invalid action, '%(action)s': %(error)s") % {

"action": self.actionstr, "error": self.errorstr }

class InvalidActionAttributesError(ActionError):

"""Used to indicate that one more action attributes were invalid."""

def __init__(self, act, errors, fmri=None):

"""'act' is an Action (object or string).

ActionError.__init__(self)

self.action = act

self.errors = errors

self.fmri = fmri

def __str__(self):

act_errors = "\n ".join(err for name, err in self.errors)

if self.fmri:

return _("The action '%(action)s' in package "

"'%(fmri)s' has invalid attribute(s):\n"

" %(act_errors)s") % { "action": self.action,

"fmri": self.fmri, "act_errors": act_errors }

return _("The action '%(action)s' has invalid attribute(s):\n"

" %(act_errors)s") % { "action": self.action,

"act_errors": act_errors }

from _actions import _fromstr

def attrsfromstr(string):

"""Create an attribute dict given a string w/ key=value pairs.

return _fromstr("bogus %s" % string)[2]

def fromstr(string, data=None):

"""Create an action instance based on a str() representation of an

atype, ahash, attr_dict = _fromstr(string)

if atype not in types:

raise UnknownActionError(string, atype)

action = types[atype](data=data, **attr_dict)

ka = action.key_attr

if ka is not None and (ka not in action.attrs or

action.attrs[ka] is None):

raise InvalidActionError(string, _("required attribute '%s' "

"was not provided.") % ka)

if ahash:

action.hash = ahash

return action

def internalizelist(atype, args, ahash=None, basedirs=None):

"""Create an action instance based on a sequence of "key=value" strings.

if atype not in types:

raise UnknownActionError(("%s %s" % (atype,

" ".join(args))).strip(), atype)

data = None

if atype in ("file", "license"):

data = args.pop(0)

attrs = {}

try:

for a, v in [kv.split("=", 1) for kv in args]:

if v == '' or a == '':

kvi = args.index(kv) + 1

p1 = " ".join(args[:kvi])

p2 = " ".join(args[kvi:])

raise MalformedActionError(

"%s %s %s" % (atype, p1, p2), len(p1) + 1,

"attribute '%s'" % kv)

# This is by far the common case-- an attribute with

# a single value.

if a not in attrs:

attrs[a] = v

else:

av = attrs[a]

if isinstance(av, list):

attrs[a].append(v)

else:

attrs[a] = [ av, v ]

except ValueError:

# We're only here if the for: statement above throws a

# MalformedActionError. That can happen if split yields a

# single element, which is possible if e.g. an attribute lacks

# an =.

kvi = args.index(kv) + 1

p1 = " ".join(args[:kvi])

p2 = " ".join(args[kvi:])

raise MalformedActionError("%s %s %s" % (atype, p1, p2),

len(p1) + 2, "attribute '%s'" % kv)

# keys called 'data' cause problems due to the named parameter being

# passed to the action constructor below. Check for these. Note that

# _fromstr also checks for this.

if "data" in attrs:

astr = atype + " " + " ".join(args)

raise InvalidActionError(astr,

"%s action cannot have a 'data' attribute" % atype)

action = types[atype](data=None, **attrs)

ka = action.key_attr

if ka is not None and (ka not in action.attrs or

action.attrs[ka] is None):

raise InvalidActionError(("%s %s" % (atype,

" ".join(args))).strip(), _("required attribute, "

"'%s', was not provided.") % ka)

if ahash:

action.hash = ahash

local_path, used_basedir = set_action_data(data, action, basedirs)

return action, local_path

def internalizestr(string, basedirs=None, load_data=True):

"""Create an action instance based on a sequence of strings.

string = string.strip()

args = string.split()

atype = args.pop(0)

if atype not in types:

raise UnknownActionError(("%s %s" % (atype,

" ".join(args))).strip(), atype)

action = fromstr(string)

if atype not in ("file", "license") or not load_data:

return action, None, None

local_path, used_basedir = set_action_data(args[0], action, basedirs)

return action, local_path, used_basedir

def set_action_data(payload, action, basedirs):

"""Sets the data field of an action using the information in the

if not payload:

return None, None

if payload == "NOHASH":

filepath = os.path.sep + action.attrs["path"]

else:

filepath = payload

used_basedir = None

if basedirs:

path = filepath.lstrip(os.path.sep)

# look for file in specified dirs

for d in basedirs:

data = os.path.join(d, path)

if os.path.isfile(data):

used_basedir = d

break

else:

data = filepath

action.set_data(data)

return data, used_basedir