from mako.template import Template
from mako.runtime import Context
+from subprocess import Popen, PIPE
from os import path
try:
import cPickle as pickle
def as_tuple(self):
return(self.addr, self.prefix, self.gateway)
+ def __cmp__(self, other):
+ if self.net_addr == other.net_addr \
+ and self.prefix == other.prefix \
+ and self.gateway == other.gateway:
+ return 0
+ return cmp(id(self), id(other))
+
class RouteHandler:
- def __init__(self, devices, config_dir, ip_handler):
+ def __init__(self, devices):
self.devices = devices
- route_add_fn = path.join(template_dir, route_add_com)
- route_del_fn = path.join(template_dir, route_del_com)
- route_flush_fn = path.join(template_dir, route_flush_com)
- self.route_add_template = Template(filename=route_add_fn)
- self.route_del_template = Template(filename=route_del_fn)
- self.route_flush_template = Template(filename=route_flush_fn)
- self.config_dir = config_dir
- self.ip_handler = ip_handler
@handler
def add(self, device, net_addr, prefix, gateway):
self.devices[device].routes.index(r)
raise RouteAlreadyExistsError(net_addr + '/' + prefix + '->' + gateway)
except ValueError:
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=device, net_addr=net_addr, prefix=prefix, gateway=gateway)
- self.route_add_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
self.devices[device].routes.append(r)
- self.ip_handler.commit()
-
@handler
def delete(self, device, net_addr, prefix, gateway):
if not device in self.devices:
raise DeviceNotFoundError(device)
r = Route(net_addr, prefix, gateway)
- #try:
- #i = self.devices[device].routes.index(r)
- #out_file = file(path.join(self.config_dir, command_filename), 'w')
- #ctx = Context(out_file, dev=device, net_addr=net_addr, prefix=prefix, gateway=gateway)
- #self.route_add_template.render_context(ctx)
- #out_file.close()
- #execute_command(self.config_dir)
- #self.devices[device].routes.append(r)
- #self.ip_handler.commit()
-
- #except ValueError:
- #raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
+ try:
+ self.devices[device].routes.remove(r)
+ except ValueError:
+ raise RouteNotFoundError(net_addr + '/' + prefix + '->' + gateway)
@handler
def flush(self, device):
if not device in self.devices:
raise DeviceNotFoundError(device)
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=device)
- self.route_flush_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
self.devices[device].routes = list()
- self.ip_handler.commit()
+
@handler
def list(self, device):
class AddressHandler:
- def __init__(self, devices, config_dir, ip_handler):
+ def __init__(self, devices):
self.devices = devices
- self.config_dir = config_dir
- ip_add_fn = path.join(template_dir, ip_add_com)
- ip_del_fn = path.join(template_dir, ip_del_com)
- ip_flush_fn = path.join(template_dir, ip_flush_com)
- self.ip_add_template = Template(filename=ip_add_fn)
- self.ip_del_template = Template(filename=ip_del_fn)
- self.ip_flush_template = Template(filename=ip_flush_fn)
- self.ip_handler = ip_handler
-
@handler
def add(self, device, ip, prefix, broadcast='+'):
raise DeviceNotFoundError(device)
if ip in self.devices[device].addrs:
raise AddressAlreadyExistsError(ip)
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=device, addr=ip, prefix=prefix, broadcast=broadcast)
- self.ip_add_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
self.devices[device].addrs[ip] = Address(ip, prefix, broadcast)
- self.ip_handler.commit()
@handler
def delete(self, device, ip):
raise DeviceNotFoundError(device)
if not ip in self.devices[device].addrs:
raise AddressNotFoundError(ip)
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=device, addr=ip, prefix=self.devices[device].addrs[ip].prefix)
- self.ip_del_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
del self.devices[device].addrs[ip]
- self.ip_handler.commit()
-
@handler
def flush(self, device):
if not device in self.devices:
raise DeviceNotFoundError(device)
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=device)
- self.ip_flush_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
self.devices[device].addrs = dict()
- self.ip_handler.commit()
-
@handler
def list(self, device):
class Device(Sequence):
- def __init__(self, name):
+ def __init__(self, name, mac):
self.name = name
+ self.mac = mac
self.addrs = dict()
self.routes = list()
def as_tuple(self):
- return (self.name, self.addrs, self.routes)
+ return (self.name, self.mac)
class DeviceHandler:
- def __init__(self, devices, config_dir = '.'):
+ def __init__(self, devices):
self.devices = devices
dev_fn = path.join(template_dir, device_com)
self.device_template = Template(filename=dev_fn)
- self.config_dir = config_dir
@handler
def up(self, name):
if name in self.devices:
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=name, action='up')
- self.device_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
+ print self.device_template.render(dev=name, action='up')
else:
raise DeviceNotFoundError(name)
@handler
def down(self, name):
if name in self.devices:
- out_file = file(path.join(self.config_dir, command_filename), 'w')
- ctx = Context(out_file, dev=name, action='down')
- self.device_template.render_context(ctx)
- out_file.close()
- execute_command(self.config_dir)
+ print self.device_template.render(dev=name, action='down')
else:
raise DeviceNotFoundError(name)
def show(self):
return self.devices.items()
-def execute_command(config_dir):
- out_file = file(path.join(config_dir, command_filename), 'r')
- print out_file.read()
- out_file.close()
-
class IpHandler:
def __init__(self, pickle_dir='.', config_dir='.'):
self.pickle_dir = pickle_dir
self.config_dir = config_dir
+ ip_add_fn = path.join(template_dir, ip_add_com)
+ ip_del_fn = path.join(template_dir, ip_del_com)
+ ip_flush_fn = path.join(template_dir, ip_flush_com)
+ self.ip_add_template = Template(filename=ip_add_fn)
+ self.ip_del_template = Template(filename=ip_del_fn)
+ self.ip_flush_template = Template(filename=ip_flush_fn)
+
+ route_add_fn = path.join(template_dir, route_add_com)
+ route_del_fn = path.join(template_dir, route_del_com)
+ route_flush_fn = path.join(template_dir, route_flush_com)
+ self.route_add_template = Template(filename=route_add_fn)
+ self.route_del_template = Template(filename=route_del_fn)
+ self.route_flush_template = Template(filename=route_flush_fn)
+
try:
self._load()
except IOError:
- # This is the first time the handler is used, create a basic
- # setup using some nice defaults
- self.devices = dict(
- eth0=Device('eth0'),
- eth1=Device('eth1'),
- )
+ p = Popen('ip link list', shell=True, stdout=PIPE, close_fds=True)
+ devs = _get_devices(p.stdout.read())
+ self.devices = dict()
+ for eth, mac in devs.values():
+ self.devices[eth] = Device(eth, mac)
self._dump()
- self.addr = AddressHandler(self.devices, config_dir, self)
- self.route = RouteHandler(self.devices, config_dir, self)
- self.dev = DeviceHandler(self.devices, config_dir)
- self._write_config()
+ self.addr = AddressHandler(self.devices)
+ self.route = RouteHandler(self.devices)
+ self.dev = DeviceHandler(self.devices)
+ self.commit()
+ @handler
def commit(self):
r"commit() -> None :: Commit the changes and reload the DHCP service."
#esto seria para poner en una interfaz
pkl_file.close()
def _load_var(self, name):
- r"_load_var() -> object :: Load a especific pickle file."
+ r"_load_var()7 -> object :: Load a especific pickle file."
# XXX podría ir en una clase base
return pickle.load(file(self._pickle_filename(name)))
def _write_config(self):
r"_write_config() -> None :: Execute all commands."
- pass
-
-
-
+ for device in self.devices.values():
+ print self.route_flush_template.render(dev=device.name)
+ print self.ip_flush_template.render(dev=device.name)
+ for address in device.addrs.values():
+ print self.ip_add_template.render(
+ dev=device.name,
+ addr=address.ip,
+ prefix=address.prefix,
+ broadcast=address.broadcast
+ )
+ for route in device.routes:
+ print self.route_add_template.render(
+ dev=device.name,
+ net_addr=route.net_addr,
+ prefix=route.prefix,
+ gateway=route.gateway
+ )
+
+ def _get_devices(string):
+ l = list()
+ i = string.find('eth')
+ while i != -1:
+ eth = string[i:i+4]
+ m = string.find('link/ether', i+4)
+ mac = string[ m+11 : m+11+17]
+ l.append((eth,mac))
+ i = string.find('eth', m+11+17)
+ return l
if __name__ == '__main__':
ip = IpHandler()
+ print '----------------------'
ip.dev.up('eth0')
- ip.dev.down('eth0')
- ip.dev.show()
ip.addr.add('eth0','192.168.0.23','24','192.168.255.255')
ip.addr.add('eth0','192.168.0.26','24')
- ip.addr.show('eth0')
- ip.addr.flush('eth0')
+ ip.commit()
ip.route.add('eth0','192.168.0.0','24','192.168.0.1')
+ ip.route.add('eth0','192.168.0.5','24','192.168.0.1')
+ ip.commit()
ip.route.flush('eth0')
- #ip.addr.delete('eth0','192.168.0.23')
- #ip.addr.delete('eth0','192.168.0.26')
\ No newline at end of file
+ ip.commit()
+ ip.addr.delete('eth0','192.168.0.23')
+ ip.commit()
+
+
+
+
projects / software / pymin.git / blobdiff