Merge branch 'master' of git.llucax.com.ar:/var/lib/git/software/pymin into logging

* 'master' of git.llucax.com.ar:/var/lib/git/software/pymin:
  Add protocol specification of firewall and nat commands.
  Added the protocol specification.
  Root class inyects ip forwrading in constructor.
  Added route handling capabilities and service restarting
  Fix so that when a device is brought back up, the routes
  Added support to hook services to IPHandler.
  Support for inactive devices added in IPHandler.

Conflicts:

	pymin/services/ip/__init__.py

diff --cc config.py
Simple merge

diff --cc pymin/services/ip/__init__.py
index 71354abdbba6983ce20618ec4bed4a17261c01db,b1d50b2262378aed9ca20d1c4d144438a89b757c..a7e23cba0a251b40122f0eb1e8c8ec4eb0ebd922
--- 1/pymin/services/ip/__init__.py
--- 2/pymin/services/ip/__init__.py
+++ b/pymin/services/ip/__init__.py
@@@ -130,20 -159,32 +162,37 @@@ class DeviceHandler(SubHandler)
  
      @handler(u'Bring the device up')
      def up(self, name):
 +        log.debug(u'DeviceHandler.up(%r)', name)
          if name in self.parent.devices:
              call(self.device_template.render(dev=name, action='up'), shell=True)
 -                    print e
+             #bring up all the route asocitaed to the device
+             for route in self.parent.devices[name].routes:
+                 try:
++                    log.debug(u'IpHandler.up: adding %r', route)
+                     call(self.parent._render_config('route_add', dict(
+                             dev = name,
+                             net_addr = route.net_addr,
+                             prefix = route.prefix,
+                             gateway = route.gateway,
+                         )
+                     ), shell=True)
+                 except ExecutionError, e:
++                    log.debug(u'IpHandler.up: error adding %r -> %r', route, e)
+             self.parent._bring_up_no_dev_routes()
+             self.parent._restart_services()
          else:
 +            log.debug(u'DeviceHandler.up: device not found')
              raise DeviceNotFoundError(name)
  
      @handler(u'Bring the device down')
      def down(self, name):
 +        log.debug(u'DeviceHandler.down(%r)', name)
          if name in self.parent.devices:
              call(self.device_template.render(dev=name, action='down'), shell=True)
+             self.parent._bring_up_no_dev_routes()
+             self.parent._restart_services()
          else:
 +            log.debug(u'DeviceHandler.up: device not found')
              raise DeviceNotFoundError(name)
  
      @handler(u'List all devices')
@@@ -186,80 -227,132 +238,156 @@@ class IpHandler(Restorable, ConfigWrite
  
      def _write_config(self):
          r"_write_config() -> None :: Execute all commands."
 +        log.debug(u'IpHandler._write_config()')
          for device in self.devices.values():
 +            log.debug(u'IpHandler._write_config: processing device %s', device)
+             if device.active:
+                 self._write_config_for_device(device)
+         self._bring_up_no_dev_routes()
+         self._write_hops()
+ 
+     def _bring_up_no_dev_routes(self):
++        log.debug(u'IpHandler._bring_up_no_dev_routes()')
+         for route in self.no_device_routes:
              try:
-                 log.debug(u'IpHandler._write_config: flushing routes...')
-                 call(self._render_config('route_flush', dict(dev=device.name)),
-                         shell=True)
-             except ExecutionError, e:
-                 log.debug(u'IpHandler._write_config: error flushing -> %r', e)
-             try:
-                 log.debug(u'IpHandler._write_config: flushing addrs...')
-                 call(self._render_config('ip_flush', dict(dev=device.name)),
-                         shell=True)
++                log.debug(u'IpHandler._bring_up_no_dev_routes: add %r', route)
+                 call(self._render_config('route_add', dict(
+                         dev = None,
+                         net_addr = route.net_addr,
+                         prefix = route.prefix,
+                         gateway = route.gateway,
+                     )
+                 ), shell=True)
              except ExecutionError, e:
 -                print e
 +                log.debug(u'IpHandler._write_config: error flushing -> %r', e)
-             for address in device.addrs.values():
-                 broadcast = address.broadcast
-                 if broadcast is None:
-                     broadcast = '+'
-                 try:
-                     log.debug(u'IpHandler._write_config: adding %r', address)
-                     call(self._render_config('ip_add', dict(
-                             dev = device.name,
-                             addr = address.ip,
-                             netmask = address.netmask,
-                             peer = address.peer,
-                             broadcast = broadcast,
-                         )), shell=True)
-                 except ExecutionError, e:
-                     log.debug(u'IpHandler._write_config: error adding -> %r', e)
-             for route in device.routes:
-                 try:
-                     log.debug(u'IpHandler._write_config: adding %r', route)
-                     call(self._render_config('route_add', dict(
-                             dev = device.name,
-                             net_addr = route.net_addr,
-                             prefix = route.prefix,
-                             gateway = route.gateway,
-                         )), shell=True)
-                 except ExecutionError, e:
-                     log.debug(u'IpHandler._write_config: error adding -> %r', e)
+ 
+     def _write_hops(self):
+         r"_write_hops() -> None :: Execute all hops."
++        log.debug(u'IpHandler._write_hops()')
          if self.hops:
-             log.debug(u'IpHandler._write_config: we have hops: %r', self.hops)
++            log.debug(u'IpHandler._write_hops: we have hops: %r', self.hops)
              try:
-                 log.debug(u'IpHandler._write_config: flushing default route')
++                log.debug(u'IpHandler._write_hops: flushing default hops')
                  call('ip route del default', shell=True)
              except ExecutionError, e:
-                 log.debug(u'IpHandler._write_config: error adding -> %r', e)
 -                print e
++                log.debug(u'IpHandler._write_hops: error adding -> %r', e)
              try:
-                 log.debug(u'IpHandler._write_config: configuring hops')
++                log.debug(u'IpHandler._write_hops: configuring hops')
+                 #get hops for active devices
+                 active_hops = dict()
+                 for h in self.hops:
+                     if h.device in self.devices:
+                         if self.devices[h.device].active:
+                             active_hops.append(h)
                  call(self._render_config('hop', dict(
-                     hops = self.hops,
+                     hops = active_hops,
                          )
                  ), shell=True)
              except ExecutionError, e:
-                 log.debug(u'IpHandler._write_config: error adding -> %r', e)
 -                print e
++                log.debug(u'IpHandler._write_hops: error adding -> %r', e)
+ 
+     def _write_config_for_device(self, device):
 -        r"_write_config_for_device(self, device) -> None :: Execute all commands for a device."
++        r"_write_config_for_device(self, device) -> None :: Execute commands."
++        log.debug(u'IpHandler._write_config_for_device()')
+         try:
 -            call(self._render_config('route_flush', dict(dev=device.name)), shell=True)
++            log.debug(u'IpHandler._write_config_for_device: flushing routes...')
++            call(self._render_config('route_flush', dict(dev=device.name)),
++                        shell=True)
+         except ExecutionError, e:
 -            print e
++            log.debug(u'IpHandler._write_config_for_device: error flushing '
++                        u'-> %r', e)
+         try:
 -            call(self._render_config('ip_flush', dict(dev=device.name)), shell=True)
++            log.debug(u'IpHandler._write_config_for_device: flushing addrs...')
++            call(self._render_config('ip_flush', dict(dev=device.name)),
++                        shell=True)
+         except ExecutionError, e:
 -            print e
++            log.debug(u'IpHandler._write_config_for_device: error flushing '
++                        u'-> %r', e)
+         for address in device.addrs.values():
+             broadcast = address.broadcast
+             if broadcast is None:
+                 broadcast = '+'
+             try:
++                log.debug(u'IpHandler._write_config_for_device: adding %r',
++                            address)
+                 call(self._render_config('ip_add', dict(
+                     dev = device.name,
+                     addr = address.ip,
+                     netmask = address.netmask,
+                     peer = address.peer,
+                     broadcast = broadcast,
+                     )
+                 ), shell=True)
+             except ExecutionError, e:
 -                print e
++                log.debug(u'IpHandler._write_config_for_device: error adding '
++                            u'-> %r', e)
+         for route in device.routes:
+             try:
++                log.debug(u'IpHandler._write_config_for_device: adding %r',
++                            route)
+                 call(self._render_config('route_add', dict(
+                         dev = device.name,
+                         net_addr = route.net_addr,
+                         prefix = route.prefix,
+                         gateway = route.gateway,
+                     )
+                 ), shell=True)
+             except ExecutionError, e:
 -                print e
++                log.debug(u'IpHandler._write_config_for_device: error adding '
++                            u'-> %r', e)
  
      def handle_timer(self):
 +        log.debug(u'IpHandler.handle_timer()')
          self.refresh_devices()
  
 -
      def refresh_devices(self):
 +        log.debug(u'IpHandler.update_devices()')
          devices = get_network_devices()
-         #add not registered devices
+         #add not registered and active devices
+         go_active = False
          for k,v in devices.items():
              if k not in self.devices:
 +                log.debug(u'IpHandler.update_devices: adding %r', v)
                  self.devices[k] = v
-         #delete dead devices
+             elif not self.devices[k].active:
+                 self.active = True
+                 go_active = True
+                 self._write_config_for_device(self.devices[k])
+         if go_active:
+             self._write_hops()
+             self._bring_up_no_dev_routes()
+             self._restart_services()
+ 
+         #mark inactive devices
          for k in self.devices.keys():
+             go_down = False
              if k not in devices:
-                 del self.devices[k]
 +                log.debug(u'IpHandler.update_devices: removing %s', k)
+                 self.devices[k].active = False
+                 go_down = True
+             if go_down:
+                 self._bring_up_no_dev_routes()
+ 
+     def _restart_services(self):
+         for s in self.services:
+             if s._service_running:
+                 try:
+                      s.stop()
+                 except ExecutionError:
+                     pass
+                 try:
+                     s.start()
+                 except ExecutionError:
+                     pass
+ 
+       #hooks a service to the ip handler, so when
+       #a device is brought up one can restart the service
+       #that need to refresh their device list
+     def device_up_hook(self, serv):
+         if hasattr(serv, 'stop') and hasattr(serv, 'start'):
+             self.services.append(serv)
+ 
+ 
  
  
  

diff --cc pymin/services/util.py
Simple merge