store hostname in pblacklisted instead of node_id

diff --git a/src/nepi/testbeds/planetlab/execute.py b/src/nepi/testbeds/planetlab/execute.py
index 8574112..cd9e06c 100644 (file)
--- a/src/nepi/testbeds/planetlab/execute.py
+++ b/src/nepi/testbeds/planetlab/execute.py
@@ -49,10 +49,11 @@ class TestbedController(testbed_impl.TestbedController):
         
         self._load_blacklist()
 
-        self._sliceapi = None
-        self._plcapi = None
         self._slice_id = None
-        
+        self._plcapi = None
+        self._sliceapi = None
+        self._vsys_vnet = None
+
         self._logger = logging.getLogger('nepi.testbeds.planetlab')
         
         self.recovering = False
@@ -91,10 +92,8 @@ class TestbedController(testbed_impl.TestbedController):
     
     @property
     def vsys_vnet(self):
-        if not hasattr(self, '_vsys_vnet'):
-            self._vsys_vnet = plutil.getVnet(
-                self.plcapi,
-                self.slicename)
+        if not self._vsys_vnet:
+            self._vsys_vnet = self.sliceapi.GetSliceVnetSysTag(self.slicename)
         return self._vsys_vnet
 
     def _load_blacklist(self):
@@ -108,9 +107,7 @@ class TestbedController(testbed_impl.TestbedController):
             
         try:
             self._blacklist = set(
-                map(int,
-                    map(str.strip, bl.readlines())
-                )
+                map(str.strip, bl.readlines())
             )
         finally:
             bl.close()
@@ -212,7 +209,7 @@ class TestbedController(testbed_impl.TestbedController):
         reserved = set(self._blacklist)
         for guid, node in self._elements.iteritems():
             if isinstance(node, self._node.Node) and node._node_id is not None:
-                reserved.add(node._node_id)
+                reserved.add(node.hostname)
         
         # Initial algo:
         #   look for perfectly defined nodes
@@ -225,32 +222,36 @@ class TestbedController(testbed_impl.TestbedController):
                 filter_slice_id = self.slice_id)
             
             node_id = None
+            candidate_hosts = set(candidates.keys() if candidates else [])
             reserve_lock.acquire()
             try:
-                candidates -= reserved
-                if len(candidates) == 1:
-                    node_id = iter(candidates).next()
-                    reserved.add(node_id)
-                elif not candidates:
+                candidate_hosts -= reserved
+                if len(candidate_hosts) == 1:
+                    hostname = iter(candidate_hosts).next()
+                    node_id = candidates[hostname]
+                    reserved.add(hostname)
+                elif not candidate_hosts:
                     # Try again including unassigned nodes
                     reserve_lock.release()
                     try:
                         candidates = node.find_candidates()
                     finally:
                         reserve_lock.acquire()
-                    candidates -= reserved
-                    if len(candidates) > 1:
+                    candidate_hosts = set(candidates.keys() if candidates else [])
+                    candidate_hosts -= reserved
+                    if len(candidate_hosts) > 1:
                         return
-                    if len(candidates) == 1:
-                        node_id = iter(candidates).next()
+                    if len(candidate_hosts) == 1:
+                        hostname = iter(candidate_hosts).next()
+                        node_id = candidates[hostname]
                         to_provision.add(node_id)
-                        reserved.add(node_id)
+                        reserved.add(hostname)
                     elif not candidates:
                         raise RuntimeError, "Cannot assign resources for node %s, no candidates sith %s" % (guid,
                             node.make_filter_description())
             finally:
                 reserve_lock.release()
-            
+           
             if node_id is not None:
                 node.assign_node_id(node_id)
         
@@ -270,14 +271,16 @@ class TestbedController(testbed_impl.TestbedController):
             # If we have only one candidate, simply use it
             candidates = node.find_candidates(
                 filter_slice_id = filter_slice_id)
-            candidates -= reserved
-            reqs.append(candidates)
+            for r in reserved:
+                if candidates.has_key(r):
+                    del candidates[r]
+            reqs.append(candidates.values())
             nodes.append(node)
         for guid, node in self._elements.iteritems():
             if isinstance(node, self._node.Node) and node._node_id is None:
                 runner.put(genreqs, node, self.slice_id)
         runner.sync()
-        
+       
         if nodes and reqs:
             if recover:
                 raise RuntimeError, "Impossible to recover: unassigned host for Nodes %r" % (nodes,)
@@ -310,9 +313,9 @@ class TestbedController(testbed_impl.TestbedController):
     def do_provisioning(self):
         if self._to_provision:
             # Add new nodes to the slice
-            cur_nodes = self.sliceapi.GetSliceNodes(self.slicename)
+            cur_nodes = self.sliceapi.GetSliceNodes(self.slice_id)
             new_nodes = list(set(cur_nodes) | self._to_provision)
-            self.sliceapi.AddSliceNodes(self.slicename, nodes=new_nodes)
+            self.sliceapi.AddSliceNodes(self.slice_id, nodes=new_nodes)
 
         # cleanup
         self._just_provisioned = self._to_provision
@@ -364,7 +367,7 @@ class TestbedController(testbed_impl.TestbedController):
                 if isinstance(node, self._node.Node):
                     if not node.is_alive():
                         self._logger.warn("Blacklisting %s for unresponsiveness", node.hostname)
-                        self._blacklist.add(node._node_id)
+                        self._blacklist.add(node.hostname)
                         node.unassign_node()
             
             try:

diff --git a/src/nepi/testbeds/planetlab/node.py b/src/nepi/testbeds/planetlab/node.py
index 10fac05..0785769 100644 (file)
--- a/src/nepi/testbeds/planetlab/node.py
+++ b/src/nepi/testbeds/planetlab/node.py
@@ -199,7 +199,7 @@ class Node(object):
             
         candidates = set(map(operator.itemgetter('node_id'), 
             self._sliceapi.GetNodes(filters=basefilters, fields=fields, **extra)))
-        
+
         # filter by tag, one tag at a time
         applicable = self.applicable_filters
         for tagfilter in self.TAGFILTERS.iteritems():
@@ -260,8 +260,9 @@ class Node(object):
                     len(ifaces.get(node_id,())) <= self.max_num_external_ifaces )
             
             candidates = set(filter(predicate, candidates))
-        
+       
         # make sure hostnames are resolvable
+        hostnames = None
         if candidates:
             self._logger.info("  Found %s candidates. Checking for reachability...", len(candidates))
             
@@ -278,8 +279,14 @@ class Node(object):
                 maxthreads = 16))
 
             self._logger.info("  Found %s reachable candidates.", len(candidates))
-            
-        return candidates
+
+            for h in hostnames.keys():
+                if h not in candidates:
+                    del hostnames[h]
+
+            hostnames = dict((v,k) for k, v in hostnames.iteritems())
+
+        return hostnames
     
     def make_filter_description(self):
         """
@@ -532,7 +539,7 @@ class Node(object):
         if self._node_id:
             self._logger.warn("Blacklisting malfunctioning node %s", self.hostname)
             import util
-            util.appendBlacklist(self._node_id)
+            util.appendBlacklist(self.hostname)
     
     def do_cleanup(self):
         if self.testbed().recovering:

diff --git a/src/nepi/testbeds/planetlab/plcapi.py b/src/nepi/testbeds/planetlab/plcapi.py
index 747e549..507dcdb 100644 (file)
--- a/src/nepi/testbeds/planetlab/plcapi.py
+++ b/src/nepi/testbeds/planetlab/plcapi.py
@@ -318,7 +318,18 @@ class PLCAPI(object):
         slices = self.GetSlices(slicename, fields=('slice_id',))
         if slices:
                 slice_id = slices[0]['slice_id']
+        # If it wasn't found, don't remember this failure, keep trying
         return slice_id
+
+    def GetSliceVnetSysTag(self, slicename):
+        slicetags = self.GetSliceTags(
+            name = slicename,
+            tagname = 'vsys_vnet',
+            fields=('value',))
+        if slicetags:
+            return slicetags[0]['value']
+        else:
+            return None
  
 def plcapi(auth_user, auth_string, plc_host, plc_url):
     api = None

diff --git a/src/nepi/testbeds/planetlab/util.py b/src/nepi/testbeds/planetlab/util.py
index a91b026..30fcf9d 100644 (file)
--- a/src/nepi/testbeds/planetlab/util.py
+++ b/src/nepi/testbeds/planetlab/util.py
@@ -62,14 +62,7 @@ def appendBlacklist(node_ids):
         bl.close()
 
 def getVnet(api, slicename):
-    slicetags = api.GetSliceTags(
-        name = slicename,
-        tagname = 'vsys_vnet',
-        fields=('value',))
-    if slicetags:
-        return slicetags[0]['value']
-    else:
-        return None
+    return api.GetSliceVsysNetTag(slicename)
 
 def getNodes(api, num, **constraints):
     # Now do the backtracking search for a suitable solution