test_circuit

#!/usr/bin/python -i


from concurrent import futures

import logging
import time
from os import getpid
import datetime
from circuits import Component, Event, Debugger, handler, task, Worker
from circuits.web import Server, Logger, JSONController

import json

_ONE_DAY_IN_SECONDS = 60 * 60 * 24


# Logging
logging.basicConfig(
    format='%(asctime)s %(name)s %(levelname)s %(process)d %(thread)d %(funcName)s() %(threadName)s %(message)s',
    datefmt='%m/%d/%Y %I:%M:%S %p'
)
logger = logging.getLogger("test")
logger.setLevel(logging.DEBUG)



def date():
    logger.info("IN")
    for n in range(1, 20):
        logger.info(n)
        logger.info(datetime.datetime.now())
        time.sleep(1)
    return n

class work(Event):
    """

    """

class App(Component):

    _worker = None

    def init(self):
        Server(('0.0.0.0', 11111)).register(self)
        Logger().register(self)
        Debugger().register(self)
        self._worker = Worker().register(self)
        DeployableJSONController().register(self)
        VirtualHostJSONController().register(self)


class DeployableJSONController(JSONController):

    channel = "/deployable"

    _worker = None

    #def init(self):
    #    self._worker = Worker().register(self)

    @handler("work")
    def work(self, data):
        logger.info("IN")
        json_data = json.loads(data)

        logger.info(data)
        logger.info("########################### start processing {n}".format(n=getpid()))

        n = yield self.call(task(date), self._worker)
        logger.info(n.value)

        logger.info(
            json.dumps(
                json_data,
                sort_keys=True,
                indent=4,
                separators=(',', ': ')
            )
        )

    def GET(self, *args, **kwargs):
        return {
            "data": "GET({0:s}, {1:s})".format(repr(args), repr(kwargs))
        }

    def POST(self, *args, **kwargs):

        data = str(self.request.body.read().decode())
        
        x = yield self.call(task(date), self._worker)
        logger(x.value)

        #self.fire(work(data), "/deployable")

        return {
            "yoda": "To the hand you talk, because listening i'm not.",
            "pid": getpid()
        }

    def PUT(self, *args, **kwargs):
        return {
            "data": "PUT({0:s}, {1:s})".format(repr(args), repr(kwargs))
        }

    def DELETE(self, *args, **kwargs):
        return {
            "data": "DELETE({0:s}, {1:s})".format(repr(args), repr(kwargs))
        }

    def HEAD(self, *args, **kwargs):
        return {
            "data": "HEAD({0:s}, {1:s})".format(repr(args), repr(kwargs))
        }


class VirtualHostJSONController(JSONController):

    channel = "/virtualhost"

    def GET(self, *args, **kwargs):
        return "GET({0:s}, {1:s})".format(repr(args), repr(kwargs))

    def POST(self, *args, **kwargs):
        return "POST({0:s}, {1:s})".format(repr(args), repr(kwargs))

    def PUT(self, *args, **kwargs):
        return "PUT({0:s}, {1:s})".format(repr(args), repr(kwargs))

    def DELETE(self, *args, **kwargs):
        return "DELETE({0:s}, {1:s})".format(repr(args), repr(kwargs))

    def HEAD(self, *args, **kwargs):
        return "HEAD({0:s}, {1:s})".format(repr(args), repr(kwargs))

if __name__ == "__main__":

    app = App()
    app.run()

    #try:
    #    while True:
    #        time.sleep(_ONE_DAY_IN_SECONDS)
    #except KeyboardInterrupt:
    #    app.stop(0)