Add Namecheap as new provider.

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

diff --git a/src/ddns/__init__.py b/src/ddns/__init__.py
index 74989f3f7fb2e1f1dabd75fa21382da5d56a5b04..7ee6a2042e92a3da02945336c928b5093e60db96 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)
@@ -49,6 +53,7 @@ class DDNSCore(object):
                # In debug mode, enable debug logging.
                if debug:
                        logger.setLevel(logging.DEBUG)
+                       logger.debug(_("Debugging mode enabled"))
 
                # Initialize the settings array.
                self.settings = {}
@@ -87,13 +92,32 @@ class DDNSCore(object):
                """
                for provider in (
                        DDNSProviderDHS,
+                       DDNSProviderDNSpark,
+                       DDNSProviderDtDNS,
+                       DDNSProviderDynDNS,
+                       DDNSProviderDynU,
+                       DDNSProviderEasyDNS,
+                       DDNSProviderFreeDNSAfraidOrg,
+                       DDNSProviderNamecheap,
                        DDNSProviderNOIP,
                        DDNSProviderLightningWireLabs,
+                       DDNSProviderOVH,
+                       DDNSProviderRegfish,
                        DDNSProviderSelfhost,
+                       DDNSProviderSPDNS,
+                       DDNSProviderVariomedia,
                ):
                        self.register_provider(provider)
 
+       def get_provider_names(self):
+               """
+                       Returns a list of names of all registered providers.
+               """
+               return sorted(self.providers.keys())
+
        def load_configuration(self, filename):
+               logger.debug(_("Loading configuration file %s") % filename)
+
                configs = ConfigParser.SafeConfigParser()
                configs.read([filename,])
 
@@ -132,19 +156,30 @@ class DDNSCore(object):
                        if not entry in self.entries:
                                self.entries.append(entry)
 
-       def updateall(self):
+       def updateone(self, hostname, **kwargs):
+               for entry in self.entries:
+                       if not entry.hostname == hostname:
+                               continue
+
+                       return self._update(entry, **kwargs)
+
+               raise DDNSHostNotFoundError(hostname)
+
+       def updateall(self, **kwargs):
+               """
+                       Update all configured entries.
+               """
                # If there are no entries, there is nothing to do.
                if not self.entries:
                        logger.debug(_("Found no entries in the configuration file. Exiting."))
                        return
 
-               # Update them all.
                for entry in self.entries:
-                       self.update(entry)
+                       self._update(entry, **kwargs)
 
-       def update(self, entry):
+       def _update(self, entry, force=False):
                try:
-                       entry()
+                       entry(force=force)
 
                except DDNSUpdateError, e:
                        logger.error(_("Dynamic DNS update for %(hostname)s (%(provider)s) failed:") % \
@@ -156,5 +191,6 @@ class DDNSCore(object):
                                { "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 })
+               else:
+                       logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
+                               { "hostname" : entry.hostname, "provider" : entry.name })