def monitor_queues(self, queues, all_bindings):
for queue_data in queues:
# Updating the queue's information in the database (owner, size).
queue = self.update_queue_information(queue_data, all_bindings)
if not queue:
continue
# If a queue is over the deletion size and ``unbounded`` is
# False (the default), then delete it regardless of it having
# an owner or not
# If ``unbounded`` is True, then let it grow indefinitely.
if queue.size > self.del_queue_size and not queue.unbounded:
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Deleting queue.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
if queue.owner and queue.owner.owners:
self.deletion_email(queue.owner.owners, queue_data)
if self.on_delete:
self.on_delete(queue.name)
pulse_management.delete_queue(vhost=queue_data['vhost'],
queue=queue.name)
db_session.delete(queue)
db_session.commit()
continue
if queue.owner is None or not queue.owner.owners:
continue
if queue.size > self.warn_queue_size and not queue.warned:
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Queue-size warning.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
queue.warned = True
if self.on_warn:
self.on_warn(queue.name)
self.warning_email(queue.owner.owners, queue_data)
elif queue.size <= self.warn_queue_size and queue.warned:
# A previously warned queue got out of the warning threshold;
# its owner should not be warned again.
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Queue-size recovered.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
queue.warned = False
self.back_to_normal_email(queue.owner.owners, queue_data)
# Commit any changes to the queue.
db_session.add(queue)
db_session.commit()
def test_user(self):
user = User.new_user(email='*****@*****.**', admin=False)
db_session.add(user)
db_session.commit()
rabbitmq_account = RabbitMQAccount.new_user(username='******',
password='******',
owners=user,
create_rabbitmq_user=False)
db_session.add(rabbitmq_account)
db_session.commit()
self.assertTrue(user in User.query.all())
# Emails are normalized by putting them lower-case
self.assertEqual(
User.query.filter(User.email == '*****@*****.**').first(), user)
self.assertEqual(
RabbitMQAccount.query.filter(
RabbitMQAccount.username == 'dummy').first(),
rabbitmq_account)
self.assertEqual(
RabbitMQAccount.query.filter(
RabbitMQAccount.username == 'DUMMY').first(),
None)
def setUp(self):
global pulse_cfg
self.proc = None
self.publisher = None
self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE,
del_queue_size=TEST_DELETE_SIZE,
emails=False)
dbinit.init_and_clear_db()
self.consumer_cfg = pulse_cfg.copy()
self.consumer_cfg['applabel'] = str(uuid.uuid1())
# Configure/create the test user to be used for message consumption.
self.consumer_cfg['user'] = CONSUMER_USER
self.consumer_cfg['password'] = CONSUMER_PASSWORD
self.user = User.new_user(email=CONSUMER_EMAIL, admin=False)
db_session.add(self.user)
db_session.commit()
self.pulse_user = PulseUser.new_user(username=CONSUMER_USER,
password=CONSUMER_PASSWORD,
owner=self.user)
db_session.add(self.pulse_user)
db_session.commit()
def update_queue_information(self, queue_data):
if not 'messages' in queue_data:
# FIXME: We should do something here, probably delete the queue,
# as it's in a weird state. More investigation is required.
# See bug 1066338.
return None
q_size, q_name, q_durable = (queue_data['messages'],
queue_data['name'], queue_data['durable'])
queue = Queue.query.filter(Queue.name == q_name).first()
# If the queue doesn't exist in the db, create it.
if queue is None:
m = re.match('queue/([^/]+)/', q_name)
logging.info("New queue '{0}' encountered. "
"Adding to the database.".format(q_name))
if m:
owner_name = m.group(1)
owner = PulseUser.query.filter(
PulseUser.username == owner_name).first()
# If the queue was created by a user that isn't in the
# pulseguardian database, skip the queue.
if owner is None:
logging.info(
"Queue '{0}' owner, {1}, isn't in the db. Creating "
"the user.".format(q_name, owner_name))
owner = PulseUser.new_user(owner_name)
# Assign the user to the queue.
logging.info("Assigning queue '{0}' to user "
"{1}.".format(q_name, owner))
else:
logging.warn(
"'{0}' is not a standard queue name.".format(q_name))
owner = None
queue = Queue(name=q_name, owner=owner)
# add the queue bindings to the db.
bindings = pulse_management.queue_bindings(config.rabbit_vhost,
queue.name)
for binding in bindings:
db_binding = Binding.query.filter(
Binding.exchange == binding["source"],
Binding.routing_key == binding["routing_key"],
Binding.queue_name == queue.name).first()
if not db_binding:
# need to create the binding in the DB
binding = Binding(exchange=binding["source"],
routing_key=binding["routing_key"],
queue_name=queue.name)
db_session.add(binding)
# Update the saved queue size.
queue.size = q_size
queue.durable = q_durable
db_session.add(queue)
db_session.commit()
return queue
def setUp(self):
global pulse_cfg
self.proc = None
self.publisher = None
self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE,
del_queue_size=TEST_DELETE_SIZE,
emails=False)
dbinit.init_and_clear_db()
self.consumer_cfg = pulse_cfg.copy()
self.consumer_cfg['applabel'] = str(uuid.uuid1())
# Configure/create the test user to be used for message consumption.
self.consumer_cfg['user'] = CONSUMER_USER
self.consumer_cfg['password'] = CONSUMER_PASSWORD
self.user = User.new_user(email=CONSUMER_EMAIL, admin=False)
# As a default owner for rabbitmq_account in some tests where an owner
# is not provided.
self.admin = User.new_user(email=ADMIN_EMAIL, admin=True)
db_session.add(self.user)
db_session.commit()
self.rabbitmq_account = RabbitMQAccount.new_user(
username=CONSUMER_USER,
password=CONSUMER_PASSWORD,
owners=self.user)
db_session.add(self.rabbitmq_account)
db_session.commit()
def setUp(self):
global pulse_cfg
self.proc = None
self.publisher = None
self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE,
del_queue_size=TEST_DELETE_SIZE,
emails=False)
dbinit.init_and_clear_db()
self.consumer_cfg = pulse_cfg.copy()
self.consumer_cfg['applabel'] = str(uuid.uuid1())
# Configure/create the test user to be used for message consumption.
self.consumer_cfg['user'] = CONSUMER_USER
self.consumer_cfg['password'] = CONSUMER_PASSWORD
self.user = User.new_user(email=CONSUMER_EMAIL, admin=False)
# As a default owner for pulse_user in some tests where an owner is not
# provided.
self.admin = User.new_user(email=ADMIN_EMAIL, admin=True)
db_session.add(self.user)
db_session.commit()
self.pulse_user = PulseUser.new_user(
username=CONSUMER_USER,
password=CONSUMER_PASSWORD,
owners=self.user)
db_session.add(self.pulse_user)
db_session.commit()
def monitor_queues(self, queues, all_bindings):
for queue_data in queues:
# Updating the queue's information in the database (owner, size).
queue = self.update_queue_information(queue_data, all_bindings)
if not queue:
continue
# If a queue is over the deletion size and ``unbounded`` is
# False (the default), then delete it regardless of it having
# an owner or not
# If ``unbounded`` is True, then let it grow indefinitely.
if queue.size > self.del_queue_size and not queue.unbounded:
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Deleting queue.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
if queue.owner and queue.owner.owners:
self.deletion_email(queue.owner.owners, queue_data)
if self.on_delete:
self.on_delete(queue.name)
pulse_management.delete_queue(vhost=queue_data['vhost'],
queue=queue.name)
db_session.delete(queue)
db_session.commit()
continue
if queue.owner is None or not queue.owner.owners:
continue
if queue.size > self.warn_queue_size and not queue.warned:
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Queue-size warning.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
queue.warned = True
if self.on_warn:
self.on_warn(queue.name)
self.warning_email(queue.owner.owners, queue_data)
elif queue.size <= self.warn_queue_size and queue.warned:
# A previously warned queue got out of the warning threshold;
# its owner should not be warned again.
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'Queue-size recovered.',
details=self._queue_details_dict(queue),
tags=['queue'],
)
queue.warned = False
self.back_to_normal_email(queue.owner.owners, queue_data)
# Commit any changes to the queue.
db_session.add(queue)
db_session.commit()
def new_user(email_address, admin=False):
"""Initializes a new user, generating a salt and encrypting
his password. Then creates a RabbitMQ user if needed and sets
permissions.
"""
email = Email.get_email(email_address)
user = User(email=email, admin=admin)
db_session.add(user)
db_session.commit()
return user
def test_user_set_admin(self):
user = User.new_user(email='*****@*****.**', admin=False)
db_session.add(user)
db_session.commit()
user = User.query.filter(User.email == '*****@*****.**').first()
user.set_admin(True)
userDb = User.query.filter(User.email == '*****@*****.**').first()
self.assertTrue(userDb.admin)
def test_user_set_admin(self):
user = User.new_user(email='*****@*****.**', admin=False)
db_session.add(user)
db_session.commit()
user = User.query.filter(User.email == '*****@*****.**').first()
user.set_admin(True)
userDb = User.query.filter(User.email == '*****@*****.**').first()
self.assertTrue(userDb.admin)
def new_user(email, admin=False):
"""Initializes a new user, generating a salt and encrypting
his password. Then creates a RabbitMQ user if needed and sets
permissions.
"""
email = email.lower()
user = User(email=email, admin=admin)
db_session.add(user)
db_session.commit()
return user
def change_password(self, new_password):
""""Changes" a user's password by deleting his rabbitmq account
and recreating it with the new password.
"""
try:
pulse_management.delete_user(self.username)
except pulse_management.PulseManagementException:
pass
self._create_user(new_password)
self._set_permissions()
db_session.add(self)
db_session.commit()
def change_password(self, new_password):
""""Changes" a user's password by deleting his rabbitmq account
and recreating it with the new password.
"""
try:
pulse_management.delete_user(self.username)
except pulse_management.PulseManagementException:
pass
self._create_user(new_password)
self._set_permissions()
db_session.add(self)
db_session.commit()
def dummy_data():
# Dummy test users
User.new_user(email='*****@*****.**')
users = User.query.all()
for i in xrange(4):
PulseUser.new_user(
username='******'.format(i),
password='******',
owner=users[0])
pulse_users = PulseUser.query.all()
# And some dummy queues
dummy_queue = Queue(name='dummy-empty-queue', size=0, owner=pulse_users[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-non-empty-queue', size=config.warn_queue_size/5, owner=pulse_users[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-warning-queue', size=config.warn_queue_size + 1, owner=pulse_users[1])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-deletion-queue', size=int(config.del_queue_size * 1.2), owner=pulse_users[2])
db_session.add(dummy_queue)
db_session.commit()
# Test admin user
User.new_user(email='*****@*****.**', admin=True)
logger.info('Finished generating dummy data.')
def dummy_data():
# Dummy test users
User.new_user(email='*****@*****.**')
users = User.query.all()
for i in xrange(4):
RabbitMQAccount.new_user(
username='******'.format(i),
password='******',
owners=users[0])
rabbitmq_accounts = RabbitMQAccount.query.all()
# And some dummy queues
dummy_queue = Queue(name='dummy-empty-queue', size=0, owner=rabbitmq_accounts[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-non-empty-queue', size=config.warn_queue_size/5, owner=rabbitmq_accounts[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-warning-queue', size=config.warn_queue_size + 1, owner=rabbitmq_accounts[1])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-deletion-queue', size=int(config.del_queue_size * 1.2), owner=rabbitmq_accounts[2])
db_session.add(dummy_queue)
db_session.commit()
# Test admin user
User.new_user(email='*****@*****.**', admin=True)
logger.info('Finished generating dummy data.')
def dummy_data():
# Dummy test users
User.new_user('*****@*****.**')
for i in xrange(4):
PulseUser.new_user(
username='******'.format(i),
password='******',
owner=User.query.first(),
management_api=pulse_management)
pulse_users = PulseUser.query.all()
# And some dummy queues
dummy_queue = Queue(name='dummy-empty-queue', size=0, owner=pulse_users[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-non-empty-queue', size=config.warn_queue_size/5, owner=pulse_users[0])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-warning-queue', size=config.warn_queue_size + 1, owner=pulse_users[1])
db_session.add(dummy_queue)
db_session.commit()
dummy_queue = Queue(name='dummy-deletion-queue', size=int(config.del_queue_size * 1.2), owner=pulse_users[2])
db_session.add(dummy_queue)
db_session.commit()
# Test admin user
User.new_user('*****@*****.**', admin=True)
logger.info('Finished generating dummy data.')
def change_password(self, new_password, management_api):
""""Changes" a user's password by deleting his rabbitmq account
and recreating it with the new password.
"""
try:
management_api.delete_user(self.username)
except management_api.exception:
pass
self._create_user(management_api, new_password)
self._set_permissions(management_api)
db_session.add(self)
db_session.commit()
def monitor_queues(self, queues, all_bindings):
for queue_data in queues:
# Updating the queue's information in the database (owner, size).
queue = self.update_queue_information(queue_data, all_bindings)
if not queue:
continue
# If a queue is over the deletion size and ``unbounded`` is
# False (the default), then delete it regardless of it having
# an owner or not
# If ``unbounded`` is True, then let it grow indefinitely.
if queue.size > self.del_queue_size and not queue.unbounded:
logging.warning("Queue '{0}' deleted. Queue size = {1}; "
"del_queue_size = {2}".format(
queue.name, queue.size, self.del_queue_size))
if queue.owner and queue.owner.owners:
self.deletion_email(queue.owner.owners, queue_data)
if self.on_delete:
self.on_delete(queue.name)
pulse_management.delete_queue(vhost=queue_data['vhost'],
queue=queue.name)
db_session.delete(queue)
db_session.commit()
continue
if queue.owner is None or not queue.owner.owners:
continue
if queue.size > self.warn_queue_size and not queue.warned:
logging.warning("Warning queue '{0}' owner. Queue size = "
"{1}; warn_queue_size = {2}".format(
queue.name, queue.size,
self.warn_queue_size))
queue.warned = True
if self.on_warn:
self.on_warn(queue.name)
self.warning_email(queue.owner.owners, queue_data)
elif queue.size <= self.warn_queue_size and queue.warned:
# A previously warned queue got out of the warning threshold;
# its owner should not be warned again.
logging.warning("Queue '{0}' was in warning zone but is OK "
"now".format(queue.name, queue.size,
self.del_queue_size))
queue.warned = False
self.back_to_normal_email(queue.owner.owners, queue_data)
# Commit any changes to the queue.
db_session.add(queue)
db_session.commit()
def new_user(username, password='', owner=None, management_api=None):
"""Initializes a new user, generating a salt and encrypting
his password. Then creates a RabbitMQ user if needed and sets
permissions.
"""
pulse_user = PulseUser(owner=owner, username=username)
if management_api is not None:
pulse_user._create_user(management_api, password)
pulse_user._set_permissions(management_api)
db_session.add(pulse_user)
db_session.commit()
return pulse_user
def monitor_queues(self, queues):
for queue_data in queues:
# Updating the queue's information in the database (owner, size).
queue = self.update_queue_information(queue_data)
if not queue:
continue
# If a queue is over the deletion size, regardless of it having an
# owner or not, delete it.
if queue.size > self.del_queue_size:
logging.warning("Queue '{0}' deleted. Queue size = {1}; "
"del_queue_size = {2}".format(
queue.name, queue.size,
self.del_queue_size))
if queue.owner and queue.owner.owner:
self.deletion_email(queue.owner.owner, queue_data)
if self.on_delete:
self.on_delete(queue.name)
pulse_management.delete_queue(vhost=queue_data['vhost'],
queue=queue.name)
db_session.delete(queue)
db_session.commit()
continue
if queue.owner is None or queue.owner.owner is None:
continue
if queue.size > self.warn_queue_size and not queue.warned:
logging.warning("Warning queue '{0}' owner. Queue size = "
"{1}; warn_queue_size = {2}".format(
queue.name, queue.size,
self.warn_queue_size))
queue.warned = True
if self.on_warn:
self.on_warn(queue.name)
self.warning_email(queue.owner.owner, queue_data)
elif queue.size <= self.warn_queue_size and queue.warned:
# A previously warned queue got out of the warning threshold;
# its owner should not be warned again.
logging.warning("Queue '{0}' was in warning zone but is OK "
"now".format(queue.name, queue.size,
self.del_queue_size))
queue.warned = False
self.back_to_normal_email(queue.owner.owner, queue_data)
# Commit any changes to the queue.
db_session.add(queue)
db_session.commit()
def monitor_queues(self, queues):
for queue_data in queues:
# Updating the queue's information in the database (owner, size).
queue = self.update_queue_information(queue_data)
if not queue:
continue
# If a queue is over the deletion size, regardless of it having an
# owner or not, delete it.
if queue.size > self.del_queue_size:
logging.warning(
"Queue '{0}' deleted. Queue size = {1}; "
"del_queue_size = {2}".format(queue.name, queue.size, self.del_queue_size)
)
if queue.owner and queue.owner.owner:
self.deletion_email(queue.owner.owner, queue_data)
if self.on_delete:
self.on_delete(queue.name)
self.api.delete_queue(vhost=queue_data["vhost"], queue=queue.name)
db_session.delete(queue)
db_session.commit()
continue
if queue.owner is None or queue.owner.owner is None:
continue
if queue.size > self.warn_queue_size and not queue.warned:
logging.warning(
"Warning queue '{0}' owner. Queue size = "
"{1}; warn_queue_size = {2}".format(queue.name, queue.size, self.warn_queue_size)
)
queue.warned = True
if self.on_warn:
self.on_warn(queue.name)
self.warning_email(queue.owner.owner, queue_data)
elif queue.size <= self.warn_queue_size and queue.warned:
# A previously warned queue got out of the warning threshold;
# its owner should not be warned again.
logging.warning(
"Queue '{0}' was in warning zone but is OK "
"now".format(queue.name, queue.size, self.del_queue_size)
)
queue.warned = False
self.back_to_normal_email(queue.owner.owner, queue_data)
# Commit any changes to the queue.
db_session.add(queue)
db_session.commit()
def new_user(username, password='', owner=None, create_rabbitmq_user=True):
"""Initializes a new user, generating a salt and encrypting
his password. Then creates a RabbitMQ user if needed and sets
permissions.
:param create_rabbitmq_user: Whether to add this user to the rabbitmq
server via the management plugin. Used by tests.
"""
pulse_user = PulseUser(owner=owner, username=username)
if create_rabbitmq_user:
pulse_user._create_user(password)
pulse_user._set_permissions()
db_session.add(pulse_user)
db_session.commit()
return pulse_user
def new_user(username, password='', owner=None, create_rabbitmq_user=True):
"""Initializes a new user, generating a salt and encrypting
his password. Then creates a RabbitMQ user if needed and sets
permissions.
:param create_rabbitmq_user: Whether to add this user to the rabbitmq
server via the management plugin. Used by tests.
"""
pulse_user = PulseUser(owner=owner, username=username)
if create_rabbitmq_user:
pulse_user._create_user(password)
pulse_user._set_permissions()
db_session.add(pulse_user)
db_session.commit()
return pulse_user
def new_user(username, password='', owners=None, create_rabbitmq_user=True):
"""Initializes a new account object, generating a salt and encrypting
its password. Then creates a RabbitMQ user if needed and sets
permissions.
:param create_rabbitmq_user: Whether to add this user to the rabbitmq
server via the management plugin. Used by tests.
"""
# Ensure that ``owners`` is a list.
if owners and not isinstance(owners, list):
owners = [owners]
rabbitmq_account = RabbitMQAccount(owners=owners, username=username)
if create_rabbitmq_user:
rabbitmq_account._create_user(password)
rabbitmq_account._set_permissions()
db_session.add(rabbitmq_account)
db_session.commit()
return rabbitmq_account
def setUp(self):
global pulse_cfg
self.proc = None
self.publisher = None
self.management_api = PulseManagementAPI(
management_url='http://{}:{}/api'.format(
pulse_cfg['host'], pulse_cfg['management_port']),
user=pulse_cfg['user'],
password=pulse_cfg['password']
)
self.guardian = PulseGuardian(self.management_api,
warn_queue_size=TEST_WARN_SIZE,
del_queue_size=TEST_DELETE_SIZE,
emails=False)
# Hack in a test config.
dbinit.pulse_management = self.management_api
dbinit.init_and_clear_db()
self.consumer_cfg = pulse_cfg.copy()
self.consumer_cfg['applabel'] = str(uuid.uuid1())
# Configure/create the test user to be used for message consumption.
self.consumer_cfg['user'] = CONSUMER_USER
self.consumer_cfg['password'] = CONSUMER_PASSWORD
self.user = User.new_user(email=CONSUMER_EMAIL, admin=False)
db_session.add(self.user)
db_session.commit()
self.pulse_user = PulseUser.new_user(
username=CONSUMER_USER,
password=CONSUMER_PASSWORD,
owner=self.user,
management_api=self.management_api)
db_session.add(self.pulse_user)
db_session.commit()
def update_queue_information(self, queue_data):
if not "messages" in queue_data:
# FIXME: We should do something here, probably delete the queue,
# as it's in a weird state. More investigation is required.
# See bug 1066338.
return None
q_size, q_name, q_durable = (queue_data["messages"], queue_data["name"], queue_data["durable"])
queue = Queue.query.filter(Queue.name == q_name).first()
# If the queue doesn't exist in the db, create it.
if queue is None:
m = re.match("queue/([^/]+)/", q_name)
logging.info("New queue '{0}' encountered. " "Adding to the database.".format(q_name))
if m:
owner_name = m.group(1)
owner = PulseUser.query.filter(PulseUser.username == owner_name).first()
# If the queue was created by a user that isn't in the
# pulseguardian database, skip the queue.
if owner is None:
logging.info(
"Queue '{0}' owner, {1}, isn't in the db. Creating " "the user.".format(q_name, owner_name)
)
owner = PulseUser.new_user(owner_name)
# Assign the user to the queue.
logging.info("Assigning queue '{0}' to user " "{1}.".format(q_name, owner))
else:
logging.warn("'{0}' is not a standard queue name.".format(q_name))
owner = None
queue = Queue(name=q_name, owner=owner)
# Update the saved queue size.
queue.size = q_size
queue.durable = q_durable
db_session.add(queue)
db_session.commit()
return queue
def test_user(self):
user = User.new_user(email='*****@*****.**', admin=False)
db_session.add(user)
db_session.commit()
pulse_user = PulseUser.new_user(username='******',
password='******',
owner=user,
management_api=None)
db_session.add(pulse_user)
db_session.commit()
self.assertTrue(user in User.query.all())
# Emails are normalized by putting them lower-case
self.assertEqual(
User.query.filter(User.email == '*****@*****.**').first(), user)
self.assertEqual(
PulseUser.query.filter(PulseUser.username == 'dummy').first(),
pulse_user)
self.assertEqual(
PulseUser.query.filter(PulseUser.username == 'DUMMY').first(),
None)
def test_user(self):
user = User.new_user(email='*****@*****.**', admin=False)
db_session.add(user)
db_session.commit()
rabbitmq_account = RabbitMQAccount.new_user(username='******',
password='******',
owners=user,
create_rabbitmq_user=False)
db_session.add(rabbitmq_account)
db_session.commit()
self.assertTrue(user in User.query.all())
# Emails are normalized by putting them lower-case
self.assertEqual(
User.query.filter(User.email == '*****@*****.**').first(), user)
self.assertEqual(
RabbitMQAccount.query.filter(
RabbitMQAccount.username == 'dummy').first(), rabbitmq_account)
self.assertEqual(
RabbitMQAccount.query.filter(
RabbitMQAccount.username == 'DUMMY').first(), None)
def update_queue_information(self, queue_data, all_bindings):
if not 'messages' in queue_data:
# FIXME: We should do something here, probably delete the queue,
# as it's in a weird state. More investigation is required.
# See bug 1066338.
return None
q_size, q_name, q_durable = (queue_data['messages'],
queue_data['name'],
queue_data['durable'])
queue = Queue.query.filter(Queue.name == q_name).first()
# If the queue doesn't exist in the db, create it.
if queue is None:
m = re.match('queue/([^/]+)/', q_name)
logging.debug("New queue '{0}' encountered. "
"Adding to the database.".format(q_name))
if m:
owner_name = m.group(1)
owner = PulseUser.query.filter(
PulseUser.username == owner_name).first()
# If the queue was created by a user that isn't in the
# pulseguardian database, skip the queue.
if owner is None:
logging.info(
"Queue '{0}' owner, {1}, isn't in the db. Creating "
"the user.".format(q_name, owner_name))
# PulseUser needs at least one owner as well, but since
# we have no way of knowing who really owns it, find the
# first admin, and set it to that.
user = User.query.filter(User.admin == True).first()
owner = PulseUser.new_user(owner_name, owners=user)
# Assign the user to the queue.
logging.debug("Assigning queue '{0}' to user "
"{1}.".format(q_name, owner))
else:
logging.warn("'{0}' is not a standard queue name.".format(
q_name))
owner = None
queue = Queue(name=q_name, owner=owner)
# add the queue bindings to the db.
bindings = self.get_queue_bindings(all_bindings, queue.name)
for binding in bindings:
db_binding = Binding.query.filter(
Binding.exchange == binding["source"],
Binding.routing_key == binding["routing_key"],
Binding.queue_name == queue.name
).first()
if not db_binding:
# need to create the binding in the DB
binding = Binding(exchange=binding["source"],
routing_key=binding["routing_key"],
queue_name=queue.name)
db_session.add(binding)
# Update the saved queue size.
queue.size = q_size
queue.durable = q_durable
db_session.add(queue)
db_session.commit()
return queue
def update_queue_information(self, queue_data, all_bindings):
if 'messages' not in queue_data:
# FIXME: We should do something here, probably delete the queue,
# as it's in a weird state. More investigation is required.
# See bug 1066338.
return None
q_size, q_name, q_durable = (queue_data['messages'],
queue_data['name'],
queue_data['durable'])
queue = Queue.query.filter(Queue.name == q_name).first()
# If the queue doesn't exist in the db, create it.
if queue is None:
log_details = {
'queuename': q_name,
'queuesize': q_size,
'queuedurable': q_durable,
}
m = re.match('queue/([^/]+)/', q_name)
if not m:
log_details['valid'] = False
owner = None
elif (config.reserved_users_regex and
re.match(config.reserved_users_regex, m.group(1))):
# Ignore this queue entirely as we will see it again on the
# next iteration.
return None
else:
log_details['valid'] = True
owner_name = m.group(1)
owner = RabbitMQAccount.query.filter(
RabbitMQAccount.username == owner_name).first()
log_details['ownername'] = owner_name
log_details['newowner'] = not owner
# If the queue belongs to a pulse user that isn't in the
# pulseguardian database, add the user to the DB, owned by an
# admin.
if owner is None:
# RabbitMQAccount needs at least one owner as well, but
# since we have no way of knowing who really owns it, find
# the first admin, and set it to that.
user = User.query.filter(User.admin == True).first()
owner = RabbitMQAccount.new_user(owner_name, owners=user)
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'New queue.',
details=log_details,
tags=['queue'],
)
queue = Queue(name=q_name, owner=owner)
# add the queue bindings to the db.
bindings = self.get_queue_bindings(all_bindings, queue.name)
for binding in bindings:
db_binding = Binding.query.filter(
Binding.exchange == binding["source"],
Binding.routing_key == binding["routing_key"],
Binding.queue_name == queue.name
).first()
if not db_binding:
# need to create the binding in the DB
binding = Binding(exchange=binding["source"],
routing_key=binding["routing_key"],
queue_name=queue.name)
db_session.add(binding)
# Update the saved queue size.
queue.size = q_size
queue.durable = q_durable
db_session.add(queue)
db_session.commit()
return queue
def update_queue_information(self, queue_data, all_bindings):
if 'messages' not in queue_data:
# FIXME: We should do something here, probably delete the queue,
# as it's in a weird state. More investigation is required.
# See bug 1066338.
return None
q_size, q_name, q_durable = (queue_data['messages'],
queue_data['name'], queue_data['durable'])
queue = Queue.query.filter(Queue.name == q_name).first()
# If the queue doesn't exist in the db, create it.
if queue is None:
log_details = {
'queuename': q_name,
'queuesize': q_size,
'queuedurable': q_durable,
}
m = re.match('queue/([^/]+)/', q_name)
if not m:
log_details['valid'] = False
owner = None
elif (config.reserved_users_regex
and re.match(config.reserved_users_regex, m.group(1))):
# Ignore this queue entirely as we will see it again on the
# next iteration.
return None
else:
log_details['valid'] = True
owner_name = m.group(1)
owner = RabbitMQAccount.query.filter(
RabbitMQAccount.username == owner_name).first()
log_details['ownername'] = owner_name
log_details['newowner'] = not owner
# If the queue belongs to a pulse user that isn't in the
# pulseguardian database, add the user to the DB, owned by an
# admin.
if owner is None:
# RabbitMQAccount needs at least one owner as well, but
# since we have no way of knowing who really owns it, find
# the first admin, and set it to that.
user = User.query.filter(User.admin == True).first()
owner = RabbitMQAccount.new_user(owner_name, owners=user)
mozdef.log(
mozdef.NOTICE,
mozdef.OTHER,
'New queue.',
details=log_details,
tags=['queue'],
)
queue = Queue(name=q_name, owner=owner)
# add the queue bindings to the db.
bindings = self.get_queue_bindings(all_bindings, queue.name)
for binding in bindings:
db_binding = Binding.query.filter(
Binding.exchange == binding["source"],
Binding.routing_key == binding["routing_key"],
Binding.queue_name == queue.name).first()
if not db_binding:
# need to create the binding in the DB
binding = Binding(exchange=binding["source"],
routing_key=binding["routing_key"],
queue_name=queue.name)
db_session.add(binding)
# Update the saved queue size.
queue.size = q_size
queue.durable = q_durable
db_session.add(queue)
db_session.commit()
return queue
def create_notification(queue, email):
queue_obj = Queue.query.filter(Queue.id==queue).first()
queue_obj.notifications.append(Email.get_email(email))
db_session.add(queue_obj)
db_session.commit()
