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