def SMBStart(): global conn global io_loop logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() io_loop.start()
class RBClient(object): def __init__(self, app, host, queue, key): self.app = app self.queue = queue self.host = host self.connected = False self.connecting = False self.connection = None self.channel = None self.key = key self.mq = {} def connect(self): if self.connecting: return self.connecting = True self.connection = Connection( host=self.host, ) self.connection.connect(self.on_connected) self.connection.on_disconnect = self.on_closed def on_connected(self): self.connected = True self.channel = self.connection.channel() self.channel.exchange_declare( exchange=self.queue, type='topic', durable=False, ) self.channel.queue_declare( queue=self.queue, auto_delete=True, durable=False, ) self.channel.queue_bind( exchange=self.queue, queue=self.queue, routing_key=self.key, ) self.channel.consume( self.queue, self.callback, no_ack=True, ) def on_basic_cancel(self, frame): self.connection.close() def on_closed(self, connection): tornado.ioloop.IOLoop.instance().stop() def callback(self, msg): subscribers = self.mq.get(msg.rx_data.routing_key, None) if subscribers: for subscriber in subscribers: subscriber.release(msg.body)
def start(on_connect): global conn global io_loop logging.basicConfig() conn = Connection(host=str_Server) conn.connect(on_connect) io_loop = IOLoop.instance() io_loop.start()
def Start(): global conn global io_loop logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() io_loop.start() print ' [*] Waiting for messages. To exit press CTRL+C'
def init_worker(): global conn conn = Connection(host='localhost') conn.connect(push_connect) io_loop = IOLoop.instance() print '=> Waiting for push notifications to notify all devices.' try: io_loop.start() except KeyboardInterrupt: conn.close(io_loop.stop)
def main(): global ch, conn conn = Connection(host='localhost') conn.connect(on_amqp_connection) application = web.Application([ (r"/round_trip", RoundTripHandler), ]) http_server = httpserver.HTTPServer(application) http_server.listen(8001) ioloop.IOLoop.instance().start()
def __init__(self, playerId, position, otherPlayers, onQuit = None): # Acking for messages. You cannot send a message until the previous # message has been ack'd (in a message, not just ack'd to the MQ). This # guarantees message order, which RabbitMQ does not otherwise do. self.waitlet = None self.waitingForAck = False self.blockingForAck = False self.messages = [] self.playerId = playerId self.inQueue = "from-%s" % playerId self.outQueue = "to-%s" % playerId # Number of messages we've recieved. Used to track whether the client has # stopped talking to us. self.msgCount = 0 # Callback -- If we lose the player, call this with our position. self.onQuit = onQuit # If we've seen our hand we can't bid double nil. We (MQView) have to guarantee # this, since we get given the hand before 00 bidding time. self.seenHand = False self.position = position self.otherPlayers = dict((self._getRelPosition(position), name) for (position, name) in otherPlayers) # Connect to the MQ. self.mq = None self.mqConn = Connection(host='localhost') self.mqConn.connect(self._onConnect)
def connect(self): if self.connecting: return self.connecting = True self.connection = Connection( host=self.host, ) self.connection.connect(self.on_connected) self.connection.on_disconnect = self.on_closed
def _handler(self, gameId, userId, alreadyJoined = False, messagesToSend=[]): self.cancelled = False self.gameId = gameId self.userId = userId self.alreadyJoined = alreadyJoined self.messagesToSend = messagesToSend self._pingTimeout = None self.mqConn = Connection(host='localhost') self.mqConn.connect(self._onConnect)
def makeAMQPConnection(self, token='', callback=None): def notifsCallback(msg): if callback: callback(msg) def on_connect(): ch = self.conn.channel() ch.queue_declare(queue=token, durable=True, exclusive=False, auto_delete=False) ch.consume(token, notifsCallback, no_ack=True) ch.qos(prefetch_count=1) self.conn = Connection(host=self.config['broker_host'],port=self.config['broker_amqp_port']) self.conn.connect(on_connect)
class FibonacciRpcClient(object): def __init__(self, n): self.conn = Connection(host='localhost') self.conn.connect(self.on_connect) self.n = n def on_connect(self): self.ch = self.conn.channel() self.ch.queue_declare(exclusive=True, callback=self.on_queue_declare) def on_queue_declare(self, q_info): callback_queue = q_info.queue self.ch.consume(callback_queue, self.on_response) self.corr_id = str(uuid.uuid4()) msg = Message(str(self.n), delivery_mode=2, reply_to=callback_queue, correlation_id=self.corr_id) self.ch.publish(msg, exchange='', routing_key='rpc_queue') def on_response(self, msg): if self.corr_id == msg.correlation_id: print " [x] Received %r" % msg.body self.conn.close(callback=IOLoop.instance().stop) print 'Closing connection.'
class RabbitHelper(object): def __init__(self, on_sent=None): self.conn = Connection(host='localhost') self.on_sent = on_sent def send_message(self, message, queue='', exchange='', routing_key=''): self.msg = Message(message, delivery_mode=2) self.queue = queue self.exchange = exchange self.routing_key = routing_key self.conn.connect(lambda: self.on_connect()) def on_connect(self): ch = self.conn.channel() ch.queue_declare(queue=self.queue, durable=True) ch.publish(self.msg, exchange=self.exchange, routing_key=self.routing_key) self.conn.close(callback=self.done) def done(self): if self.on_sent: self.on_sent()
from tornado.ioloop import IOLoop from stormed import Connection, Message import simplejson as json def on_connect(): ch = conn.channel() ch.queue_declare(queue='reply') ch.consume('reply', callback, no_ack=True) def callback(msg): print " [x] Received %r" % msg.body runmsg(msg) def runmsg(msg): print "Exec", msg.body strMsg = json.loads(msg.body) print "Head:",strMsg[0] print "Body:",strMsg[1] #exec msg logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() print ' [*] Waiting for messages. To exit press CTRL+C' try: io_loop.start() except KeyboardInterrupt: conn.close(io_loop.stop)
from stormed import Connection, Message msg = Message('Hello World!') def on_connect(): ch = conn.channel() ch.queue_declare(queue='hello') SendHello(ch) SendNo(ch) conn.close(callback=done) def SendHello(ch): ch.publish(msg, exchange='', routing_key='hello') print "Send Hello Finish" def SendNo(ch): for i in range(1,10): msgno = Message('Hello %(ID)02d'%{"ID":i}) ch.publish(msgno, exchange='', routing_key='hello') print "Send No ",i,"Finish" def done(): print " End." io_loop.stop() logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() io_loop.start()
class MQView: """ A view for the game that lets it communicate with the comet clients, via RabbitMQ. Pretends to be a normal blocking interface for this purpose, acts completely synchronous. """ def __init__(self, playerId, position, otherPlayers, onQuit = None): # Acking for messages. You cannot send a message until the previous # message has been ack'd (in a message, not just ack'd to the MQ). This # guarantees message order, which RabbitMQ does not otherwise do. self.waitlet = None self.waitingForAck = False self.blockingForAck = False self.messages = [] self.playerId = playerId self.inQueue = "from-%s" % playerId self.outQueue = "to-%s" % playerId # Number of messages we've recieved. Used to track whether the client has # stopped talking to us. self.msgCount = 0 # Callback -- If we lose the player, call this with our position. self.onQuit = onQuit # If we've seen our hand we can't bid double nil. We (MQView) have to guarantee # this, since we get given the hand before 00 bidding time. self.seenHand = False self.position = position self.otherPlayers = dict((self._getRelPosition(position), name) for (position, name) in otherPlayers) # Connect to the MQ. self.mq = None self.mqConn = Connection(host='localhost') self.mqConn.connect(self._onConnect) # Every single position that goes out from here should be relative to # the player we represent. def _getRelPosition(self, position): return (position - self.position) % 4 def playerJoined(self, name, position): self.otherPlayers[self._getRelPosition(position)] = name self._send({'type' : 'joined', 'name' : name, 'position' : self._getRelPosition(position)}, async=True) def playerQuit(self, position): self.otherPlayers[self._getRelPosition(position)] = None self._send({'type' : 'quit', 'position' : self._getRelPosition(position)}, async=True) def startRound(self, leadPosition): self._send({'type' : 'startGame', 'leadPosition' : self._getRelPosition(leadPosition), 'playerList' : map(lambda (position, name) : { 'name' : name, 'position' : position }, self.otherPlayers.items())}) def setHand(self, hand): self.hand = hand self.seenHand = False def goDoubleNil(self): if self.seenHand: return False else: self._send({'type' : 'question', 'question' : 'bid00?'}) result = self._recv() result = result['00'] if result is True and self.seenHand: print "* Player attempted to bid 00 after having looked at their hand!" return False return result def showHand(self): if not self.seenHand: self.sendHand() def bidSomethingSensible(self): self._send({'type' : 'question', 'question' : 'bid?'}) return self._recv()['bid'] def sendHand(self, async=False): msg = {'type' : 'hand', 'hand' : self.hand} self._send(msg, async) self.seenHand = True
class CometHandler(tornado.web.RequestHandler): """ Handles communication between MQView and the Javascript side, acting as the server end of the long-polling AJAX connection. """ @tornado.web.asynchronous def post(self): self._handler(self.get_argument('gameId'), self.get_argument('userId'), self.get_argument('alreadyJoined', False), json.loads(self.get_argument('messages', "[]"))) def _handler(self, gameId, userId, alreadyJoined = False, messagesToSend=[]): self.cancelled = False self.gameId = gameId self.userId = userId self.alreadyJoined = alreadyJoined self.messagesToSend = messagesToSend self._pingTimeout = None self.mqConn = Connection(host='localhost') self.mqConn.connect(self._onConnect) def _onConnect(self): self.mq = self.mqConn.channel() if not self.alreadyJoined: joinMessage = Message(pickle.dumps( { 'type' : 'join', 'id' : self.userId, 'name' : 'Tim' } )) self.mq.queue_declare(self.gameId) self.mq.publish(joinMessage, exchange = '', routing_key = self.gameId) self.outQueue = "from-%s" % self.userId self.inQueue = "to-%s" % self.userId self.mq.queue_declare(self.inQueue) self.mq.queue_declare(self.outQueue) self.mq.consume(self.inQueue, self._onRecv) # We need the MQView to know that we're connected, either by us pinging it # or by us sending actual relevant messages: if len(self.messagesToSend) > 0: for message in self.messagesToSend: self._send(message) # If we're still here in 14 seconds, make sure the MQView knows that we # haven't disconnected. self._pingTimeout = tornado.ioloop.IOLoop.instance().add_timeout(time.time() + 14, self._ping) # If we don't have any messages to send, just starting pinging instead (sooner, since # we don't know when the last message was) else: self._pingTimeout = tornado.ioloop.IOLoop.instance().add_timeout(time.time() + 5, self._ping) def _send(self, msg): # These messages are not going to be expected, and the MQView needs # do deal with them now. if 'type' in msg and (msg['type'] == 'quit' or msg['type'] == 'hand'): msg['async'] = True if 'bid' in msg: msg['bid'] = Bid(msg['bid']) if 'card' in msg: msg['card'] = Card(msg['card']['suit'], msg['card']['value']) self.mq.publish(Message(pickle.dumps(msg)), exchange = '', routing_key=self.outQueue) def _ping(self): self._pingTimeout = None if not self.request.connection.stream.closed() and not self.cancelled: self._send({'type' : 'ping'}) self._pingTimeout = tornado.ioloop.IOLoop.instance().add_timeout(time.time() + 14, self._ping) def on_connection_close(self): self.stopConsuming() def _onRecv(self, msg): if self.cancelled: # Don't print this, it happens quite a lot, not an issue unless we start getting # messages out of order again (should be fixed by our 'ack' messages. # print "* Cancelled comet got message! (%s)" % self.userId msg.reject() return data = pickle.loads(msg.body) ackRequired = True if 'async' in data: if data['async'] == True: ackRequired = False del data['async'] # Turns hands (lists of Card objects) into dictionaries of the cards values # Suits are in alphabetical order (0 clubs, 1 diamonds etc), values in # standard order, aces high, all 0 indexed. if 'hand' in data: data['hand'] = map(lambda c : {'suit' : c.suit, 'value' : c.value}, data['hand']) # Turn bids (lists of Bid objects) into lists of numbers, with # 0 as nil and -1 as double nil. elif 'bid' in data: bid = str(data['bid'].value) data['bid'] = bid if bid != '-1' else '00' # Turn individual cards into key'd maps. elif 'card' in data: data['card'] = {'suit' : data['card'].suit, 'value' : data['card'].value } # If the connection got dropped, we leave this, and we give it back to the MQ, so we # can resend it out next time. if self.request.connection.stream.closed(): print "* Comet was closed whilst passing on message" msg.reject() # Marks the message as not sent. return self.write(json.dumps(data)) self.finish() msg.ack() if ackRequired: self._send({'ack' : True}) self.stopConsuming() def stopConsuming(self): self.cancelled = True self.mqConn.close() if self._pingTimeout: tornado.ioloop.IOLoop.instance().remove_timeout(self._pingTimeout)
def __init__(self, n): self.conn = Connection(host='localhost') self.conn.connect(self.on_connect) self.n = n
def main(): global ch, conn conn = Connection(host='localhost') conn.connect(on_amqp_connection) ioloop.IOLoop.instance().start()
class SSEServer(object): def __init__(self, config): self.config = config self.conn = None self.webapp = self.makeWebFrontend() self.webapp.listen(8888) io_loop = IOLoop.instance() print ' [*] Waiting for messages. To exit press CTRL+C' try: io_loop.start() except KeyboardInterrupt: self.conn.close(io_loop.stop) def makeAMQPConnection(self, token='', callback=None): def notifsCallback(msg): if callback: callback(msg) def on_connect(): ch = self.conn.channel() ch.queue_declare(queue=token, durable=True, exclusive=False, auto_delete=False) ch.consume(token, notifsCallback, no_ack=True) ch.qos(prefetch_count=1) self.conn = Connection(host=self.config['broker_host'],port=self.config['broker_amqp_port']) self.conn.connect(on_connect) def makeWebFrontend(self): thisSSE = self class NotificationsWebHandler(tornado.web.RequestHandler): @tornado.web.asynchronous def get(self, token): self.set_header("Content-Type","text/event-stream") self.set_header("Cache-Control","no-cache") self.set_header("Connection","keep-alive") self.notifID = 0 self.flush() def callbackFunc(msg): self.publishNotification(msg.body) thisSSE.makeAMQPConnection(token, callbackFunc) @tornado.web.asynchronous def publishNotification(self, notifData): self.write("id: %i\n" % self.notifID) self.write("data:") self.write(notifData) self.write("\n\n") self.flush() self.notifID+=1 routes = [ (r"/feed/(.*)", NotificationsWebHandler) ] return tornado.web.Application(routes)
from tornado.options import define, options from stormed import Connection, Message import settings import logging from tornado.ioloop import IOLoop conn = Connection(host=settings.MQ_HOST, username=settings.MQ_USERNAME, password=settings.MQ_PASSWORD, heartbeat=settings.MQ_HEARTBEAT) msg = Message('Hello World!') def callback(msg): logging.info(" test=> Received %r" % msg.body) def on_connect(): ch = conn.channel() ch.queue_declare(queue='hello') ch.publish(msg, exchange='', routing_key='hello') logging.info(" test=> Sent 'Hello World!'") ch.consume('hello', callback, no_ack=True) logging.info("Init amqp success") options.mq_connection = conn init_queue() def init_queue(): ch = conn.channel()
#! /usr/bin/env python import logging from tornado.ioloop import IOLoop from stormed import Connection, Message def on_connect(): ch = conn.channel() ch.queue_declare(queue='hello') ch.consume('hello', callback, no_ack=True) def callback(msg): print " [x] Received %r" % msg.body logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() print ' [*] Waiting for messages. To exit press CTRL+C' try: io_loop.start() except KeyboardInterrupt: conn.close(io_loop.stop)
#! /usr/bin/env python import logging import sys from tornado.ioloop import IOLoop from stormed import Connection, Message # delivery_mode=2 makes message persistent routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info' msg = Message(' '.join(sys.argv[2:]) or 'Hello World!') def on_connect(): ch = conn.channel() ch.exchange_declare(exchange='topic_logs', type='topic') ch.publish(msg, exchange='topic_logs', routing_key=routing_key) conn.close(callback=done) def done(): print " [x] Sent %r:%r" % (routing_key, msg.body) io_loop.stop() logging.basicConfig() conn = Connection(host='localhost') conn.connect(on_connect) io_loop = IOLoop.instance() io_loop.start()
def __init__(self, on_sent=None): self.conn = Connection(host='localhost') self.on_sent = on_sent