import datetime
import time
import sys
-import xmlrpclib
import datetime
import traceback
from types import StringTypes
from TestSlice import TestSlice
from TestSliver import TestSliver
from TestBox import TestBox
+from TestSsh import TestSsh
+from TestApiserver import TestApiserver
-# step methods must take (self, options) and return a boolean
+# step methods must take (self) and return a boolean (options is a member of the class)
-def standby(minutes):
- utils.header('Entering StandBy for %d mn'%minutes)
+def standby(minutes,dry_run):
+ utils.header('Entering StandBy for %d mn'%minutes)
+ if dry_run:
+ print 'dry_run'
+ else:
time.sleep(60*minutes)
- return True
+ return True
def standby_generic (func):
- def actual(self,options):
+ def actual(self):
minutes=int(func.__name__.split("_")[1])
- return standby(minutes)
+ return standby(minutes,self.options.dry_run)
+ return actual
+
+def node_mapper (method):
+ def actual(self):
+ overall=True
+ node_method = TestNode.__dict__[method.__name__]
+ for site_spec in self.plc_spec['sites']:
+ test_site = TestSite (self,site_spec)
+ for node_spec in site_spec['nodes']:
+ test_node = TestNode (self,test_site,node_spec)
+ if not node_method(test_node): overall=False
+ return overall
+ return actual
+
+def slice_mapper_options (method):
+ def actual(self):
+ overall=True
+ slice_method = TestSlice.__dict__[method.__name__]
+ for slice_spec in self.plc_spec['slices']:
+ site_spec = self.locate_site (slice_spec['sitename'])
+ test_site = TestSite(self,site_spec)
+ test_slice=TestSlice(self,test_site,slice_spec)
+ if not slice_method(test_slice,self.options): overall=False
+ return overall
return actual
class TestPlc:
- def __init__ (self,plc_spec):
+ def __init__ (self,plc_spec,options):
self.plc_spec=plc_spec
- self.path=os.path.dirname(sys.argv[0])
+ self.options=options
+ self.test_ssh=TestSsh(self.plc_spec['hostname'],self.options.buildname)
try:
self.vserverip=plc_spec['vserverip']
self.vservername=plc_spec['vservername']
except:
self.vserver=False
self.url="https://%s:443/PLCAPI/"%plc_spec['hostname']
- utils.header('Using API url %s'%self.url)
- self.server=xmlrpclib.Server(self.url,allow_none=True)
+# utils.header('Using API url %s'%self.url)
+ self.apiserver=TestApiserver(self.url,options.dry_run)
def name(self):
name=self.plc_spec['name']
if self.vserver:
- return name+"[%s]"%self.vservername
+ return name+".vserver.%s"%self.vservername
else:
- return name+"[chroot]"
+ return name+".chroot"
def hostname(self):
return self.plc_spec['hostname']
def is_local (self):
- return utils.is_local(self.hostname())
+ return self.test_ssh.is_local()
# define the API methods on this object through xmlrpc
# would help, but not strictly necessary
def connect (self):
pass
+
+ def actual_command_in_guest (self,command):
+ return self.test_ssh.actual_command(self.host_to_guest(command))
- # command gets run in the chroot/vserver
+ 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
def host_to_guest(self,command):
if self.vserver:
return "vserver %s exec %s"%(self.vservername,command)
else:
- return "chroot /plc/root %s"%utils.backslash_shell_specials(command)
-
- # command gets run on the right box
- def to_host(self,command):
- if self.is_local():
- return command
- else:
- return "ssh %s %s"%(self.hostname(),utils.backslash_shell_specials(command))
-
- def full_command(self,command):
- return self.to_host(self.host_to_guest(command))
-
- def run_in_guest (self,command):
- return utils.system(self.full_command(command))
- def run_in_host (self,command):
- return utils.system(self.to_host(command))
-
- # xxx quick n dirty
- def run_in_guest_piped (self,local,remote):
- return utils.system(local+" | "+self.full_command(remote))
-
+ return "chroot /plc/root %s"%TestSsh.backslash_shell_specials(command)
+
# 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:
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)))
+
def auth_root (self):
return {'Username':self.plc_spec['PLC_ROOT_USER'],
'AuthMethod':'password',
def locate_node (self,nodename):
for site in self.plc_spec['sites']:
for node in site['nodes']:
- if node['node_fields']['hostname'] == nodename:
+ if node['name'] == nodename:
return (site,node)
raise Exception,"Cannot locate node %s"%nodename
+ def locate_hostname (self,hostname):
+ for site in self.plc_spec['sites']:
+ for node in site['nodes']:
+ if node['node_fields']['hostname'] == hostname:
+ return (site,node)
+ raise Exception,"Cannot locate hostname %s"%hostname
+
def locate_key (self,keyname):
for key in self.plc_spec['keys']:
if key['name'] == keyname:
return key
raise Exception,"Cannot locate key %s"%keyname
+ def locate_slice (self, slicename):
+ for slice in self.plc_spec['slices']:
+ if slice['slice_fields']['name'] == slicename:
+ return slice
+ raise Exception,"Cannot locate slice %s"%slicename
+
# all different hostboxes used in this plc
def gather_hostBoxes(self):
# maps on sites and nodes, return [ (host_box,test_node) ]
return result
# a step for checking this stuff
- def showboxes (self,options):
- print 'showboxes'
+ def show_boxes (self):
for (box,nodes) in self.gather_hostBoxes().iteritems():
print box,":"," + ".join( [ node.name() for node in nodes ] )
return True
# make this a valid step
- def kill_all_qemus(self,options):
+ def kill_all_qemus(self):
for (box,nodes) in self.gather_hostBoxes().iteritems():
# this is the brute force version, kill all qemus on that host box
- TestBox(box).kill_all_qemus()
+ TestBox(box,self.options.buildname).kill_all_qemus()
return True
# make this a valid step
- def list_all_qemus(self,options):
+ def list_all_qemus(self):
for (box,nodes) in self.gather_hostBoxes().iteritems():
- # push the script
- TestBox(box).copy("qemu_kill.sh")
# this is the brute force version, kill all qemus on that host box
- TestBox(box).run("./qemu_kill.sh -l")
+ TestBox(box,self.options.buildname).list_all_qemus()
return True
# kill only the right qemus
- def kill_qemus(self,options):
+ def list_qemus(self):
for (box,nodes) in self.gather_hostBoxes().iteritems():
- # push the script
- TestBox(box).copy("qemu_kill.sh")
# the fine-grain version
for node in nodes:
- node.kill_qemu()
+ node.list_qemu()
return True
- def clear_ssh_config (self,options):
- # install local ssh_config file as root's .ssh/config - ssh should be quiet
- # dir might need creation first
- self.run_in_guest("mkdir /root/.ssh")
- self.run_in_guest("chmod 700 /root/.ssh")
- # this does not work - > redirection somehow makes it until an argument to cat
- #self.run_in_guest_piped("cat ssh_config","cat > /root/.ssh/config")
- self.copy_in_guest("ssh_config","/root/.ssh/config",True)
+ # kill only the right qemus
+ def kill_qemus(self):
+ for (box,nodes) in self.gather_hostBoxes().iteritems():
+ # the fine-grain version
+ for node in nodes:
+ node.kill_qemu()
return True
-
+
#################### step methods
### uninstall
- def uninstall_chroot(self,options):
+ 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')
+ self.run_in_host('rm -rf /plc/data')
##### stop any running vservers
- self.run_in_host('for vserver in $(ls /vservers/* | sed -e s,/vservers/,,) ; do vserver $vserver stop ; done')
+ 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')
return True
- def uninstall_vserver(self,options):
+ def uninstall_vserver(self):
self.run_in_host("vserver --silent %s delete"%self.vservername)
return True
- def uninstall(self,options):
+ 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(options)
- self.uninstall_chroot(options)
+ self.uninstall_vserver()
+ self.uninstall_chroot()
else:
- self.uninstall_chroot(options)
+ self.uninstall_chroot()
return True
### install
- def install_chroot(self,options):
+ def install_chroot(self):
# nothing to do
return True
- # xxx this would not work with hostname != localhost as mylc-init-vserver was extracted locally
- def install_vserver(self,options):
+ def install_vserver(self):
# we need build dir for vtest-init-vserver
if self.is_local():
# a full path for the local calls
- build_dir=self.path+"/build"
+ build_dir=os.path(sys.argv[0])+"/build"
else:
# use a standard name - will be relative to HOME
- build_dir="tests-system-build"
- build_checkout = "svn checkout %s %s"%(options.build_url,build_dir)
+ build_dir="options.buildname"
+ # 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:
- raise Exception,"Cannot checkout build dir"
+ return False
# the repo url is taken from myplc-url
# with the last two steps (i386/myplc...) removed
- repo_url = options.myplc_url
- repo_url = os.path.dirname(repo_url)
- repo_url = os.path.dirname(repo_url)
+ repo_url = self.options.myplc_url
+ for level in [ 'rpmname','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)
- if self.run_in_host(create_vserver) != 0:
- raise Exception,"Could not create vserver for %s"%self.vservername
- return True
+ return self.run_in_host(create_vserver) == 0
- def install(self,options):
+ def install(self):
if self.vserver:
- return self.install_vserver(options)
+ return self.install_vserver()
else:
- return self.install_chroot(options)
-
- ### install_rpm
- def install_rpm_chroot(self,options):
- utils.header('Installing from %s'%options.myplc_url)
- url=options.myplc_url
- self.run_in_host('rpm -Uvh '+url)
- self.run_in_host('service plc mount')
- return True
-
- def install_rpm_vserver(self,options):
- self.run_in_guest("yum -y install myplc-native")
- return True
-
- def install_rpm(self,options):
+ 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
+
+ def install_rpm(self):
if self.vserver:
- return self.install_rpm_vserver(options)
+ return self.install_rpm_vserver()
else:
- return self.install_rpm_chroot(options)
+ return self.install_rpm_chroot()
###
- def configure(self,options):
- tmpname='%s/%s.plc-config-tty'%(options.path,self.name())
+ def configure(self):
+ tmpname='%s.plc-config-tty'%(self.name())
fileconf=open(tmpname,'w')
for var in [ 'PLC_NAME',
'PLC_ROOT_PASSWORD',
return True
# the chroot install is slightly different to this respect
- def start(self, options):
+ def start(self):
if self.vserver:
self.run_in_guest('service plc start')
else:
self.run_in_host('service plc start')
return True
- def stop(self, options):
+ def stop(self):
if self.vserver:
self.run_in_guest('service plc stop')
else:
return True
# could use a TestKey class
- def store_keys(self, options):
+ def store_keys(self):
for key_spec in self.plc_spec['keys']:
- TestKey(self,key_spec).store_key()
+ TestKey(self,key_spec).store_key()
return True
- def clean_keys(self, options):
- utils.system("rm -rf %s/keys/"%self.path)
+ def clean_keys(self):
+ utils.system("rm -rf %s/keys/"%os.path(sys.argv[0]))
- def sites (self,options):
- return self.do_sites(options)
+ def sites (self):
+ return self.do_sites()
- def clean_sites (self,options):
- return self.do_sites(options,action="delete")
+ def clean_sites (self):
+ return self.do_sites(action="delete")
- def do_sites (self,options,action="add"):
+ def do_sites (self,action="add"):
for site_spec in self.plc_spec['sites']:
test_site = TestSite (self,site_spec)
if (action != "add"):
test_site.create_users()
return True
- def nodes (self, options):
- return self.do_nodes(options)
- def clean_nodes (self, options):
- return self.do_nodes(options,action="delete")
+ def nodes (self):
+ return self.do_nodes()
+ def clean_nodes (self):
+ return self.do_nodes(action="delete")
- def do_nodes (self, options,action="add"):
+ def do_nodes (self,action="add"):
for site_spec in self.plc_spec['sites']:
test_site = TestSite (self,site_spec)
if action != "add":
# create nodegroups if needed, and populate
# no need for a clean_nodegroups if we are careful enough
- def nodegroups (self, options):
+ def nodegroups (self):
# 1st pass to scan contents
groups_dict = {}
for site_spec in self.plc_spec['sites']:
auth=self.auth_root()
for (nodegroupname,group_nodes) in groups_dict.iteritems():
try:
- self.server.GetNodeGroups(auth,{'name':nodegroupname})[0]
+ self.apiserver.GetNodeGroups(auth,{'name':nodegroupname})[0]
except:
- self.server.AddNodeGroup(auth,{'name':nodegroupname})
+ self.apiserver.AddNodeGroup(auth,{'name':nodegroupname})
for node in group_nodes:
- self.server.AddNodeToNodeGroup(auth,node,nodegroupname)
+ self.apiserver.AddNodeToNodeGroup(auth,node,nodegroupname)
return True
def all_hostnames (self) :
# gracetime : during the first <gracetime> minutes nothing gets printed
def do_nodes_booted (self, minutes, gracetime=2):
+ if self.options.dry_run:
+ print 'dry_run'
+ return True
# compute timeout
timeout = datetime.datetime.now()+datetime.timedelta(minutes=minutes)
graceout = datetime.datetime.now()+datetime.timedelta(minutes=gracetime)
status = dict ( [ (hostname,'undef') for hostname in tocheck ] )
while tocheck:
# get their status
- tocheck_status=self.server.GetNodes(self.auth_root(), tocheck, ['hostname','boot_state' ] )
+ tocheck_status=self.apiserver.GetNodes(self.auth_root(), tocheck, ['hostname','boot_state' ] )
# update status
for array in tocheck_status:
hostname=array['hostname']
utils.header ("%s has reached the 'boot' state"%hostname)
else:
# if it's a real node, never mind
- (site_spec,node_spec)=self.locate_node(hostname)
+ (site_spec,node_spec)=self.locate_hostname(hostname)
if TestNode.is_real_model(node_spec['node_fields']['model']):
utils.header("WARNING - Real node %s in %s - ignored"%(hostname,boot_state))
# let's cheat
# only useful in empty plcs
return True
- def nodes_booted(self,options):
- return self.do_nodes_booted(minutes=5)
+ def nodes_booted(self):
+ return self.do_nodes_booted(minutes=0)
- #to scan and store the nodes's public keys and avoid to ask for confirmation when ssh
- def scan_publicKeys(self,hostnames):
- try:
- temp_knownhosts="/root/known_hosts"
- remote_knownhosts="/root/.ssh/known_hosts"
- self.run_in_host("touch %s"%temp_knownhosts )
- for hostname in hostnames:
- utils.header("Scan Public %s key and store it in the known_host file(under the root image) "%hostname)
- scan=self.run_in_host('ssh-keyscan -t rsa %s >> %s '%(hostname,temp_knownhosts))
- #Store the public keys in the right root image
- self.copy_in_guest(temp_knownhosts,remote_knownhosts,True)
- #clean the temp keys file used
- self.run_in_host('rm -f %s '%temp_knownhosts )
- except Exception, err:
- print err
-
- def do_check_nodesSsh(self,minutes):
+
+ def do_nodes_ssh(self,minutes):
# compute timeout
timeout = datetime.datetime.now()+datetime.timedelta(minutes=minutes)
tocheck = self.all_hostnames()
- self.scan_publicKeys(tocheck)
+# self.scan_publicKeys(tocheck)
utils.header("checking Connectivity on nodes %r"%tocheck)
while tocheck:
for hostname in tocheck:
# try to ssh in nodes
- access=self.run_in_guest('ssh -i /etc/planetlab/root_ssh_key.rsa root@%s date'%hostname )
- if (not access):
+ 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:
utils.header('The node %s is sshable -->'%hostname)
# refresh tocheck
tocheck.remove(hostname)
else:
- (site_spec,node_spec)=self.locate_node(hostname)
+ # we will have tried real nodes once, in case they're up - but if not, just skip
+ (site_spec,node_spec)=self.locate_hostname(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)
# only useful in empty plcs
return True
- def nodes_ssh(self, options):
- return self.do_check_nodesSsh(minutes=2)
+ def nodes_ssh(self):
+ return self.do_nodes_ssh(minutes=2)
- def bootcd (self, options):
- for site_spec in self.plc_spec['sites']:
- test_site = TestSite (self,site_spec)
- for node_spec in site_spec['nodes']:
- test_node=TestNode (self,test_site,node_spec)
- test_node.create_boot_cd(options.path)
- return True
-
- def do_check_intiscripts(self):
- for site_spec in self.plc_spec['sites']:
- test_site = TestSite (self,site_spec)
- test_node = TestNode (self,test_site,site_spec['nodes'])
- for slice_spec in self.plc_spec['slices']:
- test_slice=TestSlice (self,test_site,slice_spec)
- test_sliver=TestSliver(self,test_node,test_slice)
- init_status=test_sliver.get_initscript(slice_spec)
- if (not init_status):
- return False
- return init_status
+ @node_mapper
+ def init_node (self): pass
+ @node_mapper
+ def bootcd (self): pass
+ @node_mapper
+ def configure_qemu (self): pass
+
+ def do_check_initscripts(self):
+ overall = True
+ for slice_spec in self.plc_spec['slices']:
+ if not slice_spec.has_key('initscriptname'):
+ continue
+ initscript=slice_spec['initscriptname']
+ for nodename in slice_spec['nodenames']:
+ (site,node) = self.locate_node (nodename)
+ # xxx - passing the wrong site - probably harmless
+ test_site = TestSite (self,site)
+ test_slice = TestSlice (self,test_site,slice_spec)
+ test_node = TestNode (self,test_site,node)
+ test_sliver = TestSliver (self, test_node, test_slice)
+ if not test_sliver.check_initscript(initscript):
+ overall = False
+ return overall
- def check_initscripts(self, options):
- return self.do_check_intiscripts()
+ def check_initscripts(self):
+ return self.do_check_initscripts()
- def initscripts (self, options):
+ def initscripts (self):
for initscript in self.plc_spec['initscripts']:
utils.pprint('Adding Initscript in plc %s'%self.plc_spec['name'],initscript)
- self.server.AddInitScript(self.auth_root(),initscript['initscript_fields'])
+ self.apiserver.AddInitScript(self.auth_root(),initscript['initscript_fields'])
return True
- def slices (self, options):
+ def slices (self):
return self.do_slices()
- def clean_slices (self, options):
+ def clean_slices (self):
return self.do_slices("delete")
def do_slices (self, action="add"):
utils.header('Created Slice %s'%slice['slice_fields']['name'])
return True
- def check_slices(self, options):
- for slice_spec in self.plc_spec['slices']:
- site_spec = self.locate_site (slice_spec['sitename'])
- test_site = TestSite(self,site_spec)
- test_slice=TestSlice(self,test_site,slice_spec)
- status=test_slice.do_check_slice(options)
- if (not status):
- return False
- return status
+ @slice_mapper_options
+ def check_slice(self): pass
+
+ @node_mapper
+ def clear_known_hosts (self): pass
- def start_nodes (self, options):
+ def start_nodes (self):
utils.header("Starting nodes")
for site_spec in self.plc_spec['sites']:
- TestSite(self,site_spec).start_nodes (options)
+ TestSite(self,site_spec).start_nodes (self.options)
+ return True
+
+ 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 locate_sliver_obj (self,nodename,slicename):
+ (site,node) = self.locate_node(nodename)
+ slice = self.locate_slice (slicename)
+ # build objects
+ test_site = TestSite (self, site)
+ test_node = TestNode (self, test_site,node)
+ # xxx the slice site is assumed to be the node site - mhh - probably harmless
+ test_slice = TestSlice (self, test_site, slice)
+ return TestSliver (self, test_node, test_slice)
+
+ def check_tcp (self):
+ specs = self.plc_spec['tcp_test']
+ overall=True
+ for spec in specs:
+ port = spec['port']
+ # server side
+ s_test_sliver = self.locate_sliver_obj (spec['server_node'],spec['server_slice'])
+ if not s_test_sliver.run_tcp_server(port,timeout=10):
+ overall=False
+ break
+
+ # idem for the client side
+ c_test_sliver = self.locate_sliver_obj(spec['server_node'],spec['server_slice'])
+ if not c_test_sliver.run_tcp_client(s_test_sliver.test_node.name(),port):
+ overall=False
+ return overall
+
+
+ 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)
+ print "-------------------- TestPlc.gather_logs : PLC's /var/log"
+ self.gather_var_logs ()
+ # (2)
+ print "-------------------- TestPlc.gather_logs : nodes's QEMU logs"
+ for site_spec in self.plc_spec['sites']:
+ test_site = TestSite (self,site_spec)
+ for node_spec in site_spec['nodes']:
+ test_node=TestNode(self,test_site,node_spec)
+ test_node.gather_qemu_logs()
+ # (3)
+ print "-------------------- TestPlc.gather_logs : nodes's /var/log"
+ self.gather_nodes_var_logs()
+ # (4)
+ print "-------------------- TestPlc.gather_logs : sample sliver's /var/log"
+ self.gather_first_sliver_logs()
return True
- def stop_nodes (self, options):
- self.kill_all_qemus()
+ def gather_first_sliver_logs(self):
+ try:
+ test_sliver = self.locate_first_sliver()
+ 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(command)
+ except Exception,e:
+ print 'Cannot locate first sliver - giving up',e
return True
- def check_tcp (self, options):
- #we just need to create a sliver object nothing else
- test_sliver=TestSliver(self,
- TestNode(self, TestSite(self,self.plc_spec['sites'][0]),
- self.plc_spec['sites'][0]['nodes'][0]),
- TestSlice(self,TestSite(self,self.plc_spec['sites'][0]),
- self.plc_spec['slices']))
- return test_sliver.do_check_tcp(self.plc_spec['tcp_param'],options)
+ 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())
+ utils.system(command)
+
+ def gather_nodes_var_logs (self):
+ for site_spec in self.plc_spec['sites']:
+ test_site = TestSite (self,site_spec)
+ for node_spec in site_spec['nodes']:
+ 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())
+ utils.system(command)
+
# returns the filename to use for sql dump/restore, using options.dbname if set
- def dbfile (self, database, options):
+ def dbfile (self, database):
# uses options.dbname if it is found
try:
- name=options.dbname
+ name=self.options.dbname
if not isinstance(name,StringTypes):
raise Exception
except:
name=str(d)
return "/root/%s-%s.sql"%(database,name)
- def db_dump(self, options):
-
- dump=self.dbfile("planetab4",options)
+ def db_dump(self):
+ dump=self.dbfile("planetab4")
self.run_in_guest('pg_dump -U pgsqluser planetlab4 -f '+ dump)
utils.header('Dumped planetlab4 database in %s'%dump)
return True
- def db_restore(self, options):
- dump=self.dbfile("planetab4",options)
+ def db_restore(self):
+ dump=self.dbfile("planetab4")
##stop httpd service
self.run_in_guest('service httpd stop')
# xxx - need another wrapper