home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / System / ProcWatch.php < prev    next >
Encoding:
PHP Script  |  2008-07-02  |  12.0 KB  |  455 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: System :: ProcWatch                                          |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: ProcWatch.php,v 1.5 2004/06/12 13:40:14 mike Exp $
  15.  
  16. /**
  17. * Requires System::ProcWatch::Parser
  18. */
  19. require_once 'System/ProcWatch/Parser.php';
  20.  
  21. /**
  22. * Constants
  23. */
  24. define('PHP_PROCWATCH_PRESENCE',        100);
  25. define('PHP_PROCWATCH_PRESENCE_MIN',    101);
  26. define('PHP_PROCWATCH_PRESENCE_MAX',    102);
  27. define('PHP_PROCWATCH_IS',              103);
  28. define('PHP_PROCWATCH_ISNOT',           104);
  29. define('PHP_PROCWATCH_MIN',             105);
  30. define('PHP_PROCWATCH_MAX',             106);
  31. define('PHP_PROCWATCH_SUM',             107);
  32.  
  33. /** 
  34. * System_ProcWatch
  35. * 
  36. * Monitor processes
  37. * 
  38. * Usage:
  39. * <code>
  40. * $cf = System_ProcWatch_Config::fromXmlFile('/etc/procwatch.xml');
  41. * $pw = &new System_ProcWatch($cf);
  42. * $pw->run();
  43. * </code>
  44. * 
  45. * @author       Michael Wallner <mike@php.net>
  46. * @package      System_ProcWatch
  47. * @category     System
  48. * 
  49. * @version      $Revision: 1.5 $
  50. * @access       public
  51. */
  52. class System_ProcWatch
  53. {
  54.     /**
  55.     * Parser
  56.     *
  57.     * @access   public
  58.     * @var      object System_ProcWatch_Parser
  59.     */
  60.     var $parser = null;
  61.     
  62.     /**
  63.     * Patterns
  64.     *
  65.     * @access   private
  66.     * @var      array
  67.     */
  68.     var $_patt = array();
  69.     
  70.     /**
  71.     * Conditions
  72.     *
  73.     * @access   private
  74.     * @var      array
  75.     */
  76.     var $_cond = array();
  77.     
  78.     /**
  79.     * Executes
  80.     *
  81.     * @access   private
  82.     * @var      array
  83.     */
  84.     var $_exec = array();
  85.     
  86.     /**
  87.     * Selected Processes
  88.     *
  89.     * @access   private
  90.     * @var      array
  91.     */
  92.     var $_procs = array();
  93.     
  94.     /**
  95.     * Constructor
  96.     *
  97.     * @access   protected
  98.     * @return   object  System_ProcWatch
  99.     * @param    array   $config     config array from System_ProcWatch_Config
  100.     */
  101.     function System_ProcWatch($config)
  102.     {
  103.         System_Procwatch::__construct($config);
  104.     }
  105.     
  106.     /**
  107.     * Constructor (ZE2)
  108.     *
  109.     * @access   protected
  110.     * @return   object      System_ProcWatch
  111.     * @param    string      $config         path to configuration file
  112.     */
  113.     function __construct($config)
  114.     {
  115.         $this->parser = &new System_ProcWatch_Parser;
  116.         $this->setConfig($config);
  117.     }
  118.     
  119.     /**
  120.     * Run
  121.     *
  122.     * @access   public
  123.     * @return   void
  124.     * @param    string  $ps_args    ps' args
  125.     */
  126.     function run($ps_args = 'aux')
  127.     {
  128.         // get actual process' data
  129.         $this->_procs = array();
  130.         $procs = &$this->parser->getParsedData($ps_args, true);
  131.         
  132.         // fetch needed data
  133.         foreach ($this->_jobs as $job) {
  134.         
  135.             // get the pattern to search for
  136.             $search = array_shift(array_keys($this->_patt[$job]));
  137.             $pattern= $this->_patt[$job][$search];
  138.             
  139.             foreach ($procs as $p) {
  140.             
  141.                 // search for the line we need
  142.                 if (!preg_match($pattern, @$p[$search])) {
  143.                     continue;
  144.                 }
  145.                 
  146.                 // save the data
  147.                 $this->_procs[$job][] = $p;
  148.             }
  149.  
  150.             // check for presence
  151.             if (isset($this->_cond[$job]['presence'])) {
  152.                 $this->_handlePresence($job);
  153.             }
  154.             
  155.             // check for attribute
  156.             if (isset($this->_cond[$job]['attr'])) {
  157.                 $this->_handleAttr($job);
  158.             }
  159.         }
  160.     }
  161.     
  162.     /**
  163.     * Daemon mode
  164.     *
  165.     * @access   public
  166.     * @return   void
  167.     * @param    int     $interval   seconds to sleep
  168.     * @param    string  $ps_args    ps' arguments
  169.     */
  170.     function daemon($interval, $ps_args = 'aux')
  171.     {
  172.         while(true) {
  173.             $this->run($ps_args);
  174.             sleep($interval);
  175.         }
  176.     }
  177.     
  178.     /**
  179.     * Handle presence
  180.     *
  181.     * @access   private
  182.     * @return   void
  183.     * @param    string  $job
  184.     */
  185.     function _handlePresence($job)
  186.     {
  187.         $presence   = @count($this->_procs[$job]);
  188.         $condition  = $this->_cond[$job]['presence'];
  189.         list($name) = array_keys($this->_patt[$job]);
  190.  
  191.         if (!isset($condition['max']) && !isset($condition['min'])) {
  192.  
  193.             $this->_execute(
  194.                 $job, 
  195.                 $presence, 
  196.                 PHP_PROCWATCH_PRESENCE, 
  197.                 array('name' => $name)
  198.             );
  199.  
  200.         } else {
  201.  
  202.             if (isset($condition['max']) && ($condition['max'] < $presence)) {
  203.                 $this->_execute(
  204.                     $job, 
  205.                     $presence, 
  206.                     PHP_PROCWATCH_PRESENCE_MAX, 
  207.                     array('name' => $name, 'max' => $condition['max'])
  208.                 );
  209.             }
  210.             
  211.             if (isset($condition['min']) && ($condition['min'] > $presence)) {
  212.                 $this->_execute(
  213.                     $job, 
  214.                     $presence, 
  215.                     PHP_PROCWATCH_PRESENCE_MIN,
  216.                     array('name' => $name, 'min' => $condition['min'])
  217.                 );
  218.             }
  219.         }
  220.         
  221.     }
  222.     
  223.     /**
  224.     * Handle attributes
  225.     *
  226.     * @access   private
  227.     * @return   void
  228.     */
  229.     function _handleAttr($job)
  230.     {
  231.         $name = array_shift(array_keys($this->_cond[$job]['attr']));
  232.         $attr = $this->_cond[$job]['attr'][$name];
  233.         $proc = isset($this->_procs[$job]) ? $this->_procs[$job] : array();
  234.  
  235.         $attr['name'] = $name;
  236.  
  237.         // SUM
  238.         if (isset($attr['sum'])) {
  239.             $sum = 0.0;
  240.             foreach ($proc as $p) {
  241.                 $sum  += @$p[$name];
  242.             }
  243.             if ($sum > $attr['sum']) {
  244.                 $this->_execute($job, $sum, PHP_PROCWATCH_SUM, $attr);
  245.             }
  246.         
  247.         } else {
  248.  
  249.             $sum = 0;
  250.             
  251.             // MAX
  252.             if (isset($attr['max'])) {
  253.                 $const = PHP_PROCWATCH_MAX;
  254.                 foreach ($proc as $p) {
  255.                     if ($p[$name] > $attr['max']) {
  256.                         ++$sum;
  257.                     }
  258.                 }
  259.                 
  260.             // MIN
  261.             } elseif (isset($attr['min'])) {
  262.                 $const = PHP_PROCWATCH_MIN;
  263.                 foreach ($proc as $p) {
  264.                     if ($p[$name] < $attr['min']) {
  265.                         ++$sum;
  266.                     }
  267.                 }
  268.             
  269.             // IS
  270.             } elseif (isset($attr['is'])) {
  271.                 $const = PHP_PROCWATCH_IS;
  272.                 foreach ($proc as $p) {
  273.                     if ($p[$name] == $attr['is']) {
  274.                         ++$sum;
  275.                     }
  276.                 }
  277.             
  278.             // ISNOT
  279.             } elseif (isset($attr['isnot'])) {
  280.                 $const = PHP_PROCWATCH_ISNOT;
  281.                 foreach ($proc as $p) {
  282.                     if ($p[$name] != $attr['isnot']) {
  283.                         ++$sum;
  284.                     }
  285.                 }
  286.             }
  287.             
  288.             if ($sum) {
  289.                 $this->_execute($job, $sum, $const, $attr);
  290.             }
  291.         }
  292.     }
  293.     
  294.     /**
  295.     * Execute
  296.     *
  297.     * @access   private
  298.     * @return   void
  299.     * @param    string  $job
  300.     * @param    mixed   $sum
  301.     * @param    int     $mode
  302.     * @param    mixed   $info
  303.     */
  304.     function _execute($job, $sum, $mode, $info = null)
  305.     {
  306.         $event_msg  = $this->_getMsg($job, $sum, $mode, $info);
  307.         $event_pids = $this->_getPids($job);
  308.         $shell_exec = @$this->_exec[$job]['shell'];
  309.         $php_exec   = @$this->_exec[$job]['php'];
  310.         
  311.         
  312.         if (is_array($shell_exec)) {
  313.             foreach ($shell_exec as $e) {
  314.                 shell_exec(
  315.                     str_replace(
  316.                         '$pids',
  317.                         $event_pids,
  318.                         str_replace('$msg', $event_msg, $e)
  319.                     )
  320.                 );
  321.             }
  322.         }
  323.         
  324.         if (is_array($php_exec)) {
  325.             $procs = 'unserialize(\'' . serialize(@$this->_procs[$job]) . '\'';
  326.             foreach ($php_exec as $e) {
  327.                 eval(
  328.                     str_replace(
  329.                         '$procs',
  330.                         $procs,
  331.                         str_replace(
  332.                             '$pids', 
  333.                             $event_pids, 
  334.                             str_replace('$msg', $event_msg, $e)
  335.                         )
  336.                     )
  337.                 );
  338.             }
  339.         }
  340.     }
  341.     
  342.     /**
  343.     * Get processes' PIDs of a certain job
  344.     *
  345.     * @access   public
  346.     * @return   string
  347.     * @param    string  $job
  348.     */
  349.     function _getPids($job)
  350.     {
  351.         $str = '';
  352.         if (isset($this->_procs[$job])) {
  353.             foreach ($this->_procs[$job] as $proc) {
  354.                 $str .= $proc['pid'] . ', ';
  355.             }
  356.         }
  357.         return '\'(' . trim($str, ', ') . ')\'';
  358.     }
  359.     
  360.     /**
  361.     * Get alert message
  362.     *
  363.     * @access   private
  364.     * @return   string
  365.     * @param    string  $job
  366.     * @param    int     $c
  367.     * @param    int     $mode
  368.     * @param    array   $a
  369.     */
  370.     function _getMsg($job, $sum, $mode, $a)
  371.     {
  372.         $w = $a['name'];
  373.         
  374.         switch($mode){
  375.  
  376.             case PHP_PROCWATCH_IS: 
  377.                 $is = $a['is'];
  378.                 $m  = "$sum procs where $w is $is";
  379.                 break;
  380.  
  381.             case PHP_PROCWATCH_ISNOT: 
  382.                 $isnot  = $a['isnot'];
  383.                 $m      = "$sum procs where $w is not $isnot";
  384.                 break;
  385.  
  386.             case PHP_PROCWATCH_MAX: 
  387.                 $max = $a['max'];
  388.                 $m   = "$sum procs where $w exceeds $max";
  389.                 break;
  390.  
  391.             case PHP_PROCWATCH_MIN: 
  392.                 $min = $a['min'];
  393.                 $m   = "$sum procs where $w under-runs $min";
  394.                 break;
  395.  
  396.             case PHP_PROCWATCH_PRESENCE: 
  397.                 $match  = $this->_patt[$job][$w];
  398.                 $m      = "$sum procs where $w matches $match";
  399.                 break;
  400.                 
  401.             case PHP_PROCWATCH_PRESENCE_MIN: 
  402.                 $min    = $a['min'];
  403.                 $match  = $this->_patt[$job][$w];
  404.                 $m      = "$sum (min $min) procs where $w matches $match";
  405.                 break;
  406.  
  407.             case PHP_PROCWATCH_PRESENCE_MAX: 
  408.                 $max    = $a['max'];
  409.                 $match  = $this->_patt[$job][$w];
  410.                 $m      = "$sum (max $max) procs where $w matches $match";
  411.                 break;
  412.                 
  413.             case PHP_PROCWATCH_SUM: 
  414.                 $s  = $a['sum'];
  415.                 $c  = count($this->_procs[$job]);
  416.                 $m  = "$c procs which sum of $w ($sum) exceeds $s";
  417.                 break;
  418.         }
  419.  
  420.         return '\'' . date('r') . ' - '. $job . ': Found ' . 
  421.                 str_replace('\'', '\\\'', $m) . '\'';
  422.     }
  423.     
  424.     
  425.     /**
  426.     * Set configuration
  427.     *
  428.     * @access   public
  429.     * @return   void
  430.     * @param    array   $config     config array from System_ProcWatch_Config
  431.     */
  432.     function setConfig($config)
  433.     {
  434.         $this->_jobs = array();
  435.         $this->addConfig($config);
  436.     }
  437.     
  438.     /**
  439.     * Add configuration
  440.     *
  441.     * @access   public
  442.     * @return   void
  443.     * @param    array   $config     config array from System_ProcWatch_Config
  444.     */
  445.     function addConfig($config)
  446.     {
  447.         foreach ($config as $job => $arrays) {
  448.             $this->_jobs[]      = $job;
  449.             $this->_patt[$job]  = $arrays['pattern'];
  450.             $this->_cond[$job]  = $arrays['condition'];
  451.             $this->_exec[$job]  = $arrays['execute'];
  452.         }
  453.     }
  454. }
  455. ?>