get ssh-slice and ssh-slice-off to work in parallel on all 3 slices
Thierry Parmentelat [Tue, 27 Aug 2013 11:04:56 +0000 (13:04 +0200)]
system/TestPlc.py
system/TestSlice.py

index 8d0dc4f..365add9 100644 (file)
@@ -64,6 +64,36 @@ def slice_mapper (method):
     actual.__doc__=TestSlice.__dict__[method.__name__].__doc__
     return actual
 
+# a variant that expects the TestSlice method to return a list of CompleterTasks that
+# are then merged into a single Completer run to avoid wating for all the slices
+# esp. useful when a test fails of course
+# because we need to pass arguments we use a class instead..
+class slice_mapper__tasks (object):
+    # could not get this to work with named arguments
+    def __init__ (self,timeout_minutes,silent_minutes,period_seconds):
+        print "self",self
+        print "timeout_minutes,silent_minutes,period_seconds",timeout_minutes,silent_minutes,period_seconds
+        self.timeout=timedelta(minutes=timeout_minutes)
+        self.silent=timedelta(minutes=silent_minutes)
+        self.period=timedelta(seconds=period_seconds)
+    def __call__ (self, method):
+        decorator_self=self
+        # compute augmented method name
+        method_name = method.__name__ + "__tasks"
+        # locate in TestSlice
+        slice_method = TestSlice.__dict__[ method_name ]
+        def wrappee(self):
+            tasks=[]
+            for slice_spec in self.plc_spec['slices']:
+                site_spec = self.locate_site (slice_spec['sitename'])
+                test_site = TestSite(self,site_spec)
+                test_slice=TestSlice(self,test_site,slice_spec)
+                tasks += slice_method (test_slice, self.options)
+            return Completer (tasks).run (decorator_self.timeout, decorator_self.silent, decorator_self.period)
+        # restore the doc text from the TestSlice method even if a bit odd
+        wrappee.__doc__ = slice_method.__doc__
+        return wrappee
+
 def auth_sfa_mapper (method):
     def actual(self):
         overall=True
@@ -1135,10 +1165,11 @@ class TestPlc:
                 test_slice.create_slice()
         return True
         
-    @slice_mapper
+    @slice_mapper__tasks(20,10,15)
     def ssh_slice(self): pass
-    @slice_mapper
+    @slice_mapper__tasks(20,19,15)
     def ssh_slice_off (self): pass
+
     @slice_mapper
     def ssh_slice_basics(self): pass
 
index 8082749..f5d1e33 100644 (file)
@@ -143,23 +143,24 @@ class TestSlice:
             key_names += user_spec['key_names']
         return self.test_plc.locate_private_key_from_key_names (key_names)
 
-    # trying to reach the slice through ssh - expected to answer
-    def ssh_slice (self, options, *args, **kwds):
+    # to be used through TestPlc.slice_mapper_tasks
+    # i.e. returns a list of CompleterTasks that are merged into the same Completer run
+    # to avoid waiting for as many slices as the Plc has
+    # also the __doc__ lines are used for the TestPlc methods, e.g. just 'ssh_slice'
+    def ssh_slice__tasks (self, options, *args, **kwds):
         "tries to ssh-enter the slice with the user key, to check for slice creation"
-        return self.do_ssh_slice(options, expected=True, *args, **kwds)
+        return self.ssh_tasks(options, expected=True, *args, **kwds)
 
     # when we expect the slice is not reachable
-    def ssh_slice_off (self, options, *args, **kwds):
+    def ssh_slice_off__tasks (self, options, *args, **kwds):
         "tries to ssh-enter the slice with the user key, expecting it to be unreachable"
-        return self.do_ssh_slice(options, expected=False, *args, **kwds)
+        return self.ssh_tasks(options, expected=False, *args, **kwds)
 
-    def do_ssh_slice(self,options,expected=True,
-                     timeout_minutes=20,silent_minutes=10,period_seconds=15,command=None):
-        "tries to enter a slice"
-
-        timeout  = timedelta(minutes=timeout_minutes)
-        graceout = timedelta(minutes=silent_minutes)
-        period   = timedelta(seconds=period_seconds)
+    def ssh_tasks(self,options, expected=True, command=None):
+#                     timeout_minutes=20,silent_minutes=10,period_seconds=15):
+#        timeout  = timedelta(minutes=timeout_minutes)
+#        graceout = timedelta(minutes=silent_minutes)
+#        period   = timedelta(seconds=period_seconds)
         if not command:
             command="echo hostname ; hostname; echo id; id; echo uname -a ; uname -a"
         # locate a key
@@ -180,7 +181,8 @@ class TestSlice:
             (site_spec,node_spec) = self.test_plc.locate_node(nodename)
             tasks.append( CompleterTaskSshSlice(self.test_plc,node_spec['node_fields']['hostname'],
                                                 slicename,private_key,command,expected,dry_run))
-        return Completer (tasks).run (timeout, graceout, period)
+        return tasks
+#        return Completer (tasks).run (timeout, graceout, period)
 
     def ssh_slice_basics (self, options, *args, **kwds):
         "the slice is expected to be UP and we just check a few simple sanity commands, including 'ps' to check for /proc"