removed another bunch of references to geni

[sfa.git] / sfa / managers / slice_manager_pl.py

diff --git a/sfa/managers/slice_manager_pl.py b/sfa/managers/slice_manager_pl.py
index 90042f3..dd80ddd 100644 (file)
--- a/sfa/managers/slice_manager_pl.py
+++ b/sfa/managers/slice_manager_pl.py
@@ -7,46 +7,35 @@ import traceback
 import sys
 
 from types import StringTypes
 import sys
 
 from types import StringTypes

-from sfa.util.misc import *
+from sfa.util.namespace import *

 from sfa.util.rspec import *
 from sfa.util.specdict import *
 from sfa.util.faults 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.record import SfaRecord

 from sfa.util.policy import Policy
 from sfa.util.prefixTree import prefixTree
 from sfa.util.rspec import *
 from sfa.util.policy import Policy
 from sfa.util.prefixTree import prefixTree
 from sfa.util.rspec import *

+from sfa.util.sfaticket import *

 from sfa.util.debug import log
 from sfa.server.registry import Registries
 from sfa.server.aggregate import Aggregates
 import sfa.plc.peers as peers
 
 from sfa.util.debug import log
 from sfa.server.registry import Registries
 from sfa.server.aggregate import Aggregates
 import sfa.plc.peers as peers
 

-def delete_slice(api, hrn, caller_cred=None):
+def delete_slice(api, hrn, origin_hrn=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:
     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)
+            aggregates[aggregate].delete_slice(credential, hrn, origin_hrn)

             success = True
         except:
             print >> log, "%s" % (traceback.format_exc())
             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 = 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
+            print >> log, "Error calling delete slice at aggregate %s" % aggregate

     return 1
 
     return 1
 

-def create_slice(api, hrn, rspec, caller_cred=None):
+def create_slice(api, hrn, rspec, origin_hrn=None):

     spec = RSpec()
     tempspec = RSpec()
     spec.parseString(rspec)
     spec = RSpec()
     tempspec = RSpec()
     spec.parseString(rspec)


@@ -61,7 +50,6 @@ def create_slice(api, hrn, rspec, caller_cred=None):
     rspecs = {}
     aggregates = Aggregates(api)
     credential = api.getCredential()
     rspecs = {}
     aggregates = Aggregates(api)
     credential = api.getCredential()

-

     # split the netspecs into individual rspecs
     netspecs = spec.getDictsByTagName('NetSpec')
     for netspec in netspecs:
     # split the netspecs into individual rspecs
     netspecs = spec.getDictsByTagName('NetSpec')
     for netspec in netspecs:


@@ -71,6 +59,8 @@ def create_slice(api, hrn, rspec, caller_cred=None):
         tempspec.parseDict(resourceDict)
         rspecs[net_hrn] = tempspec.toxml()
 
         tempspec.parseDict(resourceDict)
         rspecs[net_hrn] = tempspec.toxml()
 

+    #print "rspecs:", rspecs.keys()
+    #print "aggregates:", aggregates.keys() 

     # send each rspec to the appropriate aggregate/sm
     for net_hrn in rspecs:
         try:
     # send each rspec to the appropriate aggregate/sm
     for net_hrn in rspecs:
         try:


@@ -80,52 +70,97 @@ def create_slice(api, hrn, rspec, caller_cred=None):
             if net_hrn in aggregates:
                 # send the whloe rspec to the local aggregate
                 if net_hrn in [api.hrn]:
             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)
+                    aggregates[net_hrn].create_slice(credential, hrn, rspec, \
+                                origin_hrn)

                 else:
                 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)
+                    aggregates[net_hrn].create_slice(credential, hrn, \
+                                rspecs[net_hrn], origin_hrn)

             else:
                 # lets forward this rspec to a sm that knows about the network
             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:
                 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)
+                    network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
+                    if network_found:
+                        aggregates[aggregate].create_slice(credential, hrn, \
+                                    rspecs[net_hrn], origin_hrn)

 
         except:
             print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % \
                            locals()
             traceback.print_exc()
 
         except:
             print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % \
                            locals()
             traceback.print_exc()

-        return 1
+    return 1
+
+def get_ticket(api, slice_hrn, rspec, origin_hrn=None):
+    
+    # get the netspecs contained within the clients rspec
+    client_rspec = RSpec(xml=rspec)
+    netspecs = client_rspec.getDictsByTagName('NetSpec')
+    
+    # create an rspec for each individual rspec 
+    rspecs = {}
+    temp_rspec = RSpec()
+    for netspec in netspecs:
+        net_hrn = netspec['name']
+        resources = {'start_time': 0, 'end_time': 0 , 
+                     'network': netspec}
+        resourceDict = {'RSpec': resources}
+        temp_rspec.parseDict(resourceDict)
+        rspecs[net_hrn] = temp_rspec.toxml() 
+    
+    # send the rspec to the appropiate aggregate/sm
+    aggregates = Aggregates(api)
+    credential = api.getCredential()
+    tickets = {}
+    for net_hrn in rspecs:    
+        try:
+            # if we are directly connected to the aggregate then we can just
+            # send them the request. if not, then we may be connected to an sm
+            # thats connected to the aggregate
+            if net_hrn in aggregates:
+                ticket = aggregates[net_hrn].get_ticket(credential, slice_hrn, \
+                            rspecs[net_hrn], origin_hrn)
+                tickets[net_hrn] = ticket
+            else:
+                # lets forward this rspec to a sm that knows about the network
+                for agg in aggregates:
+                    network_found = aggregates[agg].get_aggregates(credential, net_hrn)
+                    if network_found:
+                        ticket = aggregates[aggregate].get_ticket(credential, \
+                                        slice_hrn, rspecs[net_hrn], origin_hrn)
+                        tickets[aggregate] = ticket
+        except:
+            print >> log, "Error getting ticket for %(slice_hrn)s at aggregate %(net_hrn)s" % \
+                           locals()
+            
+    # create a new ticket
+    new_ticket = SfaTicket(subject = slice_hrn)
+    new_ticket.set_gid_caller(api.auth.client_gid)
+   
+    tmp_rspec = RSpec()
+    networks = []
+    valid_data = {} 
+    # merge data from aggregate ticket into new ticket 
+    for agg_ticket in tickets.values():
+        agg_ticket = SfaTicket(string=agg_ticket)
+        object_gid = agg_ticket.get_gid_object()
+        new_ticket.set_gid_object(object_gid)
+        new_ticket.set_issuer(key=api.key, subject=api.hrn)
+        new_ticket.set_pubkey(object_gid.get_pubkey())
+        
+        #new_ticket.set_attributes(data)
+        tmp_rspec.parseString(agg_ticket.get_rspec())
+        networks.extend([{'NetSpec': tmp_rspec.getDictsByTagName('NetSpec')}])
+    
+    #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn))
+    resources = {'networks': networks, 'start_time': 0, 'duration': 0}
+    resourceDict = {'RSpec': resources}
+    tmp_rspec.parseDict(resourceDict)
+    new_ticket.set_rspec(tmp_rspec.toxml())
+        
+    new_ticket.encode()
+    new_ticket.sign()          
+    return new_ticket.save_to_string(save_parents=True)

 
 

-def start_slice(api, hrn, caller_cred=None):
+def start_slice(api, hrn):

     slicename = hrn_to_pl_slicename(hrn)
     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
     if not slices:
     slicename = hrn_to_pl_slicename(hrn)
     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
     if not slices:


@@ -137,7 +172,7 @@ def start_slice(api, hrn, caller_cred=None):
 
     return 1
  
 
     return 1
  

-def stop_slice(api, hrn, caller_cred):
+def stop_slice(api, hrn):

     slicename = hrn_to_pl_slicename(hrn)
     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
     if not slices:
     slicename = hrn_to_pl_slicename(hrn)
     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
     if not slices:


@@ -148,7 +183,7 @@ def stop_slice(api, hrn, caller_cred):
     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0")
     return 1
 
     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0")
     return 1
 

-def reset_slice(api, hrn, caller_cred):
+def reset_slice(api, hrn):

     # XX not implemented at this interface
     return 1
 
     # XX not implemented at this interface
     return 1
 


@@ -160,4 +195,32 @@ def get_slices(api):
     slices.refresh()
     return slices['hrn']
      
     slices.refresh()
     return slices['hrn']
      

+def get_rspec(api, hrn=None, origin_hrn=None):
+    from sfa.plc.nodes import Nodes
+    nodes = Nodes(api, origin_hrn=origin_hrn)
+    if hrn:
+        rspec = nodes.get_rspec(hrn)
+    else:
+        nodes.refresh()
+        rspec = nodes['rspec']
+
+    return rspec
+
+"""
+Returns the request context required by sfatables. At some point, this mechanism should be changed
+to refer to "contexts", which is the information that sfatables is requesting. But for now, we just
+return the basic information needed in a dict.
+"""
+def fetch_context(slice_hrn, user_hrn, contexts):
+    base_context = {'sfa':{'user':{'hrn':user_hrn}}}
+    return base_context
+
+def main():
+    r = RSpec()
+    r.parseFile(sys.argv[1])
+    rspec = r.toDict()
+    create_slice(None,'plc.princeton.tmacktestslice',rspec)
+
+if __name__ == "__main__":
+    main()