#!/usr/bin/php4 -qC
<?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80 foldmethod=marker:
-------------------------------------------------------------------------------
                             Ministerio de Economía
                                    YATTA!
-------------------------------------------------------------------------------
This file is part of YATTA!.

YATTA! is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.

YATTA! is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License; if not,
write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------
Creado: jue ene  8 16:53:47 ART 2004
Autor:  Martin Marrese <mmarre@mecon.gov.ar>
-------------------------------------------------------------------------------
$Id$
-----------------------------------------------------------------------------*/

// TODO FIXME XXX
// Hay problemas con el tiempo de ejecucion del script. No se puede cortar o
// parar asi porque si, si esta ejecutando un proceso hay que esperar hasta que
// este finalice, o hacer que todos manejen interrupciones.

//XXX LANZAR ESTE SCRIPT CON NICE -19

//TODO Ver si es conveniente que la conexion al mysql esta abierta desde el
//principio. Hay problemas con eso?

define ('YATTA_LOG_DEBUG', 'debug');
define ('YATTA_LOG_WARNING', 'warning');
define ('YATTA_LOG_FATAL', 'fatal');

//YATTA LOG {{{
//Varia su forma de actuar segun el archivo de configuracion
//
//$texto - Texto a agregar al log
//$modo - uno de debug, warning, fatal 
//
//Como root:
//# touch /var/log/apache/YATTA_Server.log
//# chown root.www-data /var/log/apache/YATTA_Server.log
//# chmod 660 /var/log/apache/YATTA_Server.log
function yatta_log ($texto, $modo = YATTA_LOG_FATAL) {
    GLOBAL $YATTA_SERVER;
    GLOBAL $CONF;

    if (!($FH = fopen ($CONF['server']['log'], "a"))) {
        trigger_error("No se pudo abrir el archivo de log.", E_USER_ERROR);
    }
    else {
        $linea = strftime("%b %e %H:%M:%S").' '.$YATTA_SERVER['name'].' '.
            $YATTA_SERVER['script'].'['.$YATTA_SERVER['pid'].']: '. $texto ."\n";

        switch ($CONF['server']['modo_log']) {
            case YATTA_LOG_FATAL:
                if ($modo == YATTA_LOG_FATAL) {
                    fwrite($FH, $linea);
                }
                break;
            case YATTA_LOG_WARNING:
                if (!($modo == YATTA_LOG_DEBUG)) {
                    fwrite($FH, $linea);
                }
                break;
            case YATTA_LOG_DEBUG:
                fwrite($FH, $linea);
                break;
        }
        fclose ($FH);
    }
}
//}}}

//LEO EL ARCHIVO DE CONFIGURACION {{{
$CONF = parse_ini_file(dirname(__FILE__) . '/configuracion.ini', true);
//}}}

//REQUIRE ONCE {{{
require_once 'PEAR.php';
require_once 'YATTA/Controlador.php';
require_once 'YATTA/Servidor.php';
require_once 'YATTA/DB.php';
//}}}

//CREO UNA CONEXION MYSQL{{{
$db = YATTA_DB::connect($CONF['db']);
if (DB::isError($db)) {
    yatta_log('Se produjo un error. '. $db->getMessage(), YATTA_LOG_FATAL);
    yatta_log('Finaliza la ejecución debido a un error grave.');
    exit;
}
//}}}

//CREO LOS OBJETOS NECESARIOS {{{
$CONTROLADOR =& new YATTA_Controlador;
$SERVIDOR =& new YATTA_Servidor;
//}}}

//OBTENGO LOS DATOS DEL SERVER {{{
$YATTA_SERVER['script'] = $argv[0];
$YATTA_SERVER['pid'] = getmypid();
$YATTA_SERVER['name'] = substr(file_get_contents('/etc/hostname'), 0, strpos
        (file_get_contents('/etc/hostname'), "\n"));
$YATTA_SERVER['id'] = $SERVIDOR->obtenerId($db, $YATTA_SERVER['name']);
if (PEAR::isError($YATTA_SERVER['id'])) {
    yatta_log('Se produjo un error. '. $YATTA_SERVER['id']->getMessage(),
            YATTA_LOG_FATAL);
    yatta_log('Finaliza la ejecución debido a un error grave.');
    exit;
}
yatta_log ('*************** Comienzo Ejecución ***************');
yatta_log (' SCRIPT: '      . $YATTA_SERVER['script']);
yatta_log (' PID: '         . $YATTA_SERVER['pid']);
yatta_log (' SERVER NAME: ' . $YATTA_SERVER['name']);
yatta_log (' SERVER ID: '   . $YATTA_SERVER['id']);
yatta_log ('**************************************************');
//}}}

//WHILEO LAS OPCIONES {{{
yatta_log ('Se busca un nuevo proceso.');
while (1) {
   
    //Busco un nuevo proceso {{{
    $proceso = $CONTROLADOR->obtenerNuevoProceso($db,
            $YATTA_SERVER['id']);
    //}}}

    //Si hay un proceso lo lanzo {{{
    if (@$proceso) {
        
        yatta_log ('Hay un nuevo proceso. Se forkea', YATTA_LOG_DEBUG);
        $pid = pcntl_fork();

        //FORK ERROR {{{
        if ($pid == -1) {
            yatta_log('ERROR: No se pudo forkear.', YATTA_LOG_FATAL);
            $res = $CONTROLADOR->terminarProceso($db, $proceso['id'],
                    $YATTA_SERVER['id'], 3, 'No se pudo forkear el script.');
            if (PEAR::isError($res)) {
                yatta_log('ERROR: YATTA_Controlador. '.$res->getMessage(),
                        YATTA_LOG_FATAL);
                yatta_log('Finaliza la ejecución debido a un error.', YATTA_LOG_FATAL);
                exit;
            }
            
        }
        //}}}

        //FORK PADRE {{{
        elseif ($pid) {
            yatta_log ('Fork Padre.', YATTA_LOG_DEBUG);
            //Espero a que termine el proceso.
            yatta_log ('Se espera a que termine el proceso en ejecución. '.
                    ' Verifica aborto en 5 segundos.', YATTA_LOG_DEBUG);

            //Pregunto si el hijo que se forkeo arriba termino, pero pido que no
            //corte la ejecucion (WNOHANG) para poder entrar en el while.
            //$res sera el pid del hijo, en este caso $res = $pid.
            while (!($res = pcntl_waitpid($pid, $status, WNOHANG))) {
                if ($CONTROLADOR->abortar($db, $proceso['id'])) {
                    yatta_log ('Hay que abortar el proceso en ejecución.',
                            YATTA_LOG_WARNING);
                    posix_kill($pid, 15); //SIGTERM
                    $CONTROLADOR->terminarProceso($db, $proceso['id'],
                            $YATTA_SERVER['id'], 4);
                    yatta_log ('Se aborto el proceso en ejecución.',
                            YATTA_LOG_WARNING);
                }
                sleep(5);
            }
            yatta_log ('Fin fork Padre.', YATTA_LOG_DEBUG);
        }
        //}}}

        //FORK HIJO {{{
        else {
            yatta_log ('Fork Hijo.', YATTA_LOG_DEBUG);

            //Ejecuto el proceso si existe el archivo {{{
            if (is_readable($proceso['script'])) {
                require_once $proceso['script'];
                yatta_log ('Se llama a create_process.', YATTA_LOG_DEBUG);
                
                //Llamo a la funcion create_process {{{
                if (function_exists('create_process')) {
                    $SCRIPT =& create_process();
                    yatta_log ('Se instancio el proceso. Se ejecuta el metodo '.
                            'run.', YATTA_LOG_DEBUG);
                    if (!method_exists($SCRIPT, 'run')) {
                        yatta_log ('No existe el metodo run en el proceso.',
                                YATTA_LOG_WARNING);
                        require_once 'YATTA/Proceso.php';
                        $SCRIPT =& new YATTA_Proceso;
                        $SCRIPT->error = 'No existe el metodo run en'. 
                            $proceso['script'];
                    }
                    else {
                        yatta_log ('Comienza la ejecución del proceso.',
                                YATTA_LOG_DEBUG);
                        $SCRIPT->run(unserialize($proceso['parametros']));
                        yatta_log ('Finaliza la ejecución del proceso.',
                                YATTA_LOG_DEBUG);
                    }
                }
                //}}}

                //No existe la funcion {{{
                else {
                    require_once 'YATTA/Proceso.php';
                    $SCRIPT =& new YATTA_Proceso;
                    $SCRIPT->error = 'No existe la funcion create_process en'.
                        $proceso['script'];
                    yatta_log($SCRIPT->error, YATTA_LOG_WARNING);
                }
                //}}}

                //Finalizo el script {{{
                if (@$SCRIPT->error) {
                    $estado = 3;
                }
                else {
                    $estado = 2;
                }
                $CONTROLADOR->terminarProceso($db, $proceso['id'],
                        $YATTA_SERVER['id'], $estado, @$SCRIPT->error,
                        @$SCRIPT->archivo, @$SCRIPT->notificar);
                //}}}
            
            }
            //}}}
           
            //No existe el archivo {{{
            else {
                yatta_log('No se puede alcanzar el archivo '.
                        $proceso['script'].'.', YATTA_LOG_WARNING);
                $res = $CONTROLADOR->terminarProceso($db, $proceso['id'],
                        $YATTA_SERVER['id'], 3, 'No se puede alcanzar el archivo.');
            }
            //}}}
            
            yatta_log ('Fin fork Hijo.', YATTA_LOG_DEBUG);
            exit;
        }
        //}}}

        unset($proceso);
    }
    // }}}

    //No hay proceso {{{
    else {
        yatta_log ('No hay procesos asignados a este servidor.'.
                ' En 60 segundos se buscara un nuevo proceso.', YATTA_LOG_DEBUG);
        sleep(60);
    }
    //}}}
}
//}}}
?>