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 %s" % (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.  If the vserver is running and the spaces/net file is modified, we need to restart it.
 180 """
 181 def write_conf_and_restart(slicename, value):
 182     SLICEDIR="/etc/vservers/%s/" % slicename
 183     SPACESDIR="%s/spaces/" % SLICEDIR
 184     FILENAME="%s/net" % SPACESDIR
 185     if os.path.exists(SLICEDIR):
 186         if not os.path.exists(SPACESDIR):
 187             try:
 188                 os.mkdir(SPACESDIR)
 189             except os.error:
 190                 logger.log("topo: could not create %s\n" % SPACESDIR)
 191                 return
 192
 193         if os.path.exists(FILENAME) != value:
 194             sliver = vserver.VServer(slicename)
 195             restart = sliver.is_running()
 196
 197             if (restart):
 198                 sliver.stop()
 199
 200             if value:
 201                 STATUS="ON"
 202                 f = open(FILENAME, "w")
 203                 f.close()
 204             else:
 205                 STATUS="OFF"
 206                 os.remove(FILENAME)
 207
 208             logger.log("%s: network namespace %s\n" % (slicename, STATUS))
 209
 210             if (restart):
 211                 logger.log("topo: restarting sliver %s\n" % slicename)
 212                 sliver.start()
 213
 214
 215 """
 216 Generate information for each interface in the sliver, in order to configure
 217 Quagga.
 218 """
 219 def get_ifaces(hostname, myid, topospec, key):
 220     ifaces = {}
 221     topolist = convert_topospec_to_list(topospec)
 222     for (nodeid, ipaddr, rate, myvirtip, remvirtip, virtnet) in topolist:
 223         name = "a%sx%s" % (key, nodeid)
 224         ifaces[name] = {}
 225         ifaces[name]['remote-ip'] = remvirtip
 226         ifaces[name]['local-ip'] = myvirtip
 227         ifaces[name]['network'] = virtnet
 228         ifaces[name]['short-name'] = hostname.replace('.vini-veritas.net', '')
 229     return ifaces
 230
 231
 232 def write_header(f, myname, password):
 233     f.write ("""! Configuration for %s
 234 ! Generated at %s
 235
 236 hostname %s
 237 password %s
 238
 239 """ % (myname, strftime("%Y-%m-%d %H:%M:%S"), myname, password))
 240     return
 241
 242
 243 """
 244 IP address of NAT gateway to outside world
 245 """
 246 def nat_gw(key):
 247     return "10.0.%s.1" %  key
 248
 249 """
 250 IP address of the NAT interface inside the slice
 251 """
 252 def nat_inner(key):
 253     return "10.0.%s.2" % key
 254
 255
 256 """
 257 Write zebra.conf file for Quagga
 258 """
 259 def write_zebra(filename, myname, ifaces, myid, key):
 260     f = open(filename, 'w')
 261     password = "zebra"
 262     write_header(f, myname, password)
 263
 264     f.write ("enable password %s\n" % password)
 265
 266     for name in ifaces:
 267         f.write ("""!
 268 interface %s
 269 link-detect
 270 """ %  name)
 271
 272     f.write ("""!
 273 access-list vty permit 127.0.0.1/32
 274 !
 275 line vty
 276 !
 277 """)
 278     f.close()
 279     return
 280
 281
 282 """
 283 Write ospfd.conf file for Quagga.
 284 """
 285 def write_ospf(filename, myname, ifaces):
 286     f = open(filename, 'w')
 287     password = "zebra"
 288     write_header(f, myname, password)
 289
 290     for name in ifaces:
 291         f.write ("""!
 292      interface %s
 293      ip ospf cost 10
 294      ip ospf hello-interval 5
 295      ip ospf dead-interval 10
 296      ip ospf network non-broadcast
 297 """ % name)
 298
 299     f.write ("""!
 300      router ospf
 301      ospf router-id %s
 302 """ % ifaces[name]['local-ip'])
 303
 304     for name in ifaces:
 305         f.write ("     neighbor %s\n" % ifaces[name]['remote-ip'])
 306
 307     for name in ifaces:
 308         net = ifaces[name]['network']
 309         f.write ("     network %s area 0\n" % net)
 310
 311     f.write("""     redistribute kernel
 312 !
 313 access-list vty permit 127.0.0.1/32
 314 !
 315 line vty
 316 """)
 317     return
 318
 319
 320 """
 321 Write config files directly into the slice's file system.
 322 """
 323 def update_quagga_configs(slicename, hostname, myid, topo, key, netns):
 324     ifaces = get_ifaces(hostname, myid, topo, key)
 325
 326     quagga_dir = "/vservers/%s/etc/quagga/" % slicename
 327     if not os.path.exists(quagga_dir):
 328         try:
 329             # Quagga not installed.  Install it here?  Chkconfig, sym links.
 330             os.mkdir(quagga_dir)
 331         except os.error:
 332             logger.log("topo: could not create %s\n" % quagga_dir)
 333             return
 334
 335     write_zebra(quagga_dir + "zebra.conf.generated", hostname, ifaces,
 336                 myid, key)
 337     write_ospf(quagga_dir + "ospfd.conf.generated", hostname, ifaces)
 338
 339     # Start up Quagga if we installed it earlier and netns = 1.
 340
 341     return
 342
 343
 344 """
 345 Write /etc/hosts in the sliver
 346 """
 347 def update_hosts(slicename, hosts):
 348     hosts_file = "/vservers/%s/etc/hosts" % slicename
 349     f = open(hosts_file, 'w')
 350     f.write(hosts)
 351     f.close()
 352     return
 353
 354 """
 355 Write /etc/vini/egre-keys.txt, used by vsys topo scripts
 356 """
 357 def write_egre_keys(slicekeys):
 358     vini_dir = "/etc/vini"
 359     if not os.path.exists(vini_dir):
 360         try:
 361             os.mkdir(vini_dir)
 362         except os.error:
 363             logger.log("topo: could not create %s\n" % vini_dir)
 364             return
 365     keys_file = "%s/egre-keys.txt" % vini_dir
 366     f = open(keys_file, 'w')
 367     for slice in slicekeys:
 368         f.write("%s %s\n" % (slice, slicekeys[slice]))
 369     f.close()
 370     return
 371
 372
 373 """
 374 Executed on NM startup
 375 """
 376 def start(options, config):
 377     run ("echo 1 > /proc/sys/net/ipv4/ip_forward")
 378     pass
 379
 380
 381 """
 382 Update the virtual links for a sliver if it has a 'netns' attribute,
 383 an 'egre_key' attribute, and a 'topo_rspec' attribute.
 384
 385 Creating the virtual link depends on the contents of
 386 /etc/vservers/<slice>/spaces/net.  Update this first.
 387 """
 388 def GetSlivers(data):
 389     global ifaces, old_ifaces
 390     ifaces = old_ifaces = sioc.gifconf()
 391
 392     slicekeys = {}
 393     for sliver in data['slivers']:
 394         attrs = {}
 395         for tag in sliver['attributes']:
 396             attrs[tag['tagname']] = tag['value']
 397             if tag['tagname'] == 'egre_key':
 398                 slicekeys[sliver['name']] = tag['value']
 399
 400
 401         if 'netns' in attrs:
 402             netns = int(attrs['netns'])
 403         else:
 404             netns = 0
 405         write_conf_and_restart(sliver['name'], netns)
 406
 407         if vserver.VServer(sliver['name']).is_running():
 408             if 'egre_key' in attrs and 'topo_rspec' in attrs:
 409                 logger.log("topo: Update topology for slice %s" % \
 410                                sliver['name'])
 411                 update_links(sliver['name'], data['node_id'],
 412                              attrs['topo_rspec'], attrs['egre_key'], netns)
 413                 update_quagga_configs(sliver['name'], data['hostname'],
 414                                data['node_id'], attrs['topo_rspec'],
 415                                attrs['egre_key'], netns)
 416             if 'hosts' in attrs:
 417                 update_hosts(sliver['name'], attrs['hosts'])
 418         else:
 419             logger.log("topo: sliver %s not running yet. Deferring." % \
 420                            sliver['name'])
 421
 422     clean_up_old_virtual_links()
 423     write_egre_keys(slicekeys)
 424     return
 425
 426