delim = '___'

re_id = re.compile('^[0-9]+'+delim)

@classmethod

def make( klas, id_, name):

return id_and_name.delim.join( [ str(id_ or 0), name ])

@classmethod

def get_name( klas, s):

return klas.re_id.sub( '', s, 1)

@classmethod

def get_id( klas, s):

r = klas.re_id.match(s)

if not r: return None

return int(s[ :r.end()-len(klas.delim)])

@classmethod

def strip_id_from_path( klas, path):

p, filename = os.path.split( path)

stripped = klas.get_name( filename)

return os.path.join( p, stripped)

@classmethod

def get_id_from_path( klas, path):

p, filename = os.path.split( path)

_rexp = None

_dir_name = None

class External( object):

def __init__(me, path):

me.path = path

@classmethod

def rexp( klas):

if vars(klas).get('_rexp') is None:

klas._rexp = re.compile('^/'+klas.dir_name())

return klas._rexp

@classmethod

def dir_name( klas):

if vars(klas).get('_dir_name') is None:

klas._dir_name = klas.__name__.lower()

return klas._dir_name

aliases = dict() # cache for getattr to avoid redundant parsing and queries

alias_path_in_use = None

class Parser( object):

error = None

def __init__( me, context, op_klas, full_path, path_in_aspect):

me.context = context

me.db = context.db

me.op_klas = op_klas

me.full_path = full_path # the complete path that generated the query e.g. <MPOINT>/t1/+/t2/=/object/path.txt

me.path_in_aspect = path_in_aspect # after stripping aspect regex from full path

me.init()

def init( me):

pass

def check4alias( me):

if not issubclass( me.op_klas, (Operations.getattr, Operations.readlink)):

Aspect.aliases.clear()

me.alias_path_in_use = None

return None

if me.full_path != Aspect.alias_path_in_use:

Aspect.aliases.pop( Aspect.alias_path_in_use, None)

Aspect.alias_path_in_use = me.full_path

return Aspect.aliases.get( me.full_path, None)

def setup_from_alias( me, obj):

pass

def parse( me):

if not me.is_external():

if me.path_in_aspect is None:

return 'malformed'

if not me.path_in_aspect:

return 'aspect'

log('len aliases:', len( Aspect.aliases))

obj = me.check4alias()

if obj:

log('found alias:', obj)

return me.setup_from_alias( obj)

return me._parse()

return Aspect.External( me.full_path)

def _parse( me):

pass

def is_external( me):

return (me.path_in_aspect is None

and issubclass( me.op_klas, Op2)

and not me.full_path.startswith( me.context.mountpoint))

class Error:

def __init__( me, data):

me.data = data

def __str__(me):

return me.__class__.__name__ + ' ' + str(me.data)

__repr__ = __str__

@classmethod

def init( me, context):

operandType = resultType = None

def __init__( cls, name, bases, dct):

if not cls.operandType or not cls.resultType:

return

operand = cls.operandType.__name__.lower()

result = cls.resultType.__name__.lower()

for op_name, op_klas in vars(QAspect).iteritems():

op_klas = getattr( cls, op_name, op_klas)

if issubclass( op_klas, (Op1,Op2)):

class new_op_klas( op_klas): pass

new_op_klas.__name__ = op_klas.__name__

cls.rename_meth( op_klas, new_op_klas, 'operand', operand)

cls.rename_meth( op_klas, new_op_klas, 'result', result)

setattr( cls, op_name, new_op_klas)

parser = cls.Parser

parser.result = property( lambda me: getattr( me, result), lambda me, val: setattr( me, result, val))

parser.operand = property( lambda me: getattr( me, operand), lambda me, val: setattr( me, operand, val))

def rename_meth( cls, op_klas, new_op_klas, old, new):

meth = getattr( op_klas, old, None)

if meth and getattr( new_op_klas, new, None) is None:

setattr( new_op_klas, new, meth)

oldname = old+'_'+old

newname = new+'_'+new

meth = getattr( op_klas, oldname, None)

if meth and vars( op_klas).get( newname) is None:

''' abstraction of aspects that support queries with logic operations'''

__metaclass__ = QAspectMeta

class Negative( object):

def __init__( me, operand):

me.operand = operand

def __getattr__( me, name):

return getattr( me.operand, name)

class sqlite:

@staticmethod

def make_sql_template( sql_intersect, sql_select, where4operand, where4negative, where4operand_many =None, where4negative_many =None):

def template( me, tree):

union = []

for ands in tree:

intersect = []

for op in ands:

if isinstance( op, (list, tuple)):

neg = isinstance( op[0], QAspect.Negative)

ids = tuple([ o.id for o in op])

w = (where4negative_many if neg else where4operand_many) % str(ids)

intersect.append( sql_intersect % w)

else:

s = sql_intersect % (where4negative if isinstance(op, QAspect.Negative) else where4operand)

intersect.append( s % op.id)

union.append( sql_select + ' intersect '.join( intersect) + ')')

return ' union '.join( union)

return template

class Parser( Aspect.Parser):

class UnknownObj( Aspect.Error):

def __init__( me, token, expected_type =None):

me.expected_type = expected_type

Aspect.Error.__init__( me, token + ' expected:' + me.expected_type.__name__)

unknownOperand = lambda me, token: me.UnknownObj( token, me.operand.__class__)

unknownResult = lambda me, token: me.UnknownObj( token, me.result.__class__)

@property

def is_taggable( me):

for t in me.tree:

if isinstance( t, QAspect.Negative):

return False

return bool(me.result.id) # and os.path.sep not in me.result.name #and len(me.tree) == 1

def setup_result( me, path):

pass

def setup_from_alias( me, obj):

if obj.__class__ is me.result.__class__:

me.result = obj

else:

me.operand = obj

return obj

def _parse( me):

qgram = me.context.query_grammar

me.tree = []

me.complete = False

tokens = [ t for t in me.path_in_aspect.split( os.path.sep) if t ]

log('tokens', tokens)

ands = []

me.last_token = None

me.pending_logic = None

have_negative = False

for i, token in enumerate(tokens):

me.last_token = token

if token == qgram.eval_:

if ands:

me.tree.append( ands)

me.complete = True

opath_tokens = tokens[ i+1:] # skip '='

if opath_tokens:

path_tail = os.path.join( *opath_tokens)

me.setup_result( path_tail)

if not me.result.id:

me.error = me.unknownResult( path_tail)

else:

me.error = me.unknownOperand( token)

break

elif token == qgram.or_:

if not ands or have_negative or me.pending_logic:

me.error = me.unknownOperand( token)

break

me.tree.append( ands)

ands = []

me.pending_logic = token

elif token == qgram.and_:

if have_negative or me.pending_logic:

me.error = me.unknownOperand( token)

break

me.pending_logic = token

elif token == qgram.not_:

if have_negative:

me.error = me.unknownOperand( token)

break

have_negative = True

me.pending_logic = token

#elif token == qgram.root:

# log('ERROR: unexpected symbol for root')

# assert 0

else:

logic = me.pending_logic

if logic:

me.pending_logic = None

op = me.token2operand( token)

if logic == qgram.not_:

op = QAspect.Negative( op)

me.operand = op

if not op.id:

if logic:

me.error = me.unknownOperand( token)

break

if (ands

and issubclass( me.op_klas, (Op2, Operations.getattr))

and i == len(tokens)-1):

me.tree.append( ands)

me.setup_result( token)

if not me.result.id:

me.error = me.unknownResult( token)

else:

me.error = me.unknownOperand( token) # XXX is it needed?

break

positive = getattr( op, 'operand', op) # if negative

if ands and positive in ands:

me.error = me.unknownOperand( token)

break

if logic in (qgram.not_, qgram.or_) and [ positive ] in me.tree:

me.error = me.unknownOperand( token)

break

ands.append( op)

else:

if ands:

me.tree.append( ands)

if me.result.id or getattr( me.error, 'expected_type', None) == me.result.__class__:

return me.result

if me.last_token and me.last_token not in qgram.values():# and me.tree:

return me.operand

# path ends with something from query_grammar

return 'query'

def token2operand( me, token):

pass

def tag_tree( me):

if not me.is_taggable:

return False

QAspect.aliases[ me.full_path] = me.result

ops = set( me.iter_tree( me.tree)) - set( me._get_operands4result( me.result))

log('tagging', me.result.id, ops)

me._tag_result( me.result, ops)

return True

def iter_tree( me, tree):

for elem in tree:

if not isiterable( elem):

yield elem

continue

for t in me.iter_tree( elem):

yield t

def untag_tree( me):

if not me.is_taggable:

return False

qops = set( me.iter_tree( me.tree))

log( 'untagging', me.result.id, qops)

me._untag_result( me.result, qops)

return True

def _get_operands4result( me, result):

raise NotImplementedError

def _tag_result( me, result, operands):

raise NotImplementedError

def _untag_result( me, result, operands):

raise NotImplementedError

###############

class getattr( Operations.getattr):

def query( me, *a):

if me.q.error:

log('parse error:', me.q.error)

return ENOENT

return me.osexec( me.context.archive)

operand = negative = query

class readdir( Operations.readdir):

def operand( me, o):

excl = set( me.q.tree[-1])

names = set([ name for name,op in me._iter_operands() if op not in excl ])

return me.direntries( me.context.query_grammar.values() + list(names))

def negative( me, n):

return me.direntries([ me.context.query_grammar.eval_ ])

def aspect( me):

return me.direntries( [ me.context.query_grammar.not_] + [ name for name, op in me._iter_operands() ])

def query( me):

q = me.q

results = dict()

if q.complete:

results.update( me._get_results())

names = results.keys()

for name,result in results.iteritems():

QAspect.aliases[ os.path.join( q.full_path, name)] = result

else:

# for convenience exclude tags which are already 'or'ed anyway

names = [ n for n,o in me._iter_operands() if o not in me._get_single_ors( q)]

if me.q.last_token != me.context.query_grammar.not_:

names.append( me.context.query_grammar.not_)

log( 'entries:', names)

return me.direntries( names)

def _get_single_ors( me, q):

return set( it.chain( *[ ands for ands in q.tree if len(ands)==1 ] )) # TODO reasoning here?!

class access( Operations.access):

operand = result = negative = query = lambda me, *a: None

class unlink( Operations.unlink):

def result( me, o):

me.q.untag_tree()

class rmdir( Operations.rmdir):

def negative( me, n):

return getattr( me, me.context.get_func_name( n.obj))( n.obj)

class mkdir( Operations.mkdir):

def negative( me, n):

return getattr( me, me.context.get_func_name( n.obj))( n.obj)

class link( Operations.link):

_on_result_change_name = None

def result_result( me, fr, to):

r = None

if not to.id:

if fr.name != to.name:

if me._on_result_change_name is None:

r = ENOSYS

else:

r = me._on_result_change_name( fr, to)

else:

to.id = fr.id

me.q2.tag_tree()

return r

class symlink( Operations.symlink, link):

pass

class rename( Operations.rename):

def _do_rename( me, fr, to, on_change_name):

r = None

if fr.name != to.name:

r = on_change_name( fr, to)

if r is None:

if isinstance( me.q1, QAspect.Parser):

me.q1.untag_tree()

to.id = fr.id

if isinstance( me.q2, QAspect.Parser):

me.q2.tag_tree()

return r

def operand_operand( me, fr, to):

return me._do_rename( fr, to, me._on_operand_change_name)

def result_result( me, fr, to):

''' aspect that wraps other aspects in it's directory and does nothing else'''

@classmethod

def _init( me, aspects):

me._rexp = '^/'+me.dir_name()+'$'

for op_name, op_klas in vars(me).iteritems():

op_klas = getattr( me, op_name, op_klas)

if issubclass( op_klas, (Op1,Op2)):

class new_op_klas( op_klas):

aspects = aspects

new_op_klas.__name__ = op_klas.__name__

setattr( me, op_name, new_op_klas)

getattr = Operations.getattr

access = Operations.access

class readdir( Operations.readdir):

def aspect( me):

return me.direntries([ a.dir_name() for a in me.aspects() ])

class utime( Operations.utime):

def aspect( me):

return me.osexec( me.context.archive, me.times)

class rename( Operations.rename):

not_implemented = EPERM

class symlink( Operations.symlink):

not_implemented = EPERM

class link( Operations.link):