fewer output lines

diff --git a/scripts/builds.sh b/scripts/builds.sh
index b7a3cd9..22631fa 100755 (executable)
--- a/scripts/builds.sh
+++ b/scripts/builds.sh
@@ -27,7 +27,7 @@ velvet && /root/bin/vbuild-nightly.sh -m build@onelab.eu   -d onelab -t onelab-k
 velvet && /root/bin/vbuild-nightly.sh -m build@onelab.eu   -d onelab -t onelab-k27-tags.mk -f centos5 -p linux64 -b @DATE@--k27-c54-64 -B
 
 # 2.6.22 kernel on c5
-velvet && /root/bin/vbuild-nightly.sh -m build@onelab.eu   -d onelab -f centos5 -p linux32 -b @DATE@--k22-c54-32 -B
+velvet && /root/bin/vbuild-nightly.sh -m build@onelab.eu   -d onelab -f centos5 -p linux32 -b @DATE@--k22-c54-32
 velvet && /root/bin/vbuild-nightly.sh -m build@onelab.eu   -d onelab -f centos5 -p linux64 -b @DATE@--k22-c54-64 -B
 
 # wextoolbox variants                                                                                                                   

diff --git a/scripts/manage-infrastructure.py b/scripts/manage-infrastructure.py
index f9983ec..c0fd6c2 100755 (executable)
--- a/scripts/manage-infrastructure.py
+++ b/scripts/manage-infrastructure.py
@@ -20,7 +20,8 @@ class BuildBoxes:
     def __init__ (self):
         # dummy defaults
         self.boxes = []
-        self.do_tracker = False
+        self.do_tracker_qemus = False
+        self.do_tracker_plcs = False
 
     def fqdn (self, box):
         return "%s.%s"%(box,self.domain)
@@ -54,14 +55,22 @@ class BuildBoxes:
         command=['ssh',self.root(box),'shutdown','-r','now']
         self.run (command,"Rebooting %s"%box)
 
-    def handle_trackers (self):
+    def handle_tracker_file (self,filename):
         box = self.fqdn (self.testmaster)
         if self.options.probe:
-            command=['ssh',self.root(box),"head","-100","tracker*"]
-            self.run(command,"Inspecting trackers on %s"%box)
+            command=['ssh',self.root(box),"head","-v","--lines=100",filename]
+            self.run(command,"++++++++++ Inspecting %s on %s"%(filename,box))
         else:
-            command=['ssh',self.root(box),"rm","-rf","tracker*"]
-            self.run(command,"Cleaning up trackers on %s"%box)
+            command=['ssh',self.root(box),"rm","-rf",filename]
+            self.run(command,"Cleaning up %s on %s"%(filaneme,box))
+
+    def handle_tracker_plcs (self):
+        self.handle_tracker_file("tracker-plcs")
+    def handle_tracker_qemus (self):
+        self.handle_tracker_file("tracker-qemus")
+    def handle_trackers (self):
+        self.handle_tracker_plcs()
+        self.handle_tracker_qemus()
 
     def handle_build_box (self,box):
         if not self.options.probe:
@@ -111,16 +120,17 @@ class BuildBoxes:
                     # at this point ctx_id maps context id to vservername
 
                     vserver_stat = self.backquote (command)
+                    format="%-14s"
                     for vserver_line in vserver_stat.split("\n"):
                         if not vserver_line: continue
                         context=vserver_line.split()[0]
                         if context=="CTX": 
-                            print vserver_line
+                            print format%"",vserver_line
                             continue
                         longname=ctx_dict[context]
                         plcname=self.vplcname(longname)
-                        if plcname: print "== %s =="%plcname
-                        print "%(vserver_line)s [=%(longname)s]"%locals()
+                        header="== %s =="%plcname
+                        print format%header,"%(vserver_line)s [=%(longname)s]"%locals()
                 except:
                     self.run(command,"Fine-grained method failed - fallback to plain vserver-stat")
 
@@ -143,21 +153,21 @@ class BuildBoxes:
                 if not pids:
                     self.header ('No qemu process on %s'%box)
                 else:
+                    format="%-14s"
                     self.header ("Active qemu processes on %s"%box)
                     command=['ssh',self.root(box),'ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
                     ps_lines = self.backquote (command).split("\n")
                     for ps_line in ps_lines:
                         if not ps_line or ps_line.find('PID') >=0 : continue
-                        node=self.vnodename(ps_line)
-                        if node: print "== %s =="%node
-                        print ps_line
+                        header=self.vnodename(ps_line)
+                        print format%header, ps_line
 
-    def handle_box(self,box):
+    def handle_box(self,box,type):
         if box in self.qemu_boxes:
-            self.handle_qemu_box(self.fqdn(box))
+            if type=="qemu": self.handle_qemu_box(self.fqdn(box))
         elif box in self.plc_boxes:
-            self.handle_plc_box(self.fqdn(box))
-        else:
+            if type=="plc":  self.handle_plc_box(self.fqdn(box))
+        elif type=="build":
             self.handle_build_box(self.fqdn(box))
 
     def main (self):
@@ -187,32 +197,42 @@ Default is to act on test boxes only (with trackers clean)"""
         if args:
             self.boxes=args
             # if hostnames are specified, let's stay on the safe side and don't reset trackers
-            self.do_tracker = False
+            self.do_tracker_plcs = False
+            self.do_tracker_qemus = False
         elif self.options.all_boxes:
             self.boxes=self.test_boxes + self.build_boxes
-            self.do_tracker = True
+            self.do_tracker_plcs = True
+            self.do_tracker_qemus = True
         elif self.options.build_only:
             self.boxes=self.build_boxes
-            self.do_tracker = False
+            self.do_tracker_plcs = False
+            self.do_tracker_qemus = False
         elif self.options.qemu_only:
             self.boxes=self.qemu_boxes
-            self.do_tracker = False
+            self.do_tracker_plcs = False
+            self.do_tracker_qemus = True
         elif self.options.plc_only:
             self.boxes=self.plc_boxes
-            self.do_tracker = False
+            self.do_tracker_plcs = True
+            self.do_tracker_qemus = False
         elif self.options.trackers_only:
             self.boxes = []
-            self.do_tracker = True
+            self.do_tracker_plcs = True
+            self.do_tracker_qemus = True
         # default
         else:
             self.boxes = self.test_boxes
-            self.do_tracker = True
-
-        if self.do_tracker:
-            self.handle_trackers ()
-        for box in self.boxes:
-            self.handle_box (box)
-
+            self.do_tracker_plcs = True
+            self.do_tracker_qemus = True
+
+        # ALL OTHERS
+        for box in self.boxes:  self.handle_box (box,"build")
+        # PLCS
+        if self.do_tracker_plcs:self.handle_tracker_plcs ()
+        for box in self.boxes:  self.handle_box (box,"plc")
+        # QEMU
+        if self.do_tracker_qemus:self.handle_tracker_qemus ()
+        for box in self.boxes:  self.handle_box (box,"qemu")
 
 if __name__ == "__main__":
     BuildBoxes().main()