<?php

include ("../../../inc/includes.php");

if (PluginVigiloMenu::canView()) {

    Html::header(__('Vigilo', 'vigilo'), $_SERVER["PHP_SELF"], "plugins",

                    "PluginVigiloMenu", "menu");

    $res = null;

    if (!empty($_POST["deploy"])) {

        $fds = array(

            1 => array("pipe", "w"),

            2 => array("pipe", "w"),

        );

        $cmd = "/usr/bin/sudo -n /usr/bin/vigiconf deploy -f --debug 2>&1";

        $res = proc_open($cmd, $fds, $pipes);

        if (!is_resource($res))

            $res = false;

    }

    PluginVigiloMenu::displayMenu($res, $pipes);

} else {

    Html::displayRightError();

}

Html::footer();

<?php

//require_once(__DIR__ . DIRECTORY_SEPARATOR . '');

abstract class VigiloXml

{

    abstract public function __toString();

    public static function sprintf($s)

    {

        $args = func_get_args();

        array_shift($args); // pop $s

        $new_args = array();

        foreach ($args as $arg) {

            if (is_string($arg)) {

                $new_args[] = htmlspecialchars($arg, ENT_XML1 | ENT_QUOTES, "utf-8");

            } else if (is_array($arg)) {

                $acc = '';

                foreach ($arg as $sub) {

                    if (is_object($sub))

                        $acc .= (string) $sub;

                }

                $new_args[] = $acc;

            } else {

                $new_args[] = (string) $arg;

            }

        }

        return vsprintf($s, $new_args);

    }

}

class VigiloHostTemplate extends VigiloXml

{

    protected $name;

    public function __construct($tpl)

    {

        $this->name = $tpl;

    }

    public function __toString()

    {

        return self::sprintf('<template>%s</template>', $this->name);

    }

}

class VigiloGroup extends VigiloXml

{

    protected $name;

    public function __construct($group)

    {

        $this->name = $group;

    }

    public function __toString()

    {

        return self::sprintf('<group>%s</group>', $this->name);

    }

}

class VigiloAttribute extends VigiloXml

{

    protected $name;

    protected $value;

    public function __construct($name, $value)

    {

        $this->name = $name;

        $this->value = $value;

    }

    public function __toString()

    {

        return self::sprintf(

            '<attribute name="%s">%s</attribute>',

            $this->name,

            $this->value

        );

    }

}

class VigiloItem extends VigiloXml

{

    protected $value;

    public function __construct($value)

    {

        $this->value = $value;

    }

    public function getValue()

    {

        return $this->value;

    }

    public function __toString()

    {

        return self::sprintf('<item>%s</item>', $this->value);

    }

}

class VigiloArg extends VigiloXml

{

    protected $name;

    protected $values;

    public function __construct($name, $values)

    {

        if (is_array($values)) {

            $new_values = array();

            foreach ($values as $value) {

                if (is_string($value))

                    $new_values[] = new VigiloItem($value);

                else if (!is_a($value, 'VigiloItem'))

                    throw new \RuntimeException();

                else

                    $new_values[] = $value;

            }

            $values = $new_values;

        } else if (!is_string($values) && !is_int($values) &&

                   !is_bool($values) && !is_float($values))

            throw new \RuntimeException();

        else {

            $values = (string) $values;

        }

        $this->name = $name;

        $this->values = $values;

    }

    public function getName()

    {

        return $this->name;

    }

    public function getValue()

    {

        if (is_string($this->values))

            return $this->values;

        return array_map('getValue', $this->values);

    }

    public function __toString()

    {

        return self::sprintf(

            '<arg name="%s">%s</arg>',

            $this->name,

            $this->values

        );

    }

}

class VigiloTest extends VigiloXml

{

    protected $name;

    protected $args;

    public function __construct($name, array $args = array())

    {

        $new_args = array();

        foreach ($args as $arg) {

            if (!is_a($arg, 'VigiloArg'))

                    throw new \RuntimeException();

            $new_args[$arg->getName()] = $arg;

        }

        $this->name = $name;

        $this->args = $new_args;

    }

    public function __toString()

    {

        return self::sprintf(

            '<test name="%s">%s</test>',

            $this->name,

            $this->args

        );

    }

}

class VigiloHost extends VigiloXml

{

    protected $computer;

    protected $addresses;

    protected $ventilation;

    protected $children;

    protected $agent;

    public function __construct($computer)

    {

        $this->agent        = null;

        $this->ventilation  = "Servers";

        $this->computer     = $computer;

        $this->addresses    = array();

        $this->children     = array();

        if (class_exists('PluginFusioninventoryAgent')) {

            $agent = new PluginFusioninventoryAgent();

            if ($agent->getAgentWithComputerid($this->computer->getID()) !== false)

                $this->agent = $agent;

        }

        $this->selectTemplates();

        $this->selectGroups();

        $this->monitorProcessor();

        $this->monitorMemory();

        $this->monitorNetworkInterfaces();

        $this->monitorSoftwares();

        $this->monitorPartitions();

    }

    public function getName()

    {

        return $this->computer->getName();

    }

    protected function selectTemplates()

    {

        $refs = array(

            "glpi_operatingsystems" => "operatingsystems_id",

            "glpi_operatingsystemversions" => "operatingsystemversions_id",

            "glpi_operatingsystemservicepacks" => "operatingsystemservicepacks_id",

        );

        $model = array();

        foreach ($refs as $table => $field) {

            $id = $this->computer->fields[$field];

            $value = Dropdown::getDropdownName($table, $id);

            if ($value !== "" && $value !== null && $value !== " " &&

                $value !== false && $value !== "-----") {

                $model[] = $value;

            }

        }

        if (!count($model))

            $model = "default";

        else

            $model = implode(" - ", $model);

        $this->children[] = new VigiloHostTemplate($model);

    }

    protected function selectGroups()

    {

        $location = new Location();

        $location->getFromDB($this->computer->fields["locations_id"]);

        $location = $location->getName();

        if (!$location)

            $location = "Servers";

        $this->children[] = new VigiloGroup($location);

    }

    protected function selectAddress()

    {

        static $address = null;

        if ($address === null && $this->agent) {

            $addresses = $this->agent->getIPs();

            if (count($addresses))

                $address = current($addresses);

        }

        if ($address === null) {

            $address = $this->$computer->getName();

            foreach ($this->addresses as $addr) {

                if (!$addr->is_ipv4())

                    continue;

                $textual = $addr->getTextual();

                if (is_string($textual)) {

                    $address = $textual;

                    break;

                }

            }

        }

        return $address;

    }

    protected function monitorProcessor()

    {

        $this->children[] = new VigiloTest('CPU');

    }

    protected function monitorMemory()

    {

        global $DB;

        $total = 0;

        $query = Item_DeviceMemory::getSQLRequestToSearchForItem(

            $this->computer->getType(),

            $this->computer->getID()

        );

        foreach ($DB->query($query) as $mem) {

            $memory = new Item_DeviceMemory();

            $memory->getFromDB($mem['id']);

            $total += $memory->fields['size'] * 1024 * 1024;

        }

        if ($total > 0)

            $this->children[] = new VigiloTest('RAM');

    }

    protected function monitorNetworkInterfaces()

    {

        global $DB;

        $query = NetworkPort::getSQLRequestToSearchForItem(

            $this->computer->getType(),

            $this->computer->getID()

        );

        foreach ($DB->query($query) as $np) {

            $query2 = NetworkName::getSQLRequestToSearchForItem("NetworkPort", $np['id']);

            $port = new NetworkPort();

            $port->getFromDB($np['id']);

            if ($port->getName() == 'lo')

                continue;

            $args   = array();

            $label  = isset($port->fields['comment']) ? $port->fields['comment'] : $port->getName();

            $args[] = new VigiloArg('label', $label);

            $args[] = new VigiloArg('name', $port->getName());

            // TODO: retrieve interface speed (from glpi_networkportethernets)

            $this->children[] = new VigiloTest('Interface', $args);

            // Retrieve all IP addresses associated with this interface.

            // This will be used later in selectAddress() to select

            // the most appropriate IP address to query this computer.

            foreach ($DB->query($query2) as $nn) {

                $query3 = IPAddress::getSQLRequestToSearchForItem("NetworkName", $nn['id']);

                foreach ($DB->query($query3) as $ip) {

                    $addr = new IPAddress();

                    if ($addr->getFromDB($ip['id']))

                        $this->addresses[] = $addr;

                }

            }

        }

    }

    protected function monitorSoftwares()

    {

    }

    protected function monitorPartitions()

    {

        global $DB;

        $query = ComputerDisk::getSQLRequestToSearchForItem(

            $this->computer->getType(),

            $this->computer->getID()

        );

        foreach ($DB->query($query) as $cd) {

            $disk = new ComputerDisk();

            $disk->getFromDB($cd['id']);

            $args = array();

            $args[] = new VigiloArg('label', $disk->getName());

            $args[] = new VigiloArg('partname', $disk->fields['mountpoint']);

            $total = $disk->fields['totalsize'];

            if (!empty($total))

                $args[] = new VigiloArg('max', $total * 1024 * 1024);

            $this->children[] = new VigiloTest('Partition', $args);

        }

    }

    public function __toString()

    {

        return self::sprintf(

            '<?xml version="1.0"?>' .

            '<host name="%s" address="%s" ventilation="%s">%s</host>',

            $this->computer->getName(),

            $this->selectAddress(),

            "Servers",

            $this->children

        );

    }

}

class VigiloHooks

{

    private $confdir;

    public function __construct($confdir="/etc/vigilo/vigiconf/conf.d")

    {

        $this->confdir = $confdir;

    }

    public function add($computer)

    {

        $host       = new VigiloHost($computer);

        $dirs       = array($this->confdir, "hosts", "managed");

        $confdir    = implode(DIRECTORY_SEPARATOR, $dirs);

        $file       = $confdir . DIRECTORY_SEPARATOR . $host->getName() . ".xml";

        mkdir($confdir, 0770, true);

        $acc = "";

        foreach ($dirs as $dir) {

            $acc .= DIRECTORY_SEPARATOR . $dir;

            chgrp($acc, "vigiconf");

        }

        $res = file_put_contents($file, $host, LOCK_EX);

        if ($res !== false) {

            chgrp($file, "vigiconf");

            chmod($file, 0660);

        }

    }

    public function delete($computer)

    {

        $this->_unmonitor($computer->fields["name"]);

    }

    public function update($computer)

    {

        if (isset($computer->oldvalues["name"])) {

            $this->_unmonitor($computer->oldvalues["name"]);

        }

        $this->add($computer);

    }

    public function _unmonitor($host)

    {

        $dirs = array($this->confdir, "hosts", "managed", $host . ".xml");

        unlink(implode(DIRECTORY_SEPARATOR, $dirs));

    }

}

<?php

if (!defined('GLPI_ROOT')) {

    die("Sorry. You can't access directly to this file");

}

class PluginVigiloMenu extends CommonGLPI

{

    const TIMEOUT = 30;

    /**

     * Name of the type

     *

     * @param $nb  integer  number of item in the type (default 0)

    **/

    static function getTypeName($nb=0) {

        return 'Vigilo';

    }

    static function canView() {

        return true;

    }

    static function canCreate() {

        return false;

    }

    static function getMenuName() {

        return self::getTypeName();

    }

    static function getAdditionalMenuOptions() {

        return array();

    }

    static function getAdditionalMenuContent() {

        return array();

    }

    static function displayMenu($res, $pipes) {

        echo '<h1>Vigilo</h1><form method="post" action="?itemtype=vigilo">';

        if (is_resource($res)) {

            ini_set("max_execution_time", 0);

            ignore_user_abort(true);

            set_time_limit(0);

            echo '<textarea readonly="readonly" id="vigilo_deploy" style="display: block; width: 99%; height: 280px">';

            do {

                $read = $exc = $pipes;

                $write = array();

                $nb = stream_select($read, $write, $exc, static::TIMEOUT, 0);

                // Error

                if ($nb === FALSE) {

                    echo "UNKNOWN ERROR\n";

                    break;

                }

                // Timeout

                if ($nb === 0) {

                    echo "ERROR: command timed out!\n";

                    break;

                }

                if (count($exc)) {

                    echo "UNKNOWN ERROR\n";

                    break;

                }

                foreach ($read as $stream)

                    echo htmlspecialchars(fread($stream, 1024), ENT_HTML5 | ENT_QUOTES, "utf-8");

                ob_flush();

                flush();

                if (feof($pipes[1]))

                    break;

            } while (1);

            $info = proc_get_status($res);

            if ($info === false) {

                echo "ERROR: could not determine process status\n";

            } else {

                if ($info["signaled"])

                    echo "Command terminated by signal ${info['termsig']}\n";

                if ($info["stopped"])

                    echo "Command stopped by signal ${info['stopsig']}\n";

                echo "Command exited with return code ${info['exitcode']}\n";

            }

            proc_close($res);

            echo '</textarea>';

        }

        echo '<button type="submit" name="deploy" value="1">Deploy</button>';

        Html::closeForm();

    }

}

<?php

include(__DIR__ . "/hook.php");

function plugin_init_vigilo() {

    global $PLUGIN_HOOKS;

    $hooks      =& $PLUGIN_HOOKS;

    $p          =  "vigilo";

    $hookObj    =  new VigiloHooks();

    $hooks['csrf_compliant'][$p]        = true;

    $hooks['item_add'][$p]              = array("Computer" => array($hookObj, "add"));

    $hooks['item_update'][$p]           = array("Computer" => array($hookObj, "update"));

    $hooks['item_purge'][$p]            = array("Computer" => array($hookObj, "delete"));

    $hooks['item_delete'][$p]           = array("Computer" => array($hookObj, "delete"));

    $hooks['item_restore'][$p]          = array("Computer" => array($hookObj, "add"));

    $hooks["menu_toadd"][$p]['plugins'] = 'PluginVigiloMenu';

    $hooks['config_page'][$p]           = 'front/menu.php?itemtype=vigilo';

}

function plugin_version_vigilo() {

   return array('name'           => 'Vigilo monitoring',

                'version'        => '0.1',

                'author'         => 'CSSI',

                'license'        => 'GPLv2+',

                'homepage'       => 'http://vigilo-nms.org',

                'minGlpiVersion' => '9.1');

}

function plugin_vigilo_check_config($verbose=false) {

    if (version_compare(GLPI_VERSION,'9.1','lt')) {

        echo "This plugin requires GLPI >= 9.1";

        return false;

    }

    return true;

}

function plugin_vigilo_check_prerequisites() {

    return true;

}

function plugin_vigilo_install() {

    return true;

}

function plugin_vigilo_uninstall() {

    return true;

}