script/servidores/YATTA_Server.php

   1 #!/usr/bin/php4 -qC
   2 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80 foldmethod=marker:
   3 -------------------------------------------------------------------------------
   4                              Ministerio de Economía
   5                                     YATTA!
   6 -------------------------------------------------------------------------------
   7 This file is part of YATTA!.
   8
   9 YATTA! is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2 of the License, or (at your option)
  12 any later version.
  13
  14 YATTA! is distributed in the hope that it will be useful, but WITHOUT
  15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License; if not,
  19 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20 Boston, MA  02111-1307  USA
  21 -------------------------------------------------------------------------------
  22 Creado: jue ene  8 16:53:47 ART 2004
  23 Autor:  Martin Marrese <mmarre@mecon.gov.ar>
  24 -------------------------------------------------------------------------------
  25 $Id$
  26 -----------------------------------------------------------------------------*/
  27
  28 // TODO FIXME XXX
  29 // Hay problemas con el tiempo de ejecucion del script. No se puede cortar o
  30 // parar asi porque si, si esta ejecutando un proceso hay que esperar hasta que
  31 // este finalice, o hacer que todos manejen interrupciones.
  32
  33 //XXX LANZAR ESTE SCRIPT CON NICE -19
  34
  35 //TODO Ver si es conveniente que la conexion al mysql esta abierta desde el
  36 //principio. Hay problemas con eso?
  37
  38 define ('YATTA_LOG_DEBUG', 'debug');
  39 define ('YATTA_LOG_WARNING', 'warning');
  40 define ('YATTA_LOG_FATAL', 'fatal');
  41
  42 //YATTA LOG {{{
  43 //Varia su forma de actuar segun el archivo de configuracion
  44 //
  45 //$texto - Texto a agregar al log
  46 //$modo - uno de debug, warning, fatal
  47 //
  48 //Como root:
  49 //# touch /var/log/apache/YATTA_Server.log
  50 //# chown root.www-data /var/log/apache/YATTA_Server.log
  51 //# chmod 660 /var/log/apache/YATTA_Server.log
  52 function yatta_log ($texto, $modo = YATTA_LOG_FATAL) {
  53     GLOBAL $YATTA_SERVER;
  54     GLOBAL $CONF;
  55
  56     if (!($FH = fopen ($CONF['server']['log'], "a"))) {
  57         trigger_error("No se pudo abrir el archivo de log.", E_USER_ERROR);
  58     }
  59     else {
  60         $linea = strftime("%b %e %H:%M:%S").' '.$YATTA_SERVER['name'].' '.
  61             $YATTA_SERVER['script'].'['.$YATTA_SERVER['pid'].']: '. $texto ."\n";
  62
  63         switch ($CONF['server']['modo_log']) {
  64             case YATTA_LOG_FATAL:
  65                 if ($modo == YATTA_LOG_FATAL) {
  66                     fwrite($FH, $linea);
  67                 }
  68                 break;
  69             case YATTA_LOG_WARNING:
  70                 if (!($modo == YATTA_LOG_DEBUG)) {
  71                     fwrite($FH, $linea);
  72                 }
  73                 break;
  74             case YATTA_LOG_DEBUG:
  75                 fwrite($FH, $linea);
  76                 break;
  77         }
  78         fclose ($FH);
  79     }
  80 }
  81 //}}}
  82
  83 //LEO EL ARCHIVO DE CONFIGURACION {{{
  84 $CONF = parse_ini_file(dirname(__FILE__) . '/configuracion.ini', true);
  85 //}}}
  86
  87 //REQUIRE ONCE {{{
  88 require_once 'PEAR.php';
  89 require_once 'YATTA/Controlador.php';
  90 require_once 'YATTA/Servidor.php';
  91 require_once 'YATTA/DB.php';
  92 //}}}
  93
  94 //CREO UNA CONEXION MYSQL{{{
  95 $db = YATTA_DB::connect($CONF['db']);
  96 if (DB::isError($db)) {
  97     yatta_log('Se produjo un error. '. $db->getMessage(), YATTA_LOG_FATAL);
  98     yatta_log('Finaliza la ejecución debido a un error grave.');
  99     exit;
 100 }
 101 //}}}
 102
 103 //CREO LOS OBJETOS NECESARIOS {{{
 104 $CONTROLADOR =& new YATTA_Controlador;
 105 $SERVIDOR =& new YATTA_Servidor;
 106 //}}}
 107
 108 //OBTENGO LOS DATOS DEL SERVER {{{
 109 $YATTA_SERVER['script'] = $argv[0];
 110 $YATTA_SERVER['pid'] = getmypid();
 111 $YATTA_SERVER['name'] = substr(file_get_contents('/etc/hostname'), 0, strpos
 112         (file_get_contents('/etc/hostname'), "\n"));
 113 $YATTA_SERVER['id'] = $SERVIDOR->obtenerId($db, $YATTA_SERVER['name']);
 114 if (PEAR::isError($YATTA_SERVER['id'])) {
 115     yatta_log('Se produjo un error. '. $YATTA_SERVER['id']->getMessage(),
 116             YATTA_LOG_FATAL);
 117     yatta_log('Finaliza la ejecución debido a un error grave.');
 118     exit;
 119 }
 120 yatta_log ('*************** Comienzo Ejecución ***************');
 121 yatta_log (' SCRIPT: '      . $YATTA_SERVER['script']);
 122 yatta_log (' PID: '         . $YATTA_SERVER['pid']);
 123 yatta_log (' SERVER NAME: ' . $YATTA_SERVER['name']);
 124 yatta_log (' SERVER ID: '   . $YATTA_SERVER['id']);
 125 yatta_log ('**************************************************');
 126 //}}}
 127
 128 //WHILEO LAS OPCIONES {{{
 129 yatta_log ('Se busca un nuevo proceso.');
 130 while (1) {
 131
 132     //Busco un nuevo proceso {{{
 133     $proceso = $CONTROLADOR->obtenerNuevoProceso($db,
 134             $YATTA_SERVER['id']);
 135     //}}}
 136
 137     //Si hay un proceso lo lanzo {{{
 138     if (@$proceso) {
 139
 140         yatta_log ('Hay un nuevo proceso. Se forkea', YATTA_LOG_DEBUG);
 141         $pid = pcntl_fork();
 142
 143         //FORK ERROR {{{
 144         if ($pid == -1) {
 145             yatta_log('ERROR: No se pudo forkear.', YATTA_LOG_FATAL);
 146             $res = $CONTROLADOR->terminarProceso($db, $proceso['id'],
 147                     $YATTA_SERVER['id'], 3, 'No se pudo forkear el script.');
 148             if (PEAR::isError($res)) {
 149                 yatta_log('ERROR: YATTA_Controlador. '.$res->getMessage(),
 150                         YATTA_LOG_FATAL);
 151                 yatta_log('Finaliza la ejecución debido a un error.', YATTA_LOG_FATAL);
 152                 exit;
 153             }
 154
 155         }
 156         //}}}
 157
 158         //FORK PADRE {{{
 159         elseif ($pid) {
 160             yatta_log ('Fork Padre.', YATTA_LOG_DEBUG);
 161             //Espero a que termine el proceso.
 162             yatta_log ('Se espera a que termine el proceso en ejecución. '.
 163                     ' Verifica aborto en 5 segundos.', YATTA_LOG_DEBUG);
 164
 165             //Pregunto si el hijo que se forkeo arriba termino, pero pido que no
 166             //corte la ejecucion (WNOHANG) para poder entrar en el while.
 167             //$res sera el pid del hijo, en este caso $res = $pid.
 168             while (!($res = pcntl_waitpid($pid, $status, WNOHANG))) {
 169                 if ($CONTROLADOR->abortar($db, $proceso['id'])) {
 170                     yatta_log ('Hay que abortar el proceso en ejecución.',
 171                             YATTA_LOG_WARNING);
 172                     posix_kill($pid, 15); //SIGTERM
 173                     $CONTROLADOR->terminarProceso($db, $proceso['id'],
 174                             $YATTA_SERVER['id'], 4);
 175                     yatta_log ('Se aborto el proceso en ejecución.',
 176                             YATTA_LOG_WARNING);
 177                 }
 178                 sleep(5);
 179             }
 180             yatta_log ('Fin fork Padre.', YATTA_LOG_DEBUG);
 181         }
 182         //}}}
 183
 184         //FORK HIJO {{{
 185         else {
 186             yatta_log ('Fork Hijo.', YATTA_LOG_DEBUG);
 187
 188             //Ejecuto el proceso si existe el archivo {{{
 189             if (is_readable($proceso['script'])) {
 190                 require_once $proceso['script'];
 191                 yatta_log ('Se llama a create_process.', YATTA_LOG_DEBUG);
 192
 193                 //Llamo a la funcion create_process {{{
 194                 if (function_exists('create_process')) {
 195                     $SCRIPT =& create_process();
 196                     yatta_log ('Se instancio el proceso. Se ejecuta el metodo '.
 197                             'run.', YATTA_LOG_DEBUG);
 198                     if (!method_exists($SCRIPT, 'run')) {
 199                         yatta_log ('No existe el metodo run en el proceso.',
 200                                 YATTA_LOG_WARNING);
 201                         require_once 'YATTA/Proceso.php';
 202                         $SCRIPT =& new YATTA_Proceso;
 203                         $SCRIPT->error = 'No existe el metodo run en'.
 204                             $proceso['script'];
 205                     }
 206                     else {
 207                         yatta_log ('Comienza la ejecución del proceso.',
 208                                 YATTA_LOG_DEBUG);
 209                         $SCRIPT->run(unserialize($proceso['parametros']));
 210                         yatta_log ('Finaliza la ejecución del proceso.',
 211                                 YATTA_LOG_DEBUG);
 212                     }
 213                 }
 214                 //}}}
 215
 216                 //No existe la funcion {{{
 217                 else {
 218                     require_once 'YATTA/Proceso.php';
 219                     $SCRIPT =& new YATTA_Proceso;
 220                     $SCRIPT->error = 'No existe la funcion create_process en'.
 221                         $proceso['script'];
 222                     yatta_log($SCRIPT->error, YATTA_LOG_WARNING);
 223                 }
 224                 //}}}
 225
 226                 //Finalizo el script {{{
 227                 if (@$SCRIPT->error) {
 228                     $estado = 3;
 229                 }
 230                 else {
 231                     $estado = 2;
 232                 }
 233                 $CONTROLADOR->terminarProceso($db, $proceso['id'],
 234                         $YATTA_SERVER['id'], $estado, @$SCRIPT->error,
 235                         @$SCRIPT->archivo, @$SCRIPT->notificar);
 236                 //}}}
 237
 238             }
 239             //}}}
 240
 241             //No existe el archivo {{{
 242             else {
 243                 yatta_log('No se puede alcanzar el archivo '.
 244                         $proceso['script'].'.', YATTA_LOG_WARNING);
 245                 $res = $CONTROLADOR->terminarProceso($db, $proceso['id'],
 246                         $YATTA_SERVER['id'], 3, 'No se puede alcanzar el archivo.');
 247             }
 248             //}}}
 249
 250             yatta_log ('Fin fork Hijo.', YATTA_LOG_DEBUG);
 251             exit;
 252         }
 253         //}}}
 254
 255         unset($proceso);
 256     }
 257     // }}}
 258
 259     //No hay proceso {{{
 260     else {
 261         yatta_log ('No hay procesos asignados a este servidor.'.
 262                 ' En 60 segundos se buscara un nuevo proceso.', YATTA_LOG_DEBUG);
 263         sleep(60);
 264     }
 265     //}}}
 266 }
 267 //}}}
 268 ?>