initial checkin of slice manager for pl

diff --git a/sfa/managers/slice_manager_pl.py b/sfa/managers/slice_manager_pl.py
new file mode 100644 (file)
index 0000000..e9ae758
--- /dev/null
+++ b/sfa/managers/slice_manager_pl.py
@@ -0,0 +1,163 @@
+### $Id: slices.py 15842 2009-11-22 09:56:13Z anil $
+### $URL: https://svn.planet-lab.org/svn/sfa/trunk/sfa/plc/slices.py $
+
+import datetime
+import time
+import traceback
+import sys
+
+from types import StringTypes
+from sfa.util.misc import *
+from sfa.util.rspec import *
+from sfa.util.specdict import *
+from sfa.util.faults import *
+from sfa.util.record import GeniRecord
+from sfa.util.policy import Policy
+from sfa.util.prefixTree import prefixTree
+from sfa.util.rspec import *
+from sfa.util.debug import log
+from sfa.server.registry import Registries
+from sfa.util import peers
+
+def delete_slice(api, hrn, caller_cred=None):
+    credential = api.getCredential()
+    aggregates = Aggregates(api)
+    for aggregate in aggregates:
+        success = False
+        # request hash is optional so lets try the call without it
+        try:
+            request_hash=None
+            aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred)
+            success = True
+        except:
+            print >> log, "%s" % (traceback.format_exc())
+            print >> log, "Error calling list nodes at aggregate %s" % aggregate
+
+        # try sending the request hash if the previous call failed
+        if not success:
+            try:
+                arg_list = [credential, hrn]
+                request_hash = self.api.key.compute_hash(arg_list)
+                aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred)
+                success = True
+            except:
+                print >> log, "%s" % (traceback.format_exc())
+                print >> log, "Error calling list nodes at aggregate %s" % aggregate
+    return 1
+
+def create_slice(api, hrn, rspec, caller_cred=None):
+    spec = RSpec()
+    tempspec = RSpec()
+    spec.parseString(rspec)
+    slicename = hrn_to_pl_slicename(hrn)
+    specDict = spec.toDict()
+    if specDict.has_key('RSpec'): specDict = specDict['RSpec']
+    if specDict.has_key('start_time'): start_time = specDict['start_time']
+    else: start_time = 0
+    if specDict.has_key('end_time'): end_time = specDict['end_time']
+    else: end_time = 0
+
+    rspecs = {}
+    aggregates = Aggregates(api)
+    credential = api.getCredential()
+
+    # split the netspecs into individual rspecs
+    netspecs = spec.getDictsByTagName('NetSpec')
+    for netspec in netspecs:
+        net_hrn = netspec['name']
+        resources = {'start_time': start_time, 'end_time': end_time, 'networks': netspec}
+        resourceDict = {'RSpec': resources}
+        tempspec.parseDict(resourceDict)
+        rspecs[net_hrn] = tempspec.toxml()
+
+    # send each rspec to the appropriate aggregate/sm
+    caller_cred = self.caller_cred
+    for net_hrn in rspecs:
+        try:
+            # if we are directly connected to the aggregate then we can just 
+            # send them the rspec. if not, then we may be connected to an sm 
+            # thats connected to the aggregate
+            if net_hrn in aggregates:
+                # send the whloe rspec to the local aggregate
+                if net_hrn in [api.hrn]:
+                    try:
+                        request_hash = None
+                        aggregates[net_hrn].create_slice(credential, hrn, \
+                                        rspec, request_hash, caller_cred)
+                    except:
+                        arg_list = [credential,hrn,rspec]
+                        request_hash = api.key.compute_hash(arg_list)
+                        aggregates[net_hrn].create_slice(credential, hrn, \
+                                        rspec, request_hash, caller_cred)
+                else:
+                    try:
+                        request_hash = None
+                        aggregates[net_hrn].create_slice(credential, hrn, \
+                                rspecs[net_hrn], request_hash, caller_cred)
+                    except:
+                        arg_list = [credential,hrn,rspecs[net_hrn]]
+                        request_hash = api.key.compute_hash(arg_list)
+                        aggregates[net_hrn].create_slice(credential, hrn, \
+                                rspecs[net_hrn], request_hash, caller_cred)
+            else:
+                # lets forward this rspec to a sm that knows about the network
+                arg_list = [credential, net_hrn]
+                request_hash = api.compute_hash(arg_list)
+                for aggregate in aggregates:
+                    try:
+                        network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
+                    except:
+                        network_found = aggregates[aggregate].get_aggregates(credential, net_hrn, request_hash)
+                    if network_networks:
+                        try:
+                            request_hash = None
+                            aggregates[aggregate].create_slice(credential, hrn, \
+                                    rspecs[net_hrn], request_hash, caller_cred)
+                        except:
+                            arg_list = [credential, hrn, rspecs[net_hrn]]
+                            request_hash = api.key.compute_hash(arg_list)
+                            aggregates[aggregate].create_slice(credential, hrn, \
+                                    rspecs[net_hrn], request_hash, caller_cred)
+
+        except:
+            print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % \
+                           locals()
+            traceback.print_exc()
+        return 1
+
+def start_slice(api, hrn):
+    slicename = hrn_to_pl_slicename(hrn)
+    slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
+    if not slices:
+        raise RecordNotFound(hrn)
+    slice_id = slices[0]
+    attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
+    attribute_id = attreibutes[0]['slice_attribute_id']
+    api.plshell.UpdateSliceTag(api.plauth, attribute_id, "1" )
+
+    return 1
+ 
+def stop_slice(api, hrn):
+    slicename = hrn_to_pl_slicename(hrn)
+    slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
+    if not slices:
+        raise RecordNotFound(hrn)
+    slice_id = slices[0]['slice_id']
+    attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
+    attribute_id = attributes[0]['slice_attribute_id']
+    api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0")
+    return 1
+
+def reset_slice(api, hrn):
+    # XX not implemented at this interface
+    return 1
+
+def get_slices(api):
+    # XX just import the legacy module and excute that until
+    # we transition the code to this module
+    from sfa.plc.slices import Slices
+    slices = Slices(api)
+    slices.refresh()
+    return slices['hrn']
+     
+