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 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 BuildVsBox (BuildBox):
 411     def soft_reboot (self, options):
 412             command=['pkill','vbuild']
 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 'vb',
 418         pids=self.backquote_ssh(['pgrep','vbuild'],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('BuildVsBox.sense: command %r returned line that failed to match'%command)
 436             header(">>%s<<"%line)
 437
 438 class BuildLxcBox (BuildBox):
 439     def soft_reboot (self, options):
 440             command=['pkill','lbuild']
 441             self.run_ssh(command,"Terminating vbuild processes",dry_run=options.dry_run)
 442
 443     # inspect box and find currently running builds
 444     def sense(self, options):
 445         print 'xb'
 446         pids=self.backquote_ssh(['pgrep','lbuild'],trash_err=True)
 447         if not pids: return
 448         command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
 449         ps_lines=self.backquote_ssh (command).split('\n')
 450         for line in ps_lines:
 451             if not line.strip() or line.find('PID')>=0: continue
 452             m=build_matcher.match(line)
 453             if m:
 454                 date=time.strftime('%Y-%m-%d',time.localtime(time.time()))
 455                 buildname=m.group('buildname').replace('@DATE@',date)
 456                 self.add_build (buildname,m.group('pid'))
 457                 continue
 458             m=build_matcher_initvm.match(line)
 459             if m:
 460                 # buildname is expansed here
 461                 self.add_build (buildname,m.group('pid'))
 462                 continue
 463             header('BuildLxcBox.sense: command %r returned line that failed to match'%command)
 464             header(">>%s<<"%line)
 465
 466 ############################################################
 467 class PlcInstance:
 468     def __init__ (self, plcbox):
 469         self.plc_box=plcbox
 470         # unknown yet
 471         self.timestamp=0
 472
 473     def set_timestamp (self,timestamp): self.timestamp=timestamp
 474     def set_now (self): self.timestamp=int(time.time())
 475     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 476
 477 class PlcVsInstance (PlcInstance):
 478     def __init__ (self, plcbox, vservername, ctxid):
 479         PlcInstance.__init__(self,plcbox)
 480         self.vservername=vservername
 481         self.ctxid=ctxid
 482
 483     def vplcname (self):
 484         return self.vservername.split('-')[-1]
 485     def buildname (self):
 486         return self.vservername.rsplit('-',2)[0]
 487
 488     def line (self):
 489         msg="== %s =="%(self.vplcname())
 490         msg += " [=%s]"%self.vservername
 491         if self.ctxid==0:  msg+=" not (yet?) running"
 492         else:              msg+=" (ctx=%s)"%self.ctxid
 493         if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
 494         else:              msg += " *unknown timestamp*"
 495         return msg
 496
 497     def kill (self):
 498         msg="vserver stopping %s on %s"%(self.vservername,self.plc_box.hostname)
 499         self.plc_box.run_ssh(['vserver',self.vservername,'stop'],msg)
 500         self.plc_box.forget(self)
 501
 502 class PlcLxcInstance (PlcInstance):
 503     # does lxc have a context id of any kind ?
 504     def __init__ (self, plcbox, lxcname, pid):
 505         PlcInstance.__init__(self, plcbox)
 506         self.lxcname = lxcname
 507         self.pid = pid
 508
 509     def vplcname (self):
 510         return self.lxcname.split('-')[-1]
 511     def buildname (self):
 512         return self.lxcname.rsplit('-',2)[0]
 513
 514     def line (self):
 515         msg="== %s =="%(self.vplcname())
 516         msg += " [=%s]"%self.lxcname
 517         if self.pid==-1:  msg+=" not (yet?) running"
 518         else:              msg+=" (pid=%s)"%self.pid
 519         if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
 520         else:              msg += " *unknown timestamp*"
 521         return msg
 522
 523     def kill (self):
 524         command="rsync lxc-driver.sh  %s:/root"%self.plc_box.hostname
 525         commands.getstatusoutput(command)
 526         msg="lxc container stopping %s on %s"%(self.lxcname,self.plc_box.hostname)
 527         self.plc_box.run_ssh(['/root/lxc-driver.sh','-c','stop_lxc','-n',self.lxcname],msg)
 528         self.plc_box.forget(self)
 529
 530 ##########
 531 class PlcBox (Box):
 532     def __init__ (self, hostname, max_plcs):
 533         Box.__init__(self,hostname)
 534         self.plc_instances=[]
 535         self.max_plcs=max_plcs
 536
 537     def free_slots (self):
 538         return self.max_plcs - len(self.plc_instances)
 539
 540     # fill one slot even though this one is not started yet
 541     def add_dummy (self, plcname):
 542         dummy=PlcVsInstance(self,'dummy_'+plcname,0)
 543         dummy.set_now()
 544         self.plc_instances.append(dummy)
 545
 546     def forget (self, plc_instance):
 547         self.plc_instances.remove(plc_instance)
 548
 549     def reboot (self, options):
 550         if not options.soft:
 551             Box.reboot(self,options)
 552         else:
 553             self.soft_reboot (options)
 554
 555     def list(self, verbose=False):
 556         if not self.plc_instances:
 557             header ('No plc running on %s'%(self.line()))
 558         else:
 559             header ("Active plc VMs on %s"%self.line())
 560             self.plc_instances.sort(timestamp_sort)
 561             for p in self.plc_instances:
 562                 header (p.line(),banner=False)
 563
 564 # we do not this at INRIA any more
 565 class PlcVsBox (PlcBox):
 566
 567     def add_vserver (self,vservername,ctxid):
 568         for plc in self.plc_instances:
 569             if plc.vservername==vservername:
 570                 header("WARNING, duplicate myplc %s running on %s"%\
 571                            (vservername,self.hostname),banner=False)
 572                 return
 573         self.plc_instances.append(PlcVsInstance(self,vservername,ctxid))
 574
 575     def line(self):
 576         msg="%s [max=%d,free=%d] (%s)"%(self.hostname_fedora(virt="vs"), self.max_plcs,self.free_slots(),self.uptime())
 577         return msg
 578
 579     def plc_instance_by_vservername (self, vservername):
 580         for p in self.plc_instances:
 581             if p.vservername==vservername: return p
 582         return None
 583
 584     def soft_reboot (self, options):
 585         self.run_ssh(['service','util-vserver','stop'],"Stopping all running vservers on %s"%(self.hostname,),
 586                      dry_run=options.dry_run)
 587
 588     def sense (self, options):
 589         print 'vp',
 590         # try to find fullname (vserver_stat truncates to a ridiculously short name)
 591         # fetch the contexts for all vservers on that box
 592         map_command=['grep','.','/etc/vservers/*/context','/dev/null',]
 593         context_map=self.backquote_ssh (map_command)
 594         # at this point we have a set of lines like
 595         # /etc/vservers/2010.01.20--k27-f12-32-vplc03/context:40144
 596         ctx_dict={}
 597         for map_line in context_map.split("\n"):
 598             if not map_line: continue
 599             [path,xid] = map_line.split(':')
 600             ctx_dict[xid]=os.path.basename(os.path.dirname(path))
 601         # at this point ctx_id maps context id to vservername
 602
 603         command=['vserver-stat']
 604         vserver_stat = self.backquote_ssh (command)
 605         for vserver_line in vserver_stat.split("\n"):
 606             if not vserver_line: continue
 607             context=vserver_line.split()[0]
 608             if context=="CTX": continue
 609             try:
 610                 longname=ctx_dict[context]
 611                 self.add_vserver(longname,context)
 612             except:
 613                 print 'WARNING: found ctx %s in vserver_stat but was unable to figure a corresp. vserver'%context
 614
 615         # scan timestamps
 616         running_vsnames = [ i.vservername for i in self.plc_instances ]
 617         command=   ['grep','.']
 618         command += ['/vservers/%s.timestamp'%vs for vs in running_vsnames]
 619         command += ['/dev/null']
 620         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 621         for ts_line in ts_lines:
 622             if not ts_line.strip(): continue
 623             # expect /vservers/<vservername>.timestamp:<timestamp>
 624             try:
 625                 (ts_file,timestamp)=ts_line.split(':')
 626                 ts_file=os.path.basename(ts_file)
 627                 (vservername,_)=os.path.splitext(ts_file)
 628                 timestamp=int(timestamp)
 629                 p=self.plc_instance_by_vservername(vservername)
 630                 if not p:
 631                     print 'WARNING zombie plc',self.hostname,ts_line
 632                     print '... was expecting',vservername,'in',[i.vservername for i in self.plc_instances]
 633                     continue
 634                 p.set_timestamp(timestamp)
 635             except:  print 'WARNING, could not parse ts line',ts_line
 636
 637
 638 class PlcLxcBox (PlcBox):
 639
 640     def add_lxc (self,lxcname,pid):
 641         for plc in self.plc_instances:
 642             if plc.lxcname==lxcname:
 643                 header("WARNING, duplicate myplc %s running on %s"%\
 644                            (lxcname,self.hostname),banner=False)
 645                 return
 646         self.plc_instances.append(PlcLxcInstance(self,lxcname,pid))
 647
 648
 649     # a line describing the box
 650     def line(self):
 651         return "%s [max=%d,free=%d] (%s)"%(self.hostname_fedora(virt="lxc"),
 652                                            self.max_plcs,self.free_slots(),
 653                                            self.uptime(),
 654                                            )
 655
 656     def plc_instance_by_lxcname (self, lxcname):
 657         for p in self.plc_instances:
 658             if p.lxcname==lxcname: return p
 659         return None
 660
 661     # essentially shutdown all running containers
 662     def soft_reboot (self, options):
 663         command="rsync lxc-driver.sh  %s:/root"%self.hostname
 664         commands.getstatusoutput(command)
 665         self.run_ssh(['/root/lxc-driver.sh','-c','stop_all'],"Stopping all running lxc containers on %s"%(self.hostname,),
 666                      dry_run=options.dry_run)
 667
 668
 669     # sense is expected to fill self.plc_instances with PlcLxcInstance's
 670     # to describe the currently running VM's
 671     def sense (self, options):
 672         print "xp",
 673         command="rsync lxc-driver.sh  %s:/root"%self.hostname
 674         commands.getstatusoutput(command)
 675         command=['/root/lxc-driver.sh','-c','sense_all']
 676         lxc_stat = self.backquote_ssh (command)
 677         for lxc_line in lxc_stat.split("\n"):
 678             if not lxc_line: continue
 679             lxcname=lxc_line.split(";")[0]
 680             pid=lxc_line.split(";")[1]
 681             timestamp=lxc_line.split(";")[2]
 682             self.add_lxc(lxcname,pid)
 683             try: timestamp=int(timestamp)
 684             except: timestamp=0
 685             p=self.plc_instance_by_lxcname(lxcname)
 686             if not p:
 687                 print 'WARNING zombie plc',self.hostname,lxcname
 688                 print '... was expecting',lxcname,'in',[i.lxcname for i in self.plc_instances]
 689                 continue
 690             p.set_timestamp(timestamp)
 691
 692 ############################################################
 693 class QemuInstance:
 694     def __init__ (self, nodename, pid, qemubox):
 695         self.nodename=nodename
 696         self.pid=pid
 697         self.qemu_box=qemubox
 698         # not known yet
 699         self.buildname=None
 700         self.timestamp=0
 701
 702     def set_buildname (self,buildname): self.buildname=buildname
 703     def set_timestamp (self,timestamp): self.timestamp=timestamp
 704     def set_now (self): self.timestamp=int(time.time())
 705     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 706
 707     def line (self):
 708         msg = "== %s =="%(short_hostname(self.nodename))
 709         msg += " [=%s]"%self.buildname
 710         if self.pid:       msg += " (pid=%s)"%self.pid
 711         else:              msg += " not (yet?) running"
 712         if self.timestamp: msg += " @ %s"%self.pretty_timestamp()
 713         else:              msg += " *unknown timestamp*"
 714         return msg
 715
 716     def kill(self):
 717         if self.pid==0:
 718             print "cannot kill qemu %s with pid==0"%self.nodename
 719             return
 720         msg="Killing qemu %s with pid=%s on box %s"%(self.nodename,self.pid,self.qemu_box.hostname)
 721         self.qemu_box.run_ssh(['kill',"%s"%self.pid],msg)
 722         self.qemu_box.forget(self)
 723
 724
 725 class QemuBox (Box):
 726     def __init__ (self, hostname, max_qemus):
 727         Box.__init__(self,hostname)
 728         self.qemu_instances=[]
 729         self.max_qemus=max_qemus
 730
 731     def add_node (self,nodename,pid):
 732         for qemu in self.qemu_instances:
 733             if qemu.nodename==nodename:
 734                 header("WARNING, duplicate qemu %s running on %s"%\
 735                            (nodename,self.hostname), banner=False)
 736                 return
 737         self.qemu_instances.append(QemuInstance(nodename,pid,self))
 738
 739     def forget (self, qemu_instance):
 740         self.qemu_instances.remove(qemu_instance)
 741
 742     # fill one slot even though this one is not started yet
 743     def add_dummy (self, nodename):
 744         dummy=QemuInstance('dummy_'+nodename,0,self)
 745         dummy.set_now()
 746         self.qemu_instances.append(dummy)
 747
 748     def line (self):
 749         return "%s [max=%d,free=%d] (%s) %s"%(
 750             self.hostname_fedora(virt="qemu"), self.max_qemus,self.free_slots(),
 751             self.uptime(),self.driver())
 752
 753     def list(self, verbose=False):
 754         if not self.qemu_instances:
 755             header ('No qemu on %s'%(self.line()))
 756         else:
 757             header ("Qemus on %s"%(self.line()))
 758             self.qemu_instances.sort(timestamp_sort)
 759             for q in self.qemu_instances:
 760                 header (q.line(),banner=False)
 761
 762     def free_slots (self):
 763         return self.max_qemus - len(self.qemu_instances)
 764
 765     def driver(self):
 766         if hasattr(self,'_driver') and self._driver: return self._driver
 767         return '*undef* driver'
 768
 769     def qemu_instance_by_pid (self,pid):
 770         for q in self.qemu_instances:
 771             if q.pid==pid: return q
 772         return None
 773
 774     def qemu_instance_by_nodename_buildname (self,nodename,buildname):
 775         for q in self.qemu_instances:
 776             if q.nodename==nodename and q.buildname==buildname:
 777                 return q
 778         return None
 779
 780     def reboot (self, options):
 781         if not options.soft:
 782             Box.reboot(self,options)
 783         else:
 784             self.run_ssh(['pkill','qemu'],"Killing qemu instances",
 785                          dry_run=options.dry_run)
 786
 787     matcher=re.compile("\s*(?P<pid>[0-9]+).*-cdrom\s+(?P<nodename>[^\s]+)\.iso")
 788     def sense(self, options):
 789         print 'qn',
 790         modules=self.backquote_ssh(['lsmod']).split('\n')
 791         self._driver='*NO kqemu/kvm_intel MODULE LOADED*'
 792         for module in modules:
 793             if module.find('kqemu')==0:
 794                 self._driver='kqemu module loaded'
 795             # kvm might be loaded without kvm_intel (we dont have AMD)
 796             elif module.find('kvm_intel')==0:
 797                 self._driver='kvm_intel OK'
 798         ########## find out running pids
 799         pids=self.backquote_ssh(['pgrep','qemu'])
 800         if not pids: return
 801         command=['ps','-o','pid,command'] + [ pid for pid in pids.split("\n") if pid]
 802         ps_lines = self.backquote_ssh (command).split("\n")
 803         for line in ps_lines:
 804             if not line.strip() or line.find('PID') >=0 : continue
 805             m=QemuBox.matcher.match(line)
 806             if m:
 807                 self.add_node (m.group('nodename'),m.group('pid'))
 808                 continue
 809             header('QemuBox.sense: command %r returned line that failed to match'%command)
 810             header(">>%s<<"%line)
 811         ########## retrieve alive instances and map to build
 812         live_builds=[]
 813         command=['grep','.','/vservers/*/*/qemu.pid','/dev/null']
 814         pid_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 815         for pid_line in pid_lines:
 816             if not pid_line.strip(): continue
 817             # expect <build>/<nodename>/qemu.pid:<pid>pid
 818             try:
 819                 (_,__,buildname,nodename,tail)=pid_line.split('/')
 820                 (_,pid)=tail.split(':')
 821                 q=self.qemu_instance_by_pid (pid)
 822                 if not q: continue
 823                 q.set_buildname(buildname)
 824                 live_builds.append(buildname)
 825             except: print 'WARNING, could not parse pid line',pid_line
 826         # retrieve timestamps
 827         if not live_builds: return
 828         command=   ['grep','.']
 829         command += ['/vservers/%s/*/timestamp'%b for b in live_builds]
 830         command += ['/dev/null']
 831         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 832         for ts_line in ts_lines:
 833             if not ts_line.strip(): continue
 834             # expect <build>/<nodename>/timestamp:<timestamp>
 835             try:
 836                 (_,__,buildname,nodename,tail)=ts_line.split('/')
 837                 nodename=nodename.replace('qemu-','')
 838                 (_,timestamp)=tail.split(':')
 839                 timestamp=int(timestamp)
 840                 q=self.qemu_instance_by_nodename_buildname(nodename,buildname)
 841                 if not q:
 842                     print 'WARNING zombie qemu',self.hostname,ts_line
 843                     print '... was expecting (',short_hostname(nodename),buildname,') in',\
 844                         [ (short_hostname(i.nodename),i.buildname) for i in self.qemu_instances ]
 845                     continue
 846                 q.set_timestamp(timestamp)
 847             except:  print 'WARNING, could not parse ts line',ts_line
 848
 849 ####################
 850 class TestInstance:
 851     def __init__ (self, buildname, pid=0):
 852         self.pids=[]
 853         if pid!=0: self.pid.append(pid)
 854         self.buildname=buildname
 855         # latest trace line
 856         self.trace=''
 857         # has a KO test
 858         self.broken_steps=[]
 859         self.timestamp = 0
 860
 861     def set_timestamp (self,timestamp): self.timestamp=timestamp
 862     def set_now (self): self.timestamp=int(time.time())
 863     def pretty_timestamp (self): return time.strftime("%Y-%m-%d:%H-%M",time.localtime(self.timestamp))
 864
 865     def is_running (self): return len(self.pids) != 0
 866
 867     def add_pid (self,pid):
 868         self.pids.append(pid)
 869     def set_broken (self, plcindex, step):
 870         self.broken_steps.append ( (plcindex, step,) )
 871
 872     def line (self):
 873         double='=='
 874         if self.pids: double='*'+double[1]
 875         if self.broken_steps: double=double[0]+'B'
 876         msg = " %s %s =="%(double,self.buildname)
 877         if not self.pids:       pass
 878         elif len(self.pids)==1: msg += " (pid=%s)"%self.pids[0]
 879         else:                   msg += " !!!pids=%s!!!"%self.pids
 880         msg += " @%s"%self.pretty_timestamp()
 881         if self.broken_steps:
 882             # sometimes we have an empty plcindex
 883             msg += " [BROKEN=" + " ".join( [ "%s@%s"%(s,i) if i else s for (i,s) in self.broken_steps ] ) + "]"
 884         return msg
 885
 886 class TestBox (Box):
 887     def __init__ (self,hostname):
 888         Box.__init__(self,hostname)
 889         self.starting_ips=[]
 890         self.test_instances=[]
 891
 892     def reboot (self, options):
 893         # can't reboot a vserver VM
 894         self.run_ssh (['pkill','run_log'],"Terminating current runs",
 895                       dry_run=options.dry_run)
 896         self.run_ssh (['rm','-f',Starting.location],"Cleaning %s"%Starting.location,
 897                       dry_run=options.dry_run)
 898
 899     def get_test (self, buildname):
 900         for i in self.test_instances:
 901             if i.buildname==buildname: return i
 902
 903     # we scan ALL remaining test results, even the ones not running
 904     def add_timestamp (self, buildname, timestamp):
 905         i=self.get_test(buildname)
 906         if i:
 907             i.set_timestamp(timestamp)
 908         else:
 909             i=TestInstance(buildname,0)
 910             i.set_timestamp(timestamp)
 911             self.test_instances.append(i)
 912
 913     def add_running_test (self, pid, buildname):
 914         i=self.get_test(buildname)
 915         if not i:
 916             self.test_instances.append (TestInstance (buildname,pid))
 917             return
 918         if i.pids:
 919             print "WARNING: 2 concurrent tests run on same build %s"%buildname
 920         i.add_pid (pid)
 921
 922     def add_broken (self, buildname, plcindex, step):
 923         i=self.get_test(buildname)
 924         if not i:
 925             i=TestInstance(buildname)
 926             self.test_instances.append(i)
 927         i.set_broken(plcindex, step)
 928
 929     matcher_proc=re.compile (".*/proc/(?P<pid>[0-9]+)/cwd.*/root/(?P<buildname>[^/]+)$")
 930     matcher_grep=re.compile ("/root/(?P<buildname>[^/]+)/logs/trace.*:TRACE:\s*(?P<plcindex>[0-9]+).*step=(?P<step>\S+).*")
 931     matcher_grep_missing=re.compile ("grep: /root/(?P<buildname>[^/]+)/logs/trace: No such file or directory")
 932     def sense (self, options):
 933         print 'tm',
 934         self.starting_ips=[x for x in self.backquote_ssh(['cat',Starting.location], trash_err=True).strip().split('\n') if x]
 935
 936         # scan timestamps on all tests
 937         # this is likely to not invoke ssh so we need to be a bit smarter to get * expanded
 938         # xxx would make sense above too
 939         command=['bash','-c',"grep . /root/*/timestamp /dev/null"]
 940         ts_lines=self.backquote_ssh(command,trash_err=True).split('\n')
 941         for ts_line in ts_lines:
 942             if not ts_line.strip(): continue
 943             # expect /root/<buildname>/timestamp:<timestamp>
 944             try:
 945                 (ts_file,timestamp)=ts_line.split(':')
 946                 ts_file=os.path.dirname(ts_file)
 947                 buildname=os.path.basename(ts_file)
 948                 timestamp=int(timestamp)
 949                 t=self.add_timestamp(buildname,timestamp)
 950             except:  print 'WARNING, could not parse ts line',ts_line
 951
 952         # let's try to be robust here -- tests that fail very early like e.g.
 953         # "Cannot make space for a PLC instance: vplc IP pool exhausted", that occurs as part of provision
 954         # will result in a 'trace' symlink to an inexisting 'trace-<>.txt' because no step has gone through
 955         # simple 'trace' sohuld exist though as it is created by run_log
 956         command=['bash','-c',"grep KO /root/*/logs/trace /dev/null 2>&1" ]
 957         trace_lines=self.backquote_ssh (command).split('\n')
 958         for line in trace_lines:
 959             if not line.strip(): continue
 960             m=TestBox.matcher_grep_missing.match(line)
 961             if m:
 962                 buildname=m.group('buildname')
 963                 self.add_broken(buildname,'','NO STEP DONE')
 964                 continue
 965             m=TestBox.matcher_grep.match(line)
 966             if m:
 967                 buildname=m.group('buildname')
 968                 plcindex=m.group('plcindex')
 969                 step=m.group('step')
 970                 self.add_broken(buildname,plcindex, step)
 971                 continue
 972             header("TestBox.sense: command %r returned line that failed to match\n%s"%(command,line))
 973             header(">>%s<<"%line)
 974
 975         pids = self.backquote_ssh (['pgrep','run_log'],trash_err=True)
 976         if not pids: return
 977         command=['ls','-ld'] + ["/proc/%s/cwd"%pid for pid in pids.split("\n") if pid]
 978         ps_lines=self.backquote_ssh (command).split('\n')
 979         for line in ps_lines:
 980             if not line.strip(): continue
 981             m=TestBox.matcher_proc.match(line)
 982             if m:
 983                 pid=m.group('pid')
 984                 buildname=m.group('buildname')
 985                 self.add_running_test(pid, buildname)
 986                 continue
 987             header("TestBox.sense: command %r returned line that failed to match\n%s"%(command,line))
 988             header(">>%s<<"%line)
 989
 990
 991     def line (self):
 992         return self.hostname_fedora()
 993
 994     def list (self, verbose=False):
 995         # verbose shows all tests
 996         if verbose:
 997             instances = self.test_instances
 998             msg="tests"
 999         else:
1000             instances = [ i for i in self.test_instances if i.is_running() ]
1001             msg="running tests"
1002
1003         if not instances:
1004             header ("No %s on %s"%(msg,self.line()))
1005         else:
1006             header ("%s on %s"%(msg,self.line()))
1007             instances.sort(timestamp_sort)
1008             for i in instances: print i.line()
1009         # show 'starting' regardless of verbose
1010         if self.starting_ips:
1011             header ("Starting IP addresses on %s"%self.line())
1012             self.starting_ips.sort()
1013             for starting in self.starting_ips: print starting
1014         else:
1015             header ("Empty 'starting' on %s"%self.line())
1016
1017 ############################################################
1018 class Options: pass
1019
1020 class Substrate:
1021
1022     def __init__ (self, plcs_on_vs=True, plcs_on_lxc=False):
1023         self.options=Options()
1024         self.options.dry_run=False
1025         self.options.verbose=False
1026         self.options.reboot=False
1027         self.options.soft=False
1028         self.test_box = TestBox (self.test_box_spec())
1029         self.build_vs_boxes = [ BuildVsBox(h) for h in self.build_vs_boxes_spec() ]
1030         self.build_lxc_boxes = [ BuildLxcBox(h) for h in self.build_lxc_boxes_spec() ]
1031         self.plc_vs_boxes = [ PlcVsBox (h,m) for (h,m) in self.plc_vs_boxes_spec ()]
1032         self.plc_lxc_boxes = [ PlcLxcBox (h,m) for (h,m) in self.plc_lxc_boxes_spec ()]
1033         self.qemu_boxes = [ QemuBox (h,m) for (h,m) in self.qemu_boxes_spec ()]
1034         self._sensed=False
1035
1036         self.vplc_pool = Pool (self.vplc_ips(),"for vplcs",self)
1037         self.vnode_pool = Pool (self.vnode_ips(),"for vnodes",self)
1038
1039         self.rescope (plcs_on_vs=plcs_on_vs, plcs_on_lxc=plcs_on_lxc)
1040
1041     # which plc boxes are we interested in ?
1042     def rescope (self, plcs_on_vs, plcs_on_lxc):
1043         self.build_boxes = self.build_vs_boxes + self.build_lxc_boxes
1044         self.plc_boxes=[]
1045         if plcs_on_vs: self.plc_boxes += self.plc_vs_boxes
1046         if plcs_on_lxc: self.plc_boxes += self.plc_lxc_boxes
1047         self.default_boxes = self.plc_boxes + self.qemu_boxes
1048         self.all_boxes = self.build_boxes + [ self.test_box ] + self.plc_boxes + self.qemu_boxes
1049
1050     def summary_line (self):
1051         msg  = "["
1052         msg += " %d vp"%len(self.plc_vs_boxes)
1053         msg += " %d xp"%len(self.plc_lxc_boxes)
1054         msg += " %d tried plc boxes"%len(self.plc_boxes)
1055         msg += "]"
1056         return msg
1057
1058     def fqdn (self, hostname):
1059         if hostname.find('.')<0: return "%s.%s"%(hostname,self.domain())
1060         return hostname
1061
1062     # return True if actual sensing takes place
1063     def sense (self,force=False):
1064         if self._sensed and not force: return False
1065         print 'Sensing local substrate...',
1066         for b in self.default_boxes: b.sense(self.options)
1067         print 'Done'
1068         self._sensed=True
1069         return True
1070
1071     def list (self, verbose=False):
1072         for b in self.default_boxes:
1073             b.list()
1074
1075     def add_dummy_plc (self, plc_boxname, plcname):
1076         for pb in self.plc_boxes:
1077             if pb.hostname==plc_boxname:
1078                 pb.add_dummy(plcname)
1079                 return True
1080     def add_dummy_qemu (self, qemu_boxname, qemuname):
1081         for qb in self.qemu_boxes:
1082             if qb.hostname==qemu_boxname:
1083                 qb.add_dummy(qemuname)
1084                 return True
1085
1086     def add_starting_dummy (self, bname, vname):
1087         return self.add_dummy_plc (bname, vname) or self.add_dummy_qemu (bname, vname)
1088
1089     ##########
1090     def provision (self,plcs,options):
1091         try:
1092             # attach each plc to a plc box and an IP address
1093             plcs = [ self.provision_plc (plc,options) for plc in plcs ]
1094             # attach each node/qemu to a qemu box with an IP address
1095             plcs = [ self.provision_qemus (plc,options) for plc in plcs ]
1096             # update the SFA spec accordingly
1097             plcs = [ self.localize_sfa_rspec(plc,options) for plc in plcs ]
1098             self.list()
1099             return plcs
1100         except Exception, e:
1101             print '* Could not provision this test on current substrate','--',e,'--','exiting'
1102             traceback.print_exc()
1103             sys.exit(1)
1104
1105     # it is expected that a couple of options like ips_bplc and ips_vplc
1106     # are set or unset together
1107     @staticmethod
1108     def check_options (x,y):
1109         if not x and not y: return True
1110         return len(x)==len(y)
1111
1112     # find an available plc box (or make space)
1113     # and a free IP address (using options if present)
1114     def provision_plc (self, plc, options):
1115
1116         assert Substrate.check_options (options.ips_bplc, options.ips_vplc)
1117
1118         #### let's find an IP address for that plc
1119         # look in options
1120         if options.ips_vplc:
1121             # this is a rerun
1122             # we don't check anything here,
1123             # it is the caller's responsability to cleanup and make sure this makes sense
1124             plc_boxname = options.ips_bplc.pop()
1125             vplc_hostname=options.ips_vplc.pop()
1126         else:
1127             if self.sense(): self.list()
1128             plc_boxname=None
1129             vplc_hostname=None
1130             # try to find an available IP
1131             self.vplc_pool.sense()
1132             couple=self.vplc_pool.next_free()
1133             if couple:
1134                 (vplc_hostname,unused)=couple
1135             #### we need to find one plc box that still has a slot
1136             max_free=0
1137             # use the box that has max free spots for load balancing
1138             for pb in self.plc_boxes:
1139                 free=pb.free_slots()
1140                 if free>max_free:
1141                     plc_boxname=pb.hostname
1142                     max_free=free
1143             # if there's no available slot in the plc_boxes, or we need a free IP address
1144             # make space by killing the oldest running instance
1145             if not plc_boxname or not vplc_hostname:
1146                 # find the oldest of all our instances
1147                 all_plc_instances=reduce(lambda x, y: x+y,
1148                                          [ pb.plc_instances for pb in self.plc_boxes ],
1149                                          [])
1150                 all_plc_instances.sort(timestamp_sort)
1151                 try:
1152                     plc_instance_to_kill=all_plc_instances[0]
1153                 except:
1154                     msg=""
1155                     if not plc_boxname: msg += " PLC boxes are full"
1156                     if not vplc_hostname: msg += " vplc IP pool exhausted"
1157                     msg += " %s"%self.summary_line()
1158                     raise Exception,"Cannot make space for a PLC instance:"+msg
1159                 freed_plc_boxname=plc_instance_to_kill.plc_box.hostname
1160                 freed_vplc_hostname=plc_instance_to_kill.vplcname()
1161                 message='killing oldest plc instance = %s on %s'%(plc_instance_to_kill.line(),
1162                                                                   freed_plc_boxname)
1163                 plc_instance_to_kill.kill()
1164                 # use this new plcbox if that was the problem
1165                 if not plc_boxname:
1166                     plc_boxname=freed_plc_boxname
1167                 # ditto for the IP address
1168                 if not vplc_hostname:
1169                     vplc_hostname=freed_vplc_hostname
1170                     # record in pool as mine
1171                     self.vplc_pool.set_mine(vplc_hostname)
1172
1173         #
1174         self.add_dummy_plc(plc_boxname,plc['name'])
1175         vplc_ip = self.vplc_pool.get_ip(vplc_hostname)
1176         self.vplc_pool.add_starting(vplc_hostname, plc_boxname)
1177
1178         #### compute a helpful vserver name
1179         # remove domain in hostname
1180         vplc_short = short_hostname(vplc_hostname)
1181         vservername = "%s-%d-%s" % (options.buildname,plc['index'],vplc_short)
1182         plc_name = "%s_%s"%(plc['name'],vplc_short)
1183
1184         utils.header( 'PROVISION plc %s in box %s at IP %s as %s'%\
1185                           (plc['name'],plc_boxname,vplc_hostname,vservername))
1186
1187         #### apply in the plc_spec
1188         # # informative
1189         # label=options.personality.replace("linux","")
1190         mapper = {'plc': [ ('*' , {'host_box':plc_boxname,
1191                                    # 'name':'%s-'+label,
1192                                    'name': plc_name,
1193                                    'vservername':vservername,
1194                                    'vserverip':vplc_ip,
1195                                    'PLC_DB_HOST':vplc_hostname,
1196                                    'PLC_API_HOST':vplc_hostname,
1197                                    'PLC_BOOT_HOST':vplc_hostname,
1198                                    'PLC_WWW_HOST':vplc_hostname,
1199                                    'PLC_NET_DNS1' : self.network_settings() [ 'interface_fields:dns1' ],
1200                                    'PLC_NET_DNS2' : self.network_settings() [ 'interface_fields:dns2' ],
1201                                    } ) ]
1202                   }
1203
1204
1205         # mappers only work on a list of plcs
1206         return TestMapper([plc],options).map(mapper)[0]
1207
1208     ##########
1209     def provision_qemus (self, plc, options):
1210
1211         assert Substrate.check_options (options.ips_bnode, options.ips_vnode)
1212
1213         test_mapper = TestMapper ([plc], options)
1214         nodenames = test_mapper.node_names()
1215         maps=[]
1216         for nodename in nodenames:
1217
1218             if options.ips_vnode:
1219                 # as above, it's a rerun, take it for granted
1220                 qemu_boxname=options.ips_bnode.pop()
1221                 vnode_hostname=options.ips_vnode.pop()
1222             else:
1223                 if self.sense(): self.list()
1224                 qemu_boxname=None
1225                 vnode_hostname=None
1226                 # try to find an available IP
1227                 self.vnode_pool.sense()
1228                 couple=self.vnode_pool.next_free()
1229                 if couple:
1230                     (vnode_hostname,unused)=couple
1231                 # find a physical box
1232                 max_free=0
1233                 # use the box that has max free spots for load balancing
1234                 for qb in self.qemu_boxes:
1235                     free=qb.free_slots()
1236                     if free>max_free:
1237                         qemu_boxname=qb.hostname
1238                         max_free=free
1239                 # if we miss the box or the IP, kill the oldest instance
1240                 if not qemu_boxname or not vnode_hostname:
1241                 # find the oldest of all our instances
1242                     all_qemu_instances=reduce(lambda x, y: x+y,
1243                                               [ qb.qemu_instances for qb in self.qemu_boxes ],
1244                                               [])
1245                     all_qemu_instances.sort(timestamp_sort)
1246                     try:
1247                         qemu_instance_to_kill=all_qemu_instances[0]
1248                     except:
1249                         msg=""
1250                         if not qemu_boxname: msg += " QEMU boxes are full"
1251                         if not vnode_hostname: msg += " vnode IP pool exhausted"
1252                         msg += " %s"%self.summary_line()
1253                         raise Exception,"Cannot make space for a QEMU instance:"+msg
1254                     freed_qemu_boxname=qemu_instance_to_kill.qemu_box.hostname
1255                     freed_vnode_hostname=short_hostname(qemu_instance_to_kill.nodename)
1256                     # kill it
1257                     message='killing oldest qemu node = %s on %s'%(qemu_instance_to_kill.line(),
1258                                                                    freed_qemu_boxname)
1259                     qemu_instance_to_kill.kill()
1260                     # use these freed resources where needed
1261                     if not qemu_boxname:
1262                         qemu_boxname=freed_qemu_boxname
1263                     if not vnode_hostname:
1264                         vnode_hostname=freed_vnode_hostname
1265                         self.vnode_pool.set_mine(vnode_hostname)
1266
1267             self.add_dummy_qemu (qemu_boxname,vnode_hostname)
1268             mac=self.vnode_pool.retrieve_userdata(vnode_hostname)
1269             ip=self.vnode_pool.get_ip (vnode_hostname)
1270             self.vnode_pool.add_starting(vnode_hostname,qemu_boxname)
1271
1272             vnode_fqdn = self.fqdn(vnode_hostname)
1273             nodemap={'host_box':qemu_boxname,
1274                      'node_fields:hostname':vnode_fqdn,
1275                      'interface_fields:ip':ip,
1276                      'ipaddress_fields:ip_addr':ip,
1277                      'interface_fields:mac':mac,
1278                      }
1279             nodemap.update(self.network_settings())
1280             maps.append ( (nodename, nodemap) )
1281
1282             utils.header("PROVISION node %s in box %s at IP %s with MAC %s"%\
1283                              (nodename,qemu_boxname,vnode_hostname,mac))
1284
1285         return test_mapper.map({'node':maps})[0]
1286
1287     def localize_sfa_rspec (self,plc,options):
1288
1289         plc['sfa']['SFA_REGISTRY_HOST'] = plc['PLC_DB_HOST']
1290         plc['sfa']['SFA_AGGREGATE_HOST'] = plc['PLC_DB_HOST']
1291         plc['sfa']['SFA_SM_HOST'] = plc['PLC_DB_HOST']
1292         plc['sfa']['SFA_DB_HOST'] = plc['PLC_DB_HOST']
1293         plc['sfa']['SFA_PLC_URL'] = 'https://' + plc['PLC_API_HOST'] + ':443/PLCAPI/'
1294         return plc
1295
1296     #################### release:
1297     def release (self,options):
1298         self.vplc_pool.release_my_starting()
1299         self.vnode_pool.release_my_starting()
1300         pass
1301
1302     #################### show results for interactive mode
1303     def get_box (self,boxname):
1304         for b in self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box] :
1305             if b.shortname()==boxname:                          return b
1306             try:
1307                 if b.shortname()==boxname.split('.')[0]:        return b
1308             except: pass
1309         print "Could not find box %s"%boxname
1310         return None
1311
1312     def list_boxes(self,box_or_names):
1313         print 'Sensing',
1314         for box in box_or_names:
1315             if not isinstance(box,Box): box=self.get_box(box)
1316             if not box: continue
1317             box.sense(self.options)
1318         print 'Done'
1319         for box in box_or_names:
1320             if not isinstance(box,Box): box=self.get_box(box)
1321             if not box: continue
1322             box.list(self.options.verbose)
1323
1324     def reboot_boxes(self,box_or_names):
1325         for box in box_or_names:
1326             if not isinstance(box,Box): box=self.get_box(box)
1327             if not box: continue
1328             box.reboot(self.options)
1329
1330     ####################
1331     # can be run as a utility to probe/display/manage the local infrastructure
1332     def main (self):
1333         parser=OptionParser()
1334         parser.add_option ('-r',"--reboot",action='store_true',dest='reboot',default=False,
1335                            help='reboot mode (use shutdown -r)')
1336         parser.add_option ('-s',"--soft",action='store_true',dest='soft',default=False,
1337                            help='soft mode for reboot (vserver stop or kill qemus)')
1338         parser.add_option ('-t',"--testbox",action='store_true',dest='testbox',default=False,
1339                            help='add test box')
1340         parser.add_option ('-b',"--build",action='store_true',dest='builds',default=False,
1341                            help='add build boxes')
1342         parser.add_option ('-p',"--plc",action='store_true',dest='plcs',default=False,
1343                            help='add plc boxes')
1344         parser.add_option ('-q',"--qemu",action='store_true',dest='qemus',default=False,
1345                            help='add qemu boxes')
1346         parser.add_option ('-a',"--all",action='store_true',dest='all',default=False,
1347                            help='address all known  boxes, like -b -t -p -q')
1348         parser.add_option ('-v',"--verbose",action='store_true',dest='verbose',default=False,
1349                            help='verbose mode')
1350         parser.add_option ('-n',"--dry_run",action='store_true',dest='dry_run',default=False,
1351                            help='dry run mode')
1352         (self.options,args)=parser.parse_args()
1353
1354         self.rescope (plcs_on_vs=True, plcs_on_lxc=True)
1355
1356         boxes=args
1357         if self.options.testbox: boxes += [self.test_box]
1358         if self.options.builds: boxes += self.build_boxes
1359         if self.options.plcs: boxes += self.plc_boxes
1360         if self.options.qemus: boxes += self.qemu_boxes
1361         if self.options.all: boxes += self.all_boxes
1362
1363         global verbose
1364         verbose=self.options.verbose
1365         # default scope is -b -p -q -t
1366         if not boxes:
1367             boxes = self.build_boxes + self.plc_boxes + self.qemu_boxes + [self.test_box]
1368
1369         if self.options.reboot: self.reboot_boxes (boxes)
1370         else:                   self.list_boxes (boxes)