Add runtime check for providers if all dependencies are met

[ddns.git] / src / ddns / __init__.py

diff --git a/src/ddns/__init__.py b/src/ddns/__init__.py
index bdbb1117bbcf9488593f82045ad79cf1bc93c141..7f2729c2c8c0cc93e09e46ec343fce6804664276 100644 (file)
--- a/src/ddns/__init__.py
+++ b/src/ddns/__init__.py
@@ -28,7 +28,10 @@ from i18n import _
 logger = logging.getLogger("ddns.core")
 logger.propagate = 1
 
-from .providers import *
+import database
+import providers
+
+from .errors import *
 from .system import DDNSSystem
 
 # Setup the logger.
@@ -40,6 +43,8 @@ def setup_logging():
        handler = logging.handlers.SysLogHandler(address="/dev/log",
                facility=logging.handlers.SysLogHandler.LOG_DAEMON
        )
+       formatter = logging.Formatter("ddns[%(process)d]: %(message)s")
+       handler.setFormatter(formatter)
        handler.setLevel(logging.INFO)
        rootlogger.addHandler(handler)
 
@@ -52,15 +57,19 @@ class DDNSCore(object):
        def __init__(self, debug=False):
                # In debug mode, enable debug logging.
                if debug:
-                       logger.setLevel(logging.DEBUG)
+                       rootlogger = logging.getLogger("ddns")
+                       rootlogger.setLevel(logging.DEBUG)
+
                        logger.debug(_("Debugging mode enabled"))
 
                # Initialize the settings array.
                self.settings = {}
 
                # Dict with all providers, that are supported.
-               self.providers = {}
-               self.register_all_providers()
+               self.providers = providers.get()
+
+               for handle, provider in sorted(self.providers.items()):
+                       logger.debug("Registered new provider: %s (%s)" % (provider.name, provider.handle))
 
                # List of configuration entries.
                self.entries = []
@@ -68,36 +77,8 @@ class DDNSCore(object):
                # Add the system class.
                self.system = DDNSSystem(self)
 
-       def register_provider(self, provider):
-               """
-                       Registers a new provider.
-               """
-               assert issubclass(provider, DDNSProvider)
-
-               provider_handle = provider.INFO.get("handle")
-               assert provider_handle
-
-               assert not self.providers.has_key(provider_handle), \
-                       "Provider '%s' has already been registered" % provider_handle
-
-               provider_name = provider.INFO.get("name")
-               assert provider_name
-
-               logger.debug("Registered new provider: %s (%s)" % (provider_name, provider_handle))
-               self.providers[provider_handle] = provider
-
-       def register_all_providers(self):
-               """
-                       Simply registers all providers.
-               """
-               for provider in (
-                       DDNSProviderDHS,
-                       DDNSProviderDNSpark,
-                       DDNSProviderNOIP,
-                       DDNSProviderLightningWireLabs,
-                       DDNSProviderSelfhost,
-               ):
-                       self.register_provider(provider)
+               # Open the database.
+               self.db = database.DDNSDatabase(self, "/var/lib/ddns.db")
 
        def get_provider_names(self):
                """
@@ -106,12 +87,19 @@ class DDNSCore(object):
                return sorted(self.providers.keys())
 
        def load_configuration(self, filename):
-               configs = ConfigParser.SafeConfigParser()
+               logger.debug(_("Loading configuration file %s") % filename)
+
+               configs = ConfigParser.RawConfigParser()
                configs.read([filename,])
 
                # First apply all global configuration settings.
-               for k, v in configs.items("config"):
-                       self.settings[k] = v
+               try:
+                       for k, v in configs.items("config"):
+                               self.settings[k] = v
+
+               # Allow missing config section
+               except ConfigParser.NoSectionError:
+                       pass
 
                for entry in configs.sections():
                        # Skip the special config section.
@@ -136,6 +124,12 @@ class DDNSCore(object):
                                logger.warning("Could not find provider '%s' for entry '%s'." % (provider, entry))
                                continue
 
+                       # Check if the provider is actually supported and if there are
+                       # some dependencies missing on this system.
+                       if not provider.supported():
+                               logger.warning("Provider '%s' is known, but not supported on this machine" % (provider.name))
+                               continue
+
                        # Create an instance of the provider object with settings from the
                        # configuration file.
                        entry = provider(self, **settings)
@@ -169,15 +163,13 @@ class DDNSCore(object):
                try:
                        entry(force=force)
 
-               except DDNSUpdateError, e:
+               except DDNSError, e:
                        logger.error(_("Dynamic DNS update for %(hostname)s (%(provider)s) failed:") % \
                                { "hostname" : entry.hostname, "provider" : entry.name })
-                       logger.error("  %s" % e)
+                       logger.error("  %s: %s" % (e.__class__.__name__, e.reason))
+                       if e.message:
+                               logger.error("  %s" % e.message)
 
                except Exception, e:
                        logger.error(_("Dynamic DNS update for %(hostname)s (%(provider)s) throwed an unhandled exception:") % \
-                               { "hostname" : entry.hostname, "provider" : entry.name })
-                       logger.error("  %s" % e)
-
-               logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
-                       { "hostname" : entry.hostname, "provider" : entry.name })
+                               { "hostname" : entry.hostname, "provider" : entry.name }, exc_info=True)