passing the hrn of the initial caller instead of its credentail

diff --git a/sfa/managers/aggregate_manager_pl.py b/sfa/managers/aggregate_manager_pl.py
index 2bdfc21..e51e64f 100644 (file)
--- a/sfa/managers/aggregate_manager_pl.py
+++ b/sfa/managers/aggregate_manager_pl.py
@@ -124,9 +124,9 @@ def get_slices(api):
     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
-    nodes = Nodes(api, caller_cred=caller_cred)
+    nodes = Nodes(api, origin_hrn=origin_hrn)
     if hrn:
         rspec = nodes.get_rspec(hrn)
     else:

diff --git a/sfa/managers/slice_manager_pl.py b/sfa/managers/slice_manager_pl.py
index b921b8a..d76f78b 100644 (file)
--- a/sfa/managers/slice_manager_pl.py
+++ b/sfa/managers/slice_manager_pl.py
@@ -20,7 +20,7 @@ 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:
@@ -28,7 +28,7 @@ def delete_slice(api, hrn, caller_cred=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())
@@ -39,14 +39,14 @@ def delete_slice(api, hrn, caller_cred=None):
             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
 
-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)
@@ -85,22 +85,22 @@ def create_slice(api, hrn, rspec, caller_cred=None):
                     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, \
-                                        rspec, request_hash, caller_cred)
+                                        rspec, request_hash, origin_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, \
-                                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]
@@ -114,12 +114,12 @@ def create_slice(api, hrn, rspec, caller_cred=None):
                         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, \
-                                    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" % \
@@ -127,7 +127,7 @@ def create_slice(api, hrn, rspec, caller_cred=None):
             traceback.print_exc()
     return 1
 
-def start_slice(api, hrn, caller_cred=None):
+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:
@@ -139,7 +139,7 @@ def start_slice(api, hrn, caller_cred=None):
 
     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:
@@ -150,7 +150,7 @@ def stop_slice(api, hrn, caller_cred):
     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
 
@@ -162,9 +162,9 @@ def get_slices(api):
     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
-    nodes = Nodes(api, caller_cred=caller_cred)
+    nodes = Nodes(api, origin_hrn=origin_hrn)
     if hrn:
         rspec = nodes.get_rspec(hrn)
     else:

diff --git a/sfa/methods/create_slice.py b/sfa/methods/create_slice.py
index d192a35..67bab8a 100644 (file)
--- a/sfa/methods/create_slice.py
+++ b/sfa/methods/create_slice.py
@@ -36,9 +36,9 @@ class create_slice(Method):
 
     returns = Parameter(int, "1 if successful")
     
-    def call(self, cred, hrn, requested_rspec, request_hash=None, caller_cred=None):
-        if caller_cred==None:
-            caller_cred=cred
+    def call(self, cred, hrn, requested_rspec, request_hash=None, origin_hrn=None):
+        if origin_hrn==None:
+            origin_hrn=Credential(string=cred).get_gid_caller().get_hrn()
         
         # This cred will be an slice cred, not a user, so we cant use it to
         # authenticate the caller's request_hash. Let just get the caller's gid
@@ -49,7 +49,7 @@ class create_slice(Method):
         self.api.auth.check(cred, 'createslice')
 
         #log the call
-        self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, Credential(string=caller_cred).get_gid_caller().get_hrn(), hrn, self.name))
+        self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
 
         sfa_aggregate_type = Config().get_aggregate_rspec_type()
         rspec_manager = __import__("sfa.rspecs.aggregates.rspec_manager_"+sfa_aggregate_type, fromlist = ["sfa.rspecs.aggregates"])
@@ -62,7 +62,7 @@ class create_slice(Method):
            #incoming_rules.set_slice(hrn) # This is a temporary kludge. Eventually, we'd like to fetch the context requested by the match/target
 
            contexts = incoming_rules.contexts
-           request_context = rspec_manager.fetch_context(hrn, Credential(string=caller_cred).get_gid_caller().get_hrn(), contexts)
+           request_context = rspec_manager.fetch_context(hrn, origin_hrn, contexts)
            incoming_rules.set_context(request_context)
            rspec = incoming_rules.apply(requested_rspec)
        else:   
@@ -84,6 +84,6 @@ class create_slice(Method):
             mgr_type = self.api.config.SFA_SM_TYPE
             manager_module = manager_base + ".slice_manager_%s" % mgr_type
             manager = __import__(manager_module, fromlist=[manager_base])
-            manager.create_slice(self.api, hrn, rspec, caller_cred)
+            manager.create_slice(self.api, hrn, rspec, origin_hrn)
 
         return 1 

diff --git a/sfa/methods/get_resources.py b/sfa/methods/get_resources.py
index 1aa104d..399f0e8 100644 (file)
--- a/sfa/methods/get_resources.py
+++ b/sfa/methods/get_resources.py
@@ -35,7 +35,7 @@ class get_resources(Method):
 
     returns = Parameter(str, "String representatin of an rspec")
     
-    def call(self, cred, hrn=None, request_hash = None, caller_cred=None):
+    def call(self, cred, hrn=None, request_hash = None, origin_hrn=None):
         sfa_aggregate_type = Config().get_aggregate_rspec_type()
 
         # This cred will be an authority cred, not a user, so we cant use it to 
@@ -45,11 +45,11 @@ class get_resources(Method):
         client_gid_str = client_gid.save_to_string(save_parents=True)
         self.api.auth.authenticateGid(client_gid_str, [cred,hrn], request_hash)
         self.api.auth.check(cred, 'listnodes')
-        if caller_cred==None:
-            caller_cred=cred
+        if origin_hrn==None:
+            origin_hrn=Credential(string=cred).get_gid_caller().get_hrn()
 
         #log the call
-        self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, Credential(string=caller_cred).get_gid_caller().get_hrn(), hrn, self.name))
+        self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
 
 
 
@@ -59,21 +59,18 @@ class get_resources(Method):
             mgr_type = self.api.config.SFA_AGGREGATE_TYPE
             manager_module = manager_base + ".aggregate_manager_%s" % mgr_type
             manager = __import__(manager_module, fromlist=[manager_base])
-            rspec = manager.get_rspec(self.api, hrn, caller_cred)
+            rspec = manager.get_rspec(self.api, hrn, origin_hrn)
             outgoing_rules = SFATablesRules('OUTGOING')
         elif self.api.interface in ['slicemgr']:
             mgr_type = self.api.config.SFA_SM_TYPE
             manager_module = manager_base + ".slice_manager_%s" % mgr_type
             manager = __import__(manager_module, fromlist=[manager_base])
-            rspec = manager.get_rspec(self.api, hrn, caller_cred)
+            rspec = manager.get_rspec(self.api, hrn, origin_hrn)
             outgoing_rules = SFATablesRules('FORWARD-OUTGOING')
 
         filtered_rspec = rspec
         if outgoing_rules.sorted_rule_list:
-           request_context = manager.fetch_context(
-               hrn,
-               Credential(string=caller_cred).get_gid_caller().get_hrn(),
-               outgoing_rules.contexts)
+           request_context = manager.fetch_context(hrn, origin_hrn, outgoing_rules.contexts)
            outgoing_rules.set_context(request_context)
            filtered_rspec = outgoing_rules.apply(rspec)
 

diff --git a/sfa/plc/nodes.py b/sfa/plc/nodes.py
index e36e16f..9710040 100644 (file)
--- a/sfa/plc/nodes.py
+++ b/sfa/plc/nodes.py
@@ -20,7 +20,7 @@ from sfa.server.aggregate import Aggregates
 
 class Nodes(SimpleStorage):
 
-    def __init__(self, api, ttl = 1, caller_cred=None):
+    def __init__(self, api, ttl = 1, origin_hrn=None):
         self.api = api
         self.ttl = ttl
         self.threshold = None
@@ -31,7 +31,7 @@ class Nodes(SimpleStorage):
         SimpleStorage.__init__(self, self.nodes_file)
         self.policy = Policy(api)
         self.load()
-        self.caller_cred=caller_cred
+        self.origin_hrn=origin_hrn
 
 
     def refresh(self):
@@ -114,15 +114,15 @@ class Nodes(SimpleStorage):
         for aggregate in aggregates:
           if aggregate not in [self.api.auth.client_cred.get_gid_caller().get_hrn()]:
             try:
-                caller_cred = self.caller_cred
+                origin_hrn = self.origin_hrn
                 # get the rspec from the aggregate
                 try:
                    request_hash=None
-                    agg_rspec = aggregates[aggregate].get_resources(credential, hrn, request_hash, caller_cred)
+                    agg_rspec = aggregates[aggregate].get_resources(credential, hrn, request_hash, origin_hrn)
                 except:
                     arg_list = [credential, hrn]
                     request_hash = self.api.key.compute_hash(arg_list)
-                    agg_rspec = aggregates[aggregate].get_resources(credential, hrn, request_hash, caller_cred)
+                    agg_rspec = aggregates[aggregate].get_resources(credential, hrn, request_hash, origin_hrn)
                 # extract the netspec from each aggregates rspec
                 rspec.parseString(agg_rspec)
                 networks.extend([{'NetSpec': rspec.getDictsByTagName('NetSpec')}])

diff --git a/sfa/plc/slices.py b/sfa/plc/slices.py
index 70ace8a..c001c3c 100644 (file)
--- a/sfa/plc/slices.py
+++ b/sfa/plc/slices.py
@@ -25,7 +25,7 @@ class Slices(SimpleStorage):
 
     rspec_to_slice_tag = {'max_rate':'net_max_rate'}
 
-    def __init__(self, api, ttl = .5, caller_cred=None):
+    def __init__(self, api, ttl = .5, origin_hrn=None):
         self.api = api
         self.ttl = ttl
         self.threshold = None
@@ -36,7 +36,7 @@ class Slices(SimpleStorage):
         SimpleStorage.__init__(self, self.slices_file)
         self.policy = Policy(self.api)    
         self.load()
-        self.caller_cred=caller_cred
+        self.origin_hrn=origin_hrn
 
     def get_slivers(self, hrn, node=None):
          
@@ -274,14 +274,14 @@ class Slices(SimpleStorage):
 
     def delete_slice_smgr(self, hrn):
         credential = self.api.getCredential()
-        caller_cred = self.caller_cred
+        origin_hrn = self.origin_hrn
         aggregates = Aggregates(self.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, request_hash, origin_hrn)
                 success = True
             except:
                 print >> log, "%s" % (traceback.format_exc())
@@ -292,7 +292,7 @@ class Slices(SimpleStorage):
                 try:
                     arg_list = [credential, hrn]
                     request_hash = self.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())
@@ -601,7 +601,7 @@ class Slices(SimpleStorage):
             rspecs[net_hrn] = tempspec.toxml()
 
         # send each rspec to the appropriate aggregate/sm
-        caller_cred = self.caller_cred
+        origin_hrn = self.origin_hrn
         for net_hrn in rspecs:
             try:
                 # if we are directly connected to the aggregate then we can just send them the rspec
@@ -611,19 +611,19 @@ class Slices(SimpleStorage):
                     if net_hrn in [self.api.hrn]:
                         try:
                             request_hash = None
-                            aggregates[net_hrn].create_slice(credential, hrn, rspec, request_hash, caller_cred)
+                            aggregates[net_hrn].create_slice(credential, hrn, rspec, request_hash, origin_hrn)
                         except:
                             arg_list = [credential,hrn,rspec]
                             request_hash = self.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, request_hash, origin_hrn)
                     else:
                         try:
                             request_hash = None
-                            aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], request_hash, caller_cred)
+                            aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], request_hash, origin_hrn)
                         except:
                             arg_list = [credential,hrn,rspecs[net_hrn]]
                             request_hash = self.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], request_hash, origin_hrn)
                 else:
                     # lets forward this rspec to a sm that knows about the network
                     arg_list = [credential, net_hrn]
@@ -636,11 +636,11 @@ class Slices(SimpleStorage):
                         if network_networks:
                             try:
                                request_hash = None
-                                aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], request_hash, caller_cred)
+                                aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], request_hash, origin_hrn)
                             except:
                                 arg_list = [credential, hrn, rspecs[net_hrn]]
                                 request_hash = self.api.key.compute_hash(arg_list) 
-                                aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], request_hash, caller_cred)
+                                aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], request_hash, origin_hrn)
                      
             except:
                 print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % locals()