services/ip/__init__.py

   1 # vim: set encoding=utf-8 et sw=4 sts=4 :
   2
   3 from mako.template import Template
   4 from mako.runtime import Context
   5 from subprocess import Popen, PIPE
   6 from os import path
   7 try:
   8     import cPickle as pickle
   9 except ImportError:
  10     import pickle
  11
  12 try:
  13     from seqtools import Sequence
  14 except ImportError:
  15     # NOP for testing
  16     class Sequence: pass
  17 try:
  18     from dispatcher import handler, HandlerError, Handler
  19 except ImportError:
  20     # NOP for testing
  21     class HandlerError(RuntimeError): pass
  22     class Handler: pass
  23     def handler(help):
  24         def wrapper(f):
  25             return f
  26         return wrapper
  27
  28 __ALL__ = ('IpHandler','Error','DeviceError','DeviceNotFoundError','RouteError','RouteNotFoundError',
  29             'RouteAlreadyExistsError','AddressError','AddressNotFoundError','AddressAlreadyExistsError')
  30
  31 pickle_ext = '.pkl'
  32 pickle_devices = 'devs'
  33
  34 template_dir = path.join(path.dirname(__file__), 'templates')
  35 command_filename = 'command'
  36
  37
  38 device_com = 'device.command'
  39 ip_add_com = 'ip_add.command'
  40 ip_del_com = 'ip_del.command'
  41 ip_flush_com = 'ip_flush.command'
  42 route_add_com = 'route_add.command'
  43 route_del_com = 'route_del.command'
  44 route_flush_com = 'route_flush.command'
  45
  46 class Error(HandlerError):
  47     r"""
  48     Error(command) -> Error instance :: Base IpHandler exception class.
  49
  50     All exceptions raised by the IpHandler inherits from this one, so you can
  51     easily catch any IpHandler exception.
  52
  53     message - A descriptive error message.
  54     """
  55
  56     def __init__(self, message):
  57         r"Initialize the Error object. See class documentation for more info."
  58         self.message = message
  59
  60     def __str__(self):
  61         return self.message
  62
  63 class DeviceError(Error):
  64
  65     def __init__(self, device):
  66         self.message = 'Device error : "%s"' % device
  67
  68 class DeviceNotFoundError(DeviceError):
  69
  70     def __init__(self, device):
  71         self.message = 'Device not found : "%s"' % device
  72
  73 class AddressError(Error):
  74
  75     def __init__(self, addr):
  76         self.message = 'Address error : "%s"' % addr
  77
  78 class AddressNotFoundError(AddressError):
  79
  80     def __init__(self, address):
  81         self.message = 'Address not found : "%s"' % address
  82
  83 class AddressAlreadyExistsError(AddressError):
  84
  85     def __init__(self, address):
  86         self.message = 'Address already exists : "%s"' % address
  87
  88 class RouteError(Error):
  89
  90     def __init__(self, route):
  91         self.message = 'Route error : "%s"' % route
  92
  93 class RouteNotFoundError(RouteError):
  94
  95     def __init__(self, route):
  96         self.message = 'Route not found : "%s"' % route
  97
  98 class RouteAlreadyExistsError(RouteError):
  99
 100     def __init__(self, route):
 101         self.message = 'Route already exists : "%s"' % route
 102
 103 class Route(Sequence):
 104
 105     def __init__(self, net_addr, prefix, gateway):
 106         self.net_addr = net_addr
 107         self.prefix = prefix
 108         self.gateway = gateway
 109
 110     def as_tuple(self):
 111         return(self.addr, self.prefix, self.gateway)
 112
 113     def __cmp__(self, other):
 114         if self.net_addr == other.net_addr \
 115                 and self.prefix == other.prefix \
 116                 and self.gateway == other.gateway:
 117             return 0
 118         return cmp(id(self), id(other))
 119
 120 class RouteHandler(Handler):
 121
 122     def __init__(self, devices):
 123         self.devices = devices
 124
 125     @handler(u'Adds a route to a device')
 126     def add(self, device, net_addr, prefix, gateway):
 127         if not device in self.devices:
 128             raise DeviceNotFoundError(device)
 129         r = Route(net_addr, prefix, gateway)
 130         try:
 131             self.devices[device].routes.index(r)
 132             raise RouteAlreadyExistsError(net_addr + '/' + prefix + '->' + gateway)
 133         except ValueError:
 134             self.devices[device].routes.append(r)
 135
 136     @handler(u'Deletes a route from a device')
 137     def delete(self, device, net_addr, prefix, gateway):
 138         if not device in self.devices:
 139             raise DeviceNotFoundError(device)
 140         r = Route(net_addr, prefix, gateway)
 141         try:
 142             self.devices[device].routes.remove(r)
 143         except ValueError:
 144             raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
 145
 146     @handler(u'Flushes routes from a device')
 147     def flush(self, device):
 148         if not device in self.devices:
 149             raise DeviceNotFoundError(device)
 150         self.devices[device].routes = list()
 151
 152
 153     @handler(u'List routes')
 154     def list(self, device):
 155         try:
 156             k = self.devices[device].routes.keys()
 157         except ValueError:
 158             k = list()
 159         return k
 160
 161     @handler(u'Get information about all routes')
 162     def show(self):
 163         try:
 164             k = self.devices[device].routes.values()
 165         except ValueError:
 166             k = list()
 167         return k
 168
 169 class Address(Sequence):
 170
 171     def __init__(self, ip, prefix, broadcast):
 172         self.ip = ip
 173         self.prefix = prefix
 174         self.broadcast = broadcast
 175
 176     def as_tuple(self):
 177         return (self.ip, self.prefix, self.broadcast)
 178
 179 class AddressHandler(Handler):
 180
 181     def __init__(self, devices):
 182         self.devices = devices
 183
 184     @handler(u'Adds an address to a device')
 185     def add(self, device, ip, prefix, broadcast='+'):
 186         if not device in self.devices:
 187             raise DeviceNotFoundError(device)
 188         if ip in self.devices[device].addrs:
 189             raise AddressAlreadyExistsError(ip)
 190         self.devices[device].addrs[ip] = Address(ip, prefix, broadcast)
 191
 192     @handler(u'Deletes an address from a device')
 193     def delete(self, device, ip):
 194         if not device in self.devices:
 195             raise DeviceNotFoundError(device)
 196         if not ip in self.devices[device].addrs:
 197             raise AddressNotFoundError(ip)
 198         del self.devices[device].addrs[ip]
 199
 200     @handler(u'Flushes addresses from a device')
 201     def flush(self, device):
 202         if not device in self.devices:
 203             raise DeviceNotFoundError(device)
 204         self.devices[device].addrs = dict()
 205
 206     @handler(u'List all addresses from a device')
 207     def list(self, device):
 208         try:
 209             k = self.devices[device].addrs.keys()
 210         except ValueError:
 211             k = list()
 212         return k
 213
 214     @handler(u'Get information about addresses from a device')
 215     def show(self, device):
 216         try:
 217             k = self.devices[device].addrs.values()
 218         except ValueError:
 219             k = list()
 220         return k
 221
 222 class Device(Sequence):
 223
 224     def __init__(self, name, mac):
 225         self.name = name
 226         self.mac = mac
 227         self.addrs = dict()
 228         self.routes = list()
 229
 230     def as_tuple(self):
 231         return (self.name, self.mac)
 232
 233 class DeviceHandler(Handler):
 234
 235     def __init__(self, devices):
 236         self.devices = devices
 237         dev_fn = path.join(template_dir, device_com)
 238         self.device_template = Template(filename=dev_fn)
 239
 240     @handler(u'Bring the device up')
 241     def up(self, name):
 242         if name in self.devices:
 243             print self.device_template.render(dev=name, action='up')
 244         else:
 245             raise DeviceNotFoundError(name)
 246
 247     @handler(u'Bring the device down')
 248     def down(self, name):
 249         if name in self.devices:
 250             print self.device_template.render(dev=name, action='down')
 251         else:
 252             raise DeviceNotFoundError(name)
 253
 254     @handler(u'List all devices')
 255     def list(self):
 256         return self.devices.keys()
 257
 258     @handler(u'Get information about a device')
 259     def show(self):
 260         return self.devices.items()
 261
 262 class IpHandler(Handler):
 263
 264     def __init__(self, pickle_dir='.', config_dir='.'):
 265         r"Initialize DhcpHandler object, see class documentation for details."
 266
 267         self.pickle_dir = pickle_dir
 268         self.config_dir = config_dir
 269
 270         ip_add_fn = path.join(template_dir, ip_add_com)
 271         ip_del_fn = path.join(template_dir, ip_del_com)
 272         ip_flush_fn = path.join(template_dir, ip_flush_com)
 273         self.ip_add_template = Template(filename=ip_add_fn)
 274         self.ip_del_template = Template(filename=ip_del_fn)
 275         self.ip_flush_template = Template(filename=ip_flush_fn)
 276
 277         route_add_fn = path.join(template_dir, route_add_com)
 278         route_del_fn = path.join(template_dir, route_del_com)
 279         route_flush_fn = path.join(template_dir, route_flush_com)
 280         self.route_add_template = Template(filename=route_add_fn)
 281         self.route_del_template = Template(filename=route_del_fn)
 282         self.route_flush_template = Template(filename=route_flush_fn)
 283
 284         try:
 285             self._load()
 286         except IOError:
 287             p = Popen('ip link list', shell=True, stdout=PIPE, close_fds=True)
 288             devs = _get_devices(p.stdout.read())
 289             self.devices = dict()
 290             for eth, mac in devs:
 291                 self.devices[eth] = Device(eth, mac)
 292             self._dump()
 293         self.addr = AddressHandler(self.devices)
 294         self.route = RouteHandler(self.devices)
 295         self.dev = DeviceHandler(self.devices)
 296         self.commit()
 297
 298     @handler(u'Commit the changes (reloading the service, if necessary).')
 299     def commit(self):
 300         r"commit() -> None :: Commit the changes and reload the DHCP service."
 301         #esto seria para poner en una interfaz
 302         #y seria que hace el pickle deberia llamarse
 303         #al hacerse un commit
 304         self._dump()
 305         self._write_config()
 306
 307     @handler(u'Discard all the uncommited changes.')
 308     def rollback(self):
 309         r"rollback() -> None :: Discard the changes not yet commited."
 310         self._load()
 311
 312     def _dump(self):
 313         r"_dump() -> None :: Dump all persistent data to pickle files."
 314         # XXX podría ir en una clase base
 315         self._dump_var(self.devices, pickle_devices)
 316
 317
 318     def _load(self):
 319         r"_load() -> None :: Load all persistent data from pickle files."
 320         # XXX podría ir en una clase base
 321         self.devices = self._load_var(pickle_devices)
 322
 323     def _pickle_filename(self, name):
 324         r"_pickle_filename() -> string :: Construct a pickle filename."
 325         # XXX podría ir en una clase base
 326         return path.join(self.pickle_dir, name) + pickle_ext
 327
 328     def _dump_var(self, var, name):
 329         r"_dump_var() -> None :: Dump a especific variable to a pickle file."
 330         # XXX podría ir en una clase base
 331         pkl_file = file(self._pickle_filename(name), 'wb')
 332         pickle.dump(var, pkl_file, 2)
 333         pkl_file.close()
 334
 335     def _load_var(self, name):
 336         r"_load_var()7 -> object :: Load a especific pickle file."
 337         # XXX podría ir en una clase base
 338         return pickle.load(file(self._pickle_filename(name)))
 339
 340     def _write_config(self):
 341         r"_write_config() -> None :: Execute all commands."
 342         for device in self.devices.values():
 343             print self.route_flush_template.render(dev=device.name)
 344             print self.ip_flush_template.render(dev=device.name)
 345             for address in device.addrs.values():
 346                 print self.ip_add_template.render(
 347                     dev=device.name,
 348                     addr=address.ip,
 349                     prefix=address.prefix,
 350                     broadcast=address.broadcast
 351                     )
 352             for route in device.routes:
 353                 print self.route_add_template.render(
 354                     dev=device.name,
 355                     net_addr=route.net_addr,
 356                     prefix=route.prefix,
 357                     gateway=route.gateway
 358                     )
 359
 360 def _get_devices(string):
 361    l = list()
 362    i = string.find('eth')
 363    while i != -1:
 364        eth = string[i:i+4]
 365        m = string.find('link/ether', i+4)
 366        mac = string[ m+11 : m+11+17]
 367        l.append((eth,mac))
 368        i = string.find('eth', m+11+17)
 369    return l
 370
 371 if __name__ == '__main__':
 372
 373     ip = IpHandler()
 374     print '----------------------'
 375     ip.dev.up('eth0')
 376     ip.addr.add('eth0','192.168.0.23','24','192.168.255.255')
 377     ip.addr.add('eth0','192.168.0.26','24')
 378     ip.commit()
 379     ip.route.add('eth0','192.168.0.0','24','192.168.0.1')
 380     ip.route.add('eth0','192.168.0.5','24','192.168.0.1')
 381     ip.commit()
 382     ip.route.flush('eth0')
 383     ip.commit()
 384     ip.addr.delete('eth0','192.168.0.23')
 385     ip.commit()
 386
 387
 388
 389