system/TestSliver.py

   1 import utils
   2 import os, os.path
   3 import datetime
   4 import time
   5
   6
   7 class TestSliver:
   8
   9     def __init__ (self,test_plc,test_node,test_slice):
  10         self.test_plc=test_plc
  11         self.test_node=test_node
  12         self.test_slice=test_slice
  13
  14     def get_privateKey(self,slice_spec):
  15         try:
  16             (found,remote_privatekey)=self.test_slice.locate_key(slice_spec)
  17             return (found,remote_privatekey)
  18         except Exception,e:
  19             print str(e)
  20
  21     def get_initscript(self,slice_spec):
  22         (found,remote_privatekey)=self.get_privateKey(slice_spec)
  23         if not found :
  24             raise Exception,"Cannot find a valid key for slice %s"%self.test_slice.name()
  25         for hostname in  slice_spec['nodenames']:
  26             utils.header("Checking initiscript %s on the slice %s@%s"
  27                          %(slice_spec['initscriptname'],self.test_slice.name(),hostname))
  28             init_file=self.test_plc.run_in_guest('ssh -i %s %s@%s ls -l /tmp/init* '
  29                                                  %(remote_privatekey,self.test_slice.name(),hostname))
  30             if ( init_file):
  31                 return False
  32
  33         return True
  34
  35     def run_tcpcheck(self,peer_spec,remote_privatekey):
  36         if peer_spec['peer_name']=="server":
  37             tcp_command="ssh -i %s %s@%s ./tcptest.py server -t 10"%(remote_privatekey, peer_spec['slice_name'],
  38                                                                    peer_spec['server_name'])
  39             return self.test_plc.run_in_guest(tcp_command)
  40
  41         else:
  42             tcp_command="ssh -i %s %s@%s ./tcptest.py client -a %s -p %d"%(remote_privatekey, peer_spec['slice_name'],
  43                                                                            peer_spec['client_name'],peer_spec['peer_server'],
  44                                                                            peer_spec['server_port'])
  45             return self.test_plc.run_in_guest(tcp_command)
  46
  47
  48
  49     def do_check_tcp(self,tcp_param,options):
  50         for tcp_spec in tcp_param:
  51             #copy the tcptest file under the chroot
  52             path=options.path
  53             localfile="/root/"+path+"/tcptest.py"
  54             remotefile="tcptest.py"
  55             self.test_plc.copy_in_guest(localfile, remotefile, False)
  56             peer_param=tcp_spec['tcp_fields']
  57             if (tcp_spec['tcp_fields']['peer_name']=='server'):
  58                 #server instruction
  59                 utils.header("Transfert the tcp script to the server at %s@%s"%(peer_param['slice_name'],
  60                                                                                 peer_param['server_name']))
  61                 slice_spec=self.test_slice.get_slice(peer_param['slice_name'])
  62                 (found,remote_privatekey)=self.get_privateKey(slice_spec)
  63                 cp_server_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey,peer_param['slice_name'],
  64                                                                    peer_param['server_name'])
  65                 self.test_plc.run_in_guest(cp_server_command)
  66                 serv_status=self.run_tcpcheck(peer_param,remote_privatekey)
  67                 if (serv_status):
  68                     utils.header("FAILED to check loop Connexion  on the %s server side"%peer_param['server_name'])
  69                     return False
  70             else:
  71                 #Client instruction
  72                 utils.header("Transfert the tcp script to the client at %s@%s" %(peer_param['slice_name'],
  73                                                                                  peer_param['client_name']))
  74                 slice_spec=self.test_slice.get_slice(peer_param['slice_name'])
  75                 (found,remote_privatekey)=self.get_privateKey(slice_spec)
  76                 cp_client_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey, peer_param['slice_name'],
  77                                                                    peer_param['client_name'])
  78                 self.test_plc.run_in_guest(cp_client_command)
  79                 client_status=self.run_tcpcheck(peer_param,remote_privatekey)
  80                 if ( serv_status):
  81                     utils.header("FAILED to Contact the server %s from the client side %s"%(peer_param['peer_server'],
  82                                                                                             peer_param['client_name']))
  83                     return False
  84
  85
  86         self.test_plc.run_in_guest("rm -rf tcptest.py")
  87         return True
  88
  89