Changeset 52 for branches

Timestamp:

10/26/07 05:48:32 (1 year ago)

Author:

amcgregor

Message:

TurboMail 3.0 is now usable: the smtp and debug providers are working, immediate and demand managers are good-to-go, and S/MIME signatures work, too\!

Location:

branches/3.0

Files:

• setup.py (modified) (3 diffs)
• tests/test_message.py (modified) (1 diff)
• turbomail/__init__.py (modified) (2 diffs)
• turbomail/control.py (modified) (3 diffs)
• turbomail/extensions/smime.py (modified) (1 diff)
• turbomail/managers/demand.py (modified) (1 diff)
• turbomail/managers/immediate.py (modified) (3 diffs)
• turbomail/message.py (modified) (14 diffs)
• turbomail/providers/debug.py (modified) (2 diffs)
• turbomail/providers/smtp.py (modified) (7 diffs)
• turbomail/release.py (modified) (1 diff)

branches/3.0/setup.py

@@ -28 +28 @@
                 ],
                 extras_require = {
-                        'turbogears': ["TurboGears>=1.0"]
+                        'turbogears': ["TurboGears>=1.0"],
+                        'smime': ["M2Crypto>=0.18"]
                 },
                 zip_safe=True,
@@ -50 +51 @@
                         ],
                         'turbomail.managers': [
-#                               "demand = turbomail.managers.demand",
+                                "demand = turbomail.managers.demand",
 #                               "polling = turbomail.managers.polling",
                                 "immediate = turbomail.managers.immediate"
                         ],
                         'turbomail.providers': [
-#                               "smtp = turbomail.providers.smtp",
+                                "smtp = turbomail.providers.smtp",
 #                               "sendmail = turbomail.providers.sendmail"
 #                               "disk = turbomail.providers.disk",
@@ -62 +63 @@
                         'turbomail.extensions': [
                                 "utf8qp = turbomail.extensions.utf8qp",
-#                               "smime = turbomail.extensions.smime",
+                                "smime = turbomail.extensions.smime",
 #                               "gpg = turbomail.extensions.gpg",
                         ]

branches/3.0/tests/test_message.py

@@ -30 +30 @@
         
         def test_message_string(self):
+                self.failUnless("To: Recipient <recipient@example.com>" in str(self.message))
+                self.failUnless("From: Sender <sender@example.com>" in str(self.message))
                 self.failUnless("Subject: Test message subject." in str(self.message))
                 self.failUnless("\n\nThis is a test message plain text body." in str(self.message))
+        
+        def test_recipients_collection(self):
+                self.message.cc.append("copied@example.com")
+                self.assertEqual(self.message.recipients.addresses, ["recipient@example.com", "copied@example.com"])

branches/3.0/turbomail/__init__.py

@@ -20 +20 @@
 from turbomail.util import send
 
+import pkg_resources
+
 __all__ = ['exceptions', 'extensions', 'managers', 'providers', 'release', 'manager', 'provider', 'config', 'Message', 'interface', 'send']
 
@@ -26 +28 @@
 provider = None
 config = {}
+

branches/3.0/turbomail/control.py

@@ -67 +67 @@
                 # Load the requested pool manager.
                 manager = turbomail.config.get("mail.manager", "immediate")
-                turbomail.manager = self.load_single_entry("turbomail.managers", manager).load()
-                if not turbomail.manager:
-                        turbomail.config.set("mail.on", False)
+                controller = self.load_single_entry("turbomail.managers", manager)
+                if not controller:
+                        turbomail.config.update({"mail.on": False})
                         log.error("Unable to locate %s manager, TurboMail disabled." % manager)
+                        self.stop(force=True)
                         return
+                turbomail.manager = controller.load()
                 turbomail.manager.start()
                 
                 # Load the requested mail provider.
                 provider = turbomail.config.get("mail.provider", "debug")
-                turbomail.provider = self.load_single_entry("turbomail.providers", provider).load()
-                if not turbomail.provider:
-                        turbomail.config.set("mail.on", False)
+                controller = self.load_single_entry("turbomail.providers", provider)
+                if not controller:
+                        turbomail.config.update({"mail.on": False})
                         log.error("Unable to locate %s provider, TurboMail disabled." % provider)
+                        self.stop(force=True)
                         return
+                turbomail.provider = controller.load()
                 turbomail.provider.start()
                 
@@ -94 +98 @@
                 self.running = True
         
-        def stop(self):
-                if not self.running: return
+        def stop(self, force=False):
+                if not self.running and not force: return
                 
                 log.info("TurboMail extension shutting down.")
@@ -104 +108 @@
                         if turbomail.config.get("mail." + entrypoint.name + ".on", False):
                                 ext = entrypoint.load()
-                                if hasattr(ext, "unload"): ext.unload()
+                                if hasattr(ext, "stop"): ext.stop()
                 
                 # Unload the provider and manager.
-                turbomail.provider.stop()
-                turbomail.manager.stop()
+                if turbomail.provider and hasattr(turbomail.provider, "stop"): turbomail.provider.stop()
+                if turbomail.manager and hasattr(turbomail.manager, "stop"): turbomail.manager.stop()
+                
+                turbomail.provider = None
+                turbomail.manager = None
                 
                 self.running = False

branches/3.0/turbomail/extensions/smime.py

@@ +1 @@
+# encoding: utf-8
+
+"""TurboMail extension API."""
+
+import logging
+log = logging.getLogger("turbomail.utf8qp")
+
+import turbomail, os
+from email.mime.multipart import MIMEMultipart
+from email.mime.application import MIMEApplication
+
+__all__ = ['start']
+
+
+
+class Message(turbomail.Message):
+        def __init__(self, **kw):
+                super(Message, self).__init__(**kw)
+                
+                self.sign = kw.get("sign", turbomail.config.get("mail.message.sign", False))
+                self.encrypt = kw.get("encrypt", turbomail.config.get("mail.message.encrypt", False))
+                self.force = kw.get("force", turbomail.config.get("mail.smime.force", False))
+        
+        def process_mime_message(self, message):
+                newmessage = message
+                
+                if self.sign:
+                        from M2Crypto import BIO, Rand, SMIME
+                        
+                        # Make a MemoryBuffer of the message.
+                        buf = BIO.MemoryBuffer(str(message))
+                        
+                        # Seed the PRNG.
+                        Rand.load_file('randpool.dat', -1)
+                        
+                        # Instantiate an SMIME object; set it up; sign the buffer.
+                        s = SMIME.SMIME()
+                        s.load_key(
+                                        os.path.join(turbomail.config.get("mail.smime.keystore", "./"), str(self.author.addresses[0]) + '.key'),
+                                        os.path.join(turbomail.config.get("mail.smime.keystore", "./"), str(self.author.addresses[0]) + '.x509'),
+                                )
+                        p7 = s.sign(buf)
+                        
+                        # I'm assuming -a-lot- here.  There's got to be a better way to do this, but the M2Crypto lib sucks ass from this PoV.
+                        newmessage = MIMEMultipart("signed", protocol='application/x-pkcs7-signature', micalg="sha1")
+                        newmessage.attach(message)
+                        
+                        buf = BIO.MemoryBuffer()
+                        p7.write_der(buf)
+                        signature = MIMEApplication(buf.read(), "x-pkcs7-signature")
+                        signature.set_param("name", "smime.p7s")
+                        del signature['Content-Disposition']
+                        signature.add_header("Content-Disposition", "attachment", filename="smime.p7s")
+                        
+                        newmessage.attach(signature)
+                        
+                        # Save the PRNG's state.
+                        Rand.save_file('randpool.dat')
+                
+                return newmessage

branches/3.0/turbomail/managers/demand.py

@@ +1 @@
+# encoding: utf-8
+
+"""TurboMail extension API."""
+
+import logging
+log = logging.getLogger("turbomail.manager")
+
+import turbomail
+from turbomail.api import Manager
+from turbomail.exceptions import ProviderExhaustedException
+
+import math, copy
+from Queue import Queue, Empty
+from threading import Event, Thread
+from turbomail.dispatch import Dispatch
+
+__all__ = ['load']
+
+
+def load():
+        return DemandManager()
+
+
+class DemandManager(Manager):
+        name = "Demand"
+        version = "1.0"
+        url = "http://www.python-turbomail.org/wiki/DemandManager"
+        
+        def __init__(self):
+                log.info("Demand manager starting up.")
+                
+                super(DemandManager, self).__init__()
+                
+                self.pool = 0
+                self.queue = Queue()
+                self.finished = Event()
+                
+                self.threads = turbomail.config.get("mail.demand.threads", 4) # Maximum number of threads to create.
+                self.divisor = turbomail.config.get("mail.demand.divisor", 10) # Estimate the number of required threads by dividing the queue size by this.
+                self.timeout = turbomail.config.get("mail.demand.timeout", 60)
+                
+                log.info("Demand manager ready.")
+        
+        def optimum(self):
+                return min(self.threads, math.ceil(self.queue.qsize() / float(self.divisor)))
+        
+        optimum = property(optimum)
+        
+        def stop(self):
+                log.info("Demand manager shutting down.")
+                self.finished.set()
+        
+        def spawn(self):
+                thread = Thread(target=self.wrapper)
+                thread.start()
+                self.pool += 1
+                
+        def deliver(self, message):
+                log.info("Adding message %s to the queue for background delivery." % message.id)
+                self.queue.put(copy.deepcopy(message))
+                message._processed = True
+                message._dirty = True
+                
+                if not self.queue.empty() and self.pool < self.optimum:
+                        tospawn = int(self.optimum - self.pool)
+                        log.debug("Spawning %d thread%s." % (tospawn, tospawn != 1 and "s" or ""))
+                        for i in range(tospawn):
+                                self.spawn()
+                
+        def wrapper(self):
+                log.debug("Mail queue worker starting up.")
+                
+                self.worker()
+                
+                self.pool -= 1
+                log.debug("Mail queue worker finished.")
+        
+        def worker(self):
+                log.debug("Requesting new provider instance.")
+                provider = turbomail.provider.new()
+                if not provider: raise ManagerException, "Unable to allocate new provider."
+                
+                while True:
+                        try:
+                                message = self.queue.get(True, self.timeout)
+                                provider.deliver(message)
+                        
+                        except Empty:
+                                log.debug("Worker death from starvation.")
+                                break
+                        
+                        except ProviderExhaustedException:
+                                log.debug("Worker death from provider exhaustion - spawning child.")
+                                self.deliver(message)
+                                self.spawn()
+                                break
+                        
+                        except:
+                                log.exception("Delivery of message %s failed." % message.id)
+                                break
+                        
+                        else:
+                                log.info("Delivery of message %s successful or deferred." % message.id)
+

branches/3.0/turbomail/managers/immediate.py

@@ -18 +18 @@
 
 class ImmediateManager(Manager):
+        name = "Immediate"
+        version = "1.0"
+        url = "http://www.python-turbomail.org/wiki/ImmediateManager"
+        
         def __init__(self):
                 log.info("Immediate manager starting up.")
@@ -24 +28 @@
                 
                 self.provider = None
+                
+                log.info("Immediate manager ready.")
                 
         def deliver(self, message):
@@ -45 +51 @@
                         log.debug("Provider exhausted.")
                         self.provider = None
+                        self.deliver(message)
                 
                 except:

branches/3.0/turbomail/message.py

@@ -4 +4 @@
 
 import turbomail
+from turbomail import release
 from turbomail.util import AddressList
-from turbomail.release import version
 import re, os, email
 
@@ -31 +31 @@
         This allows you to define your own message to be delivered."""
         
-        def __init__(self, sender=None, recipients=[], message=None):
+        def __init__(self, id=None, sender=None, recipients=[], message=None):
+                self.id = id
                 self.sender = sender
                 self.recipients = recipients
                 self.message = message
+                
+                if not self.id: self.id = uuid()
+                
+                super(StubMessage, self).__init__()
         
         def __str__(self):
@@ -58 +63 @@
                 
                 def configget(name, key, default=None):
-                        pass
+                        return kw.get(name, turbomail.config.get(key, default))
                 
                 self.date = kw.get("date", formatdate(localtime=True))
                 
-                self._senders = AddressList(kw.get("sender", turbomail.config.get("mail.message.sender", None)))
-                self._senders = AddressList(kw.get("senders", turbomail.config.get("mail.message.senders", self._senders)))
-                self._envelope = AddressList(kw.get("envelope", turbomail.config.get("mail.message.envelope", None)))
-                self._reply = AddressList(kw.get("reply", turbomail.config.get("mail.message.reply", None)))
+                if 'authors' in kw: kw['author'] == kw['authors']
+                if 'senders' in kw: kw['sender'] == kw['senders']
+                
+                self._author = AddressList(configget("from", "mail.message.author"))
+                self._sender = AddressList(configget("sender", "mail.message.sender"))
+                self._reply = AddressList(configget("reply", "mail.message.reply"))
                 self._to = AddressList(kw.get("to", None))
-                self._cc = AddressList(kw.get("cc", turbomail.config.get("mail.message.cc", None)))
-                self._bcc = AddressList(kw.get("bcc", turbomail.config.get("mail.message.bcc", None)))
-                self._disposition = AddressList(kw.get("disposition", turbomail.config.get("mail.message.disposition", None)))
-                
-                self.organization = kw.get("organization", turbomail.config.get("mail.message.organization", None))
-                self.encoding = kw.get("encoding", turbomail.config.get("mail.encoding", 'us-ascii'))
-                self.priority = kw.get("priority", turbomail.config.get("mail.message.priority", None))
+                self._cc = AddressList(configget("cc", "mail.message.cc"))
+                self._bcc = AddressList(configget("bcc", "mail.message.bcc"))
+                self._disposition = AddressList(configget("disposition", "mail.message.disposition"))
+                
+                self.organization = configget("organization", "mail.message.organization")
+                self.encoding = configget("encoding", "mail.encoding", 'us-ascii')
+                self.priority = configget("priority", "mail.message.priority")
                 self.subject = kw.get("subject", None)
                 self.plain = kw.get("plain", None)
@@ -79 +86 @@
                 self.attachments = kw.get("attachments", [])
                 self.embedded = kw.get("embedded", [])
-                self.headers = kw.get("headers", turbomail.config.get("mail.message.headers", []))
-                self.tries = kw.get("tries", turbomail.config.get("mail.tries", 3))
+                self.headers = configget("headers", "mail.message.headers", [])
+                self.tries = configget("tries", "mail.tries", 3)
                 
                 self._id = kw.get("id", None)
@@ -94 +101 @@
                 return self.mime.as_string()
         
-        def _get_sender(self):
-                if self._envelope:
-                        return self._envelope.addresses[0]
-                return self._senders.addresses[0]
-        
-        sender = AddressList.protected('_senders')
-        senders = AddressList.protected('_senders')
-        envelope = AddressList.protected('_envelope')
+        author = AddressList.protected('_author')
+        authors = AddressList.protected('_author')
+        sender = AddressList.protected('_sender')
+        senders = AddressList.protected('_sender')
         reply = AddressList.protected('_reply')
         to = AddressList.protected('_to')
@@ -114 +117 @@
                 
                 return self._id
+        
         id = property(id)
         
+        def envelope(self):
+                if self.sender and self.senders != self.author:
+                        return AddressList(self.senders)
+                return AddressList(self.author)
+        
+        envelope = property(envelope)
+        
         def recipients(self):
-                return [isinstance(i, tuple) and i[1] or i for i in self.to + self.cc + self.bcc]
+                return AddressList(self.to + self.cc + self.bcc)
+        
         recipients = property(recipients)
         
@@ -123 +135 @@
                 """Produce the final MIME message."""
 
-                assert self.senders, "You must specify a sender."
+                assert self.author, "You must specify an author."
                 assert self.subject, "You must specify a subject."
                 assert self.to or self.cc or self.bcc, "You must specify at least one recipient."
@@ -134 +146 @@
                 
                 plain = MIMEText(self._callable(self.plain).encode(self.encoding), 'plain', self.encoding)
-                rich = self.rich and MIMEText(self._callable(self.rich).encode(self.encoding), 'html', self.encoding) or None
-
+                
+                rich = None
+                if self.rich:
+                        rich = MIMEText(self._callable(self.rich).encode(self.encoding), 'html', self.encoding)
+                
                 def generate_mime():
                         if not rich: return plain
-
+                        
                         message = MIMEMultipart('alternative')
                         message.attach(plain)
-
+                        
                         if not self.embedded:
                                 message.attach(rich)
-
+                        
                         else:
                                 embedded = MIMEMultipart('related')
@@ -150 +165 @@
                                 for attachment in self.embedded: embedded.attach(attachment)
                                 message.attach(embedded)
-
+                        
                         return message
-
+                
                 message = generate_mime()
-
+                
                 if self.attachments:
                         attachments = MIMEMultipart()
@@ -160 +175 @@
                         for attachment in self.attachments: attachments.attach(attachment)
                         message = attachments
-
+                
+                if hasattr(self, "process_mime_message"):
+                        message = self.process_mime_message(message)
+                
                 headers = [
-                                ('Sender', self.sender), # AddressList
-                                ('From', self.senders), # AddressList
-                                ('Reply-To', self.reply), # AddressList
+                                ('Sender', self.sender),
+                                ('From', self.author),
+                                ('Reply-To', self.reply),
                                 ('Subject', self.subject),
                                 ('Date', self.date),
-                                ('To', self.to), # AddressList
-                                ('Cc', self.cc), # AddressList
-                                ('Disposition-Notification-To', self.disposition), # AddressList
+                                ('To', self.to),
+                                ('Cc', self.cc),
+                                ('Disposition-Notification-To', self.disposition),
                                 ('Organization', self.organization),
                                 ('X-Priority', self.priority),
-                                ('X-Mailer', "TurboMail <http://www.python-turbomail.org/>"),
-                                ('X-TurboMail-Version', version),
-                                ('X-TurboMail-Message-GUID', self.id),
-                                ('X-TurboMail-Extensions', "manager.demand v.1.0, provider.smtp v.1.0")
                         ]
-
+                
+                if turbomail.config.get("mail.brand", True):
+                        headers.extend([
+                                        ('X-Mailer', "%s <%s>" % (release.name, release.url)),
+                                        ('X-TurboMail-Version', release.version),
+                                        ('X-TurboMail-Message-GUID', self.id),
+                                ])
+                        
+                        if turbomail.provider:
+                                headers.extend([
+                                                ('X-TurboMail-Provider', "%s <%s>" % (turbomail.provider.name, turbomail.provider.url)),
+                                                ('X-TurboMail-Provider-Version', turbomail.provider.version),
+                                        ])
+                        
+                        if turbomail.manager:
+                                headers.extend([
+                                                ('X-TurboMail-Manager', "%s <%s>" % (turbomail.manager.name, turbomail.manager.url)),
+                                                ('X-TurboMail-Manager-Version', turbomail.manager.version),
+                                        ])
+                
                 headers.extend(self.headers)
-
+                
                 for header in headers:
                         if isinstance(header, (tuple, list)):
@@ -188 +221 @@
                         elif isinstance(header, dict):
                                 message.add_header(**header)
-
+                
                 self._mime = message
                 self._processed = True
@@ -194 +227 @@
                 
                 return message
+        
         mime = property(mime)<