sfa/managers/aggregate_manager.py

   1 import datetime
   2 import time
   3 import traceback
   4 import sys
   5 import re
   6 from types import StringTypes
   7
   8 from sfa.util.faults import *
   9 from sfa.util.xrn import get_authority, hrn_to_urn, urn_to_hrn, Xrn, urn_to_sliver_id
  10 from sfa.util.plxrn import slicename_to_hrn, hrn_to_pl_slicename, hostname_to_urn
  11 from sfa.util.specdict import *
  12 from sfa.util.record import SfaRecord
  13 from sfa.util.policy import Policy
  14 from sfa.util.record import *
  15 from sfa.util.sfaticket import SfaTicket
  16 from sfa.plc.slices import Slices
  17 from sfa.trust.credential import Credential
  18 import sfa.plc.peers as peers
  19 from sfa.plc.network import *
  20 from sfa.plc.api import SfaAPI
  21 from sfa.plc.aggregate import Aggregate
  22 from sfa.plc.slices import *
  23 from sfa.util.version import version_core
  24 from sfa.rspecs.version_manager import VersionManager
  25 from sfa.rspecs.rspec import RSpec
  26 from sfa.util.sfatime import utcparse
  27 from sfa.util.callids import Callids
  28
  29 def GetVersion(api):
  30
  31     version_manager = VersionManager()
  32     ad_rspec_versions = []
  33     request_rspec_versions = []
  34     for rspec_version in version_manager.versions:
  35         if rspec_version.content_type in ['*', 'ad']:
  36             ad_rspec_versions.append(rspec_version.to_dict())
  37         if rspec_version.content_type in ['*', 'request']:
  38             request_rspec_versions.append(rspec_version.to_dict())
  39     default_rspec_version = version_manager.get_version("sfa 1").to_dict()
  40     xrn=Xrn(api.hrn)
  41     version_more = {'interface':'aggregate',
  42                     'testbed':'myplc',
  43                     'hrn':xrn.get_hrn(),
  44                     'request_rspec_versions': request_rspec_versions,
  45                     'ad_rspec_versions': ad_rspec_versions,
  46                     'default_ad_rspec': default_rspec_version
  47                     }
  48     return version_core(version_more)
  49
  50 def __get_registry_objects(slice_xrn, creds, users):
  51     """
  52
  53     """
  54     hrn, type = urn_to_hrn(slice_xrn)
  55
  56     hrn_auth = get_authority(hrn)
  57
  58     # Build up objects that an SFA registry would return if SFA
  59     # could contact the slice's registry directly
  60     reg_objects = None
  61
  62     if users:
  63         # dont allow special characters in the site login base
  64         #only_alphanumeric = re.compile('[^a-zA-Z0-9]+')
  65         #login_base = only_alphanumeric.sub('', hrn_auth[:20]).lower()
  66         slicename = hrn_to_pl_slicename(hrn)
  67         login_base = slicename.split('_')[0]
  68         reg_objects = {}
  69         site = {}
  70         site['site_id'] = 0
  71         site['name'] = 'geni.%s' % login_base
  72         site['enabled'] = True
  73         site['max_slices'] = 100
  74
  75         # Note:
  76         # Is it okay if this login base is the same as one already at this myplc site?
  77         # Do we need uniqueness?  Should use hrn_auth instead of just the leaf perhaps?
  78         site['login_base'] = login_base
  79         site['abbreviated_name'] = login_base
  80         site['max_slivers'] = 1000
  81         reg_objects['site'] = site
  82
  83         slice = {}
  84
  85         # get_expiration always returns a normalized datetime - no need to utcparse
  86         extime = Credential(string=creds[0]).get_expiration()
  87         # If the expiration time is > 60 days from now, set the expiration time to 60 days from now
  88         if extime > datetime.datetime.utcnow() + datetime.timedelta(days=60):
  89             extime = datetime.datetime.utcnow() + datetime.timedelta(days=60)
  90         slice['expires'] = int(time.mktime(extime.timetuple()))
  91         slice['hrn'] = hrn
  92         slice['name'] = hrn_to_pl_slicename(hrn)
  93         slice['url'] = hrn
  94         slice['description'] = hrn
  95         slice['pointer'] = 0
  96         reg_objects['slice_record'] = slice
  97
  98         reg_objects['users'] = {}
  99         for user in users:
 100             user['key_ids'] = []
 101             hrn, _ = urn_to_hrn(user['urn'])
 102             user['email'] = hrn_to_pl_slicename(hrn) + "@geni.net"
 103             user['first_name'] = hrn
 104             user['last_name'] = hrn
 105             reg_objects['users'][user['email']] = user
 106
 107         return reg_objects
 108
 109 def __get_hostnames(nodes):
 110     hostnames = []
 111     for node in nodes:
 112         hostnames.append(node.hostname)
 113     return hostnames
 114
 115 def SliverStatus(api, slice_xrn, creds, call_id):
 116     if Callids().already_handled(call_id): return {}
 117
 118     (hrn, type) = urn_to_hrn(slice_xrn)
 119     # find out where this slice is currently running
 120     slicename = hrn_to_pl_slicename(hrn)
 121
 122     slices = api.plshell.GetSlices(api.plauth, [slicename], ['slice_id', 'node_ids','person_ids','name','expires'])
 123     if len(slices) == 0:
 124         raise Exception("Slice %s not found (used %s as slicename internally)" % (slice_xrn, slicename))
 125     slice = slices[0]
 126
 127     # report about the local nodes only
 128     nodes = api.plshell.GetNodes(api.plauth, {'node_id':slice['node_ids'],'peer_id':None},
 129                                  ['node_id', 'hostname', 'site_id', 'boot_state', 'last_contact'])
 130     site_ids = [node['site_id'] for node in nodes]
 131     sites = api.plshell.GetSites(api.plauth, site_ids, ['site_id', 'login_base'])
 132     sites_dict = dict ( [ (site['site_id'],site['login_base'] ) for site in sites ] )
 133
 134     result = {}
 135     top_level_status = 'unknown'
 136     if nodes:
 137         top_level_status = 'ready'
 138     slice_urn = Xrn(slice_xrn, 'slice').get_urn()
 139     result['geni_urn'] = slice_urn
 140     result['pl_login'] = slice['name']
 141     result['pl_expires'] = datetime.datetime.fromtimestamp(slice['expires']).ctime()
 142
 143     resources = []
 144     for node in nodes:
 145         res = {}
 146         res['pl_hostname'] = node['hostname']
 147         res['pl_boot_state'] = node['boot_state']
 148         res['pl_last_contact'] = node['last_contact']
 149         if node['last_contact'] is not None:
 150             res['pl_last_contact'] = datetime.datetime.fromtimestamp(node['last_contact']).ctime()
 151         sliver_id = urn_to_sliver_id(slice_urn, slice['slice_id'], node['node_id'])
 152         res['geni_urn'] = sliver_id
 153         if node['boot_state'] == 'boot':
 154             res['geni_status'] = 'ready'
 155         else:
 156             res['geni_status'] = 'failed'
 157             top_level_staus = 'failed'
 158
 159         res['geni_error'] = ''
 160
 161         resources.append(res)
 162
 163     result['geni_status'] = top_level_status
 164     result['geni_resources'] = resources
 165     return result
 166
 167 def CreateSliver(api, slice_xrn, creds, rspec_string, users, call_id):
 168     """
 169     Create the sliver[s] (slice) at this aggregate.
 170     Verify HRN and initialize the slice record in PLC if necessary.
 171     """
 172     if Callids().already_handled(call_id): return ""
 173
 174     aggregate = Aggregate(api)
 175     slices = Slices(api)
 176     (hrn, type) = urn_to_hrn(slice_xrn)
 177     peer = slices.get_peer(hrn)
 178     sfa_peer = slices.get_sfa_peer(hrn)
 179     slice_record=None
 180     if users:
 181         slice_record = users[0].get('slice_record', {})
 182
 183     # parse rspec
 184     rspec = RSpec(rspec_string)
 185     requested_attributes = rspec.version.get_slice_attributes()
 186
 187     # ensure site record exists
 188     site = slices.verify_site(hrn, slice_record, peer, sfa_peer)
 189     # ensure slice record exists
 190     slice = slices.verify_slice(hrn, slice_record, peer, sfa_peer)
 191     # ensure person records exists
 192     persons = slices.verify_persons(hrn, slice, users, peer, sfa_peer)
 193     # ensure slice attributes exists
 194     slices.verify_slice_attributes(slice, requested_attributes)
 195
 196     # add/remove slice from nodes
 197     requested_slivers = [str(host) for host in rspec.version.get_nodes_with_slivers()]
 198     slices.verify_slice_nodes(slice, requested_slivers, peer)
 199
 200     # hanlde MyPLC peer association.
 201     # only used by plc and ple.
 202     slices.handle_peer(site, slice, persons, peer)
 203
 204     return aggregate.get_rspec(slice_xrn=slice_xrn, version=rspec.version)
 205
 206
 207 def RenewSliver(api, xrn, creds, expiration_time, call_id):
 208     if Callids().already_handled(call_id): return True
 209     (hrn, type) = urn_to_hrn(xrn)
 210     slicename = hrn_to_pl_slicename(hrn)
 211     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 212     if not slices:
 213         raise RecordNotFound(hrn)
 214     slice = slices[0]
 215     requested_time = utcparse(expiration_time)
 216     record = {'expires': int(time.mktime(requested_time.timetuple()))}
 217     try:
 218         api.plshell.UpdateSlice(api.plauth, slice['slice_id'], record)
 219         return True
 220     except:
 221         return False
 222
 223 def start_slice(api, xrn, creds):
 224     hrn, type = urn_to_hrn(xrn)
 225     slicename = hrn_to_pl_slicename(hrn)
 226     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 227     if not slices:
 228         raise RecordNotFound(hrn)
 229     slice_id = slices[0]['slice_id']
 230     slice_tags = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'tagname': 'enabled'}, ['slice_tag_id'])
 231     # just remove the tag if it exists
 232     if slice_tags:
 233         api.plshell.DeleteSliceTag(api.plauth, slice_tags[0]['slice_tag_id'])
 234
 235     return 1
 236
 237 def stop_slice(api, xrn, creds):
 238     hrn, type = urn_to_hrn(xrn)
 239     slicename = hrn_to_pl_slicename(hrn)
 240     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 241     if not slices:
 242         raise RecordNotFound(hrn)
 243     slice_id = slices[0]['slice_id']
 244     slice_tags = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'tagname': 'enabled'})
 245     if not slice_tags:
 246         api.plshell.AddSliceTag(api.plauth, slice_id, 'enabled', '0')
 247     elif slice_tags[0]['value'] != "0":
 248         tag_id = attributes[0]['slice_tag_id']
 249         api.plshell.UpdateSliceTag(api.plauth, tag_id, '0')
 250     return 1
 251
 252 def reset_slice(api, xrn):
 253     # XX not implemented at this interface
 254     return 1
 255
 256 def DeleteSliver(api, xrn, creds, call_id):
 257     if Callids().already_handled(call_id): return ""
 258     (hrn, type) = urn_to_hrn(xrn)
 259     slicename = hrn_to_pl_slicename(hrn)
 260     slices = api.plshell.GetSlices(api.plauth, {'name': slicename})
 261     if not slices:
 262         return 1
 263     slice = slices[0]
 264
 265     # determine if this is a peer slice
 266     peer = peers.get_peer(api, hrn)
 267     try:
 268         if peer:
 269             api.plshell.UnBindObjectFromPeer(api.plauth, 'slice', slice['slice_id'], peer)
 270         api.plshell.DeleteSliceFromNodes(api.plauth, slicename, slice['node_ids'])
 271     finally:
 272         if peer:
 273             api.plshell.BindObjectToPeer(api.plauth, 'slice', slice['slice_id'], peer, slice['peer_slice_id'])
 274     return 1
 275
 276 # xxx Thierry : caching at the aggregate level sounds wrong...
 277 #caching=True
 278 caching=False
 279 def ListSlices(api, creds, call_id):
 280     if Callids().already_handled(call_id): return []
 281     # look in cache first
 282     if caching and api.cache:
 283         slices = api.cache.get('slices')
 284         if slices:
 285             return slices
 286
 287     # get data from db
 288     slices = api.plshell.GetSlices(api.plauth, {'peer_id': None}, ['name'])
 289     slice_hrns = [slicename_to_hrn(api.hrn, slice['name']) for slice in slices]
 290     slice_urns = [hrn_to_urn(slice_hrn, 'slice') for slice_hrn in slice_hrns]
 291
 292     # cache the result
 293     if caching and api.cache:
 294         api.cache.add('slices', slice_urns)
 295
 296     return slice_urns
 297
 298 def ListResources(api, creds, options, call_id):
 299     if Callids().already_handled(call_id): return ""
 300     # get slice's hrn from options
 301     xrn = options.get('geni_slice_urn', None)
 302     (hrn, type) = urn_to_hrn(xrn)
 303
 304     version_manager = VersionManager()
 305     # get the rspec's return format from options
 306     rspec_version = version_manager.get_version(options.get('rspec_version'))
 307     version_string = "rspec_%s" % (rspec_version.to_string())
 308
 309     #panos adding the info option to the caching key (can be improved)
 310     if options.get('info'):
 311         version_string = version_string + "_"+options.get('info', 'default')
 312
 313     # look in cache first
 314     if caching and api.cache and not xrn:
 315         rspec = api.cache.get(version_string)
 316         if rspec:
 317             api.logger.info("aggregate.ListResources: returning cached value for hrn %s"%hrn)
 318             return rspec
 319
 320     #panos: passing user-defined options
 321     #print "manager options = ",options
 322     aggregate = Aggregate(api, options)
 323     rspec =  aggregate.get_rspec(slice_xrn=xrn, version=rspec_version)
 324
 325     # cache the result
 326     if caching and api.cache and not xrn:
 327         api.cache.add(version_string, rspec)
 328
 329     return rspec
 330
 331
 332 def get_ticket(api, xrn, creds, rspec, users):
 333
 334     reg_objects = __get_registry_objects(xrn, creds, users)
 335
 336     slice_hrn, type = urn_to_hrn(xrn)
 337     slices = Slices(api)
 338     peer = slices.get_peer(slice_hrn)
 339     sfa_peer = slices.get_sfa_peer(slice_hrn)
 340
 341     # get the slice record
 342     registry = api.registries[api.hrn]
 343     credential = api.getCredential()
 344     records = registry.Resolve(xrn, credential)
 345
 346     # similar to CreateSliver, we must verify that the required records exist
 347     # at this aggregate before we can issue a ticket
 348     site_id, remote_site_id = slices.verify_site(registry, credential, slice_hrn,
 349                                                  peer, sfa_peer, reg_objects)
 350     slice = slices.verify_slice(registry, credential, slice_hrn, site_id,
 351                                 remote_site_id, peer, sfa_peer, reg_objects)
 352
 353     # make sure we get a local slice record
 354     record = None
 355     for tmp_record in records:
 356         if tmp_record['type'] == 'slice' and \
 357            not tmp_record['peer_authority']:
 358             record = SliceRecord(dict=tmp_record)
 359     if not record:
 360         raise RecordNotFound(slice_hrn)
 361
 362     # get sliver info
 363     slivers = Slices(api).get_slivers(slice_hrn)
 364     if not slivers:
 365         raise SliverDoesNotExist(slice_hrn)
 366
 367     # get initscripts
 368     initscripts = []
 369     data = {
 370         'timestamp': int(time.time()),
 371         'initscripts': initscripts,
 372         'slivers': slivers
 373     }
 374
 375     # create the ticket
 376     object_gid = record.get_gid_object()
 377     new_ticket = SfaTicket(subject = object_gid.get_subject())
 378     new_ticket.set_gid_caller(api.auth.client_gid)
 379     new_ticket.set_gid_object(object_gid)
 380     new_ticket.set_issuer(key=api.key, subject=api.hrn)
 381     new_ticket.set_pubkey(object_gid.get_pubkey())
 382     new_ticket.set_attributes(data)
 383     new_ticket.set_rspec(rspec)
 384     #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn))
 385     new_ticket.encode()
 386     new_ticket.sign()
 387
 388     return new_ticket.save_to_string(save_parents=True)
 389
 390
 391
 392 def main():
 393     api = SfaAPI()
 394     """
 395     rspec = ListResources(api, "plc.princeton.sapan", None, 'pl_test_sapan')
 396     #rspec = ListResources(api, "plc.princeton.coblitz", None, 'pl_test_coblitz')
 397     #rspec = ListResources(api, "plc.pl.sirius", None, 'pl_test_sirius')
 398     print rspec
 399     """
 400     f = open(sys.argv[1])
 401     xml = f.read()
 402     f.close()
 403     CreateSliver(api, "plc.princeton.sapan", xml, 'CreateSliver_sapan')
 404
 405 if __name__ == "__main__":
 406     main()