#!/usr/bin/env python2.6

import sys

import logging

import threading

import Queue

from threadpool import ThreadPool

##

# A task, representing a series of linked pairs of callback and error

# handler Concept is similar to twisted, but you need to put all your

# callback on the task before giving it to the Scheduler.  For this

# reason, you shouldnt call the callback/errorback method yourself (or

# at least, don't put it back in the scheduler after that).

class Task(object):

    @staticmethod

    def DefaultCallback(result):

        return result

    @staticmethod

    def DefaultErrorback(error):

        return error

    def __init__(self, func = None, *args, **kwargs):

        super(Task, self).__init__()

        if func:

            def callback(result):

                return func(*args, **kwargs)

            self.AddCallback(callback)

        if errorback == None:

            errorback = self.DefaultErrorback

        # permit chained calls

        return self

class Scheduler(threading.Thread):

    class _SchedulerStop(Exception):

        pass

    def __init__(self, poolSize):

        threading.Thread.__init__(self, name = "Scheduler", target = self.Run)

        self.pool = ThreadPool(poolSize)

        self.tasks = Queue.Queue()

    def ExecuteOne(self, blocking = True):

        logging.debug("Looking for next task...")

        try:

            task = self.tasks.get(blocking)

        except Queue.Empty:

            logging.debug("No task to run")

    def Run(self):

        logging.info("Scheduler start")

        while True:

            try:

                self.ExecuteOne()

            except self._SchedulerStop:

                break

            except:

                logging.exception("Unhandled task exception")

        logging.info("Scheduler stop")

    def Start(self):

        self.pool.Start()

        return self.start()

    def Stop(self, now = False):

        self.pool.Stop(now)

        if now:

            self.tasks = Queue.Queue()

        def RaiseSchedulerStop():

            raise self._SchedulerStop

        self.AddTask(Task(RaiseSchedulerStop))

        self.join()

    def AddTask(self, task, blocking = True):

        self.tasks.put(task, blocking)

            try:

            except:

                errtype, error, traceback = sys.exc_info()

                    raise error, None, traceback

            jobTask.ChainTask(task)

            self.AddTask(jobTask)

        self.pool.AddJob(Job)

# The global scheduler

scheduler = None

def StartScheduler(size):

    global scheduler

    if scheduler:

        StopScheduler()

    scheduler = Scheduler(size)

    scheduler.Start()

def StopScheduler(now = False):

    global scheduler

    if scheduler:

        scheduler.Stop(now)

    scheduler = None

if __name__ == '__main__':

    from time import sleep

    logging.getLogger().setLevel(logging.INFO)

    # This function is a sample and shouldn't know about the scheduler

    count = 0

    def AsyncCall(name, seconds):

        global count

        count += 1

        def Initialize(name, seconds):

            print "Here", name

            return name, seconds

        def Blocking(args):

            name, time = args

            print name, "goes to bed"

            sleep(time)

            print name, ": ZZZ..."

            return name

        def Finalize(name):

            global count

            print name, "wakes up!"

            count -= 1

    logging.info("Starting scheduler with 10 workers")

    StartScheduler(10)

    logging.info("Adding asynccall task")

    for x in xrange(int(sys.argv[1])):

    while count > 0:

        logging.debug("Count = %d", count)

        sleep(1)

    logging.info("Stopping scheduler")

    StopScheduler()

    logging.info("The End.")