class.module.php

Go to the documentation of this file.

<?php
/*
 * Copyright (c) 2021-2026 Bearsampp
 * License:  GNU General Public License version 3 or later; see LICENSE.txt
 * Author: Bear
 * Website: https://bearsampp.com
 * Github: https://github.com/Bearsampp
 */

abstract class Module
{
    private static $configCache = array();

    private $type;

    private $id;

    protected $name;

    protected $version;

    protected $release = 'N/A';

    public $rootPath;

    public $currentPath;

    public $symlinkPath;

    protected $enable;

    protected $bearsamppConf;

    protected $bearsamppConfRaw;

    protected function __construct()
    {
        // Initialization logic can be added here if needed
    }

    protected function reload($id = null, $type = null)
    {
        global $bearsamppRoot;
 
        $this->id   = empty($id) ? $this->id : $id;
        $this->type = empty($type) ? $this->type : $type;
        $mainPath   = 'N/A';
 
        switch ($this->type) {
            case Apps::TYPE:
                $mainPath = Path::getAppsPath();
                break;
            case Bins::TYPE:
                $mainPath = Path::getBinPath();
                break;
            case Tools::TYPE:
                $mainPath = Path::getToolsPath();
                break;
        }
 
        $this->rootPath      = $mainPath . '/' . $this->id;
        $this->currentPath   = $this->rootPath . '/' . $this->id . $this->version;
        $this->symlinkPath   = $this->rootPath . '/current';
        $this->enable        = is_dir($this->currentPath);
        $this->bearsamppConf = $this->currentPath . '/bearsampp.conf';
 
        $cacheKey = md5($this->bearsamppConf);
        if (!isset(self::$configCache[$cacheKey])) {
            // CacheManager handles both disk cache and parsing
            $data = CacheManager::load(
                $this->bearsamppConf,
                function ($path) {
                    return @parse_ini_file($path) ?: [];
                },
                $cacheKey
            );
 
            if (!empty($data)) {
                $this->bearsamppConfRaw       = $data;
                self::$configCache[$cacheKey] = $this->bearsamppConfRaw;
            } else {
                $this->bearsamppConfRaw = [];
                // Do not cache empty results in memory to allow retry on next reload
            }
        } else {
            $this->bearsamppConfRaw = self::$configCache[$cacheKey];
        }
 
        if (!Symlinks::isSkippingSymlinkCreation()) {
            Symlinks::createModuleSymlink($this);
        }
    }
 

    protected function replace($key, $value)
    {
        $this->replaceAll(array($key => $value));
    }

    protected function replaceAll($params)
    {
        $content = file_get_contents($this->bearsamppConf);
 
        foreach ($params as $key => $value) {
            // Same hardening as Config::replaceAll() - the key is used in a
            // regex pattern and the value in the INI content, so both must be
            // validated to prevent config poisoning.
            if (!is_string($key) || preg_match('/^[a-zA-Z0-9_-]+$/', $key) !== 1) {
                throw new RuntimeException('Invalid configuration key: ' . var_export($key, true));
            }
            $value = (string)$value;
            if (preg_match('/[\r\n"\x00-\x1F\x7F]/', $value) === 1) {
                throw new RuntimeException('Invalid configuration value for key: ' . $key);
            }
 
            $content                      = preg_replace('|' . preg_quote($key, '|') . ' = .*|', $key . ' = ' . '"' . $value . '"', $content);
            $this->bearsamppConfRaw[$key] = $value;
        }
 
        file_put_contents($this->bearsamppConf, $content);
 
        // Invalidate both memory cache and disk cache
        self::invalidateConfigCacheForPath($this->bearsamppConf);
    }

    public static function invalidateConfigCacheForPath($sourcePath)
    {
        $cacheKey = md5($sourcePath);
        unset(self::$configCache[$cacheKey]);
        CacheManager::invalidate($sourcePath);
    }

    public static function clearMemoryCache()
    {
        self::$configCache = array();
    }

    public function update($sub = 0, $showWindow = false)
    {
        $this->updateConfig(null, $sub, $showWindow);
    }

    protected function updateConfig($version = null, $sub = 0, $showWindow = false)
    {
        $version = $version == null ? $this->version : $version;
        Log::debug(($sub > 0 ? str_repeat(' ', 2 * $sub) : '') . 'Update ' . $this->name . ' ' . $version . ' config');
    }

    public function __toString()
    {
        return $this->getName();
    }

    public function getType()
    {
        return $this->type;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }

    public function getVersion()
    {
        return $this->version;
    }

    public function getVersionList()
    {
        return Util::getVersionList($this->rootPath);
    }

    abstract public function setVersion($version);

    public function getRelease()
    {
        return $this->release;
    }
 

    public function isEnable()
    {
        return $this->enable;
    }
 
}