root / trunk / turbomail / control.py

# encoding: utf-8

"""TurboGears extension startup and shutdown interface.

TurboGears will automatically start and stop TurboMail if you configure
your application with `mail.on = True`.  To start and stop TurboMail
in your own applications::

  import turbomail
  
  turbomail.interface.config = {'mail.on': True, ...}
  turbomail.interface.start()
  
  message = turbomail.Message(...)
  turbomail.interface.send(message)
  
  turbomail.interface.stop()

Remember to configure your outbound settings in the config dictionary.

TurboMail will, by default, immediately delete any messages remaining in
the queue and wait on any in-progress deliveries.
"""

__version__ = "$Revision$"

import logging
log = logging.getLogger("turbomail.control")

import pkg_resources

__all__ = ['extension']


from turbomail.exceptions import MailNotEnabledException

class ControlClass(object):
    """Control TurboMail startup and shutdown.
    
    Dynamically discovers the presence of TurboGears, creating appropriate aliases for
    TurboGears extension startup and shutdown."""
    
    def __init__(self):
        self.running = False
        self.extensions = dict()
        self.config = dict()
        self.manager = None
        self.transport = None
    
    def __load_single_entry(self, group, name):
        for entrypoint in pkg_resources.iter_entry_points(group, name):
            return entrypoint.load()
        return None
    
    def start(self, extra_classes=None):
        if not self.config.get("mail.on", False):
            return
        
        log.info("TurboMail extension starting up.")
        
        def load(t, default, extra_classes):
            extension = self.config.get("mail.%s" % t, default)
            if extra_classes != None and extension in extra_classes:
                controller = extra_classes[extension]
                if isinstance(controller, type):
                    controller = controller()
            else:
                entry_point = "turbomail.%ss" % t
                controller = self.__load_single_entry(entry_point, extension)
            if not controller:
                self.config.update({"mail.on": False})
                log.error("Unable to locate %s %s, TurboMail disabled." % (extension, t))
                self.stop(force=True)
                return
            setattr(self, t, controller)
            if hasattr(getattr(self, t), 'load'):
                setattr(self, t, getattr(self, t).load())
            if hasattr(getattr(self, t), 'start'):
                getattr(self, t).start()
        
        # Load the requested manager and transport.
        load('manager', 'immediate', extra_classes)
        load('transport', 'debug', extra_classes)
        
        # Load and initialize the various extensions.
        extensions = pkg_resources.iter_entry_points("turbomail.extensions")
        for entrypoint in extensions:
            log.debug("Found extension '%s'." % entrypoint.name)
            
            if self.config.get("mail.%s.on" % entrypoint.name, False):
                log.info("Loading extension '%s'." % entrypoint.name)
                
                self.extensions[entrypoint.name] = entrypoint.load()
                
                if hasattr(self.extensions[entrypoint.name], 'interface'):
                    self.extensions[entrypoint.name] = self.extensions[entrypoint.name].interface
                
                elif hasattr(self.extensions[entrypoint.name], 'load'):
                    self.extensions[entrypoint.name] = self.extensions[entrypoint.name].load()
                
                if hasattr(self.extensions[entrypoint.name], 'start'):
                    self.extensions[entrypoint.name].start()
        
        self.running = True
    
    def stop(self, force=False):
        if not self.running and not force: return
        
        log.info("TurboMail extension shutting down.")
        
        # Unload the various extensions.
        extensions = pkg_resources.iter_entry_points("turbomail.extensions")
        for entrypoint in extensions:
            if self.config.get("mail." + entrypoint.name + ".on", False):
                ext = entrypoint.load()
                if hasattr(ext, "stop"): ext.stop()
        
        # Unload the transport and manager.
        if self.transport and hasattr(self.transport, "stop"): self.transport.stop()
        if self.manager and hasattr(self.manager, "stop"): self.manager.stop()
        
        self.transport = None
        self.manager = None
        
        self.running = False
    
    def send(self, message):
        if not self.manager:
            raise MailNotEnabledException
        
        return self.manager.deliver(message)



interface = ControlClass()