Ejemplos de Default.connect en Python

Ejemplo n.º 1

Archivo: test_wb_output_mqtt.py Proyecto: smetj/experiments

from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wishbone.module import Header
from wishbone.module import TestEvent
from wishbone.module import Fanout

from wb_output_mqtt import MQTT
from gevent import sleep, spawn

# Initialize router
router = Default(interval=1, rescue=False, uuid=False)

# organize eventstream
router.registerMetricModule(Null, "null")

# organize logstream
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

router.register(TestEvent, "testevent", interval=0)
router.register(Header, "header", header={"mqtt": {"topic": "my/topic"}})
router.register(MQTT, "mqtt", client_id="blah", host="127.0.0.1")

router.connect("testevent.outbox", "header.inbox")
router.connect("header.outbox", "mqtt.inbox")

# start
router.start()
router.block()

Ejemplo n.º 2

Archivo: test_wb_input_udp.py Proyecto: smetj/experiments

from wishbone.router import Default
from wishbone.tools import Measure

from wishbone.module import Graphite
from wishbone.module import Null
from wishbone.module import LogFormatFilter
from wishbone.module import STDOUT
from wb_input_udp import UDP

from gevent import sleep, spawn

# Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=True)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

# Consume events to STDOUT
router.register((UDP, "udp", 0))
router.register((STDOUT, "stdout_events", 0))


router.connect("udp.outbox", "stdout_events.inbox")

# start
router.start()
router.block()

Ejemplo n.º 3

Archivo: minimal.py Proyecto: bugcy013/experiments

        Actor.__init__(self, name)
        self.createQueue("inbox")
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(0.5)


# gevent_profiler.set_stats_output('my-stats.txt')
# gevent_profiler.set_summary_output('my-summary.txt')
# gevent_profiler.set_trace_output('my-trace.txt')

# gevent_profiler.attach()

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule(STDOUT, "logs_out")
router.registerMetricModule(STDOUT, "metrics_out")

router.register(Input, "input")
router.register(Output, "output")

router.connect("input.outbox", "output.inbox")

#start
router.start()
router.block()

# gevent_profiler.detach()

Ejemplo n.º 4

Archivo: test_wb_minimal.py Proyecto: smetj/experiments

        self.createQueue("outbox")
        spawn(self.generate)

    def generate(self):
        context_switch_loop = self.getContextSwitcher(100, self.loop)
        while context_switch_loop.do():
            try:
                self.queuepool.outbox.put({"header": {}, "data": "X"})
            except:
                break


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(STDOUT, "stdout")

#Organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register(XGenerator, "xgenerator")
router.register(Null, "null")
router.connect("xgenerator.outbox", "null.inbox")

#start
router.start()
router.block()

Ejemplo n.º 5

Archivo: test_wb_minimal.py Proyecto: bugcy013/experiments

    def __init__(self, name, size=1):
        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("inbox", size)
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(5)

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout")
router.connect("loglevelfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule(Null, "null")

#Organize data flow
router.register(Input, "input")
router.register(Forwarder, "forwarder")
router.register(Output, "output")

router.connect("input.outbox", "forwarder.inbox")
router.connect("forwarder.outbox", "output.inbox")

#start
router.start()
router.block()

Ejemplo n.º 6

Archivo: funnel_test.py Proyecto: bugcy013/experiments

                if looper == 100:
                    looper=0
                    sleep()
                self.queuepool.outbox.put({"header":{},"data":str(x)})
                x+=1
                looper+=1
            except:
                break


router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")

router.register((STDOUT, "stdout_logs", 0))
router.register((STDOUT, "stdout", 0))
router.register((NumberGenerator, "numbergenerator1", 0))
router.register((NumberGenerator, "numbergenerator2", 0))
router.register((Funnel, "funnel", 0))

#logs & metrics
router.connect("logformatfilter.outbox", "stdout_logs.inbox")

#events
router.connect("numbergenerator1.outbox", "funnel.one")
router.connect("numbergenerator2.outbox", "funnel.two")
router.connect("funnel.outbox", "stdout.inbox")

#start
router.start()
router.block()

Ejemplo n.º 7

Archivo: funnel_test.py Proyecto: smetj/experiments

                    sleep()
                self.queuepool.outbox.put({"header": {}, "data": str(x)})
                x += 1
                looper += 1
            except:
                break


router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")

router.register((STDOUT, "stdout_logs", 0))
router.register((STDOUT, "stdout", 0))
router.register((NumberGenerator, "numbergenerator1", 0))
router.register((NumberGenerator, "numbergenerator2", 0))
router.register((Funnel, "funnel", 0))

#logs & metrics
router.connect("logformatfilter.outbox", "stdout_logs.inbox")

#events
router.connect("numbergenerator1.outbox", "funnel.one")
router.connect("numbergenerator2.outbox", "funnel.two")
router.connect("funnel.outbox", "stdout.inbox")

#start
router.start()
router.block()

Ejemplo n.º 8

Archivo: test_wb_output_udp.py Proyecto: smetj/experiments

from wishbone import Actor
from wishbone.router import Default

from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wishbone.module import Header
from wishbone.module import TestEvent

from wb_output_udp import UDP
from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#organize eventstream
router.registerMetricModule(Null, "null")

#organize logstream
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

router.register(TestEvent, "testevent")
router.register(UDP, "udp", host="localhost")

router.connect("testevent.outbox", "udp.inbox")

#start
router.start()
router.block()

Ejemplo n.º 9

from wishbone.module import Graphite
from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wb_input_dictgenerator import DictGenerator
from wb_output_tcp import TCP

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(LogLevelFilter, "filter")
router.register(STDOUT, "stdout")
router.connect("filter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize event flow
router.register(DictGenerator, "dictgenerator", max_elements=10)
router.register(STDOUT, "stdout_events")
router.register(Null, "null_events")
router.connect("dictgenerator.outbox", "null_events.inbox")


#start
router.start()

Ejemplo n.º 10

from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wb_input_dictgenerator import DictGenerator
from wb_output_tcp import TCP

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
# router.registerLogModule(LogLevelFilter, "filter")
# router.register(STDOUT, "stdout")
# router.connect("filter.outbox", "stdout.inbox")

#Organize metric flow
# router.registerMetricModule(Graphite, "graphite")
# router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
# router.connect("graphite.outbox", "graphite_out.inbox")

#Organize event flow
router.register(DictGenerator, "dictgenerator", max_elements=10)
router.register(STDOUT, "stdout_events")
router.connect("dictgenerator.outbox", "stdout_events.inbox")


#start
router.start()
router.block()

Ejemplo n.º 11

Archivo: broker_test.py Proyecto: smetj/experiments

                self.queuepool.outbox.put(
                    {"header": {"broker_exchange": "", "broker_key": "test", "broker_tag": "test"}, "data": str(x)}
                )
                x += 1
                looper += 1
            except:
                break


# Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

# Feedback loop
router.register((Header, "header", 0), header={"broker_exchange": "", "broker_key": "test", "broker_tag": "test"})
router.register((AMQP, "broker", 0), host="sandbox", consume_queue="test")
router.connect("broker.inbox", "header.inbox")
router.connect("header.outbox", "broker.outbox")

# Produce events
# router.register((NumberGenerator, "numbergenerator", 0))
# router.register((Header, "header", 0), header={'broker_exchange':"", 'broker_key':"test", 'broker_tag':"test"})
# router.register((AMQP, "broker", 0), host="sandbox")
# router.connect("numbergenerator.outbox", "header.inbox")
# router.connect("header.outbox", "broker.outbox")

Ejemplo n.º 12

Archivo: test_wb_minimal.py Proyecto: smetj/experiments

        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("inbox", size)
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(5)


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout")
router.connect("loglevelfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule(Null, "null")

#Organize data flow
router.register(Input, "input")
router.register(Forwarder, "forwarder")
router.register(Output, "output")

router.connect("input.outbox", "forwarder.inbox")
router.connect("forwarder.outbox", "output.inbox")

#start
router.start()
router.block()

Ejemplo n.º 13

Archivo: test_wb_function_jsonconversion.py Proyecto: bugcy013/experiments

from wishbone.module import Graphite
from wishbone.module import Null
from wishbone.module import LogFormatFilter
from wishbone.module import STDOUT
from wb_input_namedpipe import NamedPipe
from wb_function_json import JSON

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=True)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

#Consume events to STDOUT
router.register((NamedPipe, "namedpipe", 0))
router.register((JSON, "jsonconversion", 0), mode="decode", schema="/tmp/schema.example")
router.register((STDOUT, "stdout_events", 0))


router.connect("namedpipe.outbox", "jsonconversion.inbox")
router.connect("jsonconversion.outbox", "stdout_events.inbox")

#start
router.start()
router.block()

Ejemplo n.º 14

Archivo: fanout_test.py Proyecto: smetj/experiments

                looper += 1
            except:
                break


router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")

router.register((STDOUT, "stdout", 0))
router.register((NumberGenerator, "numbergenerator", 0))

router.register((Fanout, "fanout", 0), clone=True)
router.register((STDOUT, "stdout1", 0), counter=False, complete=False)
router.register((STDOUT, "stdout2", 0), counter=True, complete=True)
router.register((STDOUT, "stdout3", 0), counter=True, complete=True)

#logs & metrics
router.connect("logformatfilter.outbox", "stdout.inbox")

#events
router.connect("numbergenerator.outbox", "fanout.inbox")
router.connect("fanout.one", "stdout1.inbox")
router.connect("fanout.two", "stdout2.inbox")
router.connect("fanout.three", "stdout3.inbox")

#start
router.start()
router.block()

Ejemplo n.º 15

from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wb_input_dictgenerator import DictGenerator
from wb_output_tcp import TCP
from wb_output_mongodb import MongoDB

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, context_switch=100, rescue=False, uuid=False)

#organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

#organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP,
                'graphite_out',
                host="graphite-001",
                port=2013,
                stream=True)
router.connect("graphite.outbox", "graphite_out.inbox")

#organize event flow
router.register(DictGenerator, "dictgenerator", max_elements=10, sleep=1)
router.register(MongoDB, "mongodb", host="sandbox", capped=True, drop_db=False)
router.connect("dictgenerator.outbox", "mongodb.inbox")

Ejemplo n.º 16

Archivo: test_wb_wait_seconds.py Proyecto: bugcy013/experiments

        context_switch_loop = self.getContextSwitcher(75, self.loop)

        while context_switch_loop.do():
            try:
                self.queuepool.outbox.put({"header":{},"data":"X"})
            except QueueFull:
                sleeping = (self.queuepool.outbox.stats()["out_rate"])+0.1
                self.logging.info("Oops queue full waiting for %s seconds."%(sleeping))
                sleep(sleeping)

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=False)
router.register((STDOUT, "stdout", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((TCP, 'graphite_out', 0), host="graphite-001", port=2013, stream=True )
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register((XGenerator, "xgenerator", 0))
router.register((WaitSeconds, "waitseconds", 0), seconds=0.5, max_size=10)
router.connect("xgenerator.outbox", "waitseconds.inbox")

#start
router.start()
router.block()

Ejemplo n.º 17

Archivo: fanout_test.py Proyecto: bugcy013/experiments

                self.queuepool.outbox.put({"header":{},"data":str(x)})
                x+=1
                looper+=1
            except:
                break


router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")

router.register((STDOUT, "stdout", 0))
router.register((NumberGenerator, "numbergenerator", 0))

router.register((Fanout, "fanout", 0), clone=True)
router.register((STDOUT, "stdout1", 0), counter=False, complete=False)
router.register((STDOUT, "stdout2", 0), counter=True, complete=True)
router.register((STDOUT, "stdout3", 0), counter=True, complete=True)

#logs & metrics
router.connect("logformatfilter.outbox", "stdout.inbox")

#events
router.connect("numbergenerator.outbox", "fanout.inbox")
router.connect("fanout.one", "stdout1.inbox")
router.connect("fanout.two", "stdout2.inbox")
router.connect("fanout.three", "stdout3.inbox")

#start
router.start()
router.block()

Ejemplo n.º 18

Archivo: test_wb_output_mqtt.py Proyecto: smetj/experiments

from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wishbone.module import Header
from wishbone.module import TestEvent
from wishbone.module import Fanout

from wb_output_mqtt import MQTT
from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#organize eventstream
router.registerMetricModule(Null, "null")

#organize logstream
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

router.register(TestEvent, "testevent", interval=0)
router.register(Header, "header", header={"mqtt": {"topic": "my/topic"}})
router.register(MQTT, "mqtt", client_id="blah", host="127.0.0.1")

router.connect("testevent.outbox", "header.inbox")
router.connect("header.outbox", "mqtt.inbox")

#start
router.start()
router.block()

Ejemplo n.º 19

Archivo: test_wb_output_mongodb.py Proyecto: bugcy013/experiments

from wishbone.module import Graphite
from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wb_input_dictgenerator import DictGenerator
from wb_output_tcp import TCP
from wb_output_mongodb import MongoDB

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, context_switch=100, rescue=False, uuid=False)

#organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

#organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013, stream=True )
router.connect("graphite.outbox", "graphite_out.inbox")

#organize event flow
router.register(DictGenerator, "dictgenerator", max_elements=10, sleep=1)
router.register(MongoDB, "mongodb", host="sandbox", capped=True, drop_db=False)
router.connect("dictgenerator.outbox", "mongodb.inbox")

#start
router.start()
router.block()

Ejemplo n.º 20

Archivo: test_wb_minimal_thread.py Proyecto: smetj/experiments

    def run(self):
        while self.loop():
            try:
                self.queuepool.outbox.put({"header": {}, "data": "X"})
            except:
                self.queuepool.outbox.waitUntilPutAllowed()


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule((Filter, "logformatfilter", 0))
router.register((STDOUT, "stdout", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule((Graphite, "graphite", 0))
router.register((TCP, 'graphite_out', 0),
                host="graphite-001",
                port=2013,
                stream=True)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register((XGenerator, "xgenerator", 0))
router.register((Null, "null", 0))
router.register((STDOUT, "events_stdout", 0))
router.connect("xgenerator.outbox", "null.inbox")

Ejemplo n.º 21

Archivo: test_wb_minimal.py Proyecto: bugcy013/experiments

        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("outbox")
        spawn(self.generate)

    def generate(self):
        context_switch_loop = self.getContextSwitcher(100, self.loop)
        while context_switch_loop.do():
            try:
                self.queuepool.outbox.put({"header":{},"data":"X"})
            except:
                break

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(STDOUT, "stdout")

#Organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register(XGenerator, "xgenerator")
router.register(Null, "null")
router.connect("xgenerator.outbox", "null.inbox")

#start
router.start()
router.block()

Ejemplo n.º 22

from wishbone.router import Default
from wishbone.tools import Measure

from wishbone.module import Graphite
from wishbone.module import Null
from wishbone.module import LogFormatFilter
from wishbone.module import STDOUT
from wb_input_udp import UDP

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=True)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

#Consume events to STDOUT
router.register((UDP, "udp", 0))
router.register((STDOUT, "stdout_events", 0))

router.connect("udp.outbox", "stdout_events.inbox")

#start
router.start()
router.block()

Ejemplo n.º 23

        Actor.__init__(self, name)
        self.createQueue("inbox")
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(0.5)


# gevent_profiler.set_stats_output('my-stats.txt')
# gevent_profiler.set_summary_output('my-summary.txt')
# gevent_profiler.set_trace_output('my-trace.txt')

# gevent_profiler.attach()

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule(STDOUT, "logs_out")
router.registerMetricModule(STDOUT, "metrics_out")

router.register(Input, "input")
router.register(Output, "output")

router.connect("input.outbox", "output.inbox")

#start
router.start()
router.block()

# gevent_profiler.detach()

Ejemplo n.º 24

Archivo: broker_test.py Proyecto: smetj/experiments

                })
                x += 1
                looper += 1
            except:
                break


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

#Feedback loop
router.register((Header, "header", 0),
                header={
                    'broker_exchange': "",
                    'broker_key': "test",
                    'broker_tag': "test"
                })
router.register((AMQP, "broker", 0), host="sandbox", consume_queue="test")
router.connect("broker.inbox", "header.inbox")
router.connect("header.outbox", "broker.outbox")

#Produce events
# router.register((NumberGenerator, "numbergenerator", 0))

Ejemplo n.º 25

from wishbone.module import LogFormatFilter
from wishbone.module import STDOUT
from wb_input_namedpipe import NamedPipe
from wb_function_json import JSON

from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=True)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

#Consume events to STDOUT
router.register((NamedPipe, "namedpipe", 0))
router.register((JSON, "jsonconversion", 0),
                mode="decode",
                schema="/tmp/schema.example")
router.register((STDOUT, "stdout_events", 0))

router.connect("namedpipe.outbox", "jsonconversion.inbox")
router.connect("jsonconversion.outbox", "stdout_events.inbox")

#start
router.start()
router.block()