X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=system%2FSubstrate.py;h=fc5125f59b7845fe2ab58680a69b0ac037c3c02b;hb=e85fe8ae48538f2cec761ef1a47f8a374dc1526c;hp=b2748a8c303d61366e18114008da569981af9c65;hpb=8935fb0b41c4bd5368da7724d68393342c172c70;p=tests.git

diff --git a/system/Substrate.py b/system/Substrate.py
index b2748a8..fc5125f 100644
--- a/system/Substrate.py
+++ b/system/Substrate.py
@@ -59,6 +59,9 @@ import utils
 from TestSsh import TestSsh
 from TestMapper import TestMapper
 
+# too painful to propagate this cleanly
+verbose=None
+
 def header (message,banner=True):
     if not message: return
     if banner: print "===============",
@@ -150,7 +153,7 @@ class Pool:
         # where to send notifications upon load_starting
         self.substrate=substrate
 
-    def list (self):
+    def list (self, verbose=False):
         for i in self.pool_items: print i.line()
 
     def line (self):
@@ -261,13 +264,73 @@ class Box:
         self.test_ssh().run("shutdown -r now",message="Rebooting %s"%self.hostname,
                             dry_run=options.dry_run)
 
+    def hostname_fedora (self,virt=None):
+        result = "%s {"%self.hostname
+        if virt: result += "%s-"%virt
+        result += "%s"%self.fedora()
+        # too painful to propagate this cleanly
+        global verbose
+        if verbose:
+            result += "-%s" % self.uname()
+        result += "}"
+        return result
+
+    separator = "===composite==="
+
+    # probe the ssh link
+    # take this chance to gather useful stuff
+    def probe (self):
+        # try it only once
+        if self._probed is not None: return self._probed
+        composite_command = [ ]
+        composite_command += [ "hostname" ]
+        composite_command += [ ";" , "echo", Box.separator , ";" ]
+        composite_command += [ "uptime" ]
+        composite_command += [ ";" , "echo", Box.separator , ";" ]
+        composite_command += [ "uname", "-r"]
+        composite_command += [ ";" , "echo", Box.separator , ";" ]
+        composite_command += [ "cat" , "/etc/fedora-release" ]
+
+        # due to colons and all, this is going wrong on the local box (typically testmaster)
+        # I am reluctant to change TestSsh as it might break all over the place, so
+        if self.test_ssh().is_local():
+            probe_argv = [ "bash", "-c", " ".join (composite_command) ]
+        else:
+            probe_argv=self.test_ssh().actual_argv(composite_command)
+        composite=self.backquote ( probe_argv, trash_err=True )
+        self._hostname = self._uptime = self._uname = self._fedora = "** Unknown **"
+        if not composite: 
+            print "root@%s unreachable"%self.hostname
+            self._probed=''
+        else:
+            try:
+                pieces = composite.split(Box.separator)
+                pieces = [ x.strip() for x in pieces ]
+                [self._hostname, self._uptime, self._uname, self._fedora] = pieces
+                # customize
+                self._uptime = ', '.join([ x.strip() for x in self._uptime.split(',')[2:]])
+                self._fedora = self._fedora.replace("Fedora release ","f").split(" ")[0]
+            except:
+                import traceback
+                print 'BEG issue with pieces',pieces
+                traceback.print_exc()
+                print 'END issue with pieces',pieces
+            self._probed=self._hostname
+        return self._probed
+
+    # use argv=['bash','-c',"the command line"]
     def uptime(self):
+        self.probe()
         if hasattr(self,'_uptime') and self._uptime: return self._uptime
-        return '*undef* uptime'
-    def sense_uptime (self):
-        command=['uptime']
-        self._uptime=self.backquote_ssh(command,trash_err=True).strip()
-        if not self._uptime: self._uptime='unreachable'
+        return '*unprobed* uptime'
+    def uname(self):
+        self.probe()
+        if hasattr(self,'_uname') and self._uname: return self._uname
+        return '*unprobed* uname'
+    def fedora(self):
+        self.probe()
+        if hasattr(self,'_fedora') and self._fedora: return self._fedora
+        return '*unprobed* fedora'
 
     def run(self,argv,message=None,trash_err=False,dry_run=False):
         if dry_run:
@@ -296,15 +359,6 @@ class Box:
             result= subprocess.Popen(argv,stdout=subprocess.PIPE,stderr=file('/dev/null','w')).communicate()[0]
         return result
 
-    def probe (self):
-        if self._probed is not None: return self._probed
-        # first probe the ssh link
-        probe_argv=self.test_ssh().actual_argv(['hostname'])
-        self._probed=self.backquote ( probe_argv, trash_err=True )
-        if not self._probed: print "root@%s unreachable"%self.hostname
-        return self._probed
-
-    # use argv=['bash','-c',"the command line"]
     # if you have any shell-expanded arguments like *
     # and if there's any chance the command is adressed to the local host
     def backquote_ssh (self, argv, trash_err=False):
@@ -336,11 +390,11 @@ class BuildBox (Box):
                 return
         self.build_instances.append(BuildInstance(buildname, pid, self))
 
-    def list(self):
+    def list(self, verbose=False):
         if not self.build_instances: 
-            header ('No build process on %s (%s)'%(self.hostname,self.uptime()))
+            header ('No build process on %s (%s)'%(self.hostname_fedora(),self.uptime()))
         else:
-            header ("Builds on %s (%s)"%(self.hostname,self.uptime()))
+            header ("Builds on %s (%s)"%(self.hostname_fedora(),self.uptime()))
             for b in self.build_instances: 
                 header (b.line(),banner=False)
 
@@ -348,35 +402,67 @@ class BuildBox (Box):
         if not options.soft:
             Box.reboot(self,options)
         else:
+            self.soft_reboot (options)
+
+build_matcher=re.compile("\s*(?P<pid>[0-9]+).*-[bo]\s+(?P<buildname>[^\s]+)(\s|\Z)")
+build_matcher_initvm=re.compile("\s*(?P<pid>[0-9]+).*initvm.*\s+(?P<buildname>[^\s]+)\s*\Z")
+
+class BuildVsBox (BuildBox):
+    def soft_reboot (self, options):
             command=['pkill','vbuild']
             self.run_ssh(command,"Terminating vbuild processes",dry_run=options.dry_run)
 
     # inspect box and find currently running builds
-    matcher=re.compile("\s*(?P<pid>[0-9]+).*-[bo]\s+(?P<buildname>[^\s]+)(\s|\Z)")
-    matcher_building_vm=re.compile("\s*(?P<pid>[0-9]+).*init-vserver.*-i\s+eth.\s+(?P<buildname>[^\s]+)\s*\Z")
     def sense(self, options):
-        print 'bb',
-        self.sense_uptime()
+        print 'vb',
         pids=self.backquote_ssh(['pgrep','vbuild'],trash_err=True)
         if not pids: return
         command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
         ps_lines=self.backquote_ssh (command).split('\n')
         for line in ps_lines:
             if not line.strip() or line.find('PID')>=0: continue
-            m=BuildBox.matcher.match(line)
+            m=build_matcher.match(line)
             if m: 
                 date=time.strftime('%Y-%m-%d',time.localtime(time.time()))
                 buildname=m.group('buildname').replace('@DATE@',date)
                 self.add_build (buildname,m.group('pid'))
                 continue
-            m=BuildBox.matcher_building_vm.match(line)
+            m=build_matcher_initvm.match(line)
             if m: 
                 # buildname is expansed here
                 self.add_build (buildname,m.group('pid'))
                 continue
-            header('BuildBox.sense: command %r returned line that failed to match'%command)
+            header('BuildVsBox.sense: command %r returned line that failed to match'%command)
             header(">>%s<<"%line)
 
+class BuildLxcBox (BuildBox):
+    def soft_reboot (self, options):
+            command=['pkill','lbuild']
+            self.run_ssh(command,"Terminating vbuild processes",dry_run=options.dry_run)
+
+    # inspect box and find currently running builds
+    def sense(self, options):
+        print 'xb'
+        pids=self.backquote_ssh(['pgrep','lbuild'],trash_err=True)
+        if not pids: return
+        command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
+        ps_lines=self.backquote_ssh (command).split('\n')
+        for line in ps_lines:
+            if not line.strip() or line.find('PID')>=0: continue
+            m=build_matcher.match(line)
+            if m: 
+                date=time.strftime('%Y-%m-%d',time.localtime(time.time()))
+                buildname=m.group('buildname').replace('@DATE@',date)
+                self.add_build (buildname,m.group('pid'))
+                continue
+            m=build_matcher_initvm.match(line)
+            if m: 
+                # buildname is expansed here
+                self.add_build (buildname,m.group('pid'))
+                continue
+            header('BuildLxcBox.sense: command %r returned line that failed to match'%command)
+            header(">>%s<<"%line)
+    
 ############################################################
 class PlcInstance:
     def __init__ (self, plcbox):
@@ -415,15 +501,31 @@ class PlcVsInstance (PlcInstance):
 
 class PlcLxcInstance (PlcInstance):
     # does lxc have a context id of any kind ?
-    def __init__ (self, plcbox, lxcname):
+    def __init__ (self, plcbox, lxcname, pid):
         PlcInstance.__init__(self, plcbox)
         self.lxcname = lxcname
+	self.pid = pid
 
-    def kill (self):
-        print "TODO lxc PlcLxcInstance.kill ..."
+    def vplcname (self):
+        return self.lxcname.split('-')[-1]
+    def buildname (self):
+        return self.lxcname.rsplit('-',2)[0]
 
     def line (self):
-        return "TODO lxc PlcLxcInstance.line with lxcname=%s"%(self.lxcname)
+        msg="== %s =="%(self.vplcname())
+        msg += " [=%s]"%self.lxcname
+        if self.pid==-1:  msg+=" not (yet?) running"
+        else:              msg+=" (pid=%s)"%self.pid
+        if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
+        else:              msg += " *unknown timestamp*"
+        return msg
+
+    def kill (self):
+        command="rsync lxc-driver.sh  %s:/root"%self.plc_box.hostname
+	commands.getstatusoutput(command)
+	msg="lxc container stopping %s on %s"%(self.lxcname,self.plc_box.hostname)
+	self.plc_box.run_ssh(['/root/lxc-driver.sh','-c','stop_lxc','-n',self.lxcname],msg)
+        self.plc_box.forget(self)
 
 ##########
 class PlcBox (Box):
@@ -446,11 +548,11 @@ class PlcBox (Box):
 
     def reboot (self, options):
         if not options.soft:
-            self.reboot(options)
+            Box.reboot(self,options)
         else:
             self.soft_reboot (options)
 
-    def list(self):
+    def list(self, verbose=False):
         if not self.plc_instances: 
             header ('No plc running on %s'%(self.line()))
         else:
@@ -459,14 +561,7 @@ class PlcBox (Box):
             for p in self.plc_instances: 
                 header (p.line(),banner=False)
 
-    def get_uname(self):
-        self._uname=self.backquote_ssh(['uname','-r']).strip()
-
-    # expecting sense () to have filled self._uname
-    def uname(self):
-        if hasattr(self,'_uname') and self._uname: return self._uname
-        return '*undef* uname'
-
+# we do not this at INRIA any more
 class PlcVsBox (PlcBox):
 
     def add_vserver (self,vservername,ctxid):
@@ -478,7 +573,7 @@ class PlcVsBox (PlcBox):
         self.plc_instances.append(PlcVsInstance(self,vservername,ctxid))
     
     def line(self): 
-        msg="%s [max=%d,%d free, VS-based] (%s)"%(self.hostname, self.max_plcs,self.free_slots(),self.uname())
+        msg="%s [max=%d,free=%d] (%s)"%(self.hostname_fedora(virt="vs"), self.max_plcs,self.free_slots(),self.uptime())
         return msg
         
     def plc_instance_by_vservername (self, vservername):
@@ -487,12 +582,11 @@ class PlcVsBox (PlcBox):
         return None
 
     def soft_reboot (self, options):
-        self.run_ssh(['service','util-vserver','stop'],"Stopping all running vservers",
+        self.run_ssh(['service','util-vserver','stop'],"Stopping all running vservers on %s"%(self.hostname,),
                      dry_run=options.dry_run)
 
     def sense (self, options):
         print 'vp',
-        self.get_uname()
         # try to find fullname (vserver_stat truncates to a ridiculously short name)
         # fetch the contexts for all vservers on that box
         map_command=['grep','.','/etc/vservers/*/context','/dev/null',]
@@ -543,22 +637,57 @@ class PlcVsBox (PlcBox):
 
 class PlcLxcBox (PlcBox):
 
+    def add_lxc (self,lxcname,pid):
+        for plc in self.plc_instances:
+            if plc.lxcname==lxcname:
+                header("WARNING, duplicate myplc %s running on %s"%\
+                           (lxcname,self.hostname),banner=False)
+                return
+        self.plc_instances.append(PlcLxcInstance(self,lxcname,pid))    
+
+
     # a line describing the box
     def line(self): 
-        msg="%s [max=%d,%d free, LXC-based] (%s)"%(self.hostname, self.max_plcs,self.free_slots(),self.uname())
-        return msg
-        
+        return "%s [max=%d,free=%d] (%s)"%(self.hostname_fedora(virt="lxc"), 
+                                           self.max_plcs,self.free_slots(),
+                                           self.uptime(),
+                                           )
+    
+    def plc_instance_by_lxcname (self, lxcname):
+        for p in self.plc_instances:
+            if p.lxcname==lxcname: return p
+        return None
+    
     # essentially shutdown all running containers
     def soft_reboot (self, options):
-        print "TODO lxc PlcLxcBox.soft_reboot"
+        command="rsync lxc-driver.sh  %s:/root"%self.hostname
+        commands.getstatusoutput(command)
+	self.run_ssh(['/root/lxc-driver.sh','-c','stop_all'],"Stopping all running lxc containers on %s"%(self.hostname,),
+                     dry_run=options.dry_run)
+
 
     # sense is expected to fill self.plc_instances with PlcLxcInstance's 
     # to describe the currently running VM's
-    # as well as to call  self.get_uname() once
     def sense (self, options):
-        print "px (todo:PlcLxcBox.sense)",
-        self.get_uname()
-
+        print "xp",
+	command="rsync lxc-driver.sh  %s:/root"%self.hostname
+        commands.getstatusoutput(command)
+	command=['/root/lxc-driver.sh','-c','sense_all']
+        lxc_stat = self.backquote_ssh (command)
+	for lxc_line in lxc_stat.split("\n"):
+            if not lxc_line: continue
+            lxcname=lxc_line.split(";")[0]
+	    pid=lxc_line.split(";")[1]
+	    timestamp=lxc_line.split(";")[2]
+            self.add_lxc(lxcname,pid)
+            try: timestamp=int(timestamp)
+            except: timestamp=0
+            p=self.plc_instance_by_lxcname(lxcname)
+            if not p:
+                print 'WARNING zombie plc',self.hostname,lxcname
+                print '... was expecting',lxcname,'in',[i.lxcname for i in self.plc_instances]
+                continue
+            p.set_timestamp(timestamp)
 
 ############################################################
 class QemuInstance: 
@@ -617,14 +746,15 @@ class QemuBox (Box):
         self.qemu_instances.append(dummy)
 
     def line (self):
-        msg="%s [max=%d,%d free] (%s)"%(self.hostname, self.max_qemus,self.free_slots(),self.driver())
-        return msg
+        return "%s [max=%d,free=%d] (%s) %s"%(
+            self.hostname_fedora(virt="qemu"), self.max_qemus,self.free_slots(),
+            self.uptime(),self.driver())
 
-    def list(self):
+    def list(self, verbose=False):
         if not self.qemu_instances: 
-            header ('No qemu process on %s'%(self.line()))
+            header ('No qemu on %s'%(self.line()))
         else:
-            header ("Active qemu processes on %s"%(self.line()))
+            header ("Qemus on %s"%(self.line()))
             self.qemu_instances.sort(timestamp_sort)
             for q in self.qemu_instances: 
                 header (q.line(),banner=False)
@@ -649,7 +779,7 @@ class QemuBox (Box):
 
     def reboot (self, options):
         if not options.soft:
-            self.reboot(options)
+            Box.reboot(self,options)
         else:
             self.run_ssh(['pkill','qemu'],"Killing qemu instances",
                          dry_run=options.dry_run)
@@ -658,13 +788,13 @@ class QemuBox (Box):
     def sense(self, options):
         print 'qn',
         modules=self.backquote_ssh(['lsmod']).split('\n')
-        self._driver='*NO kqemu/kmv_intel MODULE LOADED*'
+        self._driver='*NO kqemu/kvm_intel MODULE LOADED*'
         for module in modules:
             if module.find('kqemu')==0:
                 self._driver='kqemu module loaded'
-            # kvm might be loaded without vkm_intel (we dont have AMD)
+            # kvm might be loaded without kvm_intel (we dont have AMD)
             elif module.find('kvm_intel')==0:
-                self._driver='kvm_intel module loaded'
+                self._driver='kvm_intel OK'
         ########## find out running pids
         pids=self.backquote_ssh(['pgrep','qemu'])
         if not pids: return
@@ -680,13 +810,13 @@ class QemuBox (Box):
             header(">>%s<<"%line)
         ########## retrieve alive instances and map to build
         live_builds=[]
-        command=['grep','.','*/*/qemu.pid','/dev/null']
+        command=['grep','.','/vservers/*/*/qemu.pid','/dev/null']
         pid_lines=self.backquote_ssh(command,trash_err=True).split('\n')
         for pid_line in pid_lines:
             if not pid_line.strip(): continue
             # expect <build>/<nodename>/qemu.pid:<pid>pid
             try:
-                (buildname,nodename,tail)=pid_line.split('/')
+                (_,__,buildname,nodename,tail)=pid_line.split('/')
                 (_,pid)=tail.split(':')
                 q=self.qemu_instance_by_pid (pid)
                 if not q: continue
@@ -696,14 +826,14 @@ class QemuBox (Box):
         # retrieve timestamps
         if not live_builds: return
         command=   ['grep','.']
-        command += ['%s/*/timestamp'%b for b in live_builds]
+        command += ['/vservers/%s/*/timestamp'%b for b in live_builds]
         command += ['/dev/null']
         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
         for ts_line in ts_lines:
             if not ts_line.strip(): continue
             # expect <build>/<nodename>/timestamp:<timestamp>
             try:
-                (buildname,nodename,tail)=ts_line.split('/')
+                (_,__,buildname,nodename,tail)=ts_line.split('/')
                 nodename=nodename.replace('qemu-','')
                 (_,timestamp)=tail.split(':')
                 timestamp=int(timestamp)
@@ -732,6 +862,7 @@ class TestInstance:
     def set_now (self): self.timestamp=int(time.time())
     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 
+    def is_running (self): return len(self.pids) != 0
 
     def add_pid (self,pid):
         self.pids.append(pid)
@@ -748,7 +879,8 @@ class TestInstance:
         else:                   msg += " !!!pids=%s!!!"%self.pids
         msg += " @%s"%self.pretty_timestamp()
         if self.broken_steps:
-            msg += " [BROKEN=" + " ".join( [ "%s@%s"%(s,i) for (i,s) in self.broken_steps ] ) + "]"
+            # sometimes we have an empty plcindex
+            msg += " [BROKEN=" + " ".join( [ "%s@%s"%(s,i) if i else s for (i,s) in self.broken_steps ] ) + "]"
         return msg
 
 class TestBox (Box):
@@ -796,9 +928,9 @@ class TestBox (Box):
 
     matcher_proc=re.compile (".*/proc/(?P<pid>[0-9]+)/cwd.*/root/(?P<buildname>[^/]+)$")
     matcher_grep=re.compile ("/root/(?P<buildname>[^/]+)/logs/trace.*:TRACE:\s*(?P<plcindex>[0-9]+).*step=(?P<step>\S+).*")
+    matcher_grep_missing=re.compile ("grep: /root/(?P<buildname>[^/]+)/logs/trace: No such file or directory")
     def sense (self, options):
         print 'tm',
-        self.sense_uptime()
         self.starting_ips=[x for x in self.backquote_ssh(['cat',Starting.location], trash_err=True).strip().split('\n') if x]
 
         # scan timestamps on all tests
@@ -817,10 +949,19 @@ class TestBox (Box):
                 t=self.add_timestamp(buildname,timestamp)
             except:  print 'WARNING, could not parse ts line',ts_line
 
-        command=['bash','-c',"grep KO /root/*/logs/trace-* /dev/null" ]
+        # let's try to be robust here -- tests that fail very early like e.g.
+        # "Cannot make space for a PLC instance: vplc IP pool exhausted", that occurs as part of provision
+        # will result in a 'trace' symlink to an inexisting 'trace-<>.txt' because no step has gone through
+        # simple 'trace' sohuld exist though as it is created by run_log
+        command=['bash','-c',"grep KO /root/*/logs/trace /dev/null 2>&1" ]
         trace_lines=self.backquote_ssh (command).split('\n')
         for line in trace_lines:
             if not line.strip(): continue
+            m=TestBox.matcher_grep_missing.match(line)
+            if m:
+                buildname=m.group('buildname')
+                self.add_broken(buildname,'','NO STEP DONE')
+                continue
             m=TestBox.matcher_grep.match(line)
             if m: 
                 buildname=m.group('buildname')
@@ -848,19 +989,30 @@ class TestBox (Box):
         
         
     def line (self):
-        return "%s (%s)"%(self.hostname,self.uptime())
+        return self.hostname_fedora()
 
-    def list (self):
-        if not self.test_instances:
-            header ("No known tests on %s"%self.line())
+    def list (self, verbose=False):
+        # verbose shows all tests
+        if verbose:
+            instances = self.test_instances
+            msg="tests"
         else:
-            header ("Known tests on %s"%self.line())
-            self.test_instances.sort(timestamp_sort)
-            for i in self.test_instances: print i.line()
+            instances = [ i for i in self.test_instances if i.is_running() ]
+            msg="running tests"
+
+        if not instances:
+            header ("No %s on %s"%(msg,self.line()))
+        else:
+            header ("%s on %s"%(msg,self.line()))
+            instances.sort(timestamp_sort)
+            for i in instances: print i.line()
+        # show 'starting' regardless of verbose
         if self.starting_ips:
             header ("Starting IP addresses on %s"%self.line())
             self.starting_ips.sort()
             for starting in self.starting_ips: print starting
+        else:
+            header ("Empty 'starting' on %s"%self.line())
 
 ############################################################
 class Options: pass
@@ -874,14 +1026,10 @@ class Substrate:
         self.options.reboot=False
         self.options.soft=False
         self.test_box = TestBox (self.test_box_spec())
-        self.build_boxes = [ BuildBox(h) for h in self.build_boxes_spec() ]
-        # for compat with older LocalSubstrate
-        try:
-            self.plc_vs_boxes = [ PlcVsBox (h,m) for (h,m) in self.plc_vs_boxes_spec ()]
-            self.plc_lxc_boxes = [ PlcLxcBox (h,m) for (h,m) in self.plc_lxc_boxes_spec ()]
-        except:
-            self.plc_vs_boxes = [ PlcVsBox (h,m) for (h,m) in self.plc_boxes_spec ()]
-            self.plc_lxc_boxes = [ ]
+        self.build_vs_boxes = [ BuildVsBox(h) for h in self.build_vs_boxes_spec() ]
+        self.build_lxc_boxes = [ BuildLxcBox(h) for h in self.build_lxc_boxes_spec() ]
+        self.plc_vs_boxes = [ PlcVsBox (h,m) for (h,m) in self.plc_vs_boxes_spec ()]
+        self.plc_lxc_boxes = [ PlcLxcBox (h,m) for (h,m) in self.plc_lxc_boxes_spec ()]
         self.qemu_boxes = [ QemuBox (h,m) for (h,m) in self.qemu_boxes_spec ()]
         self._sensed=False
 
@@ -890,13 +1038,23 @@ class Substrate:
         
         self.rescope (plcs_on_vs=plcs_on_vs, plcs_on_lxc=plcs_on_lxc)
 
-    def rescope(self, plcs_on_vs, plcs_on_lxc):
+    # which plc boxes are we interested in ?
+    def rescope (self, plcs_on_vs, plcs_on_lxc):
+        self.build_boxes = self.build_vs_boxes + self.build_lxc_boxes
         self.plc_boxes=[]
         if plcs_on_vs: self.plc_boxes += self.plc_vs_boxes
         if plcs_on_lxc: self.plc_boxes += self.plc_lxc_boxes
         self.default_boxes = self.plc_boxes + self.qemu_boxes
         self.all_boxes = self.build_boxes + [ self.test_box ] + self.plc_boxes + self.qemu_boxes
 
+    def summary_line (self):
+        msg  = "["
+        msg += " %d vp"%len(self.plc_vs_boxes)
+        msg += " %d xp"%len(self.plc_lxc_boxes)
+        msg += " %d tried plc boxes"%len(self.plc_boxes)
+        msg += "]"
+        return msg
+
     def fqdn (self, hostname):
         if hostname.find('.')<0: return "%s.%s"%(hostname,self.domain())
         return hostname
@@ -910,7 +1068,7 @@ class Substrate:
         self._sensed=True
         return True
 
-    def list (self):
+    def list (self, verbose=False):
         for b in self.default_boxes:
             b.list()
 
@@ -995,8 +1153,9 @@ class Substrate:
                 except:
                     msg=""
                     if not plc_boxname: msg += " PLC boxes are full"
-                    if not vplc_hostname: msg += " vplc IP pool exhausted" 
-                    raise Exception,"Could not make space for a PLC instance:"+msg
+                    if not vplc_hostname: msg += " vplc IP pool exhausted"
+                    msg += " %s"%self.summary_line()
+                    raise Exception,"Cannot make space for a PLC instance:"+msg
                 freed_plc_boxname=plc_instance_to_kill.plc_box.hostname
                 freed_vplc_hostname=plc_instance_to_kill.vplcname()
                 message='killing oldest plc instance = %s on %s'%(plc_instance_to_kill.line(),
@@ -1090,7 +1249,8 @@ class Substrate:
                         msg=""
                         if not qemu_boxname: msg += " QEMU boxes are full"
                         if not vnode_hostname: msg += " vnode IP pool exhausted" 
-                        raise Exception,"Could not make space for a QEMU instance:"+msg
+                        msg += " %s"%self.summary_line()
+                        raise Exception,"Cannot make space for a QEMU instance:"+msg
                     freed_qemu_boxname=qemu_instance_to_kill.qemu_box.hostname
                     freed_vnode_hostname=short_hostname(qemu_instance_to_kill.nodename)
                     # kill it
@@ -1113,6 +1273,7 @@ class Substrate:
             nodemap={'host_box':qemu_boxname,
                      'node_fields:hostname':vnode_fqdn,
                      'interface_fields:ip':ip, 
+                     'ipaddress_fields:ip_addr':ip, 
                      'interface_fields:mac':mac,
                      }
             nodemap.update(self.network_settings())
@@ -1141,8 +1302,10 @@ class Substrate:
     #################### show results for interactive mode
     def get_box (self,boxname):
         for b in self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box] :
-            if b.shortname()==boxname:
-                return b
+            if b.shortname()==boxname:                          return b
+            try:
+                if b.shortname()==boxname.split('.')[0]:        return b
+            except: pass
         print "Could not find box %s"%boxname
         return None
 
@@ -1156,7 +1319,7 @@ class Substrate:
         for box in box_or_names:
             if not isinstance(box,Box): box=self.get_box(box)
             if not box: continue
-            box.list()
+            box.list(self.options.verbose)
 
     def reboot_boxes(self,box_or_names):
         for box in box_or_names:
@@ -1165,7 +1328,7 @@ class Substrate:
             box.reboot(self.options)
 
     ####################
-    # can be run as a utility to manage the local infrastructure
+    # can be run as a utility to probe/display/manage the local infrastructure
     def main (self):
         parser=OptionParser()
         parser.add_option ('-r',"--reboot",action='store_true',dest='reboot',default=False,
@@ -1178,8 +1341,6 @@ class Substrate:
                            help='add build boxes')
         parser.add_option ('-p',"--plc",action='store_true',dest='plcs',default=False,
                            help='add plc boxes')
-        parser.add_option ('-X', "--lxc",action='store_true',dest='plcs_use_lxc',
-                           help='use lxc-enabled plc boxes instead of vs-enabled ones')
         parser.add_option ('-q',"--qemu",action='store_true',dest='qemus',default=False,
                            help='add qemu boxes') 
         parser.add_option ('-a',"--all",action='store_true',dest='all',default=False,
@@ -1190,8 +1351,7 @@ class Substrate:
                            help='dry run mode')
         (self.options,args)=parser.parse_args()
 
-        if self.options.plcs_use_lxc:
-            self.rescope (plcs_on_vs=False, plcs_on_lxc=True)
+        self.rescope (plcs_on_vs=True, plcs_on_lxc=True)
 
         boxes=args
         if self.options.testbox: boxes += [self.test_box]
@@ -1200,9 +1360,11 @@ class Substrate:
         if self.options.qemus: boxes += self.qemu_boxes
         if self.options.all: boxes += self.all_boxes
         
-        # default scope is -b -p -q
+        global verbose
+        verbose=self.options.verbose
+        # default scope is -b -p -q -t
         if not boxes:
-            boxes = self.build_boxes + self.plc_boxes + self.qemu_boxes
+            boxes = self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box]
 
         if self.options.reboot: self.reboot_boxes (boxes)
         else:                   self.list_boxes (boxes)