def handle(self, verbosity, **options): # If this is just a count request the just calculate, report and exit. if options['count']: queued = models.QueuedMessage.objects.non_deferred().count() deferred = models.QueuedMessage.objects.deferred().count() sys.stdout.write('%s queued message%s (and %s deferred message%s).' '\n' % (queued, queued != 1 and 's' or '', deferred, deferred != 1 and 's' or '')) sys.exit() # Send logged messages to the console. logger = logging.getLogger('django_yubin') handler = create_handler(verbosity) logger.addHandler(handler) # if PAUSE_SEND is turned on don't do anything. if not settings.PAUSE_SEND: send_all(options['block_size'], backend=settings.USE_BACKEND, message_limit=options['message_limit']) else: logger = logging.getLogger('django_yubin.commands.send_mail') logger.warning("Sending is paused, exiting without sending " "queued mail.") logger.removeHandler(handler) # Stop superfluous "unexpected EOF on client connection" errors in # Postgres log files caused by the database connection not being # explicitly closed. connection.close()
def test_send_all_non_empty_queue(self): msg = mail.EmailMessage('subject', 'body', '*****@*****.**', ['*****@*****.**']) queue_email_message(msg) engine.send_all() self.output.seek(0) self.assertEqual(self.output.readlines()[-1].strip()[-8:], 'seconds.')
def handle_noargs(self, verbosity, block_size, count, **options): # If this is just a count request the just calculate, report and exit. if count: queued = models.QueuedMessage.objects.non_deferred().count() deferred = models.QueuedMessage.objects.deferred().count() sys.stdout.write('%s queued message%s (and %s deferred message%s).' '\n' % (queued, queued != 1 and 's' or '', deferred, deferred != 1 and 's' or '')) sys.exit() # Send logged messages to the console. logger = logging.getLogger('django_yubin') handler = create_handler(verbosity) logger.addHandler(handler) # if PAUSE_SEND is turned on don't do anything. if not settings.PAUSE_SEND: if EMAIL_BACKEND_SUPPORT: send_all(block_size, backend=settings.USE_BACKEND) else: send_all(block_size) else: logger = logging.getLogger('django_yubin.commands.send_mail') logger.warning("Sending is paused, exiting without sending " "queued mail.") logger.removeHandler(handler) # Stop superfluous "unexpected EOF on client connection" errors in # Postgres log files caused by the database connection not being # explicitly closed. connection.close()
def test_locked(self): # Acquire the lock so that send_all will fail. engine.send_all() self.output.seek(0) self.assertEqual(self.output.readlines()[-1].strip(), 'Lock already in place. Exiting.') # Try with a timeout. settings.LOCK_WAIT_TIMEOUT = .1 engine.send_all() self.output.seek(0) self.assertEqual(self.output.readlines()[-1].strip(), 'Waiting for the lock timed out. Exiting.')
def queue_email_message(email_message, fail_silently=False, priority=None): """ Add new messages to the email queue. The ``email_message`` argument should be an instance of Django's core mail ``EmailMessage`` class. The messages can be assigned a priority in the queue by using the ``priority`` argument. The ``fail_silently`` argument is not used and is only provided to match the signature of the ``EmailMessage.send`` function which it may emulate (see ``queue_django_mail``). """ from django_yubin import constants, models, settings if constants.PRIORITY_HEADER in email_message.extra_headers: priority = email_message.extra_headers.pop(constants.PRIORITY_HEADER) priority = constants.PRIORITIES.get(priority.lower()) if settings.MAILER_TEST_MODE and settings.MAILER_TEST_EMAIL: email_message = set_message_test_mode(email_message, settings.MAILER_TEST_EMAIL) if priority == constants.PRIORITY_NOW_NOT_QUEUED: from django.core.mail import get_connection from django_yubin.engine import send_message connection = get_connection(backend=settings.USE_BACKEND) result = send_message(email_message, smtp_connection=connection) return (result == constants.RESULT_SENT) count = 0 for to_email in email_message.recipients(): message = models.Message.objects.create( to_address=to_email, from_address=email_message.from_email, subject=email_message.subject, encoded_message=email_message.message().as_string()) queued_message = models.QueuedMessage(message=message) if priority: queued_message.priority = priority queued_message.save() count += 1 if priority == constants.PRIORITY_NOW: from django_yubin.engine import send_all messages = [queued_message] send_all(backend=settings.USE_BACKEND, messages=messages) return count
def handle(self, verbosity, **options): # If this is just a count request the just calculate, report and exit. if options['count']: queued = models.QueuedMessage.objects.non_deferred().count() deferred = models.QueuedMessage.objects.deferred().count() sys.stdout.write('%s queued message%s (and %s deferred message%s).' '\n' % (queued, queued != 1 and 's' or '', deferred, deferred != 1 and 's' or '')) sys.exit() send_all(options['block_size'], backend=settings.USE_BACKEND, message_limit=options['message_limit']) # Stop superfluous "unexpected EOF on client connection" errors in # Postgres log files caused by the database connection not being # explicitly closed. connection.close()
def test_locked_timeoutbug(self): # We want to emulate the lock acquiring taking no time, so the next # three calls to time.time() always return 0 (then set it back to the # real function). original_time = time.time global time_call_count time_call_count = 0 def fake_time(): global time_call_count time_call_count = time_call_count + 1 if time_call_count >= 3: time.time = original_time return 0 time.time = fake_time try: engine.send_all() self.output.seek(0) self.assertEqual(self.output.readlines()[-1].strip(), 'Lock already in place. Exiting.') finally: time.time = original_time
def test_send_all_empty_queue(self): engine.send_all() self.output.seek(0) self.assertEqual(self.output.readlines()[2].strip(), 'No messages in queue.')