Python Default.register Beispiele

Beispiel #1

Datei: test_wb_input_gearman.py Projekt: smetj/experiments

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_tcp import TCP
from wb_input_gearman import Gearman

#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(
    (Gearman, "gearman", 0),
    hostlist=["besrvuc-nag02:4730"],
    queue="perfdata",
    workers=10,
    secret="Aloh9uibshojeF8oAhyo3eefGu5ohr3iDeek4ehamaM9eisoas6OoveiareQuo0i")
router.register((STDOUT, "stdout_events", 0))

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

Beispiel #2

Datei: test_wb_output_mqtt.py Projekt: 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()

Beispiel #3

Datei: test_wb_input_udp.py Projekt: 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()

Beispiel #4

Datei: test_wb_wait_seconds.py Projekt: 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()

Beispiel #5

        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()

Beispiel #6

Datei: test_wb_input_tcp.py Projekt: bugcy013/experiments

from wishbone import Actor
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_tcp import TCP

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((TCP, "tcp", 0))
router.register((STDOUT, "stdout_events", 0))


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

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

Beispiel #7

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

    def consume(self, event):
        pass
        #self.logging.info("Received event.")
        #sleep(0.005)


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

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

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

#Organize data flow
router.register(AMQP,
                "amqp",
                host="localhost",
                queue="test",
                prefetch_count=100,
                no_ack=True)

Beispiel #8

Datei: minimal.py Projekt: 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()

Beispiel #9

Datei: test_wb_output_amqp.py Projekt: bugcy013/experiments

from wb_output_amqp import AMQP
from wb_output_tcp import TCP

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

#organize metricstream
router.registerMetricModule(Null, "null")
#router.registerMetricModule(Graphite, "graphite")
#router.register(TCP, "graphite_transport", host="graphite-001", port=2013)
#router.connect("graphite.outbox", "graphite_transport.inbox")

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

#router.register(TestEvent, "testevent", interval=1)
router.register(TestEvent, "testevent", interval=0.5)
router.register(Header, "header", key="amqp", header={'broker_exchange':"", 'broker_key':"test", 'broker_tag':"test"})
router.register(STDOUT, "stdout", complete=True)
router.register(AMQP, "amqp", host="rabbitmq", )

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

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

Beispiel #10

Datei: test_wb_input_generator.py Projekt: bugcy013/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_generator import Generator

from gevent import sleep, spawn

#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")

#Consume events to Null
router.register((Generator, "generator", 0))
router.register((STDOUT, "stdout_events", 0))
#router.register((Null, "null", 0))


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

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

Beispiel #11

Datei: test_wb_function_jsonconversion.py Projekt: bugcy013/experiments

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_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()

Beispiel #12

Datei: test_wb_minimal.py Projekt: 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()

Beispiel #13

Datei: test_wb_input_gearman.py Projekt: bugcy013/experiments

from wishbone import Actor
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_tcp import TCP
from wb_input_gearman import Gearman

#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((Gearman, "gearman", 0), hostlist=["besrvuc-nag02:4730"], queue="perfdata", workers=10, secret="Aloh9uibshojeF8oAhyo3eefGu5ohr3iDeek4ehamaM9eisoas6OoveiareQuo0i")
router.register((STDOUT, "stdout_events", 0))


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

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

Beispiel #14

Datei: test_wb_minimal_thread.py Projekt: smetj/experiments

        thread.start()

    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")

Beispiel #15

Datei: test_wb_wait_seconds.py Projekt: smetj/experiments

                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")

Beispiel #16

Datei: test_wb_input_generator.py Projekt: smetj/experiments

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_generator import Generator

from gevent import sleep, spawn

#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")

#Consume events to Null
router.register((Generator, "generator", 0))
router.register((STDOUT, "stdout_events", 0))
#router.register((Null, "null", 0))

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

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

Beispiel #17

Datei: test_wb_minimal.py Projekt: smetj/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()

Beispiel #18

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

Beispiel #19

Datei: broker_test.py Projekt: smetj/experiments

                    looper = 0
                    sleep()
                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")

Beispiel #20

Datei: test_wb_output_mqtt.py Projekt: 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()

Beispiel #21

Datei: test_wb_output_amqp.py Projekt: smetj/experiments

from wb_output_amqp import AMQP
from wb_output_tcp import TCP

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

#organize metricstream
router.registerMetricModule(Null, "null")
#router.registerMetricModule(Graphite, "graphite")
#router.register(TCP, "graphite_transport", host="graphite-001", port=2013)
#router.connect("graphite.outbox", "graphite_transport.inbox")

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

#router.register(TestEvent, "testevent", interval=1)
router.register(TestEvent, "testevent", interval=0.5)
router.register(Header,
                "header",
                key="amqp",
                header={
                    'broker_exchange': "",
                    'broker_key': "test",
                    'broker_tag': "test"
                })
router.register(STDOUT, "stdout", complete=True)
router.register(
    AMQP,

Beispiel #22

Datei: test_wb_output_uds.py Projekt: 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 TestEvent

from wb_output_uds import UDS

#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(UDS, "uds")

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

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

Beispiel #23

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

Beispiel #24

Datei: fanout_test.py Projekt: smetj/experiments

                    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", 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")

Beispiel #25

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()

Beispiel #26

Datei: test_wb_input_amqp.py Projekt: bugcy013/experiments

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

    def consume(self, event):
        pass
        #self.logging.info("Received event.")
        #sleep(0.005)

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

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

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

#Organize data flow
router.register(AMQP, "amqp", host="localhost", queue="test", prefetch_count=100, no_ack=True)
router.register(Forwarder, "forwarder")
router.register(Output, "output")

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

Beispiel #27

Datei: funnel_test.py Projekt: smetj/experiments

                    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()

Beispiel #28

Datei: test_wb_output_udp.py Projekt: 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()

Beispiel #29

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")

Beispiel #30

Datei: test_wb_minimal.py Projekt: bugcy013/experiments

class Output(Actor):
    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()

Beispiel #31

Datei: fanout_test.py Projekt: bugcy013/experiments

            try:
                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", 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")

Beispiel #32

Datei: funnel_test.py Projekt: bugcy013/experiments

            try:
                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()

Beispiel #33

Datei: test_wb_output_mongodb.py Projekt: 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()

Beispiel #34

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()

Beispiel #35

Datei: test_wb_minimal.py Projekt: 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()

Beispiel #36

Datei: broker_test.py Projekt: smetj/experiments

                    },
                    "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")

Beispiel #37

Datei: test_wb_input_tcp.py Projekt: 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_tcp import TCP

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((TCP, "tcp", 0))
router.register((STDOUT, "stdout_events", 0))

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

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