phpmyadmin/libraries/sysinfo.lib.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Library for extracting information about system memory and cpu.
   5  * Currently supports all Windows and Linux plattforms
   6  *
   7  * This code is based on the OS Classes from the phpsysinfo project
   8  * (http://phpsysinfo.sourceforge.net/)
   9  *
  10  * @package PhpMyAdmin-sysinfo
  11  */
  12 if (! defined('PHPMYADMIN')) {
  13     exit;
  14 }
  15
  16 define(
  17     'MEMORY_REGEXP',
  18     '/^(MemTotal|MemFree|Cached|Buffers|SwapCached|SwapTotal|SwapFree):'
  19     . '\s+(.*)\s*kB/im'
  20 );
  21
  22 /**
  23  * Returns OS type used for sysinfo class
  24  *
  25  * @param string $php_os PHP_OS constant
  26  *
  27  * @return string
  28  */
  29 function PMA_getSysInfoOs($php_os = PHP_OS)
  30 {
  31
  32     // look for common UNIX-like systems
  33     $unix_like = array('FreeBSD', 'DragonFly');
  34     if (in_array($php_os, $unix_like)) {
  35         $php_os = 'Linux';
  36     }
  37
  38     return ucfirst($php_os);
  39 }
  40
  41 /**
  42  * Gets sysinfo class mathing current OS
  43  *
  44  * @return sysinfo class
  45  */
  46 function PMA_getSysInfo()
  47 {
  48     $php_os = PMA_getSysInfoOs();
  49     $supported = array('Linux', 'WINNT', 'SunOS');
  50
  51     $sysinfo = array();
  52
  53     if (in_array($php_os, $supported)) {
  54         $ret = eval("return new PMA_SysInfo" . $php_os . "();");
  55         if ($ret->supported()) {
  56             return $ret;
  57         }
  58     }
  59
  60     return new PMA_SysInfo;
  61 }
  62
  63 /**
  64  * Basic sysinfo class not providing any real data.
  65  *
  66  * @package PhpMyAdmin-sysinfo
  67  */
  68 class PMA_SysInfo
  69 {
  70     public $os = PHP_OS;
  71
  72     /**
  73      * Gets load information
  74      *
  75      * @return array with load data
  76      */
  77     public function loadavg()
  78     {
  79         return array('loadavg' => 0);
  80     }
  81
  82     /**
  83      * Gets information about memory usage
  84      *
  85      * @return array with memory usage data
  86      */
  87     public function memory()
  88     {
  89         return array();
  90     }
  91
  92     /**
  93      * Checks whether class is supported in this environment
  94      *
  95      * @return true on success
  96      */
  97     public function supported()
  98     {
  99         return true;
 100     }
 101 }
 102
 103 /**
 104  * Windows NT based SysInfo class
 105  *
 106  * @package PhpMyAdmin-sysinfo
 107  */
 108 class PMA_SysInfoWinnt extends PMA_SysInfo
 109 {
 110     private $_wmi;
 111
 112     public $os = 'WINNT';
 113
 114     /**
 115      * Constructor to access to wmi database.
 116      */
 117     public function __construct()
 118     {
 119         if (!class_exists('COM')) {
 120             $this->_wmi = null;
 121         } else {
 122             // initialize the wmi object
 123             $objLocator = new COM('WbemScripting.SWbemLocator');
 124             $this->_wmi = $objLocator->ConnectServer();
 125         }
 126     }
 127
 128     /**
 129      * Gets load information
 130      *
 131      * @return array with load data
 132      */
 133     function loadavg()
 134     {
 135         $loadavg = "";
 136         $sum = 0;
 137         $buffer = $this->_getWMI('Win32_Processor', array('LoadPercentage'));
 138
 139         foreach ($buffer as $load) {
 140             $value = $load['LoadPercentage'];
 141             $loadavg .= $value . ' ';
 142             $sum += $value;
 143         }
 144
 145         return array('loadavg' => $sum / count($buffer));
 146     }
 147
 148     /**
 149      * Checks whether class is supported in this environment
 150      *
 151      * @return true on success
 152      */
 153     public function supported()
 154     {
 155         return !is_null($this->_wmi);
 156     }
 157
 158     /**
 159      * Reads data from WMI
 160      *
 161      * @param string $strClass Class to read
 162      * @param array  $strValue Values to read
 163      *
 164      * @return arrray with results
 165      */
 166     private function _getWMI($strClass, $strValue = array())
 167     {
 168         $arrData = array();
 169         $value = "";
 170
 171         $objWEBM = $this->_wmi->Get($strClass);
 172         $arrProp = $objWEBM->Properties_;
 173         $arrWEBMCol = $objWEBM->Instances_();
 174         foreach ($arrWEBMCol as $objItem) {
 175             if (is_array($arrProp)) {
 176                 reset($arrProp);
 177             }
 178             $arrInstance = array();
 179             foreach ($arrProp as $propItem) {
 180                 if ( empty($strValue)) {
 181                     eval("\$value = \$objItem->" . $propItem->Name . ";");
 182                     $arrInstance[$propItem->Name] = trim($value);
 183                 } else {
 184                     if (in_array($propItem->Name, $strValue)) {
 185                         eval("\$value = \$objItem->" . $propItem->Name . ";");
 186                         $arrInstance[$propItem->Name] = trim($value);
 187                     }
 188                 }
 189             }
 190             $arrData[] = $arrInstance;
 191         }
 192         return $arrData;
 193     }
 194
 195     /**
 196      * Gets information about memory usage
 197      *
 198      * @return array with memory usage data
 199      */
 200     function memory()
 201     {
 202         $buffer = $this->_getWMI(
 203             "Win32_OperatingSystem",
 204             array('TotalVisibleMemorySize', 'FreePhysicalMemory')
 205         );
 206         $mem = Array();
 207         $mem['MemTotal'] = $buffer[0]['TotalVisibleMemorySize'];
 208         $mem['MemFree'] = $buffer[0]['FreePhysicalMemory'];
 209         $mem['MemUsed'] = $mem['MemTotal'] - $mem['MemFree'];
 210
 211         $buffer = $this->_getWMI('Win32_PageFileUsage');
 212
 213         $mem['SwapTotal'] = 0;
 214         $mem['SwapUsed'] = 0;
 215         $mem['SwapPeak'] = 0;
 216
 217         foreach ($buffer as $swapdevice) {
 218             $mem['SwapTotal'] += $swapdevice['AllocatedBaseSize'] * 1024;
 219             $mem['SwapUsed'] += $swapdevice['CurrentUsage'] * 1024;
 220             $mem['SwapPeak'] += $swapdevice['PeakUsage'] * 1024;
 221         }
 222
 223         return $mem;
 224     }
 225 }
 226
 227 /**
 228  * Linux based SysInfo class
 229  *
 230  * @package PhpMyAdmin-sysinfo
 231  */
 232 class PMA_SysInfoLinux extends PMA_SysInfo
 233 {
 234     public $os = 'Linux';
 235
 236     /**
 237      * Gets load information
 238      *
 239      * @return array with load data
 240      */
 241     function loadavg()
 242     {
 243         $buf = file_get_contents('/proc/stat');
 244         $nums = preg_split("/\s+/", substr($buf, 0, strpos($buf, "\n")));
 245         return Array(
 246             'busy' => $nums[1] + $nums[2] + $nums[3],
 247             'idle' => intval($nums[4])
 248         );
 249     }
 250
 251     /**
 252      * Checks whether class is supported in this environment
 253      *
 254      * @return true on success
 255      */
 256     public function supported()
 257     {
 258         return is_readable('/proc/meminfo') && is_readable('/proc/stat');
 259     }
 260
 261
 262     /**
 263      * Gets information about memory usage
 264      *
 265      * @return array with memory usage data
 266      */
 267     function memory()
 268     {
 269         preg_match_all(
 270             MEMORY_REGEXP,
 271             file_get_contents('/proc/meminfo'),
 272             $matches
 273         );
 274
 275         $mem = array_combine($matches[1], $matches[2]);
 276         $mem['MemUsed']
 277             = $mem['MemTotal'] - $mem['MemFree'] - $mem['Cached'] - $mem['Buffers'];
 278         $mem['SwapUsed']
 279             = $mem['SwapTotal'] - $mem['SwapFree'] - $mem['SwapCached'];
 280
 281         foreach ($mem as $idx => $value) {
 282             $mem[$idx] = intval($value);
 283         }
 284         return $mem;
 285     }
 286 }
 287
 288 /**
 289  * SunOS based SysInfo class
 290  *
 291  * @package PhpMyAdmin-sysinfo
 292  */
 293 class PMA_SysInfoSunos extends PMA_SysInfo
 294 {
 295     public $os = 'SunOS';
 296
 297     /**
 298      * Read value from kstat
 299      *
 300      * @param string $key Key to read
 301      *
 302      * @return string with value
 303      */
 304     private function _kstat($key)
 305     {
 306         if ($m = shell_exec('kstat -p d '.$key)) {
 307             list($key, $value) = preg_split("/\t/", trim($m), 2);
 308             return $value;
 309         } else {
 310             return '';
 311         }
 312     }
 313
 314     /**
 315      * Gets load information
 316      *
 317      * @return array with load data
 318      */
 319     public function loadavg()
 320     {
 321         $load1 = $this->_kstat('unix:0:system_misc:avenrun_1min');
 322
 323         return array('loadavg' => $load1);
 324     }
 325
 326     /**
 327      * Checks whether class is supported in this environment
 328      *
 329      * @return true on success
 330      */
 331     public function supported()
 332     {
 333         return is_readable('/proc/meminfo');
 334     }
 335
 336
 337     /**
 338      * Gets information about memory usage
 339      *
 340      * @return array with memory usage data
 341      */
 342     public function memory()
 343     {
 344         preg_match_all(
 345             MEMORY_REGEXP,
 346             file_get_contents('/proc/meminfo'),
 347             $matches
 348         );
 349
 350         $pagesize = $this->_kstat('unix:0:seg_cache:slab_size');
 351         $mem['MemTotal']
 352             = $this->_kstat('unix:0:system_pages:pagestotal') * $pagesize;
 353         $mem['MemUsed']
 354             = $this->_kstat('unix:0:system_pages:pageslocked') * $pagesize;
 355         $mem['MemFree']
 356             = $this->_kstat('unix:0:system_pages:pagesfree') * $pagesize;
 357         $mem['SwapTotal'] = $this->_kstat('unix:0:vminfo:swap_avail') / 1024;
 358         $mem['SwapUsed'] = $this->_kstat('unix:0:vminfo:swap_alloc') / 1024;
 359         $mem['SwapFree'] = $this->_kstat('unix:0:vminfo:swap_free') / 1024;
 360
 361         return $mem;
 362     }
 363 }