Don't log debugging output to syslog.

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

diff --git a/src/ddns/__init__.py b/src/ddns/__init__.py
index ff3d3cc3d660d0fb0ffebdbb3121eec51f9e462d..d14097dbcb9cf97be66162352765cf73061ab1b6 100644 (file)
--- a/src/ddns/__init__.py
+++ b/src/ddns/__init__.py
@@ -34,10 +34,14 @@ from .system import DDNSSystem
 # Setup the logger.
 def setup_logging():
        rootlogger = logging.getLogger("ddns")
-       rootlogger.setLevel(logging.DEBUG)
+       rootlogger.setLevel(logging.INFO)
 
        # Setup a logger that logs to syslog.
-       #handler = logging.handlers.SysLogHandler(address="/dev/log")
+       handler = logging.handlers.SysLogHandler(address="/dev/log",
+               facility=logging.handlers.SysLogHandler.LOG_DAEMON
+       )
+       handler.setLevel(logging.INFO)
+       rootlogger.addHandler(handler)
 
        handler = logging.StreamHandler()
        rootlogger.addHandler(handler)
@@ -48,7 +52,10 @@ 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 = {}
@@ -69,28 +76,40 @@ class DDNSCore(object):
                """
                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
+               if not all((provider.handle, provider.name, provider.website)):
+                       raise DDNSError(_("Provider is not properly configured"))
 
-               provider_name = provider.INFO.get("name")
-               assert provider_name
+               assert not self.providers.has_key(provider.handle), \
+                       "Provider '%s' has already been registered" % provider.handle
 
-               logger.debug("Registered new provider: %s (%s)" % (provider_name, provider_handle))
-               self.providers[provider_handle] = provider
+               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 (
+                       DDNSProviderAllInkl,
                        DDNSProviderDHS,
                        DDNSProviderDNSpark,
+                       DDNSProviderDtDNS,
+                       DDNSProviderDynDNS,
+                       DDNSProviderDynU,
+                       DDNSProviderEasyDNS,
+                       DDNSProviderFreeDNSAfraidOrg,
+                       DDNSProviderNamecheap,
                        DDNSProviderNOIP,
                        DDNSProviderLightningWireLabs,
+                       DDNSProviderOVH,
+                       DDNSProviderRegfish,
                        DDNSProviderSelfhost,
+                       DDNSProviderSPDNS,
+                       DDNSProviderStrato,
+                       DDNSProviderTwoDNS,
+                       DDNSProviderUdmedia,
+                       DDNSProviderVariomedia,
+                       DDNSProviderZoneedit,
                ):
                        self.register_provider(provider)
 
@@ -101,6 +120,8 @@ class DDNSCore(object):
                return sorted(self.providers.keys())
 
        def load_configuration(self, filename):
+               logger.debug(_("Loading configuration file %s") % filename)
+
                configs = ConfigParser.SafeConfigParser()
                configs.read([filename,])
 
@@ -164,15 +185,17 @@ 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)
+                               { "hostname" : entry.hostname, "provider" : entry.name }, exc_info=True)
 
-               logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
-                       { "hostname" : entry.hostname, "provider" : entry.name })
+               else:
+                       logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
+                               { "hostname" : entry.hostname, "provider" : entry.name })