743 lines
30 KiB
PHP
743 lines
30 KiB
PHP
<?php
|
|
/**
|
|
* XML Generation class
|
|
*
|
|
* PHP version 5
|
|
*
|
|
* @category PHP
|
|
* @package PSI_XML
|
|
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
|
* @copyright 2009 phpSysInfo
|
|
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
|
* @version SVN: $Id: class.XML.inc.php 699 2012-09-15 11:57:13Z namiltd $
|
|
* @link http://phpsysinfo.sourceforge.net
|
|
*/
|
|
/**
|
|
* class for generation of the xml
|
|
*
|
|
* @category PHP
|
|
* @package PSI_XML
|
|
* @author Michael Cramer <BigMichi1@users.sourceforge.net>
|
|
* @copyright 2009 phpSysInfo
|
|
* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License
|
|
* @version Release: 3.0
|
|
* @link http://phpsysinfo.sourceforge.net
|
|
*/
|
|
class XML
|
|
{
|
|
/**
|
|
* Sysinfo object where the information retrieval methods are included
|
|
*
|
|
* @var PSI_Interface_OS
|
|
*/
|
|
private $_sysinfo;
|
|
|
|
/**
|
|
* @var System
|
|
*/
|
|
private $_sys = null;
|
|
|
|
/**
|
|
* xml object with the xml content
|
|
*
|
|
* @var SimpleXMLExtended
|
|
*/
|
|
private $_xml;
|
|
|
|
/**
|
|
* object for error handling
|
|
*
|
|
* @var Error
|
|
*/
|
|
private $_errors;
|
|
|
|
/**
|
|
* array with all enabled plugins (name)
|
|
*
|
|
* @var array
|
|
*/
|
|
private $_plugins;
|
|
|
|
/**
|
|
* plugin name if pluginrequest
|
|
*
|
|
* @var string
|
|
*/
|
|
private $_plugin = '';
|
|
|
|
/**
|
|
* generate a xml for a plugin or for the main app
|
|
*
|
|
* @var boolean
|
|
*/
|
|
private $_plugin_request = false;
|
|
|
|
/**
|
|
* generate the entire xml with all plugins or only a part of the xml (main or plugin)
|
|
*
|
|
* @var boolean
|
|
*/
|
|
private $_complete_request = false;
|
|
|
|
/**
|
|
* doing some initial tasks
|
|
* - generate the xml structure with the right header elements
|
|
* - get the error object for error output
|
|
* - get a instance of the sysinfo object
|
|
*
|
|
* @param boolean $complete generate xml with all plugins or not
|
|
* @param string $pluginname name of the plugin
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __construct($complete = false, $pluginname = "")
|
|
{
|
|
$this->_errors = Error::singleton();
|
|
if ($pluginname == "") {
|
|
$this->_plugin_request = false;
|
|
$this->_plugin = '';
|
|
} else {
|
|
$this->_plugin_request = true;
|
|
$this->_plugin = $pluginname;
|
|
}
|
|
if ($complete) {
|
|
$this->_complete_request = true;
|
|
} else {
|
|
$this->_complete_request = false;
|
|
}
|
|
$os = PSI_OS;
|
|
$this->_sysinfo = new $os();
|
|
$this->_plugins = CommonFunctions::getPlugins();
|
|
$this->_xmlbody();
|
|
}
|
|
|
|
/**
|
|
* generate common information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildVitals()
|
|
{
|
|
$vitals = $this->_xml->addChild('Vitals');
|
|
$vitals->addAttribute('Hostname', $this->_sys->getHostname());
|
|
$vitals->addAttribute('IPAddr', $this->_sys->getIp());
|
|
$vitals->addAttribute('Kernel', $this->_sys->getKernel());
|
|
$vitals->addAttribute('Distro', $this->_sys->getDistribution());
|
|
$vitals->addAttribute('Distroicon', $this->_sys->getDistributionIcon());
|
|
$vitals->addAttribute('Uptime', $this->_sys->getUptime());
|
|
$vitals->addAttribute('Users', $this->_sys->getUsers());
|
|
$vitals->addAttribute('LoadAvg', $this->_sys->getLoad());
|
|
if ($this->_sys->getLoadPercent() !== null) {
|
|
$vitals->addAttribute('CPULoad', $this->_sys->getLoadPercent());
|
|
}
|
|
if ($this->_sysinfo->getLanguage() !== null) {
|
|
$vitals->addAttribute('SysLang', $this->_sysinfo->getLanguage());
|
|
}
|
|
if ($this->_sysinfo->getEncoding() !== null) {
|
|
$vitals->addAttribute('CodePage', $this->_sysinfo->getEncoding());
|
|
}
|
|
|
|
//processes
|
|
if (($procss = $this->_sys->getProcesses()) !== null) {
|
|
if (isset($procss['*']) && (($procall = $procss['*']) > 0)) {
|
|
$vitals->addAttribute('Processes', $procall);
|
|
if (!isset($procss[' ']) || !($procss[' '] > 0)) { // not unknown
|
|
$procsum = 0;
|
|
if (isset($procss['R']) && (($proctmp = $procss['R']) > 0)) {
|
|
$vitals->addAttribute('ProcessesRunning', $proctmp);
|
|
$procsum += $proctmp;
|
|
}
|
|
if (isset($procss['S']) && (($proctmp = $procss['S']) > 0)) {
|
|
$vitals->addAttribute('ProcessesSleeping', $proctmp);
|
|
$procsum += $proctmp;
|
|
}
|
|
if (isset($procss['T']) && (($proctmp = $procss['T']) > 0)) {
|
|
$vitals->addAttribute('ProcessesStopped', $proctmp);
|
|
$procsum += $proctmp;
|
|
}
|
|
if (isset($procss['Z']) && (($proctmp = $procss['Z']) > 0)) {
|
|
$vitals->addAttribute('ProcessesZombie', $proctmp);
|
|
$procsum += $proctmp;
|
|
}
|
|
if (isset($procss['D']) && (($proctmp = $procss['D']) > 0)) {
|
|
$vitals->addAttribute('ProcessesWaiting', $proctmp);
|
|
$procsum += $proctmp;
|
|
}
|
|
if (($proctmp = $procall - $procsum) > 0) {
|
|
$vitals->addAttribute('ProcessesOther', $proctmp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$vitals->addAttribute('OS', PSI_OS);
|
|
}
|
|
|
|
/**
|
|
* generate the network information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildNetwork()
|
|
{
|
|
$hideDevices = array();
|
|
$network = $this->_xml->addChild('Network');
|
|
if (defined('PSI_HIDE_NETWORK_INTERFACE')) {
|
|
if (is_string(PSI_HIDE_NETWORK_INTERFACE)) {
|
|
if (preg_match(ARRAY_EXP, PSI_HIDE_NETWORK_INTERFACE)) {
|
|
$hideDevices = eval(PSI_HIDE_NETWORK_INTERFACE);
|
|
} else {
|
|
$hideDevices = array(PSI_HIDE_NETWORK_INTERFACE);
|
|
}
|
|
} elseif (PSI_HIDE_NETWORK_INTERFACE === true) {
|
|
return;
|
|
}
|
|
}
|
|
foreach ($this->_sys->getNetDevices() as $dev) {
|
|
if (!in_array(trim($dev->getName()), $hideDevices)) {
|
|
$device = $network->addChild('NetDevice');
|
|
$device->addAttribute('Name', $dev->getName());
|
|
$device->addAttribute('RxBytes', $dev->getRxBytes());
|
|
$device->addAttribute('TxBytes', $dev->getTxBytes());
|
|
$device->addAttribute('Err', $dev->getErrors());
|
|
$device->addAttribute('Drops', $dev->getDrops());
|
|
if (defined('PSI_SHOW_NETWORK_INFOS') && PSI_SHOW_NETWORK_INFOS && $dev->getInfo())
|
|
$device->addAttribute('Info', $dev->getInfo());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the hardware information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildHardware()
|
|
{
|
|
$dev = new HWDevice();
|
|
$hardware = $this->_xml->addChild('Hardware');
|
|
if ($this->_sys->getMachine() != "") {
|
|
$hardware->addAttribute('Name', $this->_sys->getMachine());
|
|
}
|
|
$pci = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getPciDevices()) as $dev) {
|
|
if ($pci === null) $pci = $hardware->addChild('PCI');
|
|
$tmp = $pci->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
}
|
|
$usb = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getUsbDevices()) as $dev) {
|
|
if ($usb === null) $usb = $hardware->addChild('USB');
|
|
$tmp = $usb->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
}
|
|
$ide = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getIdeDevices()) as $dev) {
|
|
if ($ide === null) $ide = $hardware->addChild('IDE');
|
|
$tmp = $ide->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
if ($dev->getCapacity() !== null) {
|
|
$tmp->addAttribute('Capacity', $dev->getCapacity());
|
|
}
|
|
}
|
|
$scsi = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getScsiDevices()) as $dev) {
|
|
if ($scsi === null) $scsi = $hardware->addChild('SCSI');
|
|
$tmp = $scsi->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
if ($dev->getCapacity() !== null) {
|
|
$tmp->addAttribute('Capacity', $dev->getCapacity());
|
|
}
|
|
}
|
|
$tb = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getTbDevices()) as $dev) {
|
|
if ($tb === null) $tb = $hardware->addChild('TB');
|
|
$tmp = $tb->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
}
|
|
$i2c = null;
|
|
foreach (System::removeDupsAndCount($this->_sys->getI2cDevices()) as $dev) {
|
|
if ($i2c === null) $i2c = $hardware->addChild('I2C');
|
|
$tmp = $i2c->addChild('Device');
|
|
$tmp->addAttribute('Name', $dev->getName());
|
|
$tmp->addAttribute('Count', $dev->getCount());
|
|
}
|
|
|
|
$cpu = null;
|
|
foreach ($this->_sys->getCpus() as $oneCpu) {
|
|
if ($cpu === null) $cpu = $hardware->addChild('CPU');
|
|
$tmp = $cpu->addChild('CpuCore');
|
|
$tmp->addAttribute('Model', $oneCpu->getModel());
|
|
if ($oneCpu->getCpuSpeed() !== 0) {
|
|
$tmp->addAttribute('CpuSpeed', $oneCpu->getCpuSpeed());
|
|
}
|
|
if ($oneCpu->getCpuSpeedMax() !== 0) {
|
|
$tmp->addAttribute('CpuSpeedMax', $oneCpu->getCpuSpeedMax());
|
|
}
|
|
if ($oneCpu->getCpuSpeedMin() !== 0) {
|
|
$tmp->addAttribute('CpuSpeedMin', $oneCpu->getCpuSpeedMin());
|
|
}
|
|
if ($oneCpu->getTemp() !== null) {
|
|
$tmp->addAttribute('CpuTemp', $oneCpu->getTemp());
|
|
}
|
|
if ($oneCpu->getBusSpeed() !== null) {
|
|
$tmp->addAttribute('BusSpeed', $oneCpu->getBusSpeed());
|
|
}
|
|
if ($oneCpu->getCache() !== null) {
|
|
$tmp->addAttribute('Cache', $oneCpu->getCache());
|
|
}
|
|
if ($oneCpu->getVirt() !== null) {
|
|
$tmp->addAttribute('Virt', $oneCpu->getVirt());
|
|
}
|
|
if ($oneCpu->getBogomips() !== null) {
|
|
$tmp->addAttribute('Bogomips', $oneCpu->getBogomips());
|
|
}
|
|
if ($oneCpu->getLoad() !== null) {
|
|
$tmp->addAttribute('Load', $oneCpu->getLoad());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the memory information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildMemory()
|
|
{
|
|
$memory = $this->_xml->addChild('Memory');
|
|
$memory->addAttribute('Free', $this->_sys->getMemFree());
|
|
$memory->addAttribute('Used', $this->_sys->getMemUsed());
|
|
$memory->addAttribute('Total', $this->_sys->getMemTotal());
|
|
$memory->addAttribute('Percent', $this->_sys->getMemPercentUsed());
|
|
if (($this->_sys->getMemApplication() !== null) || ($this->_sys->getMemBuffer() !== null) || ($this->_sys->getMemCache() !== null)) {
|
|
$details = $memory->addChild('Details');
|
|
if ($this->_sys->getMemApplication() !== null) {
|
|
$details->addAttribute('App', $this->_sys->getMemApplication());
|
|
$details->addAttribute('AppPercent', $this->_sys->getMemPercentApplication());
|
|
}
|
|
if ($this->_sys->getMemBuffer() !== null) {
|
|
$details->addAttribute('Buffers', $this->_sys->getMemBuffer());
|
|
$details->addAttribute('BuffersPercent', $this->_sys->getMemPercentBuffer());
|
|
}
|
|
if ($this->_sys->getMemCache() !== null) {
|
|
$details->addAttribute('Cached', $this->_sys->getMemCache());
|
|
$details->addAttribute('CachedPercent', $this->_sys->getMemPercentCache());
|
|
}
|
|
}
|
|
if (count($this->_sys->getSwapDevices()) > 0) {
|
|
$swap = $memory->addChild('Swap');
|
|
$swap->addAttribute('Free', $this->_sys->getSwapFree());
|
|
$swap->addAttribute('Used', $this->_sys->getSwapUsed());
|
|
$swap->addAttribute('Total', $this->_sys->getSwapTotal());
|
|
$swap->addAttribute('Percent', $this->_sys->getSwapPercentUsed());
|
|
$i = 1;
|
|
foreach ($this->_sys->getSwapDevices() as $dev) {
|
|
$swapMount = $swap->addChild('Mount');
|
|
$this->_fillDevice($swapMount, $dev, $i++);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* fill a xml element with atrributes from a disk device
|
|
*
|
|
* @param SimpleXmlExtended $mount Xml-Element
|
|
* @param DiskDevice $dev DiskDevice
|
|
* @param Integer $i counter
|
|
*
|
|
* @return Void
|
|
*/
|
|
private function _fillDevice(SimpleXMLExtended $mount, DiskDevice $dev, $i)
|
|
{
|
|
$mount->addAttribute('MountPointID', $i);
|
|
$mount->addAttribute('FSType', $dev->getFsType());
|
|
$mount->addAttribute('Name', $dev->getName());
|
|
$mount->addAttribute('Free', sprintf("%.0f", $dev->getFree()));
|
|
$mount->addAttribute('Used', sprintf("%.0f", $dev->getUsed()));
|
|
$mount->addAttribute('Total', sprintf("%.0f", $dev->getTotal()));
|
|
$mount->addAttribute('Percent', $dev->getPercentUsed());
|
|
if (PSI_SHOW_MOUNT_OPTION === true) {
|
|
if ($dev->getOptions() !== null) {
|
|
$mount->addAttribute('MountOptions', preg_replace("/,/", ", ", $dev->getOptions()));
|
|
}
|
|
}
|
|
if ($dev->getPercentInodesUsed() !== null) {
|
|
$mount->addAttribute('Inodes', $dev->getPercentInodesUsed());
|
|
}
|
|
if (PSI_SHOW_MOUNT_POINT === true) {
|
|
$mount->addAttribute('MountPoint', $dev->getMountPoint());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the filesysteminformation
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildFilesystems()
|
|
{
|
|
$hideMounts = $hideFstypes = $hideDisks = array();
|
|
$i = 1;
|
|
if (defined('PSI_HIDE_MOUNTS') && is_string(PSI_HIDE_MOUNTS)) {
|
|
if (preg_match(ARRAY_EXP, PSI_HIDE_MOUNTS)) {
|
|
$hideMounts = eval(PSI_HIDE_MOUNTS);
|
|
} else {
|
|
$hideMounts = array(PSI_HIDE_MOUNTS);
|
|
}
|
|
}
|
|
if (defined('PSI_HIDE_FS_TYPES') && is_string(PSI_HIDE_FS_TYPES)) {
|
|
if (preg_match(ARRAY_EXP, PSI_HIDE_FS_TYPES)) {
|
|
$hideFstypes = eval(PSI_HIDE_FS_TYPES);
|
|
} else {
|
|
$hideFstypes = array(PSI_HIDE_FS_TYPES);
|
|
}
|
|
}
|
|
if (defined('PSI_HIDE_DISKS')) {
|
|
if (is_string(PSI_HIDE_DISKS)) {
|
|
if (preg_match(ARRAY_EXP, PSI_HIDE_DISKS)) {
|
|
$hideDisks = eval(PSI_HIDE_DISKS);
|
|
} else {
|
|
$hideDisks = array(PSI_HIDE_DISKS);
|
|
}
|
|
} elseif (PSI_HIDE_DISKS === true) {
|
|
return;
|
|
}
|
|
}
|
|
$fs = $this->_xml->addChild('FileSystem');
|
|
foreach ($this->_sys->getDiskDevices() as $disk) {
|
|
if (!in_array($disk->getMountPoint(), $hideMounts, true) && !in_array($disk->getFsType(), $hideFstypes, true) && !in_array($disk->getName(), $hideDisks, true)) {
|
|
$mount = $fs->addChild('Mount');
|
|
$this->_fillDevice($mount, $disk, $i++);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the motherboard information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildMbinfo()
|
|
{
|
|
$mbinfo = $this->_xml->addChild('MBInfo');
|
|
$temp = $fan = $volt = $power = $current = null;
|
|
|
|
if (sizeof(unserialize(PSI_MBINFO))>0) {
|
|
foreach (unserialize(PSI_MBINFO) as $mbinfoclass) {
|
|
$mbinfo_data = new $mbinfoclass();
|
|
$mbinfo_detail = $mbinfo_data->getMBInfo();
|
|
|
|
foreach ($mbinfo_detail->getMbTemp() as $dev) {
|
|
if ($temp == null) {
|
|
$temp = $mbinfo->addChild('Temperature');
|
|
}
|
|
$item = $temp->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMax() !== null) {
|
|
$item->addAttribute('Max', $dev->getMax());
|
|
}
|
|
if (defined('PSI_SENSOR_EVENTS') && PSI_SENSOR_EVENTS && $dev->getEvent() !== "") {
|
|
$item->addAttribute('Event', $dev->getEvent());
|
|
}
|
|
}
|
|
|
|
foreach ($mbinfo_detail->getMbFan() as $dev) {
|
|
if ($fan == null) {
|
|
$fan = $mbinfo->addChild('Fans');
|
|
}
|
|
$item = $fan->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMin() !== null) {
|
|
$item->addAttribute('Min', $dev->getMin());
|
|
}
|
|
if (defined('PSI_SENSOR_EVENTS') && PSI_SENSOR_EVENTS && $dev->getEvent() !== "") {
|
|
$item->addAttribute('Event', $dev->getEvent());
|
|
}
|
|
}
|
|
|
|
foreach ($mbinfo_detail->getMbVolt() as $dev) {
|
|
if ($volt == null) {
|
|
$volt = $mbinfo->addChild('Voltage');
|
|
}
|
|
$item = $volt->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMin() !== null) {
|
|
$item->addAttribute('Min', $dev->getMin());
|
|
}
|
|
if ($dev->getMax() !== null) {
|
|
$item->addAttribute('Max', $dev->getMax());
|
|
}
|
|
if (defined('PSI_SENSOR_EVENTS') && PSI_SENSOR_EVENTS && $dev->getEvent() !== "") {
|
|
$item->addAttribute('Event', $dev->getEvent());
|
|
}
|
|
}
|
|
|
|
foreach ($mbinfo_detail->getMbPower() as $dev) {
|
|
if ($power == null) {
|
|
$power = $mbinfo->addChild('Power');
|
|
}
|
|
$item = $power->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMax() !== null) {
|
|
$item->addAttribute('Max', $dev->getMax());
|
|
}
|
|
if (defined('PSI_SENSOR_EVENTS') && PSI_SENSOR_EVENTS && $dev->getEvent() !== "") {
|
|
$item->addAttribute('Event', $dev->getEvent());
|
|
}
|
|
}
|
|
|
|
foreach ($mbinfo_detail->getMbCurrent() as $dev) {
|
|
if ($current == null) {
|
|
$current = $mbinfo->addChild('Current');
|
|
}
|
|
$item = $current->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMax() !== null) {
|
|
$item->addAttribute('Max', $dev->getMax());
|
|
}
|
|
if (defined('PSI_SENSOR_EVENTS') && PSI_SENSOR_EVENTS && $dev->getEvent() !== "") {
|
|
$item->addAttribute('Event', $dev->getEvent());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PSI_HDDTEMP) {
|
|
$hddtemp = new HDDTemp();
|
|
$hddtemp_data = $hddtemp->getMBInfo();
|
|
foreach ($hddtemp_data->getMbTemp() as $dev) {
|
|
if ($temp == null) {
|
|
$temp = $mbinfo->addChild('Temperature');
|
|
}
|
|
$item = $temp->addChild('Item');
|
|
$item->addAttribute('Label', $dev->getName());
|
|
$item->addAttribute('Value', $dev->getValue());
|
|
if ($dev->getMax() !== null) {
|
|
$item->addAttribute('Max', $dev->getMax());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the ups information
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildUpsinfo()
|
|
{
|
|
$upsinfo = $this->_xml->addChild('UPSInfo');
|
|
if (defined('PSI_UPS_APCUPSD_CGI_ENABLE') && PSI_UPS_APCUPSD_CGI_ENABLE) {
|
|
$upsinfo->addAttribute('ApcupsdCgiLinks', true);
|
|
}
|
|
if (sizeof(unserialize(PSI_UPSINFO))>0) {
|
|
foreach (unserialize(PSI_UPSINFO) as $upsinfoclass) {
|
|
$upsinfo_data = new $upsinfoclass();
|
|
$upsinfo_detail = $upsinfo_data->getUPSInfo();
|
|
foreach ($upsinfo_detail->getUpsDevices() as $ups) {
|
|
$item = $upsinfo->addChild('UPS');
|
|
$item->addAttribute('Name', $ups->getName());
|
|
if ($ups->getModel() !== "") {
|
|
$item->addAttribute('Model', $ups->getModel());
|
|
}
|
|
$item->addAttribute('Mode', $ups->getMode());
|
|
if ($ups->getStartTime() !== "") {
|
|
$item->addAttribute('StartTime', $ups->getStartTime());
|
|
}
|
|
$item->addAttribute('Status', $ups->getStatus());
|
|
if ($ups->getTemperatur() !== null) {
|
|
$item->addAttribute('Temperature', $ups->getTemperatur());
|
|
}
|
|
if ($ups->getOutages() !== null) {
|
|
$item->addAttribute('OutagesCount', $ups->getOutages());
|
|
}
|
|
if ($ups->getLastOutage() !== null) {
|
|
$item->addAttribute('LastOutage', $ups->getLastOutage());
|
|
}
|
|
if ($ups->getLastOutageFinish() !== null) {
|
|
$item->addAttribute('LastOutageFinish', $ups->getLastOutageFinish());
|
|
}
|
|
if ($ups->getLineVoltage() !== null) {
|
|
$item->addAttribute('LineVoltage', $ups->getLineVoltage());
|
|
}
|
|
if ($ups->getLineFrequency() !== null) {
|
|
$item->addAttribute('LineFrequency', $ups->getLineFrequency());
|
|
}
|
|
if ($ups->getLoad() !== null) {
|
|
$item->addAttribute('LoadPercent', $ups->getLoad());
|
|
}
|
|
if ($ups->getBatteryDate() !== null) {
|
|
$item->addAttribute('BatteryDate', $ups->getBatteryDate());
|
|
}
|
|
if ($ups->getBatteryVoltage() !== null) {
|
|
$item->addAttribute('BatteryVoltage', $ups->getBatteryVoltage());
|
|
}
|
|
if ($ups->getBatterCharge() !== null) {
|
|
$item->addAttribute('BatteryChargePercent', $ups->getBatterCharge());
|
|
}
|
|
if ($ups->getTimeLeft() !== null) {
|
|
$item->addAttribute('TimeLeftMinutes', $ups->getTimeLeft());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate the xml document
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildXml()
|
|
{
|
|
if (!$this->_plugin_request || $this->_complete_request) {
|
|
if ($this->_sys === null) {
|
|
if (PSI_DEBUG === true) {
|
|
// Safe mode check
|
|
$safe_mode = @ini_get("safe_mode") ? true : false;
|
|
if ($safe_mode) {
|
|
$this->_errors->addError("WARN", "PhpSysInfo requires to set off 'safe_mode' in 'php.ini'");
|
|
}
|
|
// Include path check
|
|
$include_path = @ini_get("include_path");
|
|
if ($include_path && ($include_path!="")) {
|
|
$include_path = preg_replace("/(:)|(;)/", "\n", $include_path);
|
|
if (preg_match("/^\.$/m", $include_path)) {
|
|
$include_path = ".";
|
|
}
|
|
}
|
|
if ($include_path != ".") {
|
|
$this->_errors->addError("WARN", "PhpSysInfo requires '.' inside the 'include_path' in php.ini");
|
|
}
|
|
// popen mode check
|
|
if (defined("PSI_MODE_POPEN") && PSI_MODE_POPEN === true) {
|
|
$this->_errors->addError("WARN", "Installed version of PHP does not support proc_open() function, popen() is used");
|
|
}
|
|
}
|
|
$this->_sys = $this->_sysinfo->getSys();
|
|
}
|
|
$this->_buildVitals();
|
|
$this->_buildNetwork();
|
|
$this->_buildHardware();
|
|
$this->_buildMemory();
|
|
$this->_buildFilesystems();
|
|
$this->_buildMbinfo();
|
|
$this->_buildUpsinfo();
|
|
}
|
|
$this->_buildPlugins();
|
|
$this->_xml->combinexml($this->_errors->errorsAddToXML($this->_sysinfo->getEncoding()));
|
|
}
|
|
|
|
/**
|
|
* get the xml object
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getXml()
|
|
{
|
|
$this->_buildXml();
|
|
|
|
return $this->_xml->getSimpleXmlElement();
|
|
}
|
|
|
|
/**
|
|
* include xml-trees of the plugins to the main xml
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _buildPlugins()
|
|
{
|
|
$pluginroot = $this->_xml->addChild("Plugins");
|
|
if (($this->_plugin_request || $this->_complete_request) && count($this->_plugins) > 0) {
|
|
$plugins = array();
|
|
if ($this->_complete_request) {
|
|
$plugins = $this->_plugins;
|
|
}
|
|
if ($this->_plugin_request) {
|
|
$plugins = array($this->_plugin);
|
|
}
|
|
foreach ($plugins as $plugin) {
|
|
$object = new $plugin($this->_sysinfo->getEncoding());
|
|
$object->execute();
|
|
$oxml = $object->xml();
|
|
if (sizeof($oxml) > 0) {
|
|
$pluginroot->combinexml($oxml);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* build the xml structure where the content can be inserted
|
|
*
|
|
* @return void
|
|
*/
|
|
private function _xmlbody()
|
|
{
|
|
$dom = new DOMDocument('1.0', 'UTF-8');
|
|
$root = $dom->createElement("tns:phpsysinfo");
|
|
$root->setAttribute('xmlns:tns', 'http://phpsysinfo.sourceforge.net/');
|
|
$root->setAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance');
|
|
$root->setAttribute('xsi:schemaLocation', 'http://phpsysinfo.sourceforge.net/ phpsysinfo3.xsd');
|
|
$dom->appendChild($root);
|
|
$this->_xml = new SimpleXMLExtended(simplexml_import_dom($dom), $this->_sysinfo->getEncoding());
|
|
|
|
$generation = $this->_xml->addChild('Generation');
|
|
$generation->addAttribute('version', PSI_VERSION_STRING);
|
|
$generation->addAttribute('timestamp', time());
|
|
$options = $this->_xml->addChild('Options');
|
|
$options->addAttribute('tempFormat', defined('PSI_TEMP_FORMAT') ? strtolower(PSI_TEMP_FORMAT) : 'c');
|
|
$options->addAttribute('byteFormat', defined('PSI_BYTE_FORMAT') ? strtolower(PSI_BYTE_FORMAT) : 'auto_binary');
|
|
if (defined('PSI_REFRESH')) {
|
|
if (PSI_REFRESH === false) {
|
|
$options->addAttribute('refresh', 0);
|
|
} elseif (PSI_REFRESH === true) {
|
|
$options->addAttribute('refresh', 1);
|
|
} else {
|
|
$options->addAttribute('refresh', PSI_REFRESH);
|
|
}
|
|
} else {
|
|
$options->addAttribute('refresh', 60000);
|
|
}
|
|
if (defined('PSI_FS_USAGE_THRESHOLD')) {
|
|
if (PSI_FS_USAGE_THRESHOLD === true) {
|
|
$options->addAttribute('threshold', 1);
|
|
} elseif ((PSI_FS_USAGE_THRESHOLD !== false) && (PSI_FS_USAGE_THRESHOLD >= 1) && (PSI_FS_USAGE_THRESHOLD <= 99)) {
|
|
$options->addAttribute('threshold', PSI_FS_USAGE_THRESHOLD);
|
|
}
|
|
} else {
|
|
$options->addAttribute('threshold', 90);
|
|
}
|
|
$options->addAttribute('showPickListTemplate', defined('PSI_SHOW_PICKLIST_TEMPLATE') ? (PSI_SHOW_PICKLIST_TEMPLATE ? 'true' : 'false') : 'false');
|
|
$options->addAttribute('showPickListLang', defined('PSI_SHOW_PICKLIST_LANG') ? (PSI_SHOW_PICKLIST_LANG ? 'true' : 'false') : 'false');
|
|
$options->addAttribute('showCPUListExpanded', defined('PSI_SHOW_CPULIST_EXPANDED') ? (PSI_SHOW_CPULIST_EXPANDED ? 'true' : 'false') : 'true');
|
|
$options->addAttribute('showCPUInfoExpanded', defined('PSI_SHOW_CPUINFO_EXPANDED') ? (PSI_SHOW_CPUINFO_EXPANDED ? 'true' : 'false') : 'false');
|
|
if (count($this->_plugins) > 0) {
|
|
if ($this->_plugin_request) {
|
|
$plug = $this->_xml->addChild('UsedPlugins');
|
|
$plug->addChild('Plugin')->addAttribute('name', $this->_plugin);
|
|
} elseif ($this->_complete_request) {
|
|
$plug = $this->_xml->addChild('UsedPlugins');
|
|
foreach ($this->_plugins as $plugin) {
|
|
$plug->addChild('Plugin')->addAttribute('name', $plugin);
|
|
}
|
|
} else {
|
|
$plug = $this->_xml->addChild('UnusedPlugins');
|
|
foreach ($this->_plugins as $plugin) {
|
|
$plug->addChild('Plugin')->addAttribute('name', $plugin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|