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
