root/trac/hacks/marketplugin/0.9/tracmarket/ctl.py

import os
import sys
import time
import types
import urllib

from trac.core import *

from tracmarket.api import *
from tracmarket.mq import *
from tracmarket.response import Response 

SequenceType = (types.ListType, types.TupleType, types.GeneratorType)

# XXX deprecate this file, move Context to context.py

class Controller(Component):
    implements(IMessageBusSubscriber, IMarketController)

    interpreters = ExtensionPoint(ICommandInterpreter)
    models = ExtensionPoint(IMessageBusSubscriber)
    ledgers = ExtensionPoint(ILedger)

    # IMessageBusSubscriber methods

    def solicit(self, bus):
        bus.subscribe('market.cmd', reader=self._route_cmd)

    def _route_cmd(self, bus, group, msg):
        '''route all incoming commands to a per-symbol group'''
        cmd = msg.data
        tokens = cmd.strip().split()
        symbol = tokens.pop(0)
        if tokens:
            verb = tokens.pop(0)
        else:
            verb = 'show'
        args = tokens
        msg = Msg(cmd, verb=verb, args=args)
        group = 'market.cmd.%s' % (symbol)
        bus.send(group, msg)

    # IMarketController methods  XXX these should probably just move
    # to UI, deprecate IMarketController

    def open(self, req=None, bus=None, db=None):
        if not db:
            db = self.env.get_db_cnx()
        ledger = iter(self.ledgers).next()
        ctx = Context(env=self.env, req=req, db=db, ledger=ledger)
        if not bus:
            bus = MemoryBus(subscribers=self.models, ctx=ctx)
        # XXX circ ref bus <-> ctx
        ctx.mkres(bus=bus) 
        return bus

    def run(bus, cmds):
        '''Return a generator which sends commands to bus and yields
        the resulting message stream.  Cmds is a list of command
        strings.'''

        '''
        # execute cmd
        id = bus.subscribe(re.compile('.*'))
        msg = Msg(cmd)
        bus.send('market.cmd', msg)
        while True:
            msg = bus.recv(id)
            if not msg:
                break
            req.hdf[msg.group] = msg.data
        '''

    def commit(self, bus):
        bus.ctx.db.commit()

    def rollback(self, bus):
        bus.ctx.db.rollback()

    def run_cmd(self, req, cmd):
        bus = self.open(req)
        bus.subscribe('res.', reader=self._recv_res)
        ctx = bus.ctx
        '''
        results = self.run(bus, [cmd])
        for msg in results:
            if not msg.group.startswith('message.'):
                # XXX let ctx.res accumulate for now
                continue
            XXX
        self.close(bus)
        '''
        db = ctx.db
        try:
            self.xeq(ctx, db, cmd)
        except InsufficientFunds, e:
            db.rollback()
            ctx.res.error(str(e))
        except:
            db.rollback()
            raise
        else:
            db.commit()
        return ctx

    # internal

    def _recv_res(self, bus, group, msg):
        pass

    def xeq(self, ctx, db, cmd):
        req = ctx.req
        db = ctx.db
        messages = None
        hit = False
        for interpreter in self.interpreters:
            cmx = interpreter.parse_cmd(ctx, cmd)
            if cmx:
                hit = True
                cmx()
                break
        if not hit:
            raise TracError, "Unrecognized command: %s" % cmd
    

class Context(object):
    '''A place to hold per-query context, since we shouldn't store
    transients in the specialist Component instance.'''

    def __init__(self, env, req, ledger, res=None, db=None):
        self.env = env
        self.req = req
        self.ledger = ledger
        self.res = res
        self.db = db

    def mkres(self, bus):
        self.res = Response(bus=bus, path='')

    def Mock(cls, **kwargs):
        d = dict(
                env = None,
                req = None,
                ledger = None,
            )
        d.update(kwargs)
        return cls(**d)
    Mock = classmethod(Mock)