system/Substrate.py

   1 #
   2 # Thierry Parmentelat <thierry.parmentelat@inria.fr>
   3 # Copyright (C) 2010 INRIA
   4 #
   5 # #################### history
   6 #
   7 # see also Substrate.readme
   8 #
   9 # This is a complete rewrite of TestResources/Tracker/Pool
  10 # we don't use trackers anymore and just probe/sense the running
  11 # boxes to figure out where we are
  12 # in order to implement some fairness in the round-robin allocation scheme
  13 # we need an indication of the 'age' of each running entity,
  14 # hence the 'timestamp-*' steps in TestPlc
  15 #
  16 # this should be much more flexible:
  17 # * supports several plc boxes
  18 # * supports several qemu guests per host
  19 # * no need to worry about tracker being in sync or not
  20 #
  21 # #################### howto use
  22 #
  23 # each site is to write its own LocalSubstrate.py,
  24 # (see e.g. LocalSubstrate.inria.py)
  25 # LocalSubstrate.py is expected to be in /root on the testmaster box
  26 # and needs to define
  27 # MYPLCs
  28 # . the vserver-capable boxes used for hosting myplcs
  29 # .  and their admissible load (max # of myplcs)
  30 # . the pool of DNS-names and IP-addresses available for myplcs
  31 # QEMU nodes
  32 # . the kvm-qemu capable boxes to host qemu instances
  33 # .  and their admissible load (max # of myplcs)
  34 # . the pool of DNS-names and IP-addresses available for nodes
  35 #
  36 # #################### implem. note
  37 #
  38 # this model relies on 'sensing' the substrate,
  39 # i.e. probing all the boxes for their running instances of vservers and qemu
  40 # this is how we get rid of tracker inconsistencies
  41 # however there is a 'black hole' between the time where a given address is
  42 # allocated and when it actually gets used/pingable
  43 # this is why we still need a shared knowledge among running tests
  44 # in a file named /root/starting
  45 # this is connected to the Pool class
  46 #
  47 # ####################
  48
  49 import os.path, sys
  50 import time
  51 import re
  52 import traceback
  53 import subprocess
  54 import commands
  55 import socket
  56 from optparse import OptionParser
  57
  58 import utils
  59 from TestSsh import TestSsh
  60 from TestMapper import TestMapper
  61
  62 # too painful to propagate this cleanly
  63 verbose=None
  64
  65 def header (message,banner=True):
  66     if not message: return
  67     if banner: print "===============",
  68     print message
  69     sys.stdout.flush()
  70
  71 def timestamp_sort(o1,o2): return o1.timestamp-o2.timestamp
  72
  73 def short_hostname (hostname):
  74     return hostname.split('.')[0]
  75
  76 ####################
  77 # the place were other test instances tell about their not-yet-started
  78 # instances, that go undetected through sensing
  79 class Starting:
  80
  81     location='/root/starting'
  82     def __init__ (self):
  83         self.tuples=[]
  84
  85     def load (self):
  86         try:    self.tuples=[line.strip().split('@')
  87                              for line in file(Starting.location).readlines()]
  88         except: self.tuples=[]
  89
  90     def vnames (self) :
  91         self.load()
  92         return [ x for (x,_) in self.tuples ]
  93
  94     def add (self, vname, bname):
  95         if not vname in self.vnames():
  96             file(Starting.location,'a').write("%s@%s\n"%(vname,bname))
  97
  98     def delete_vname (self, vname):
  99         self.load()
 100         if vname in self.vnames():
 101             f=file(Starting.location,'w')
 102             for (v,b) in self.tuples:
 103                 if v != vname: f.write("%s@%s\n"%(v,b))
 104             f.close()
 105
 106 ####################
 107 # pool class
 108 # allows to pick an available IP among a pool
 109 # input is expressed as a list of tuples (hostname,ip,user_data)
 110 # that can be searched iteratively for a free slot
 111 # e.g.
 112 # pool = [ (hostname1,user_data1),
 113 #          (hostname2,user_data2),
 114 #          (hostname3,user_data2),
 115 #          (hostname4,user_data4) ]
 116 # assuming that ip1 and ip3 are taken (pingable), then we'd get
 117 # pool=Pool(pool)
 118 # pool.next_free() -> entry2
 119 # pool.next_free() -> entry4
 120 # pool.next_free() -> None
 121 # that is, even if ip2 is not busy/pingable when the second next_free() is issued
 122
 123 class PoolItem:
 124     def __init__ (self,hostname,userdata):
 125         self.hostname=hostname
 126         self.userdata=userdata
 127         # slot holds 'busy' or 'free' or 'mine' or 'starting' or None
 128         # 'mine' is for our own stuff, 'starting' from the concurrent tests
 129         self.status=None
 130         self.ip=None
 131
 132     def line(self):
 133         return "Pooled %s (%s) -> %s"%(self.hostname,self.userdata, self.status)
 134
 135     def char (self):
 136         if   self.status==None:       return '?'
 137         elif self.status=='busy':     return '+'
 138         elif self.status=='free':     return '-'
 139         elif self.status=='mine':     return 'M'
 140         elif self.status=='starting': return 'S'
 141
 142     def get_ip(self):
 143         if self.ip: return self.ip
 144         ip=socket.gethostbyname(self.hostname)
 145         self.ip=ip
 146         return ip
 147
 148 class Pool:
 149
 150     def __init__ (self, tuples,message, substrate):
 151         self.pool_items= [ PoolItem (hostname,userdata) for (hostname,userdata) in tuples ]
 152         self.message=message
 153         # where to send notifications upon load_starting
 154         self.substrate=substrate
 155
 156     def list (self, verbose=False):
 157         for i in self.pool_items: print i.line()
 158
 159     def line (self):
 160         line=self.message
 161         for i in self.pool_items: line += ' ' + i.char()
 162         return line
 163
 164     def _item (self, hostname):
 165         for i in self.pool_items:
 166             if i.hostname==hostname: return i
 167         raise Exception ("Could not locate hostname %s in pool %s"%(hostname,self.message))
 168
 169     def retrieve_userdata (self, hostname):
 170         return self._item(hostname).userdata
 171
 172     def get_ip (self, hostname):
 173         try:    return self._item(hostname).get_ip()
 174         except: return socket.gethostbyname(hostname)
 175
 176     def set_mine (self, hostname):
 177         try:
 178             self._item(hostname).status='mine'
 179         except:
 180             print 'WARNING: host %s not found in IP pool %s'%(hostname,self.message)
 181
 182     def next_free (self):
 183         for i in self.pool_items:
 184             if i.status == 'free':
 185                 i.status='mine'
 186                 return (i.hostname,i.userdata)
 187         return None
 188
 189     ####################
 190     # we have a starting instance of our own
 191     def add_starting (self, vname, bname):
 192         Starting().add(vname,bname)
 193         for i in self.pool_items:
 194             if i.hostname==vname: i.status='mine'
 195
 196     # load the starting instances from the common file
 197     # remember that might be ours
 198     # return the list of (vname,bname) that are not ours
 199     def load_starting (self):
 200         starting=Starting()
 201         starting.load()
 202         new_tuples=[]
 203         for (v,b) in starting.tuples:
 204             for i in self.pool_items:
 205                 if i.hostname==v and i.status=='free':
 206                     i.status='starting'
 207                     new_tuples.append( (v,b,) )
 208         return new_tuples
 209
 210     def release_my_starting (self):
 211         for i in self.pool_items:
 212             if i.status=='mine':
 213                 Starting().delete_vname (i.hostname)
 214                 i.status=None
 215
 216
 217     ##########
 218     def _sense (self):
 219         for item in self.pool_items:
 220             if item.status is not None:
 221                 print item.char(),
 222                 continue
 223             if self.check_ping (item.hostname):
 224                 item.status='busy'
 225                 print '*',
 226             else:
 227                 item.status='free'
 228                 print '.',
 229
 230     def sense (self):
 231         print 'Sensing IP pool',self.message,
 232         self._sense()
 233         print 'Done'
 234         for (vname,bname) in self.load_starting():
 235             self.substrate.add_starting_dummy (bname, vname)
 236         print "After having loaded 'starting': IP pool"
 237         print self.line()
 238     # OS-dependent ping option (support for macos, for convenience)
 239     ping_timeout_option = None
 240     # returns True when a given hostname/ip responds to ping
 241     def check_ping (self,hostname):
 242         if not Pool.ping_timeout_option:
 243             (status,osname) = commands.getstatusoutput("uname -s")
 244             if status != 0:
 245                 raise Exception, "TestPool: Cannot figure your OS name"
 246             if osname == "Linux":
 247                 Pool.ping_timeout_option="-w"
 248             elif osname == "Darwin":
 249                 Pool.ping_timeout_option="-t"
 250
 251         command="ping -c 1 %s 1 %s"%(Pool.ping_timeout_option,hostname)
 252         (status,output) = commands.getstatusoutput(command)
 253         return status == 0
 254
 255 ####################
 256 class Box:
 257     def __init__ (self,hostname):
 258         self.hostname=hostname
 259         self._probed=None
 260     def shortname (self):
 261         return short_hostname(self.hostname)
 262     def test_ssh (self): return TestSsh(self.hostname,username='root',unknown_host=False)
 263     def reboot (self, options):
 264         self.test_ssh().run("shutdown -r now",message="Rebooting %s"%self.hostname,
 265                             dry_run=options.dry_run)
 266
 267     def hostname_fedora (self,virt=None):
 268         result = "%s {"%self.hostname
 269         if virt: result += "%s-"%virt
 270         result += "%s"%self.fedora()
 271         # too painful to propagate this cleanly
 272         global verbose
 273         if verbose:
 274             result += "-%s" % self.uname()
 275         result += "}"
 276         return result
 277
 278     separator = "===composite==="
 279
 280     # probe the ssh link
 281     # take this chance to gather useful stuff
 282     def probe (self):
 283         # try it only once
 284         if self._probed is not None: return self._probed
 285         composite_command = [ ]
 286         composite_command += [ "hostname" ]
 287         composite_command += [ ";" , "echo", Box.separator , ";" ]
 288         composite_command += [ "uptime" ]
 289         composite_command += [ ";" , "echo", Box.separator , ";" ]
 290         composite_command += [ "uname", "-r"]
 291         composite_command += [ ";" , "echo", Box.separator , ";" ]
 292         composite_command += [ "cat" , "/etc/fedora-release" ]
 293
 294         # due to colons and all, this is going wrong on the local box (typically testmaster)
 295         # I am reluctant to change TestSsh as it might break all over the place, so
 296         if self.test_ssh().is_local():
 297             probe_argv = [ "bash", "-c", " ".join (composite_command) ]
 298         else:
 299             probe_argv=self.test_ssh().actual_argv(composite_command)
 300         composite=self.backquote ( probe_argv, trash_err=True )
 301         self._hostname = self._uptime = self._uname = self._fedora = "** Unknown **"
 302         if not composite:
 303             print "root@%s unreachable"%self.hostname
 304             self._probed=''
 305         else:
 306             try:
 307                 pieces = composite.split(Box.separator)
 308                 pieces = [ x.strip() for x in pieces ]
 309                 [self._hostname, self._uptime, self._uname, self._fedora] = pieces
 310                 # customize
 311                 self._uptime = ', '.join([ x.strip() for x in self._uptime.split(',')[2:]])
 312                 self._fedora = self._fedora.replace("Fedora release ","f").split(" ")[0]
 313             except:
 314                 import traceback
 315                 print 'BEG issue with pieces',pieces
 316                 traceback.print_exc()
 317                 print 'END issue with pieces',pieces
 318             self._probed=self._hostname
 319         return self._probed
 320
 321     # use argv=['bash','-c',"the command line"]
 322     def uptime(self):
 323         self.probe()
 324         if hasattr(self,'_uptime') and self._uptime: return self._uptime
 325         return '*unprobed* uptime'
 326     def uname(self):
 327         self.probe()
 328         if hasattr(self,'_uname') and self._uname: return self._uname
 329         return '*unprobed* uname'
 330     def fedora(self):
 331         self.probe()
 332         if hasattr(self,'_fedora') and self._fedora: return self._fedora
 333         return '*unprobed* fedora'
 334
 335     def run(self,argv,message=None,trash_err=False,dry_run=False):
 336         if dry_run:
 337             print 'DRY_RUN:',
 338             print " ".join(argv)
 339             return 0
 340         else:
 341             header(message)
 342             if not trash_err:
 343                 return subprocess.call(argv)
 344             else:
 345                 return subprocess.call(argv,stderr=file('/dev/null','w'))
 346
 347     def run_ssh (self, argv, message, trash_err=False, dry_run=False):
 348         ssh_argv = self.test_ssh().actual_argv(argv)
 349         result=self.run (ssh_argv, message, trash_err, dry_run=dry_run)
 350         if result!=0:
 351             print "WARNING: failed to run %s on %s"%(" ".join(argv),self.hostname)
 352         return result
 353
 354     def backquote (self, argv, trash_err=False):
 355         # print 'running backquote',argv
 356         if not trash_err:
 357             result= subprocess.Popen(argv,stdout=subprocess.PIPE).communicate()[0]
 358         else:
 359             result= subprocess.Popen(argv,stdout=subprocess.PIPE,stderr=file('/dev/null','w')).communicate()[0]
 360         return result
 361
 362     # if you have any shell-expanded arguments like *
 363     # and if there's any chance the command is adressed to the local host
 364     def backquote_ssh (self, argv, trash_err=False):
 365         if not self.probe(): return ''
 366         return self.backquote( self.test_ssh().actual_argv(argv), trash_err)
 367
 368 ############################################################
 369 class BuildInstance:
 370     def __init__ (self, buildname, pid, buildbox):
 371         self.buildname=buildname
 372         self.buildbox=buildbox
 373         self.pids=[pid]
 374
 375     def add_pid(self,pid):
 376         self.pids.append(pid)
 377
 378     def line (self):
 379         return "== %s == (pids=%r)"%(self.buildname,self.pids)
 380
 381 class BuildBox (Box):
 382     def __init__ (self,hostname):
 383         Box.__init__(self,hostname)
 384         self.build_instances=[]
 385
 386     def add_build (self,buildname,pid):
 387         for build in self.build_instances:
 388             if build.buildname==buildname:
 389                 build.add_pid(pid)
 390                 return
 391         self.build_instances.append(BuildInstance(buildname, pid, self))
 392
 393     def list(self, verbose=False):
 394         if not self.build_instances:
 395             header ('No build process on %s (%s)'%(self.hostname_fedora(),self.uptime()))
 396         else:
 397             header ("Builds on %s (%s)"%(self.hostname_fedora(),self.uptime()))
 398             for b in self.build_instances:
 399                 header (b.line(),banner=False)
 400
 401     def reboot (self, options):
 402         if not options.soft:
 403             Box.reboot(self,options)
 404         else:
 405             self.soft_reboot (options)
 406
 407 build_matcher=re.compile("\s*(?P<pid>[0-9]+).*-[bo]\s+(?P<buildname>[^\s]+)(\s|\Z)")
 408 build_matcher_initvm=re.compile("\s*(?P<pid>[0-9]+).*initvm.*\s+(?P<buildname>[^\s]+)\s*\Z")
 409
 410 class BuildLxcBox (BuildBox):
 411     def soft_reboot (self, options):
 412             command=['pkill','lbuild']
 413             self.run_ssh(command,"Terminating vbuild processes",dry_run=options.dry_run)
 414
 415     # inspect box and find currently running builds
 416     def sense(self, options):
 417         print 'xb',
 418         pids=self.backquote_ssh(['pgrep','lbuild'],trash_err=True)
 419         if not pids: return
 420         command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
 421         ps_lines=self.backquote_ssh (command).split('\n')
 422         for line in ps_lines:
 423             if not line.strip() or line.find('PID')>=0: continue
 424             m=build_matcher.match(line)
 425             if m:
 426                 date=time.strftime('%Y-%m-%d',time.localtime(time.time()))
 427                 buildname=m.group('buildname').replace('@DATE@',date)
 428                 self.add_build (buildname,m.group('pid'))
 429                 continue
 430             m=build_matcher_initvm.match(line)
 431             if m:
 432                 # buildname is expansed here
 433                 self.add_build (buildname,m.group('pid'))
 434                 continue
 435             header('BuildLxcBox.sense: command %r returned line that failed to match'%command)
 436             header(">>%s<<"%line)
 437
 438 ############################################################
 439 class PlcInstance:
 440     def __init__ (self, plcbox):
 441         self.plc_box=plcbox
 442         # unknown yet
 443         self.timestamp=0
 444
 445     def set_timestamp (self,timestamp): self.timestamp=timestamp
 446     def set_now (self): self.timestamp=int(time.time())
 447     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 448
 449 class PlcLxcInstance (PlcInstance):
 450     # does lxc have a context id of any kind ?
 451     def __init__ (self, plcbox, lxcname, pid):
 452         PlcInstance.__init__(self, plcbox)
 453         self.lxcname = lxcname
 454         self.pid = pid
 455
 456     def vplcname (self):
 457         return self.lxcname.split('-')[-1]
 458     def buildname (self):
 459         return self.lxcname.rsplit('-',2)[0]
 460
 461     def line (self):
 462         msg="== %s =="%(self.vplcname())
 463         msg += " [=%s]"%self.lxcname
 464         if self.pid==-1:  msg+=" not (yet?) running"
 465         else:              msg+=" (pid=%s)"%self.pid
 466         if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
 467         else:              msg += " *unknown timestamp*"
 468         return msg
 469
 470     def kill (self):
 471         command="rsync lxc-driver.sh  %s:/root"%self.plc_box.hostname
 472         commands.getstatusoutput(command)
 473         msg="lxc container stopping %s on %s"%(self.lxcname,self.plc_box.hostname)
 474         self.plc_box.run_ssh(['/root/lxc-driver.sh','-c','stop_lxc','-n',self.lxcname],msg)
 475         self.plc_box.forget(self)
 476
 477 ##########
 478 class PlcBox (Box):
 479     def __init__ (self, hostname, max_plcs):
 480         Box.__init__(self,hostname)
 481         self.plc_instances=[]
 482         self.max_plcs=max_plcs
 483
 484     def free_slots (self):
 485         return self.max_plcs - len(self.plc_instances)
 486
 487     # fill one slot even though this one is not started yet
 488     def add_dummy (self, plcname):
 489         dummy=PlcLxcInstance(self,'dummy_'+plcname,0)
 490         dummy.set_now()
 491         self.plc_instances.append(dummy)
 492
 493     def forget (self, plc_instance):
 494         self.plc_instances.remove(plc_instance)
 495
 496     def reboot (self, options):
 497         if not options.soft:
 498             Box.reboot(self,options)
 499         else:
 500             self.soft_reboot (options)
 501
 502     def list(self, verbose=False):
 503         if not self.plc_instances:
 504             header ('No plc running on %s'%(self.line()))
 505         else:
 506             header ("Active plc VMs on %s"%self.line())
 507             self.plc_instances.sort(timestamp_sort)
 508             for p in self.plc_instances:
 509                 header (p.line(),banner=False)
 510
 511 ## we do not this at INRIA any more
 512 class PlcLxcBox (PlcBox):
 513
 514     def add_lxc (self,lxcname,pid):
 515         for plc in self.plc_instances:
 516             if plc.lxcname==lxcname:
 517                 header("WARNING, duplicate myplc %s running on %s"%\
 518                            (lxcname,self.hostname),banner=False)
 519                 return
 520         self.plc_instances.append(PlcLxcInstance(self,lxcname,pid))
 521
 522
 523     # a line describing the box
 524     def line(self):
 525         return "%s [max=%d,free=%d] (%s)"%(self.hostname_fedora(virt="lxc"),
 526                                            self.max_plcs,self.free_slots(),
 527                                            self.uptime(),
 528                                            )
 529
 530     def plc_instance_by_lxcname (self, lxcname):
 531         for p in self.plc_instances:
 532             if p.lxcname==lxcname: return p
 533         return None
 534
 535     # essentially shutdown all running containers
 536     def soft_reboot (self, options):
 537         command="rsync lxc-driver.sh  %s:/root"%self.hostname
 538         commands.getstatusoutput(command)
 539         self.run_ssh(['/root/lxc-driver.sh','-c','stop_all'],"Stopping all running lxc containers on %s"%(self.hostname,),
 540                      dry_run=options.dry_run)
 541
 542
 543     # sense is expected to fill self.plc_instances with PlcLxcInstance's
 544     # to describe the currently running VM's
 545     def sense (self, options):
 546         print "xp",
 547         command="rsync lxc-driver.sh  %s:/root"%self.hostname
 548         commands.getstatusoutput(command)
 549         command=['/root/lxc-driver.sh','-c','sense_all']
 550         lxc_stat = self.backquote_ssh (command)
 551         for lxc_line in lxc_stat.split("\n"):
 552             if not lxc_line: continue
 553             lxcname=lxc_line.split(";")[0]
 554             pid=lxc_line.split(";")[1]
 555             timestamp=lxc_line.split(";")[2]
 556             self.add_lxc(lxcname,pid)
 557             try: timestamp=int(timestamp)
 558             except: timestamp=0
 559             p=self.plc_instance_by_lxcname(lxcname)
 560             if not p:
 561                 print 'WARNING zombie plc',self.hostname,lxcname
 562                 print '... was expecting',lxcname,'in',[i.lxcname for i in self.plc_instances]
 563                 continue
 564             p.set_timestamp(timestamp)
 565
 566 ############################################################
 567 class QemuInstance:
 568     def __init__ (self, nodename, pid, qemubox):
 569         self.nodename=nodename
 570         self.pid=pid
 571         self.qemu_box=qemubox
 572         # not known yet
 573         self.buildname=None
 574         self.timestamp=0
 575
 576     def set_buildname (self,buildname): self.buildname=buildname
 577     def set_timestamp (self,timestamp): self.timestamp=timestamp
 578     def set_now (self): self.timestamp=int(time.time())
 579     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 580
 581     def line (self):
 582         msg = "== %s =="%(short_hostname(self.nodename))
 583         msg += " [=%s]"%self.buildname
 584         if self.pid:       msg += " (pid=%s)"%self.pid
 585         else:              msg += " not (yet?) running"
 586         if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
 587         else:              msg += " *unknown timestamp*"
 588         return msg
 589
 590     def kill(self):
 591         if self.pid==0:
 592             print "cannot kill qemu %s with pid==0"%self.nodename
 593             return
 594         msg="Killing qemu %s with pid=%s on box %s"%(self.nodename,self.pid,self.qemu_box.hostname)
 595         self.qemu_box.run_ssh(['kill',"%s"%self.pid],msg)
 596         self.qemu_box.forget(self)
 597
 598
 599 class QemuBox (Box):
 600     def __init__ (self, hostname, max_qemus):
 601         Box.__init__(self,hostname)
 602         self.qemu_instances=[]
 603         self.max_qemus=max_qemus
 604
 605     def add_node (self,nodename,pid):
 606         for qemu in self.qemu_instances:
 607             if qemu.nodename==nodename:
 608                 header("WARNING, duplicate qemu %s running on %s"%\
 609                            (nodename,self.hostname), banner=False)
 610                 return
 611         self.qemu_instances.append(QemuInstance(nodename,pid,self))
 612
 613     def forget (self, qemu_instance):
 614         self.qemu_instances.remove(qemu_instance)
 615
 616     # fill one slot even though this one is not started yet
 617     def add_dummy (self, nodename):
 618         dummy=QemuInstance('dummy_'+nodename,0,self)
 619         dummy.set_now()
 620         self.qemu_instances.append(dummy)
 621
 622     def line (self):
 623         return "%s [max=%d,free=%d] (%s) %s"%(
 624             self.hostname_fedora(virt="qemu"), self.max_qemus,self.free_slots(),
 625             self.uptime(),self.driver())
 626
 627     def list(self, verbose=False):
 628         if not self.qemu_instances:
 629             header ('No qemu on %s'%(self.line()))
 630         else:
 631             header ("Qemus on %s"%(self.line()))
 632             self.qemu_instances.sort(timestamp_sort)
 633             for q in self.qemu_instances:
 634                 header (q.line(),banner=False)
 635
 636     def free_slots (self):
 637         return self.max_qemus - len(self.qemu_instances)
 638
 639     def driver(self):
 640         if hasattr(self,'_driver') and self._driver: return self._driver
 641         return '*undef* driver'
 642
 643     def qemu_instance_by_pid (self,pid):
 644         for q in self.qemu_instances:
 645             if q.pid==pid: return q
 646         return None
 647
 648     def qemu_instance_by_nodename_buildname (self,nodename,buildname):
 649         for q in self.qemu_instances:
 650             if q.nodename==nodename and q.buildname==buildname:
 651                 return q
 652         return None
 653
 654     def reboot (self, options):
 655         if not options.soft:
 656             Box.reboot(self,options)
 657         else:
 658             self.run_ssh(['pkill','qemu'],"Killing qemu instances",
 659                          dry_run=options.dry_run)
 660
 661     matcher=re.compile("\s*(?P<pid>[0-9]+).*-cdrom\s+(?P<nodename>[^\s]+)\.iso")
 662     def sense(self, options):
 663         print 'qn',
 664         modules=self.backquote_ssh(['lsmod']).split('\n')
 665         self._driver='*NO kqemu/kvm_intel MODULE LOADED*'
 666         for module in modules:
 667             if module.find('kqemu')==0:
 668                 self._driver='kqemu module loaded'
 669             # kvm might be loaded without kvm_intel (we dont have AMD)
 670             elif module.find('kvm_intel')==0:
 671                 self._driver='kvm_intel OK'
 672         ########## find out running pids
 673         pids=self.backquote_ssh(['pgrep','qemu'])
 674         if not pids: return
 675         command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
 676         ps_lines = self.backquote_ssh (command).split("\n")
 677         for line in ps_lines:
 678             if not line.strip() or line.find('PID') >=0 : continue
 679             m=QemuBox.matcher.match(line)
 680             if m:
 681                 self.add_node (m.group('nodename'),m.group('pid'))
 682                 continue
 683             header('QemuBox.sense: command %r returned line that failed to match'%command)
 684             header(">>%s<<"%line)
 685         ########## retrieve alive instances and map to build
 686         live_builds=[]
 687         command=['grep','.','/vservers/*/*/qemu.pid','/dev/null']
 688         pid_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 689         for pid_line in pid_lines:
 690             if not pid_line.strip(): continue
 691             # expect <build>/<nodename>/qemu.pid:<pid>pid
 692             try:
 693                 (_,__,buildname,nodename,tail)=pid_line.split('/')
 694                 (_,pid)=tail.split(':')
 695                 q=self.qemu_instance_by_pid (pid)
 696                 if not q: continue
 697                 q.set_buildname(buildname)
 698                 live_builds.append(buildname)
 699             except: print 'WARNING, could not parse pid line',pid_line
 700         # retrieve timestamps
 701         if not live_builds: return
 702         command=   ['grep','.']
 703         command += ['/vservers/%s/*/timestamp'%b for b in live_builds]
 704         command += ['/dev/null']
 705         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 706         for ts_line in ts_lines:
 707             if not ts_line.strip(): continue
 708             # expect <build>/<nodename>/timestamp:<timestamp>
 709             try:
 710                 (_,__,buildname,nodename,tail)=ts_line.split('/')
 711                 nodename=nodename.replace('qemu-','')
 712                 (_,timestamp)=tail.split(':')
 713                 timestamp=int(timestamp)
 714                 q=self.qemu_instance_by_nodename_buildname(nodename,buildname)
 715                 if not q:
 716                     print 'WARNING zombie qemu',self.hostname,ts_line
 717                     print '... was expecting (',short_hostname(nodename),buildname,') in',\
 718                         [ (short_hostname(i.nodename),i.buildname) for i in self.qemu_instances ]
 719                     continue
 720                 q.set_timestamp(timestamp)
 721             except:  print 'WARNING, could not parse ts line',ts_line
 722
 723 ####################
 724 class TestInstance:
 725     def __init__ (self, buildname, pid=0):
 726         self.pids=[]
 727         if pid!=0: self.pid.append(pid)
 728         self.buildname=buildname
 729         # latest trace line
 730         self.trace=''
 731         # has a KO test
 732         self.broken_steps=[]
 733         self.timestamp = 0
 734
 735     def set_timestamp (self,timestamp): self.timestamp=timestamp
 736     def set_now (self): self.timestamp=int(time.time())
 737     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 738
 739     def is_running (self): return len(self.pids) != 0
 740
 741     def add_pid (self,pid):
 742         self.pids.append(pid)
 743     def set_broken (self, plcindex, step):
 744         self.broken_steps.append ( (plcindex, step,) )
 745
 746     def second_letter (self):
 747         if not self.broken_steps: return '='
 748         else:
 749             really_broken = [ step for (i,step) in self.broken_steps if '_ignore' not in step ]
 750             # W is for warning like what's in the build mail
 751             if len(really_broken)==0: return 'W'
 752             else: return 'B'
 753
 754     def line (self):
 755         # make up a 2-letter sign
 756         # first letter : '=', unless build is running : '*'
 757         double = '*' if self.pids else '='
 758         # second letter : '=' if fine, 'W' for warnings (only ignored steps) 'B' for broken
 759         letter2 = self.second_letter()
 760         double += letter2
 761         msg = " %s %s =="%(double,self.buildname)
 762         if not self.pids:       pass
 763         elif len(self.pids)==1: msg += " (pid=%s)"%self.pids[0]
 764         else:                   msg += " !!!pids=%s!!!"%self.pids
 765         msg += " @%s"%self.pretty_timestamp()
 766         if letter2 != '=':
 767             msg2 = ( ' BROKEN' if letter2 == 'B' else ' WARNING' )
 768             # sometimes we have an empty plcindex
 769             msg += " [%s="%msg2 + " ".join( [ "%s@%s"%(s,i) if i else s for (i,s) in self.broken_steps ] ) + "]"
 770         return msg
 771
 772 class TestBox (Box):
 773     def __init__ (self,hostname):
 774         Box.__init__(self,hostname)
 775         self.starting_ips=[]
 776         self.test_instances=[]
 777
 778     def reboot (self, options):
 779         # can't reboot a vserver VM
 780         self.run_ssh (['pkill','run_log'],"Terminating current runs",
 781                       dry_run=options.dry_run)
 782         self.run_ssh (['rm','-f',Starting.location],"Cleaning %s"%Starting.location,
 783                       dry_run=options.dry_run)
 784
 785     def get_test (self, buildname):
 786         for i in self.test_instances:
 787             if i.buildname==buildname: return i
 788
 789     # we scan ALL remaining test results, even the ones not running
 790     def add_timestamp (self, buildname, timestamp):
 791         i=self.get_test(buildname)
 792         if i:
 793             i.set_timestamp(timestamp)
 794         else:
 795             i=TestInstance(buildname,0)
 796             i.set_timestamp(timestamp)
 797             self.test_instances.append(i)
 798
 799     def add_running_test (self, pid, buildname):
 800         i=self.get_test(buildname)
 801         if not i:
 802             self.test_instances.append (TestInstance (buildname,pid))
 803             return
 804         if i.pids:
 805             print "WARNING: 2 concurrent tests run on same build %s"%buildname
 806         i.add_pid (pid)
 807
 808     def add_broken (self, buildname, plcindex, step):
 809         i=self.get_test(buildname)
 810         if not i:
 811             i=TestInstance(buildname)
 812             self.test_instances.append(i)
 813         i.set_broken(plcindex, step)
 814
 815     matcher_proc=re.compile (".*/proc/(?P<pid>[0-9]+)/cwd.*/root/(?P<buildname>[^/]+)$")
 816     matcher_grep=re.compile ("/root/(?P<buildname>[^/]+)/logs/trace.*:TRACE:\s*(?P<plcindex>[0-9]+).*step=(?P<step>\S+).*")
 817     matcher_grep_missing=re.compile ("grep: /root/(?P<buildname>[^/]+)/logs/trace: No such file or directory")
 818     def sense (self, options):
 819         print 'tm',
 820         self.starting_ips=[x for x in self.backquote_ssh(['cat',Starting.location], trash_err=True).strip().split('\n') if x]
 821
 822         # scan timestamps on all tests
 823         # this is likely to not invoke ssh so we need to be a bit smarter to get * expanded
 824         # xxx would make sense above too
 825         command=['bash','-c',"grep . /root/*/timestamp /dev/null"]
 826         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 827         for ts_line in ts_lines:
 828             if not ts_line.strip(): continue
 829             # expect /root/<buildname>/timestamp:<timestamp>
 830             try:
 831                 (ts_file,timestamp)=ts_line.split(':')
 832                 ts_file=os.path.dirname(ts_file)
 833                 buildname=os.path.basename(ts_file)
 834                 timestamp=int(timestamp)
 835                 t=self.add_timestamp(buildname,timestamp)
 836             except:  print 'WARNING, could not parse ts line',ts_line
 837
 838         # let's try to be robust here -- tests that fail very early like e.g.
 839         # "Cannot make space for a PLC instance: vplc IP pool exhausted", that occurs as part of provision
 840         # will result in a 'trace' symlink to an inexisting 'trace-<>.txt' because no step has gone through
 841         # simple 'trace' should exist though as it is created by run_log
 842         command=['bash','-c',"grep KO /root/*/logs/trace /dev/null 2>&1" ]
 843         trace_lines=self.backquote_ssh (command).split('\n')
 844         for line in trace_lines:
 845             if not line.strip(): continue
 846             m=TestBox.matcher_grep_missing.match(line)
 847             if m:
 848                 buildname=m.group('buildname')
 849                 self.add_broken(buildname,'','NO STEP DONE')
 850                 continue
 851             m=TestBox.matcher_grep.match(line)
 852             if m:
 853                 buildname=m.group('buildname')
 854                 plcindex=m.group('plcindex')
 855                 step=m.group('step')
 856                 self.add_broken(buildname,plcindex, step)
 857                 continue
 858             header("TestBox.sense: command %r returned line that failed to match\n%s"%(command,line))
 859             header(">>%s<<"%line)
 860
 861         pids = self.backquote_ssh (['pgrep','run_log'],trash_err=True)
 862         if not pids: return
 863         command=['ls','-ld'] + ["/proc/%s/cwd"%pid for pid in pids.split("\n") if pid]
 864         ps_lines=self.backquote_ssh (command).split('\n')
 865         for line in ps_lines:
 866             if not line.strip(): continue
 867             m=TestBox.matcher_proc.match(line)
 868             if m:
 869                 pid=m.group('pid')
 870                 buildname=m.group('buildname')
 871                 self.add_running_test(pid, buildname)
 872                 continue
 873             header("TestBox.sense: command %r returned line that failed to match\n%s"%(command,line))
 874             header(">>%s<<"%line)
 875
 876
 877     def line (self):
 878         return self.hostname_fedora()
 879
 880     def list (self, verbose=False):
 881         # verbose shows all tests
 882         if verbose:
 883             instances = self.test_instances
 884             msg="tests"
 885         else:
 886             instances = [ i for i in self.test_instances if i.is_running() ]
 887             msg="running tests"
 888
 889         if not instances:
 890             header ("No %s on %s"%(msg,self.line()))
 891         else:
 892             header ("%s on %s"%(msg,self.line()))
 893             instances.sort(timestamp_sort)
 894             for i in instances: print i.line()
 895         # show 'starting' regardless of verbose
 896         if self.starting_ips:
 897             header ("Starting IP addresses on %s"%self.line())
 898             self.starting_ips.sort()
 899             for starting in self.starting_ips: print starting
 900         else:
 901             header ("Empty 'starting' on %s"%self.line())
 902
 903 ############################################################
 904 class Options: pass
 905
 906 class Substrate:
 907
 908     def __init__ (self):
 909         self.options=Options()
 910         self.options.dry_run=False
 911         self.options.verbose=False
 912         self.options.reboot=False
 913         self.options.soft=False
 914         self.test_box = TestBox (self.test_box_spec())
 915         self.build_lxc_boxes = [ BuildLxcBox(h) for h in self.build_lxc_boxes_spec() ]
 916         self.plc_lxc_boxes = [ PlcLxcBox (h,m) for (h,m) in self.plc_lxc_boxes_spec ()]
 917         self.qemu_boxes = [ QemuBox (h,m) for (h,m) in self.qemu_boxes_spec ()]
 918         self._sensed=False
 919
 920         self.vplc_pool = Pool (self.vplc_ips(),"for vplcs",self)
 921         self.vnode_pool = Pool (self.vnode_ips(),"for vnodes",self)
 922
 923         self.build_boxes = self.build_lxc_boxes
 924         self.plc_boxes = self.plc_lxc_boxes
 925         self.default_boxes = self.plc_boxes + self.qemu_boxes
 926         self.all_boxes = self.build_boxes + [ self.test_box ] + self.plc_boxes + self.qemu_boxes
 927
 928     def summary_line (self):
 929         msg  = "["
 930         msg += " %d xp"%len(self.plc_lxc_boxes)
 931         msg += " %d tried plc boxes"%len(self.plc_boxes)
 932         msg += "]"
 933         return msg
 934
 935     def fqdn (self, hostname):
 936         if hostname.find('.')<0: return "%s.%s"%(hostname,self.domain())
 937         return hostname
 938
 939     # return True if actual sensing takes place
 940     def sense (self,force=False):
 941         if self._sensed and not force: return False
 942         print 'Sensing local substrate...',
 943         for b in self.default_boxes: b.sense(self.options)
 944         print 'Done'
 945         self._sensed=True
 946         return True
 947
 948     def list (self, verbose=False):
 949         for b in self.default_boxes:
 950             b.list()
 951
 952     def add_dummy_plc (self, plc_boxname, plcname):
 953         for pb in self.plc_boxes:
 954             if pb.hostname==plc_boxname:
 955                 pb.add_dummy(plcname)
 956                 return True
 957     def add_dummy_qemu (self, qemu_boxname, qemuname):
 958         for qb in self.qemu_boxes:
 959             if qb.hostname==qemu_boxname:
 960                 qb.add_dummy(qemuname)
 961                 return True
 962
 963     def add_starting_dummy (self, bname, vname):
 964         return self.add_dummy_plc (bname, vname) or self.add_dummy_qemu (bname, vname)
 965
 966     ##########
 967     def provision (self,plcs,options):
 968         try:
 969             # attach each plc to a plc box and an IP address
 970             plcs = [ self.provision_plc (plc,options) for plc in plcs ]
 971             # attach each node/qemu to a qemu box with an IP address
 972             plcs = [ self.provision_qemus (plc,options) for plc in plcs ]
 973             # update the SFA spec accordingly
 974             plcs = [ self.localize_sfa_rspec(plc,options) for plc in plcs ]
 975             self.list()
 976             return plcs
 977         except Exception, e:
 978             print '* Could not provision this test on current substrate','--',e,'--','exiting'
 979             traceback.print_exc()
 980             sys.exit(1)
 981
 982     # it is expected that a couple of options like ips_bplc and ips_vplc
 983     # are set or unset together
 984     @staticmethod
 985     def check_options (x,y):
 986         if not x and not y: return True
 987         return len(x)==len(y)
 988
 989     # find an available plc box (or make space)
 990     # and a free IP address (using options if present)
 991     def provision_plc (self, plc, options):
 992
 993         assert Substrate.check_options (options.ips_bplc, options.ips_vplc)
 994
 995         #### let's find an IP address for that plc
 996         # look in options
 997         if options.ips_vplc:
 998             # this is a rerun
 999             # we don't check anything here,
1000             # it is the caller's responsability to cleanup and make sure this makes sense
1001             plc_boxname = options.ips_bplc.pop()
1002             vplc_hostname=options.ips_vplc.pop()
1003         else:
1004             if self.sense(): self.list()
1005             plc_boxname=None
1006             vplc_hostname=None
1007             # try to find an available IP
1008             self.vplc_pool.sense()
1009             couple=self.vplc_pool.next_free()
1010             if couple:
1011                 (vplc_hostname,unused)=couple
1012             #### we need to find one plc box that still has a slot
1013             max_free=0
1014             # use the box that has max free spots for load balancing
1015             for pb in self.plc_boxes:
1016                 free=pb.free_slots()
1017                 if free>max_free:
1018                     plc_boxname=pb.hostname
1019                     max_free=free
1020             # if there's no available slot in the plc_boxes, or we need a free IP address
1021             # make space by killing the oldest running instance
1022             if not plc_boxname or not vplc_hostname:
1023                 # find the oldest of all our instances
1024                 all_plc_instances=reduce(lambda x, y: x+y,
1025                                          [ pb.plc_instances for pb in self.plc_boxes ],
1026                                          [])
1027                 all_plc_instances.sort(timestamp_sort)
1028                 try:
1029                     plc_instance_to_kill=all_plc_instances[0]
1030                 except:
1031                     msg=""
1032                     if not plc_boxname: msg += " PLC boxes are full"
1033                     if not vplc_hostname: msg += " vplc IP pool exhausted"
1034                     msg += " %s"%self.summary_line()
1035                     raise Exception,"Cannot make space for a PLC instance:"+msg
1036                 freed_plc_boxname=plc_instance_to_kill.plc_box.hostname
1037                 freed_vplc_hostname=plc_instance_to_kill.vplcname()
1038                 message='killing oldest plc instance = %s on %s'%(plc_instance_to_kill.line(),
1039                                                                   freed_plc_boxname)
1040                 plc_instance_to_kill.kill()
1041                 # use this new plcbox if that was the problem
1042                 if not plc_boxname:
1043                     plc_boxname=freed_plc_boxname
1044                 # ditto for the IP address
1045                 if not vplc_hostname:
1046                     vplc_hostname=freed_vplc_hostname
1047                     # record in pool as mine
1048                     self.vplc_pool.set_mine(vplc_hostname)
1049
1050         #
1051         self.add_dummy_plc(plc_boxname,plc['name'])
1052         vplc_ip = self.vplc_pool.get_ip(vplc_hostname)
1053         self.vplc_pool.add_starting(vplc_hostname, plc_boxname)
1054
1055         #### compute a helpful vserver name
1056         # remove domain in hostname
1057         vplc_short = short_hostname(vplc_hostname)
1058         vservername = "%s-%d-%s" % (options.buildname,plc['index'],vplc_short)
1059         plc_name = "%s_%s"%(plc['name'],vplc_short)
1060
1061         utils.header( 'PROVISION plc %s in box %s at IP %s as %s'%\
1062                           (plc['name'],plc_boxname,vplc_hostname,vservername))
1063
1064         #### apply in the plc_spec
1065         # # informative
1066         # label=options.personality.replace("linux","")
1067         mapper = {'plc': [ ('*' , {'host_box':plc_boxname,
1068                                    # 'name':'%s-'+label,
1069                                    'name': plc_name,
1070                                    'vservername':vservername,
1071                                    'vserverip':vplc_ip,
1072                                    'PLC_DB_HOST':vplc_hostname,
1073                                    'PLC_API_HOST':vplc_hostname,
1074                                    'PLC_BOOT_HOST':vplc_hostname,
1075                                    'PLC_WWW_HOST':vplc_hostname,
1076                                    'PLC_NET_DNS1' : self.network_settings() [ 'interface_fields:dns1' ],
1077                                    'PLC_NET_DNS2' : self.network_settings() [ 'interface_fields:dns2' ],
1078                                    } ) ]
1079                   }
1080
1081
1082         # mappers only work on a list of plcs
1083         return TestMapper([plc],options).map(mapper)[0]
1084
1085     ##########
1086     def provision_qemus (self, plc, options):
1087
1088         assert Substrate.check_options (options.ips_bnode, options.ips_vnode)
1089
1090         test_mapper = TestMapper ([plc], options)
1091         nodenames = test_mapper.node_names()
1092         maps=[]
1093         for nodename in nodenames:
1094
1095             if options.ips_vnode:
1096                 # as above, it's a rerun, take it for granted
1097                 qemu_boxname=options.ips_bnode.pop()
1098                 vnode_hostname=options.ips_vnode.pop()
1099             else:
1100                 if self.sense(): self.list()
1101                 qemu_boxname=None
1102                 vnode_hostname=None
1103                 # try to find an available IP
1104                 self.vnode_pool.sense()
1105                 couple=self.vnode_pool.next_free()
1106                 if couple:
1107                     (vnode_hostname,unused)=couple
1108                 # find a physical box
1109                 max_free=0
1110                 # use the box that has max free spots for load balancing
1111                 for qb in self.qemu_boxes:
1112                     free=qb.free_slots()
1113                     if free>max_free:
1114                         qemu_boxname=qb.hostname
1115                         max_free=free
1116                 # if we miss the box or the IP, kill the oldest instance
1117                 if not qemu_boxname or not vnode_hostname:
1118                 # find the oldest of all our instances
1119                     all_qemu_instances=reduce(lambda x, y: x+y,
1120                                               [ qb.qemu_instances for qb in self.qemu_boxes ],
1121                                               [])
1122                     all_qemu_instances.sort(timestamp_sort)
1123                     try:
1124                         qemu_instance_to_kill=all_qemu_instances[0]
1125                     except:
1126                         msg=""
1127                         if not qemu_boxname: msg += " QEMU boxes are full"
1128                         if not vnode_hostname: msg += " vnode IP pool exhausted"
1129                         msg += " %s"%self.summary_line()
1130                         raise Exception,"Cannot make space for a QEMU instance:"+msg
1131                     freed_qemu_boxname=qemu_instance_to_kill.qemu_box.hostname
1132                     freed_vnode_hostname=short_hostname(qemu_instance_to_kill.nodename)
1133                     # kill it
1134                     message='killing oldest qemu node = %s on %s'%(qemu_instance_to_kill.line(),
1135                                                                    freed_qemu_boxname)
1136                     qemu_instance_to_kill.kill()
1137                     # use these freed resources where needed
1138                     if not qemu_boxname:
1139                         qemu_boxname=freed_qemu_boxname
1140                     if not vnode_hostname:
1141                         vnode_hostname=freed_vnode_hostname
1142                         self.vnode_pool.set_mine(vnode_hostname)
1143
1144             self.add_dummy_qemu (qemu_boxname,vnode_hostname)
1145             mac=self.vnode_pool.retrieve_userdata(vnode_hostname)
1146             ip=self.vnode_pool.get_ip (vnode_hostname)
1147             self.vnode_pool.add_starting(vnode_hostname,qemu_boxname)
1148
1149             vnode_fqdn = self.fqdn(vnode_hostname)
1150             nodemap={'host_box':qemu_boxname,
1151                      'node_fields:hostname':vnode_fqdn,
1152                      'interface_fields:ip':ip,
1153                      'ipaddress_fields:ip_addr':ip,
1154                      'interface_fields:mac':mac,
1155                      }
1156             nodemap.update(self.network_settings())
1157             maps.append ( (nodename, nodemap) )
1158
1159             utils.header("PROVISION node %s in box %s at IP %s with MAC %s"%\
1160                              (nodename,qemu_boxname,vnode_hostname,mac))
1161
1162         return test_mapper.map({'node':maps})[0]
1163
1164     def localize_sfa_rspec (self,plc,options):
1165
1166         plc['sfa']['SFA_REGISTRY_HOST'] = plc['PLC_DB_HOST']
1167         plc['sfa']['SFA_AGGREGATE_HOST'] = plc['PLC_DB_HOST']
1168         plc['sfa']['SFA_SM_HOST'] = plc['PLC_DB_HOST']
1169         plc['sfa']['SFA_DB_HOST'] = plc['PLC_DB_HOST']
1170         plc['sfa']['SFA_PLC_URL'] = 'https://' + plc['PLC_API_HOST'] + ':443/PLCAPI/'
1171         return plc
1172
1173     #################### release:
1174     def release (self,options):
1175         self.vplc_pool.release_my_starting()
1176         self.vnode_pool.release_my_starting()
1177         pass
1178
1179     #################### show results for interactive mode
1180     def get_box (self,boxname):
1181         for b in self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box] :
1182             if b.shortname()==boxname:                          return b
1183             try:
1184                 if b.shortname()==boxname.split('.')[0]:        return b
1185             except: pass
1186         print "Could not find box %s"%boxname
1187         return None
1188
1189     def list_boxes(self,box_or_names):
1190         print 'Sensing',
1191         for box in box_or_names:
1192             if not isinstance(box,Box): box=self.get_box(box)
1193             if not box: continue
1194             box.sense(self.options)
1195         print 'Done'
1196         for box in box_or_names:
1197             if not isinstance(box,Box): box=self.get_box(box)
1198             if not box: continue
1199             box.list(self.options.verbose)
1200
1201     def reboot_boxes(self,box_or_names):
1202         for box in box_or_names:
1203             if not isinstance(box,Box): box=self.get_box(box)
1204             if not box: continue
1205             box.reboot(self.options)
1206
1207     ####################
1208     # can be run as a utility to probe/display/manage the local infrastructure
1209     def main (self):
1210         parser=OptionParser()
1211         parser.add_option ('-r',"--reboot",action='store_true',dest='reboot',default=False,
1212                            help='reboot mode (use shutdown -r)')
1213         parser.add_option ('-s',"--soft",action='store_true',dest='soft',default=False,
1214                            help='soft mode for reboot (terminates processes)')
1215         parser.add_option ('-t',"--testbox",action='store_true',dest='testbox',default=False,
1216                            help='add test box')
1217         parser.add_option ('-b',"--build",action='store_true',dest='builds',default=False,
1218                            help='add build boxes')
1219         parser.add_option ('-p',"--plc",action='store_true',dest='plcs',default=False,
1220                            help='add plc boxes')
1221         parser.add_option ('-q',"--qemu",action='store_true',dest='qemus',default=False,
1222                            help='add qemu boxes')
1223         parser.add_option ('-a',"--all",action='store_true',dest='all',default=False,
1224                            help='address all known  boxes, like -b -t -p -q')
1225         parser.add_option ('-v',"--verbose",action='store_true',dest='verbose',default=False,
1226                            help='verbose mode')
1227         parser.add_option ('-n',"--dry_run",action='store_true',dest='dry_run',default=False,
1228                            help='dry run mode')
1229         (self.options,args)=parser.parse_args()
1230
1231         boxes=args
1232         if self.options.testbox: boxes += [self.test_box]
1233         if self.options.builds: boxes += self.build_boxes
1234         if self.options.plcs: boxes += self.plc_boxes
1235         if self.options.qemus: boxes += self.qemu_boxes
1236         if self.options.all: boxes += self.all_boxes
1237
1238         global verbose
1239         verbose=self.options.verbose
1240         # default scope is -b -p -q -t
1241         if not boxes:
1242             boxes = self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box]
1243
1244         if self.options.reboot: self.reboot_boxes (boxes)
1245         else:                   self.list_boxes (boxes)