X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fplc%2Fslices.py;h=c8905b0476ffb400dafacbbe447b1860c7a87b7c;hb=8da8caf2d1352ec2ddd99efde9144250a22d0ba6;hp=98a24c6c946fe9ff88a0ea641e9cdb5a5ccb7f19;hpb=98f5ae2e8b7893fabf6bc0d77938761f464e28f4;p=sfa.git

diff --git a/sfa/plc/slices.py b/sfa/plc/slices.py
index 98a24c6c..c8905b04 100644
--- 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):
@@ -243,7 +243,11 @@ class Slices(SimpleStorage):
             if not person_record:
                 pass
             person_dict = person_record.as_dict()
-            persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids'])
+	    if peer:
+	       peer_id=self.api.plshell.GetPeers(self.api.plauth, {'shortname' : peer}, ['peer_id'])[0]['peer_id']
+               persons = self.api.plshell.GetPersons(self.api.plauth, {'email' : [person_dict['email']], 'peer_id' : peer_id}, ['person_id', 'key_ids'])
+	    else:
+               persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids'])
 
             # Create the person record 
             if not persons:
@@ -289,8 +293,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 +341,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