services/dhcp/__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 try:
  11     from dispatcher import handler
  12 except ImportError:
  13     def handler(f): return f # NOP for testing
  14
  15 __ALL__ = ('DhcpHandler',)
  16
  17 pickle_ext = '.pkl'
  18 pickle_vars = 'vars'
  19 pickle_hosts = 'hosts'
  20
  21 config_filename = 'dhcpd.conf'
  22
  23 template_dir = path.join(path.dirname(__file__), 'templates')
  24
  25 class Error(RuntimeError):
  26     r"""
  27     Error(command) -> Error instance :: Base DhcpHandler exception class.
  28
  29     All exceptions raised by the DhcpHandler inherits from this one, so you can
  30     easily catch any DhcpHandler exception.
  31
  32     message - A descriptive error message.
  33     """
  34
  35     def __init__(self, message):
  36         r"Initialize the Error object. See class documentation for more info."
  37         self.message = message
  38
  39     def __str__(self):
  40         return self.message
  41
  42 class HostError(Error, KeyError):
  43     r"""
  44     HostError(hostname) -> HostError instance
  45
  46     This is the base exception for all host related errors.
  47     """
  48
  49     def __init__(self, hostname):
  50         r"Initialize the object. See class documentation for more info."
  51         self.message = 'Host error: "%s"' % hostname
  52
  53 class HostAlreadyExistsError(HostError):
  54     r"""
  55     HostAlreadyExistsError(hostname) -> HostAlreadyExistsError instance
  56
  57     This exception is raised when trying to add a hostname that already exists.
  58     """
  59
  60     def __init__(self, hostname):
  61         r"Initialize the object. See class documentation for more info."
  62         self.message = 'Host already exists: "%s"' % hostname
  63
  64 class HostNotFoundError(HostError):
  65     r"""
  66     HostNotFoundError(hostname) -> HostNotFoundError instance
  67
  68     This exception is raised when trying to operate on a hostname that doesn't
  69     exists.
  70     """
  71
  72     def __init__(self, hostname):
  73         r"Initialize the object. See class documentation for more info."
  74         self.message = 'Host not found: "%s"' % hostname
  75
  76 class ParameterError(Error, KeyError):
  77     r"""
  78     ParameterError(paramname) -> ParameterError instance
  79
  80     This is the base exception for all DhcpHandler parameters related errors.
  81     """
  82
  83     def __init__(self, paramname):
  84         r"Initialize the object. See class documentation for more info."
  85         self.message = 'Parameter error: "%s"' % paramname
  86
  87 class ParameterNotFoundError(ParameterError):
  88     r"""
  89     ParameterNotFoundError(hostname) -> ParameterNotFoundError instance
  90
  91     This exception is raised when trying to operate on a parameter that doesn't
  92     exists.
  93     """
  94
  95     def __init__(self, paramname):
  96         r"Initialize the object. See class documentation for more info."
  97         self.message = 'Parameter not found: "%s"' % paramname
  98
  99
 100 class Host:
 101     r"""Host(name, ip, mac) -> Host instance :: Class representing a host.
 102
 103     name - Host name, should be a fully qualified name, but no checks are done.
 104     ip - IP assigned to the hostname.
 105     mac - MAC address to associate to the hostname.
 106     """
 107
 108     def __init__(self, name, ip, mac):
 109         r"Initialize Host object, see class documentation for details."
 110         self.name = name
 111         self.ip = ip
 112         self.mac = mac
 113
 114 class HostHandler:
 115     r"""HostHandler(hosts) -> HostHandler instance :: Handle a list of hosts.
 116
 117     This class is a helper for DhcpHandler to do all the work related to hosts
 118     administration.
 119
 120     hosts - A dictionary with string keys (hostnames) and Host instances values.
 121     """
 122
 123     def __init__(self, hosts):
 124         r"Initialize HostHandler object, see class documentation for details."
 125         self.hosts = hosts
 126
 127     @handler
 128     def add(self, name, ip, mac):
 129         r"add(name, ip, mac) -> None :: Add a host to the hosts list."
 130         if name in self.hosts:
 131             raise HostAlreadyExistsError(name)
 132         self.hosts[name] = Host(name, ip, mac)
 133
 134     @handler
 135     def update(self, name, ip=None, mac=None):
 136         r"update(name[, ip[, mac]]) -> None :: Update a host of the hosts list."
 137         if not name in self.hosts:
 138             raise HostNotFoundError(name)
 139         if ip is not None:
 140             self.hosts[name].ip = ip
 141         if mac is not None:
 142             self.hosts[name].mac = mac
 143
 144     @handler
 145     def delete(self, name):
 146         r"delete(name) -> None :: Delete a host of the hosts list."
 147         if not name in self.hosts:
 148             raise HostNotFoundError(name)
 149         del self.hosts[name]
 150
 151     @handler
 152     def get(self, name):
 153         r"""get(name) -> CSV string :: List all the information of a host.
 154
 155         The host is returned as a CSV list of: hostname,ip,mac
 156         """
 157         if not name in self.hosts:
 158             raise HostNotFoundError(name)
 159         h = self.hosts[name]
 160         return '%s,%s,%s' % (h.name, h.ip, h.mac)
 161
 162     @handler
 163     def list(self):
 164         r"""list() -> CSV string :: List all the hostnames.
 165
 166         The list is returned as a single CSV line with all the hostnames.
 167         """
 168         return ','.join(self.hosts)
 169
 170     @handler
 171     def show(self):
 172         r"""show() -> CSV string :: List all the complete hosts information.
 173
 174         The hosts are returned as a CSV list with each host in a line, like:
 175         hostname,ip,mac
 176         """
 177         hosts = self.hosts.values()
 178         return '\n'.join('%s,%s,%s' % (h.name, h.ip, h.mac) for h in hosts)
 179
 180 class DhcpHandler:
 181     r"""DhcpHandler([pickle_dir[, config_dir]]) -> DhcpHandler instance.
 182
 183     Handles DHCP service commands for the dhcpd program.
 184
 185     pickle_dir - Directory where to write the persistent configuration data.
 186
 187     config_dir - Directory where to store de generated configuration files.
 188
 189     Both defaults to the current working directory.
 190     """
 191
 192     def __init__(self, pickle_dir='.', config_dir='.'):
 193         r"Initialize DhcpHandler object, see class documentation for details."
 194         self.pickle_dir = pickle_dir
 195         self.config_dir = config_dir
 196         filename = path.join(template_dir, config_filename)
 197         self.template = Template(filename=filename)
 198         try:
 199             self._load()
 200         except IOError:
 201             # This is the first time the handler is used, create a basic
 202             # setup using some nice defaults
 203             self.hosts = dict()
 204             self.vars = dict(
 205                 domain_name = 'example.com',
 206                 dns_1       = 'ns1.example.com',
 207                 dns_2       = 'ns2.example.com',
 208                 net_address = '192.168.0.0',
 209                 net_mask    = '255.255.255.0',
 210                 net_start   = '192.168.0.100',
 211                 net_end     = '192.168.0.200',
 212                 net_gateway = '192.168.0.1',
 213             )
 214             self._dump()
 215             self._write_config()
 216         self.host = HostHandler(self.hosts)
 217
 218     @handler
 219     def set(self, param, value):
 220         r"set(param, value) -> None :: Set a DHCP parameter."
 221         if not param in self.vars:
 222             raise ParameterNotFoundError(param)
 223         self.vars[param] = value
 224
 225     @handler
 226     def get(self, param):
 227         r"get(param) -> None :: Get a DHCP parameter."
 228         if not param in self.vars:
 229             raise ParameterNotFoundError(param)
 230         return self.vars[param]
 231
 232     @handler
 233     def list(self):
 234         r"""list() -> CSV string :: List all the parameter names.
 235
 236         The list is returned as a single CSV line with all the names.
 237         """
 238         return ','.join(self.vars)
 239
 240     @handler
 241     def show(self):
 242         r"""show() -> CSV string :: List all the parameters (with their values).
 243
 244         The parameters are returned as a CSV list with each parameter in a
 245         line, like:
 246         name,value
 247         """
 248         return '\n'.join(('%s,%s' % (k, v) for (k, v) in self.vars.items()))
 249
 250     @handler
 251     def start(self):
 252         r"start() -> None :: Start the DHCP service."
 253         #esto seria para poner en una interfaz
 254         #y seria el hook para arrancar el servicio
 255         pass
 256
 257     @handler
 258     def stop(self):
 259         r"stop() -> None :: Stop the DHCP service."
 260         #esto seria para poner en una interfaz
 261         #y seria el hook para arrancar el servicio
 262         pass
 263
 264     @handler
 265     def restart(self):
 266         r"restart() -> None :: Restart the DHCP service."
 267         #esto seria para poner en una interfaz
 268         #y seria el hook para arrancar el servicio
 269         pass
 270
 271     @handler
 272     def reload(self):
 273         r"reload() -> None :: Reload the configuration of the DHCP service."
 274         #esto seria para poner en una interfaz
 275         #y seria el hook para arrancar el servicio
 276         pass
 277
 278     @handler
 279     def commit(self):
 280         r"commit() -> None :: Commit the changes and reload the DHCP service."
 281         #esto seria para poner en una interfaz
 282         #y seria que hace el pickle deberia llamarse
 283         #al hacerse un commit
 284         self._dump()
 285         self._write_config()
 286         self.reload()
 287
 288     @handler
 289     def rollback(self):
 290         r"rollback() -> None :: Discard the changes not yet commited."
 291         self._load()
 292
 293     def _dump(self):
 294         r"_dump() -> None :: Dump all persistent data to pickle files."
 295         # XXX podría ir en una clase base
 296         self._dump_var(self.vars, pickle_vars)
 297         self._dump_var(self.hosts, pickle_hosts)
 298
 299     def _load(self):
 300         r"_load() -> None :: Load all persistent data from pickle files."
 301         # XXX podría ir en una clase base
 302         self.vars = self._load_var(pickle_vars)
 303         self.hosts = self._load_var(pickle_hosts)
 304
 305     def _pickle_filename(self, name):
 306         r"_pickle_filename() -> string :: Construct a pickle filename."
 307         # XXX podría ir en una clase base
 308         return path.join(self.pickle_dir, name) + pickle_ext
 309
 310     def _dump_var(self, var, name):
 311         r"_dump_var() -> None :: Dump a especific variable to a pickle file."
 312         # XXX podría ir en una clase base
 313         pkl_file = file(self._pickle_filename(name), 'wb')
 314         pickle.dump(var, pkl_file, 2)
 315         pkl_file.close()
 316
 317     def _load_var(self, name):
 318         r"_load_var() -> object :: Load a especific pickle file."
 319         # XXX podría ir en una clase base
 320         return pickle.load(file(self._pickle_filename(name)))
 321
 322     def _write_config(self):
 323         r"_write_config() -> None :: Generate all the configuration files."
 324         # XXX podría ir en una clase base, ver como generalizar variables a
 325         # reemplazar en la template
 326         out_file = file(path.join(self.config_dir, config_filename), 'w')
 327         ctx = Context(out_file, hosts=self.hosts.values(), **self.vars)
 328         self.template.render_context(ctx)
 329         out_file.close()
 330
 331 if __name__ == '__main__':
 332
 333     import os
 334
 335     dhcp_handler = DhcpHandler()
 336
 337     def dump():
 338         print '-' * 80
 339         print 'Variables:', dhcp_handler.list()
 340         print dhcp_handler.show()
 341         print
 342         print 'Hosts:', dhcp_handler.host.list()
 343         print dhcp_handler.host.show()
 344         print '-' * 80
 345
 346     dump()
 347
 348     dhcp_handler.host.add('my_name','192.168.0.102','00:12:ff:56')
 349
 350     dhcp_handler.host.update('my_name','192.168.0.192','00:12:ff:56')
 351
 352     dhcp_handler.host.add('nico','192.168.0.188','00:00:00:00')
 353
 354     dhcp_handler.set('domain_name','baryon.com.ar')
 355
 356     try:
 357         dhcp_handler.set('sarasa','baryon.com.ar')
 358     except KeyError, e:
 359         print 'Error:', e
 360
 361     dhcp_handler.commit()
 362
 363     dump()
 364
 365     for f in (pickle_vars + pickle_ext, pickle_hosts + pickle_ext,
 366                                                             config_filename):
 367         os.unlink(f)
 368