pymin/services/dhcp/__init__.py

   1 # vim: set encoding=utf-8 et sw=4 sts=4 :
   2
   3 from os import path
   4
   5 from pymin.seqtools import Sequence
   6 from pymin.dispatcher import Handler, handler, HandlerError
   7 from pymin.services.util import Restorable, ConfigWriter, InitdHandler, \
   8                                 TransactionalHandler, ParametersHandler
   9
  10 __ALL__ = ('DhcpHandler', 'Error', 'HostError', 'HostAlreadyExistsError',
  11             'HostNotFoundError')
  12
  13 class Error(HandlerError):
  14     r"""
  15     Error(message) -> Error instance :: Base DhcpHandler exception class.
  16
  17     All exceptions raised by the DhcpHandler inherits from this one, so you can
  18     easily catch any DhcpHandler exception.
  19
  20     message - A descriptive error message.
  21     """
  22     pass
  23
  24 class HostError(Error, KeyError):
  25     r"""
  26     HostError(hostname) -> HostError instance
  27
  28     This is the base exception for all host related errors.
  29     """
  30
  31     def __init__(self, hostname):
  32         r"Initialize the object. See class documentation for more info."
  33         self.message = u'Host error: "%s"' % hostname
  34
  35 class HostAlreadyExistsError(HostError):
  36     r"""
  37     HostAlreadyExistsError(hostname) -> HostAlreadyExistsError instance
  38
  39     This exception is raised when trying to add a hostname that already exists.
  40     """
  41
  42     def __init__(self, hostname):
  43         r"Initialize the object. See class documentation for more info."
  44         self.message = u'Host already exists: "%s"' % hostname
  45
  46 class HostNotFoundError(HostError):
  47     r"""
  48     HostNotFoundError(hostname) -> HostNotFoundError instance
  49
  50     This exception is raised when trying to operate on a hostname that doesn't
  51     exists.
  52     """
  53
  54     def __init__(self, hostname):
  55         r"Initialize the object. See class documentation for more info."
  56         self.message = u'Host not found: "%s"' % hostname
  57
  58
  59 class Host(Sequence):
  60     r"""Host(name, ip, mac) -> Host instance :: Class representing a host.
  61
  62     name - Host name, should be a fully qualified name, but no checks are done.
  63     ip - IP assigned to the hostname.
  64     mac - MAC address to associate to the hostname.
  65     """
  66
  67     def __init__(self, name, ip, mac):
  68         r"Initialize Host object, see class documentation for details."
  69         self.name = name
  70         self.ip = ip
  71         self.mac = mac
  72
  73     def as_tuple(self):
  74         r"Return a tuple representing the host."
  75         return (self.name, self.ip, self.mac)
  76
  77 class HostHandler(Handler):
  78     r"""HostHandler(hosts) -> HostHandler instance :: Handle a list of hosts.
  79
  80     This class is a helper for DhcpHandler to do all the work related to hosts
  81     administration.
  82
  83     hosts - A dictionary with string keys (hostnames) and Host instances values.
  84     """
  85
  86     handler_help = u"Manage DHCP hosts"
  87
  88     def __init__(self, parent):
  89         r"Initialize HostHandler object, see class documentation for details."
  90         self.parent = parent
  91
  92     @handler(u'Add a new host')
  93     def add(self, name, ip, mac):
  94         r"add(name, ip, mac) -> None :: Add a host to the hosts list."
  95         if name in self.parent.hosts:
  96             raise HostAlreadyExistsError(name)
  97         self.parent.hosts[name] = Host(name, ip, mac)
  98
  99     @handler(u'Update a host')
 100     def update(self, name, ip=None, mac=None):
 101         r"update(name[, ip[, mac]]) -> None :: Update a host of the hosts list."
 102         if not name in self.parent.hosts:
 103             raise HostNotFoundError(name)
 104         if ip is not None:
 105             self.parent.hosts[name].ip = ip
 106         if mac is not None:
 107             self.parent.hosts[name].mac = mac
 108
 109     @handler(u'Delete a host')
 110     def delete(self, name):
 111         r"delete(name) -> None :: Delete a host of the hosts list."
 112         if not name in self.parent.hosts:
 113             raise HostNotFoundError(name)
 114         del self.parent.hosts[name]
 115
 116     @handler(u'Get information about a host')
 117     def get(self, name):
 118         r"get(name) -> Host :: List all the information of a host."
 119         if not name in self.parent.hosts:
 120             raise HostNotFoundError(name)
 121         return self.parent.hosts[name]
 122
 123     @handler(u'List hosts')
 124     def list(self):
 125         r"list() -> tuple :: List all the hostnames."
 126         return self.parent.hosts.keys()
 127
 128     @handler(u'Get information about all hosts')
 129     def show(self):
 130         r"show() -> list of Hosts :: List all the complete hosts information."
 131         return self.parent.hosts.values()
 132
 133
 134 class DhcpHandler(Restorable, ConfigWriter, InitdHandler, TransactionalHandler,
 135                   ParametersHandler):
 136     r"""DhcpHandler([pickle_dir[, config_dir]]) -> DhcpHandler instance.
 137
 138     Handles DHCP service commands for the dhcpd program.
 139
 140     pickle_dir - Directory where to write the persistent configuration data.
 141
 142     config_dir - Directory where to store de generated configuration files.
 143
 144     Both defaults to the current working directory.
 145     """
 146
 147     handler_help = u"Manage DHCP service"
 148
 149     _initd_name = 'dhcpd'
 150
 151     _persistent_attrs = ('params', 'hosts')
 152
 153     _restorable_defaults = dict(
 154             hosts = dict(),
 155             params  = dict(
 156                 domain_name = 'example.com',
 157                 dns_1       = 'ns1.example.com',
 158                 dns_2       = 'ns2.example.com',
 159                 net_address = '192.168.0.0',
 160                 net_mask    = '255.255.255.0',
 161                 net_start   = '192.168.0.100',
 162                 net_end     = '192.168.0.200',
 163                 net_gateway = '192.168.0.1',
 164             ),
 165     )
 166
 167     _config_writer_files = 'dhcpd.conf'
 168     _config_writer_tpl_dir = path.join(path.dirname(__file__), 'templates')
 169
 170     def __init__(self, pickle_dir='.', config_dir='.'):
 171         r"Initialize DhcpHandler object, see class documentation for details."
 172         self._persistent_dir = pickle_dir
 173         self._config_writer_cfg_dir = config_dir
 174         self._config_build_templates()
 175         self._restore()
 176         self.host = HostHandler(self)
 177
 178     def _get_config_vars(self, config_file):
 179         return dict(hosts=self.hosts.values(), **self.params)
 180
 181
 182 if __name__ == '__main__':
 183
 184     import os
 185
 186     h = DhcpHandler()
 187
 188     def dump():
 189         print '-' * 80
 190         print 'Variables:', h.list()
 191         print h.show()
 192         print
 193         print 'Hosts:', h.host.list()
 194         print h.host.show()
 195         print '-' * 80
 196
 197     dump()
 198
 199     h.host.add('my_name','192.168.0.102','00:12:ff:56')
 200
 201     h.host.update('my_name','192.168.0.192','00:12:ff:56')
 202
 203     h.host.add('nico','192.168.0.188','00:00:00:00')
 204
 205     h.set('domain_name','baryon.com.ar')
 206
 207     try:
 208         h.set('sarasa','baryon.com.ar')
 209     except KeyError, e:
 210         print 'Error:', e
 211
 212     h.commit()
 213
 214     dump()
 215
 216     os.system('rm -f *.pkl ' + ' '.join(h._config_writer_files))
 217