actual.__doc__=TestSlice.__dict__[method.__name__].__doc__
return actual
+# run a step but return True so that we can go on
+def ignore_result (method):
+ def wrappee (self):
+ # ssh_slice_ignore->ssh_slice
+ ref_name=method.__name__.replace('_ignore','').replace('force_','')
+ ref_method=TestPlc.__dict__[ref_name]
+ result=ref_method(self)
+ print "Actual (but ignored) result for %(ref_name)s is %(result)s"%locals()
+ return Ignored (result)
+ wrappee.__doc__="ignored version of " + method.__name__.replace('_ignore','').replace('ignore_','')
+ return wrappee
+
# a variant that expects the TestSlice method to return a list of CompleterTasks that
# are then merged into a single Completer run to avoid wating for all the slices
# esp. useful when a test fails of course
class slice_mapper__tasks (object):
# could not get this to work with named arguments
def __init__ (self,timeout_minutes,silent_minutes,period_seconds):
- print "timeout_minutes,silent_minutes,period_seconds",timeout_minutes,silent_minutes,period_seconds
self.timeout=timedelta(minutes=timeout_minutes)
self.silent=timedelta(minutes=silent_minutes)
self.period=timedelta(seconds=period_seconds)
actual.__doc__=TestAuthSfa.__dict__[method.__name__].__doc__
return actual
+class Ignored:
+ def __init__ (self,result):
+ self.result=result
+
SEP='<sep>'
SEPSFA='<sep_sfa>'
default_steps = [
'show', SEP,
'vs_delete','timestamp_vs','vs_create', SEP,
-# 'plc_install', 'mod_python', 'plc_configure', 'plc_start', SEP,
'plc_install', 'plc_configure', 'plc_start', SEP,
'keys_fetch', 'keys_store', 'keys_clear_known_hosts', SEP,
'plcapi_urls','speed_up_slices', SEP,
# we used to run plcsh_stress_test, and then ssh_node_debug and ssh_node_boot
# but as the stress test might take a while, we sometimes missed the debug mode..
'ssh_node_debug@1', 'plcsh_stress_test@1', SEP,
- 'ssh_node_boot@1', 'node_bmlogs@1', 'ssh_slice', 'ssh_slice_basics', 'check_initscripts', SEP,
+ 'ssh_node_boot@1', 'node_bmlogs@1', 'ssh_slice', 'ssh_slice_basics', 'check_initscripts_ignore', SEP,
'ssh_slice_sfa@1', 'sfa_delete_slice@1', 'sfa_delete_user@1', SEPSFA,
'cross_check_tcp@1', 'check_system_slice', SEP,
# check slices are turned off properly
'empty_slices', 'ssh_slice_off', SEP,
# check they are properly re-created with the same name
- 'fill_slices', 'ssh_slice', SEP,
- 'force_gather_logs', SEP,
+ 'fill_slices', 'ssh_slice_again_ignore', SEP,
+ 'gather_logs_force', SEP,
]
other_steps = [
'export', 'show_boxes', SEP,
'plc_db_dump' , 'plc_db_restore', SEP,
'check_netflow','check_drl', SEP,
'debug_nodemanager', SEP,
- 'standby_1_through_20',SEP,
+ 'standby_1_through_20','yes','no',SEP,
]
@staticmethod
def connect (self):
pass
- def actual_command_in_guest (self,command):
- return self.test_ssh.actual_command(self.host_to_guest(command),dry_run=self.options.dry_run)
+ def actual_command_in_guest (self,command, backslash=False):
+ raw1=self.host_to_guest(command)
+ raw2=self.test_ssh.actual_command(raw1,dry_run=self.options.dry_run, backslash=backslash)
+ return raw2
def start_guest (self):
return utils.system(self.test_ssh.actual_command(self.start_guest_in_host(),dry_run=self.options.dry_run))
def stop_guest (self):
return utils.system(self.test_ssh.actual_command(self.stop_guest_in_host(),dry_run=self.options.dry_run))
- def run_in_guest (self,command):
- return utils.system(self.actual_command_in_guest(command))
+ def run_in_guest (self,command,backslash=False):
+ raw=self.actual_command_in_guest(command,backslash)
+ return utils.system(raw)
def run_in_host (self,command):
return self.test_ssh.run_in_buildname(command, dry_run=self.options.dry_run)
+ # backslashing turned out so awful at some point that I've turned off auto-backslashing
+ # see e.g. plc_start esp. the version for f14
#command gets run in the plc's vm
def host_to_guest(self,command):
- if self.options.plcs_use_lxc:
- return "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null %s %s"%(self.vserverip,command)
+ # f14 still needs some extra help
+ if self.options.fcdistro == 'f14':
+ raw="virsh -c lxc:/// lxc-enter-namespace %s /usr/bin/env PATH=/bin:/sbin:/usr/bin:/usr/sbin %s" %(self.vservername,command)
else:
- return "vserver %s exec %s"%(self.vservername,command)
+ raw="virsh -c lxc:/// lxc-enter-namespace %s /bin/bash -c \\'%s\\'" %(self.vservername,command)
+ return raw
+ # this /vservers thing is legacy...
def vm_root_in_host(self):
- if self.options.plcs_use_lxc:
- return "/vservers/%s/rootfs/"%(self.vservername)
- else:
- return "/vservers/%s"%(self.vservername)
+ return "/vservers/%s/"%(self.vservername)
def vm_timestamp_path (self):
- if self.options.plcs_use_lxc:
- return "/vservers/%s/%s.timestamp"%(self.vservername,self.vservername)
- else:
- return "/vservers/%s.timestamp"%(self.vservername)
+ return "/vservers/%s/%s.timestamp"%(self.vservername,self.vservername)
#start/stop the vserver
def start_guest_in_host(self):
- if self.options.plcs_use_lxc:
- return "virsh -c lxc:// start %s"%(self.vservername)
- else:
- return "vserver %s start"%(self.vservername)
+ return "virsh -c lxc:/// start %s"%(self.vservername)
def stop_guest_in_host(self):
- if self.options.plcs_use_lxc:
- return "virsh -c lxc:// destroy %s"%(self.vservername)
- else:
- return "vserver %s stop"%(self.vservername)
+ return "virsh -c lxc:/// destroy %s"%(self.vservername)
# xxx quick n dirty
def run_in_guest_piped (self,local,remote):
domain=socket.gethostname().split('.',1)[1]
fqdn="%s.%s"%(self.plc_spec['host_box'],domain)
print "export BUILD=%s"%self.options.buildname
- if self.options.plcs_use_lxc:
- print "export PLCHOSTLXC=%s"%fqdn
- else:
- print "export PLCHOSTVS=%s"%fqdn
+ print "export PLCHOSTLXC=%s"%fqdn
print "export GUESTNAME=%s"%self.plc_spec['vservername']
vplcname=self.plc_spec['vservername'].split('-')[-1]
print "export GUESTHOSTNAME=%s.%s"%(vplcname,domain)
"vserver delete the test myplc"
stamp_path=self.vm_timestamp_path()
self.run_in_host("rm -f %s"%stamp_path)
- if self.options.plcs_use_lxc:
- self.run_in_host("virsh -c lxc:// destroy %s"%self.vservername)
- self.run_in_host("virsh -c lxc:// undefine %s"%self.vservername)
- self.run_in_host("rm -fr /vservers/%s"%self.vservername)
- return True
- else:
- self.run_in_host("vserver --silent %s delete"%self.vservername)
- return True
+ self.run_in_host("virsh -c lxc:// destroy %s"%self.vservername)
+ self.run_in_host("virsh -c lxc:// undefine %s"%self.vservername)
+ self.run_in_host("rm -fr /vservers/%s"%self.vservername)
+ return True
### install
# historically the build was being fetched by the tests
repo_url = self.options.arch_rpms_url
for level in [ 'arch' ]:
repo_url = os.path.dirname(repo_url)
+
+ # invoke initvm (drop support for vs)
+ script="lbuild-initvm.sh"
+ script_options=""
# pass the vbuild-nightly options to [lv]test-initvm
- test_env_options=""
- test_env_options += " -p %s"%self.options.personality
- test_env_options += " -d %s"%self.options.pldistro
- test_env_options += " -f %s"%self.options.fcdistro
- if self.options.plcs_use_lxc:
- script="ltest-initvm.sh"
- else:
- script="vtest-initvm.sh"
+ script_options += " -p %s"%self.options.personality
+ script_options += " -d %s"%self.options.pldistro
+ script_options += " -f %s"%self.options.fcdistro
+ script_options += " -r %s"%repo_url
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
+ script_options += " -n %s"%vserver_hostname
except:
print "Cannot reverse lookup %s"%self.vserverip
print "This is considered fatal, as this might pollute the test results"
return False
- create_vserver="%(build_dir)s/%(script)s %(test_env_options)s %(vserver_name)s %(repo_url)s -- %(vserver_options)s"%locals()
+ create_vserver="%(build_dir)s/%(script)s %(script_options)s %(vserver_name)s"%locals()
return self.run_in_host(create_vserver) == 0
### install_rpm
utils.system('rm %s'%tmpname)
return True
+# f14 is a bit odd in this respect, although this worked fine in guests up to f18
+# however using a vplc guest under f20 requires this trick
+# the symptom is this: service plc start
+# Starting plc (via systemctl): Failed to get D-Bus connection: \
+# Failed to connect to socket /org/freedesktop/systemd1/private: Connection refused
+# weird thing is the doc says f14 uses upstart by default and not systemd
+# so this sounds kind of harmless
+ def start_service (self,service): return self.start_stop_service (service,'start')
+ def stop_service (self,service): return self.start_stop_service (service,'stop')
+
+ def start_stop_service (self, service,start_or_stop):
+ "utility to start/stop a service with the special trick for f14"
+ if self.options.fcdistro != 'f14':
+ return self.run_in_guest ("service %s %s"%(service,start_or_stop))==0
+ else:
+ # patch /sbin/service so it does not reset environment
+ # this is because our own scripts in turn call service
+ self.run_in_guest ('sed -i -e \\"s,env -i,env,\\" /sbin/service')
+ return self.run_in_guest("SYSTEMCTL_SKIP_REDIRECT=true service %s %s"%(service,start_or_stop))==0
+
def plc_start(self):
"service plc start"
- self.run_in_guest('service plc start')
- return True
+ return self.start_service ('plc')
def plc_stop(self):
"service plc stop"
- self.run_in_guest('service plc stop')
- return True
-
+ return self.stop_service ('plc')
+
def vs_start (self):
"start the PLC vserver"
self.start_guest()
@slice_mapper__tasks(20,19,15)
def ssh_slice_off (self): pass
+ # use another name so we can exclude/ignore it from the tests on the nightly command line
+ def ssh_slice_again(self): return self.ssh_slice()
+ # note that simply doing ssh_slice_again=ssh_slice would kind od work too
+ # but for some reason the ignore-wrapping thing would not
+
@slice_mapper
def ssh_slice_basics(self): pass
def sfa_import(self):
"use sfaadmin to import from plc"
auth=self.plc_spec['sfa']['SFA_REGISTRY_ROOT_AUTH']
- return \
- self.run_in_guest('sfaadmin reg import_registry')==0
-# not needed anymore
-# self.run_in_guest('cp /etc/sfa/authorities/%s/%s.pkey /etc/sfa/authorities/server.key'%(auth,auth))
+ return self.run_in_guest('sfaadmin reg import_registry')==0
def sfa_start(self):
"service sfa start"
- return self.run_in_guest('service sfa start')==0
+ return self.start_service('sfa')
+
def sfi_configure(self):
"Create /root/sfi on the plc side for sfi client configuration"
def sfa_stop(self):
"service sfa stop"
- self.run_in_guest('service sfa stop')==0
- return True
+ return self.stop_service ('sfa')
def populate (self):
"creates random entries in the PLCAPI"
utils.header('Database restored from ' + dump)
+ @staticmethod
+ def create_ignore_steps ():
+ for step in TestPlc.default_steps + TestPlc.other_steps:
+ # default step can have a plc qualifier
+ if '@' in step: (step,qualifier)=step.split('@')
+ # or be defined as forced or ignored by default
+ for keyword in ['_ignore','_force']:
+ if step.endswith (keyword): step=step.replace(keyword,'')
+ if step == SEP or step == SEPSFA : continue
+ method=getattr(TestPlc,step)
+ name=step+'_ignore'
+ wrapped=ignore_result(method)
+# wrapped.__doc__ = method.__doc__ + " (run in ignore-result mode)"
+ setattr(TestPlc, name, wrapped)
+
+# @ignore_result
+# def ssh_slice_again_ignore (self): pass
+# @ignore_result
+# def check_initscripts_ignore (self): pass
+
def standby_1_through_20(self):
"""convenience function to wait for a specified number of minutes"""
pass
def standby_19(): pass
@standby_generic
def standby_20(): pass
+
+ # convenience for debugging the test logic
+ def yes (self): return True
+ def no (self): return False
git://git.onelab.eu / tests.git / blobdiff