first draft to clean up TestSsh, but bug not fixed for remote qemu nodes -a sigh
Thierry Parmentelat [Tue, 25 Mar 2008 20:37:02 +0000 (20:37 +0000)]
system/TestBox.py
system/TestKey.py
system/TestNode.py
system/TestPlc.py
system/TestSlice.py
system/TestSliver.py
system/TestSsh.py

index fe17923..b46ec52 100644 (file)
@@ -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"))
 
index 69520ad..d411a90 100644 (file)
@@ -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()
index aacd63d..7b5bccd 100644 (file)
@@ -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
index 0ee6315..9192f89 100644 (file)
@@ -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)
 
index 41757d4..fc5b528 100644 (file)
@@ -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
index 3aad927..654e401 100644 (file)
@@ -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
 
 
index b4668e0..b46b558 100644 (file)
@@ -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)