here we are dealing with slice hrn

[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 b921b8a..e29ab25 100644 (file)
--- a/sfa/managers/slice_manager_pl.py
+++ b/sfa/managers/slice_manager_pl.py
@@ -15,12 +15,13 @@ 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.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:
     credential = api.getCredential()
     aggregates = Aggregates(api)
     for aggregate in aggregates:


@@ -28,7 +29,7 @@ def delete_slice(api, hrn, caller_cred=None):
         # request hash is optional so lets try the call without it
         try:
             request_hash=None
         # 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, request_hash, origin_hrn)

             success = True
         except:
             print >> log, "%s" % (traceback.format_exc())
             success = True
         except:
             print >> log, "%s" % (traceback.format_exc())


@@ -39,14 +40,14 @@ def delete_slice(api, hrn, caller_cred=None):
             try:
                 arg_list = [credential, hrn]
                 request_hash = api.key.compute_hash(arg_list)
             try:
                 arg_list = [credential, hrn]
                 request_hash = api.key.compute_hash(arg_list)

-                aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred)
+                aggregates[aggregate].delete_slice(credential, hrn, request_hash, origin_hrn)

                 success = True
             except:
                 print >> log, "%s" % (traceback.format_exc())
                 print >> log, "Error calling list nodes at aggregate %s" % aggregate
     return 1
 
                 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):
+def create_slice(api, hrn, rspec, origin_hrn=None):

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


@@ -71,8 +72,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() 
+    #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:


@@ -85,22 +86,22 @@ def create_slice(api, hrn, rspec, caller_cred=None):
                     try:
                         request_hash = None
                         aggregates[net_hrn].create_slice(credential, hrn, \
                     try:
                         request_hash = None
                         aggregates[net_hrn].create_slice(credential, hrn, \

-                                        rspec, request_hash, caller_cred)
+                                        rspec, request_hash, origin_hrn)

                     except:
                         arg_list = [credential,hrn,rspec]
                         request_hash = api.key.compute_hash(arg_list)
                         aggregates[net_hrn].create_slice(credential, hrn, \
                     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)
+                                        rspec, request_hash, origin_hrn)

                 else:
                     try:
                         request_hash = None
                         aggregates[net_hrn].create_slice(credential, hrn, \
                 else:
                     try:
                         request_hash = None
                         aggregates[net_hrn].create_slice(credential, hrn, \

-                                rspecs[net_hrn], request_hash, caller_cred)
+                                rspecs[net_hrn], request_hash, origin_hrn)

                     except:
                         arg_list = [credential,hrn,rspecs[net_hrn]]
                         request_hash = api.key.compute_hash(arg_list)
                         aggregates[net_hrn].create_slice(credential, hrn, \
                     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)
+                                rspecs[net_hrn], request_hash, origin_hrn)

             else:
                 # lets forward this rspec to a sm that knows about the network
                 arg_list = [credential, net_hrn]
             else:
                 # lets forward this rspec to a sm that knows about the network
                 arg_list = [credential, net_hrn]


@@ -110,16 +111,16 @@ def create_slice(api, hrn, rspec, caller_cred=None):
                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
                     except:
                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn, request_hash)
                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
                     except:
                         network_found = aggregates[aggregate].get_aggregates(credential, net_hrn, request_hash)

-                    if network_networks:
+                    if network_found:

                         try:
                             request_hash = None
                             aggregates[aggregate].create_slice(credential, hrn, \
                         try:
                             request_hash = None
                             aggregates[aggregate].create_slice(credential, hrn, \

-                                    rspecs[net_hrn], request_hash, caller_cred)
+                                    rspecs[net_hrn], request_hash, origin_hrn)

                         except:
                             arg_list = [credential, hrn, rspecs[net_hrn]]
                             request_hash = api.key.compute_hash(arg_list)
                             aggregates[aggregate].create_slice(credential, hrn, \
                         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)
+                                    rspecs[net_hrn], request_hash, origin_hrn)

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


@@ -127,7 +128,99 @@ def create_slice(api, hrn, rspec, caller_cred=None):
             traceback.print_exc()
     return 1
 
             traceback.print_exc()
     return 1
 

-def start_slice(api, hrn, caller_cred=None):
+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:
+                try:
+                    ticket = aggregates[net_hrn].get_ticket(credential, slice_hrn, \
+                                rspecs[net_hrn], None, origin_hrn)
+                    tickets[net_hrn] = ticket
+                except:
+                    arg_list = [credential,hrn,rspecs[net_hrn]]
+                    request_hash = api.key.compute_hash(arg_list)
+                    ticket = aggregates[net_hrn].get_ticket(credential, slice_hrn, \
+                                rspecs[net_hrn], request_hash, origin_hrn)
+                    tickets[net_hrn] = ticket 
+            else:
+                # lets forward this rspec to a sm that knows about the network
+                arg_list = [credential, net_hrn]
+                request_hash = api.key.compute_hash(arg_list)
+                for agg in aggregates:
+                    try:
+                        network_found = aggregates[agg].get_aggregates(credential, \
+                                                        net_hrn)
+                    except:
+                        network_found = aggregates[agg].get_aggregates(credential, \
+                                                        net_hrn, request_hash)
+                    if network_found:
+                        try:
+                            ticket = aggregates[aggregate].get_ticket(credential, \
+                                        slice_hrn, rspecs[net_hrn], None, origin_hrn)
+                            tickets[aggregate] = ticket
+                        except:
+                            arg_list = [credential, hrn, rspecs[net_hrn]]
+                            request_hash = api.key.compute_hash(arg_list)
+                            aggregates[aggregate].get_ticket(credential, slice_hrn, \
+                                    rspecs[net_hrn], request_hash, 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()
+    tmp_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)
+        newtworks.extend([{'NetSpec': 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()          
+
+def start_slice(api, hrn, origin_hrn=None):

     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:


@@ -139,7 +232,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, origin_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:


@@ -150,7 +243,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, origin_hrn):

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


@@ -162,9 +255,9 @@ def get_slices(api):
     slices.refresh()
     return slices['hrn']
      
     slices.refresh()
     return slices['hrn']
      

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

     from sfa.plc.nodes import Nodes
     from sfa.plc.nodes import Nodes

-    nodes = Nodes(api, caller_cred=caller_cred)
+    nodes = Nodes(api, origin_hrn=origin_hrn)

     if hrn:
         rspec = nodes.get_rspec(hrn)
     else:
     if hrn:
         rspec = nodes.get_rspec(hrn)
     else: