sfa/managers/slice_manager_pl.py

   1 ### $Id: slices.py 15842 2009-11-22 09:56:13Z anil $
   2 ### $URL: https://svn.planet-lab.org/svn/sfa/trunk/sfa/plc/slices.py $
   3
   4 import datetime
   5 import time
   6 import traceback
   7 import sys
   8
   9 from types import StringTypes
  10 from sfa.util.misc 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 GeniRecord
  15 from sfa.util.policy import Policy
  16 from sfa.util.prefixTree import prefixTree
  17 from sfa.util.rspec import *
  18 from sfa.util.debug import log
  19 from sfa.server.registry import Registries
  20 from sfa.server.aggregate import Aggregates
  21 import sfa.plc.peers as peers
  22
  23 def delete_slice(api, hrn, caller_cred=None):
  24     credential = api.getCredential()
  25     aggregates = Aggregates(api)
  26     for aggregate in aggregates:
  27         success = False
  28         # request hash is optional so lets try the call without it
  29         try:
  30             request_hash=None
  31             aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred)
  32             success = True
  33         except:
  34             print >> log, "%s" % (traceback.format_exc())
  35             print >> log, "Error calling delete slice at aggregate %s" % aggregate
  36
  37         # try sending the request hash if the previous call failed
  38         if not success:
  39             try:
  40                 arg_list = [credential, hrn]
  41                 request_hash = api.key.compute_hash(arg_list)
  42                 aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred)
  43                 success = True
  44             except:
  45                 print >> log, "%s" % (traceback.format_exc())
  46                 print >> log, "Error calling list nodes at aggregate %s" % aggregate
  47     return 1
  48
  49 def create_slice(api, hrn, rspec, caller_cred=None):
  50     spec = RSpec()
  51     tempspec = RSpec()
  52     spec.parseString(rspec)
  53     slicename = hrn_to_pl_slicename(hrn)
  54     specDict = spec.toDict()
  55     if specDict.has_key('RSpec'): specDict = specDict['RSpec']
  56     if specDict.has_key('start_time'): start_time = specDict['start_time']
  57     else: start_time = 0
  58     if specDict.has_key('end_time'): end_time = specDict['end_time']
  59     else: end_time = 0
  60
  61     rspecs = {}
  62     aggregates = Aggregates(api)
  63     credential = api.getCredential()
  64
  65     # split the netspecs into individual rspecs
  66     netspecs = spec.getDictsByTagName('NetSpec')
  67     for netspec in netspecs:
  68         net_hrn = netspec['name']
  69         resources = {'start_time': start_time, 'end_time': end_time, 'networks': netspec}
  70         resourceDict = {'RSpec': resources}
  71         tempspec.parseDict(resourceDict)
  72         rspecs[net_hrn] = tempspec.toxml()
  73
  74     print "rspecs:", rspecs.keys()
  75     print "aggregates:", aggregates.keys()
  76     # send each rspec to the appropriate aggregate/sm
  77     for net_hrn in rspecs:
  78         try:
  79             # if we are directly connected to the aggregate then we can just
  80             # send them the rspec. if not, then we may be connected to an sm
  81             # thats connected to the aggregate
  82             if net_hrn in aggregates:
  83                 # send the whloe rspec to the local aggregate
  84                 if net_hrn in [api.hrn]:
  85                     try:
  86                         request_hash = None
  87                         aggregates[net_hrn].create_slice(credential, hrn, \
  88                                         rspec, request_hash, caller_cred)
  89                     except:
  90                         arg_list = [credential,hrn,rspec]
  91                         request_hash = api.key.compute_hash(arg_list)
  92                         aggregates[net_hrn].create_slice(credential, hrn, \
  93                                         rspec, request_hash, caller_cred)
  94                 else:
  95                     try:
  96                         request_hash = None
  97                         aggregates[net_hrn].create_slice(credential, hrn, \
  98                                 rspecs[net_hrn], request_hash, caller_cred)
  99                     except:
 100                         arg_list = [credential,hrn,rspecs[net_hrn]]
 101                         request_hash = api.key.compute_hash(arg_list)
 102                         aggregates[net_hrn].create_slice(credential, hrn, \
 103                                 rspecs[net_hrn], request_hash, caller_cred)
 104             else:
 105                 # lets forward this rspec to a sm that knows about the network
 106                 arg_list = [credential, net_hrn]
 107                 request_hash = api.key.compute_hash(arg_list)
 108                 for aggregate in aggregates:
 109                     try:
 110                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
 111                     except:
 112                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn, request_hash)
 113                     if network_networks:
 114                         try:
 115                             request_hash = None
 116                             aggregates[aggregate].create_slice(credential, hrn, \
 117                                     rspecs[net_hrn], request_hash, caller_cred)
 118                         except:
 119                             arg_list = [credential, hrn, rspecs[net_hrn]]
 120                             request_hash = api.key.compute_hash(arg_list)
 121                             aggregates[aggregate].create_slice(credential, hrn, \
 122                                     rspecs[net_hrn], request_hash, caller_cred)
 123
 124         except:
 125             print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % \
 126                            locals()
 127             traceback.print_exc()
 128     return 1
 129
 130 def start_slice(api, hrn, caller_cred=None):
 131     slicename = hrn_to_pl_slicename(hrn)
 132     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 133     if not slices:
 134         raise RecordNotFound(hrn)
 135     slice_id = slices[0]
 136     attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
 137     attribute_id = attreibutes[0]['slice_attribute_id']
 138     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "1" )
 139
 140     return 1
 141
 142 def stop_slice(api, hrn, caller_cred):
 143     slicename = hrn_to_pl_slicename(hrn)
 144     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 145     if not slices:
 146         raise RecordNotFound(hrn)
 147     slice_id = slices[0]['slice_id']
 148     attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
 149     attribute_id = attributes[0]['slice_attribute_id']
 150     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0")
 151     return 1
 152
 153 def reset_slice(api, hrn, caller_cred):
 154     # XX not implemented at this interface
 155     return 1
 156
 157 def get_slices(api):
 158     # XX just import the legacy module and excute that until
 159     # we transition the code to this module
 160     from sfa.plc.slices import Slices
 161     slices = Slices(api)
 162     slices.refresh()
 163     return slices['hrn']
 164
 165