tests/selenium/SeleniumServerManager.php

   1 <?php
   2 /**
   3  * Selenium server manager
   4  *
   5  * @file
   6  * @ingroup Testing
   7  * Copyright (C) 2010 Dan Nessett <dnessett@yahoo.com>
   8  * http://citizendium.org/
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @addtogroup Testing
  26  */
  27
  28 class SeleniumServerManager {
  29         private $SeleniumStartServer = false;
  30         private $OS = '';
  31         private $SeleniumServerPid = 'NaN';
  32         private $SeleniumServerPort = 4444;
  33         private $SeleniumServerStartTimeout = 10; // 10 secs.
  34         private $SeleniumServerExecPath;
  35
  36         public function __construct( $startServer,
  37                                          $serverPort,
  38                                          $serverExecPath ) {
  39                 $this->OS = (string) PHP_OS;
  40                 if ( isset( $startServer ) )
  41                         $this->SeleniumStartServer = $startServer;
  42                 if ( isset( $serverPort ) )
  43                         $this->SeleniumServerPort = $serverPort;
  44                 if ( isset( $serverExecPath ) )
  45                         $this->SeleniumServerExecPath = $serverExecPath;
  46                 return;
  47         }
  48
  49         // Getters for certain private attributes. No setters, since they
  50         // should not change after the manager object is created.
  51
  52         public function getSeleniumStartServer() {
  53                 return $this->SeleniumStartServer;
  54         }
  55
  56         public function getSeleniumServerPort() {
  57                 return $this->SeleniumServerPort;
  58         }
  59
  60         public function getSeleniumServerPid() {
  61                 return $this->SeleniumServerPid;
  62         }
  63
  64         // Changing value of SeleniumStartServer allows starting server after
  65         // creation of the class instance. Only allow setting SeleniumStartServer
  66         // to true, since after server is started, it is shut down by stop().
  67
  68         public function setSeleniumStartServer( $startServer ) {
  69                 if ( $startServer == true ) $this->SeleniumStartServer = true;
  70         }
  71
  72         // return values are: 1) started - server started, 2) failed -
  73         // server not started, 3) running - instructed to start server, but
  74         // server already running
  75
  76         public function start() {
  77
  78                 if ( !$this->SeleniumStartServer ) return 'failed';
  79
  80                 // commented out cases are untested
  81
  82                 switch ( $this->OS ) {
  83                         case "Linux":
  84 #                       case' CYGWIN_NT-5.1':
  85                         case 'Darwin':
  86 #                       case 'FreeBSD':
  87 #                       case 'HP-UX':
  88 #                       case 'IRIX64':
  89 #                       case 'NetBSD':
  90 #                       case 'OpenBSD':
  91 #                       case 'SunOS':
  92 #                       case 'Unix':
  93                                 // *nix based OS
  94                                 return $this->startServerOnUnix();
  95                                 break;
  96                         case "Windows":
  97                         case "WIN32":
  98                         case "WINNT":
  99                                 // Windows
 100                                 return $this->startServerOnWindows();
 101                                 break;
 102                         default:
 103                                 // An untested OS
 104                                 return 'failed';
 105                                 break;
 106                 }
 107         }
 108
 109         public function stop() {
 110
 111                 // commented out cases are untested
 112
 113                 switch ( $this->OS ) {
 114                         case "Linux":
 115 #                       case' CYGWIN_NT-5.1':
 116                         case 'Darwin':
 117 #                       case 'FreeBSD':
 118 #                       case 'HP-UX':
 119 #                       case 'IRIX64':
 120 #                       case 'NetBSD':
 121 #                       case 'OpenBSD':
 122 #                       case 'SunOS':
 123 #                       case 'Unix':
 124                                 // *nix based OS
 125                                 return $this->stopServerOnUnix();
 126                                 break;
 127                         case "Windows":
 128                         case "WIN32":
 129                         case "WINNT":
 130                                 // Windows
 131                                 return $this->stopServerOnWindows();
 132                                 break;
 133                         default:
 134                                 // An untested OS
 135                                 return 'failed';
 136                                 break;
 137                 }
 138         }
 139
 140         private function startServerOnUnix() {
 141
 142                 $output = array();
 143                 $user = $_ENV['USER'];
 144                 // @todo FIXME: This should be a little more generalized :)
 145                 if (PHP_OS == 'Darwin') {
 146                         // Mac OS X's ps barfs on the 'w' param, but doesn't need it.
 147                         $ps = "ps -U %s";
 148                 } else {
 149                         // Good on Linux
 150                         $ps = "ps -U %s w";
 151                 }
 152                 $psCommand = sprintf($ps, escapeshellarg($user));
 153                 exec($psCommand . " | grep -i selenium-server", $output);
 154
 155                 // Start server. If there is already a server running,
 156                 // return running.
 157
 158                 if ( isset( $this->SeleniumServerExecPath ) ) {
 159                         $found = 0;
 160                         foreach ( $output as $string ) {
 161                                 $found += preg_match(
 162                                         '~^(.*)java(.+)-jar(.+)selenium-server~',
 163                                         $string );
 164                         }
 165                         if ( $found == 0 ) {
 166
 167                                 // Didn't find the selenium server. Start it up.
 168                                 // First set up comamand line suffix.
 169                                 // NB: $! is pid of last job run in background
 170                                 // The echo guarentees it is put into $op when
 171                                 // the exec command is run.
 172
 173                                 $commandSuffix = ' > /dev/null 2>&1'. ' & echo $!';
 174                                 $portText = ' -port ' . $this->SeleniumServerPort;
 175                                 $command = "java -jar " .
 176                                         escapeshellarg($this->SeleniumServerExecPath) .
 177                                         $portText . $commandSuffix;
 178                                 exec($command ,$op);
 179                                 $pid = (int)$op[0];
 180                                 if ( $pid != "" )
 181                                         $this->SeleniumServerPid = $pid;
 182                                 else {
 183                                         $this->SeleniumServerPid = 'NaN';
 184                                         // Server start failed.
 185                                         return 'failed';
 186                                 }
 187                                 // Wait for the server to startup and listen
 188                                 // on its port. Note: this solution kinda
 189                                 // stinks, since it uses a wait loop - dnessett
 190
 191                                 wfSuppressWarnings();
 192                                 for ( $cnt = 1;
 193                                           $cnt <= $this->SeleniumServerStartTimeout;
 194                                           $cnt++ ) {
 195                                         $fp = fsockopen ( 'localhost',
 196                                                 $this->SeleniumServerPort,
 197                                                 $errno, $errstr, 0 );
 198                                         if ( !$fp ) {
 199                                                 sleep( 1 );
 200                                                 continue;
 201                                           // Server start succeeded.
 202                                         } else {
 203                                                 fclose ( $fp );
 204                                                 return 'started';
 205                                         }
 206                                 }
 207                                 wfRestoreWarnings();
 208                                 echo ( "Starting Selenium server timed out.\n" );
 209                                 return 'failed';
 210                         }
 211                         // server already running.
 212                         else return 'running';
 213
 214                 }
 215                                 // No Server execution path defined.
 216                 return 'failed';
 217         }
 218
 219         private function startServerOnWindows() {
 220                 // Unimplemented.
 221                 return 'failed';
 222         }
 223
 224         private function stopServerOnUnix() {
 225
 226                 if ( !empty( $this->SeleniumServerPid ) &&
 227                          $this->SeleniumServerPid != 'NaN' ) {
 228                         exec( "kill -9 " . $this->SeleniumServerPid );
 229                         return 'stopped';
 230                 }
 231                 else return 'failed';
 232         }
 233
 234         private function stopServerOnWindows() {
 235                 // Unimplemented.
 236                 return 'failed';
 237
 238         }
 239 }