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