def queue_message(self, message, queue_name): logger.info("Sending message to queue '%s'" % queue_name) with self.mutex: if queue_name not in self.queues: raise Exception("Queue '%s' does not exist" % queue_name) self.queues[queue_name].put(message)
def send_broadcast(self, message, username): logger.info("Sending broadcast to user '%s'" % username) with self.mutex: if username not in self.userToQueues: raise Exception("User '%s' has no queues" % username) # Deliver message to each of the user's queues for queue_name in self.userToQueues[username]: self.queues[queue_name].put(message)
def delete_subscription(self, username, token): logger.info("Deleting subscription '%s' for user '%s'" % (token, username)) with self.mutex: self._ensure_user_exists(username) if token not in self.subToUser: raise Exception("Subscription token '%s' does not exist" % token) del self.subToUser[token]
def _cleanMessage(self, username, message): """ """ dead_file = os.path.join(self._user_storage_path(username), json.loads(message).get('file')) logger.info("Removing expired msg file %s" % dead_file) try: os.remove(dead_file) except OSError: pass self.redis.lrem('u2m:%s' % username, message, 0)
def create_subscription(self, username, token): logger.info("Creating subscription '%s' for user '%s'" % (token, username)) with self.mutex: self._ensure_user_exists(username) if token in self.subToUser: if self.subToUser[token] != username: raise Exception("Subscription token '%s' is already taken" % token) else: pass # Don't care if same user registers token twice self.subToUser[token] = username
def get_message(self, queue_name): logger.info("Consuming message from queue '%s'" % queue_name) queue = None with self.mutex: if queue_name not in self.queues: raise Exception("Queue '%s' does not exist") queue = self.queues[queue_name] # NOTE: In theory, a queue can be deleted with other storage plugins. # This is not a case we worry about with in-memory storage return queue.get() # Blocks until queue gets item
def __init__(self, **config): self.config = config self.broker_user = self.config.get('username', 'user') self.broker_pass = self.config.get('password', 'user') self.broker_host = self.config.get('host', 'localhost') self.broker_amqp_port = int(self.config.get('amqp_port', '5672')) self.broker_http_port = int(self.config.get('http_port', '8000')) self.broker_vhost = self.config.get('virtual_host', '/') self.incoming_exchange_name = self.config.get('incoming_exchange_name', 'incoming_exchange') self.routing_queue_name = self.config.get('routing_queue_name', 'notifications') logger.info("Message Broker User: %s" % self.broker_user) logger.info("Message Broker Host: %s" % self.broker_host) logger.info("Message Broker Port: %s" % self.broker_amqp_port) logger.info("Message Broker Virtual Host: %s" % self.broker_vhost) # Create connection parameters object for easy reuse self.conn_params = pika.ConnectionParameters( credentials=pika.PlainCredentials( self.broker_user, self.broker_pass, ), host=self.broker_host, port=self.broker_amqp_port, virtual_host=self.broker_vhost, ) self.master_connection = SelectConnection(self.conn_params, self.on_open) # Create HTTP connection object for easy reuse self.http_conn = httplib.HTTPConnection(self.broker_host, self.broker_http_port)
def publish_message(self, message, token): logger.info("Publishing message to subscription token '%s'" % token) with self.mutex: if token not in self.subToUser: raise Exception("Subscription token '%s' does not exist" % token) username = self.subToUser[token] self._ensure_user_exists(username) # Deliver message to each of the user's queues for queue_name in self.userToQueues[username]: self.queues[queue_name].put(message)
def __init__(self, **config): self.broker_user = config['username'] self.broker_pass = config['password'] self.broker_host = config['host'] self.broker_amqp_port = int(config['amqp_port']) self.broker_http_port = int(config['http_port']) self.broker_vhost = config['virtual_host'] self.incoming_exchange_name = config['incoming_exchange_name'] self.routing_queue_name = config['routing_queue_name'] logger.info("Message Broker User: %s" % self.broker_user) logger.info("Message Broker Host: %s" % self.broker_host) logger.info("Message Broker Port: %s" % self.broker_amqp_port) logger.info("Message Broker Virtual Host: %s" % self.broker_vhost) # Create connection parameters object for easy reuse self.conn_params = pika.ConnectionParameters( credentials=pika.PlainCredentials( self.broker_user, self.broker_pass, ), host=self.broker_host, port=self.broker_amqp_port, virtual_host=self.broker_vhost, ) # Create HTTP connection object for easy reuse self.http_conn = httplib.HTTPConnection(self.broker_host, self.broker_http_port)
def create_client_queue(self, username): user_exchange_name = username # Create a unique client id to also be used as the name of the queue client_queue_name = "%x" % random.getrandbits(256) logger.info("Creating queue %s for user %s", client_queue_name, username) # Create the user exchange (if it doesn't already exist) and a client # queue with the generated name. conn = self._get_amqp_conn() try: channel = conn.channel() logger.debug("Declaring exchange %s", user_exchange_name) channel.exchange_declare( exchange=user_exchange_name, durable=True, type='fanout', ) logger.debug("Declaring queue %s", client_queue_name) channel.queue_declare(queue=client_queue_name, durable=True) logger.debug("Binding queue %s to exchange %s", client_queue_name, user_exchange_name, ) channel.queue_bind( exchange=user_exchange_name, queue=client_queue_name, ) except: logger.error("Error creating new client queue") raise finally: logger.debug("Closing AMQP connection to broker") conn.disconnect() return { 'queue_id': client_queue_name, 'host': self.broker_host, 'port': self.broker_amqp_port, }
def create_client_queue(self, username): logger.info("Creating incoming queue for user %s" % username) try: # Check to see if the user already has a token. # ut: user -> token user_token = self.redis.get('u2t:%s' % username) if user_token is None: user_token = new_token() self.redis.set('u2t:%s' % username, user_token) self.redis.set('t2u:%s' % user_token, username) info = {"created": int(time.time()), "state": 'active', "changedate": int(time.time())} self.redis.hmset('sin:%s:%s' % (username, user_token), info) return {'queue_id': user_token, 'port': self.config.get('notifserver.port', 80), 'host': self.config.get('notifserver.host')} except Exception, ex: logger.error("Could not create user queue %s" % str(ex))
def create_client_queue(self, username): self.mutex.acquire() self._ensure_user_exists(username) # TODO: Probably unnecessary, but make sure the queue name isn't taken queue_name = "%x" % random.getrandbits(256) logger.info("Creating queue %s for user %s", queue_name, username) self.userToQueues[username].append(queue_name) self.queues[queue_name] = Queue() self.mutex.release() return { 'queue_id': queue_name, 'host': self.broker_host, 'port': self.broker_port, }
def create_client_queue(self, username): # create the mapping record channel_info = {u'token': new_token(), u'user_id': username, u'type': 'queue', u'created': int(time.time()) } logger.info("Creating incoming queue %s for user %s" % ( channel_info.get('token'), username)) try: self.db.user.insert(channel_info, safe=True) return {'queue_id': channel_info['token'], 'host': self.config.get('notifserver.host'), 'port': self.config.get('notifserver.port')} except OperationFailure, e: logger.error('Could not create mapping: %s' % str(e)) return False
def create_client_queue(self, username): self.channel_info = {} self.channel_info['exchange_name'] = username self.channel_info['queue_name'] = new_token() # Create a unique client id to also be used as the name of the queue client_queue_name = new_token() logger.info("Creating queue %s for user %s", self.channel_info.get('queue_name'), self.channel_info.get('exchange_name')) # Create the user exchange (if it doesn't already exist) and a client # queue with the generated name. conn = self._get_blocking_amqp_conn() try: channel = conn.channel() logger.debug("Declaring exchange %s", self.channel_info.get('exchange_name')) channel.exchange_declare( exchange=self.channel_info.get('exchange_name'), durable=True, type='fanout', ) logger.debug("Declaring queue %s", client_queue_name) channel.queue_declare(queue=client_queue_name, durable=True) logger.debug("Binding queue %s to exchange %s", client_queue_name, self.channel_info.get('exchange_name'), ) channel.queue_bind( exchange=self.channel_info.get('exchange_name'), queue=client_queue_name, ) except Exception, e: logger.error("Error creating new client queue. %s" % e.message) raise NotifStorageException('Cannot create new client')
def on_open(self, connection): logger.info("Connected to RabbitMQ") self.is_connected = True self.connection = connection