Maximum CD 2011 February/maximum-cd-2011-02.iso/DiscContents/digsby_setup85.exe/lib/util/command_queue.pyo

Python Compiled Bytecode | 2010-11-24 | 6.6 KB | 274 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

from util import Timer, threaded
from util.primitives.funcs import do
from Queue import Queue
from threading import RLock
from functools import wraps
from util import callsback, callany
from Queue import Empty
import logging
log = logging.getLogger('cmdq')

class SerialCommandQueue(object):

    def __init__(self, start_hooks = None, end_hooks = None, retry_time = 2):
        self.start_hooks = start_hooks
        self.end_hooks = end_hooks
        self.retry_time = retry_time
        self.do_queue = Queue()
        self.state_lock = RLock()
        self.loop_running = False


    def add_new(self, .1):
        (func, instance, a, k) = .1
        self.state_lock.__enter__()

        try:
            self.do_queue.put((func, instance, a, k))
            if not self.loop_running:
                self.loop_running = True
                self.flush()
        finally:
            pass



    def flush(self):

        try:
            do((lambda .0: for f in .0:
f())(self.start_hooks))
        except Exception:
            e = None
            import traceback
            traceback.print_exc()
            self.state_lock.__enter__()

            try:
                self.do_queue = Queue()
                self.loop_running = False
                return None
            finally:
                pass

        except:
            self.state_lock.__exit__

        self.state_lock.acquire()
        while True:

            try:
                (func, instance, a, k) = self.do_queue.get(False)
            except Empty:
                self.state_lock.__exit__
                self.state_lock.__exit__
                self.state_lock
                break
                continue

            self.state_lock.release()
            func(instance, *a, **k)
            self.state_lock.acquire()
            continue
            self.state_lock.__exit__
        self.state_lock.release()
        do((lambda .0: for f in .0:
f())(self.end_hooks))
        self.state_lock.__enter__()

        try:
            if self.do_queue.empty():
                self.loop_running = False
            else:
                self.flush()
        finally:
            pass


    flush = threaded(flush)


class CommandQueue(object):

    def __init__(self, start_hooks, end_hooks, shutdown_interval = 30, retry_time = 2):
        self.start_hooks = start_hooks
        self.end_hooks = end_hooks
        self.shutdown_interval = shutdown_interval
        self.retry_time = retry_time
        self.do_queue = Queue()
        self.state_lock = RLock()
        self.timer = Timer(shutdown_interval, self.finish)
        self.loop_running = False
        self.initialized = False
        self.initializing = False
        self.shutting_down = False
        self.timer_valid = False


    def add_new(self, .1):
        (func, instance, a, k) = .1
        self.state_lock.__enter__()

        try:
            self.timer_valid = False
            self.timer.cancel()
            self.do_queue.put((func, instance, a, k))
            if not self.loop_running:
                self.loop_running = True
                if self.initialized:
                    self.flush()
                elif not self.initializing:
                    self.initializing = True
                    threaded(self.initialize)()

        finally:
            pass



    def initialize(self):
        self.state_lock.__enter__()

        try:
            if self.shutting_down:
                t = Timer(self.retry_time, threaded(self.initialize))
                t.start()
                return None
        finally:
            pass


        try:
            do((lambda .0: for f in .0:
f())(self.start_hooks))
        except Exception:
            self.state_lock.__exit__
            e = self.state_lock.__exit__
            self.state_lock
            import traceback
            traceback.print_exc()
            self.state_lock.__enter__()

            try:
                self.do_queue = Queue()
                self.loop_running = False
                self.initialized = False
                self.initializing = False
                return None
            finally:
                pass

        except:
            self.state_lock.__exit__

        self.state_lock.__enter__()

        try:
            self.initialized = True
            self.initializing = False
        finally:
            pass

        self.flush()


    def flush(self):
        self.state_lock.acquire()
        while True:
            self.state_lock.release()

            try:
                (func, instance, a, k) = self.do_queue.get(False)
            except Empty:
                break
            else:
                func(instance, *a, **k)
            finally:
                self.state_lock.acquire()

        self.loop_running = False
        self.timer_valid = True
        self.timer.start()
        self.state_lock.release()

    flush = threaded(flush)

    def finish(self):
        self.state_lock.__enter__()

        try:
            if not self.timer_valid:
                return None
            self.initialized = False
            self.shutting_down = True
        finally:
            pass

        do((lambda .0: for f in .0:
f())(self.end_hooks))
        self.state_lock.__enter__()

        try:
            self.shutting_down = False
        finally:
            pass


    finish = threaded(finish)


def cmdqueue(qname = 'cmdq'):

    def wrapper2(func):

        def wrapper1(instance, *args, **kws):
            cmdq = getattr(instance, qname)
            cmdq.add_new((func, instance, args, kws))

        return wrapper1

    return wrapper2


def callback_cmdqueue(qname = 'cmdq'):

    def wrapper2(func):

        def wrapper(instance, callback = (callsback, None), *args, **kws):
            requestID = kws.pop('requestID', None)
            cmdq = getattr(instance, qname)

            def do_thing(*a, **k):

                try:
                    result = func(instance, *args, **kws)
                    exception = None
                except Exception:
                    e = None
                    exception = e
                    result = None
                    import traceback
                    import sys
                    sys.stderr.write('The following exception occurred in callback_cmdqueue:\n')
                    traceback.print_exc()

                if exception:
                    callany(callback.error, e)
                else:
                    callany(callback.success, result)

            cmdq.add_new((do_thing, None, (), { }))

        wrapper = None(wraps(func)(wrapper))
        return wrapper

    return wrapper2

__all__ = [
    'callback_cmdqueue',
    'cmdqueue',
    'CommandQueue']