src/Util/ConfigFileLoader.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2021, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Util;
  23
  24 use Exception;
  25 use Friendica\Core\Addon;
  26 use Friendica\Core\Config\Cache;
  27
  28 /**
  29  * The ConfigFileLoader loads config-files and stores them in a ConfigCache ( @see Cache )
  30  *
  31  * It is capable of loading the following config files:
  32  * - *.config.php   (current)
  33  * - *.ini.php      (deprecated)
  34  * - *.htconfig.php (deprecated)
  35  */
  36 class ConfigFileLoader
  37 {
  38         /**
  39          * The default name of the user defined ini file
  40          *
  41          * @var string
  42          */
  43         const CONFIG_INI = 'local';
  44
  45         /**
  46          * The default name of the user defined legacy config file
  47          *
  48          * @var string
  49          */
  50         const CONFIG_HTCONFIG = 'htconfig';
  51
  52         /**
  53          * The sample string inside the configs, which shouldn't get loaded
  54          *
  55          * @var string
  56          */
  57         const SAMPLE_END = '-sample';
  58
  59         /**
  60          * @var string
  61          */
  62         private $baseDir;
  63         /**
  64          * @var string
  65          */
  66         private $configDir;
  67         /**
  68          * @var string
  69          */
  70         private $staticDir;
  71
  72         /**
  73          * @param string $baseDir   The base
  74          * @param string $configDir
  75          * @param string $staticDir
  76          */
  77         public function __construct(string $baseDir, string $configDir, string $staticDir)
  78         {
  79                 $this->baseDir   = $baseDir;
  80                 $this->configDir = $configDir;
  81                 $this->staticDir = $staticDir;
  82         }
  83
  84         /**
  85          * Load the configuration files into an configuration cache
  86          *
  87          * First loads the default value for all the configuration keys, then the legacy configuration files, then the
  88          * expected local.config.php
  89          *
  90          * @param Cache $config The config cache to load to
  91          * @param array $server The $_SERVER array
  92          * @param bool  $raw    Setup the raw config format
  93          *
  94          * @throws Exception
  95          */
  96         public function setupCache(Cache $config, array $server = [], bool $raw = false)
  97         {
  98                 // Load static config files first, the order is important
  99                 $config->load($this->loadStaticConfig('defaults'), Cache::SOURCE_FILE);
 100                 $config->load($this->loadStaticConfig('settings'), Cache::SOURCE_FILE);
 101
 102                 // try to load the legacy config first
 103                 $config->load($this->loadLegacyConfig('htpreconfig'), Cache::SOURCE_FILE);
 104                 $config->load($this->loadLegacyConfig('htconfig'), Cache::SOURCE_FILE);
 105
 106                 // Now load every other config you find inside the 'config/' directory
 107                 $this->loadCoreConfig($config);
 108
 109                 $config->load($this->loadEnvConfig($server), Cache::SOURCE_ENV);
 110
 111                 // In case of install mode, add the found basepath (because there isn't a basepath set yet
 112                 if (!$raw && empty($config->get('system', 'basepath'))) {
 113                         // Setting at least the basepath we know
 114                         $config->set('system', 'basepath', $this->baseDir, Cache::SOURCE_FILE);
 115                 }
 116         }
 117
 118         /**
 119          * Tries to load the static core-configuration and returns the config array.
 120          *
 121          * @param string $name The name of the configuration
 122          *
 123          * @return array The config array (empty if no config found)
 124          *
 125          * @throws Exception if the configuration file isn't readable
 126          */
 127         private function loadStaticConfig($name)
 128         {
 129                 $configName = $this->staticDir . DIRECTORY_SEPARATOR . $name . '.config.php';
 130                 $iniName    = $this->staticDir . DIRECTORY_SEPARATOR . $name . '.ini.php';
 131
 132                 if (file_exists($configName)) {
 133                         return $this->loadConfigFile($configName);
 134                 } elseif (file_exists($iniName)) {
 135                         return $this->loadINIConfigFile($iniName);
 136                 } else {
 137                         return [];
 138                 }
 139         }
 140
 141         /**
 142          * Tries to load the specified core-configuration into the config cache.
 143          *
 144          * @param Cache $config The Config cache
 145          *
 146          * @return array The config array (empty if no config found)
 147          *
 148          * @throws Exception if the configuration file isn't readable
 149          */
 150         private function loadCoreConfig(Cache $config)
 151         {
 152                 // try to load legacy ini-files first
 153                 foreach ($this->getConfigFiles(true) as $configFile) {
 154                         $config->load($this->loadINIConfigFile($configFile), Cache::SOURCE_FILE);
 155                 }
 156
 157                 // try to load supported config at last to overwrite it
 158                 foreach ($this->getConfigFiles() as $configFile) {
 159                         $config->load($this->loadConfigFile($configFile), Cache::SOURCE_FILE);
 160                 }
 161
 162                 return [];
 163         }
 164
 165         /**
 166          * Tries to load the specified addon-configuration and returns the config array.
 167          *
 168          * @param string $name The name of the configuration
 169          *
 170          * @return array The config array (empty if no config found)
 171          *
 172          * @throws Exception if the configuration file isn't readable
 173          */
 174         public function loadAddonConfig($name)
 175         {
 176                 $filepath = $this->baseDir . DIRECTORY_SEPARATOR .   // /var/www/html/
 177                             Addon::DIRECTORY . DIRECTORY_SEPARATOR . // addon/
 178                             $name . DIRECTORY_SEPARATOR .            // openstreetmap/
 179                             'config'. DIRECTORY_SEPARATOR .              // config/
 180                             $name . ".config.php";                   // openstreetmap.config.php
 181
 182                 if (file_exists($filepath)) {
 183                         return $this->loadConfigFile($filepath);
 184                 } else {
 185                         return [];
 186                 }
 187         }
 188
 189         /**
 190          * Tries to load environment specific variables, based on the `env.config.php` mapping table
 191          *
 192          * @param array $server The $_SERVER variable
 193          *
 194          * @return array The config array (empty if no config was found)
 195          *
 196          * @throws Exception if the configuration file isn't readable
 197          */
 198         public function loadEnvConfig(array $server)
 199         {
 200                 $filepath = $this->staticDir . DIRECTORY_SEPARATOR .   // /var/www/html/static/
 201                                         "env.config.php";                          // env.config.php
 202
 203                 if (!file_exists($filepath)) {
 204                         return [];
 205                 }
 206
 207                 $envConfig = $this->loadConfigFile($filepath);
 208
 209                 $return = [];
 210
 211                 foreach ($envConfig as $envKey => $configStructure) {
 212                         if (isset($server[$envKey])) {
 213                                 $return[$configStructure[0]][$configStructure[1]] = $server[$envKey];
 214                         }
 215                 }
 216
 217                 return $return;
 218         }
 219
 220         /**
 221          * Get the config files of the config-directory
 222          *
 223          * @param bool $ini True, if scan for ini-files instead of config files
 224          *
 225          * @return array
 226          */
 227         private function getConfigFiles(bool $ini = false)
 228         {
 229                 $files = scandir($this->configDir);
 230                 $found = array();
 231
 232                 $filePattern = ($ini ? '*.ini.php' : '*.config.php');
 233
 234                 // Don't load sample files
 235                 $sampleEnd = self::SAMPLE_END . ($ini ? '.ini.php' : '.config.php');
 236
 237                 foreach ($files as $filename) {
 238                         if (fnmatch($filePattern, $filename) && substr_compare($filename, $sampleEnd, -strlen($sampleEnd))) {
 239                                 $found[] = $this->configDir . '/' . $filename;
 240                         }
 241                 }
 242
 243                 return $found;
 244         }
 245
 246         /**
 247          * Tries to load the legacy config files (.htconfig.php, .htpreconfig.php) and returns the config array.
 248          *
 249          * @param string $name The name of the config file (default is empty, which means .htconfig.php)
 250          *
 251          * @return array The configuration array (empty if no config found)
 252          *
 253          * @deprecated since version 2018.09
 254          */
 255         private function loadLegacyConfig($name = '')
 256         {
 257                 $name     = !empty($name) ? $name : self::CONFIG_HTCONFIG;
 258                 $fullName = $this->baseDir . DIRECTORY_SEPARATOR . '.' . $name . '.php';
 259
 260                 $config = [];
 261                 if (file_exists($fullName)) {
 262                         $a         = new \stdClass();
 263                         $a->config = [];
 264                         include $fullName;
 265
 266                         $htConfigCategories = array_keys($a->config);
 267
 268                         // map the legacy configuration structure to the current structure
 269                         foreach ($htConfigCategories as $htConfigCategory) {
 270                                 if (is_array($a->config[$htConfigCategory])) {
 271                                         $keys = array_keys($a->config[$htConfigCategory]);
 272
 273                                         foreach ($keys as $key) {
 274                                                 $config[$htConfigCategory][$key] = $a->config[$htConfigCategory][$key];
 275                                         }
 276                                 } else {
 277                                         $config['config'][$htConfigCategory] = $a->config[$htConfigCategory];
 278                                 }
 279                         }
 280
 281                         unset($a);
 282
 283                         if (isset($db_host)) {
 284                                 $config['database']['hostname'] = $db_host;
 285                                 unset($db_host);
 286                         }
 287                         if (isset($db_user)) {
 288                                 $config['database']['username'] = $db_user;
 289                                 unset($db_user);
 290                         }
 291                         if (isset($db_pass)) {
 292                                 $config['database']['password'] = $db_pass;
 293                                 unset($db_pass);
 294                         }
 295                         if (isset($db_data)) {
 296                                 $config['database']['database'] = $db_data;
 297                                 unset($db_data);
 298                         }
 299                         if (isset($config['system']['db_charset'])) {
 300                                 $config['database']['charset'] = $config['system']['db_charset'];
 301                         }
 302                         if (isset($pidfile)) {
 303                                 $config['system']['pidfile'] = $pidfile;
 304                                 unset($pidfile);
 305                         }
 306                         if (isset($default_timezone)) {
 307                                 $config['system']['default_timezone'] = $default_timezone;
 308                                 unset($default_timezone);
 309                         }
 310                         if (isset($lang)) {
 311                                 $config['system']['language'] = $lang;
 312                                 unset($lang);
 313                         }
 314                 }
 315
 316                 return $config;
 317         }
 318
 319         /**
 320          * Tries to load the specified legacy configuration file and returns the config array.
 321          *
 322          * @param string $filepath
 323          *
 324          * @return array The configuration array
 325          * @throws Exception
 326          * @deprecated since version 2018.12
 327          */
 328         private function loadINIConfigFile($filepath)
 329         {
 330                 $contents = include($filepath);
 331
 332                 $config = parse_ini_string($contents, true, INI_SCANNER_TYPED);
 333
 334                 if ($config === false) {
 335                         throw new Exception('Error parsing INI config file ' . $filepath);
 336                 }
 337
 338                 return $config;
 339         }
 340
 341         /**
 342          * Tries to load the specified configuration file and returns the config array.
 343          *
 344          * The config format is PHP array and the template for configuration files is the following:
 345          *
 346          * <?php return [
 347          *      'section' => [
 348          *          'key' => 'value',
 349          *      ],
 350          * ];
 351          *
 352          * @param string $filepath The filepath of the
 353          *
 354          * @return array The config array0
 355          *
 356          * @throws Exception if the config cannot get loaded.
 357          */
 358         private function loadConfigFile($filepath)
 359         {
 360                 $config = include($filepath);
 361
 362                 if (!is_array($config)) {
 363                         throw new Exception('Error loading config file ' . $filepath);
 364                 }
 365
 366                 return $config;
 367         }
 368 }