topo.py

   1 # $Id$
   2 # $URL$
   3
   4 """
   5 VINI/Trellis NodeManager plugin.
   6 Create virtual links from the topo_rspec slice attribute.
   7 """
   8
   9 import logger
  10 import subprocess
  11 import sioc
  12 import re
  13 import vserver
  14 import os
  15 from time import strftime
  16
  17 dryrun = 0
  18 vinidir = "/usr/share/vini/"
  19 setup_link_cmd = vinidir + "setup-egre-link"
  20 teardown_link_cmd = vinidir + "teardown-egre-link"
  21 setup_nat_cmd = vinidir + "setup-nat"
  22 teardown_nat_cmd = vinidir + "teardown-nat"
  23 ifaces = {}
  24 old_ifaces = {}
  25
  26 def run(cmd):
  27     if dryrun:
  28         logger.log(cmd)
  29         return -1
  30     else:
  31         return subprocess.call(cmd, shell=True);
  32
  33
  34 """
  35 Subnet used for virtual interfaces by setup-egre-link script
  36 """
  37 def iias_network():
  38     return "192.168.0.0 255.255.0.0"
  39
  40
  41 """
  42 Check for existence of interface d<key>x<nodeid>
  43 """
  44 def virtual_link(key, nodeid):
  45     name = "d%sx%s" % (key, nodeid)
  46     if name in ifaces:
  47         return True
  48     else:
  49         return False
  50
  51 """
  52 Create a "virtual link" for slice between here and nodeid.
  53 The key is used to create the EGRE tunnel.
  54 """
  55 def setup_virtual_link(slice, key, rate, myid, nodeid, ipaddr, virtip, vnet):
  56     logger.log("%s: Set up virtual link to node %d" % (slice, nodeid))
  57     run(setup_link_cmd + " %s %s %s %s %s %s %s" % (slice, nodeid, ipaddr,
  58                                                  key, rate, virtip, vnet))
  59     return
  60
  61
  62 """
  63 Tear down the "virtual link" for slice between here and nodeid.
  64 """
  65 def teardown_virtual_link(key, nodeid):
  66     logger.log("topo: Tear down virtual link %sx%s" % (key, nodeid))
  67     run(teardown_link_cmd + " %s %s" % (nodeid, key))
  68     return
  69
  70
  71 """
  72 Called for all active virtual link interfaces, so they won't be cleaned up.
  73 """
  74 def refresh_virtual_link(nodeid, key):
  75     name = "d%sx%s" % (key, nodeid)
  76     if name in old_ifaces:
  77         del old_ifaces[name]
  78     return
  79
  80
  81 """
  82 IP address of the NAT interface created inside the slice by the
  83 setup-nat script.
  84 """
  85 def nat_inner_ip(key):
  86     return "10.0.%s.2" % key
  87
  88
  89 """
  90 Check for existence of interface natx<key>
  91 """
  92 def nat_exists(key):
  93     name = "natx%s" % key
  94     if name in ifaces:
  95         return True
  96     else:
  97         return False
  98
  99
 100 """
 101 Create a NAT interface inside the sliver.
 102 """
 103 def setup_nat(slice, myid, key):
 104     logger.log("%s: Set up NAT" % slice)
 105     run(setup_nat_cmd + " %s %s %s" % (slice, myid, key))
 106     return
 107
 108
 109 """
 110 Tear down the NAT interface identified by key
 111 """
 112 def teardown_nat(key):
 113     logger.log("topo: Tear down NAT %s" % key)
 114     run(teardown_nat_cmd + " %s" % key)
 115     return
 116
 117
 118 """
 119 Called for all active NAT interfaces, so they won't be cleaned up.
 120 """
 121 def refresh_nat(key):
 122     name = "natx%s" % (key)
 123     if name in old_ifaces:
 124         del old_ifaces[name]
 125     return
 126
 127
 128 """
 129 Clean up old virtual links (e.g., to nodes that have been deleted
 130 from the slice).
 131 """
 132 def clean_up_old_virtual_links():
 133     pattern1 = "d(.*)x(.*)"
 134     pattern2 = "natx(.*)"
 135     for iface in old_ifaces:
 136         m = re.match(pattern1, iface)
 137         if m:
 138             key = int(m.group(1))
 139             node = int(m.group(2))
 140             teardown_virtual_link(key, node)
 141
 142         m = re.match(pattern2, iface)
 143         if m:
 144             key = int(m.group(1))
 145             teardown_nat(key)
 146     return
 147
 148
 149 """
 150 Not the safest thing to do, probably should use pickle() or something.
 151 """
 152 def convert_topospec_to_list(rspec):
 153     return eval(rspec)
 154
 155
 156 """
 157 Update virtual links for the slice
 158 """
 159 def update_links(slice, myid, topospec, key, netns):
 160     topolist = convert_topospec_to_list(topospec)
 161     for (nodeid, ipaddr, rate, myvirtip, remvirtip, virtnet) in topolist:
 162         if not virtual_link(key, nodeid):
 163             if netns:
 164                 setup_virtual_link(slice, key, rate, myid, nodeid,
 165                                    ipaddr, myvirtip, virtnet)
 166         else:
 167             logger.log("%s: virtual link to node %s exists" % (slice, nodeid))
 168             refresh_virtual_link(nodeid, key)
 169
 170     if not nat_exists(key):
 171         if netns:
 172             setup_nat(slice, myid, key)
 173     else:
 174         logger.log("%s: NAT exists" % slice)
 175         refresh_nat(key)
 176
 177
 178 """
 179 Write /etc/vservers/<slicename>/spaces/net
 180 """
 181 def writeConf(slicename, value):
 182     SLICEDIR="/etc/vservers/%s/" % slicename
 183     SPACESDIR="%s/spaces/" % SLICEDIR
 184     if os.path.exists(SLICEDIR):
 185         if not os.path.exists(SPACESDIR):
 186             try:
 187                 os.mkdir(SPACESDIR)
 188             except os.error:
 189                 logger.log("topo: could not create %s\n" % SPACESDIR)
 190                 return
 191         f = open("%s/net" % SPACESDIR, "w")
 192         f.write("%s\n" % value)
 193         f.close()
 194         STATUS="OFF"
 195         if value:
 196             STATUS="ON"
 197         logger.log("%s: network namespace %s\n" % (slicename, STATUS))
 198
 199
 200 """
 201 Generate information for each interface in the sliver, in order to configure
 202 Quagga.
 203 """
 204 def get_ifaces(hostname, myid, topospec, key):
 205     ifaces = {}
 206     topolist = convert_topospec_to_list(topospec)
 207     for (nodeid, ipaddr, rate, myvirtip, remvirtip, virtnet) in topolist:
 208         name = "a%sx%s" % (key, nodeid)
 209         ifaces[name] = {}
 210         ifaces[name]['remote-ip'] = remvirtip
 211         ifaces[name]['local-ip'] = myvirtip
 212         ifaces[name]['network'] = virtnet
 213         ifaces[name]['short-name'] = hostname.replace('.vini-veritas.net', '')
 214     return ifaces
 215
 216
 217 def write_header(f, myname, password):
 218     f.write ("""! Configuration for %s
 219 ! Generated at %s
 220
 221 hostname %s
 222 password %s
 223
 224 """ % (myname, strftime("%Y-%m-%d %H:%M:%S"), myname, password))
 225     return
 226
 227
 228 """
 229 IP address of NAT gateway to outside world
 230 """
 231 def nat_gw(key):
 232     return "10.0.%s.1" %  key
 233
 234 """
 235 IP address of the NAT interface inside the slice
 236 """
 237 def nat_inner(key):
 238     return "10.0.%s.2" % key
 239
 240
 241 """
 242 Write zebra.conf file for Quagga
 243 """
 244 def write_zebra(filename, myname, ifaces, myid, key):
 245     f = open(filename, 'w')
 246     password = "zebra"
 247     write_header(f, myname, password)
 248
 249     f.write ("enable password %s\n" % password)
 250
 251     for name in ifaces:
 252         f.write ("""!
 253 interface %s
 254 link-detect
 255 """ %  name)
 256
 257     f.write ("""!
 258 access-list vty permit 127.0.0.1/32
 259 !
 260 line vty
 261 !
 262 """)
 263     f.close()
 264     return
 265
 266
 267 """
 268 Write ospfd.conf file for Quagga.
 269 """
 270 def write_ospf(filename, myname, ifaces):
 271     f = open(filename, 'w')
 272     password = "zebra"
 273     write_header(f, myname, password)
 274
 275     for name in ifaces:
 276         f.write ("""!
 277      interface %s
 278      ip ospf cost 10
 279      ip ospf hello-interval 5
 280      ip ospf dead-interval 10
 281      ip ospf network non-broadcast
 282 """ % name)
 283
 284     f.write ("""!
 285      router ospf
 286      ospf router-id %s
 287 """ % ifaces[name]['local-ip'])
 288
 289     for name in ifaces:
 290         f.write ("     neighbor %s\n" % ifaces[name]['remote-ip'])
 291
 292     for name in ifaces:
 293         net = ifaces[name]['network']
 294         f.write ("     network %s area 0\n" % net)
 295
 296     f.write("""     redistribute kernel
 297 !
 298 access-list vty permit 127.0.0.1/32
 299 !
 300 line vty
 301 """)
 302     return
 303
 304
 305 """
 306 Write config files directly into the slice's file system.
 307 """
 308 def update_quagga_configs(slicename, hostname, myid, topo, key, netns):
 309     ifaces = get_ifaces(hostname, myid, topo, key)
 310
 311     quagga_dir = "/vservers/%s/etc/quagga/" % slicename
 312     if not os.path.exists(quagga_dir):
 313         try:
 314             # Quagga not installed.  Install it here?  Chkconfig, sym links.
 315             os.mkdir(quagga_dir)
 316         except os.error:
 317             logger.log("topo: could not create %s\n" % quagga_dir)
 318             return
 319
 320     write_zebra(quagga_dir + "zebra.conf.generated", hostname, ifaces,
 321                 myid, key)
 322     write_ospf(quagga_dir + "ospfd.conf.generated", hostname, ifaces)
 323
 324     # Start up Quagga if we installed it earlier and netns = 1.
 325
 326     return
 327
 328
 329 """
 330 Write /etc/hosts in the sliver
 331 """
 332 def update_hosts(slicename, hosts):
 333     hosts_file = "/vservers/%s/etc/hosts" % slicename
 334     f = open(hosts_file, 'w')
 335     f.write(hosts)
 336     f.close()
 337     return
 338
 339
 340 def start(options, config):
 341     run ("echo 1 > /proc/sys/net/ipv4/ip_forward")
 342     pass
 343
 344
 345 """
 346 Update the virtual links for a sliver if it has a 'netns' attribute,
 347 an 'egre_key' attribute, and a 'topo_rspec' attribute.
 348
 349 Creating the virtual link depends on the contents of
 350 /etc/vservers/<slice>/spaces/net.  Update this first.
 351 """
 352 def GetSlivers(data):
 353     global ifaces, old_ifaces
 354     ifaces = old_ifaces = sioc.gifconf()
 355
 356     for sliver in data['slivers']:
 357         attrs = {}
 358         for attribute in sliver['attributes']:
 359             attrs[attribute['name']] = attribute['value']
 360         if 'netns' in attrs:
 361             netns = int(attrs['netns'])
 362             writeConf(sliver['name'], netns)
 363         else:
 364             netns = 0
 365
 366         if vserver.VServer(sliver['name']).is_running():
 367             if 'egre_key' in attrs and 'topo_rspec' in attrs:
 368                 logger.log("topo: Update topology for slice %s" % \
 369                                sliver['name'])
 370                 update_links(sliver['name'], data['node_id'],
 371                              attrs['topo_rspec'], attrs['egre_key'], netns)
 372                 update_quagga_configs(sliver['name'], data['hostname'],
 373                                data['node_id'], attrs['topo_rspec'],
 374                                attrs['egre_key'], netns)
 375             if 'hosts' in attrs:
 376                 update_hosts(sliver['name'], attrs['hosts'])
 377         else:
 378             logger.log("topo: sliver %s not running yet. Deferring." % \
 379                            sliver['name'])
 380
 381     clean_up_old_virtual_links()
 382     return
 383
 384