Factored out a lot of common code.

[software/pymin.git] / services / ip / __init__.py

diff --git a/services/ip/__init__.py b/services/ip/__init__.py
index c2fff476e800f0449ebe5a1125362bb59ad26537..cf16088fad959b8bb098432e762e202bd62ea73f 100644 (file)
--- a/services/ip/__init__.py
+++ b/services/ip/__init__.py
@@ -1,41 +1,15 @@
 # vim: set encoding=utf-8 et sw=4 sts=4 :
 
 # vim: set encoding=utf-8 et sw=4 sts=4 :
 

-from mako.template import Template
-from mako.runtime import Context
+from subprocess import Popen, PIPE

 from os import path
 from os import path

-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, HandlerError
-except ImportError:
-    # NOP for testing
-    class HandlerError(RuntimeError): pass
-    def handler(f): return f
-
-__ALL__ = ('IpHandler',)
-
-pickle_ext = '.pkl'
-pickle_devices = 'devs'
-
-template_dir = path.join(path.dirname(__file__), 'templates')
-command_filename = 'command'
-
-
-device_com = 'device.command'
-ip_add_com = 'ip_add.command'
-ip_del_com = 'ip_del.command'
-ip_flush_com = 'ip_flush.command'
-route_add_com = 'route_add.command'
-route_del_com = 'route_del.command'
-route_flush_com = 'route_flush.command'
+
+from seqtools import Sequence
+from dispatcher import handler, HandlerError, Handler
+from services.util import Restorable, ConfigWriter
+from services.util import InitdHandler, TransactionalHandler
+
+__ALL__ = ('IpHandler','Error','DeviceError','DeviceNotFoundError','RouteError','RouteNotFoundError',
+            'RouteAlreadyExistsError','AddressError','AddressNotFoundError','AddressAlreadyExistsError')

 
 class Error(HandlerError):
     r"""
 
 class Error(HandlerError):
     r"""


@@ -104,20 +78,19 @@ class Route(Sequence):
     def as_tuple(self):
         return(self.addr, self.prefix, self.gateway)
 
     def as_tuple(self):
         return(self.addr, self.prefix, self.gateway)
 

-class RouteHandler:
+    def __cmp__(self, other):
+        if self.net_addr == other.net_addr \
+                and self.prefix == other.prefix \
+                and self.gateway == other.gateway:
+            return 0
+        return cmp(id(self), id(other))

 
 

-    def __init__(self, devices, config_dir, ip_handler):
+class RouteHandler(Handler):
+
+    def __init__(self, devices):

         self.devices = devices
         self.devices = devices

-        route_add_fn = path.join(template_dir, route_add_com)
-        route_del_fn = path.join(template_dir, route_del_com)
-        route_flush_fn = path.join(template_dir, route_flush_com)
-        self.route_add_template = Template(filename=route_add_fn)
-        self.route_del_template = Template(filename=route_del_fn)
-        self.route_flush_template = Template(filename=route_flush_fn)
-        self.config_dir = config_dir
-        self.ip_handler = ip_handler
-
-    @handler
+
+    @handler(u'Adds a route to a device')

     def add(self, device, net_addr, prefix, gateway):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
     def add(self, device, net_addr, prefix, gateway):
         if not device in self.devices:
             raise DeviceNotFoundError(device)


@@ -126,46 +99,26 @@ class RouteHandler:
             self.devices[device].routes.index(r)
             raise RouteAlreadyExistsError(net_addr + '/' + prefix + '->' + gateway)
         except ValueError:
             self.devices[device].routes.index(r)
             raise RouteAlreadyExistsError(net_addr + '/' + prefix + '->' + gateway)
         except ValueError:

-            out_file = file(path.join(self.config_dir, command_filename), 'w')
-            ctx = Context(out_file, dev=device, net_addr=net_addr, prefix=prefix, gateway=gateway)
-            self.route_add_template.render_context(ctx)
-            out_file.close()
-            execute_command(self.config_dir)

             self.devices[device].routes.append(r)
             self.devices[device].routes.append(r)

-            self.ip_handler.commit()

 
 

-
-    @handler
+    @handler(u'Deletes a route from a device')

     def delete(self, device, net_addr, prefix, gateway):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         r = Route(net_addr, prefix, gateway)
     def delete(self, device, net_addr, prefix, gateway):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         r = Route(net_addr, prefix, gateway)

-        #try:
-            #i = self.devices[device].routes.index(r)
-            #out_file = file(path.join(self.config_dir, command_filename), 'w')
-            #ctx = Context(out_file, dev=device, net_addr=net_addr, prefix=prefix, gateway=gateway)
-            #self.route_add_template.render_context(ctx)
-            #out_file.close()
-            #execute_command(self.config_dir)
-            #self.devices[device].routes.append(r)
-            #self.ip_handler.commit()
-
-        #except ValueError:
-            #raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
-
-    @handler
+        try:
+            self.devices[device].routes.remove(r)
+        except ValueError:
+            raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
+
+    @handler(u'Flushes routes from a device')

     def flush(self, device):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
     def flush(self, device):
         if not device in self.devices:
             raise DeviceNotFoundError(device)

-        out_file = file(path.join(self.config_dir, command_filename), 'w')
-        ctx = Context(out_file, dev=device)
-        self.route_flush_template.render_context(ctx)
-        out_file.close()
-        execute_command(self.config_dir)

         self.devices[device].routes = list()
         self.devices[device].routes = list()

-        self.ip_handler.commit()

 
 

-    @handler
+
+    @handler(u'List routes')

     def list(self, device):
         try:
             k = self.devices[device].routes.keys()
     def list(self, device):
         try:
             k = self.devices[device].routes.keys()


@@ -173,7 +126,7 @@ class RouteHandler:
             k = list()
         return k
 
             k = list()
         return k
 

-    @handler
+    @handler(u'Get information about all routes')

     def show(self):
         try:
             k = self.devices[device].routes.values()
     def show(self):
         try:
             k = self.devices[device].routes.values()


@@ -191,63 +144,34 @@ class Address(Sequence):
     def as_tuple(self):
         return (self.ip, self.prefix, self.broadcast)
 
     def as_tuple(self):
         return (self.ip, self.prefix, self.broadcast)
 

-class AddressHandler:
+class AddressHandler(Handler):

 
 

-    def __init__(self, devices, config_dir, ip_handler):
+    def __init__(self, devices):

         self.devices = devices
         self.devices = devices

-        self.config_dir = config_dir
-        ip_add_fn = path.join(template_dir, ip_add_com)
-        ip_del_fn = path.join(template_dir, ip_del_com)
-        ip_flush_fn = path.join(template_dir, ip_flush_com)
-        self.ip_add_template = Template(filename=ip_add_fn)
-        self.ip_del_template = Template(filename=ip_del_fn)
-        self.ip_flush_template = Template(filename=ip_flush_fn)
-        self.ip_handler = ip_handler

 
 

-
-    @handler
+    @handler(u'Adds an address to a device')

     def add(self, device, ip, prefix, broadcast='+'):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         if ip in self.devices[device].addrs:
             raise AddressAlreadyExistsError(ip)
     def add(self, device, ip, prefix, broadcast='+'):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         if ip in self.devices[device].addrs:
             raise AddressAlreadyExistsError(ip)

-        out_file = file(path.join(self.config_dir, command_filename), 'w')
-        ctx = Context(out_file, dev=device, addr=ip, prefix=prefix, broadcast=broadcast)
-        self.ip_add_template.render_context(ctx)
-        out_file.close()
-        execute_command(self.config_dir)

         self.devices[device].addrs[ip] = Address(ip, prefix, broadcast)
         self.devices[device].addrs[ip] = Address(ip, prefix, broadcast)

-        self.ip_handler.commit()

 
 

-    @handler
+    @handler(u'Deletes an address from a device')

     def delete(self, device, ip):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         if not ip in self.devices[device].addrs:
             raise AddressNotFoundError(ip)
     def delete(self, device, ip):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
         if not ip in self.devices[device].addrs:
             raise AddressNotFoundError(ip)

-        out_file = file(path.join(self.config_dir, command_filename), 'w')
-        ctx = Context(out_file, dev=device, addr=ip, prefix=self.devices[device].addrs[ip].prefix)
-        self.ip_del_template.render_context(ctx)
-        out_file.close()
-        execute_command(self.config_dir)

         del self.devices[device].addrs[ip]
         del self.devices[device].addrs[ip]

-        self.ip_handler.commit()
-

 
 

-    @handler
+    @handler(u'Flushes addresses from a device')

     def flush(self, device):
         if not device in self.devices:
             raise DeviceNotFoundError(device)
     def flush(self, device):
         if not device in self.devices:
             raise DeviceNotFoundError(device)

-        out_file = file(path.join(self.config_dir, command_filename), 'w')
-        ctx = Context(out_file, dev=device)
-        self.ip_flush_template.render_context(ctx)
-        out_file.close()
-        execute_command(self.config_dir)

         self.devices[device].addrs = dict()
         self.devices[device].addrs = dict()

-        self.ip_handler.commit()

 
 

-
-    @handler
+    @handler(u'List all addresses from a device')

     def list(self, device):
         try:
             k = self.devices[device].addrs.keys()
     def list(self, device):
         try:
             k = self.devices[device].addrs.keys()


@@ -255,7 +179,7 @@ class AddressHandler:
             k = list()
         return k
 
             k = list()
         return k
 

-    @handler
+    @handler(u'Get information about addresses from a device')

     def show(self, device):
         try:
             k = self.devices[device].addrs.values()
     def show(self, device):
         try:
             k = self.devices[device].addrs.values()


@@ -265,139 +189,120 @@ class AddressHandler:
 
 class Device(Sequence):
 
 
 class Device(Sequence):
 

-    def __init__(self, name):
+    def __init__(self, name, mac):

         self.name = name
         self.name = name

+        self.mac = mac

         self.addrs = dict()
         self.routes = list()
 
     def as_tuple(self):
         self.addrs = dict()
         self.routes = list()
 
     def as_tuple(self):

-        return (self.name, self.addrs, self.routes)
+        return (self.name, self.mac)

 
 

-class DeviceHandler:
+class DeviceHandler(Handler):

 
 

-    def __init__(self, devices, config_dir = '.'):
+    def __init__(self, devices):
+        # FIXME remove templates to execute commands
+        from mako.template import Template

         self.devices = devices
         self.devices = devices

-        dev_fn = path.join(template_dir, device_com)
+        template_dir = path.join(path.dirname(__file__), 'templates')
+        dev_fn = path.join(template_dir, 'device')

         self.device_template = Template(filename=dev_fn)
         self.device_template = Template(filename=dev_fn)

-        self.config_dir = config_dir

 
 

-    @handler
+    @handler(u'Bring the device up')

     def up(self, name):
         if name in self.devices:
     def up(self, name):
         if name in self.devices:

-            out_file = file(path.join(self.config_dir, command_filename), 'w')
-            ctx = Context(out_file, dev=name, action='up')
-            self.device_template.render_context(ctx)
-            out_file.close()
-            execute_command(self.config_dir)
+            print self.device_template.render(dev=name, action='up')

         else:
             raise DeviceNotFoundError(name)
 
         else:
             raise DeviceNotFoundError(name)
 

-    @handler
+    @handler(u'Bring the device down')

     def down(self, name):
         if name in self.devices:
     def down(self, name):
         if name in self.devices:

-            out_file = file(path.join(self.config_dir, command_filename), 'w')
-            ctx = Context(out_file, dev=name, action='down')
-            self.device_template.render_context(ctx)
-            out_file.close()
-            execute_command(self.config_dir)
+            print self.device_template.render(dev=name, action='down')

         else:
             raise DeviceNotFoundError(name)
 
         else:
             raise DeviceNotFoundError(name)
 

-    @handler
+    @handler(u'List all devices')

     def list(self):
         return self.devices.keys()
 
     def list(self):
         return self.devices.keys()
 

-    @handler
+    @handler(u'Get information about a device')

     def show(self):
         return self.devices.items()
 
     def show(self):
         return self.devices.items()
 

-def execute_command(config_dir):
-    out_file = file(path.join(config_dir, command_filename), 'r')
-    print out_file.read()
-    out_file.close()
+def get_devices():
+    p = Popen(('ip', 'link', 'list'), stdout=PIPE, close_fds=True)
+    string = p.stdout.read()
+    p.wait()
+    d = dict()
+    i = string.find('eth')
+    while i != -1:
+        eth = string[i:i+4]
+        m = string.find('link/ether', i+4)
+        mac = string[ m+11 : m+11+17]
+        d[eth] = Device(eth, mac)
+        i = string.find('eth', m+11+17)
+    return d

 
 

-class IpHandler:
+class IpHandler(Restorable, ConfigWriter, TransactionalHandler):

 
 

-    def __init__(self, pickle_dir='.', config_dir='.'):
-        r"Initialize DhcpHandler object, see class documentation for details."
+    _persistent_vars = 'devices'

 
 

-        self.pickle_dir = pickle_dir
-        self.config_dir = config_dir
+    _restorable_defaults = dict(devices=get_devices())

 
 

-        try:
-            self._load()
-        except IOError:
-            # This is the first time the handler is used, create a basic
-            # setup using some nice defaults
-            self.devices = dict(
-                eth0=Device('eth0'),
-                eth1=Device('eth1'),
-                )
-            self._dump()
-        self.addr = AddressHandler(self.devices, config_dir, self)
-        self.route = RouteHandler(self.devices, config_dir, self)
-        self.dev = DeviceHandler(self.devices, config_dir)
-        self._write_config()
-
-    def commit(self):
-        r"commit() -> None :: Commit the changes and reload the DHCP service."
-        #esto seria para poner en una interfaz
-        #y seria que hace el pickle deberia llamarse
-        #al hacerse un commit
-        self._dump()
-        self._write_config()
-
-    @handler
-    def rollback(self):
-        r"rollback() -> None :: Discard the changes not yet commited."
-        self._load()
-
-    def _dump(self):
-        r"_dump() -> None :: Dump all persistent data to pickle files."
-        # XXX podría ir en una clase base
-        self._dump_var(self.devices, pickle_devices)
-
-
-    def _load(self):
-        r"_load() -> None :: Load all persistent data from pickle files."
-        # XXX podría ir en una clase base
-        self.devices = self._load_var(pickle_devices)
-
-    def _pickle_filename(self, name):
-        r"_pickle_filename() -> string :: Construct a pickle filename."
-        # XXX podría ir en una clase base
-        return path.join(self.pickle_dir, name) + pickle_ext
-
-    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
-        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."
-        # XXX podría ir en una clase base
-        return pickle.load(file(self._pickle_filename(name)))
+    _config_writer_files = ('device', 'ip_add', 'ip_del', 'ip_flush',
+                            'route_add', 'route_del', 'route_flush')
+    _config_writer_tpl_dir = path.join(path.dirname(__file__), 'templates')
+
+    def __init__(self, pickle_dir='.', config_dir='.'):
+        r"Initialize DhcpHandler object, see class documentation for details."
+        self._persistent_dir = pickle_dir
+        self._config_writer_cfg_dir = config_dir
+        self._config_build_templates()
+        self._restore()
+        self.addr = AddressHandler(self.devices)
+        self.route = RouteHandler(self.devices)
+        self.dev = DeviceHandler(self.devices)

 
     def _write_config(self):
         r"_write_config() -> None :: Execute all commands."
 
     def _write_config(self):
         r"_write_config() -> None :: Execute all commands."

-        pass
-
-
+        for device in self.devices.values():
+            print self._render_config('route_flush', dict(dev=device.name))
+            print self._render_config('ip_flush', dict(dev=device.name))
+            for address in device.addrs.values():
+                print self._render_config('ip_add', dict(
+                        dev = device.name,
+                        addr = address.ip,
+                        prefix = address.prefix,
+                        broadcast = address.broadcast,
+                    )
+                )
+            for route in device.routes:
+                print self._render_config('route_add', dict(
+                        dev = device.name,
+                        net_addr = route.net_addr,
+                        prefix = route.prefix,
+                        gateway = route.gateway,
+                    )
+                )

 
 
 if __name__ == '__main__':
 
     ip = IpHandler()
 
 
 if __name__ == '__main__':
 
     ip = IpHandler()

+    print '----------------------'

     ip.dev.up('eth0')
     ip.dev.up('eth0')

-    ip.dev.down('eth0')
-    ip.dev.show()

     ip.addr.add('eth0','192.168.0.23','24','192.168.255.255')
     ip.addr.add('eth0','192.168.0.26','24')
     ip.addr.add('eth0','192.168.0.23','24','192.168.255.255')
     ip.addr.add('eth0','192.168.0.26','24')

-    ip.addr.show('eth0')
-    ip.addr.flush('eth0')
+    ip.commit()

     ip.route.add('eth0','192.168.0.0','24','192.168.0.1')
     ip.route.add('eth0','192.168.0.0','24','192.168.0.1')

+    ip.route.add('eth0','192.168.0.5','24','192.168.0.1')
+    ip.commit()

     ip.route.flush('eth0')
     ip.route.flush('eth0')

-    #ip.addr.delete('eth0','192.168.0.23')
-    #ip.addr.delete('eth0','192.168.0.26')
\ No newline at end of file
+    ip.commit()
+    ip.addr.delete('eth0','192.168.0.23')
+    ip.commit()
+
+
+
+