From: Thierry Parmentelat Date: Tue, 25 Mar 2008 20:37:02 +0000 (+0000) Subject: first draft to clean up TestSsh, but bug not fixed for remote qemu nodes -a sigh X-Git-Tag: tests-4.2-4~166 X-Git-Url: http://git.onelab.eu/?a=commitdiff_plain;h=cd80e5acaa38ea44818c604a573e50e3f45ce082;p=tests.git first draft to clean up TestSsh, but bug not fixed for remote qemu nodes -a sigh --- diff --git a/system/TestBox.py b/system/TestBox.py index fe17923..b46ec52 100644 --- a/system/TestBox.py +++ b/system/TestBox.py @@ -11,7 +11,7 @@ class TestBox: self.hostname_value=hostname self.buildname=buildname self.key=key - self.test_ssh=TestSsh(self,buildname) + self.test_ssh=TestSsh(self.hostname_value,self.buildname,self.key) def hostname (self): return self.hostname_value @@ -30,18 +30,15 @@ class TestBox: return self.test_ssh.run_in_buildname (command) # should use rsync instead def copy (self,local_file,recursive=False): - return self.test_ssh.copy (local_file,recursive=False) - - def clean_dir (self): - if self.is_local(): - return 0 - return utils.system("rm -rf %s"%self.buildname) + return self.test_ssh.copy (local_file,recursive) + + def clean_dir (self,dirname): + return self.test_ssh.clean_dir(dirname) - def mkdir (self): - if self.is_local(): - return 0 - return utils.system("mkdir %s"%self.buildname) + def mkdir (self,direname): + return self.test_ssh.mkdir(direname) + def kill_all_qemus(self): - self.run_in_buildname("killall qemu") + utils.system(self.test_ssh.to_host("killall qemu")) diff --git a/system/TestKey.py b/system/TestKey.py index 69520ad..d411a90 100644 --- a/system/TestKey.py +++ b/system/TestKey.py @@ -1,11 +1,13 @@ import utils import os, os.path +from TestSsh import TestSsh class TestKey: def __init__ (self,test_plc,key_spec): self.test_plc=test_plc self.key_spec=key_spec + self.test_ssh=TestSsh(self.test_plc.test_ssh) def name(self): return self.key_spec['name'] @@ -15,6 +17,18 @@ class TestKey: def privatepath(self): return "keys/%s.rsa"%(self.name()) + def store_remote_key(self,hostname): + #Not tested yet, don't know if needed + pub=self.publicpath() + priv=self.privatepath() + utils.header("Storing key %s in %s into %s "%(self.name(),pub,hostname)) + dir=os.path.dirname(pub) + utils.system(self.test_ssh.to_host("mkdir %s"%dir)) + utils.system(self.test_ssh.to_host("cat %s >> %s"%(self.key_spec['key_fields']['key'],pub))) + utils.system(self.test_ssh.to_host("cat %s >> %s"%(self.key_spec['private'],priv))) + utils.system(self.test_ssh.to_host("chmod %s 0400"%priv)) + utils.system(self.test_ssh.to_host("chmod %s 0444"%pub)) + def store_key(self): pub=self.publicpath() priv=self.privatepath() diff --git a/system/TestNode.py b/system/TestNode.py index aacd63d..7b5bccd 100644 --- a/system/TestNode.py +++ b/system/TestNode.py @@ -11,7 +11,7 @@ class TestNode: self.test_plc=test_plc self.test_site=test_site self.node_spec=node_spec - + def name(self): return self.node_spec['node_fields']['hostname'] @@ -137,10 +137,12 @@ class TestNode: # if relevant, push the qemu area onto the host box if ( not self.test_box().is_local()): utils.header ("Transferring configuration files for node %s onto %s"%(self.name(),self.host_box())) - self.test_box().clean_dir() - self.test_box().mkdir() + self.test_box().clean_dir(self.buildname()) + self.test_box().mkdir(self.buildname()) + self.test_box().mkdir("nodeslogs") self.test_box().copy(self.areaname(),recursive=True) + def start_node (self,options): model=self.node_spec['node_fields']['model'] #starting the Qemu nodes before @@ -154,8 +156,7 @@ class TestNode: utils.header("Starting qemu node %s on %s"%(self.name(),test_box.hostname())) test_box.run_in_buildname("qemu-%s/env-qemu start >> nodeslogs/%s.log"%(self.name(),self.name())) - test_box.run_in_buildname("qemu-%s/start-qemu-node 2>&1 >> nodeslogs/%s.log &"%( - self.name(),self.name())) + test_box.run_in_buildname("qemu-%s/start-qemu-node 2>&1 >> nodeslogs/%s.log &"%(self.name(),self.name())) def kill_qemu (self): #Prepare the log file before killing the nodes diff --git a/system/TestPlc.py b/system/TestPlc.py index 0ee6315..9192f89 100644 --- a/system/TestPlc.py +++ b/system/TestPlc.py @@ -36,7 +36,7 @@ class TestPlc: def __init__ (self,plc_spec): self.plc_spec=plc_spec self.path=os.path.dirname(sys.argv[0]) - self.test_ssh=TestSsh(self) + self.test_ssh=TestSsh(self.plc_spec['hostname'],self.path) try: self.vserverip=plc_spec['vserverip'] self.vservername=plc_spec['vservername'] @@ -65,7 +65,16 @@ class TestPlc: # would help, but not strictly necessary def connect (self): pass + + def full_command(self,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.test_ssh.to_host(command)) + #command gets run in the chroot/vserver def host_to_guest(self,command): if self.vserver: @@ -90,6 +99,12 @@ class TestPlc: 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.full_command(remote)) + + def auth_root (self): return {'Username':self.plc_spec['PLC_ROOT_USER'], 'AuthMethod':'password', @@ -172,8 +187,8 @@ class TestPlc: 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.test_ssh.run_in_guest("mkdir /root/.ssh") - self.test_ssh.run_in_guest("chmod 700 /root/.ssh") + 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) @@ -183,17 +198,17 @@ class TestPlc: ### uninstall def uninstall_chroot(self,options): - self.test_ssh.run_in_host('service plc safestop') + self.run_in_host('service plc safestop') #####detecting the last myplc version installed and remove it - self.test_ssh.run_in_host('rpm -e myplc') + self.run_in_host('rpm -e myplc') ##### Clean up the /plc directory - self.test_ssh.run_in_host('rm -rf /plc/data') + self.run_in_host('rm -rf /plc/data') ##### stop any running vservers - self.test_ssh.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 /vservers/* | sed -e s,/vservers/,,) ; do vserver $vserver stop ; done') return True def uninstall_vserver(self,options): - self.test_ssh.run_in_host("vserver --silent %s delete"%self.vservername) + self.run_in_host("vserver --silent %s delete"%self.vservername) return True def uninstall(self,options): @@ -222,7 +237,7 @@ class TestPlc: 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.test_ssh.run_in_host(build_checkout) != 0: + 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 @@ -231,7 +246,7 @@ class TestPlc: 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.test_ssh.run_in_host(create_vserver) != 0: + if self.run_in_host(create_vserver) != 0: raise Exception,"Could not create vserver for %s"%self.vservername return True @@ -243,9 +258,9 @@ class TestPlc: ### install_rpm def cache_rpm(self,url): - self.test_ssh.run_in_host('rm -rf *.rpm') + self.run_in_host('rm -rf *.rpm') utils.header('Curling rpm from %s'%url) - id= self.test_ssh.run_in_host('curl -O '+url) + id= self.run_in_host('curl -O '+url) if (id != 0): raise Exception,"Could not get rpm from %s"%url return False @@ -256,12 +271,12 @@ class TestPlc: if (not os.path.isfile(rpm)): self.cache_rpm(options.myplc_url) utils.header('Installing the : %s'%rpm) - self.test_ssh.run_in_host('rpm -Uvh '+rpm) - self.test_ssh.run_in_host('service plc mount') + self.run_in_host('rpm -Uvh '+rpm) + self.run_in_host('service plc mount') return True def install_rpm_vserver(self,options): - self.test_ssh.run_in_guest("yum -y install myplc-native") + self.run_in_guest("yum -y install myplc-native") return True def install_rpm(self,options): @@ -290,29 +305,29 @@ class TestPlc: fileconf.write('q\n') fileconf.close() utils.system('cat %s'%tmpname) - self.test_ssh.run_in_guest_piped('cat %s'%tmpname,'plc-config-tty') + self.run_in_guest_piped('cat %s'%tmpname,'plc-config-tty') utils.system('rm %s'%tmpname) return True # the chroot install is slightly different to this respect def start(self, options): if self.vserver: - self.test_ssh.run_in_guest('service plc start') + self.run_in_guest('service plc start') else: - self.test_ssh.run_in_host('service plc start') + self.run_in_host('service plc start') return True def stop(self, options): if self.vserver: - self.test_ssh.run_in_guest('service plc stop') + self.run_in_guest('service plc stop') else: - self.test_ssh.run_in_host('service plc stop') + self.run_in_host('service plc stop') return True # 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): @@ -446,14 +461,14 @@ class TestPlc: try: temp_knownhosts="/root/known_hosts" remote_knownhosts="/root/.ssh/known_hosts" - self.test_ssh.run_in_host("touch %s"%temp_knownhosts ) + 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.test_ssh.run_in_host('ssh-keyscan -t rsa %s >> %s '%(hostname,temp_knownhosts)) + 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.test_ssh.run_in_host('rm -f %s '%temp_knownhosts ) + self.run_in_host('rm -f %s '%temp_knownhosts ) except Exception, err: print err @@ -466,7 +481,7 @@ class TestPlc: while tocheck: for hostname in tocheck: # try to ssh in nodes - access=self.test_ssh.run_in_guest('ssh -i /etc/planetlab/root_ssh_key.rsa root@%s date'%hostname ) + access=self.run_in_guest('ssh -i /etc/planetlab/root_ssh_key.rsa root@%s date'%hostname ) if (not access): utils.header('The node %s is sshable -->'%hostname) # refresh tocheck @@ -586,20 +601,20 @@ class TestPlc: def db_dump(self, options): dump=self.dbfile("planetab4",options) - self.test_ssh.run_in_guest('pg_dump -U pgsqluser planetlab4 -f '+ dump) + 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) ##stop httpd service - self.test_ssh.run_in_guest('service httpd stop') + self.run_in_guest('service httpd stop') # xxx - need another wrapper - self.test_ssh.run_in_guest_piped('echo drop database planetlab4','psql --user=pgsqluser template1') - self.test_ssh.run_in_guest('createdb -U postgres --encoding=UNICODE --owner=pgsqluser planetlab4') - self.test_ssh.run_in_guest('psql -U pgsqluser planetlab4 -f '+dump) + self.run_in_guest_piped('echo drop database planetlab4','psql --user=pgsqluser template1') + self.run_in_guest('createdb -U postgres --encoding=UNICODE --owner=pgsqluser planetlab4') + self.run_in_guest('psql -U pgsqluser planetlab4 -f '+dump) ##starting httpd service - self.test_ssh.run_in_guest('service httpd start') + self.run_in_guest('service httpd start') utils.header('Database restored from ' + dump) diff --git a/system/TestSlice.py b/system/TestSlice.py index 41757d4..fc5b528 100644 --- a/system/TestSlice.py +++ b/system/TestSlice.py @@ -14,17 +14,11 @@ class TestSlice: self.test_plc=test_plc self.test_site=test_site self.slice_spec=slice_spec - self.test_ssh=TestSsh(self) + self.test_ssh=TestSsh(self.test_plc.test_ssh) def name(self): return self.slice_spec['slice_fields']['name'] - def is_local(self): - return self.test_ssh.is_local() - - def host_to_guest(self,command): - return self.test_plc.host_to_guest(command) - def get_slice(self,slice_name): for slice_spec in self.test_plc.plc_spec['slices']: if(slice_spec['slice_fields']['name']== slice_name): @@ -67,7 +61,7 @@ class TestSlice: utils.header("Messing with known_hosts for slice %s"%self.name()) # scan nodenames for nodename in self.slice_spec['nodenames']: - self.test_ssh.run_in_guest("sed -i -e /^%s/d /root/.ssh/known_hosts"%nodename) + self.test_plc.run_in_guest("sed -i -e /^%s/d /root/.ssh/known_hosts"%nodename) #scan public key and update the known_host file in the root image self.test_plc.scan_publicKeys(self.slice_spec['nodenames']) @@ -87,7 +81,7 @@ class TestSlice: #create dir in plc root image remote_privatekey="/root/keys/%s.rsa"%keyname if not os.path.isfile(remote_privatekey): - self.test_ssh.run_in_guest("mkdir -p /root/keys" ) + self.test_plc.run_in_guest("mkdir -p /root/keys" ) self.test_plc.copy_in_guest(privatekey,remote_privatekey,True) return (found,remote_privatekey) @@ -109,7 +103,7 @@ class TestSlice: break while (bool): utils.header('trying to connect to %s@%s'%(self.name(),hostname)) - Date=self.test_ssh.run_in_guest('ssh -i %s %s@%s date'%(remote_privatekey,self.name(),hostname)) + Date=self.test_plc.run_in_guest('ssh -i %s %s@%s date'%(remote_privatekey,self.name(),hostname)) if (Date==0): break elif ( start_time <= dead_time ) : @@ -117,13 +111,13 @@ class TestSlice: time.sleep(45) elif (options.forcenm): utils.header('%s@%s : restarting nm in case is in option on %s'%(self.name(),hostname,hostname)) - access=self.test_ssh.run_in_guest('ssh -i /etc/planetlab/root_ssh_key.rsa root@%s service nm restart'%hostname) + access=self.test_plc.run_in_guest('ssh -i /etc/planetlab/root_ssh_key.rsa root@%s service nm restart'%hostname) if (access==0): utils.header('nm restarted on %s'%hostname) else: utils.header('%s@%s : Failed to restart the NM on %s'%(self.name(),hostname,hostname)) utils.header('Try to reconnect to %s@%s after the tentative of restarting NM'%(self.name(),hostname)) - connect=self.test_ssh.run_in_guest('ssh -i %s %s@%s date'%(remote_privatekey,self.name(),hostname)) + connect=self.test_plc.run_in_guest('ssh -i %s %s@%s date'%(remote_privatekey,self.name(),hostname)) if (not connect): utils.header('connected to %s@%s -->'%(self.name(),hostname)) break diff --git a/system/TestSliver.py b/system/TestSliver.py index 3aad927..654e401 100644 --- a/system/TestSliver.py +++ b/system/TestSliver.py @@ -10,13 +10,13 @@ class TestSliver: self.test_plc=test_plc self.test_node=test_node self.test_slice=test_slice - self.test_ssh =TestSsh(self) + self.test_ssh =TestSsh(self.test_plc.test_ssh) def is_local(self): return self.test_ssh.is_local() def host_to_guest(self,command): - return self.test_plc.host_to_guest(command) + return self.test_plc.host_to_guest(self.test_plc.vserver,self.test_plc.vservername,command) def get_privateKey(self,slice_spec): try: @@ -32,7 +32,7 @@ class TestSliver: for hostname in slice_spec['nodenames']: utils.header("Checking initiscript %s on the slice %s@%s" %(slice_spec['initscriptname'],self.test_slice.name(),hostname)) - init_file=self.test_ssh.run_in_guest('ssh -i %s %s@%s ls -l /tmp/init* ' + init_file=self.test_plc.run_in_guest('ssh -i %s %s@%s ls -l /tmp/init* ' %(remote_privatekey,self.test_slice.name(),hostname)) if ( init_file): return False @@ -43,13 +43,13 @@ class TestSliver: if peer_spec['peer_name']=="server": tcp_command="ssh -i %s %s@%s ./tcptest.py server -t 10"%(remote_privatekey, peer_spec['slice_name'], peer_spec['server_name']) - return self.test_ssh.run_in_guest(tcp_command) + return self.test_plc.run_in_guest(tcp_command) else: tcp_command="ssh -i %s %s@%s ./tcptest.py client -a %s -p %d"%(remote_privatekey, peer_spec['slice_name'], peer_spec['client_name'],peer_spec['peer_server'], peer_spec['server_port']) - return self.test_ssh.run_in_guest(tcp_command) + return self.test_plc.run_in_guest(tcp_command) @@ -67,7 +67,7 @@ class TestSliver: (found,remote_privatekey)=self.get_privateKey(slice_spec) cp_server_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey,peer_param['slice_name'], peer_param['server_name']) - self.test_ssh.run_in_guest(cp_server_command) + self.test_plc.run_in_guest(cp_server_command) serv_status=self.run_tcpcheck(peer_param,remote_privatekey) if (serv_status): utils.header("FAILED to check loop Connexion on the %s server side"%peer_param['server_name']) @@ -80,7 +80,7 @@ class TestSliver: (found,remote_privatekey)=self.get_privateKey(slice_spec) cp_client_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey, peer_param['slice_name'], peer_param['client_name']) - self.test_ssh.run_in_guest(cp_client_command) + self.test_plc.run_in_guest(cp_client_command) client_status=self.run_tcpcheck(peer_param,remote_privatekey) if ( serv_status): utils.header("FAILED to Contact the server %s from the client side %s"%(peer_param['peer_server'], @@ -88,7 +88,7 @@ class TestSliver: return False - self.test_ssh.run_in_guest("rm -rf tcptest.py") + self.test_plc.run_in_guest("rm -rf tcptest.py") return True diff --git a/system/TestSsh.py b/system/TestSsh.py index b4668e0..b46b558 100644 --- a/system/TestSsh.py +++ b/system/TestSsh.py @@ -1,14 +1,12 @@ #this class is used for any ssh command and #also for any remote or a local command independently #on which box this must be done. -#new TestSsh object take like an argument an instance -#of the class where it was created import os.path import utils class TestSsh: - + # inserts a backslash before each occurence of the following chars # \ " ' < > & | ; ( ) $ * ~ @staticmethod @@ -35,62 +33,49 @@ class TestSsh: utils.header("WARNING : something wrong in is_local_hostname with hostname=%s"%hostname) return False - # buildname is the name of a directory that we can use in $hostname's homedir (/root) - def __init__(self,caller,buildname=None,key=None): - self.caller=caller + def __init__(self,hostname,buildname=None,key=None): + self.hostname=hostname self.buildname=buildname - self._key=key + self.key=key - def hostname(self): - return self.caller.hostname() - def is_local(self): - return TestSsh.is_local_hostname(self.hostname()) + def is_local(self): + return TestSsh.is_local_hostname(self.hostname) + # 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(),TestSsh.backslash_shell_specials(command)) + return "ssh %s %s"%(self.hostname,TestSsh.backslash_shell_specials(command)) - def full_command(self,command): - return self.to_host(self.caller.host_to_guest(command)) + def clean_dir (self,dirname): + if self.is_local(): + return 0 + return utils.system(self.to_host("rm -rf %s"%dirname)) - 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)) + def mkdir (self,dirname): + if self.is_local(): + return 0 + return utils.system(self.to_host("mkdir %s"%dirname)) - # xxx quick n dirty - def run_in_guest_piped (self,local,remote): - return utils.system(local+" | "+self.full_command(remote)) - def run_in_buildname (self,command): - if not self.buildname: - utils.header ("WARNING : TestSsh.run_in_buildname without a buildname") - return 1 if self.is_local(): return utils.system(command) ssh_command="ssh " - if self.caller.key: - ssh_command += "-i %s.rsa "%(self.caller.key) - ssh_command += "%s %s/%s"%(self.hostname(), - self.buildname, - TestSsh.backslash_shell_specials(command)) + if self.key: + ssh_command += "-i %s.rsa "%(self.key) + ssh_command += "%s %s/%s"%(self.hostname,self.buildname,TestSsh.backslash_shell_specials(command)) return utils.system(ssh_command) def copy (self,local_file,recursive=False): - if not self.buildname: - utils.header ("WARNING : TestSsh.copy without a buildname") - return 1 if self.is_local(): return 0 command="scp " if recursive: command += "-r " - if self.caller.key: + if self.key: command += "-i %s.rsa " - command +="%s %s:%s/%s"%(local_file,self.hostname(),self.buildname, + command +="%s %s:%s/%s"%(local_file,self.hostname,self.buildname, os.path.basename(local_file) or ".") return utils.system(command)