487 lines
12 KiB
PHP
Executable File
487 lines
12 KiB
PHP
Executable File
<?php
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
/**
|
|
* This file is part of Icinga 2 Web.
|
|
*
|
|
* Icinga 2 Web - Head for multiple monitoring backends.
|
|
* Copyright (C) 2013 Icinga Development Team
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* @copyright 2013 Icinga Development Team <info@icinga.org>
|
|
* @license http://www.gnu.org/licenses/gpl-2.0.txt GPL, version 2
|
|
* @author Icinga Development Team <info@icinga.org>
|
|
*/
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
|
|
namespace Icinga\Protocol\Statusdat;
|
|
|
|
use Exception;
|
|
use Icinga\Filter\Query\Node;
|
|
use Icinga\Protocol;
|
|
use Icinga\Data\BaseQuery;
|
|
use Icinga\Protocol\Statusdat\View\MonitoringObjectList;
|
|
use Icinga\Protocol\Statusdat\Query\IQueryPart;
|
|
|
|
/**
|
|
* Class Query
|
|
* @package Icinga\Protocol\Statusdat
|
|
*/
|
|
class Query extends BaseQuery
|
|
{
|
|
/**
|
|
* @var array
|
|
*/
|
|
public static $VALID_TARGETS = array(
|
|
"hosts" => array("host"),
|
|
"services" => array("service"),
|
|
"downtimes" => array("downtime"),
|
|
"groups" => array("hostgroup", "servicegroup"),
|
|
"hostgroups" => array("hostgroup"),
|
|
"servicegroups" => array("servicegroup"),
|
|
"comments" => array("comment"),
|
|
"contacts" => array("contact"),
|
|
"contactgroups" => array("contactgroup")
|
|
);
|
|
|
|
private $queryFilter = null;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
private $source = "";
|
|
|
|
/**
|
|
* @var null
|
|
*/
|
|
private $limit = null;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
private $offset = 0;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $orderColumns = array();
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $groupColumns = array();
|
|
|
|
/**
|
|
* @var null
|
|
*/
|
|
private $groupByFn = null;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $filter = null;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $attributes = array();
|
|
|
|
/**
|
|
*
|
|
*/
|
|
const FN_SCOPE = 0;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
const FN_NAME = 1;
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasOrder()
|
|
{
|
|
return !empty($this->orderColumns);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasColumns()
|
|
{
|
|
$columns = $this->getColumns();
|
|
return !empty($columns);
|
|
}
|
|
|
|
public function setQueryFilter($filter)
|
|
{
|
|
$this->queryFilter = $filter;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasLimit()
|
|
{
|
|
return $this->limit !== false;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasOffset()
|
|
{
|
|
return $this->offset !== false;
|
|
}
|
|
|
|
/**
|
|
* @return null
|
|
*/
|
|
public function getLimit()
|
|
{
|
|
return $this->limit;
|
|
}
|
|
|
|
/**
|
|
* @return int|null
|
|
*/
|
|
public function getOffset()
|
|
{
|
|
return $this->offset;
|
|
}
|
|
|
|
/**
|
|
* @param $columns
|
|
* @param null $dir
|
|
* @return $this
|
|
*/
|
|
public function order($columns, $dir = null, $isFunction = false)
|
|
{
|
|
if ($dir && strtolower($dir) == "desc") {
|
|
$dir = self::SORT_DESC;
|
|
} else {
|
|
$dir = self::SORT_ASC;
|
|
}
|
|
if ($isFunction) {
|
|
$this->orderColumns[] = array($columns, $dir);
|
|
return $this;
|
|
}
|
|
if (!is_array($columns)) {
|
|
$columns = array($columns);
|
|
}
|
|
|
|
foreach ($columns as $col) {
|
|
if (($pos = strpos($col, ' ')) !== false) {
|
|
$dir = strtoupper(substr($col, $pos + 1));
|
|
if ($dir === 'DESC') {
|
|
$dir = self::SORT_DESC;
|
|
} else {
|
|
$dir = self::SORT_ASC;
|
|
}
|
|
$col = substr($col, 0, $pos);
|
|
} else {
|
|
$col = $col;
|
|
}
|
|
|
|
$this->orderColumns[] = array($col, $dir);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
public function orderByFn(array $callBack, $dir = null)
|
|
{
|
|
$this->order($callBack, $dir, true);
|
|
}
|
|
|
|
/**
|
|
* @param null $count
|
|
* @param int $offset
|
|
* @return $this
|
|
* @throws Exception
|
|
*/
|
|
public function limit($count = null, $offset = 0)
|
|
{
|
|
if ((is_null($count) || is_integer($count)) && (is_null($offset) || is_integer($offset))) {
|
|
$this->offset = $offset;
|
|
$this->limit = $count;
|
|
} else {
|
|
throw new Exception("Got invalid limit $count, $offset");
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $table
|
|
* @param null $columns
|
|
* @return $this
|
|
* @throws \Exception
|
|
*/
|
|
public function from($table, array $attributes = null)
|
|
{
|
|
if (!$this->getColumns() && $attributes) {
|
|
$this->setColumns($attributes);
|
|
}
|
|
if (isset(self::$VALID_TARGETS[$table])) {
|
|
$this->source = $table;
|
|
} else {
|
|
throw new \Exception("Unknown from target for status.dat :" . $table);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
private function getFilteredIndices($classType = "\Icinga\Protocol\Statusdat\Query\Group")
|
|
{
|
|
$baseGroup = $this->queryFilter;
|
|
|
|
|
|
$state = $this->ds->getObjects();
|
|
$result = array();
|
|
$source = self::$VALID_TARGETS[$this->source];
|
|
|
|
foreach ($source as $target) {
|
|
if (! isset($state[$target])) {
|
|
continue;
|
|
}
|
|
$indexes = array_keys($state[$target]);
|
|
if ($baseGroup) {
|
|
$baseGroup->setQuery($this);
|
|
$indexes = $baseGroup->filter($state[$target]);
|
|
}
|
|
if (!isset($result[$target])) {
|
|
$result[$target] = $indexes;
|
|
} else {
|
|
array_merge($result[$target], $indexes);
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param array $indices
|
|
*/
|
|
private function orderIndices(array &$indices)
|
|
{
|
|
if (!empty($this->orderColumns)) {
|
|
foreach ($indices as $type => &$subindices) {
|
|
$this->currentType = $type;
|
|
usort($subindices, array($this, "orderResult"));
|
|
}
|
|
}
|
|
}
|
|
|
|
public function select()
|
|
{
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param $a
|
|
* @param $b
|
|
* @return int
|
|
*/
|
|
private function orderResult($a, $b)
|
|
{
|
|
$o1 = $this->ds->getObjectByName($this->currentType, $a);
|
|
$o2 = $this->ds->getObjectByName($this->currentType, $b);
|
|
$result = 0;
|
|
|
|
foreach ($this->orderColumns as &$col) {
|
|
if (is_array($col[0])) {
|
|
$result += $col[1] * strnatcasecmp($col[0][0]->$col[0][1]($o1), $col[0][0]->$col[0][1]($o2));
|
|
} else {
|
|
if (is_string($o1->{$col[0]}) && is_string($o2->{$col[0]}) ) {
|
|
$result += $col[1] * strnatcasecmp($o1->{$col[0]}, $o2->{$col[0]});
|
|
}
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param array $indices
|
|
*/
|
|
private function limitIndices(array &$indices)
|
|
{
|
|
foreach ($indices as $type => $subindices) {
|
|
$indices[$type] = array_slice($subindices, $this->offset, $this->limit);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $fn
|
|
* @param null $scope
|
|
* @return $this
|
|
*/
|
|
public function groupByFunction($fn, $scope = null)
|
|
{
|
|
$this->groupByFn = array($scope ? $scope : $this, $fn);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param $columns
|
|
* @return $this
|
|
*/
|
|
public function groupByColumns($columns)
|
|
{
|
|
if (!is_array($columns)) {
|
|
$columns = array($columns);
|
|
}
|
|
$this->groupColumns = $columns;
|
|
$this->groupByFn = array($this, "columnGroupFn");
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param array $indices
|
|
* @return array
|
|
*/
|
|
private function columnGroupFn(array &$indices)
|
|
{
|
|
$cols = $this->groupColumns;
|
|
$result = array();
|
|
foreach ($indices as $type => $subindices) {
|
|
foreach ($subindices as $objectIndex) {
|
|
$r = $this->ds->getObjectByName($type, $objectIndex);
|
|
$hash = "";
|
|
$cols = array();
|
|
foreach ($this->groupColumns as $col) {
|
|
$hash = md5($hash . $r->$col);
|
|
$cols[$col] = $r->$col;
|
|
}
|
|
if (!isset($result[$hash])) {
|
|
$result[$hash] = (object)array(
|
|
"columns" => (object)$cols,
|
|
"count" => 0
|
|
);
|
|
}
|
|
$result[$hash]->count++;
|
|
}
|
|
}
|
|
return array_values($result);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getResult()
|
|
{
|
|
|
|
$indices = $this->getFilteredIndices();
|
|
$this->orderIndices($indices);
|
|
if ($this->groupByFn) {
|
|
$scope = $this->groupByFn[self::FN_SCOPE];
|
|
$fn = $this->groupByFn[self::FN_NAME];
|
|
|
|
return $scope->$fn($indices);
|
|
}
|
|
|
|
$this->limitIndices($indices);
|
|
|
|
$result = array();
|
|
$state = $this->ds->getObjects();
|
|
foreach ($indices as $type => $subindices) {
|
|
foreach ($subindices as $index) {
|
|
$result[] = & $state[$type][$index];
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Apply all filters of this filterable on the datasource
|
|
*/
|
|
public function applyFilter()
|
|
{
|
|
$parser = new TreeToStatusdatQueryParser();
|
|
if ($this->getFilter()) {
|
|
$query = $parser->treeToQuery($this->getFilter());
|
|
$this->setQueryFilter($query);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function fetchRow()
|
|
{
|
|
$result = $this->fetchAll();
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @return mixed|void
|
|
*/
|
|
public function fetchPairs()
|
|
{
|
|
$result = array();
|
|
if (count($this->getColumns()) < 2) {
|
|
throw new Exception(
|
|
'Status.dat "fetchPairs()" query expects at least' .
|
|
' columns to be set in the query expression'
|
|
);
|
|
}
|
|
$attributes = $this->getColumns();
|
|
|
|
$param1 = $attributes[0];
|
|
$param2 = $attributes[1];
|
|
foreach ($this->fetchAll() as $resultList) {
|
|
$result[$resultList->$param1] = $resultList->$param2;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function fetchOne()
|
|
{
|
|
return next($this->fetchAll());
|
|
}
|
|
|
|
/**
|
|
* @return MList|mixed|null
|
|
*/
|
|
public function fetchAll()
|
|
{
|
|
$this->applyFilter();
|
|
if (!isset($this->cursor)) {
|
|
$result = $this->getResult();
|
|
$this->cursor = new MonitoringObjectList($result, $this);
|
|
}
|
|
return $this->cursor;
|
|
}
|
|
|
|
/**
|
|
* @return int|mixed
|
|
*/
|
|
public function count()
|
|
{
|
|
$q = clone $this;
|
|
$q->limit(null, null);
|
|
return count($q->fetchAll());
|
|
}
|
|
|
|
|
|
}
|