netspec contains the slit Rspec

[sfa.git] / sfa / plc / slices.py

diff --git a/sfa/plc/slices.py b/sfa/plc/slices.py
index 21cf41f..1e486a5 100644 (file)
--- a/sfa/plc/slices.py
+++ b/sfa/plc/slices.py
@@ -30,7 +30,7 @@ class Slices(SimpleStorage):
         SimpleStorage.__init__(self, self.slices_file)
         self.policy = Policy(self.api)    
         self.load()
-       self.caller_cred=caller_cred
+        self.caller_cred=caller_cred
 
 
     def get_peer(self, hrn):
@@ -184,13 +184,13 @@ class Slices(SimpleStorage):
 
         # Get the slice's site record
         authority = get_authority(hrn)
-        site_records = registry.resolve(credential, get_authority(hrn))
+        site_records = registry.resolve(credential, authority)
         site = {}
         for site_record in site_records:
             if site_record.get_type() in ['authority']:
                 site = site_record.as_dict()
         if not site:
-            raise RecordNotFound(hrn)
+            raise RecordNotFound(authority)
         remote_site_id = site.pop('site_id')
             
         # Make sure slice exists at plc, if it doesnt add it
@@ -289,8 +289,11 @@ class Slices(SimpleStorage):
                         self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer)
                     key_id=self.api.plshell.AddPersonKey(self.api.plauth, person_dict['email'], key)
                     if peer:
-                        self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
-                        self.api.plshell.BindObjectToPeer(self.api.plauth, 'key', key_id, peer, key_ids.pop(0))
+                        self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
+                        # BindObjectToPeer may faill if type is key and it's already bound to the peer
+                        # so lets just put a try/except here
+                        try: self.api.plshell.BindObjectToPeer(self.api.plauth, 'key', key_id, peer, key_ids.pop(0))
+                        except: pass
 
         # find out where this slice is currently running
         nodelist = self.api.plshell.GetNodes(self.api.plauth, slice['node_ids'], ['hostname'])
@@ -334,26 +337,36 @@ class Slices(SimpleStorage):
         rspecs = {}
         aggregates = Aggregates(self.api)
         credential = self.api.getCredential()
-        # only attempt to extract information about the aggregates we know about
-        for aggregate in aggregates:
-            netspec = spec.getDictByTagNameValue('NetSpec', aggregate)
-            if netspec:
-                # creat a plc dict 
-                resources = {'start_time': start_time, 'end_time': end_time, 'networks': netspec}
-                resourceDict = {'Rspec': resources}
-                tempspec.parseDict(resourceDict)
-                rspecs[aggregate] = tempspec.toxml()
-
-        # notify the aggregates
-        for aggregate in rspecs.keys():
+
+        # 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 
+        for net_hrn in rspecs:
             try:
-                # send the whloe rspec to the local aggregate
-                if aggregate in [self.api.hrn]:
-                    aggregates[aggregate].create_slice(credential, hrn, rspec, caller_cred=self.caller_cred)
+                # 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 [self.api.hrn]:
+                        aggregates[net_hrn].create_slice(credential, hrn, rspec, caller_cred=self.caller_cred)
+                    else:
+                        aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], caller_cred=self.caller_cred)
                 else:
-                    aggregates[aggregate].create_slice(credential, hrn, rspecs[aggregate], caller_cred=self.caller_cred)
+                    # lets forward this rspec to a sm that knows about the network    
+                    for aggregate in aggregates:
+                        network_found = aggregates[aggregate].get_aggregates(credential, net_hrn)
+                        if network_networks:
+                            aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], caller_cred=self.caller_cred)
+                     
             except:
-                print >> log, "Error creating slice %(hrn)s at aggregate %(aggregate)s" % locals()
+                print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % locals()
                 traceback.print_exc()
         return 1