diff options
Diffstat (limited to 'django/core/mail.py')
| -rw-r--r-- | django/core/mail.py | 220 |
1 files changed, 176 insertions, 44 deletions
diff --git a/django/core/mail.py b/django/core/mail.py index e7dcfb4132..8661d84287 100644 --- a/django/core/mail.py +++ b/django/core/mail.py @@ -1,14 +1,22 @@ -# Use this module for e-mailing. +""" +Tools for sending email. +""" from django.conf import settings from email.MIMEText import MIMEText from email.Header import Header from email.Utils import formatdate +from email import Charset +import os import smtplib import socket import time import random +# Don't BASE64-encode UTF-8 messages so that we avoid unwanted attention from +# some spam filters. +Charset.add_charset('utf-8', Charset.SHORTEST, Charset.QP, 'utf-8') + # Cache the hostname, but do it lazily: socket.getfqdn() can take a couple of # seconds, which slows down the restart of the server. class CachedDnsName(object): @@ -22,6 +30,28 @@ class CachedDnsName(object): DNS_NAME = CachedDnsName() +# Copied from Python standard library and modified to used the cached hostname +# for performance. +def make_msgid(idstring=None): + """Returns a string suitable for RFC 2822 compliant Message-ID, e.g: + + <20020201195627.33539.96671@nightshade.la.mastaler.com> + + Optional idstring if given is a string used to strengthen the + uniqueness of the message id. + """ + timeval = time.time() + utcdate = time.strftime('%Y%m%d%H%M%S', time.gmtime(timeval)) + pid = os.getpid() + randint = random.randrange(100000) + if idstring is None: + idstring = '' + else: + idstring = '.' + idstring + idhost = DNS_NAME + msgid = '<%s.%s.%s%s@%s>' % (utcdate, pid, randint, idstring, idhost) + return msgid + class BadHeaderError(ValueError): pass @@ -34,6 +64,131 @@ class SafeMIMEText(MIMEText): val = Header(val, settings.DEFAULT_CHARSET) MIMEText.__setitem__(self, name, val) +class SMTPConnection(object): + """ + A wrapper that manages the SMTP network connection. + """ + + def __init__(self, host=None, port=None, username=None, password=None, + use_tls=None, fail_silently=False): + self.host = host or settings.EMAIL_HOST + self.port = port or settings.EMAIL_PORT + self.username = username or settings.EMAIL_HOST_USER + self.password = password or settings.EMAIL_HOST_PASSWORD + self.use_tls = (use_tls is not None) and use_tls or settings.EMAIL_USE_TLS + self.fail_silently = fail_silently + self.connection = None + + def open(self): + """ + Ensure we have a connection to the email server. Returns whether or not + a new connection was required. + """ + if self.connection: + # Nothing to do if the connection is already open. + return False + try: + self.connection = smtplib.SMTP(self.host, self.port) + if self.use_tls: + self.connection.ehlo() + self.connection.starttls() + self.connection.ehlo() + if self.username and self.password: + self.connection.login(self.username, self.password) + return True + except: + if not self.fail_silently: + raise + + def close(self): + """Close the connection to the email server.""" + try: + try: + self.connection.quit() + except socket.sslerror: + # This happens when calling quit() on a TLS connection + # sometimes. + self.connection.close() + except: + if self.fail_silently: + return + raise + finally: + self.connection = None + + def send_messages(self, email_messages): + """ + Send one or more EmailMessage objects and return the number of email + messages sent. + """ + if not email_messages: + return + new_conn_created = self.open() + if not self.connection: + # We failed silently on open(). Trying to send would be pointless. + return + num_sent = 0 + for message in email_messages: + sent = self._send(message) + if sent: + num_sent += 1 + if new_conn_created: + self.close() + return num_sent + + def _send(self, email_message): + """A helper method that does the actual sending.""" + if not email_message.to: + return False + try: + self.connection.sendmail(email_message.from_email, + email_message.recipients(), + email_message.message().as_string()) + except: + if not self.fail_silently: + raise + return False + return True + +class EmailMessage(object): + """ + A container for email information. + """ + def __init__(self, subject='', body='', from_email=None, to=None, bcc=None, connection=None): + self.to = to or [] + self.bcc = bcc or [] + self.from_email = from_email or settings.DEFAULT_FROM_EMAIL + self.subject = subject + self.body = body + self.connection = connection + + def get_connection(self, fail_silently=False): + if not self.connection: + self.connection = SMTPConnection(fail_silently=fail_silently) + return self.connection + + def message(self): + msg = SafeMIMEText(self.body, 'plain', settings.DEFAULT_CHARSET) + msg['Subject'] = self.subject + msg['From'] = self.from_email + msg['To'] = ', '.join(self.to) + msg['Date'] = formatdate() + msg['Message-ID'] = make_msgid() + if self.bcc: + msg['Bcc'] = ', '.join(self.bcc) + return msg + + def recipients(self): + """ + Returns a list of all recipients of the email (includes direct + addressees as well as Bcc entries). + """ + return self.to + self.bcc + + def send(self, fail_silently=False): + """Send the email message.""" + return self.get_connection(fail_silently).send_messages([self]) + def send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None): """ Easy wrapper for sending a single message to a recipient list. All members @@ -41,8 +196,13 @@ def send_mail(subject, message, from_email, recipient_list, fail_silently=False, If auth_user is None, the EMAIL_HOST_USER setting is used. If auth_password is None, the EMAIL_HOST_PASSWORD setting is used. + + NOTE: This method is deprecated. It exists for backwards compatibility. + New code should use the EmailMessage class directly. """ - return send_mass_mail([[subject, message, from_email, recipient_list]], fail_silently, auth_user, auth_password) + connection = SMTPConnection(username=auth_user, password=auth_password, + fail_silently=fail_silently) + return EmailMessage(subject, message, from_email, recipient_list, connection=connection).send() def send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None): """ @@ -53,52 +213,24 @@ def send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password If auth_user and auth_password are set, they're used to log in. If auth_user is None, the EMAIL_HOST_USER setting is used. If auth_password is None, the EMAIL_HOST_PASSWORD setting is used. + + NOTE: This method is deprecated. It exists for backwards compatibility. + New code should use the EmailMessage class directly. """ - if auth_user is None: - auth_user = settings.EMAIL_HOST_USER - if auth_password is None: - auth_password = settings.EMAIL_HOST_PASSWORD - try: - server = smtplib.SMTP(settings.EMAIL_HOST, settings.EMAIL_PORT) - if auth_user and auth_password: - server.login(auth_user, auth_password) - except: - if fail_silently: - return - raise - num_sent = 0 - for subject, message, from_email, recipient_list in datatuple: - if not recipient_list: - continue - from_email = from_email or settings.DEFAULT_FROM_EMAIL - msg = SafeMIMEText(message, 'plain', settings.DEFAULT_CHARSET) - msg['Subject'] = subject - msg['From'] = from_email - msg['To'] = ', '.join(recipient_list) - msg['Date'] = formatdate() - try: - random_bits = str(random.getrandbits(64)) - except AttributeError: # Python 2.3 doesn't have random.getrandbits(). - random_bits = ''.join([random.choice('1234567890') for i in range(19)]) - msg['Message-ID'] = "<%d.%s@%s>" % (time.time(), random_bits, DNS_NAME) - try: - server.sendmail(from_email, recipient_list, msg.as_string()) - num_sent += 1 - except: - if not fail_silently: - raise - try: - server.quit() - except: - if fail_silently: - return - raise - return num_sent + connection = SMTPConnection(username=auth_user, password=auth_password, + fail_silently=fail_silently) + messages = [EmailMessage(subject, message, sender, recipient) for subject, message, sender, recipient in datatuple] + return connection.send_messages(messages) def mail_admins(subject, message, fail_silently=False): "Sends a message to the admins, as defined by the ADMINS setting." - send_mail(settings.EMAIL_SUBJECT_PREFIX + subject, message, settings.SERVER_EMAIL, [a[1] for a in settings.ADMINS], fail_silently) + EmailMessage(settings.EMAIL_SUBJECT_PREFIX + subject, message, + settings.SERVER_EMAIL, [a[1] for a in + settings.ADMINS]).send(fail_silently=fail_silently) def mail_managers(subject, message, fail_silently=False): "Sends a message to the managers, as defined by the MANAGERS setting." - send_mail(settings.EMAIL_SUBJECT_PREFIX + subject, message, settings.SERVER_EMAIL, [a[1] for a in settings.MANAGERS], fail_silently) + EmailMessage(settings.EMAIL_SUBJECT_PREFIX + subject, message, + settings.SERVER_EMAIL, [a[1] for a in + settings.MANAGERS]).send(fail_silently=fail_silently) + |