def setUp(self):
self.io = DecafIOThread()
self.zmq_actor = ZmqActor()
self.io.register_actor(self.zmq_actor)
self.io.start()
time.sleep(2)
pass
def test_channel(self):
self.con = None
def do():
pass
def do2():
pass
def on_exchange_declareok(self):
print "EXCHANGE OK"
def callback(channel):
channel.exchange_declare(on_exchange_declareok,
"trool",
"topic")
io = DecafIOThread()
print "here"
self.con = RabbitConnection(ioloop=io.ioloop)
self.con.run()
io.start()
time.sleep(5)
self.con.new_channel(callback)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.io = DecafIOThread()
self.zmq_actor = ZmqActor()
self.io.register_actor(self.zmq_actor)
self.io.start()
time.sleep(2)
pass
def test_something(self):
socket = self.zmq_actor.new_socket(zmq.DEALER)
port = socket.bind_to_random_port("tcp://127.0.0.1")
print port
print socket.type
socket2 = self.zmq_actor.new_socket(zmq.DEALER)
succ = socket2.connect("tcp://127.0.0.1:{0}".format(port))
print succ
succ = socket2.send_string("moin")
print succ
recv = socket.recv_string()
print "Recieved", recv
i = raw_input()
def test_channel(self):
self.con = None
def do():
pass
def do2():
pass
def on_exchange_declareok(self):
print "EXCHANGE OK"
def callback(channel):
channel.exchange_declare(on_exchange_declareok, "trool", "topic")
io = DecafIOThread()
print "here"
self.con = RabbitConnection(ioloop=io.ioloop)
self.con.run()
io.start()
time.sleep(5)
self.con.new_channel(callback)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.io = DecafIOThread()
self.zmq_actor = ZmqActor()
self.io.register_actor(self.zmq_actor)
self.io.start()
time.sleep(2)
pass
def test_something(self):
socket = self.zmq_actor.new_socket(zmq.DEALER)
port = socket.bind_to_random_port("tcp://127.0.0.1")
print port
print socket.type
socket2 = self.zmq_actor.new_socket(zmq.DEALER)
succ = socket2.connect("tcp://127.0.0.1:{0}".format(port))
print succ
succ = socket2.send_string("moin")
print succ
recv = socket.recv_string()
print "Recieved", recv
i = raw_input()
def test_consumer(self):
def on_setup_done(tag=None):
print " setup done"
#con.stop()
def method(*args, **kwargs):
print "trololololololol"
io = DecafIOThread()
con = RabbitConnection(ioloop=io.ioloop)
con.run()
io.setDaemon(True)
io.start()
consumer = AsyncConsumer(con,
"TheQueue",
method,
on_setup_done=on_setup_done,
exchange="trool",
exchange_type="topic",
routing_key="trololol")
try:
i = raw_input("")
except:
print "signal"
io.stop_ioloop()
def setUp(self):
self.io = DecafIOThread()
self.zmq_actor = ZmqActor()
self.io.register_actor(self.zmq_actor)
self.io.start()
time.sleep(2)
pass
def __init__(self, host_url=u'amqp://127.0.0.1:5672', logger=None, ioloop=None, parameters=None, on_connected=None):
self._consumers = dict()
self.ready=False
self.callWhenReady = {}
self._host_url = host_url
url = urlparse.urlparse(host_url)
self._host_ip = url.hostname
if url.port:
self._host_port = url.port
else:
self._host_port = 5762
if logger is not None:
self.logger = logger
else:
self.logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
self.logger.addHandler(ch)
if ioloop is None:
self.io = DecafIOThread()
self._connection = RabbitConnection(host_url, ioloop=self.io.ioloop, logger=self.logger, parameters=parameters, on_connected=on_connected)
self.io.start()
self._connection.run()
else:
self._connection = RabbitConnection(host_url, ioloop=ioloop, logger=self.logger, parameters=parameters, on_connected=on_connected)
self._connection.run()
def __init__(self, loop=None, endpoint="tcp://127.0.0.1:9999", server=True, type=zmq.ROUTER):
super(ZeroActor, self).__init__()
self.ctx = Context.instance()
self.isserver = server
self.socket = self.ctx.socket(type)
self.endpoint = endpoint
if loop is None:
self.io = DecafIOThread()
self.io.register_actor(self)
self.io.start()
self.run()
else:
self.io = loop
self.io.register_actor(self)
self.run()
def __init__(self,
host_url=u'amqp://127.0.0.1:5672',
logger=None,
ioloop=None,
parameters=None,
on_connected=None):
self._consumers = dict()
self.ready = False
self.callWhenReady = {}
self._host_url = host_url
url = urlparse.urlparse(host_url)
self._host_ip = url.hostname
if url.port:
self._host_port = url.port
else:
self._host_port = 5762
if logger is not None:
self.logger = logger
else:
self.logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
self.logger.addHandler(ch)
if ioloop is None:
self.io = DecafIOThread()
self._connection = RabbitConnection(host_url,
ioloop=self.io.ioloop,
logger=self.logger,
parameters=parameters,
on_connected=on_connected)
self.io.start()
self._connection.run()
else:
self._connection = RabbitConnection(host_url,
ioloop=ioloop,
logger=self.logger,
parameters=parameters,
on_connected=on_connected)
self._connection.run()
def test_consumer(self):
def on_setup_done(tag=None):
print " setup done"
#con.stop()
def method(*args,**kwargs):
print "trololololololol"
io = DecafIOThread()
con = RabbitConnection(ioloop=io.ioloop)
con.run()
io.setDaemon(True)
io.start()
consumer = AsyncConsumer(con,"TheQueue", method, on_setup_done = on_setup_done, exchange = "trool", exchange_type = "topic", routing_key = "trololol")
try:
i = raw_input("")
except:
print "signal"
io.stop_ioloop()
class ZeroActor(DecafActor):
"""
A minimal Wrapper around a ZeroMQ Socket that turns it into a threadsafe actor.
"""
def set_handler(self, handler):
self.handled = True
self.handler = handler
def msg_handler(self, socket, events, **kwargs):
if events & READ:
msg_type = self.socket.recv_string()
if msg_type in [JSON, BYTES, PYTHON, STRING]:
msg = None
if msg_type == JSON:
msg = self.socket.recv_json()
elif msg_type == BYTES:
msg = self.socket.recv()
elif msg_type == PYTHON:
msg = self.socket.recv_pyobj()
elif msg_type == STRING:
msg = self.socket.recv_string()
self.handler(msg, msg_type)
else:
pass
if events & WRITE:
pass
if events & ERROR:
pass
@on_loop
def send(self, msg, msg_type, **kwargs):
if msg_type in [JSON, BYTES, PYTHON, STRING]:
self.socket.send_string(msg_type)
if msg_type == JSON:
self.socket.send_json(msg, **kwargs)
elif msg_type == BYTES:
self.socket.send(msg, **kwargs)
elif msg_type == PYTHON:
self.socket.send_pyobj(msg, **kwargs)
elif msg_type == STRING:
self.socket.send_string(msg, **kwargs)
else:
return
@on_loop
def do_recurring(self, function, intervall=1000):
def make_recurring_call(f):
def recurring_call():
f()
self.io.ioloop.add_timeout(intervall, recurring_call)
return recurring_call
f = make_recurring_call(function)
self.io.ioloop.add_timeout(intervall, f)
@on_loop
def run(self):
if self.isserver:
self.socket.bind(self.endpoint)
else:
self.socket.connect(self.endpoint)
self.io.ioloop.add_handler(self.socket, self.msg_handler, READ)
def __init__(self, loop=None, endpoint="tcp://127.0.0.1:9999", server=True, type=zmq.ROUTER):
super(ZeroActor, self).__init__()
self.ctx = Context.instance()
self.isserver = server
self.socket = self.ctx.socket(type)
self.endpoint = endpoint
if loop is None:
self.io = DecafIOThread()
self.io.register_actor(self)
self.io.start()
self.run()
else:
self.io = loop
self.io.register_actor(self)
self.run()
class RabbitMQLayer(object):
"""
This class is a generic interface to RabbitMQ.
"""
def __del__(self):
self.dispose()
def disposeConsumer(self, tag):
con = self._consumers.get(tag, None)
if con:
con.stop_consuming()
def dispose(self):
for tag in self._consumers:
self.disposeConsumer(tag)
self._connection.stop()
def __init__(self,
host_url=u'amqp://127.0.0.1:5672',
logger=None,
ioloop=None,
parameters=None,
on_connected=None):
self._consumers = dict()
self.ready = False
self.callWhenReady = {}
self._host_url = host_url
url = urlparse.urlparse(host_url)
self._host_ip = url.hostname
if url.port:
self._host_port = url.port
else:
self._host_port = 5762
if logger is not None:
self.logger = logger
else:
self.logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
self.logger.addHandler(ch)
if ioloop is None:
self.io = DecafIOThread()
self._connection = RabbitConnection(host_url,
ioloop=self.io.ioloop,
logger=self.logger,
parameters=parameters,
on_connected=on_connected)
self.io.start()
self._connection.run()
else:
self._connection = RabbitConnection(host_url,
ioloop=ioloop,
logger=self.logger,
parameters=parameters,
on_connected=on_connected)
self._connection.run()
@property
def getHostIP(self):
return self._host_ip
@property
def getHostPort(self):
return self._host_port
def _twisted_ready(self, *args, **kwargs):
self.ready = True
for d in self.callWhenReady:
res = self.callWhenReady[d]()
if isinstance(res, defer.Deferred):
res.chainDeferred(d)
else:
d.callback(res)
def createProducer(self):
def callback(channel):
d.callback(channel)
d = defer.Deferred()
con = self._connection.new_channel(callback)
return d
def createConsumer(self,
queue_name,
consume_method,
exchange=None,
exchange_type=None,
routing_key=None,
exclusive=True,
tag=None):
"""
Creates a ansynchrounus consumer which listens on the given Queue.
:param queue_name:
:param consume_method:
:param exchange:
:param exchange_type:
:param routing_key:
:return:
"""
def on_setup_done(tag=None):
if tag is not None:
self._consumers[tag] = con
result = (tag, queue_name)
d.callback(result)
d = defer.Deferred()
con = AsyncConsumer(self._connection,
queue_name,
consume_method,
amqp_url=self._host_url,
on_setup_done=on_setup_done,
exchange=exchange,
exchange_type=exchange_type,
routing_key=routing_key,
logger=self.logger,
exclusive=exclusive,
tag=tag)
return d
class RabbitMQLayer(object):
"""
This class is a generic interface to RabbitMQ.
"""
def __del__(self):
self.dispose()
def disposeConsumer(self, tag):
con = self._consumers.get(tag, None)
if con:
con.stop_consuming()
def dispose(self):
for tag in self._consumers:
self.disposeConsumer(tag)
self._connection.stop()
def __init__(self, host_url=u'amqp://127.0.0.1:5672', logger=None, ioloop=None, parameters=None, on_connected=None):
self._consumers = dict()
self.ready=False
self.callWhenReady = {}
self._host_url = host_url
url = urlparse.urlparse(host_url)
self._host_ip = url.hostname
if url.port:
self._host_port = url.port
else:
self._host_port = 5762
if logger is not None:
self.logger = logger
else:
self.logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
self.logger.addHandler(ch)
if ioloop is None:
self.io = DecafIOThread()
self._connection = RabbitConnection(host_url, ioloop=self.io.ioloop, logger=self.logger, parameters=parameters, on_connected=on_connected)
self.io.start()
self._connection.run()
else:
self._connection = RabbitConnection(host_url, ioloop=ioloop, logger=self.logger, parameters=parameters, on_connected=on_connected)
self._connection.run()
@property
def getHostIP(self):
return self._host_ip
@property
def getHostPort(self):
return self._host_port
def _twisted_ready(self, *args, **kwargs):
self.ready = True
for d in self.callWhenReady:
res = self.callWhenReady[d]()
if isinstance(res, defer.Deferred):
res.chainDeferred(d)
else:
d.callback(res)
def createProducer(self):
def callback(channel):
d.callback(channel)
d = defer.Deferred()
con = self._connection.new_channel(callback)
return d
def createConsumer(self, queue_name, consume_method, exchange = None, exchange_type = None, routing_key = None, exclusive=True, tag=None):
"""
Creates a ansynchrounus consumer which listens on the given Queue.
:param queue_name:
:param consume_method:
:param exchange:
:param exchange_type:
:param routing_key:
:return:
"""
def on_setup_done(tag=None):
if tag is not None:
self._consumers[tag] = con
result = (tag,queue_name)
d.callback(result)
d = defer.Deferred()
con = AsyncConsumer(self._connection, queue_name, consume_method, amqp_url=self._host_url, on_setup_done = on_setup_done, exchange = exchange, exchange_type = exchange_type, routing_key = routing_key, logger=self.logger, exclusive=exclusive, tag=tag)
return d