src/Core/Config/ValueObject/Cache.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\Core\Config\ValueObject;
  23
  24 use Friendica\Core\Config\Util\ConfigFileLoader;
  25 use ParagonIE\HiddenString\HiddenString;
  26
  27 /**
  28  * The Friendica config cache for the application
  29  * Initial, all *.config.php files are loaded into this cache with the
  30  * ConfigFileLoader ( @see ConfigFileLoader )
  31  */
  32 class Cache
  33 {
  34         /** @var int Indicates that the cache entry is a default value - Lowest Priority */
  35         const SOURCE_STATIC = 0;
  36         /** @var int Indicates that the cache entry is set by file - Low Priority */
  37         const SOURCE_FILE = 1;
  38         /** @var int Indicates that the cache entry is set by the DB config table - Middle Priority */
  39         const SOURCE_DB = 2;
  40         /** @var int Indicates that the cache entry is set by a server environment variable - High Priority */
  41         const SOURCE_ENV = 3;
  42         /** @var int Indicates that the cache entry is fixed and must not be changed */
  43         const SOURCE_FIX = 5;
  44
  45         /** @var int Default value for a config source */
  46         const SOURCE_DEFAULT = self::SOURCE_FILE;
  47
  48         /**
  49          * @var array
  50          */
  51         private $config = [];
  52
  53         /**
  54          * @var int[][]
  55          */
  56         private $source = [];
  57
  58         /**
  59          * @var bool
  60          */
  61         private $hidePasswordOutput;
  62
  63         /**
  64          * @param array $config             A initial config array
  65          * @param bool  $hidePasswordOutput True, if cache variables should take extra care of password values
  66          * @param int   $source             Sets a source of the initial config values
  67          */
  68         public function __construct(array $config = [], bool $hidePasswordOutput = true, $source = self::SOURCE_DEFAULT)
  69         {
  70                 $this->hidePasswordOutput = $hidePasswordOutput;
  71                 $this->load($config, $source);
  72         }
  73
  74         /**
  75          * Tries to load the specified configuration array into the config array.
  76          * Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
  77          *
  78          * @param array $config
  79          * @param int   $source Indicates the source of the config entry
  80          */
  81         public function load(array $config, int $source = self::SOURCE_DEFAULT)
  82         {
  83                 $categories = array_keys($config);
  84
  85                 foreach ($categories as $category) {
  86                         if (is_array($config[$category])) {
  87                                 $keys = array_keys($config[$category]);
  88
  89                                 foreach ($keys as $key) {
  90                                         $value = $config[$category][$key];
  91                                         if (isset($value)) {
  92                                                 $this->set($category, $key, $value, $source);
  93                                         }
  94                                 }
  95                         }
  96                 }
  97         }
  98
  99         /**
 100          * Gets a value from the config cache.
 101          *
 102          * @param string      $cat Config category
 103          * @param string|null $key Config key
 104          *
 105          * @return null|mixed Returns the value of the Config entry or null if not set
 106          */
 107         public function get(string $cat, ?string $key = null)
 108         {
 109                 if (isset($this->config[$cat][$key])) {
 110                         return $this->config[$cat][$key];
 111                 } elseif (!isset($key) && isset($this->config[$cat])) {
 112                         return $this->config[$cat];
 113                 } else {
 114                         return null;
 115                 }
 116         }
 117
 118         /**
 119          * Returns the source value of the current, cached config value
 120          *
 121          * @param string $cat Config category
 122          * @param string $key Config key
 123          *
 124          * @return int
 125          */
 126         public function getSource(string $cat, string $key): int
 127         {
 128                 return $this->source[$cat][$key] ?? -1;
 129         }
 130
 131         /**
 132          * Sets a value in the config cache. Accepts raw output from the config table
 133          *
 134          * @param string $cat    Config category
 135          * @param string $key    Config key
 136          * @param mixed  $value  Value to set
 137          * @param int    $source The source of the current config key
 138          *
 139          * @return bool True, if the value is set
 140          */
 141         public function set(string $cat, string $key, $value, int $source = self::SOURCE_DEFAULT): bool
 142         {
 143                 if (!isset($this->config[$cat])) {
 144                         $this->config[$cat] = [];
 145                         $this->source[$cat] = [];
 146                 }
 147
 148                 if (isset($this->source[$cat][$key]) &&
 149                         $source < $this->source[$cat][$key]) {
 150                         return false;
 151                 }
 152
 153                 if ($this->hidePasswordOutput &&
 154                         $key == 'password' &&
 155                         is_string($value)) {
 156                         $this->config[$cat][$key] = new HiddenString((string)$value);
 157                 } else {
 158                         $this->config[$cat][$key] = $value;
 159                 }
 160
 161                 $this->source[$cat][$key] = $source;
 162
 163                 return true;
 164         }
 165
 166         /**
 167          * Deletes a value from the config cache.
 168          *
 169          * @param string $cat Config category
 170          * @param string $key Config key
 171          *
 172          * @return bool true, if deleted
 173          */
 174         public function delete(string $cat, string $key): bool
 175         {
 176                 if (isset($this->config[$cat][$key])) {
 177                         unset($this->config[$cat][$key]);
 178                         unset($this->source[$cat][$key]);
 179                         if (count($this->config[$cat]) == 0) {
 180                                 unset($this->config[$cat]);
 181                                 unset($this->source[$cat]);
 182                         }
 183                         return true;
 184                 } else {
 185                         return false;
 186                 }
 187         }
 188
 189         /**
 190          * Returns the whole configuration
 191          *
 192          * @return string[][] The configuration
 193          */
 194         public function getAll(): array
 195         {
 196                 return $this->config;
 197         }
 198
 199         /**
 200          * Returns an array with missing categories/Keys
 201          *
 202          * @param string[][] $config The array to check
 203          *
 204          * @return string[][]
 205          */
 206         public function keyDiff(array $config): array
 207         {
 208                 $return = [];
 209
 210                 $categories = array_keys($config);
 211
 212                 foreach ($categories as $category) {
 213                         if (is_array($config[$category])) {
 214                                 $keys = array_keys($config[$category]);
 215
 216                                 foreach ($keys as $key) {
 217                                         if (!isset($this->config[$category][$key])) {
 218                                                 $return[$category][$key] = $config[$category][$key];
 219                                         }
 220                                 }
 221                         }
 222                 }
 223
 224                 return $return;
 225         }
 226 }