def _clock():
    "call all events scheduled before now, maybe recurr in the future"
    now = time.time()
    future = now + precision
    while _scheduled:
        # get the next defered ...
        event = heapq.heappop(_scheduled)
        if event[0] > now:
            heapq.heappush(_scheduled, event)
            break  # ... nothing to defer now.

        try:
            # ... do defer and ...
            continued = event[1](event[0])
        except Exit:
            raise

        except:
            loginfo.traceback()
        else:
            if continued != None:
                # ... maybe recurr in the future
                if continued[0] < future:
                    continued = (future, continued[1])
                heapq.heappush(_scheduled, continued)
def _clock ():
	"call all events scheduled before now, maybe recurr in the future"
	now = time.time ()
        future = now + precision
	while _scheduled:
		# get the next defered ...
		event = heapq.heappop (_scheduled)
		if event[0] > now:
			heapq.heappush (_scheduled, event)
			break  # ... nothing to defer now.

		try:
			# ... do defer and ...
			continued = event[1] (event[0])
                except Exit:
                        raise
                
		except:
			loginfo.traceback ()
		else:
			if continued != None:
                                # ... maybe recurr in the future
                                if continued[0] < future:
                                        continued = (future, continued[1])
				heapq.heappush (_scheduled, continued) 
def dispatch ():
        "dispatch I/O, time and finalization events"
        assert None == loginfo.log ('async_dispatch_start', 'debug')
        while _dispatched or _scheduled or _finalized or gc.collect () > 0:
                try:
                        _io (_dispatched, precision, concurrency)
                        _clock ()
                        _finalize ()
                except Exit:
                        if not _catched ():
                                break
                
                except:
                        loginfo.traceback ()
        
        assert None == loginfo.log ('async_dispatch_stop', 'debug')
def dispatch():
    "dispatch I/O, time and finalization events"
    assert None == loginfo.log('async_dispatch_start', 'debug')
    while _dispatched or _scheduled or _finalized or gc.collect() > 0:
        try:
            _io(_dispatched, precision, concurrency)
            _clock()
            _finalize()
        except Exit:
            if not _catched():
                break

        except:
            loginfo.traceback()

    assert None == loginfo.log('async_dispatch_stop', 'debug')
def _finalize():
    "call all finalizations queued"
    while True:
        try:
            finalized = _finalized.popleft()
        except IndexError:
            break

        try:
            finalized.finalization = finalized.finalization(
                finalized)  # finalize and maybe continue ...
        except Exit:
            finalized.finalization = None
            raise

        except:
            finalized.finalization = None
            loginfo.traceback()  # log exception
Example #6
0
import sys
from allegra import loginfo

loginfo.log ('message')
loginfo.log ('message', 'info')
try:
        foobar
except:
        ctb = loginfo.traceback ()

logged = loginfo.Loginfo ()
logged.log ('message')
logged.log ('message', 'info')

loginfo.toggle ()
logged.log ('message')

logged.loginfo_toggle ()
logged.log ('message')

logged.loginfo_toggle ()
try:
        foobar
except:
        ctb = logged.loginfo_traceback ()

loginfo.toggle ()
logged.loginfo_logger = loginfo.Loginfo ()
logged.log ('message')
logged.log ('message', 'info')
Example #7
0
"http://laurentszyster.be/blog/ansqlite/"

import sys, time

from allegra import (netstring, loginfo, async_loop, finalization, ip_peer,
                     tcp_client, ansqlite)

loads = ansqlite.loads
dumps = ansqlite.dumps
try:
    statements = netstring.netpipe(lambda r=sys.stdin.read: r(4096))
    addr = ip_peer.addr(sys.argv[1], 3999)
    clients = int(sys.argv[2])
except:
    loginfo.traceback()
    sys.exit(1)


class Dispatcher(ansqlite.Client):

    statements_count = 0

    def callback(self, resultset):
        assert None == loginfo.log('%r' % resultset)
        try:
            stmt, param = loads(statements.next())
        except StopIteration:
            self.handle_close()
        except:
            self.loginfo_traceback()
Example #8
0
from allegra import (
        netstring, loginfo, async_loop, finalization, 
        ip_peer, tcp_client, ansqlite
        )

loads = ansqlite.loads
dumps = ansqlite.dumps
try:
        statements = netstring.netpipe (
                lambda r=sys.stdin.read: r (4096)
                )
        addr = ip_peer.addr (sys.argv[1], 3999)
        clients = int (sys.argv[2])
except:
        loginfo.traceback ()
        sys.exit (1)

class Dispatcher (ansqlite.Client):

        statements_count = 0

        def callback (self, resultset):
                assert None == loginfo.log ('%r' % resultset)
                try:
                        stmt, param = loads (statements.next ())
                except StopIteration:
                        self.handle_close ()
                except:
                        self.loginfo_traceback ()
                else: