application/config/ConfigManager.php

   1 <?php
   2
   3 // FIXME! Namespaces...
   4 require_once 'ConfigIO.php';
   5 require_once 'ConfigJson.php';
   6 require_once 'ConfigPhp.php';
   7
   8 /**
   9  * Class ConfigManager
  10  *
  11  * Manages all Shaarli's settings.
  12  * See the documentation for more information on settings:
  13  *   - doc/Shaarli-configuration.html
  14  *   - https://github.com/shaarli/Shaarli/wiki/Shaarli-configuration
  15  */
  16 class ConfigManager
  17 {
  18     /**
  19      * @var string Flag telling a setting is not found.
  20      */
  21     protected static $NOT_FOUND = 'NOT_FOUND';
  22
  23     /**
  24      * @var string Config folder.
  25      */
  26     protected $configFile;
  27
  28     /**
  29      * @var array Loaded config array.
  30      */
  31     protected $loadedConfig;
  32
  33     /**
  34      * @var ConfigIO implementation instance.
  35      */
  36     protected $configIO;
  37
  38     /**
  39      * Constructor.
  40      */
  41     public function __construct($configFile = 'data/config')
  42     {
  43         $this->configFile = $configFile;
  44         $this->initialize();
  45     }
  46
  47     /**
  48      * Reset the ConfigManager instance.
  49      */
  50     public function reset()
  51     {
  52         $this->initialize();
  53     }
  54
  55     /**
  56      * Rebuild the loaded config array from config files.
  57      */
  58     public function reload()
  59     {
  60         $this->load();
  61     }
  62
  63     /**
  64      * Initialize the ConfigIO and loaded the conf.
  65      */
  66     protected function initialize()
  67     {
  68         if (file_exists($this->configFile . '.php')) {
  69             $this->configIO = new ConfigPhp();
  70         } else {
  71             $this->configIO = new ConfigJson();
  72         }
  73         $this->load();
  74     }
  75
  76     /**
  77      * Load configuration in the ConfigurationManager.
  78      */
  79     protected function load()
  80     {
  81         $this->loadedConfig = $this->configIO->read($this->getConfigFileExt());
  82         $this->setDefaultValues();
  83     }
  84
  85     /**
  86      * Get a setting.
  87      *
  88      * Supports nested settings with dot separated keys.
  89      * Eg. 'config.stuff.option' will find $conf[config][stuff][option],
  90      * or in JSON:
  91      *   { "config": { "stuff": {"option": "mysetting" } } } }
  92      *
  93      * @param string $setting Asked setting, keys separated with dots.
  94      * @param string $default Default value if not found.
  95      *
  96      * @return mixed Found setting, or the default value.
  97      */
  98     public function get($setting, $default = '')
  99     {
 100         // During the ConfigIO transition, map legacy settings to the new ones.
 101         if ($this->configIO instanceof ConfigPhp && isset(ConfigPhp::$LEGACY_KEYS_MAPPING[$setting])) {
 102             $setting = ConfigPhp::$LEGACY_KEYS_MAPPING[$setting];
 103         }
 104
 105         $settings = explode('.', $setting);
 106         $value = self::getConfig($settings, $this->loadedConfig);
 107         if ($value === self::$NOT_FOUND) {
 108             return $default;
 109         }
 110         return $value;
 111     }
 112
 113     /**
 114      * Set a setting, and eventually write it.
 115      *
 116      * Supports nested settings with dot separated keys.
 117      *
 118      * @param string $setting    Asked setting, keys separated with dots.
 119      * @param string $value      Value to set.
 120      * @param bool   $write      Write the new setting in the config file, default false.
 121      * @param bool   $isLoggedIn User login state, default false.
 122      *
 123      * @throws Exception Invalid
 124      */
 125     public function set($setting, $value, $write = false, $isLoggedIn = false)
 126     {
 127         if (empty($setting) || ! is_string($setting)) {
 128             throw new Exception('Invalid setting key parameter. String expected, got: '. gettype($setting));
 129         }
 130
 131         // During the ConfigIO transition, map legacy settings to the new ones.
 132         if ($this->configIO instanceof ConfigPhp && isset(ConfigPhp::$LEGACY_KEYS_MAPPING[$setting])) {
 133             $setting = ConfigPhp::$LEGACY_KEYS_MAPPING[$setting];
 134         }
 135
 136         $settings = explode('.', $setting);
 137         self::setConfig($settings, $value, $this->loadedConfig);
 138         if ($write) {
 139             $this->write($isLoggedIn);
 140         }
 141     }
 142
 143     /**
 144      * Check if a settings exists.
 145      *
 146      * Supports nested settings with dot separated keys.
 147      *
 148      * @param string $setting    Asked setting, keys separated with dots.
 149      *
 150      * @return bool true if the setting exists, false otherwise.
 151      */
 152     public function exists($setting)
 153     {
 154         // During the ConfigIO transition, map legacy settings to the new ones.
 155         if ($this->configIO instanceof ConfigPhp && isset(ConfigPhp::$LEGACY_KEYS_MAPPING[$setting])) {
 156             $setting = ConfigPhp::$LEGACY_KEYS_MAPPING[$setting];
 157         }
 158
 159         $settings = explode('.', $setting);
 160         $value = self::getConfig($settings, $this->loadedConfig);
 161         if ($value === self::$NOT_FOUND) {
 162             return false;
 163         }
 164         return true;
 165     }
 166
 167     /**
 168      * Call the config writer.
 169      *
 170      * @param bool $isLoggedIn User login state.
 171      *
 172      * @return bool True if the configuration has been successfully written, false otherwise.
 173      *
 174      * @throws MissingFieldConfigException: a mandatory field has not been provided in $conf.
 175      * @throws UnauthorizedConfigException: user is not authorize to change configuration.
 176      * @throws IOException: an error occurred while writing the new config file.
 177      */
 178     public function write($isLoggedIn)
 179     {
 180         // These fields are required in configuration.
 181         $mandatoryFields = array(
 182             'credentials.login',
 183             'credentials.hash',
 184             'credentials.salt',
 185             'security.session_protection_disabled',
 186             'general.timezone',
 187             'general.title',
 188             'general.header_link',
 189             'privacy.default_private_links',
 190             'redirector.url',
 191         );
 192
 193         // Only logged in user can alter config.
 194         if (is_file($this->getConfigFileExt()) && !$isLoggedIn) {
 195             throw new UnauthorizedConfigException();
 196         }
 197
 198         // Check that all mandatory fields are provided in $conf.
 199         foreach ($mandatoryFields as $field) {
 200             if (! $this->exists($field)) {
 201                 throw new MissingFieldConfigException($field);
 202             }
 203         }
 204
 205         return $this->configIO->write($this->getConfigFileExt(), $this->loadedConfig);
 206     }
 207
 208     /**
 209      * Set the config file path (without extension).
 210      *
 211      * @param string $configFile File path.
 212      */
 213     public function setConfigFile($configFile)
 214     {
 215         $this->configFile = $configFile;
 216     }
 217
 218     /**
 219      * Return the configuration file path (without extension).
 220      *
 221      * @return string Config path.
 222      */
 223     public function getConfigFile()
 224     {
 225         return $this->configFile;
 226     }
 227
 228     /**
 229      * Get the configuration file path with its extension.
 230      *
 231      * @return string Config file path.
 232      */
 233     public function getConfigFileExt()
 234     {
 235         return $this->configFile . $this->configIO->getExtension();
 236     }
 237
 238     /**
 239      * Recursive function which find asked setting in the loaded config.
 240      *
 241      * @param array $settings Ordered array which contains keys to find.
 242      * @param array $conf   Loaded settings, then sub-array.
 243      *
 244      * @return mixed Found setting or NOT_FOUND flag.
 245      */
 246     protected static function getConfig($settings, $conf)
 247     {
 248         if (!is_array($settings) || count($settings) == 0) {
 249             return self::$NOT_FOUND;
 250         }
 251
 252         $setting = array_shift($settings);
 253         if (!isset($conf[$setting])) {
 254             return self::$NOT_FOUND;
 255         }
 256
 257         if (count($settings) > 0) {
 258             return self::getConfig($settings, $conf[$setting]);
 259         }
 260         return $conf[$setting];
 261     }
 262
 263     /**
 264      * Recursive function which find asked setting in the loaded config.
 265      *
 266      * @param array $settings Ordered array which contains keys to find.
 267      * @param mixed $value
 268      * @param array $conf   Loaded settings, then sub-array.
 269      *
 270      * @return mixed Found setting or NOT_FOUND flag.
 271      */
 272     protected static function setConfig($settings, $value, &$conf)
 273     {
 274         if (!is_array($settings) || count($settings) == 0) {
 275             return self::$NOT_FOUND;
 276         }
 277
 278         $setting = array_shift($settings);
 279         if (count($settings) > 0) {
 280             return self::setConfig($settings, $value, $conf[$setting]);
 281         }
 282         $conf[$setting] = $value;
 283     }
 284
 285     /**
 286      * Set a bunch of default values allowing Shaarli to start without a config file.
 287      */
 288     protected function setDefaultValues()
 289     {
 290         $this->setEmpty('resource.data_dir', 'data');
 291         $this->setEmpty('resource.config', 'data/config.php');
 292         $this->setEmpty('resource.datastore', 'data/datastore.php');
 293         $this->setEmpty('resource.ban_file', 'data/ipbans.php');
 294         $this->setEmpty('resource.updates', 'data/updates.txt');
 295         $this->setEmpty('resource.log', 'data/log.txt');
 296         $this->setEmpty('resource.update_check', 'data/lastupdatecheck.txt');
 297         $this->setEmpty('resource.raintpl_tpl', 'tpl/');
 298         $this->setEmpty('resource.raintpl_tmp', 'tmp/');
 299         $this->setEmpty('resource.thumbnails_cache', 'cache');
 300         $this->setEmpty('resource.page_cache', 'pagecache');
 301
 302         $this->setEmpty('security.ban_after', 4);
 303         $this->setEmpty('security.ban_duration', 1800);
 304         $this->setEmpty('security.session_protection_disabled', false);
 305         $this->setEmpty('security.open_shaarli', false);
 306
 307         $this->setEmpty('general.header_link', '?');
 308         $this->setEmpty('general.links_per_page', 20);
 309         $this->setEmpty('general.enabled_plugins', array('qrcode'));
 310
 311         $this->setEmpty('updates.check_updates', false);
 312         $this->setEmpty('updates.check_updates_branch', 'stable');
 313         $this->setEmpty('updates.check_updates_interval', 86400);
 314
 315         $this->setEmpty('feed.rss_permalinks', true);
 316         $this->setEmpty('feed.show_atom', false);
 317
 318         $this->setEmpty('privacy.default_private_links', false);
 319         $this->setEmpty('privacy.hide_public_links', false);
 320         $this->setEmpty('privacy.hide_timestamps', false);
 321
 322         $this->setEmpty('thumbnail.enable_thumbnails', true);
 323         $this->setEmpty('thumbnail.enable_localcache', true);
 324
 325         $this->setEmpty('redirector.url', '');
 326         $this->setEmpty('redirector.encode_url', true);
 327
 328         $this->setEmpty('plugins', array());
 329     }
 330
 331     /**
 332      * Set only if the setting does not exists.
 333      *
 334      * @param string $key   Setting key.
 335      * @param mixed  $value Setting value.
 336      */
 337     public function setEmpty($key, $value)
 338     {
 339         if (! $this->exists($key)) {
 340             $this->set($key, $value);
 341         }
 342     }
 343
 344     /**
 345      * @return ConfigIO
 346      */
 347     public function getConfigIO()
 348     {
 349         return $this->configIO;
 350     }
 351
 352     /**
 353      * @param ConfigIO $configIO
 354      */
 355     public function setConfigIO($configIO)
 356     {
 357         $this->configIO = $configIO;
 358     }
 359 }
 360
 361 /**
 362  * Exception used if a mandatory field is missing in given configuration.
 363  */
 364 class MissingFieldConfigException extends Exception
 365 {
 366     public $field;
 367
 368     /**
 369      * Construct exception.
 370      *
 371      * @param string $field field name missing.
 372      */
 373     public function __construct($field)
 374     {
 375         $this->field = $field;
 376         $this->message = 'Configuration value is required for '. $this->field;
 377     }
 378 }
 379
 380 /**
 381  * Exception used if an unauthorized attempt to edit configuration has been made.
 382  */
 383 class UnauthorizedConfigException extends Exception
 384 {
 385     /**
 386      * Construct exception.
 387      */
 388     public function __construct()
 389     {
 390         $this->message = 'You are not authorized to alter config.';
 391     }
 392 }