Se modifica el comando ip.

Se  modifica para que haga el flush ante un commit
y ademas se parse la salida del ip link list para
cargar en el init los devices y direcciones mac de
cada device

diff --git a/services/ip/__init__.py b/services/ip/__init__.py
index c2fff476e800f0449ebe5a1125362bb59ad26537..9152ba403b12ac7d8ac2fec9a9a39920dfff39bf 100644 (file)
--- a/services/ip/__init__.py
+++ b/services/ip/__init__.py
@@ -2,6 +2,7 @@
 
 from mako.template import Template
 from mako.runtime import Context
+from subprocess import Popen, PIPE
 from os import path
 try:
     import cPickle as pickle
@@ -104,18 +105,17 @@ class Route(Sequence):
     def as_tuple(self):
         return(self.addr, self.prefix, self.gateway)
 
+    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))
+
 class RouteHandler:
 
-    def __init__(self, devices, config_dir, ip_handler):
+    def __init__(self, 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
     def add(self, device, net_addr, prefix, gateway):
@@ -126,44 +126,24 @@ class RouteHandler:
             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.ip_handler.commit()
-
 
     @handler
     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)
+        try:
+            self.devices[device].routes.remove(r)
+        except ValueError:
+            raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
 
     @handler
     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.ip_handler.commit()
+
 
     @handler
     def list(self, device):
@@ -193,17 +173,8 @@ class Address(Sequence):
 
 class AddressHandler:
 
-    def __init__(self, devices, config_dir, ip_handler):
+    def __init__(self, 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
     def add(self, device, ip, prefix, broadcast='+'):
@@ -211,13 +182,7 @@ class AddressHandler:
             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.ip_handler.commit()
 
     @handler
     def delete(self, device, ip):
@@ -225,27 +190,13 @@ class AddressHandler:
             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]
-        self.ip_handler.commit()
-
 
     @handler
     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.ip_handler.commit()
-
 
     @handler
     def list(self, device):
@@ -265,41 +216,33 @@ class AddressHandler:
 
 class Device(Sequence):
 
-    def __init__(self, name):
+    def __init__(self, name, mac):
         self.name = name
+        self.mac = mac
         self.addrs = dict()
         self.routes = list()
 
     def as_tuple(self):
-        return (self.name, self.addrs, self.routes)
+        return (self.name, self.mac)
 
 class DeviceHandler:
 
-    def __init__(self, devices, config_dir = '.'):
+    def __init__(self, devices):
         self.devices = devices
         dev_fn = path.join(template_dir, device_com)
         self.device_template = Template(filename=dev_fn)
-        self.config_dir = config_dir
 
     @handler
     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)
 
     @handler
     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)
 
@@ -311,11 +254,6 @@ class DeviceHandler:
     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()
-
 class IpHandler:
 
     def __init__(self, pickle_dir='.', config_dir='.'):
@@ -324,21 +262,35 @@ class IpHandler:
         self.pickle_dir = pickle_dir
         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)
+
+        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)
+
         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'),
-                )
+            p = Popen('ip link list', shell=True, stdout=PIPE, close_fds=True)
+            devs = _get_devices(p.stdout.read())
+            self.devices = dict()
+            for eth, mac in devs.values():
+                self.devices[eth] = Device(eth, mac)
             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()
+        self.addr = AddressHandler(self.devices)
+        self.route = RouteHandler(self.devices)
+        self.dev = DeviceHandler(self.devices)
+        self.commit()
 
+    @handler
     def commit(self):
         r"commit() -> None :: Commit the changes and reload the DHCP service."
         #esto seria para poner en una interfaz
@@ -376,28 +328,57 @@ class IpHandler:
         pkl_file.close()
 
     def _load_var(self, name):
-        r"_load_var() -> object :: Load a especific pickle file."
+        r"_load_var()7 -> object :: Load a especific pickle file."
         # XXX podría ir en una clase base
         return pickle.load(file(self._pickle_filename(name)))
 
     def _write_config(self):
         r"_write_config() -> None :: Execute all commands."
-        pass
-
-
-
+        for device in self.devices.values():
+            print self.route_flush_template.render(dev=device.name)
+            print self.ip_flush_template.render(dev=device.name)
+            for address in device.addrs.values():
+                print self.ip_add_template.render(
+                    dev=device.name,
+                    addr=address.ip,
+                    prefix=address.prefix,
+                    broadcast=address.broadcast
+                    )
+            for route in device.routes:
+                print self.route_add_template.render(
+                    dev=device.name,
+                    net_addr=route.net_addr,
+                    prefix=route.prefix,
+                    gateway=route.gateway
+                    )
+
+    def _get_devices(string):
+       l = list()
+       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]
+           l.append((eth,mac))
+           i = string.find('eth', m+11+17)
+       return l
 
 if __name__ == '__main__':
 
     ip = IpHandler()
+    print '----------------------'
     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.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.5','24','192.168.0.1')
+    ip.commit()
     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()
+
+
+
+