X-Git-Url: https://git.llucax.com/software/pymin.git/blobdiff_plain/d46203541c7463746edf19344d3ddbd1fb412128..031a757fb7b600a9015d018011cc7b135d7c8627:/services/dhcp/__init__.py?ds=sidebyside

diff --git a/services/dhcp/__init__.py b/services/dhcp/__init__.py
index 3d956f9..08bb8b5 100644
--- a/services/dhcp/__init__.py
+++ b/services/dhcp/__init__.py
@@ -7,12 +7,25 @@ try:
     import cPickle as pickle
 except ImportError:
     import pickle
+
+try:
+    from seqtools import Sequence
+except ImportError:
+    # NOP for testing
+    class Sequence: pass
 try:
-    from dispatcher import handler
+    from dispatcher import Handler, handler, HandlerError
 except ImportError:
-    def handler(f): return f # NOP for testing
+    # NOP for testing
+    class HandlerError(RuntimeError): pass
+    class Handler: pass
+    def handler(help):
+        def wrapper(f):
+            return f
+        return wrapper
 
-__ALL__ = ('DhcpHandler',)
+__ALL__ = ('DhcpHandler', 'Error', 'HostError', 'HostAlreadyExistsError',
+            'HostNotFoundError', 'ParameterError', 'ParameterNotFoundError')
 
 pickle_ext = '.pkl'
 pickle_vars = 'vars'
@@ -22,7 +35,82 @@ config_filename = 'dhcpd.conf'
 
 template_dir = path.join(path.dirname(__file__), 'templates')
 
-class Host:
+class Error(HandlerError):
+    r"""
+    Error(message) -> Error instance :: Base DhcpHandler exception class.
+
+    All exceptions raised by the DhcpHandler inherits from this one, so you can
+    easily catch any DhcpHandler exception.
+
+    message - A descriptive error message.
+    """
+
+    def __init__(self, message):
+        r"Initialize the Error object. See class documentation for more info."
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+class HostError(Error, KeyError):
+    r"""
+    HostError(hostname) -> HostError instance
+
+    This is the base exception for all host related errors.
+    """
+
+    def __init__(self, hostname):
+        r"Initialize the object. See class documentation for more info."
+        self.message = 'Host error: "%s"' % hostname
+
+class HostAlreadyExistsError(HostError):
+    r"""
+    HostAlreadyExistsError(hostname) -> HostAlreadyExistsError instance
+
+    This exception is raised when trying to add a hostname that already exists.
+    """
+
+    def __init__(self, hostname):
+        r"Initialize the object. See class documentation for more info."
+        self.message = 'Host already exists: "%s"' % hostname
+
+class HostNotFoundError(HostError):
+    r"""
+    HostNotFoundError(hostname) -> HostNotFoundError instance
+
+    This exception is raised when trying to operate on a hostname that doesn't
+    exists.
+    """
+
+    def __init__(self, hostname):
+        r"Initialize the object. See class documentation for more info."
+        self.message = 'Host not found: "%s"' % hostname
+
+class ParameterError(Error, KeyError):
+    r"""
+    ParameterError(paramname) -> ParameterError instance
+
+    This is the base exception for all DhcpHandler parameters related errors.
+    """
+
+    def __init__(self, paramname):
+        r"Initialize the object. See class documentation for more info."
+        self.message = 'Parameter error: "%s"' % paramname
+
+class ParameterNotFoundError(ParameterError):
+    r"""
+    ParameterNotFoundError(hostname) -> ParameterNotFoundError instance
+
+    This exception is raised when trying to operate on a parameter that doesn't
+    exists.
+    """
+
+    def __init__(self, paramname):
+        r"Initialize the object. See class documentation for more info."
+        self.message = 'Parameter not found: "%s"' % paramname
+
+
+class Host(Sequence):
     r"""Host(name, ip, mac) -> Host instance :: Class representing a host.
 
     name - Host name, should be a fully qualified name, but no checks are done.
@@ -36,7 +124,11 @@ class Host:
         self.ip = ip
         self.mac = mac
 
-class HostHandler:
+    def as_tuple(self):
+        r"Return a tuple representing the host."
+        return (self.name, self.ip, self.mac)
+
+class HostHandler(Handler):
     r"""HostHandler(hosts) -> HostHandler instance :: Handle a list of hosts.
 
     This class is a helper for DhcpHandler to do all the work related to hosts
@@ -49,50 +141,58 @@ class HostHandler:
         r"Initialize HostHandler object, see class documentation for details."
         self.hosts = hosts
 
-    @handler
+    @handler(u'Add a new host.')
     def add(self, name, ip, mac):
         r"add(name, ip, mac) -> None :: Add a host to the hosts list."
-        # XXX deberia indexar por hostname o por ip? o por mac? :)
-        # o por nada... Puedo tener un nombre con muchas IPs? Una IP con muchos
-        # nombres? Una MAC con muchas IP? una MAC con muchos nombre? Etc...
+        if name in self.hosts:
+            raise HostAlreadyExistsError(name)
         self.hosts[name] = Host(name, ip, mac)
 
-    @handler
+    @handler(u'Update a host.')
     def update(self, name, ip=None, mac=None):
         r"update(name[, ip[, mac]]) -> None :: Update a host of the hosts list."
         if not name in self.hosts:
-            raise KeyError('Host not found')
+            raise HostNotFoundError(name)
         if ip is not None:
             self.hosts[name].ip = ip
         if mac is not None:
             self.hosts[name].mac = mac
 
-    @handler
+    @handler(u'Delete a host.')
     def delete(self, name):
         r"delete(name) -> None :: Delete a host of the hosts list."
         if not name in self.hosts:
-            raise KeyError('Host not found')
+            raise HostNotFoundError(name)
         del self.hosts[name]
 
-    @handler
+    @handler(u'Get information about a host.')
+    def get(self, name):
+        r"""get(name) -> CSV string :: List all the information of a host.
+
+        The host is returned as a CSV list of: hostname,ip,mac
+        """
+        if not name in self.hosts:
+            raise HostNotFoundError(name)
+        return self.hosts[name]
+
+    @handler(u'List hosts.')
     def list(self):
         r"""list() -> CSV string :: List all the hostnames.
 
         The list is returned as a single CSV line with all the hostnames.
         """
-        return ','.join(self.hosts)
+        return self.hosts.keys()
 
-    @handler
+    @handler(u'Get information about all hosts.')
     def show(self):
         r"""show() -> CSV string :: List all the complete hosts information.
 
         The hosts are returned as a CSV list with each host in a line, like:
         hostname,ip,mac
         """
-        hosts = self.hosts.values()
-        return '\n'.join('%s,%s,%s' % (h.name, h.ip, h.mac) for h in hosts)
+        return self.hosts.values()
 
-class DhcpHandler:
+class DhcpHandler(Handler):
     r"""DhcpHandler([pickle_dir[, config_dir]]) -> DhcpHandler instance.
 
     Handles DHCP service commands for the dhcpd program.
@@ -130,22 +230,29 @@ class DhcpHandler:
             self._write_config()
         self.host = HostHandler(self.hosts)
 
-    @handler
+    @handler(u'Set a DHCP parameter.')
     def set(self, param, value):
         r"set(param, value) -> None :: Set a DHCP parameter."
         if not param in self.vars:
-            raise KeyError('Parameter ' + param + ' not found')
+            raise ParameterNotFoundError(param)
         self.vars[param] = value
 
-    @handler
+    @handler(u'Get a DHCP parameter.')
+    def get(self, param):
+        r"get(param) -> None :: Get a DHCP parameter."
+        if not param in self.vars:
+            raise ParameterNotFoundError(param)
+        return self.vars[param]
+
+    @handler(u'List all available DHCP parameters.')
     def list(self):
         r"""list() -> CSV string :: List all the parameter names.
 
         The list is returned as a single CSV line with all the names.
         """
-        return ','.join(self.vars)
+        return self.vars.keys()
 
-    @handler
+    @handler(u'Get all DHCP parameters, with their values.')
     def show(self):
         r"""show() -> CSV string :: List all the parameters (with their values).
 
@@ -153,37 +260,37 @@ class DhcpHandler:
         line, like:
         name,value
         """
-        return '\n'.join(('%s,%s' % (k, v) for (k, v) in self.vars.items()))
+        return self.vars.items()
 
-    @handler
+    @handler(u'Start the service.')
     def start(self):
         r"start() -> None :: Start the DHCP service."
         #esto seria para poner en una interfaz
         #y seria el hook para arrancar el servicio
         pass
 
-    @handler
+    @handler(u'Stop the service.')
     def stop(self):
         r"stop() -> None :: Stop the DHCP service."
         #esto seria para poner en una interfaz
         #y seria el hook para arrancar el servicio
         pass
 
-    @handler
+    @handler(u'Restart the service.')
     def restart(self):
         r"restart() -> None :: Restart the DHCP service."
         #esto seria para poner en una interfaz
         #y seria el hook para arrancar el servicio
         pass
 
-    @handler
+    @handler(u'Reload the service config (without restarting, if possible).')
     def reload(self):
         r"reload() -> None :: Reload the configuration of the DHCP service."
         #esto seria para poner en una interfaz
         #y seria el hook para arrancar el servicio
         pass
 
-    @handler
+    @handler(u'Commit the changes (reloading the service, if necessary).')
     def commit(self):
         r"commit() -> None :: Commit the changes and reload the DHCP service."
         #esto seria para poner en una interfaz
@@ -193,7 +300,7 @@ class DhcpHandler:
         self._write_config()
         self.reload()
 
-    @handler
+    @handler(u'Discard all the uncommited changes.')
     def rollback(self):
         r"rollback() -> None :: Discard the changes not yet commited."
         self._load()
@@ -218,7 +325,9 @@ class DhcpHandler:
     def _dump_var(self, var, name):
         r"_dump_var() -> None :: Dump a especific variable to a pickle file."
         # XXX podría ir en una clase base
-        pickle.dump(var, file(self._pickle_filename(name), 'wb'), 2)
+        pkl_file = file(self._pickle_filename(name), 'wb')
+        pickle.dump(var, pkl_file, 2)
+        pkl_file.close()
 
     def _load_var(self, name):
         r"_load_var() -> object :: Load a especific pickle file."
@@ -232,6 +341,7 @@ class DhcpHandler:
         out_file = file(path.join(self.config_dir, config_filename), 'w')
         ctx = Context(out_file, hosts=self.hosts.values(), **self.vars)
         self.template.render_context(ctx)
+        out_file.close()
 
 if __name__ == '__main__':