Source of file NextDomHelper.php

<?php

/* This file is part of Jeedom.

 *

 * Jeedom 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 3 of the License, or

 * (at your option) any later version.

 *

 * Jeedom 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 Jeedom. If not, see <http://www.gnu.org/licenses/>.

 */

/* This file is part of NextDom Software.

 *

 * NextDom 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 3 of the License, or

 * (at your option) any later version.

 *

 * NextDom Software 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 NextDom Software. If not, see <http://www.gnu.org/licenses/>.

 */

namespace NextDom\Helpers;

use NextDom\Enums\Common;

use NextDom\Enums\ConfigKey;

use NextDom\Enums\DateFormat;

use NextDom\Enums\LogTarget;

use NextDom\Enums\NextDomObj;

use NextDom\Enums\SystemCron;

use NextDom\Exceptions\CoreException;

use NextDom\Managers\CacheManager;

use NextDom\Managers\CmdManager;

use NextDom\Managers\ConfigManager;

use NextDom\Managers\CronManager;

use NextDom\Managers\DataStoreManager;

use NextDom\Managers\EqLogicManager;

use NextDom\Managers\EventManager;

use NextDom\Managers\JeeObjectManager;

use NextDom\Managers\MessageManager;

use NextDom\Managers\PlanHeaderManager;

use NextDom\Managers\PluginManager;

use NextDom\Managers\ScenarioExpressionManager;

use NextDom\Managers\ScenarioManager;

use NextDom\Managers\UpdateManager;

use NextDom\Managers\UserManager;

use NextDom\Managers\ViewManager;

use NextDom\Model\DataClass\SystemHealth;

use NextDom\Repo\RepoMarket;

/**

 * Class NextDomHelper

 * @package NextDom\Helpers

 */

class NextDomHelper

{

    /**

     *

     */

    private static $nextdomConfiguration;

    /**

     * Add an entry in the history and keep only the last 200

     * @param $data

     */

    public static function addRemoveHistory($data)

    {

        $removeHistory = [];

        $removeHistoryPath = NEXTDOM_DATA . '/data/remove_history.json';

        if (file_exists($removeHistoryPath)) {

            $removeHistory = json_decode(file_get_contents($removeHistoryPath), true);

        }

        $removeHistory[] = $data;

        $removeHistory = array_slice($removeHistory, -200, 200);

        file_put_contents($removeHistoryPath, json_encode($removeHistory));

    }

    /**

     * Get all dead commands

     *

     * @return array

     * @throws \Exception

     */

    public static function getDeadCmd()

    {

        global $NEXTDOM_INTERNAL_CONFIG;

        $result = [];

        $cmd = ConfigManager::byKey('interact::warnme::defaultreturncmd', 'core', '');

        if ($cmd != '' && !CmdManager::byId(str_replace('#', '', $cmd))) {

            $result[] = ['detail' => 'Administration', 'help' => __('Commande retour interactions'), 'who' => $cmd];

        }

        $cmd = ConfigManager::byKey('emailAdmin', 'core', '');

        if ($cmd != '' && !CmdManager::byId(str_replace('#', '', $cmd))) {

            $result[] = ['detail' => 'Administration', 'help' => __('Commande information utilisateur'), 'who' => $cmd];

        }

        foreach ($NEXTDOM_INTERNAL_CONFIG['alerts'] as $level => $value) {

            $cmds = ConfigManager::byKey('alert::' . $level . 'Cmd', 'core', '');

            preg_match_all("/#([0-9]*)#/", $cmds, $matches);

            foreach ($matches[1] as $cmd_id) {

                if (CmdManager::byId($cmd_id)) {

                    $result[] = ['detail' => 'Administration', 'help' => __('Commande sur ') . $value['name'], 'who' => '#' . $cmd_id . '#'];

                }

            }

        }

        return $result;

    }

    /**

     * Get system health

     * Test all functionnalities

     *

     * @return array Data about system health

     * @throws \Exception

     */

    public static function health(): array

    {

        $okStr = __('common.ok');

        $nokStr = __('common.nok');

        $systemHealth = [];

        $state = true;

        $version = '';

        $uname = SystemHelper::getSystemInformations();

        if (SystemHelper::getDistrib() != 'debian') {

            $state = false;

        } else {

            $version = trim(strtolower(file_get_contents('/etc/debian_version')));

            if (version_compare($version, '8', '<')

                && strpos($version, 'jessie') === false

                && strpos($version, 'stretch') === false

                && strpos($version, 'buster') === false) {

                $state = false;

            }

        }

        $systemHealth[] = new SystemHealth(

            'fa-cogs',

            'health.os-version',

            $state,

            ($state) ? $uname . ' [' . $version . ']' : $uname,

            ($state) ? '' : __('health.os-not-supported'),

            'os::version');

        $nbNeededUpdate = UpdateManager::nbNeedUpdate();

        $state = ($nbNeededUpdate == 0) ? true : false;

        $systemHealth[] = new SystemHealth('fa-heartbeat', 'health.update-to-date', $state, ($state) ? $okStr : $nbNeededUpdate . ' ' . __('health.updates'), '', 'uptodate');

        $state = ConfigManager::byKey(ConfigKey::ENABLE_CRON, 'core', 1, true) != 0;

        $systemHealth[] = new SystemHealth('fa-calendar-alt', 'health.cron-enabled', $state, ($state) ? $okStr : $nokStr, ($state) ? '' : __('health.cron-disabled'), 'cron::enable');

        $state = !(ConfigManager::byKey(ConfigKey::ENABLE_SCENARIO) == 0 && count(ScenarioManager::all()) > 0);

        $systemHealth[] = new SystemHealth('fa-film', 'health.scenario-enabled', $state, ($state) ? $okStr : $nokStr, ($state) ? '' : __('health.scenario-disabled'), 'scenario::enable');

        $state = self::isStarted();

        $systemHealth[] = new SystemHealth('fa-play', 'health.product-started', $state, ($state) ? $okStr . ' - ' . file_get_contents(self::getStartedFilePath()) : $nokStr, '', 'isStarted');

        $state = self::isDateOk();

        $cache = CacheManager::byKey('hour');

        $lastKnowDate = $cache->getValue();

        $systemHealth[] = new SystemHealth('fa-clock', 'health.system-date', $state, ($state) ? $okStr . ' - ' . date(DateFormat::FULL) . ' (' . $lastKnowDate . ')' : date(DateFormat::FULL), ($state) ? '' : __('health.system-date-error'), 'hour');

        $state = self::isCapable('sudo', true);

        $systemHealth[] = new SystemHealth('fa-user-secret', 'health.sudo-rights', ($state) ? 1 : 2, ($state) ? $okStr : $nokStr, ($state) ? '' : __('sudo-error'), 'sudo::right');

        $systemHealth[] = new SystemHealth('fa-code-branch', 'health.product-version', true, self::getNextdomVersion(), '', 'nextdom::version');

        $state = version_compare(phpversion(), '7.0', '>=');

        $systemHealth[] = new SystemHealth('fa-code', 'health.php-version', $state, phpversion(), ($state) ? '' : __('health.php-error'), 'php::version');

        $version = DBHelper::getOne('select version()');

        $systemHealth[] = new SystemHealth('fa-database', 'health.database-version', true, $version['version()'], ($state) ? '' : __('health.php-error'), 'database::version');

        $value = self::checkSpaceLeft();

        $systemHealth[] = new SystemHealth('fa-hdd', 'health.harddisk-freespace', ($value > 10), $value . ' %', __('health.need-more-than') . ': 10%', 'space::root');

        $value = self::checkSpaceLeft(self::getTmpFolder());

        $systemHealth[] = new SystemHealth('fa-hdd', 'health.tmp-space-left', ($value > 10), $value . ' %', __('health.tmp-problem') . ': 10%', 'space::tmp');

        $values = SystemHelper::getMemInfo();

        $value = round(($values['MemAvailable'] / $values['MemTotal']) * 100);

        $systemHealth[] = new SystemHealth('fa-th', 'health.available-memory', ($value > 15), $value . ' %', __('health.need-more-than') . ': 15%', 'meminfo');

        $value = shell_exec('sudo dmesg | grep oom | grep -v deprecated | wc -l');

        $systemHealth[] = new SystemHealth('fa-th-large', 'health.enough-memory', ($value == 0), ($state == 0) ? $nokStr : $okStr, ($value == 0) ? '' : __('health.processes-killed'), 'oom');

        $value = shell_exec('sudo dmesg | grep "CRC error" | grep "mmcblk0" | grep "card status" | wc -l');

        if (!is_numeric($value)) {

            $value = 0;

        }

        $value2 = @shell_exec('sudo dmesg | grep "I/O error" | wc -l');

        if (is_numeric($value2)) {

            $value += $value2;

        }

        $systemHealth[] = new SystemHealth('fa fa-hearth', __('Erreur I/O'), $value == 0, $value, ($value == 0) ? '' : __('Il y a des erreurs disque, cela peut indiquer un soucis avec le disque ou un problème d\'alimentation'), 'io_error');

        if ($values['SwapTotal'] != 0 && $values['SwapTotal'] !== null) {

            $value = round(($values['SwapFree'] / $values['SwapTotal']) * 100);

            $systemHealth[] = new SystemHealth('fa-hdd', 'health.available-swap', ($value > 15), $value . ' %', __('health.need-more-than') . ': 15%', 'swap');

        } else {

            $systemHealth[] = new SystemHealth('fa-hdd', 'health.available-swap', 2, __('health.unknow'), '', 'swap');

        }

        $value = shell_exec('sudo cat /proc/sys/vm/swappiness');

        $state = ($value <= 20);

        if($values['MemTotal'] >= (1024*1024)){

            $state = true;

        }

        $systemHealth[] = new SystemHealth('fa-hdd', 'health.swapiness', $state, $value.'%', ($state) ? '' :__('health.swapiness-config'), 'swapiness');

        $values = sys_getloadavg();

        $systemHealth[] = new SystemHealth('fa-fire', 'health.load', ($values[2] < 20), $values[0] . ' - ' . $values[1] . ' - ' . $values[2], __('health.need-less-than') . ': 20', 'load');

        $state = NetworkHelper::test('internal');

        $systemHealth[] = new SystemHealth('fa-plug', 'health.internal-network-conf', $state, ($state) ? $okStr : $nokStr, ($state) ? '' : __('health.network-config'), 'network::internal');

        $state = NetworkHelper::test('external');

        $systemHealth[] = new SystemHealth('fa-globe', 'health.external-network-conf', $state, ($state) ? $okStr : $nokStr, ($state) ? '' : __('health.network-config'), 'network::external');

        $cacheHealth = new SystemHealth('fa-inbox', 'health.cache-persistence', false, '', '', 'cache::persit');

        if (CacheManager::isPersistOk()) {

            if ((ConfigManager::byKey('cache::engine') != 'FilesystemCache') &&

                (ConfigManager::byKey('cache::engine') != 'PhpFileCache')) {

                $cacheHealth->setState(true);

                $cacheHealth['result'] = $okStr;

            } else {

                $cache_path = CacheManager::getArchivePath();

                $cache_time = date(DateFormat::FULL, filemtime($cache_path));

                $cacheHealth->setState(true);

                $cacheHealth->setResult(sprintf("%s (%s)", $okStr, $cache_time));

            }

        } else {

            $cacheHealth->setState(false)

                ->setResult($nokStr)

                ->setComment(__('health.cache-not-saved'));

        }

        $systemHealth[] = $cacheHealth;

        $state = shell_exec('systemctl show apache2 | grep  PrivateTmp | grep yes | wc -l');

        $systemHealth[] = new SystemHealth('fa-folder', 'health.apache-private-tmp', $state, ($state) ? $okStr : $nokStr, ($state) ? '' : __('health.apache-private-tmp-disabled'), 'apache2::privateTmp');

        foreach (UpdateManager::listRepo() as $repo) {

            if ($repo['enable']) {

                $targetClass = $repo['class'];

                if (class_exists($targetClass) && method_exists($targetClass, 'health')) {

                    $systemHealth += array_merge($systemHealth, $targetClass::health());

                }

            }

        }

        return $systemHealth;

    }

    /**

     * Test if NextDom is started

     *

     * @return bool True if NextDom is started

     * @throws \Exception

     */

    public static function isStarted(): bool

    {

        return file_exists(self::getStartedFilePath());

    }

    /**

     * @return string

     * @throws \Exception

     */

    public static function getStartedFilePath(): string

    {

        return sprintf("%s/started", self::getTmpFolder());

    }

    /**

     * Get temporary folder and creates it if not exists

     *

     * @param string|null $subFolder Log subfolder

     *

     * @return string

     * @throws \Exception

     */

    public static function getTmpFolder($subFolder = null)

    {

        $result = '/' . trim(ConfigManager::byKey('folder::tmp'), '/');

        if ($subFolder !== null) {

            $result .= '/' . $subFolder;

        }

        if (!file_exists($result)) {

            mkdir($result, 0775, true);

        }

        return $result;

    }

    /**

     * Update time status and get it

     *

     * @return boolean Time status

     * @throws \Exception

     */

    public static function isDateOk()

    {

        if (ConfigManager::byKey('ignoreHourCheck') == 1) {

            return true;

        }

        $cache = CacheManager::byKey('hour');

        $lastKnowDate = $cache->getValue();

        if (strtotime($lastKnowDate) > strtotime('now')) {

            self::forceSyncHour();

            sleep(3);

            if (strtotime($lastKnowDate) > strtotime('now')) {

                return false;

            }

        }

        $minDateValue = new \DateTime('2017-01-01');

        $mindate = strtotime($minDateValue->format('Y-m-d 00:00:00'));

        $maxDateValue = $minDateValue->modify('+6 year')->format('Y-m-d 00:00:00');

        $maxdate = strtotime($maxDateValue);

        if (strtotime('now') < $mindate || strtotime('now') > $maxdate) {

            self::forceSyncHour();

            sleep(3);

            if (strtotime('now') < $mindate || strtotime('now') > $maxdate) {

                LogHelper::addError('core', sprintf(__('core.incorrect-sys-date'), $minDateValue, $maxDateValue) . (new \DateTime())->format(DateFormat::FULL), 'dateCheckFailed');

                return false;

            }

        }

        return true;

    }

    /**

     * Sync time

     */

    public static function forceSyncHour()

    {

        if (ConfigManager::byKey('disable_ntp', Common::CORE, 0) == 1) {

            return false;

        }

        shell_exec(SystemHelper::getCmdSudo() . 'service ntp stop;' . SystemHelper::getCmdSudo() . 'ntpdate -s ' . ConfigManager::byKey('ntp::optionalServer', 'core', '0.debian.pool.ntp.org') . ';' . SystemHelper::getCmdSudo() . 'service ntp start');

    }

    /**

     * Test if NextDom can call system function

     *

     * @param string $systemFunc Function to test

     * @param bool $forceRefresh Force refresh in configuration

     *

     * @return bool True if $systemFunc can be executed

     * @throws \Exception

     */

    public static function isCapable($systemFunc, $forceRefresh = false)

    {

        global $NEXTDOM_COMPATIBILIY_CONFIG;

        if ($systemFunc == 'sudo') {

            if (!$forceRefresh) {

                $cache = CacheManager::byKey('nextdom::isCapable::sudo');

                if ($cache->getValue(0) == 1) {

                    return true;

                }

            }

            $result = shell_exec('sudo -l > /dev/null 2>&1; echo $?') == 0;

            CacheManager::set('nextdom::isCapable::sudo', $result);

            return $result;

        }

        $hardware = self::getHardwareName();

        if (!isset($NEXTDOM_COMPATIBILIY_CONFIG[$hardware])) {

            return false;

        }

        if (in_array($systemFunc, $NEXTDOM_COMPATIBILIY_CONFIG[$hardware])) {

            return true;

        }

        return false;

    }

    /**

     * Get hostname

     *

     * @return string

     * @throws \Exception

     */

    public static function getHardwareName()

    {

        if (ConfigManager::byKey(ConfigKey::HARDWARE_NAME) != '') {

            return ConfigManager::byKey(ConfigKey::HARDWARE_NAME);

        }

        $result = 'diy';

        $uname = SystemHelper::getSystemInformations();

        if (strpos(shell_exec('sudo cat /proc/1/cgroup'), 'docker') !== false) {

            $result = 'docker';

        } else if (file_exists('/usr/bin/raspi-config')) {

            $result = 'rpi';

            $hardware_revision = strtolower(shell_exec('cat /proc/cpuinfo | grep Revision'));

            global $NEXTDOM_RPI_HARDWARE;

            foreach ($NEXTDOM_RPI_HARDWARE as $key => $values) {

                foreach ($values as $value) {

                    if (strpos($hardware_revision, $value) !== false) {

                        $result = $key;

                    }

                }

            }

        } else if (strpos($uname, 'cubox') !== false || strpos($uname, 'imx6') !== false || file_exists('/media/boot/multiboot/meson64_odroidc2.dtb.linux')) {

            $result = 'miniplus';

        }

        if (file_exists('/media/boot/multiboot/meson64_odroidc2.dtb.linux')) {

            $result = 'smart';

        }

        ConfigManager::save(ConfigKey::HARDWARE_NAME, $result);

        return ConfigManager::byKey(ConfigKey::HARDWARE_NAME);

    }

    /**

     * Get Nextdom version

     *

     * @return string

     */

    public static function getNextdomVersion()

    {

        if (file_exists(NEXTDOM_DATA . '/config/Nextdom_version')) {

            return trim(file_get_contents(NEXTDOM_DATA . '/config/Nextdom_version'));

        }

        return '';

    }

    /**

     * Check space left

     *

     * @param null $directory

     * @return float

     */

    public static function checkSpaceLeft($directory = null): float

    {

        if ($directory == null) {

            $pathToCheck = NEXTDOM_ROOT;

        } else {

            $pathToCheck = $directory;

        }

        return round(disk_free_space($pathToCheck) / disk_total_space($pathToCheck) * 100);

    }

    /**

     * Get informations about system installation

     */

    public static function sick()

    {

        $cmd = NEXTDOM_ROOT . '/scripts/sick.php';

        $cmd .= ' >> ' . LogHelper::getPathToLog('sick') . ' 2>&1';

        SystemHelper::php($cmd);

    }

    /**

     * Test if NextDom running right

     *

     * @return bool

     * @throws \Exception

     */

    public static function isOk()

    {

        if (!self::isStarted()) {

            return false;

        }

        if (!self::isDateOk()) {

            return false;

        }

        if (ConfigManager::byKey(ConfigKey::ENABLE_SCENARIO) == 0 && count(ScenarioManager::all()) > 0) {

            return false;

        }

        if (!self::isCapable('sudo')) {

            return false;

        }

        if (ConfigManager::byKey(ConfigKey::ENABLE_CRON, 'core', 1, true) == 0) {

            return false;

        }

        return true;

    }

    /**

     * Start update

     *

     * @param array $options Options list of /install/update.php script

     * @throws \Exception

     */

    public static function update($options = [])

    {

        LogHelper::clear('update');

        $params = '';

        foreach ($options as $key => $value) {

            $params .= '"' . $key . '"="' . $value . '" ';

        }

        SystemHelper::php(NEXTDOM_ROOT . '/install/update.php ' . $params . ' >> ' . LogHelper::getPathToLog('update') . ' &');

    }

    /**

     * Get configuration informations or global configuration

     *

     * @param string $askedKey

     * @param mixed $defaultValue

     *

     * @return mixed

     * @throws \Exception

     */

    public static function getConfiguration(string $askedKey = '', $defaultValue = false)

    {

        global $NEXTDOM_INTERNAL_CONFIG;

        if ($askedKey == '') {

            return $NEXTDOM_INTERNAL_CONFIG;

        }

        if (!is_array(self::$nextdomConfiguration)) {

            self::$nextdomConfiguration = [];

        }

        // @TODO: Bizarre

        if (!$defaultValue && isset(self::$nextdomConfiguration[$askedKey])) {

            return self::$nextdomConfiguration[$askedKey];

        }

        $keys = explode(':', $askedKey);

        $result = $NEXTDOM_INTERNAL_CONFIG;

        foreach ($keys as $key) {

            if (isset($result[$key])) {

                $result = $result[$key];

            }

        }

        if ($defaultValue) {

            return $result;

        }

        self::$nextdomConfiguration[$askedKey] = self::checkValueInConfiguration($askedKey, $result);

        return self::$nextdomConfiguration[$askedKey];

    }

    /**

     * @TODO: ???

     *

     * @param string $configKey

     * @param mixed $configValue

     * @return array|mixed|string

     * @throws \Exception

     */

    public static function checkValueInConfiguration($configKey, $configValue)

    {

        if (!is_array(self::$nextdomConfiguration)) {

            self::$nextdomConfiguration = [];

        }

        if (isset(self::$nextdomConfiguration[$configKey])) {

            return self::$nextdomConfiguration[$configKey];

        }

        if (is_array($configValue)) {

            foreach ($configValue as $key => $value) {

                $configValue[$key] = self::checkValueInConfiguration($configKey . ':' . $key, $value);

            }

            self::$nextdomConfiguration[$configKey] = $configValue;

            return $configValue;

        } else {

            $config = ConfigManager::byKey($configKey);

            return ($config == '') ? $configValue : $config;

        }

    }

    /**

     * Get Jeedom version

     *

     * @return string

     */

    public static function getJeedomVersion()

    {

        if (file_exists(NEXTDOM_DATA . '/config/Jeedom_version')) {

            return trim(file_get_contents(NEXTDOM_DATA . '/config/Jeedom_version'));

        }

        return '';

    }

    /**

     * Stop all cron tasks and scenarios

     * @param bool $isBackupProcess if true stop all except backup cron

     * @throws \Exception

     */

    public static function stopSystem($isBackupProcess)

    {

        // $okStr = __('common.ok');

        // echo __('core.disable-tasks');

        ConfigManager::save('enableCron', 0);

        foreach (CronManager::all() as $cron) {

            if($isBackupProcess && $cron->getClass() === SystemCron::NEXTDOM_BACKUP[0] && $cron->getFunction() === SystemCron::NEXTDOM_BACKUP[1] ){

                LogHelper::addInfo(LogTarget::MIGRATION, "Stopping all cron in backup context. Backup's cron won't be stop");

            } else if ($cron->running()) {

                try {

                    $cron->halt();

                } catch (\Exception $e) {

                    sleep(5);

                    $cron->halt();

                }

            }

        }

        // echo " $okStr\n";

        /*         * **********arrêt des crons********************* */

        if (CronManager::jeeCronRun()) {

            $pid = CronManager::getPidFile();

            SystemHelper::kill($pid);

        }

        /*         * *********Arrêt des scénarios**************** */

        ConfigManager::save('enableScenario', 0);

        foreach (ScenarioManager::all() as $scenario) {

            try {

                $scenario->stop();

            } catch (\Exception $e) {

                sleep(5);

                $scenario->stop();

            }

        }

        SystemHelper::stopService('cron');

    }

    /**

     * Task started minutes

     */

    public static function cron()

    {

        if (!self::isStarted()) {

            echo date(DateFormat::FULL) . ' starting NextDom';

            LogHelper::addDebug(LogTarget::STARTING, __('Démarrage de nextdom'));

            try {

                LogHelper::addDebug(LogTarget::STARTING, __('Arrêt des crons'));

                foreach (CronManager::all() as $cron) {

                    if ($cron->running() && $cron->getClass() != 'nextdom' && $cron->getFunction() != 'cron') {

                        try {

                            $cron->halt();

                        } catch (\Exception $e) {

                            LogHelper::addError(LogTarget::STARTING, __('Erreur sur l\'arrêt d\'une tâche cron : ') . LogHelper::exception($e));

                        }

                    }

                }

            } catch (\Exception $e) {

                LogHelper::addError(LogTarget::STARTING, __('Erreur sur l\'arrêt des tâches crons : ') . LogHelper::exception($e));

            }

            try {