lib/YATTA/Controlador.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 -------------------------------------------------------------------------------
   3                              Ministerio de Economía
   4                                     YATTA!
   5 -------------------------------------------------------------------------------
   6 This file is part of YATTA!.
   7
   8 YATTA! is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2 of the License, or (at your option)
  11 any later version.
  12
  13 YATTA! is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License; if not,
  18 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19 Boston, MA  02111-1307  USA
  20 -------------------------------------------------------------------------------
  21 Creado: vie ene  9 16:28:04 ART 2004
  22 Autor:  Martin Marrese <mmarre@mecon.gov.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 require_once 'YATTA/Proceso.php';
  28 require_once 'YATTA/ProcesoDB.php';
  29 require_once 'YATTA/Servidor.php';
  30
  31 define ('PATH_TACHO', '/var/www/yatta_tacho/');
  32
  33 /**
  34  * Clase para el manejo centralizado de toda la informacion de YATTA.
  35  *
  36  * @access public
  37  */
  38 class YATTA_Controlador {
  39
  40     /**
  41      * Obtiene el nombre del servidor al cual asignar un nuevo proceso.
  42      *
  43      * @param DB $db Conexion a la base de datos.
  44      *
  45      * @return mixed
  46      * @access private
  47      */
  48     function _obtenerServidor($db) {
  49         $res = $db->query('SELECT s.id, s.escala * s.procesos AS ponderacion
  50             FROM yatta.servidores AS s
  51             ORDER BY ponderacion ASC, s.escala DESC');
  52         // Si hay error lo devuelve.
  53         if (DB::isError($res)) {
  54             return $res;
  55         }
  56         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
  57         return  $res['id'];
  58     }
  59
  60     /**
  61      * Agrega un proceso a la base de datos
  62      * Los datos a pasar son:
  63      *  Obligatorios
  64      *   script     : Path completo para el require_once.
  65      *   id_sistema : Identificador del sistema al que pertenece .
  66      *   descripcion: Es lo que permite al usuario identificar al proecso.
  67      *   owner      : Login@Organismo de la persona responsable del proceso.
  68      *
  69      *  Opcionales
  70      *   destinos   : Login@Organismo separado por comas de aquellos usuarios
  71      *                que deben poder ver los resultados del proceso.
  72      *   prioridad  : Indica la prioridad del proceso.
  73      *   notificar  : Indica si hay que notificar al owner y a los destinos
  74      *                cuando finalize el proceso.
  75      *   resultado  : En caso que el proceso genere archivos resultado, se debe
  76      *                indicar aqui el nombre del archivo que deben visualizar
  77      *                los usuarios.
  78      *
  79      * @param  DB $db Conexion a la base de datos.
  80      * @param  mixed $datos Datos necesarios del proceso.
  81      *
  82      * @return mixed
  83      * @access public
  84      */
  85     function agregarProceso($db, $datos) {
  86         //XXX Dentro de los datos puede estar el tiempo estimado de ejecucion
  87         //del proceso. Esta informacion podria ser utilizada en futuras
  88         //versiones para asignar servidores.
  89
  90         //Si no es un array
  91         if (is_object($datos) && is_a ($datos, 'YATTA_ProcesoDB')) {
  92             $datos = $datos->obtenerDatos();
  93         }
  94         elseif (!is_array($datos)) {
  95             return new PEAR_Error ("Error con los datos pasados. El segundo".
  96                     " parametro debe ser un array asociativo o una instancia".
  97                     " del objeto YATTA_Proceso.");
  98         }
  99         $res = $this->_obtenerServidor($db);
 100
 101         if (DB::isError($res)) {
 102             return $res;
 103         }
 104         $datos['server'] = $res;
 105         $datos['fecha'] = date('Y-m-d');
 106         $res = $db->autoExecute('yatta.procesos', $datos, DB_AUTOQUERY_INSERT);
 107         if (DB::isError($res)) {
 108             return $res;
 109         }
 110         $SERVER =& new YATTA_Servidor;
 111         return $SERVER->agregarProceso($db, $datos['server']);
 112     }
 113
 114     /**
 115      * Obtiene los procesos de un usuario.
 116      *
 117      * @param DB $db Conexion a la base de datos.
 118      * @param string $owner Usuario duenio de los procesos.
 119      * @param int $id Identificador del proceso a buscar
 120      *
 121      * @return mixed
 122      * @access public
 123      */
 124     function obtenerProcesosUsuario($db, $owner, $id = null) {
 125         $proceso =& new YATTA_ProcesoDB;
 126         $proceso->owner = $owner;
 127         if (@$id) {
 128             $proceso->id = $id;
 129             $res = $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 130             $res = $proceso->cargar($res);
 131             return $proceso;
 132         }
 133         else {
 134             return $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 135         }
 136     }
 137
 138     /**
 139      * Actualiza los datos de un proceso al terminar.
 140      *
 141      * @param DB $db Conexion a la base de datos.
 142      * @param int $id_proceso Identificador del proceso.
 143      * @param int $id_server Identificador del Servidor.
 144      * @param int $status Identificador del estado de finalizacion.
 145      * @param string $nota Nota de error o similar.
 146      * @param string $archivo Nombre del archivo temporal que esta en el fs.
 147      * @param int $notificar Indica si hay que notificar al owner.
 148      *
 149      * @return mixed
 150      * @access public
 151      */
 152     function terminarProceso($db, $id_proceso, $id_server, $status, $nota =
 153             null, $archivo = null, $notificar = 0) {
 154
 155         //Actualizo la base procesos
 156         $sql = 'UPDATE yatta.procesos SET status = '. $status;
 157         if (@$nota) {
 158             $sql.= ', nota = '. $nota;
 159         }
 160         if (@$archivo) {
 161             $sql.= ', archivo = '. $archivo;
 162         }
 163         if (@$notificar) {
 164             $sql.= ', notificar = '. $notificar;
 165         }
 166         $sql.= ' WHERE id = '. $id_proceso;
 167         $res = $db->query($sql);
 168         if (DB::isError($res)) {
 169             return $res;
 170         }
 171
 172         //NOTIFICO
 173         if (@$notificar) {
 174             $res = $db->query(
 175                     "SELECT p.descripcion AS descripcion, p.owner AS owner, ".
 176                     "p.destinos AS destinos ".
 177                     "FROM yatta.procesos AS p"/
 178                     "WHERE p.id = ". $id_proceso);
 179             if (DB::isError($res)) {
 180                 return $res;
 181             }
 182             $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 183             $dest = split (',', @$res['destinos']);
 184             $to = $owner.'.gov.ar';
 185             foreach ($dest as $d) {
 186                 $to = $to . ", $d.gov.ar";
 187             }
 188             $headers = "From: Intranet - YATTA <intranet@mecon.gov.ar>\r\n";
 189             $subject = "Proceso finalizado";
 190             $body = "El proceso:\n".
 191                 $res['descripcion'] .
 192                 "\nha finalizado. Puede verificar el estado de finalizacion\n".
 193                 "en el sistema YATTA dentro de la intranet.\n".
 194                 "\n\n\n".
 195                 "************************************************************\n".
 196                 "Este es un mensaje generado automaticamente por MECON_YATTA.\n".
 197                 "Por favor no responder a esta direccion de e-mail.\n".
 198                 "************************************************************\n";
 199             mail($to, $subject, $body, $headers);
 200         }
 201
 202         //COPIO EL ARCHIVO
 203         if (@$archivo) {
 204             $arch = basename ($archivo);
 205             rename ($archivo, PATH_TACHO.$arch);
 206         }
 207
 208         //Actualizo los servidores
 209         $SERVER =& new YATTA_Servidor;
 210         return $SERVER->quitarProceso($db, $id_server);
 211     }
 212
 213     /**
 214      * Busca un proceso en cola para el servidor
 215      *
 216      * @param DB $db Conexion a la base de datos.
 217      * @param int $id Identificador del servidor.
 218      *
 219      * @return mixed
 220      * @access public
 221      */
 222     function obtenerNuevoProceso($db, $id) {
 223         $res = $db->query('SELECT p.id AS id, p.script AS script
 224                 FROM yatta.procesos AS p
 225                 WHERE p.server = '.$id.' AND status = 0
 226                 ORDER BY p.prioridad, p.id');
 227         // Si hay error lo devuelve.
 228         if (DB::isError($res)) {
 229             return $res;
 230         }
 231         return $res->fetchRow(DB_FETCHMODE_ASSOC);
 232     }
 233
 234     /**
 235      * Busca si un proceso que se esta ejecutando tiene pedido de cancelacion.
 236      *
 237      * @param DB $db Conexion a la base de datos.
 238      * @param int $id Identificador del proceso.
 239      *
 240      * @return mixed
 241      * @access public
 242      */
 243     function abortar($db, $id) {
 244         $res = $db->query('SELECT count(*) AS cuenta
 245                 FROM yatta.procesos
 246                 WHERE id = '.$id.' AND status = 5');
 247         // Si hay error lo devuelve.
 248         if (DB::isError($res)) {
 249             return $res;
 250         }
 251         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 252         return  $res['cuenta'];
 253     }
 254 }
 255 ?>