def test_oversize_protections(): # first just make an oversize limited queue overq = queue.Queue("run/queue", pop_limit=10) overq.clear() for i in range(5): overq.push("HELLO" * 100) assert_equal(overq.count(), 5) key, msg = overq.pop() assert not key and not msg, "Should get no messages." assert_equal(overq.count(), 0) # now make sure that oversize mail is moved to the overq setup() overq = queue.Queue("run/queue", pop_limit=10, oversize_dir="run/big_queue") moveq = queue.Queue("run/big_queue") for i in range(5): overq.push("HELLO" * 100) key, msg = overq.pop() assert not key and not msg, "Should get no messages." assert_equal(overq.count(), 0) assert_equal(moveq.count(), 5) moveq.clear() overq.clear()
def queue_command(pop=False, get=False, keys=False, remove=False, count=False, clear=False, name="run/queue"): """ Let's you do most of the operations available to a queue. lamson queue (-pop | -get | -remove | -count | -clear | -keys) -name run/queue """ print "Using queue: %r" % name inq = queue.Queue(name) if pop: key, msg = inq.pop() if key: print "KEY: ", key print msg elif get: print inq.get(get) elif remove: inq.remove(remove) elif count: print "Queue %s contains %d messages" % (name, inq.count()) elif clear: inq.clear() elif keys: print "\n".join(inq.keys()) else: print "Give something to do. Try lamson help -for queue to find out what." sys.exit(1) return # for unit tests mocking sys.exit
def start(self, one_shot=False): """ Start simply loops indefinitely sleeping and pulling messages off for processing when they are available. If you give one_shot=True it will run once rather than do a big while loop with a sleep. """ logging.info("Queue receiver started on queue dir %s" % (self.queue_dir)) logging.debug("Sleeping for %d seconds..." % self.sleep) inq = queue.Queue(self.queue_dir) while True: keys = inq.keys() for key in keys: msg = inq.get(key) if msg: logging.debug("Pulled message with key: %r off", key) self.process_message(msg) logging.debug("Removed %r key from queue.", key) inq.remove(key) if one_shot: return else: time.sleep(self.sleep)
def POSTING(message, post_name=None, host=None, action=None): name, address = parseaddr(message['from']) if not action: post.post(post_name, address, host, message) msg = view.respond(locals(), 'mail/page_ready.msg', From="noreply@%(host)s", To=message['from'], Subject="Your page '%(post_name)s' is ready.") relay.deliver(msg) # first real message, now we can index it index_q = queue.Queue("run/posts") index_q.push(message) elif action == "delete": post.delete(post_name, address) msg = view.respond(locals(), 'mail/deleted.msg', From="noreply@%(host)s", To=message['from'], Subject="Your page '%(post_name)s' was deleted.") relay.deliver(msg) else: logging.debug("Invalid action: %r", action) return POSTING
def START(message, to=None, host=None): """ @stateless and routes however handlers.log.START routes (everything). Has @nolocking, but that's alright since it's just writing to a maildir. """ q = queue.Queue('run/queue') q.push(message)
def __init__(self, queue_dir, sleep=10, size_limit=0, oversize_dir=None): """ The router should be fully configured and ready to work, the queue_dir can be a fully qualified path or relative. """ self.queue = queue.Queue(queue_dir, pop_limit=size_limit, oversize_dir=oversize_dir) self.queue_dir = queue_dir self.sleep = sleep
def enqueue(list_name, message): qpath = store_path(list_name, 'queue') pending = queue.Queue(qpath, safe=True) white_list_cleanse(message) key = pending.push(message) fix_permissions(qpath) update_json(list_name, key, message) return key
def test_queue_receiver(): receiver = server.QueueReceiver('run/queue') run_queue = queue.Queue('run/queue') run_queue.push(str(test_mail_response_plain_text())) assert run_queue.count() > 0 receiver.start(one_shot=True) assert run_queue.count() == 0 routing.Router.deliver.side_effect = raises_exception receiver.process_message(mail.MailRequest('localhost', 'test@localhost', 'test@localhost', 'Fake body.'))
def __init__(self, pending_queue, storage): """ The pending_queue should be a string with the path to the lamson.queue.Queue that will store pending messages. These messages are the originals the user sent when they tried to confirm. Storage should be something that is like ConfirmationStorage so that this can store things for later verification. """ self.pending = queue.Queue(pending_queue) self.storage = storage
def START(message, to=None, host=None): q = queue.Queue(spampot.pathOfQueue) ''' lamson has been found missing delivering mails to recipients in 'cc' and 'bcc'. Upto this point, lamson perfectly determines recipients combining 'to' and 'host' variables but always pushes 'message' in queue. The issue is, 'message' contains just the original 'To' recipent. Hence, though lamson successfully determines 'cc'/'bcc', the 'message' misses that. Using following dirty regex, 'To' field is replaced with next 'cc'/'bcc' recipient with each iteration. If, including 'To', there are 4 recipient in 'cc'/'bcc', total 5 mails would be pushed in queue. ''' email = "%s@%s" % (to, host) message = str(message).replace("%", "%%") new_msg = re.sub(r'(?m)^\To:.*\n?', 'To: %s\n', message, 1) % (email, ) q.push(new_msg)
def test_push(): q = queue.Queue("run/queue", safe=USE_SAFE) q.clear() # the queue doesn't really care if its a request or response, as long # as the object answers to str(msg) msg = mail.MailResponse(To="test@localhost", From="test@localhost", Subject="Test", Body="Test") key = q.push(msg) assert key, "Didn't get a key for test_get push." return q
def test_ConfirmationEngine_send(): queue.Queue('run/queue').clear() engine.clear() list_name = 'testing' action = 'subscribing to' host = 'localhost' message = mail.MailRequest('fakepeer', 'somedude@localhost', 'testing-subscribe@localhost', 'Fake body.') engine.send(relay(port=8899), 'testing', message, 'confirmation.msg', locals()) confirm = delivered('confirm') assert delivered('somedude', to_queue=engine.pending) assert confirm return confirm
def _settings_loader(): from lamson.routing import Router from lamson.server import Relay, SMTPReceiver from lamson import view, queue import logging import logging.config import jinja2 settings = Settings() for attr_name in dir(django_settings): if attr_name.startswith("LAMSON_"): setattr(settings, attr_name.split("LAMSON_")[1].lower(), getattr(django_settings, attr_name)) #logging.config.fileConfig("logging.conf") # the relay host to actually send the final message to #TODO make debug a parameter to the command if hasattr(settings, 'relay_config'): settings.relay = Relay(host=settings.relay_config['host'], port=settings.relay_config['port'], debug=1) # where to listen for incoming messages settings.receiver = SMTPReceiver(settings.receiver_config['host'], settings.receiver_config['port']) Router.defaults(**settings.router_defaults) Router.load(settings.handlers) #TODO make this a parameter to the command Router.RELOAD = True #TODO make run a parameter to the command Router.UNDELIVERABLE_QUEUE = queue.Queue("run/undeliverable") if hasattr(settings, 'template_config'): view.LOADER = jinja2.Environment( loader=jinja2.PackageLoader(settings.template_config['dir'], settings.template_config['module'])) return settings
def enqueue_as_spam(self, message): """Drops the message into the configured spam queue.""" outq = queue.Queue(self.spam_queue) outq.push(str(message))
def SPAMMING(message, **options): spam = queue.Queue(SPAM['queue']) spam.push(message) return SPAMMING
def archive_bounce(message): qu = queue.Queue(settings.BOUNCE_ARCHIVE) qu.push(message)
from config import settings from lamson.routing import Router from lamson.server import Relay, SMTPReceiver, QueueReceiver from lamson import view, queue import logging import logging.config import jinja2 logging.config.fileConfig("config/logging.conf") # the relay host to actually send the final message to settings.relay = Relay(host=settings.relay_config['host'], port=settings.relay_config['port'], debug=1) # where to listen for incoming messages #settings.receiver = SMTPReceiver(settings.receiver_config['host'], # settings.receiver_config['port']) # b0nd - include the maildir option we've set in settings.py settings.receiver = QueueReceiver(settings.receiver_config['maildir']) Router.defaults(**settings.router_defaults) Router.load(settings.handlers) Router.RELOAD = True Router.UNDELIVERABLE_QUEUE = queue.Queue("run/undeliverable") view.LOADER = jinja2.Environment(loader=jinja2.PackageLoader( settings.template_config['dir'], settings.template_config['module']))
def get_user_post_queue(user_dir): queue_dir = "%s/posts_queue" % (user_dir) return queue.Queue(queue_dir)
def IGNORE_BOUNCE(message): bounces = queue.Queue(BOUNCES) bounces.push(message) return START
def defer_to_queue(message): index_q = queue.Queue("run/posts") # use a diff queue? index_q.push(message) print "run/posts count after dever", index_q.count()