import datetime
import time
import sys
-import datetime
import traceback
from types import StringTypes
+import socket
import utils
from TestSite import TestSite
return overall
return actual
+SEP='<sep>'
+
class TestPlc:
default_steps = ['uninstall','install','install_rpm',
'configure', 'start', SEP,
'store_keys', 'clear_known_hosts', 'initscripts', SEP,
'sites', 'nodes', 'slices', 'nodegroups', SEP,
- 'init_node','bootcd', 'configure_qemu',
+ 'init_node','bootcd', 'configure_qemu', 'export_qemu',
'kill_all_qemus', 'reinstall_node','start_node', SEP,
- 'standby_20', SEP,
'nodes_booted', 'nodes_ssh', 'check_slice',
- 'check_initscripts', 'check_tcp',SEP,
- 'force_gather_logs', 'force_kill_qemus', ]
- other_steps = [ 'stop_all_vservers','fresh_install', 'cache_rpm', 'stop', SEP,
- 'clean_sites', 'clean_nodes', 'clean_slices', 'clean_keys', SEP,
+ 'check_initscripts', 'check_tcp', 'plcsh_stress_test', SEP,
+ 'force_gather_logs', 'force_kill_qemus', 'force_record_tracker','force_free_tracker' ]
+ other_steps = [ 'stop_all_vservers','fresh_install', 'cache_rpm', 'stop', 'vs_start', SEP,
+ 'clean_initscripts', 'clean_all_sites',
+ 'clean_sites', 'clean_nodes',
+ 'clean_slices', 'clean_keys', SEP,
'show_boxes', 'list_all_qemus', 'list_qemus', SEP,
- 'db_dump' , 'db_restore',
+ 'db_dump' , 'db_restore', ' cleanup_tracker',
'standby_1 through 20'
]
+
+ @staticmethod
+ def printable_steps (list):
+ return " ".join(list).replace(" "+SEP+" "," \\\n")
+ @staticmethod
+ def valid_step (step):
+ return step != SEP
+
def __init__ (self,plc_spec,options):
self.plc_spec=plc_spec
self.options=options
self.url="https://%s:443/PLCAPI/"%plc_spec['vserverip']
self.vserver=True
except:
- self.vserver=False
- self.url="https://%s:443/PLCAPI/"%plc_spec['hostname']
-# utils.header('Using API url %s'%self.url)
+ raise Exception,'chroot-based myplc testing is deprecated'
self.apiserver=TestApiserver(self.url,options.dry_run)
def name(self):
name=self.plc_spec['name']
- if self.vserver:
- return name+".vserver.%s"%self.vservername
- else:
- return name+".chroot"
+ return "%s.%s"%(name,self.vservername)
def hostname(self):
return self.plc_spec['hostname']
def actual_command_in_guest (self,command):
return self.test_ssh.actual_command(self.host_to_guest(command))
+ def start_guest (self):
+ return utils.system(self.test_ssh.actual_command(self.start_guest_in_host()))
+
def run_in_guest (self,command):
return utils.system(self.actual_command_in_guest(command))
def run_in_host (self,command):
return self.test_ssh.run_in_buildname(command)
- #command gets run in the chroot/vserver
+ #command gets run in the vserver
def host_to_guest(self,command):
- if self.vserver:
- return "vserver %s exec %s"%(self.vservername,command)
- else:
- return "chroot /plc/root %s"%TestSsh.backslash_shell_specials(command)
+ return "vserver %s exec %s"%(self.vservername,command)
+
+ #command gets run in the vserver
+ def start_guest_in_host(self):
+ return "vserver %s start"%(self.vservername)
- # copy a file to the myplc root image - pass in_data=True if the file must go in /plc/data
- def copy_in_guest (self, localfile, remotefile, in_data=False):
- if in_data:
- chroot_dest="/plc/data"
- else:
- chroot_dest="/plc/root"
- if self.is_local():
- if not self.vserver:
- utils.system("cp %s %s/%s"%(localfile,chroot_dest,remotefile))
- else:
- utils.system("cp %s /vservers/%s/%s"%(localfile,self.vservername,remotefile))
- else:
- if not self.vserver:
- utils.system("scp %s %s:%s/%s"%(localfile,self.hostname(),chroot_dest,remotefile))
- else:
- utils.system("scp %s %s@/vservers/%s/%s"%(localfile,self.hostname(),self.vservername,remotefile))
-
-
# xxx quick n dirty
def run_in_guest_piped (self,local,remote):
- return utils.system(local+" | "+self.test_ssh.actual_command(self.host_to_guest(remote)))
+ return utils.system(local+" | "+self.test_ssh.actual_command(self.host_to_guest(remote),keep_stdin=True))
def auth_root (self):
return {'Username':self.plc_spec['PLC_ROOT_USER'],
# this is the brute force version, kill all qemus on that host box
for (box,nodes) in self.gather_hostBoxes().iteritems():
# pass the first nodename, as we don't push template-qemu on testboxes
- nodename=nodes[0].name()
- TestBox(box,self.options.buildname).kill_all_qemus(nodename)
+ nodedir=nodes[0].nodedir()
+ TestBox(box,self.options.buildname).kill_all_qemus(nodedir)
return True
# make this a valid step
node.kill_qemu()
return True
- #################### step methods
-
- ### uninstall
- def uninstall_chroot(self):
- self.run_in_host('service plc safestop')
- #####detecting the last myplc version installed and remove it
- self.run_in_host('rpm -e myplc')
- ##### Clean up the /plc directory
- self.run_in_host('rm -rf /plc/data')
- ##### stop any running vservers
- self.run_in_host('for vserver in $(ls -d /vservers/* | sed -e s,/vservers/,,) ; do case $vserver in vtest*) echo Shutting down vserver $vserver ; vserver $vserver stop ;; esac ; done')
+
+ ### utility methods for handling the pool of IP addresses allocated to plcs
+ # Logic
+ # (*) running plcs are recorded in the file named ~/running-test-plcs
+ # (*) this file contains a line for each running plc, older first
+ # (*) each line contains the vserver name + the hostname of the (vserver) testbox where it sits
+ # (*) the free_tracker method performs a vserver stop on the oldest entry
+ # (*) the record_tracker method adds an entry at the bottom of the file
+ # (*) the cleanup_tracker method stops all known vservers and removes the tracker file
+
+ TRACKER_FILE="~/running-test-plcs"
+
+ def record_tracker (self):
+ command="echo %s %s >> %s"%(self.vservername,self.test_ssh.hostname,TestPlc.TRACKER_FILE)
+ (code,output) = utils.output_of (self.test_ssh.actual_command(command))
+ if code != 0:
+ print "WARNING : COULD NOT record_tracker %s as a running plc on %s"%(self.vservername,self.test_ssh.hostname)
+ return False
+ print "Recorded %s in running plcs on host %s"%(self.vservername,self.test_ssh.hostname)
return True
- def uninstall_vserver(self):
- self.run_in_host("vserver --silent %s delete"%self.vservername)
+ def free_tracker (self):
+ command="head -1 %s"%TestPlc.TRACKER_FILE
+ (code,line) = utils.output_of(self.test_ssh.actual_command(command))
+ if code != 0:
+ print "No entry found in %s on %s"%(TestPlc.TRACKER_FILE,self.test_ssh.hostname)
+ return False
+ try:
+ [vserver_to_stop,hostname] = line.split()
+ except:
+ print "WARNING: free_tracker: Could not parse %s - skipped"%TestPlc.TRACKER_FILE
+ return False
+ stop_command = "vserver --silent %s stop"%vserver_to_stop
+ utils.system(self.test_ssh.actual_command(stop_command))
+ x=TestPlc.TRACKER_FILE
+ flush_command = "tail --lines=+2 %s > %s.tmp ; mv %s.tmp %s"%(x,x,x,x)
+ utils.system(self.test_ssh.actual_command(flush_command))
return True
+ # this should/could stop only the ones in TRACKER_FILE if that turns out to be reliable
+ def cleanup_tracker (self):
+ stop_all = "cd /vservers ; for i in * ; do vserver --silent $i stop ; done"
+ utils.system(self.test_ssh.actual_command(stop_all))
+ clean_tracker = "rm -f %s"%TestPlc.TRACKER_FILE
+ utils.system(self.test_ssh.actual_command(clean_tracker))
+
def uninstall(self):
- # if there's a chroot-based myplc running, and then a native-based myplc is being deployed
- # it sounds safer to have the former uninstalled too
- # now the vserver method cannot be invoked for chroot instances as vservername is required
- if self.vserver:
- self.uninstall_vserver()
- self.uninstall_chroot()
- else:
- self.uninstall_chroot()
+ self.run_in_host("vserver --silent %s delete"%self.vservername)
return True
### install
- def install_chroot(self):
- # nothing to do
- return True
-
- def install_vserver(self):
- # we need build dir for vtest-init-vserver
+ def install(self):
if self.is_local():
# a full path for the local calls
- build_dir=os.path(sys.argv[0])+"/build"
+ build_dir=os.path.dirname(sys.argv[0])
+ # sometimes this is empty - set to "." in such a case
+ if not build_dir: build_dir="."
+ build_dir += "/build"
else:
- # use a standard name - will be relative to HOME
- build_dir="options.buildname"
+ # use a standard name - will be relative to remote buildname
+ build_dir="build"
# run checkout in any case - would do an update if already exists
build_checkout = "svn checkout %s %s"%(self.options.build_url,build_dir)
if self.run_in_host(build_checkout) != 0:
return False
- # the repo url is taken from myplc-url
- # with the last two steps (i386/myplc...) removed
- repo_url = self.options.myplc_url
- for level in [ 'rpmname','arch' ]:
+ # the repo url is taken from arch-rpms-url
+ # with the last step (i386.) removed
+ repo_url = self.options.arch_rpms_url
+ for level in [ 'arch' ]:
repo_url = os.path.dirname(repo_url)
- create_vserver="%s/vtest-init-vserver.sh %s %s -- --interface eth0:%s"%\
- (build_dir,self.vservername,repo_url,self.vserverip)
- return self.run_in_host(create_vserver) == 0
-
- def install(self):
- if self.vserver:
- return self.install_vserver()
+ if self.options.arch == "i386":
+ personality_option="-p linux32"
else:
- return self.install_chroot()
-
- ### install_rpm - make this an optional step
- def cache_rpm(self):
- url = self.options.myplc_url
- rpm = os.path.basename(url)
- cache_fetch="pwd;if [ -f %(rpm)s ] ; then echo Using cached rpm %(rpm)s ; else echo Fetching %(url)s ; curl -O %(url)s; fi"%locals()
- return self.run_in_host(cache_fetch)==0
-
- def install_rpm_chroot(self):
- url = self.options.myplc_url
- rpm = os.path.basename(url)
- if not self.cache_rpm():
- return False
- utils.header('Installing the : %s'%rpm)
- return self.run_in_host('rpm -Uvh '+rpm)==0 and self.run_in_host('service plc mount')==0
-
- def install_rpm_vserver(self):
- return self.run_in_guest("yum -y install myplc-native")==0
+ personality_option="-p linux64"
+ script="vtest-init-vserver.sh"
+ vserver_name = self.vservername
+ vserver_options="--netdev eth0 --interface %s"%self.vserverip
+ try:
+ vserver_hostname=socket.gethostbyaddr(self.vserverip)[0]
+ vserver_options += " --hostname %s"%vserver_hostname
+ except:
+ pass
+ create_vserver="%(build_dir)s/%(script)s %(personality_option)s %(vserver_name)s %(repo_url)s -- %(vserver_options)s"%locals()
+ return self.run_in_host(create_vserver) == 0
+ ### install_rpm
def install_rpm(self):
- if self.vserver:
- return self.install_rpm_vserver()
- else:
- return self.install_rpm_chroot()
+ return self.run_in_guest("yum -y install myplc-native")==0
###
def configure(self):
utils.system('rm %s'%tmpname)
return True
- # the chroot install is slightly different to this respect
def start(self):
- if self.vserver:
- self.run_in_guest('service plc start')
- else:
- self.run_in_host('service plc start')
+ self.run_in_guest('service plc start')
return True
-
+
def stop(self):
- if self.vserver:
- self.run_in_guest('service plc stop')
- else:
- self.run_in_host('service plc stop')
+ self.run_in_guest('service plc stop')
return True
+ def vs_start (self):
+ self.start_guest()
+ return True
+
# could use a TestKey class
def store_keys(self):
for key_spec in self.plc_spec['keys']:
test_site.create_users()
return True
+ def clean_all_sites (self):
+ print 'auth_root',self.auth_root()
+ site_ids = [s['site_id'] for s in self.apiserver.GetSites(self.auth_root(), {}, ['site_id'])]
+ for site_id in site_ids:
+ print 'Deleting site_id',site_id
+ self.apiserver.DeleteSite(self.auth_root(),site_id)
+
def nodes (self):
return self.do_nodes()
def clean_nodes (self):
groups_dict[nodegroupname].append(test_node.name())
auth=self.auth_root()
for (nodegroupname,group_nodes) in groups_dict.iteritems():
- try:
- self.apiserver.GetNodeGroups(auth,{'name':nodegroupname})[0]
- except:
- self.apiserver.AddNodeGroup(auth,{'name':nodegroupname})
- for node in group_nodes:
- self.apiserver.AddNodeToNodeGroup(auth,node,nodegroupname)
- return True
+ print 'nodegroups:','dealing with nodegroup',nodegroupname,'on nodes',group_nodes
+ # first, check if the nodetagtype is here
+ tag_types = self.apiserver.GetTagTypes(auth,{'tagname':nodegroupname})
+ if tag_types:
+ tag_type_id = tag_types[0]['node_tag_type_id']
+ else:
+ tag_type_id = self.apiserver.AddNodeTagType(auth,
+ {'tagname':nodegroupname,
+ 'description': 'for nodegroup %s'%nodegroupname,
+ 'category':'test',
+ 'min_role_id':10})
+ # create nodegroup
+ nodegroups = self.apiserver.GetNodeGroups (auth, {'groupname':nodegroupname})
+ if not nodegroups:
+ self.apiserver.AddNodeGroup(auth, nodegroupname, tag_type_id, 'yes')
+ # set node tag on all nodes, value='yes'
+ overall = True
+ for nodename in group_nodes:
+ try:
+ self.apiserver.AddNodeTag(auth, nodename, nodegroupname, "yes")
+ except:
+ print 'node',nodename,'seems to already have tag',nodegroupname
+ # check anyway
+ try:
+ expect_yes = self.apiserver.GetNodeTags(
+ auth,
+ {'hostname':nodename,
+ 'tagname':nodegroupname},
+ ['tagvalue'])[0]['tagvalue']
+ if expect_yes != "yes":
+ print 'Mismatch node tag on node',nodename,'got',expect_yes
+ overall=False
+ except:
+ if not self.options.dry_run:
+ print 'Cannot find tag',nodegroupname,'on node',nodename
+ overall = False
+ return overall
def all_hostnames (self) :
hostnames = []
return hostnames
# gracetime : during the first <gracetime> minutes nothing gets printed
- def do_nodes_booted (self, minutes, gracetime=2):
+ def do_nodes_booted (self, minutes, gracetime,period=15):
if self.options.dry_run:
print 'dry_run'
return True
utils.header("WARNING - Real node %s in %s - ignored"%(hostname,boot_state))
# let's cheat
boot_state = 'boot'
- if datetime.datetime.now() > graceout:
+ elif datetime.datetime.now() > graceout:
utils.header ("%s still in '%s' state"%(hostname,boot_state))
graceout=datetime.datetime.now()+datetime.timedelta(1)
status[hostname] = boot_state
utils.header("FAILURE due to %s in '%s' state"%(hostname,status[hostname]))
return False
# otherwise, sleep for a while
- time.sleep(15)
+ time.sleep(period)
# only useful in empty plcs
return True
def nodes_booted(self):
- return self.do_nodes_booted(minutes=0)
-
+ return self.do_nodes_booted(minutes=20,gracetime=15)
- def do_nodes_ssh(self,minutes):
+ def do_nodes_ssh(self,minutes,gracetime,period=15):
# compute timeout
timeout = datetime.datetime.now()+datetime.timedelta(minutes=minutes)
+ graceout = datetime.datetime.now()+datetime.timedelta(minutes=gracetime)
tocheck = self.all_hostnames()
# self.scan_publicKeys(tocheck)
utils.header("checking Connectivity on nodes %r"%tocheck)
for hostname in tocheck:
# try to ssh in nodes
node_test_ssh = TestSsh (hostname,key="/etc/planetlab/root_ssh_key.rsa")
- access=self.run_in_guest(node_test_ssh.actual_command("date"))
- if not access:
+ success=self.run_in_guest(node_test_ssh.actual_command("hostname"))==0
+ if success:
utils.header('The node %s is sshable -->'%hostname)
# refresh tocheck
tocheck.remove(hostname)
if TestNode.is_real_model(node_spec['node_fields']['model']):
utils.header ("WARNING : check ssh access into real node %s - skipped"%hostname)
tocheck.remove(hostname)
+ elif datetime.datetime.now() > graceout:
+ utils.header("Could not ssh-enter root context on %s"%hostname)
if not tocheck:
return True
if datetime.datetime.now() > timeout:
utils.header("FAILURE to ssh into %s"%hostname)
return False
# otherwise, sleep for a while
- time.sleep(15)
+ time.sleep(period)
# only useful in empty plcs
return True
def nodes_ssh(self):
- return self.do_nodes_ssh(minutes=2)
+ return self.do_nodes_ssh(minutes=6,gracetime=4)
@node_mapper
def init_node (self): pass
def configure_qemu (self): pass
@node_mapper
def reinstall_node (self): pass
+ @node_mapper
+ def export_qemu (self): pass
def do_check_initscripts(self):
overall = True
self.apiserver.AddInitScript(self.auth_root(),initscript['initscript_fields'])
return True
+ def clean_initscripts (self):
+ for initscript in self.plc_spec['initscripts']:
+ initscript_name = initscript['initscript_fields']['name']
+ print('Attempting to delete %s in plc %s'%(initscript_name,self.plc_spec['name']))
+ try:
+ self.apiserver.DeleteInitScript(self.auth_root(),initscript_name)
+ print initscript_name,'deleted'
+ except:
+ print 'deletion went wrong - probably did not exist'
+ return True
+
def slices (self):
return self.do_slices()
@node_mapper
def start_node (self) : pass
- def locate_first_sliver (self):
- slice_spec = self.plc_spec['slices'][0]
- slicename = slice_spec['slice_fields']['name']
- nodename = slice_spec['nodenames'][0]
- return self.locate_sliver_obj(nodename,slicename)
+ def all_sliver_objs (self):
+ result=[]
+ for slice_spec in self.plc_spec['slices']:
+ slicename = slice_spec['slice_fields']['name']
+ for nodename in slice_spec['nodenames']:
+ result.append(self.locate_sliver_obj (nodename,slicename))
+ return result
def locate_sliver_obj (self,nodename,slicename):
(site,node) = self.locate_node(nodename)
if not c_test_sliver.run_tcp_client(s_test_sliver.test_node.name(),port):
overall=False
return overall
-
+
+ def plcsh_stress_test (self):
+ # install the stress-test in the plc image
+ location = "/usr/share/plc_api/plcsh-stress-test.py"
+ remote="/vservers/%s/%s"%(self.vservername,location)
+ self.test_ssh.copy_abs("plcsh-stress-test.py",remote)
+ command = location
+ command += " -- --check"
+ if self.options.small_test:
+ command += " --tiny"
+ return ( self.run_in_guest(command) == 0)
def gather_logs (self):
- # (1) get the plc's /var/log and store it locally in logs/<plcname>-var-log/*
- # (2) get all the nodes qemu log and store it as logs/<node>-qemu.log
- # (3) get the nodes /var/log and store is as logs/<node>-var-log/*
- # (4) as far as possible get the slice's /var/log as logs/<slice>-<node>-var-log/*
+ # (1) get the plc's /var/log and store it locally in logs/myplc.var-log.<plcname>/*
+ # (2) get all the nodes qemu log and store it as logs/node.qemu.<node>.log
+ # (3) get the nodes /var/log and store is as logs/node.var-log.<node>/*
+ # (4) as far as possible get the slice's /var/log as logs/sliver.var-log.<sliver>/*
# (1)
print "-------------------- TestPlc.gather_logs : PLC's /var/log"
self.gather_var_logs ()
self.gather_nodes_var_logs()
# (4)
print "-------------------- TestPlc.gather_logs : sample sliver's /var/log"
- self.gather_first_sliver_logs()
+ self.gather_slivers_var_logs()
return True
- def gather_first_sliver_logs(self):
- try:
- test_sliver = self.locate_first_sliver()
+ def gather_slivers_var_logs(self):
+ for test_sliver in self.all_sliver_objs():
remote = test_sliver.tar_var_logs()
- utils.system("mkdir -p logs/%s-var-log"%test_sliver.name())
- command = remote + " | tar -C logs/%s-var-log -xf -"%test_sliver.name()
+ utils.system("mkdir -p logs/sliver.var-log.%s"%test_sliver.name())
+ command = remote + " | tar -C logs/sliver.var-log.%s -xf -"%test_sliver.name()
utils.system(command)
- except Exception,e:
- print 'Cannot locate first sliver - giving up',e
return True
def gather_var_logs (self):
to_plc = self.actual_command_in_guest("tar -C /var/log/ -cf - .")
- command = to_plc + "| tar -C logs/%s-var-log -xf -"%self.name()
- utils.system("mkdir -p logs/%s-var-log"%self.name())
+ command = to_plc + "| tar -C logs/myplc.var-log.%s -xf -"%self.name()
+ utils.system("mkdir -p logs/myplc.var-log.%s"%self.name())
utils.system(command)
def gather_nodes_var_logs (self):
test_node=TestNode(self,test_site,node_spec)
test_ssh = TestSsh (test_node.name(),key="/etc/planetlab/root_ssh_key.rsa")
to_plc = self.actual_command_in_guest ( test_ssh.actual_command("tar -C /var/log -cf - ."))
- command = to_plc + "| tar -C logs/%s-var-log -xf -"%test_node.name()
- utils.system("mkdir -p logs/%s-var-log"%test_node.name())
+ command = to_plc + "| tar -C logs/node.var-log.%s -xf -"%test_node.name()
+ utils.system("mkdir -p logs/node.var-log.%s"%test_node.name())
utils.system(command)
git://git.onelab.eu / tests.git / blobdiff