sfa/plc/slices.py

   1 ### $Id$
   2 ### $URL$
   3
   4 import datetime
   5 import time
   6 import traceback
   7 import sys
   8
   9 from types import StringTypes
  10 from sfa.util.namespace import *
  11 from sfa.util.rspec import *
  12 from sfa.util.specdict import *
  13 from sfa.util.faults import *
  14 from sfa.util.record import SfaRecord
  15 from sfa.util.policy import Policy
  16 from sfa.util.prefixTree import prefixTree
  17 from sfa.util.debug import log
  18
  19 MAXINT =  2L**31-1
  20
  21 class Slices:
  22
  23     rspec_to_slice_tag = {'max_rate':'net_max_rate'}
  24
  25     def __init__(self, api, ttl = .5, origin_hrn=None):
  26         self.api = api
  27         #filepath = path + os.sep + filename
  28         self.policy = Policy(self.api)
  29         self.origin_hrn = origin_hrn
  30
  31     def get_slivers(self, xrn, node=None):
  32         hrn, type = urn_to_hrn(xrn)
  33
  34         slice_name = hrn_to_pl_slicename(hrn)
  35         # XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead
  36         # of doing all of this?
  37         #return self.api.GetSliceTicket(self.auth, slice_name)
  38
  39         # from PLCAPI.GetSlivers.get_slivers()
  40         slice_fields = ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids']
  41         slices = self.api.plshell.GetSlices(self.api.plauth, slice_name, slice_fields)
  42         # Build up list of users and slice attributes
  43         person_ids = set()
  44         all_slice_tag_ids = set()
  45         for slice in slices:
  46             person_ids.update(slice['person_ids'])
  47             all_slice_tag_ids.update(slice['slice_tag_ids'])
  48         person_ids = list(person_ids)
  49         all_slice_tag_ids = list(all_slice_tag_ids)
  50         # Get user information
  51         all_persons_list = self.api.plshell.GetPersons(self.api.plauth, {'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids'])
  52         all_persons = {}
  53         for person in all_persons_list:
  54             all_persons[person['person_id']] = person
  55
  56         # Build up list of keys
  57         key_ids = set()
  58         for person in all_persons.values():
  59             key_ids.update(person['key_ids'])
  60         key_ids = list(key_ids)
  61         # Get user account keys
  62         all_keys_list = self.api.plshell.GetKeys(self.api.plauth, key_ids, ['key_id', 'key', 'key_type'])
  63         all_keys = {}
  64         for key in all_keys_list:
  65             all_keys[key['key_id']] = key
  66         # Get slice attributes
  67         all_slice_tags_list = self.api.plshell.GetSliceTags(self.api.plauth, all_slice_tag_ids)
  68         all_slice_tags = {}
  69         for slice_tag in all_slice_tags_list:
  70             all_slice_tags[slice_tag['slice_tag_id']] = slice_tag
  71
  72         slivers = []
  73         for slice in slices:
  74             keys = []
  75             for person_id in slice['person_ids']:
  76                 if person_id in all_persons:
  77                     person = all_persons[person_id]
  78                     if not person['enabled']:
  79                         continue
  80                     for key_id in person['key_ids']:
  81                         if key_id in all_keys:
  82                             key = all_keys[key_id]
  83                             keys += [{'key_type': key['key_type'],
  84                                     'key': key['key']}]
  85             attributes = []
  86             # All (per-node and global) attributes for this slice
  87             slice_tags = []
  88             for slice_tag_id in slice['slice_tag_ids']:
  89                 if slice_tag_id in all_slice_tags:
  90                     slice_tags.append(all_slice_tags[slice_tag_id])
  91             # Per-node sliver attributes take precedence over global
  92             # slice attributes, so set them first.
  93             # Then comes nodegroup slice attributes
  94             # Followed by global slice attributes
  95             sliver_attributes = []
  96
  97             if node is not None:
  98                 for sliver_attribute in filter(lambda a: a['node_id'] == node['node_id'], slice_tags):
  99                     sliver_attributes.append(sliver_attribute['tagname'])
 100                     attributes.append({'tagname': sliver_attribute['tagname'],
 101                                     'value': sliver_attribute['value']})
 102
 103             # set nodegroup slice attributes
 104             for slice_tag in filter(lambda a: a['nodegroup_id'] in node['nodegroup_ids'], slice_tags):
 105                 # Do not set any nodegroup slice attributes for
 106                 # which there is at least one sliver attribute
 107                 # already set.
 108                 if slice_tag not in slice_tags:
 109                     attributes.append({'tagname': slice_tag['tagname'],
 110                         'value': slice_tag['value']})
 111
 112             for slice_tag in filter(lambda a: a['node_id'] is None, slice_tags):
 113                 # Do not set any global slice attributes for
 114                 # which there is at least one sliver attribute
 115                 # already set.
 116                 if slice_tag['tagname'] not in sliver_attributes:
 117                     attributes.append({'tagname': slice_tag['tagname'],
 118                                    'value': slice_tag['value']})
 119
 120             # XXX Sanity check; though technically this should be a system invariant
 121             # checked with an assertion
 122             if slice['expires'] > MAXINT:  slice['expires']= MAXINT
 123
 124             slivers.append({
 125                 'hrn': hrn,
 126                 'name': slice['name'],
 127                 'slice_id': slice['slice_id'],
 128                 'instantiation': slice['instantiation'],
 129                 'expires': slice['expires'],
 130                 'keys': keys,
 131                 'attributes': attributes
 132             })
 133
 134         return slivers
 135
 136     def get_peer(self, xrn):
 137         hrn, type = urn_to_hrn(xrn)
 138         # Becaues of myplc federation,  we first need to determine if this
 139         # slice belongs to out local plc or a myplc peer. We will assume it
 140         # is a local site, unless we find out otherwise
 141         peer = None
 142
 143         # get this slice's authority (site)
 144         slice_authority = get_authority(hrn)
 145
 146         # get this site's authority (sfa root authority or sub authority)
 147         site_authority = get_authority(slice_authority).lower()
 148
 149         # check if we are already peered with this site_authority, if so
 150         peers = self.api.plshell.GetPeers(self.api.plauth, {}, ['peer_id', 'peername', 'shortname', 'hrn_root'])
 151         for peer_record in peers:
 152             names = [name.lower() for name in peer_record.values() if isinstance(name, StringTypes)]
 153             if site_authority in names:
 154                 peer = peer_record['shortname']
 155
 156         return peer
 157
 158     def get_sfa_peer(self, xrn):
 159         hrn, type = urn_to_hrn(xrn)
 160
 161         # return the authority for this hrn or None if we are the authority
 162         sfa_peer = None
 163         slice_authority = get_authority(hrn)
 164         site_authority = get_authority(slice_authority)
 165
 166         if site_authority != self.api.hrn:
 167             sfa_peer = site_authority
 168
 169         return sfa_peer
 170
 171     def verify_site(self, registry, credential, slice_hrn, peer, sfa_peer):
 172         authority = get_authority(slice_hrn)
 173         authority_urn = hrn_to_urn(authority, 'authority')
 174         site_records = registry.resolve(credential, authority_urn)
 175
 176         site = {}
 177         for site_record in site_records:
 178             if site_record['type'] == 'authority':
 179                 site = site_record
 180         if not site:
 181             raise RecordNotFound(authority)
 182         remote_site_id = site.pop('site_id')
 183
 184         login_base = get_leaf(authority)
 185         sites = self.api.plshell.GetSites(self.api.plauth, login_base)
 186         if not sites:
 187             site_id = self.api.plshell.AddSite(self.api.plauth, site)
 188             if peer:
 189                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id)
 190             # mark this site as an sfa peer record
 191             if sfa_peer:
 192                 peer_dict = {'type': 'authority', 'hrn': authority, 'peer_authority': sfa_peer, 'pointer': site_id}
 193                 registry.register_peer_object(credential, peer_dict)
 194         else:
 195             site_id = sites[0]['site_id']
 196             remote_site_id = sites[0]['peer_site_id']
 197             old_site = sites[0]
 198             #the site is alredy on the remote agg. Let us update(e.g. max_slices field) it with the latest info.
 199             self.sync_site(old_site, site, peer)
 200
 201
 202         return (site_id, remote_site_id)
 203
 204     def verify_slice(self, registry, credential, slice_hrn, site_id, remote_site_id, peer, sfa_peer):
 205         slice = {}
 206         slice_record = None
 207         authority = get_authority(slice_hrn)
 208         slice_records = registry.resolve(credential, slice_hrn)
 209
 210         for record in slice_records:
 211             if record['type'] in ['slice']:
 212                 slice_record = record
 213         if not slice_record:
 214             raise RecordNotFound(hrn)
 215         slicename = hrn_to_pl_slicename(slice_hrn)
 216         parts = slicename.split("_")
 217         login_base = parts[0]
 218         slices = self.api.plshell.GetSlices(self.api.plauth, [slicename])
 219         if not slices:
 220             slice_fields = {}
 221             slice_keys = ['name', 'url', 'description']
 222             for key in slice_keys:
 223                 if key in slice_record and slice_record[key]:
 224                     slice_fields[key] = slice_record[key]
 225
 226             # add the slice
 227             slice_id = self.api.plshell.AddSlice(self.api.plauth, slice_fields)
 228             slice = slice_fields
 229             slice['slice_id'] = slice_id
 230
 231             # mark this slice as an sfa peer record
 232             if sfa_peer:
 233                 peer_dict = {'type': 'slice', 'hrn': slice_hrn, 'peer_authority': sfa_peer, 'pointer': slice_id}
 234                 registry.register_peer_object(credential, peer_dict)
 235
 236             #this belongs to a peer
 237             if peer:
 238                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'slice', slice_id, peer, slice_record['pointer'])
 239             slice['node_ids'] = []
 240         else:
 241             slice = slices[0]
 242             slice_id = slice['slice_id']
 243             site_id = slice['site_id']
 244             #the slice is alredy on the remote agg. Let us update(e.g. expires field) it with the latest info.
 245             self.sync_slice(slice, slice_record, peer)
 246
 247         slice['peer_slice_id'] = slice_record['pointer']
 248         self.verify_persons(registry, credential, slice_record, site_id, remote_site_id, peer, sfa_peer)
 249
 250         return slice
 251
 252     def verify_persons(self, registry, credential, slice_record, site_id, remote_site_id, peer, sfa_peer):
 253         # get the list of valid slice users from the registry and make
 254         # sure they are added to the slice
 255         slicename = hrn_to_pl_slicename(slice_record['hrn'])
 256         researchers = slice_record.get('researcher', [])
 257         for researcher in researchers:
 258             person_record = {}
 259             person_records = registry.resolve(credential, researcher)
 260             for record in person_records:
 261                 if record['type'] in ['user'] and record['enabled']:
 262                     person_record = record
 263             if not person_record:
 264                 return 1
 265             person_dict = person_record
 266             local_person=False
 267             if peer:
 268                 peer_id = self.api.plshell.GetPeers(self.api.plauth, {'shortname': peer}, ['peer_id'])[0]['peer_id']
 269                 persons = self.api.plshell.GetPersons(self.api.plauth, {'email': [person_dict['email']], 'peer_id': peer_id}, ['person_id', 'key_ids'])
 270                 if not persons:
 271                     persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids'])
 272                     if persons:
 273                        local_person=True
 274
 275             else:
 276                 persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids'])
 277
 278             if not persons:
 279                 person_id=self.api.plshell.AddPerson(self.api.plauth, person_dict)
 280                 self.api.plshell.UpdatePerson(self.api.plauth, person_id, {'enabled' : True})
 281
 282                 # mark this person as an sfa peer record
 283                 if sfa_peer:
 284                     peer_dict = {'type': 'user', 'hrn': researcher, 'peer_authority': sfa_peer, 'pointer': person_id}
 285                     registry.register_peer_object(credential, peer_dict)
 286
 287                 if peer:
 288                     self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
 289                 key_ids = []
 290             else:
 291                 person_id = persons[0]['person_id']
 292                 key_ids = persons[0]['key_ids']
 293
 294
 295             # if this is a peer person, we must unbind them from the peer or PLCAPI will throw
 296             # an error
 297             if peer:
 298                 self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer)
 299                 self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'site', site_id,  peer)
 300
 301             self.api.plshell.AddPersonToSlice(self.api.plauth, person_dict['email'], slicename)
 302             self.api.plshell.AddPersonToSite(self.api.plauth, person_dict['email'], site_id)
 303             if peer and not local_person:
 304                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
 305             if peer:
 306                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id)
 307
 308             self.verify_keys(registry, credential, person_dict, key_ids, person_id, peer, local_person)
 309
 310     def verify_keys(self, registry, credential, person_dict, key_ids, person_id,  peer, local_person):
 311         keylist = self.api.plshell.GetKeys(self.api.plauth, key_ids, ['key'])
 312         keys = [key['key'] for key in keylist]
 313
 314         #add keys that arent already there
 315         key_ids = person_dict['key_ids']
 316         for personkey in person_dict['keys']:
 317             if personkey not in keys:
 318                 key = {'key_type': 'ssh', 'key': personkey}
 319                 if peer:
 320                     self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer)
 321                 key_id = self.api.plshell.AddPersonKey(self.api.plauth, person_dict['email'], key)
 322                 if peer and not local_person:
 323                     self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
 324                 if peer:
 325                     try: self.api.plshell.BindObjectToPeer(self.api.plauth, 'key', key_id, peer, key_ids.pop(0))
 326
 327                     except: pass
 328
 329     def create_slice_aggregate(self, xrn, rspec):
 330         hrn, type = urn_to_hrn(xrn)
 331         # Determine if this is a peer slice
 332         peer = self.get_peer(hrn)
 333         sfa_peer = self.get_sfa_peer(hrn)
 334
 335         spec = RSpec(rspec)
 336         # Get the slice record from sfa
 337         slicename = hrn_to_pl_slicename(hrn)
 338         slice = {}
 339         slice_record = None
 340         registry = self.api.registries[self.api.hrn]
 341         credential = self.api.getCredential()
 342
 343         site_id, remote_site_id = self.verify_site(registry, credential, hrn, peer, sfa_peer)
 344         slice = self.verify_slice(registry, credential, hrn, site_id, remote_site_id, peer, sfa_peer)
 345
 346         # find out where this slice is currently running
 347         nodelist = self.api.plshell.GetNodes(self.api.plauth, slice['node_ids'], ['hostname'])
 348         hostnames = [node['hostname'] for node in nodelist]
 349
 350         # get netspec details
 351         nodespecs = spec.getDictsByTagName('NodeSpec')
 352
 353         # dict in which to store slice attributes to set for the nodes
 354         nodes = {}
 355         for nodespec in nodespecs:
 356             if isinstance(nodespec['name'], list):
 357                 for nodename in nodespec['name']:
 358                     nodes[nodename] = {}
 359                     for k in nodespec.keys():
 360                         rspec_attribute_value = nodespec[k]
 361                         if (self.rspec_to_slice_tag.has_key(k)):
 362                             slice_tag_name = self.rspec_to_slice_tag[k]
 363                             nodes[nodename][slice_tag_name] = rspec_attribute_value
 364             elif isinstance(nodespec['name'], StringTypes):
 365                 nodename = nodespec['name']
 366                 nodes[nodename] = {}
 367                 for k in nodespec.keys():
 368                     rspec_attribute_value = nodespec[k]
 369                     if (self.rspec_to_slice_tag.has_key(k)):
 370                         slice_tag_name = self.rspec_to_slice_tag[k]
 371                         nodes[nodename][slice_tag_name] = rspec_attribute_value
 372
 373                 for k in nodespec.keys():
 374                     rspec_attribute_value = nodespec[k]
 375                     if (self.rspec_to_slice_tag.has_key(k)):
 376                         slice_tag_name = self.rspec_to_slice_tag[k]
 377                         nodes[nodename][slice_tag_name] = rspec_attribute_value
 378
 379         node_names = nodes.keys()
 380         # remove nodes not in rspec
 381         deleted_nodes = list(set(hostnames).difference(node_names))
 382         # add nodes from rspec
 383         added_nodes = list(set(node_names).difference(hostnames))
 384
 385         if peer:
 386             self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'slice', slice['slice_id'], peer)
 387
 388         self.api.plshell.AddSliceToNodes(self.api.plauth, slicename, added_nodes)
 389
 390         # Add recognized slice tags
 391         for node_name in node_names:
 392             node = nodes[node_name]
 393             for slice_tag in node.keys():
 394                 value = node[slice_tag]
 395                 if (isinstance(value, list)):
 396                     value = value[0]
 397
 398                 self.api.plshell.AddSliceTag(self.api.plauth, slicename, slice_tag, value, node_name)
 399
 400         self.api.plshell.DeleteSliceFromNodes(self.api.plauth, slicename, deleted_nodes)
 401         if peer:
 402             self.api.plshell.BindObjectToPeer(self.api.plauth, 'slice', slice['slice_id'], peer, slice['peer_slice_id'])
 403
 404         return 1
 405
 406     def sync_site(self, old_record, new_record, peer):
 407         if old_record['max_slices'] != new_record['max_slices'] or old_record['max_slivers'] != new_record['max_slivers']:
 408             if peer:
 409                 self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'site', old_record['site_id'], peer)
 410             if old_record['max_slices'] != new_record['max_slices']:
 411                 self.api.plshell.UpdateSite(self.api.plauth, old_record['site_id'], {'max_slices' : new_record['max_slices']})
 412             if old_record['max_slivers'] != new_record['max_slivers']:
 413                 self.api.plshell.UpdateSite(self.api.plauth, old_record['site_id'], {'max_slivers' : new_record['max_slivers']})
 414             if peer:
 415                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', old_record['site_id'], peer, old_record['peer_site_id'])
 416         return 1
 417
 418     def sync_slice(self, old_record, new_record, peer):
 419         if old_record['expires'] != new_record['expires']:
 420             if peer:
 421                 self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'slice', old_record['slice_id'], peer)
 422             self.api.plshell.UpdateSlice(self.api.plauth, old_record['slice_id'], {'expires' : new_record['expires']})
 423             if peer:
 424                 self.api.plshell.BindObjectToPeer(self.api.plauth, 'slice', old_record['slice_id'], peer, old_record['peer_slice_id'])
 425         return 1