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.
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)
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 = []
# 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,
- DDNSProviderDtDNS,
- DDNSProviderDynDNS,
- DDNSProviderEasyDNS,
- DDNSProviderFreeDNSAfraidOrg,
- DDNSProviderNOIP,
- DDNSProviderLightningWireLabs,
- DDNSProviderOVH,
- DDNSProviderRegfish,
- DDNSProviderSelfhost,
- DDNSProviderSPDNS,
- DDNSProviderVariomedia,
- ):
- self.register_provider(provider)
+ # Open the database.
+ self.db = database.DDNSDatabase(self, "/var/lib/ddns.db")
def get_provider_names(self):
"""
def load_configuration(self, filename):
logger.debug(_("Loading configuration file %s") % filename)
- configs = ConfigParser.SafeConfigParser()
+ 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.
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)
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)
-
- else:
- 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)