from TestSlice import TestSlice
from TestSliver import TestSliver
from TestBox import TestBox
+from TestSsh import TestSsh
# step methods must take (self, options) and return a boolean
def __init__ (self,plc_spec):
self.plc_spec=plc_spec
self.path=os.path.dirname(sys.argv[0])
+ self.test_ssh=TestSsh(self.plc_spec['hostname'],self.path)
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)
+# utils.header('Using API url %s'%self.url)
self.server=xmlrpclib.Server(self.url,allow_none=True)
def name(self):
else:
return name+"[chroot]"
+ def hostname(self):
+ return self.plc_spec['hostname']
+
def is_local (self):
- return self.plc_spec['hostname'] == 'localhost'
+ 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
-
- # 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.plc_spec['hostname'],utils.backslash_shell_specials(command))
def full_command(self,command):
- return self.to_host(self.host_to_guest(command))
+ return self.test_ssh.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 utils.system(self.test_ssh.to_host(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"%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:
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.plc_spec['hostname'],chroot_dest,remotefile))
+ utils.system("scp %s %s:%s/%s"%(localfile,self.hostname(),chroot_dest,remotefile))
else:
- utils.system("scp %s %s@/vservers/%s/%s"%(localfile,self.plc_spec['hostname'],self.vservername,remotefile))
+ 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.full_command(remote))
+
def auth_root (self):
return {'Username':self.plc_spec['PLC_ROOT_USER'],
def kill_all_qemus(self,options):
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,options.buildname).kill_all_qemus()
return True
# make this a valid step
def list_all_qemus(self,options):
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,options.buildname).run_in_buildname("qemu-%s/kill-qemu-node -l %s"%(node.name(),node.name()))
+ return True
+
+ # kill only the right qemus
+ def list_qemus(self,options):
+ for (box,nodes) in self.gather_hostBoxes().iteritems():
+ # the fine-grain version
+ for node in nodes:
+ node.list_qemu()
return True
# kill only the right qemus
def kill_qemus(self,options):
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()
# 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):
# we need build dir for vtest-init-vserver
if self.is_local():
build_dir=self.path+"/build"
else:
# use a standard name - will be relative to HOME
- build_dir="tests-system-build"
+ build_dir="options.buildname"
+ # run checkout in any case - would do an update if already exists
build_checkout = "svn checkout %s %s"%(options.build_url,build_dir)
if self.run_in_host(build_checkout) != 0:
raise Exception,"Cannot checkout build dir"
# 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)
+ 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:
return self.install_vserver(options)
else:
return self.install_chroot(options)
-
+
### install_rpm
+ def cache_rpm(self,url):
+ self.run_in_host('rm -rf *.rpm')
+ utils.header('Curling rpm from %s'%url)
+ id= self.run_in_host('curl -O '+url)
+ if (id != 0):
+ raise Exception,"Could not get rpm from %s"%url
+ return False
+ return True
+
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)
+ rpm = os.path.basename(options.myplc_url)
+ if (not os.path.isfile(rpm)):
+ self.cache_rpm(options.myplc_url)
+ utils.header('Installing the : %s'%rpm)
+ self.run_in_host('rpm -Uvh '+rpm)
self.run_in_host('service plc mount')
return True
###
def configure(self,options):
- tmpname='%s/%s.plc-config-tty'%(options.path,self.name())
+ tmpname='%s.plc-config-tty'%(self.name())
fileconf=open(tmpname,'w')
for var in [ 'PLC_NAME',
'PLC_ROOT_PASSWORD',
# could use a TestKey class
def store_keys(self, options):
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):
else:
utils.header("Creating nodes for site %s in %s"%(test_site.name(),self.name()))
for node_spec in site_spec['nodes']:
- utils.show_spec('Creating node %s'%node_spec,node_spec)
+ utils.pprint('Creating node %s'%node_spec,node_spec)
test_node = TestNode (self,test_site,node_spec)
test_node.create_node ()
return True
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)
+ test_node.prepare_area()
+ test_node.create_boot_cd()
+ test_node.configure_qemu()
return True
def do_check_intiscripts(self):
def initscripts (self, options):
for initscript in self.plc_spec['initscripts']:
- utils.show_spec('Adding Initscript in plc %s'%self.plc_spec['name'],initscript)
+ utils.pprint('Adding Initscript in plc %s'%self.plc_spec['name'],initscript)
self.server.AddInitScript(self.auth_root(),initscript['initscript_fields'])
return True
utils.header("Deleting slices in site %s"%test_site.name())
test_slice.delete_slice()
else:
- utils.show_spec("Creating slice",slice)
+ utils.pprint("Creating slice",slice)
test_slice.create_slice()
utils.header('Created Slice %s'%slice['slice_fields']['name'])
return True
return True
def stop_nodes (self, options):
- self.kill_all_qemus()
+ self.kill_all_qemus(options)
return True
def check_tcp (self, options):
git://git.onelab.eu / tests.git / blobdiff