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
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"))
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']
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()
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']
# 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
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
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']
# 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:
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',
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)
### 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):
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
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
### 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
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):
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):
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
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
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)
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):
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'])
#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)
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 ) :
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
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:
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
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)
(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'])
(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'],
return False
- self.test_ssh.run_in_guest("rm -rf tcptest.py")
+ self.test_plc.run_in_guest("rm -rf tcptest.py")
return True
#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
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)
git://git.onelab.eu / tests.git / commitdiff