sfa/rspecs/aggregates/rspec_manager_vini.py

   1 from sfa.util.faults import *
   2 from sfa.util.misc import *
   3 from sfa.util.rspec import Rspec
   4 from sfa.server.registry import Registries
   5 from sfa.plc.nodes import *
   6 import sys
   7 import socket
   8
   9 SFA_VINI_DEFAULT_RSPEC = '/etc/sfa/vini.rspec'
  10
  11 class Node:
  12     def __init__(self, node):
  13         self.id = node['node_id']
  14         self.hostname = node['hostname']
  15         self.shortname = self.hostname.replace('.vini-veritas.net', '')
  16         self.site_id = node['site_id']
  17         self.ipaddr = socket.gethostbyname(self.hostname)
  18         self.links = []
  19
  20     def get_link_id(self, remote):
  21         if self.id < remote.id:
  22             link = (self.id<<7) + remote.id
  23         else:
  24             link = (remote.id<<7) + self.id
  25         return link
  26
  27     def get_iface_id(self, remote):
  28         if self.id < remote.id:
  29             iface = 1
  30         else:
  31             iface = 2
  32         return iface
  33
  34     def get_virt_ip(self, remote):
  35         link = self.get_link_id(remote)
  36         iface = self.get_iface_id(remote)
  37         first = link >> 6
  38         second = ((link & 0x3f)<<2) + iface
  39         return "192.168.%d.%d" % (first, second)
  40
  41     def get_virt_net(self, remote):
  42         link = self.get_link_id(remote)
  43         first = link >> 6
  44         second = (link & 0x3f)<<2
  45         return "192.168.%d.%d/30" % (first, second)
  46
  47     def get_site(self, sites):
  48         return sites[self.site_id]
  49
  50     def adjacent_nodes(self, sites, nodes, node_ids):
  51         mysite = self.get_site(sites)
  52         adj_ids = mysite.adj_node_ids.intersection(node_ids)
  53         adj_nodes = []
  54         for id in adj_ids:
  55             adj_nodes.append(nodes[id])
  56         return adj_nodes
  57
  58     def init_links(self):
  59         self.links = []
  60
  61     def add_link(self, remote, bw):
  62         my_ip = self.get_virt_ip(remote)
  63         remote_ip = remote.get_virt_ip(self)
  64         net = self.get_virt_net(remote)
  65         link = remote.id, remote.ipaddr, bw, my_ip, remote_ip, net
  66         self.links.append(link)
  67
  68
  69 class Site:
  70     def __init__(self, site):
  71         self.id = site['site_id']
  72         self.node_ids = site['node_ids']
  73         self.adj_site_ids = set()
  74         self.adj_node_ids = set()
  75
  76     def get_sitenodes(self, nodes):
  77         n = []
  78         for i in self.node_ids:
  79             n.append(nodes[i])
  80         return n
  81
  82     def add_adjacency(self, site):
  83         self.adj_site_ids.add(site.id)
  84         for n in site.node_ids:
  85             self.adj_node_ids.add(n)
  86
  87
  88 class Slice:
  89     def __init__(self, slice):
  90         self.id = slice['slice_id']
  91         self.name = slice['name']
  92         self.node_ids = set(slice['node_ids'])
  93         self.slice_tag_ids = slice['slice_tag_ids']
  94
  95     def get_tag(self, tagname, slicetags, node = None):
  96         for i in self.slice_tag_ids:
  97             tag = slicetags[i]
  98             if tag.tagname == tagname:
  99                 if (not node) or (node.id == tag.node_id):
 100                     return tag
 101         else:
 102             return None
 103
 104     def get_nodes(self, nodes):
 105         n = []
 106         for id in self.node_ids:
 107             n.append(nodes[id])
 108         return n
 109
 110
 111     # Add a new slice tag
 112     def add_tag(self, tagname, value, slicetags, node = None):
 113         record = {'slice_tag_id':None, 'slice_id':self.id, 'tagname':tagname, 'value':value}
 114         if node:
 115             record['node_id'] = node.id
 116         else:
 117             record['node_id'] = None
 118         tag = Slicetag(record)
 119         slicetags[tag.id] = tag
 120         self.slice_tag_ids.append(tag.id)
 121         tag.changed = True
 122         tag.updated = True
 123         return tag
 124
 125     # Update a slice tag if it exists, else add it
 126     def update_tag(self, tagname, value, slicetags, node = None):
 127         tag = self.get_tag(tagname, slicetags, node)
 128         if tag and tag.value == value:
 129             value = "no change"
 130         elif tag:
 131             tag.value = value
 132             tag.changed = True
 133         else:
 134             tag = self.add_tag(tagname, value, slicetags, node)
 135         tag.updated = True
 136
 137     def assign_egre_key(self, slicetags):
 138         if not self.get_tag('egre_key', slicetags):
 139             try:
 140                 key = free_egre_key(slicetags)
 141                 self.update_tag('egre_key', key, slicetags)
 142             except:
 143                 # Should handle this case...
 144                 pass
 145         return
 146
 147     def turn_on_netns(self, slicetags):
 148         tag = self.get_tag('netns', slicetags)
 149         if (not tag) or (tag.value != '1'):
 150             self.update_tag('netns', '1', slicetags)
 151         return
 152
 153     def turn_off_netns(self, slicetags):
 154         tag = self.get_tag('netns', slicetags)
 155         if tag and (tag.value != '0'):
 156             tag.delete()
 157         return
 158
 159     def add_cap_net_admin(self, slicetags):
 160         tag = self.get_tag('capabilities', slicetags)
 161         if tag:
 162             caps = tag.value.split(',')
 163             for cap in caps:
 164                 if cap == "CAP_NET_ADMIN":
 165                     return
 166             else:
 167                 newcaps = "CAP_NET_ADMIN," + tag.value
 168                 self.update_tag('capabilities', newcaps, slicetags)
 169         else:
 170             self.add_tag('capabilities', 'CAP_NET_ADMIN', slicetags)
 171         return
 172
 173     def remove_cap_net_admin(self, slicetags):
 174         tag = self.get_tag('capabilities', slicetags)
 175         if tag:
 176             caps = tag.value.split(',')
 177             newcaps = []
 178             for cap in caps:
 179                 if cap != "CAP_NET_ADMIN":
 180                     newcaps.append(cap)
 181             if newcaps:
 182                 value = ','.join(newcaps)
 183                 self.update_tag('capabilities', value, slicetags)
 184             else:
 185                 tag.delete()
 186         return
 187
 188     # Update the vsys/setup-link and vsys/setup-nat slice tags.
 189     def add_vsys_tags(self, slicetags):
 190         link = nat = False
 191         for i in self.slice_tag_ids:
 192             tag = slicetags[i]
 193             if tag.tagname == 'vsys':
 194                 if tag.value == 'setup-link':
 195                     link = True
 196                 elif tag.value == 'setup-nat':
 197                     nat = True
 198         if not link:
 199             self.add_tag('vsys', 'setup-link', slicetags)
 200         if not nat:
 201             self.add_tag('vsys', 'setup-nat', slicetags)
 202         return
 203
 204
 205 class Slicetag:
 206     newid = -1
 207     def __init__(self, tag):
 208         self.id = tag['slice_tag_id']
 209         if not self.id:
 210             # Make one up for the time being...
 211             self.id = Slicetag.newid
 212             Slicetag.newid -= 1
 213         self.slice_id = tag['slice_id']
 214         self.tagname = tag['tagname']
 215         self.value = tag['value']
 216         self.node_id = tag['node_id']
 217         self.updated = False
 218         self.changed = False
 219         self.deleted = False
 220
 221     # Mark a tag as deleted
 222     def delete(self):
 223         self.deleted = True
 224         self.updated = True
 225
 226     def write(self, api):
 227         if self.changed:
 228             if int(self.id) > 0:
 229                 api.plshell.UpdateSliceTag(api.plauth, self.id, self.value)
 230             else:
 231                 api.plshell.AddSliceTag(api.plauth, self.slice_id,
 232                                         self.tagname, self.value, self.node_id)
 233         elif self.deleted and int(self.id) > 0:
 234             api.plshell.DeleteSliceTag(api.plauth, self.id)
 235
 236
 237 """
 238 Create a dictionary of site objects keyed by site ID
 239 """
 240 def get_sites():
 241     tmp = []
 242     for site in GetSites():
 243         t = site['site_id'], Site(site)
 244         tmp.append(t)
 245     return dict(tmp)
 246
 247
 248 """
 249 Create a dictionary of node objects keyed by node ID
 250 """
 251 def get_nodes(api):
 252     tmp = []
 253     for node in api.plshell.GetNodes(api.plauth):
 254         t = node['node_id'], Node(node)
 255         tmp.append(t)
 256     return dict(tmp)
 257
 258 """
 259 Create a dictionary of slice objects keyed by slice ID
 260 """
 261 def get_slice(api, slicename):
 262     slice = api.plshell.GetSlices(api.plauth, [slicename])
 263     if slice:
 264         return Slice(slice[0])
 265     else:
 266         return None
 267
 268 """
 269 Create a dictionary of slicetag objects keyed by slice tag ID
 270 """
 271 def get_slice_tags(api):
 272     tmp = []
 273     for tag in api.plshell.GetSliceTags(api.plauth):
 274         t = tag['slice_tag_id'], Slicetag(tag)
 275         tmp.append(t)
 276     return dict(tmp)
 277
 278 """
 279 Find a free EGRE key
 280 """
 281 def free_egre_key(slicetags):
 282     used = set()
 283     for i in slicetags:
 284         tag = slicetags[i]
 285         if tag.tagname == 'egre_key':
 286             used.add(int(tag.value))
 287
 288     for i in range(1, 256):
 289         if i not in used:
 290             key = i
 291             break
 292     else:
 293         raise KeyError("No more EGRE keys available")
 294
 295     return "%s" % key
 296
 297
 298 """
 299 Copied from create_slice_aggregate() in sfa.plc.slices
 300 """
 301 def create_slice_vini_aggregate(api, hrn, nodes):
 302     # Get the slice record from geni
 303     slice = {}
 304     registries = Registries(api)
 305     registry = registries[api.hrn]
 306     credential = api.getCredential()
 307     records = registry.resolve(credential, hrn)
 308     for record in records:
 309         if record.get_type() in ['slice']:
 310             slice = record.as_dict()
 311     if not slice:
 312         raise RecordNotFound(hrn)
 313
 314     # Make sure slice exists at plc, if it doesnt add it
 315     slicename = hrn_to_pl_slicename(hrn)
 316     slices = api.plshell.GetSlices(api.plauth, [slicename], ['node_ids'])
 317     if not slices:
 318         parts = slicename.split("_")
 319         login_base = parts[0]
 320         # if site doesnt exist add it
 321         sites = api.plshell.GetSites(api.plauth, [login_base])
 322         if not sites:
 323             authority = get_authority(hrn)
 324             site_records = registry.resolve(credential, authority)
 325             site_record = {}
 326             if not site_records:
 327                 raise RecordNotFound(authority)
 328             site_record = site_records[0]
 329             site = site_record.as_dict()
 330
 331             # add the site
 332             site.pop('site_id')
 333             site_id = api.plshell.AddSite(api.plauth, site)
 334         else:
 335             site = sites[0]
 336
 337         slice_fields = {}
 338         slice_keys = ['name', 'url', 'description']
 339         for key in slice_keys:
 340             if key in slice and slice[key]:
 341                 slice_fields[key] = slice[key]
 342         api.plshell.AddSlice(api.plauth, slice_fields)
 343         slice = slice_fields
 344         slice['node_ids'] = 0
 345     else:
 346         slice = slices[0]
 347
 348     # get the list of valid slice users from the registry and make
 349     # they are added to the slice
 350     researchers = record.get('researcher', [])
 351     for researcher in researchers:
 352         person_record = {}
 353         person_records = registry.resolve(credential, researcher)
 354         for record in person_records:
 355             if record.get_type() in ['user']:
 356                 person_record = record
 357         if not person_record:
 358             pass
 359         person_dict = person_record.as_dict()
 360         persons = api.plshell.GetPersons(api.plauth, [person_dict['email']],
 361                                          ['person_id', 'key_ids'])
 362
 363         # Create the person record
 364         if not persons:
 365             person_id=api.plshell.AddPerson(api.plauth, person_dict)
 366
 367             # The line below enables the user account on the remote aggregate
 368             # soon after it is created.
 369             # without this the user key is not transfered to the slice
 370             # (as GetSlivers returns key of only enabled users),
 371             # which prevents the user from login to the slice.
 372             # We may do additional checks before enabling the user.
 373
 374             api.plshell.UpdatePerson(api.plauth, person_id, {'enabled' : True})
 375             key_ids = []
 376         else:
 377             key_ids = persons[0]['key_ids']
 378
 379         api.plshell.AddPersonToSlice(api.plauth, person_dict['email'],
 380                                      slicename)
 381
 382         # Get this users local keys
 383         keylist = api.plshell.GetKeys(api.plauth, key_ids, ['key'])
 384         keys = [key['key'] for key in keylist]
 385
 386         # add keys that arent already there
 387         for personkey in person_dict['keys']:
 388             if personkey not in keys:
 389                 key = {'key_type': 'ssh', 'key': personkey}
 390                 api.plshell.AddPersonKey(api.plauth, person_dict['email'], key)
 391
 392     # find out where this slice is currently running
 393     nodelist = api.plshell.GetNodes(api.plauth, slice['node_ids'],
 394                                     ['hostname'])
 395     hostnames = [node['hostname'] for node in nodelist]
 396
 397     # remove nodes not in rspec
 398     deleted_nodes = list(set(hostnames).difference(nodes))
 399     # add nodes from rspec
 400     added_nodes = list(set(nodes).difference(hostnames))
 401
 402 """
 403     print >> sys.stderr, "Slice on nodes:"
 404     for n in hostnames:
 405         print >> sys.stderr, n
 406     print >> sys.stderr, "Wants nodes:"
 407     for n in nodes:
 408         print >> sys.stderr, n
 409     print >> sys.stderr, "Deleting nodes:"
 410     for n in deleted_nodes:
 411         print >> sys.stderr, n
 412     print >> sys.stderr, "Adding nodes:"
 413     for n in added_nodes:
 414         print >> sys.stderr, n
 415 """
 416
 417     api.plshell.AddSliceToNodes(api.plauth, slicename, added_nodes)
 418     api.plshell.DeleteSliceFromNodes(api.plauth, slicename, deleted_nodes)
 419
 420     return 1
 421
 422 def get_rspec(api, hrn):
 423     # Get default rspec
 424     default = Rspec()
 425     default.parseFile(SFA_VINI_DEFAULT_RSPEC)
 426
 427     if (hrn):
 428         slicename = hrn_to_pl_slicename(hrn)
 429         defaultrspec = default.toDict()
 430         nodedict = get_nodedict(defaultrspec)
 431
 432         # call the default sfa.plc.nodes.get_rspec() method
 433         nodes = Nodes(api)
 434         rspec = nodes.get_rspec(hrn)
 435
 436         # Grab all the PLC info we'll need at once
 437         slice = get_slice(api, slicename)
 438         if slice:
 439             nodes = get_nodes(api)
 440             tags = get_slice_tags(api)
 441
 442             # Add the node tags from the Capacity statement to Node objects
 443             for (k, v) in nodedict.iteritems():
 444                 for id in nodes:
 445                     if v == nodes[id].hostname:
 446                         nodes[id].tag = k
 447
 448             endpoints = []
 449             for node in slice.get_nodes(nodes):
 450                 linktag = slice.get_tag('topo_rspec', tags, node)
 451                 if linktag:
 452                     l = eval(linktag.value)
 453                     for (id, realip, bw, lvip, rvip, vnet) in l:
 454                         endpoints.append((node.id, id, bw))
 455
 456             if endpoints:
 457                 linkspecs = []
 458                 for (l, r, bw) in endpoints:
 459                     if (r, l, bw) in endpoints:
 460                         if l < r:
 461                             edict = {}
 462                             edict['endpoint'] = [nodes[l].tag, nodes[r].tag]
 463                             edict['bw'] = [bw]
 464                             linkspecs.append(edict)
 465
 466                 d = default.toDict()
 467                 d['Rspec']['Request'][0]['NetSpec'][0]['LinkSpec'] = linkspecs
 468                 d['Rspec']['Request'][0]['NetSpec'][0]['name'] = hrn
 469                 new = Rspec()
 470                 new.parseDict(d)
 471                 rspec = new.toxml()
 472     else:
 473         # Return canned response for now...
 474         rspec = default.toxml()
 475
 476     return rspec
 477
 478
 479 def create_slice(api, hrn, xml):
 480     r = Rspec(xml)
 481     rspec = r.toDict()
 482
 483     # Check request against current allocations
 484     # Request OK
 485
 486     nodes = rspec_to_nodeset(rspec)
 487     create_slice_vini_aggregate(api, hrn, nodes)
 488
 489     # Add VINI-specific topology attributes to slice here
 490     try:
 491         linkspecs = rspec['Rspec']['Request'][0]['NetSpec'][0]['LinkSpec']
 492         if linkspecs:
 493             slicename = hrn_to_pl_slicename(hrn)
 494
 495             # Grab all the PLC info we'll need at once
 496             slice = get_slice(api, slicename)
 497             if slice:
 498                 nodes = get_nodes(api)
 499                 tags = get_slice_tags(api)
 500
 501                 slice.update_tag('vini_topo', 'manual', tags)
 502                 slice.assign_egre_key(tags)
 503                 slice.turn_on_netns(tags)
 504                 slice.add_cap_net_admin(tags)
 505
 506                 nodedict = {}
 507                 for (k, v) in get_nodedict(rspec).iteritems():
 508                     for id in nodes:
 509                         if v == nodes[id].hostname:
 510                             nodedict[k] = nodes[id]
 511
 512                 for l in linkspecs:
 513                     n1 = nodedict[l['endpoint'][0]]
 514                     n2 = nodedict[l['endpoint'][1]]
 515                     bw = l['bw'][0]
 516                     n1.add_link(n2, bw)
 517                     n2.add_link(n1, bw)
 518
 519                 for node in slice.get_nodes(nodes):
 520                     if node.links:
 521                         topo_str = "%s" % node.links
 522                         slice.update_tag('topo_rspec', topo_str, tags, node)
 523
 524                 # Update slice tags in database
 525                 for i in tags:
 526                     tag = tags[i]
 527                     if tag.slice_id == slice.id:
 528                         if tag.tagname == 'topo_rspec' and not tag.updated:
 529                             tag.delete()
 530                         tag.write(api)
 531     except KeyError:
 532         # Bad Rspec
 533         pass
 534
 535
 536     return True
 537
 538 def get_nodedict(rspec):
 539     nodedict = {}
 540     try:
 541         sitespecs = rspec['Rspec']['Capacity'][0]['NetSpec'][0]['SiteSpec']
 542         for s in sitespecs:
 543             for node in s['NodeSpec']:
 544                 nodedict[node['name']] = node['hostname'][0]
 545     except KeyError:
 546         pass
 547
 548     return nodedict
 549
 550
 551 def rspec_to_nodeset(rspec):
 552     nodes = set()
 553     try:
 554         nodedict = get_nodedict(rspec)
 555         linkspecs = rspec['Rspec']['Request'][0]['NetSpec'][0]['LinkSpec']
 556         for l in linkspecs:
 557             for e in l['endpoint']:
 558                 nodes.add(nodedict[e])
 559     except KeyError:
 560         # Bad Rspec
 561         pass
 562
 563     return nodes
 564
 565 def main():
 566     r = Rspec()
 567     r.parseFile(sys.argv[1])
 568     rspec = r.toDict()
 569     create_slice(None,'plc',rspec)
 570
 571 if __name__ == "__main__":
 572     main()