import subprocess
import sioc
import re
+import vserver
+import os
+from time import strftime
+import socket
-dryrun=0
-setup_link_cmd="/usr/share/vini/setup-egre-link"
-teardown_link_cmd="/usr/share/vini/teardown-egre-link"
+dryrun = 0
+vinidir = "/usr/share/vini/"
+setup_link_cmd = vinidir + "setup-egre-link"
+teardown_link_cmd = vinidir + "teardown-egre-link"
+setup_nat_cmd = vinidir + "setup-nat"
+teardown_nat_cmd = vinidir + "teardown-nat"
ifaces = {}
+old_ifaces = {}
def run(cmd):
if dryrun:
else:
return subprocess.call(cmd, shell=True);
+"""
+From old pyplnet, former semantics needed for VINI
+"""
+def gifconf():
+ try:
+ interfaces = os.listdir("/sys/class/net")
+ except:
+ interfaces = []
+ s = None
+ ret = {}
+ try:
+ s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
+ for interface in interfaces:
+ try:
+ ifreq = fcntl.ioctl(s.fileno(), SIOCGIFADDR,
+ struct.pack("16sH14x", interface, socket.AF_INET))
+ (family, ip) = struct.unpack(SIOCGIFADDR_struct, ifreq)
+ if family == socket.AF_INET:
+ ret[interface] = _format_ip(ip)
+ else:
+ raise Exception
+ except:
+ ret[interface] = "0.0.0.0"
+ finally:
+ if s is not None:
+ s.close()
+ return ret
+
+"""
+Subnet used for virtual interfaces by setup-egre-link script
+"""
+def iias_network():
+ return "192.168.0.0 255.255.0.0"
+
"""
-Check for existence of interface a<key>x<nodeid>
+Check for existence of interface d<key>x<nodeid>
"""
def virtual_link(key, nodeid):
name = "d%sx%s" % (key, nodeid)
else:
return False
-
"""
Create a "virtual link" for slice between here and nodeid.
The key is used to create the EGRE tunnel.
"""
-def setup_virtual_link(slice, key, rate, myid, nodeid, ipaddr):
- if myid < nodeid:
- virtip = "10.%d.%d.2" % (myid, nodeid)
- else:
- virtip = "10.%d.%d.3" % (nodeid, myid)
-
- run(setup_link_cmd + " %s %s %s %s %s %s" % (slice, nodeid, ipaddr,
- key, rate, virtip))
+def setup_virtual_link(slice, key, rate, myid, nodeid, ipaddr, virtip, vnet):
+ logger.log("%s: Set up virtual link to node %s" % (slice, nodeid))
+ run(setup_link_cmd + " %s %s %s %s %s %s %s" % (slice, nodeid, ipaddr,
+ key, rate, virtip, vnet))
return
"""
Tear down the "virtual link" for slice between here and nodeid.
"""
-def teardown_virtual_link(slice, key, nodeid):
- logger.log("Tear down virtual link to node %d" % nodeid)
- run(teardown_link_cmd + " %s %s %s" % (slice, nodeid, key))
+def teardown_virtual_link(key, nodeid):
+ logger.log("topo: Tear down virtual link %sx%s" % (key, nodeid))
+ run(teardown_link_cmd + " %s %s" % (nodeid, key))
+ return
+
+
+"""
+Called for all active virtual link interfaces, so they won't be cleaned up.
+"""
+def refresh_virtual_link(nodeid, key):
+ name = "d%sx%s" % (key, nodeid)
+ if name in old_ifaces:
+ del old_ifaces[name]
+ return
+
+
+"""
+IP address of the NAT interface created inside the slice by the
+setup-nat script.
+"""
+def nat_inner_ip(key):
+ return "10.0.%s.2" % key
+
+
+"""
+Check for existence of interface natx<key>
+"""
+def nat_exists(key):
+ name = "natx%s" % key
+ if name in ifaces:
+ return True
+ else:
+ return False
+
+
+"""
+Create a NAT interface inside the sliver.
+"""
+def setup_nat(slice, myid, key):
+ logger.log("%s: Set up NAT" % slice)
+ run(setup_nat_cmd + " %s %s %s" % (slice, myid, key))
+ return
+
+
+"""
+Tear down the NAT interface identified by key
+"""
+def teardown_nat(key):
+ logger.log("topo: Tear down NAT %s" % key)
+ run(teardown_nat_cmd + " %s" % key)
+ return
+
+
+"""
+Called for all active NAT interfaces, so they won't be cleaned up.
+"""
+def refresh_nat(key):
+ name = "natx%s" % (key)
+ if name in old_ifaces:
+ del old_ifaces[name]
return
Clean up old virtual links (e.g., to nodes that have been deleted
from the slice).
"""
-def clean_up_old_virtual_links(slice, key, nodelist):
- pattern = "d%sx(.*)" % key
- for iface in ifaces:
- m = re.match(pattern, iface)
+def clean_up_old_virtual_links():
+ pattern1 = "d(.*)x(.*)"
+ pattern2 = "natx(.*)"
+ for iface in old_ifaces:
+ m = re.match(pattern1, iface)
if m:
- node = m.group(1)
- if not node in nodelist:
- teardown_virtual_link(slice, key, node)
+ key = m.group(1)
+ node = m.group(2)
+ teardown_virtual_link(key, node)
+
+ m = re.match(pattern2, iface)
+ if m:
+ key = m.group(1)
+ teardown_nat(key)
+ return
"""
"""
Update virtual links for the slice
"""
-def update(slice, myid, topospec, key):
+def update_links(slice, myid, topospec, key, netns):
topolist = convert_topospec_to_list(topospec)
- nodelist=[]
- for (nodeid,ipaddr,rate) in topolist:
- nodelist.append(nodeid)
+ for (nodeid, ipaddr, rate, myvirtip, remvirtip, virtnet) in topolist:
if not virtual_link(key, nodeid):
- setup_virtual_link(slice, key, rate, myid, nodeid, ipaddr)
+ if netns:
+ setup_virtual_link(slice, key, rate, myid, nodeid,
+ ipaddr, myvirtip, virtnet)
else:
- logger.log("Virtual link to node %s exists" % nodeid)
+ logger.log("%s: virtual link to node %s exists" % (slice, nodeid))
+ refresh_virtual_link(nodeid, key)
+
+
+"""
+Update NAT interface for the slice
+"""
+def update_nat(slice, myid, key, netns):
+ if not nat_exists(key):
+ if netns:
+ setup_nat(slice, myid, key)
+ else:
+ logger.log("%s: NAT exists" % slice)
+ refresh_nat(key)
+
+
+"""
+Write /etc/vservers/<slicename>/spaces/net.
+Restart the vserver if there are any changes.
+"""
+def write_spaces_net(slicename, value):
+ SLICEDIR="/etc/vservers/%s/" % slicename
+ SPACESDIR="%s/spaces/" % SLICEDIR
+ FILENAME="%s/net" % SPACESDIR
+ if os.path.exists(SLICEDIR):
+ if not os.path.exists(SPACESDIR):
+ try:
+ os.mkdir(SPACESDIR)
+ except os.error:
+ logger.log("topo: could not create %s\n" % SPACESDIR)
+ return
+
+ if os.path.exists(FILENAME) != value:
+ sliver = vserver.VServer(slicename)
+
+ sliver.stop()
+
+ if value:
+ STATUS="ON"
+ f = open(FILENAME, "w")
+ f.close()
+ else:
+ STATUS="OFF"
+ os.remove(FILENAME)
+
+ sliver.start()
+
+ logger.log("%s: network namespace %s\n" % (slicename, STATUS))
+
+
+"""
+Generate information for each interface in the sliver, in order to configure
+Quagga.
+"""
+def get_ifaces(hostname, myid, topospec, key):
+ ifaces = {}
+ topolist = convert_topospec_to_list(topospec)
+ for (nodeid, ipaddr, rate, myvirtip, remvirtip, virtnet) in topolist:
+ name = "a%sx%s" % (key, nodeid)
+ ifaces[name] = {}
+ ifaces[name]['remote-ip'] = remvirtip
+ ifaces[name]['local-ip'] = myvirtip
+ ifaces[name]['network'] = virtnet
+ ifaces[name]['short-name'] = hostname.replace('.vini-veritas.net', '')
+ return ifaces
+
+
+def write_header(f, myname, password):
+ f.write ("""! Configuration for %s
+! Generated at %s
+
+hostname %s
+password %s
+
+""" % (myname, strftime("%Y-%m-%d %H:%M:%S"), myname, password))
+ return
+
+
+"""
+IP address of NAT gateway to outside world
+"""
+def nat_gw(key):
+ return "10.0.%s.1" % key
+
+"""
+IP address of the NAT interface inside the slice
+"""
+def nat_inner(key):
+ return "10.0.%s.2" % key
+
+
+"""
+Write zebra.conf file for Quagga
+"""
+def write_zebra(filename, myname, ifaces, myid, key):
+ f = open(filename, 'w')
+ password = "zebra"
+ write_header(f, myname, password)
+
+ f.write ("enable password %s\n" % password)
+
+ for name in ifaces:
+ f.write ("""!
+interface %s
+link-detect
+""" % name)
+
+ f.write ("""!
+access-list vty permit 127.0.0.1/32
+!
+line vty
+!
+""")
+ f.close()
+ return
+
+
+"""
+Write ospfd.conf file for Quagga.
+"""
+def write_ospf(filename, myname, ifaces):
+ f = open(filename, 'w')
+ password = "zebra"
+ write_header(f, myname, password)
+ name = None
+
+ for name in ifaces:
+ f.write ("""!
+ interface %s
+ ip ospf cost 10
+ ip ospf hello-interval 5
+ ip ospf dead-interval 10
+ ip ospf network non-broadcast
+""" % name)
+
+ if name:
+ f.write ("""!
+ router ospf
+ ospf router-id %s
+""" % ifaces[name]['local-ip'])
- clean_up_old_virtual_links(slice, key, nodelist)
+ for name in ifaces:
+ f.write (" neighbor %s\n" % ifaces[name]['remote-ip'])
+ for name in ifaces:
+ net = ifaces[name]['network']
+ f.write (" network %s area 0\n" % net)
-def start(options, config):
+ f.write(""" redistribute kernel
+!
+access-list vty permit 127.0.0.1/32
+!
+line vty
+""")
+ return
+
+
+"""
+Write config files directly into the slice's file system.
+"""
+def update_quagga_configs(slicename, hostname, myid, topo, key, netns):
+ ifaces = get_ifaces(hostname, myid, topo, key)
+
+ quagga_dir = "/vservers/%s/etc/quagga/" % slicename
+ if not os.path.exists(quagga_dir):
+ try:
+ os.mkdir(quagga_dir)
+ except os.error:
+ logger.log("topo: could not create %s\n" % quagga_dir)
+ return
+
+ write_zebra(quagga_dir + "zebra.conf.generated", hostname, ifaces,
+ myid, key)
+ write_ospf(quagga_dir + "ospfd.conf.generated", hostname, ifaces)
+
+ return
+
+
+"""
+Write /etc/hosts in the sliver
+"""
+def update_hosts(slicename, hosts):
+ hosts_file = "/vservers/%s/etc/hosts" % slicename
+ f = open(hosts_file, 'w')
+ f.write(hosts)
+ f.close()
+ return
+
+"""
+Write /etc/vini/egre-keys.txt, used by vsys topo scripts
+"""
+def write_egre_keys(slicekeys):
+ vini_dir = "/etc/vini"
+ if not os.path.exists(vini_dir):
+ try:
+ os.mkdir(vini_dir)
+ except os.error:
+ logger.log("topo: could not create %s\n" % vini_dir)
+ return
+ keys_file = "%s/egre-keys.txt" % vini_dir
+ f = open(keys_file, 'w')
+ for slice in slicekeys:
+ f.write("%s %s\n" % (slice, slicekeys[slice]))
+ f.close()
+ return
+
+
+"""
+Executed on NM startup
+"""
+def start():
+ # Should be taken care of by /etc/sysctl.conf, but it doesn't hurt...
+ run ("echo 1 > /proc/sys/net/ipv4/ip_forward")
pass
"""
Update the virtual links for a sliver if it has a 'netns' attribute,
an 'egre_key' attribute, and a 'topo_rspec' attribute.
+
+Creating the virtual link depends on the contents of
+/etc/vservers/<slice>/spaces/net. Update this first.
"""
-def GetSlivers(data):
- global ifaces
- ifaces = sioc.gifconf()
+def GetSlivers(data, config = None, plc = None):
+ global ifaces, old_ifaces
+ ifaces = old_ifaces = gifconf()
+ slicekeys = {}
for sliver in data['slivers']:
attrs = {}
- for attribute in sliver['attributes']:
- attrs[attribute['name']] = attribute['value']
- if 'netns' in attrs and 'egre_key' in attrs and 'topo_rspec' in attrs:
- if attrs['netns'] > 0:
- logger.log("Update topology for slice %s" % sliver['name'])
- update(sliver['name'], data['node_id'],
- attrs['topo_rspec'], attrs['egre_key'])
+ for tag in sliver['attributes']:
+ attrs[tag['tagname']] = tag['value']
+ if tag['tagname'] == 'egre_key':
+ slicekeys[sliver['name']] = tag['value']
+
+
+ if vserver.VServer(sliver['name']).is_running():
+ if 'netns' in attrs:
+ netns = int(attrs['netns'])
+ else:
+ netns = 0
+ write_spaces_net(sliver['name'], netns)
+
+ if vserver.VServer(sliver['name']).is_running():
+ if 'egre_key' in attrs:
+ logger.log("topo: Update slice %s" % sliver['name'])
+ update_nat(sliver['name'], data['node_id'], attrs['egre_key'],
+ netns)
+ if 'topo_rspec' in attrs:
+ update_links(sliver['name'], data['node_id'],
+ attrs['topo_rspec'], attrs['egre_key'], netns)
+ update_quagga_configs(sliver['name'], data['hostname'],
+ data['node_id'], attrs['topo_rspec'],
+ attrs['egre_key'], netns)
+ if 'hosts' in attrs:
+ update_hosts(sliver['name'], attrs['hosts'])
+ else:
+ logger.log("topo: sliver %s not running yet. Deferring." % \
+ sliver['name'])
+
+ clean_up_old_virtual_links()
+ write_egre_keys(slicekeys)
+ return
+
git://git.onelab.eu / nodemanager-topo.git / blobdiff