system/TestSliver.py

   1 import utils
   2 import os, os.path
   3 import datetime
   4 import time
   5 from TestSsh import TestSsh
   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         self.test_ssh =TestSsh(self.test_plc.test_ssh)
  14
  15     def is_local(self):
  16         return self.test_ssh.is_local()
  17
  18     def host_to_guest(self,command):
  19         return self.test_plc.host_to_guest(self.test_plc.vserver,self.test_plc.vservername,command)
  20
  21     def get_privateKey(self,slice_spec):
  22         try:
  23             (found,remote_privatekey)=self.test_slice.locate_key(slice_spec)
  24             return (found,remote_privatekey)
  25         except Exception,e:
  26             print str(e)
  27
  28     def get_initscript(self,slice_spec):
  29         (found,remote_privatekey)=self.get_privateKey(slice_spec)
  30         if not found :
  31             raise Exception,"Cannot find a valid key for slice %s"%self.test_slice.name()
  32         for hostname in  slice_spec['nodenames']:
  33             utils.header("Checking initiscript %s on the slice %s@%s"
  34                          %(slice_spec['initscriptname'],self.test_slice.name(),hostname))
  35             init_file=self.test_plc.run_in_guest('ssh -i %s %s@%s ls -l /tmp/init* '
  36                                                  %(remote_privatekey,self.test_slice.name(),hostname))
  37             if ( init_file):
  38                 return False
  39
  40         return True
  41
  42     def run_tcp_server (self,port):
  43         print ("XXX run_tcp_server not implemented")
  44         return True
  45     def run_tcp_client (self,hostname,port):
  46         print ("XXX run_tcp_client not implemented")
  47         return True
  48
  49     def run_tcpcheck(self,peer_spec,remote_privatekey):
  50         if peer_spec['peer_name']=="server":
  51             slice_ssh = TestSsh (peer_spec['server_name'],
  52                                  key=remote_privatekey,
  53                                  username=peer_spec['slice_name'])
  54             remote_server_command=slice_ssh.actual_command("./tcptest.py server -t 10")
  55             return self.test_plc.run_in_guest(remote_server_command)
  56
  57         else:
  58             slice_ssh = TestSsh (peer_spec['client_name'],
  59                                  key=remote_privatekey,
  60                                  username=peer_spec['slice_name'])
  61             client_command="/tcptest.py client -a %s -p %d"%(peer_spec['peer_server'],
  62                                                              peer_spec['server_port'])
  63             remote_client_command=slice_ssh.actual_command(client_command)
  64             return self.test_plc.run_in_guest(remote_client_command)
  65
  66     def do_check_tcp(self,tcp_param,options):
  67         for tcp_spec in tcp_param:
  68             #copy the tcptest file under the chroot
  69             localfile=remotefile="tcptest.py"
  70             self.test_plc.copy_in_guest(localfile, remotefile, False)
  71             peer_param=tcp_spec['tcp_fields']
  72             if (tcp_spec['tcp_fields']['peer_name']=='server'):
  73                 #server instruction
  74                 utils.header("Transfert the tcp script to the server at %s@%s"%(peer_param['slice_name'],
  75                                                                                 peer_param['server_name']))
  76                 slice_spec=self.test_slice.get_slice(peer_param['slice_name'])
  77                 (found,remote_privatekey)=self.get_privateKey(slice_spec)
  78                 cp_server_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey,peer_param['slice_name'],
  79                                                                    peer_param['server_name'])
  80                 self.test_plc.run_in_guest(cp_server_command)
  81                 serv_status=self.run_tcpcheck(peer_param,remote_privatekey)
  82                 if (serv_status):
  83                     utils.header("FAILED to check loop Connexion  on the %s server side"%peer_param['server_name'])
  84                     return False
  85             else:
  86                 #Client instruction
  87                 utils.header("Transfert the tcp script to the client at %s@%s" %(peer_param['slice_name'],
  88                                                                                  peer_param['client_name']))
  89                 slice_spec=self.test_slice.get_slice(peer_param['slice_name'])
  90                 (found,remote_privatekey)=self.get_privateKey(slice_spec)
  91                 cp_client_command="scp -i %s ./tcptest.py %s@%s:"%(remote_privatekey, peer_param['slice_name'],
  92                                                                    peer_param['client_name'])
  93                 self.test_plc.run_in_guest(cp_client_command)
  94                 client_status=self.run_tcpcheck(peer_param,remote_privatekey)
  95                 if ( serv_status):
  96                     utils.header("FAILED to Contact the server %s from the client side %s"%(peer_param['peer_server'],
  97                                                                                             peer_param['client_name']))
  98                     return False
  99
 100
 101         self.test_plc.run_in_guest("rm -rf tcptest.py")
 102         return True
 103
 104