Friendica/friendica-github
1
0
Fork 0
mirror of https://github.com/friendica/friendica synced 2024-12-31 21:22:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

3) Introducing ConfigFactory

Browse source
This commit is contained in:
Philipp Holzer 2019-02-03 22:22:04 +01:00
parent 5c50684b50
commit 4af0119b73
No known key found for this signature in database
GPG key ID: 517BE60E2CE5C8A5
23 changed files with 843 additions and 632 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
boot.php
View file

@ -19,18 +19,12 @@
use Friendica\App; use Friendica\App;
use Friendica\BaseObject; use Friendica\BaseObject;
use Friendica\Core\Addon;
use Friendica\Core\Cache;
use Friendica\Core\Config; use Friendica\Core\Config;
use Friendica\Core\L10n;
use Friendica\Core\PConfig; use Friendica\Core\PConfig;
use Friendica\Core\Protocol; use Friendica\Core\Protocol;
use Friendica\Core\System;
use Friendica\Core\Update;
use Friendica\Core\Worker;
use Friendica\Database\DBA; use Friendica\Database\DBA;
use Friendica\Model\Contact; use Friendica\Model\Contact;
use Friendica\Model\Conversation; use Friendica\Util\BasePath;
use Friendica\Util\DateTimeFormat; use Friendica\Util\DateTimeFormat;
define('FRIENDICA_PLATFORM', 'Friendica'); define('FRIENDICA_PLATFORM', 'Friendica');
@ -642,7 +636,7 @@ function get_temppath()
if (($temppath != "") && App::isDirectoryUsable($temppath)) { if (($temppath != "") && App::isDirectoryUsable($temppath)) {
// We have a temp path and it is usable // We have a temp path and it is usable
return App::getRealPath($temppath); return BasePath::getRealPath($temppath);
} }
// We don't have a working preconfigured temp path, so we take the system path. // We don't have a working preconfigured temp path, so we take the system path.
@ -651,7 +645,7 @@ function get_temppath()
// Check if it is usable // Check if it is usable
if (($temppath != "") && App::isDirectoryUsable($temppath)) { if (($temppath != "") && App::isDirectoryUsable($temppath)) {
// Always store the real path, not the path through symlinks // Always store the real path, not the path through symlinks
$temppath = App::getRealPath($temppath); $temppath = BasePath::getRealPath($temppath);
// To avoid any interferences with other systems we create our own directory // To avoid any interferences with other systems we create our own directory
$new_temppath = $temppath . "/" . $a->getHostName(); $new_temppath = $temppath . "/" . $a->getHostName();
@ -743,7 +737,7 @@ function get_itemcachepath()
$itemcache = Config::get('system', 'itemcache'); $itemcache = Config::get('system', 'itemcache');
if (($itemcache != "") && App::isDirectoryUsable($itemcache)) { if (($itemcache != "") && App::isDirectoryUsable($itemcache)) {
return App::getRealPath($itemcache); return BasePath::getRealPath($itemcache);
} }
$temppath = get_temppath(); $temppath = get_temppath();

11
index.php
View file

@ -5,7 +5,9 @@
*/ */
use Friendica\App; use Friendica\App;
use Friendica\Util\LoggerFactory; use Friendica\Core\Config;
use Friendica\Factory;
use Friendica\Util\BasePath;
if (!file_exists(__DIR__ . '/vendor/autoload.php')) { if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
die('Vendor path not found. Please execute "bin/composer.phar --no-dev install" on the command line in the web root.'); die('Vendor path not found. Please execute "bin/composer.phar --no-dev install" on the command line in the web root.');
@ -13,10 +15,13 @@ if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
require __DIR__ . '/vendor/autoload.php'; require __DIR__ . '/vendor/autoload.php';
$logger = LoggerFactory::create('index'); $basedir = BasePath::create(__DIR__);
$configLoader = new Config\ConfigCacheLoader($basedir);
$config = Factory\ConfigFactory::createCache($configLoader);
$logger = Factory\LoggerFactory::create('index', $config);
// We assume that the index.php is called by a frontend process // We assume that the index.php is called by a frontend process
// The value is set to "true" by default in App // The value is set to "true" by default in App
$a = new App(__DIR__, $logger, false); $a = new App($config, $logger, false);
$a->runFrontend(); $a->runFrontend();

9
mod/admin.php
View file

@ -15,11 +15,11 @@ use Friendica\Core\Config;
use Friendica\Core\L10n; use Friendica\Core\L10n;
use Friendica\Core\Logger; use Friendica\Core\Logger;
use Friendica\Core\Renderer; use Friendica\Core\Renderer;
use Friendica\Core\StorageManager;
use Friendica\Core\System; use Friendica\Core\System;
use Friendica\Core\Theme; use Friendica\Core\Theme;
use Friendica\Core\Update; use Friendica\Core\Update;
use Friendica\Core\Worker; use Friendica\Core\Worker;
use Friendica\Core\StorageManager;
use Friendica\Database\DBA; use Friendica\Database\DBA;
use Friendica\Database\DBStructure; use Friendica\Database\DBStructure;
use Friendica\Model\Contact; use Friendica\Model\Contact;
@ -30,6 +30,7 @@ use Friendica\Module;
use Friendica\Module\Login; use Friendica\Module\Login;
use Friendica\Module\Tos; use Friendica\Module\Tos;
use Friendica\Util\Arrays; use Friendica\Util\Arrays;
use Friendica\Util\BasePath;
use Friendica\Util\DateTimeFormat; use Friendica\Util\DateTimeFormat;
use Friendica\Util\Network; use Friendica\Util\Network;
use Friendica\Util\Strings; use Friendica\Util\Strings;
@ -1375,7 +1376,7 @@ function admin_page_site_post(App $a)
Config::set('system', 'dbclean-expire-unclaimed', $dbclean_unclaimed); Config::set('system', 'dbclean-expire-unclaimed', $dbclean_unclaimed);
if ($itemcache != '') { if ($itemcache != '') {
$itemcache = App::getRealPath($itemcache); $itemcache = BasePath::getRealPath($itemcache);
} }
Config::set('system', 'itemcache', $itemcache); Config::set('system', 'itemcache', $itemcache);
@ -1383,13 +1384,13 @@ function admin_page_site_post(App $a)
Config::set('system', 'max_comments', $max_comments); Config::set('system', 'max_comments', $max_comments);
if ($temppath != '') { if ($temppath != '') {
$temppath = App::getRealPath($temppath); $temppath = BasePath::getRealPath($temppath);
} }
Config::set('system', 'temppath', $temppath); Config::set('system', 'temppath', $temppath);
if ($basepath != '') { if ($basepath != '') {
$basepath = App::getRealPath($basepath); $basepath = BasePath::getRealPath($basepath);
} }
Config::set('system', 'basepath' , $basepath); Config::set('system', 'basepath' , $basepath);

6
mod/friendica.php
View file

@ -12,7 +12,7 @@ use Friendica\Core\System;
use Friendica\Database\DBA; use Friendica\Database\DBA;
use Friendica\Module\Register; use Friendica\Module\Register;
function friendica_init(App $a) function friendica_init(App $a, Config\ConfigCache $config)
{ {
if (!empty($a->argv[1]) && ($a->argv[1] == "json")) { if (!empty($a->argv[1]) && ($a->argv[1] == "json")) {
$register_policies = [ $register_policies = [
@ -29,7 +29,7 @@ function friendica_init(App $a)
} }
$sql_extra = ''; $sql_extra = '';
if (Config::getConfigValue('config', 'admin_nickname') !== null) { if ($config->get('config', 'admin_nickname') !== null) {
$sql_extra = sprintf(" AND `nickname` = '%s' ", DBA::escape(Config::get('config', 'admin_nickname'))); $sql_extra = sprintf(" AND `nickname` = '%s' ", DBA::escape(Config::get('config', 'admin_nickname')));
} }
if (!empty(Config::get('config', 'admin_email'))) { if (!empty(Config::get('config', 'admin_email'))) {
@ -48,7 +48,7 @@ function friendica_init(App $a)
Config::load('feature_lock'); Config::load('feature_lock');
$locked_features = []; $locked_features = [];
$featureLock = Config::getConfigValue('config', 'feature_lock'); $featureLock = $config->get('config', 'feature_lock');
if (isset($featureLock)) { if (isset($featureLock)) {
foreach ($featureLock as $k => $v) { foreach ($featureLock as $k => $v) {
if ($k === 'config_loaded') { if ($k === 'config_loaded') {

351
src/App.php
View file

@ -8,8 +8,12 @@ use Detection\MobileDetect;
use DOMDocument; use DOMDocument;
use DOMXPath; use DOMXPath;
use Exception; use Exception;
use Friendica\Core\Config\ConfigCache;
use Friendica\Core\Config\ConfigCacheLoader;
use Friendica\Database\DBA; use Friendica\Database\DBA;
use Friendica\Factory\ConfigFactory;
use Friendica\Network\HTTPException\InternalServerErrorException; use Friendica\Network\HTTPException\InternalServerErrorException;
use Friendica\Util\BasePath;
use Psr\Log\LoggerInterface; use Psr\Log\LoggerInterface;
/** /**
@ -111,6 +115,31 @@ class App
*/ */
private $logger; private $logger;
/**
* @var ConfigCache The cached config
*/
private $config;
/**
* Returns the current config cache of this node
*
* @return ConfigCache
*/
public function getConfig()
{
return $this->config;
}
/**
* The basepath of this app
*
* @return string
*/
public function getBasePath()
{
return $this->basePath;
}
/** /**
* Register a stylesheet file path to be included in the <head> tag of every page. * Register a stylesheet file path to be included in the <head> tag of every page.
* Inclusion is done in App->initHead(). * Inclusion is done in App->initHead().
@ -123,7 +152,7 @@ class App
*/ */
public function registerStylesheet($path) public function registerStylesheet($path)
{ {
$url = str_replace($this->getBasePath() . DIRECTORY_SEPARATOR, '', $path); $url = str_replace($this->basePath . DIRECTORY_SEPARATOR, '', $path);
$this->stylesheets[] = trim($url, '/'); $this->stylesheets[] = trim($url, '/');
} }
@ -140,7 +169,7 @@ class App
*/ */
public function registerFooterScript($path) public function registerFooterScript($path)
{ {
$url = str_replace($this->getBasePath() . DIRECTORY_SEPARATOR, '', $path); $url = str_replace($this->basePath . DIRECTORY_SEPARATOR, '', $path);
$this->footerScripts[] = trim($url, '/'); $this->footerScripts[] = trim($url, '/');
} }
@ -153,23 +182,25 @@ class App
/** /**
* @brief App constructor. * @brief App constructor.
* *
* @param string $basePath Path to the app base folder * @param ConfigCache $config The Cached Config
* @param LoggerInterface $logger Logger of this application * @param LoggerInterface $logger Logger of this application
* @param bool $isBackend Whether it is used for backend or frontend (Default true=backend) * @param bool $isBackend Whether it is used for backend or frontend (Default true=backend)
* *
* @throws Exception if the Basepath is not usable * @throws Exception if the Basepath is not usable
*/ */
public function __construct($basePath, LoggerInterface $logger, $isBackend = true) public function __construct(ConfigCache $config, LoggerInterface $logger, $isBackend = true)
{ {
$this->logger = $logger; $this->config = $config;
$this->logger = $logger;
$this->basePath = $this->config->get('system', 'basepath');
if (!static::isDirectoryUsable($basePath, false)) { if (!BasePath::isDirectoryUsable($this->basePath, false)) {
throw new Exception('Basepath ' . $basePath . ' isn\'t usable.'); throw new Exception('Basepath ' . $this->basePath . ' isn\'t usable.');
} }
$this->basePath = rtrim($this->basePath, DIRECTORY_SEPARATOR);
BaseObject::setApp($this); BaseObject::setApp($this);
$this->basePath = rtrim($basePath, DIRECTORY_SEPARATOR);
$this->checkBackend($isBackend); $this->checkBackend($isBackend);
$this->checkFriendicaApp(); $this->checkFriendicaApp();
@ -194,7 +225,7 @@ class App
$this->callstack['rendering'] = []; $this->callstack['rendering'] = [];
$this->callstack['parser'] = []; $this->callstack['parser'] = [];
$this->mode = new App\Mode($basePath); $this->mode = new App\Mode($this->basePath);
$this->reload(); $this->reload();
@ -225,9 +256,9 @@ class App
set_include_path( set_include_path(
get_include_path() . PATH_SEPARATOR get_include_path() . PATH_SEPARATOR
. $this->getBasePath() . DIRECTORY_SEPARATOR . 'include' . PATH_SEPARATOR . $this->basePath . DIRECTORY_SEPARATOR . 'include' . PATH_SEPARATOR
. $this->getBasePath() . DIRECTORY_SEPARATOR . 'library' . PATH_SEPARATOR . $this->basePath . DIRECTORY_SEPARATOR . 'library' . PATH_SEPARATOR
. $this->getBasePath()); . $this->basePath);
if (!empty($_SERVER['QUERY_STRING']) && strpos($_SERVER['QUERY_STRING'], 'pagename=') === 0) { if (!empty($_SERVER['QUERY_STRING']) && strpos($_SERVER['QUERY_STRING'], 'pagename=') === 0) {
$this->query_string = substr($_SERVER['QUERY_STRING'], 9); $this->query_string = substr($_SERVER['QUERY_STRING'], 9);
@ -331,21 +362,32 @@ class App
*/ */
public function reload() public function reload()
{ {
// The order of the following calls is important to ensure proper initialization Core\Config::init($this->config);
$this->loadConfigFiles(); Core\PConfig::init($this->config);
$this->loadDatabase(); $this->loadDatabase();
$this->getMode()->determine($this->getBasePath()); $this->getMode()->determine($this->basePath);
$this->determineURLPath(); $this->determineURLPath();
Core\Config::load(); if ($this->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) {
$adapterType = $this->config->get('system', 'config_adapter');
$adapter = ConfigFactory::createConfig($adapterType, $this->config);
Core\Config::setAdapter($adapter);
$adapterP = ConfigFactory::createConfig($adapterType, $this->config);
Core\PConfig::setAdapter($adapterP);
Core\Config::load();
}
// again because DB-config could change the config
$this->getMode()->determine($this->basePath);
if ($this->getMode()->has(App\Mode::DBAVAILABLE)) { if ($this->getMode()->has(App\Mode::DBAVAILABLE)) {
Core\Hook::loadHooks(); Core\Hook::loadHooks();
$loader = new ConfigCacheLoader($this->basePath);
$this->loadAddonConfig(); Core\Hook::callAll('load_config', $loader);
$this->config->loadConfigArray($loader->loadAddonConfig(), true);
} }
$this->loadDefaultTimezone(); $this->loadDefaultTimezone();
@ -357,139 +399,6 @@ class App
Core\Logger::setLogger($this->logger); Core\Logger::setLogger($this->logger);
} }
/**
* Load the configuration files
*
* First loads the default value for all the configuration keys, then the legacy configuration files, then the
* expected local.config.php
*/
private function loadConfigFiles()
{
$this->loadConfigFile($this->getBasePath() . '/config/defaults.config.php');
$this->loadConfigFile($this->getBasePath() . '/config/settings.config.php');
// Legacy .htconfig.php support
if (file_exists($this->getBasePath() . '/.htpreconfig.php')) {
$a = $this;
include $this->getBasePath() . '/.htpreconfig.php';
}
// Legacy .htconfig.php support
if (file_exists($this->getBasePath() . '/.htconfig.php')) {
$a = $this;
include $this->getBasePath() . '/.htconfig.php';
Core\Config::setConfigValue('database', 'hostname', $db_host);
Core\Config::setConfigValue('database', 'username', $db_user);
Core\Config::setConfigValue('database', 'password', $db_pass);
Core\Config::setConfigValue('database', 'database', $db_data);
$charset = Core\Config::getConfigValue('system', 'db_charset');
if (isset($charset)) {
Core\Config::setConfigValue('database', 'charset', $charset);
}
unset($db_host, $db_user, $db_pass, $db_data);
if (isset($default_timezone)) {
Core\Config::setConfigValue('system', 'default_timezone', $default_timezone);
unset($default_timezone);
}
if (isset($pidfile)) {
Core\Config::setConfigValue('system', 'pidfile', $pidfile);
unset($pidfile);
}
if (isset($lang)) {
Core\Config::setConfigValue('system', 'language', $lang);
unset($lang);
}
}
if (file_exists($this->getBasePath() . '/config/local.config.php')) {
$this->loadConfigFile($this->getBasePath() . '/config/local.config.php', true);
} elseif (file_exists($this->getBasePath() . '/config/local.ini.php')) {
$this->loadINIConfigFile($this->getBasePath() . '/config/local.ini.php', true);
}
}
/**
* Tries to load the specified legacy configuration file into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* @deprecated since version 2018.12
* @param string $filepath
* @param bool $overwrite Force value overwrite if the config key already exists
* @throws Exception
*/
public function loadINIConfigFile($filepath, $overwrite = false)
{
if (!file_exists($filepath)) {
throw new Exception('Error parsing non-existent INI config file ' . $filepath);
}
$contents = include($filepath);
$config = parse_ini_string($contents, true, INI_SCANNER_TYPED);
if ($config === false) {
throw new Exception('Error parsing INI config file ' . $filepath);
}
Core\Config::loadConfigArray($config, $overwrite);
}
/**
* Tries to load the specified configuration file into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* The config format is PHP array and the template for configuration files is the following:
*
* <?php return [
* 'section' => [
* 'key' => 'value',
* ],
* ];
*
* @param string $filepath
* @param bool $overwrite Force value overwrite if the config key already exists
* @throws Exception
*/
public function loadConfigFile($filepath, $overwrite = false)
{
if (!file_exists($filepath)) {
throw new Exception('Error loading non-existent config file ' . $filepath);
}
$config = include($filepath);
if (!is_array($config)) {
throw new Exception('Error loading config file ' . $filepath);
}
Core\Config::loadConfigArray($config, $overwrite);
}
/**
* Loads addons configuration files
*
* First loads all activated addons default configuration through the load_config hook, then load the local.config.php
* again to overwrite potential local addon configuration.
*/
private function loadAddonConfig()
{
// Loads addons default config
Core\Hook::callAll('load_config');
// Load the local addon config file to overwritten default addon config values
if (file_exists($this->getBasePath() . '/config/addon.config.php')) {
$this->loadConfigFile($this->getBasePath() . '/config/addon.config.php', true);
} elseif (file_exists($this->getBasePath() . '/config/addon.ini.php')) {
$this->loadINIConfigFile($this->getBasePath() . '/config/addon.ini.php', true);
}
}
/** /**
* Loads the default timezone * Loads the default timezone
* *
@ -499,8 +408,8 @@ class App
*/ */
private function loadDefaultTimezone() private function loadDefaultTimezone()
{ {
if (Core\Config::getConfigValue('system', 'default_timezone')) { if ($this->config->get('system', 'default_timezone')) {
$this->timezone = Core\Config::getConfigValue('system', 'default_timezone'); $this->timezone = $this->config->get('system', 'default_timezone');
} else { } else {
global $default_timezone; global $default_timezone;
$this->timezone = !empty($default_timezone) ? $default_timezone : 'UTC'; $this->timezone = !empty($default_timezone) ? $default_timezone : 'UTC';
@ -526,7 +435,7 @@ class App
$relative_script_path = defaults($_SERVER, 'SCRIPT_URL' , $relative_script_path); $relative_script_path = defaults($_SERVER, 'SCRIPT_URL' , $relative_script_path);
$relative_script_path = defaults($_SERVER, 'REQUEST_URI' , $relative_script_path); $relative_script_path = defaults($_SERVER, 'REQUEST_URI' , $relative_script_path);
$this->urlPath = Core\Config::getConfigValue('system', 'urlpath'); $this->urlPath = $this->config->get('system', 'urlpath');
/* $relative_script_path gives /relative/path/to/friendica/module/parameter /* $relative_script_path gives /relative/path/to/friendica/module/parameter
* QUERY_STRING gives pagename=module/parameter * QUERY_STRING gives pagename=module/parameter
@ -554,11 +463,11 @@ class App
return; return;
} }
$db_host = Core\Config::getConfigValue('database', 'hostname'); $db_host = $this->config->get('database', 'hostname');
$db_user = Core\Config::getConfigValue('database', 'username'); $db_user = $this->config->get('database', 'username');
$db_pass = Core\Config::getConfigValue('database', 'password'); $db_pass = $this->config->get('database', 'password');
$db_data = Core\Config::getConfigValue('database', 'database'); $db_data = $this->config->get('database', 'database');
$charset = Core\Config::getConfigValue('database', 'charset'); $charset = $this->config->get('database', 'charset');
// Use environment variables for mysql if they are set beforehand // Use environment variables for mysql if they are set beforehand
if (!empty(getenv('MYSQL_HOST')) if (!empty(getenv('MYSQL_HOST'))
@ -581,9 +490,9 @@ class App
$stamp1 = microtime(true); $stamp1 = microtime(true);
if (DBA::connect($db_host, $db_user, $db_pass, $db_data, $charset)) { if (DBA::connect($this->config, $db_host, $db_user, $db_pass, $db_data, $charset)) {
// Loads DB_UPDATE_VERSION constant // Loads DB_UPDATE_VERSION constant
Database\DBStructure::definition(false); Database\DBStructure::definition($this->basePath, false);
} }
unset($db_host, $db_user, $db_pass, $db_data, $charset); unset($db_host, $db_user, $db_pass, $db_data, $charset);
@ -591,55 +500,6 @@ class App
$this->saveTimestamp($stamp1, 'network'); $this->saveTimestamp($stamp1, 'network');
} }
/**
* @brief Returns the base filesystem path of the App
*
* It first checks for the internal variable, then for DOCUMENT_ROOT and
* finally for PWD
*
* @return string
* @throws InternalServerErrorException
*/
public function getBasePath()
{
$basepath = $this->basePath;
if (!$basepath) {
$basepath = Core\Config::get('system', 'basepath');
}
if (!$basepath && !empty($_SERVER['DOCUMENT_ROOT'])) {
$basepath = $_SERVER['DOCUMENT_ROOT'];
}
if (!$basepath && !empty($_SERVER['PWD'])) {
$basepath = $_SERVER['PWD'];
}
return self::getRealPath($basepath);
}
/**
* @brief Returns a normalized file path
*
* This is a wrapper for the "realpath" function.
* That function cannot detect the real path when some folders aren't readable.
* Since this could happen with some hosters we need to handle this.
*
* @param string $path The path that is about to be normalized
* @return string normalized path - when possible
*/
public static function getRealPath($path)
{
$normalized = realpath($path);
if (!is_bool($normalized)) {
return $normalized;
} else {
return $path;
}
}
public function getScheme() public function getScheme()
{ {
return $this->scheme; return $this->scheme;
@ -715,8 +575,8 @@ class App
$this->urlPath = trim($parsed['path'], '\\/'); $this->urlPath = trim($parsed['path'], '\\/');
} }
if (file_exists($this->getBasePath() . '/.htpreconfig.php')) { if (file_exists($this->basePath . '/.htpreconfig.php')) {
include $this->getBasePath() . '/.htpreconfig.php'; include $this->basePath . '/.htpreconfig.php';
} }
if (Core\Config::get('config', 'hostname') != '') { if (Core\Config::get('config', 'hostname') != '') {
@ -769,9 +629,9 @@ class App
// compose the page title from the sitename and the // compose the page title from the sitename and the
// current module called // current module called
if (!$this->module == '') { if (!$this->module == '') {
$this->page['title'] = Core\Config::getConfigValue('config', 'sitename') . ' (' . $this->module . ')'; $this->page['title'] = $this->config->get('config', 'sitename') . ' (' . $this->module . ')';
} else { } else {
$this->page['title'] = Core\Config::getConfigValue('config', 'sitename'); $this->page['title'] = $this->config->get('config', 'sitename');
} }
if (!empty(Core\Renderer::$theme['stylesheet'])) { if (!empty(Core\Renderer::$theme['stylesheet'])) {
@ -892,7 +752,7 @@ class App
*/ */
public function saveTimestamp($timestamp, $value) public function saveTimestamp($timestamp, $value)
{ {
$profiler = Core\Config::getConfigValue('system', 'profiler'); $profiler = $this->config->get('system', 'profiler');
if (!isset($profiler) || !$profiler) { if (!isset($profiler) || !$profiler) {
return; return;
@ -1132,7 +992,7 @@ class App
return; return;
} }
$cmdline = Core\Config::getConfigValue('config', 'php_path', 'php') . ' ' . escapeshellarg($command); $cmdline = $this->config->get('config', 'php_path', 'php') . ' ' . escapeshellarg($command);
foreach ($args as $key => $value) { foreach ($args as $key => $value) {
if (!is_null($value) && is_bool($value) && !$value) { if (!is_null($value) && is_bool($value) && !$value) {
@ -1150,9 +1010,9 @@ class App
} }
if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
$resource = proc_open('cmd /c start /b ' . $cmdline, [], $foo, $this->getBasePath()); $resource = proc_open('cmd /c start /b ' . $cmdline, [], $foo, $this->basePath);
} else { } else {
$resource = proc_open($cmdline . ' &', [], $foo, $this->getBasePath()); $resource = proc_open($cmdline . ' &', [], $foo, $this->basePath);
} }
if (!is_resource($resource)) { if (!is_resource($resource)) {
Core\Logger::log('We got no resource for command ' . $cmdline, Core\Logger::DEBUG); Core\Logger::log('We got no resource for command ' . $cmdline, Core\Logger::DEBUG);
@ -1161,61 +1021,6 @@ class App
proc_close($resource); proc_close($resource);
} }
/**
* @brief Returns the system user that is executing the script
*
* This mostly returns something like "www-data".
*
* @return string system username
*/
private static function getSystemUser()
{
if (!function_exists('posix_getpwuid') || !function_exists('posix_geteuid')) {
return '';
}
$processUser = posix_getpwuid(posix_geteuid());
return $processUser['name'];
}
/**
* @brief Checks if a given directory is usable for the system
*
* @param $directory
* @param bool $check_writable
* @return boolean the directory is usable
* @throws Exception
*/
public static function isDirectoryUsable($directory, $check_writable = true)
{
if ($directory == '') {
Core\Logger::log('Directory is empty. This shouldn\'t happen.', Core\Logger::DEBUG);
return false;
}
if (!file_exists($directory)) {
Core\Logger::log('Path "' . $directory . '" does not exist for user ' . self::getSystemUser(), Core\Logger::DEBUG);
return false;
}
if (is_file($directory)) {
Core\Logger::log('Path "' . $directory . '" is a file for user ' . self::getSystemUser(), Core\Logger::DEBUG);
return false;
}
if (!is_dir($directory)) {
Core\Logger::log('Path "' . $directory . '" is not a directory for user ' . self::getSystemUser(), Core\Logger::DEBUG);
return false;
}
if ($check_writable && !is_writable($directory)) {
Core\Logger::log('Path "' . $directory . '" is not writable for user ' . self::getSystemUser(), Core\Logger::DEBUG);
return false;
}
return true;
}
/** /**
* Generates the site's default sender email address * Generates the site's default sender email address
* *

192
src/Core/Config.php
View file

@ -8,8 +8,8 @@
*/ */
namespace Friendica\Core; namespace Friendica\Core;
use Friendica\App; use Friendica\Core\Config\IConfigAdapter;
use Friendica\BaseObject; use Friendica\Core\Config\IConfigCache;
/** /**
* @brief Arbitrary system configuration storage * @brief Arbitrary system configuration storage
@ -18,27 +18,36 @@ use Friendica\BaseObject;
* If we ever would decide to return exactly the variable type as entered, * If we ever would decide to return exactly the variable type as entered,
* we will have fun with the additional features. :-) * we will have fun with the additional features. :-)
*/ */
class Config extends BaseObject class Config
{ {
public static $config = []; /**
* @var IConfigAdapter
*/
private static $adapter;
/** /**
* @var \Friendica\Core\Config\IConfigAdapter * @var IConfigCache
*/ */
private static $adapter = null; private static $config;
public static function init() /**
* Initialize the config with only the cache
*
* @param IConfigCache $config The configuration cache
*/
public static function init($config)
{ {
// Database isn't ready or populated yet self::$config = $config;
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { }
return;
}
if (self::getConfigValue('system', 'config_adapter') == 'preload') { /**
self::$adapter = new Config\PreloadConfigAdapter(); * Add the adapter for DB-backend
} else { *
self::$adapter = new Config\JITConfigAdapter(); * @param $adapter
} */
public static function setAdapter($adapter)
{
self::$adapter = $adapter;
} }
/** /**
@ -50,19 +59,13 @@ class Config extends BaseObject
* @param string $family The category of the configuration value * @param string $family The category of the configuration value
* *
* @return void * @return void
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function load($family = "config") public static function load($family = "config")
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) {
return; return;
} }
if (empty(self::$adapter)) {
self::init();
}
self::$adapter->load($family); self::$adapter->load($family);
} }
@ -84,17 +87,11 @@ class Config extends BaseObject
* @param boolean $refresh optional, If true the config is loaded from the db and not from the cache (default: false) * @param boolean $refresh optional, If true the config is loaded from the db and not from the cache (default: false)
* *
* @return mixed Stored value or null if it does not exist * @return mixed Stored value or null if it does not exist
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function get($family, $key, $default_value = null, $refresh = false) public static function get($family, $key, $default_value = null, $refresh = false)
{ {
// Database isn't ready or populated yet, fallback to file config if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { return self::$config->get($family, $key, $default_value);
return self::getConfigValue($family, $key, $default_value);
}
if (empty(self::$adapter)) {
self::init();
} }
return self::$adapter->get($family, $key, $default_value, $refresh); return self::$adapter->get($family, $key, $default_value, $refresh);
@ -113,17 +110,12 @@ class Config extends BaseObject
* @param mixed $value The value to store * @param mixed $value The value to store
* *
* @return bool Operation success * @return bool Operation success
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function set($family, $key, $value) public static function set($family, $key, $value)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { self::$config->set($family, $key, $value);
return false; return true;
}
if (empty(self::$adapter)) {
self::init();
} }
return self::$adapter->set($family, $key, $value); return self::$adapter->set($family, $key, $value);
@ -139,131 +131,13 @@ class Config extends BaseObject
* @param string $key The configuration key to delete * @param string $key The configuration key to delete
* *
* @return mixed * @return mixed
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function delete($family, $key) public static function delete($family, $key)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { self::$config->delete($family, $key);
return false;
}
if (empty(self::$adapter)) {
self::init();
} }
return self::$adapter->delete($family, $key); return self::$adapter->delete($family, $key);
} }
/**
* Tries to load the specified configuration array into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* @param array $config
* @param bool $overwrite Force value overwrite if the config key already exists
*/
public static function loadConfigArray(array $config, $overwrite = false)
{
foreach ($config as $category => $values) {
foreach ($values as $key => $value) {
if ($overwrite) {
self::setConfigValue($category, $key, $value);
} else {
self::setDefaultConfigValue($category, $key, $value);
}
}
}
}
/**
* @param string $cat Config category
* @param string $k Config key
* @param mixed $default Default value if it isn't set
*
* @return string Returns the value of the Config entry
*/
public static function getConfigValue($cat, $k = null, $default = null)
{
$return = $default;
if ($cat === 'config') {
if (isset(self::$config[$k])) {
$return = self::$config[$k];
}
} else {
if (isset(self::$config[$cat][$k])) {
$return = self::$config[$cat][$k];
} elseif ($k == null && isset(self::$config[$cat])) {
$return = self::$config[$cat];
}
}
return $return;
}
/**
* Sets a default value in the config cache. Ignores already existing keys.
*
* @param string $cat Config category
* @param string $k Config key
* @param mixed $v Default value to set
*/
private static function setDefaultConfigValue($cat, $k, $v)
{
if (!isset(self::$config[$cat][$k])) {
self::setConfigValue($cat, $k, $v);
}
}
/**
* Sets a value in the config cache. Accepts raw output from the config table
*
* @param string $cat Config category
* @param string $k Config key
* @param mixed $v Value to set
*/
public static function setConfigValue($cat, $k, $v)
{
// Only arrays are serialized in database, so we have to unserialize sparingly
$value = is_string($v) && preg_match("|^a:[0-9]+:{.*}$|s", $v) ? unserialize($v) : $v;
if ($cat === 'config') {
self::$config[$k] = $value;
} else {
if (!isset(self::$config[$cat])) {
self::$config[$cat] = [];
}
self::$config[$cat][$k] = $value;
}
}
/**
* Deletes a value from the config cache
*
* @param string $cat Config category
* @param string $k Config key
*/
public static function deleteConfigValue($cat, $k)
{
if ($cat === 'config') {
if (isset(self::$config[$k])) {
unset(self::$config[$k]);
}
} else {
if (isset(self::$config[$cat][$k])) {
unset(self::$config[$cat][$k]);
}
}
}
/**
* Returns the whole configuration
*
* @return array The configuration
*/
public static function getAll()
{
return self::$config;
}
} }

173
src/Core/Config/ConfigCache.php Normal file
View file

@ -0,0 +1,173 @@
<?php
namespace Friendica\Core\Config;
class ConfigCache implements IConfigCache, IPConfigCache
{
/**
* NEVER, EVER use this public config array outside of the class
* It is only public due to backward compatibility to .htconfig.php
*
* @var array The cached config array
*/
public $config;
public function __construct($config = [], $overwrite = false)
{
$this->config = [];
if (isset($config)) {
$this->loadConfigArray($config, $overwrite);
}
}
/**
* Tries to load the specified configuration array into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* @param array $config
* @param bool $overwrite Force value overwrite if the config key already exists
*/
public function loadConfigArray(array $config, $overwrite = false)
{
foreach ($config as $category => $values) {
foreach ($values as $key => $value) {
if ($overwrite) {
self::set($category, $key, $value);
} else {
self::setDefault($category, $key, $value);
}
}
}
}
/**
* {@inheritdoc}
*/
public function get($cat, $key = null, $default = null)
{
$return = $default;
if ($cat === 'config') {
if (isset($this->config[$key])) {
$return = $this->config[$key];
}
} else {
if (isset($this->config[$cat][$key])) {
$return = $this->config[$cat][$key];
} elseif ($key == null && isset($this->config[$cat])) {
$return = $this->config[$cat];
}
}
return $return;
}
/**
* Sets a default value in the config cache. Ignores already existing keys.
*
* @param string $cat Config category
* @param string $k Config key
* @param mixed $v Default value to set
*/
private function setDefault($cat, $k, $v)
{
if (!isset($this->config[$cat][$k])) {
self::set($cat, $k, $v);
}
}
/**
* {@inheritdoc}
*/
public function set($cat, $key, $value)
{
// Only arrays are serialized in database, so we have to unserialize sparingly
$value = is_string($value) && preg_match("|^a:[0-9]+:{.*}$|s", $value) ? unserialize($value) : $value;
if ($cat === 'config') {
$this->config[$key] = $value;
} else {
if (!isset($this->config[$cat])) {
$this->config[$cat] = [];
}
$this->config[$cat][$key] = $value;
}
}
/**
* {@inheritdoc}
*/
public function delete($cat, $key)
{
if ($cat === 'config') {
if (isset($this->config[$key])) {
unset($this->config[$key]);
}
} else {
if (isset($this->config[$cat][$key])) {
unset($this->config[$cat][$key]);
}
}
}
/**
* {@inheritdoc}
*/
public function getP($uid, $cat, $key = null, $default = null)
{
$return = $default;
if (isset($this->config[$uid][$cat][$key])) {
$return = $this->config[$uid][$cat][$key];
} elseif ($key == null && isset($this->config[$uid][$cat])) {
$return = $this->config[$uid][$cat];
}
return $return;
}
/**
* {@inheritdoc}
*/
public function setP($uid, $cat, $key, $value)
{
// Only arrays are serialized in database, so we have to unserialize sparingly
$value = is_string($value) && preg_match("|^a:[0-9]+:{.*}$|s", $value) ? unserialize($value) : $value;
if (!isset($this->config[$uid]) || !is_array($this->config[$uid])) {
$this->config[$uid] = [];
}
if (!isset($this->config[$uid][$cat]) || !is_array($this->config[$uid][$cat])) {
$this->config[$uid][$cat] = [];
}
if ($key === null) {
$this->config[$uid][$cat] = $value;
} else {
$this->config[$uid][$cat][$key] = $value;
}
}
/**
* {@inheritdoc}
*/
public function deleteP($uid, $cat, $key)
{
if (isset($this->config[$uid][$cat][$key])) {
unset($this->config[$uid][$cat][$key]);
}
}
/**
* Returns the whole configuration
*
* @return array The configuration
*/
public function getAll()
{
return $this->config;
}
}

159
src/Core/Config/ConfigCacheLoader.php Normal file
View file

@ -0,0 +1,159 @@
<?php
namespace Friendica\Core\Config;
class ConfigCacheLoader
{
private $baseDir;
private $configDir;
public function __construct($baseDir)
{
$this->baseDir = $baseDir;
$this->configDir = $baseDir . '/config/';
}
/**
* Load the configuration files
*
* First loads the default value for all the configuration keys, then the legacy configuration files, then the
* expected local.config.php
*/
public function loadConfigFiles(ConfigCache $config)
{
// Setting at least the basepath we know
$config->set('system', 'basepath', $this->baseDir);
$config->loadConfigArray($this->loadConfigFile('defaults'));
$config->loadConfigArray($this->loadConfigFile('settings'));
// Legacy .htconfig.php support
if (file_exists($this->baseDir . '/.htpreconfig.php')) {
$a = $config;
include $this->baseDir . '/.htpreconfig.php';
}
// Legacy .htconfig.php support
if (file_exists($this->baseDir . '/.htconfig.php')) {
$a = $config;
include $this->baseDir . '/.htconfig.php';
$config->set('database', 'hostname', $db_host);
$config->set('database', 'username', $db_user);
$config->set('database', 'password', $db_pass);
$config->set('database', 'database', $db_data);
$charset = $config->get('system', 'db_charset');
if (isset($charset)) {
$config->set('database', 'charset', $charset);
}
unset($db_host, $db_user, $db_pass, $db_data);
if (isset($default_timezone)) {
$config->set('system', 'default_timezone', $default_timezone);
unset($default_timezone);
}
if (isset($pidfile)) {
$config->set('system', 'pidfile', $pidfile);
unset($pidfile);
}
if (isset($lang)) {
$config->set('system', 'language', $lang);
unset($lang);
}
}
if (file_exists($this->baseDir . '/config/local.config.php')) {
$config->loadConfigArray($this->loadConfigFile('local'), true);
} elseif (file_exists($this->baseDir . '/config/local.ini.php')) {
$config->loadConfigArray($this->loadINIConfigFile('local'), true);
}
}
/**
* Tries to load the specified legacy configuration file into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* @deprecated since version 2018.12
* @param string $filename
*
* @return array The configuration
* @throws \Exception
*/
public function loadINIConfigFile($filename)
{
$filepath = $this->configDir . $filename . ".ini.php";
if (!file_exists($filepath)) {
throw new \Exception('Error parsing non-existent INI config file ' . $filepath);
}
$contents = include($filepath);
$config = parse_ini_string($contents, true, INI_SCANNER_TYPED);
if ($config === false) {
throw new \Exception('Error parsing INI config file ' . $filepath);
}
return $config;
}
/**
* Tries to load the specified configuration file into the App->config array.
* Doesn't overwrite previously set values by default to prevent default config files to supersede DB Config.
*
* The config format is PHP array and the template for configuration files is the following:
*
* <?php return [
* 'section' => [
* 'key' => 'value',
* ],
* ];
*
* @param string $filename
* @return array The configuration
* @throws \Exception
*/
public function loadConfigFile($filename)
{
$filepath = $this->configDir . $filename . ".config.php";
if (!file_exists($filepath)) {
throw new \Exception('Error loading non-existent config file ' . $filepath);
}
$config = include($filepath);
if (!is_array($config)) {
throw new \Exception('Error loading config file ' . $filepath);
}
return $config;
}
/**
* Loads addons configuration files
*
* First loads all activated addons default configuration through the load_config hook, then load the local.config.php
* again to overwrite potential local addon configuration.
*
* @return array The config array
*
* @throws \Exception
*/
public function loadAddonConfig()
{
// Load the local addon config file to overwritten default addon config values
if (file_exists($this->configDir . 'addon.config.php')) {
return $this->loadConfigFile('addon');
} elseif (file_exists($this->configDir . 'addon.ini.php')) {
return $this->loadINIConfigFile('addon');
} else {
return [];
}
}
}

34
src/Core/Config/IConfigCache.php Normal file
View file

@ -0,0 +1,34 @@
<?php
namespace Friendica\Core\Config;
interface IConfigCache
{
/**
* @param string $cat Config category
* @param string $key Config key
* @param mixed $default Default value if it isn't set
*
* @return mixed Returns the value of the Config entry
*/
function get($cat, $key = null, $default = null);
/**
* Sets a value in the config cache. Accepts raw output from the config table
*
* @param string $cat Config category
* @param string $key Config key
* @param mixed $value Value to set
*/
function set($cat, $key, $value);
/**
* Deletes a value from the config cache
*
* @param string $cat Config category
* @param string $key Config key
*/
function delete($cat, $key);
function getAll();
}

41
src/Core/Config/IPConfigCache.php Normal file
View file

@ -0,0 +1,41 @@
<?php
namespace Friendica\Core\Config;
interface IPConfigCache
{
/**
* Retrieves a value from the user config cache
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $key Config key
* @param mixed $default Default value if key isn't set
*
* @return string The value of the config entry
*/
function getP($uid, $cat, $key = null, $default = null);
/**
* Sets a value in the user config cache
*
* Accepts raw output from the pconfig table
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $key Config key
* @param mixed $value Value to set
*/
function setP($uid, $cat, $key, $value);
/**
* Deletes a value from the user config cache
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $key Config key
*/
function deleteP($uid, $cat, $key);
function getAll();
}

30
src/Core/Config/JITConfigAdapter.php
View file

@ -1,7 +1,6 @@
<?php <?php
namespace Friendica\Core\Config; namespace Friendica\Core\Config;
use Friendica\Core\Config;
use Friendica\Database\DBA; use Friendica\Database\DBA;
/** /**
@ -16,6 +15,19 @@ class JITConfigAdapter implements IConfigAdapter
private $cache; private $cache;
private $in_db; private $in_db;
/**
* @var IConfigCache The config cache of this driver
*/
private $config;
/**
* @param IConfigCache $config The config cache of this driver
*/
public function __construct($config)
{
$this->config = $config;
}
public function load($cat = "config") public function load($cat = "config")
{ {
// We don't preload "system" anymore. // We don't preload "system" anymore.
@ -28,7 +40,7 @@ class JITConfigAdapter implements IConfigAdapter
while ($config = DBA::fetch($configs)) { while ($config = DBA::fetch($configs)) {
$k = $config['k']; $k = $config['k'];
Config::setConfigValue($cat, $k, $config['v']); $this->config->set($cat, $k, $config['v']);
if ($cat !== 'config') { if ($cat !== 'config') {
$this->cache[$cat][$k] = $config['v']; $this->cache[$cat][$k] = $config['v'];
@ -60,18 +72,18 @@ class JITConfigAdapter implements IConfigAdapter
$this->cache[$cat][$k] = $value; $this->cache[$cat][$k] = $value;
$this->in_db[$cat][$k] = true; $this->in_db[$cat][$k] = true;
return $value; return $value;
} elseif (Config::getConfigValue($cat, $k) !== null) { } elseif ($this->config->get($cat, $k) !== null) {
// Assign the value (mostly) from config/local.config.php file to the cache // Assign the value (mostly) from config/local.config.php file to the cache
$this->cache[$cat][$k] = Config::getConfigValue($cat, $k); $this->cache[$cat][$k] = $this->config->get($cat, $k);
$this->in_db[$cat][$k] = false; $this->in_db[$cat][$k] = false;
return Config::getConfigValue($cat, $k); return $this->config->get($cat, $k);
} elseif (Config::getConfigValue('config', $k) !== null) { } elseif ($this->config->get('config', $k) !== null) {
// Assign the value (mostly) from config/local.config.php file to the cache // Assign the value (mostly) from config/local.config.php file to the cache
$this->cache[$k] = Config::getConfigValue('config', $k); $this->cache[$k] = $this->config->get('config', $k);
$this->in_db[$k] = false; $this->in_db[$k] = false;
return Config::getConfigValue('config', $k); return $this->config->get('config', $k);
} }
$this->cache[$cat][$k] = '!<unset>!'; $this->cache[$cat][$k] = '!<unset>!';
@ -100,7 +112,7 @@ class JITConfigAdapter implements IConfigAdapter
return true; return true;
} }
Config::setConfigValue($cat, $k, $value); $this->config->set($cat, $k, $value);
// Assign the just added value to the cache // Assign the just added value to the cache
$this->cache[$cat][$k] = $dbvalue; $this->cache[$cat][$k] = $dbvalue;

37
src/Core/Config/JITPConfigAdapter.php
View file

@ -1,7 +1,6 @@
<?php <?php
namespace Friendica\Core\Config; namespace Friendica\Core\Config;
use Friendica\Core\PConfig;
use Friendica\Database\DBA; use Friendica\Database\DBA;
/** /**
@ -15,6 +14,20 @@ class JITPConfigAdapter implements IPConfigAdapter
{ {
private $in_db; private $in_db;
/**
* The config cache of this adapter
* @var IPConfigCache
*/
private $config;
/**
* @param IPConfigCache $config The config cache of this adapter
*/
public function __construct($config)
{
$this->config = $config;
}
public function load($uid, $cat) public function load($uid, $cat)
{ {
$pconfigs = DBA::select('pconfig', ['v', 'k'], ['cat' => $cat, 'uid' => $uid]); $pconfigs = DBA::select('pconfig', ['v', 'k'], ['cat' => $cat, 'uid' => $uid]);
@ -22,13 +35,13 @@ class JITPConfigAdapter implements IPConfigAdapter
while ($pconfig = DBA::fetch($pconfigs)) { while ($pconfig = DBA::fetch($pconfigs)) {
$k = $pconfig['k']; $k = $pconfig['k'];
PConfig::setPConfigValue($uid, $cat, $k, $pconfig['v']); $this->config->setP($uid, $cat, $k, $pconfig['v']);
$this->in_db[$uid][$cat][$k] = true; $this->in_db[$uid][$cat][$k] = true;
} }
} else if ($cat != 'config') { } else if ($cat != 'config') {
// Negative caching // Negative caching
PConfig::setPConfigValue($uid, $cat, null, "!<unset>!"); $this->config->setP($uid, $cat, null, "!<unset>!");
} }
DBA::close($pconfigs); DBA::close($pconfigs);
} }
@ -37,17 +50,17 @@ class JITPConfigAdapter implements IPConfigAdapter
{ {
if (!$refresh) { if (!$refresh) {
// Looking if the whole family isn't set // Looking if the whole family isn't set
if (PConfig::getPConfigValue($uid, $cat) !== null) { if ($this->config->getP($uid, $cat) !== null) {
if (PConfig::getPConfigValue($uid, $cat) === '!<unset>!') { if ($this->config->getP($uid, $cat) === '!<unset>!') {
return $default_value; return $default_value;
} }
} }
if (PConfig::getPConfigValue($uid, $cat, $k) !== null) { if ($this->config->getP($uid, $cat, $k) !== null) {
if (PConfig::getPConfigValue($uid, $cat, $k) === '!<unset>!') { if ($this->config->getP($uid, $cat, $k) === '!<unset>!') {
return $default_value; return $default_value;
} }
return PConfig::getPConfigValue($uid, $cat, $k); return $this->config->getP($uid, $cat, $k);
} }
} }
@ -55,13 +68,13 @@ class JITPConfigAdapter implements IPConfigAdapter
if (DBA::isResult($pconfig)) { if (DBA::isResult($pconfig)) {
$val = (preg_match("|^a:[0-9]+:{.*}$|s", $pconfig['v']) ? unserialize($pconfig['v']) : $pconfig['v']); $val = (preg_match("|^a:[0-9]+:{.*}$|s", $pconfig['v']) ? unserialize($pconfig['v']) : $pconfig['v']);
PConfig::setPConfigValue($uid, $cat, $k, $val); $this->config->setP($uid, $cat, $k, $val);
$this->in_db[$uid][$cat][$k] = true; $this->in_db[$uid][$cat][$k] = true;
return $val; return $val;
} else { } else {
PConfig::setPConfigValue($uid, $cat, $k, '!<unset>!'); $this->config->setP($uid, $cat, $k, '!<unset>!');
$this->in_db[$uid][$cat][$k] = false; $this->in_db[$uid][$cat][$k] = false;
@ -82,7 +95,7 @@ class JITPConfigAdapter implements IPConfigAdapter
return true; return true;
} }
PConfig::setPConfigValue($uid, $cat, $k, $value); $this->config->setP($uid, $cat, $k, $value);
// manage array value // manage array value
$dbvalue = (is_array($value) ? serialize($value) : $dbvalue); $dbvalue = (is_array($value) ? serialize($value) : $dbvalue);
@ -98,7 +111,7 @@ class JITPConfigAdapter implements IPConfigAdapter
public function delete($uid, $cat, $k) public function delete($uid, $cat, $k)
{ {
PConfig::deletePConfigValue($uid, $cat, $k); $this->config->deleteP($uid, $cat, $k);
if (!empty($this->in_db[$uid][$cat][$k])) { if (!empty($this->in_db[$uid][$cat][$k])) {
unset($this->in_db[$uid][$cat][$k]); unset($this->in_db[$uid][$cat][$k]);

24
src/Core/Config/PreloadConfigAdapter.php
View file

@ -3,7 +3,6 @@
namespace Friendica\Core\Config; namespace Friendica\Core\Config;
use Exception; use Exception;
use Friendica\Core\Config;
use Friendica\Database\DBA; use Friendica\Database\DBA;
/** /**
@ -17,8 +16,17 @@ class PreloadConfigAdapter implements IConfigAdapter
{ {
private $config_loaded = false; private $config_loaded = false;
public function __construct() /**
* @var IConfigCache The config cache of this driver
*/
private $config;
/**
* @param IConfigCache $config The config cache of this driver
*/
public function __construct($config)
{ {
$this->config = $config;
$this->load(); $this->load();
} }
@ -30,7 +38,7 @@ class PreloadConfigAdapter implements IConfigAdapter
$configs = DBA::select('config', ['cat', 'v', 'k']); $configs = DBA::select('config', ['cat', 'v', 'k']);
while ($config = DBA::fetch($configs)) { while ($config = DBA::fetch($configs)) {
Config::setConfigValue($config['cat'], $config['k'], $config['v']); $this->config->set($config['cat'], $config['k'], $config['v']);
} }
DBA::close($configs); DBA::close($configs);
@ -42,11 +50,11 @@ class PreloadConfigAdapter implements IConfigAdapter
if ($refresh) { if ($refresh) {
$config = DBA::selectFirst('config', ['v'], ['cat' => $cat, 'k' => $k]); $config = DBA::selectFirst('config', ['v'], ['cat' => $cat, 'k' => $k]);
if (DBA::isResult($config)) { if (DBA::isResult($config)) {
Config::setConfigValue($cat, $k, $config['v']); $this->config->set($cat, $k, $config['v']);
} }
} }
$return = Config::getConfigValue($cat, $k, $default_value); $return = $this->config->get($cat, $k, $default_value);
return $return; return $return;
} }
@ -58,11 +66,11 @@ class PreloadConfigAdapter implements IConfigAdapter
// The exception are array values. // The exception are array values.
$compare_value = !is_array($value) ? (string)$value : $value; $compare_value = !is_array($value) ? (string)$value : $value;
if (Config::getConfigValue($cat, $k) === $compare_value) { if ($this->config->get($cat, $k) === $compare_value) {
return true; return true;
} }
Config::setConfigValue($cat, $k, $value); $this->config->set($cat, $k, $value);
// manage array value // manage array value
$dbvalue = is_array($value) ? serialize($value) : $value; $dbvalue = is_array($value) ? serialize($value) : $value;
@ -77,7 +85,7 @@ class PreloadConfigAdapter implements IConfigAdapter
public function delete($cat, $k) public function delete($cat, $k)
{ {
Config::deleteConfigValue($cat, $k); $this->config->delete($cat, $k);
$result = DBA::delete('config', ['cat' => $cat, 'k' => $k]); $result = DBA::delete('config', ['cat' => $cat, 'k' => $k]);

30
src/Core/Config/PreloadPConfigAdapter.php
View file

@ -3,7 +3,6 @@
namespace Friendica\Core\Config; namespace Friendica\Core\Config;
use Exception; use Exception;
use Friendica\Core\PConfig;
use Friendica\Database\DBA; use Friendica\Database\DBA;
/** /**
@ -17,8 +16,19 @@ class PreloadPConfigAdapter implements IPConfigAdapter
{ {
private $config_loaded = false; private $config_loaded = false;
public function __construct($uid) /**
* The config cache of this adapter
* @var IPConfigCache
*/
private $config;
/**
* @param int $uid The UID of the current user
* @param IPConfigCache $config The config cache of this adapter
*/
public function __construct($uid, $config)
{ {
$this->config = $config;
$this->load($uid, 'config'); $this->load($uid, 'config');
} }
@ -34,7 +44,7 @@ class PreloadPConfigAdapter implements IPConfigAdapter
$pconfigs = DBA::select('pconfig', ['cat', 'v', 'k'], ['uid' => $uid]); $pconfigs = DBA::select('pconfig', ['cat', 'v', 'k'], ['uid' => $uid]);
while ($pconfig = DBA::fetch($pconfigs)) { while ($pconfig = DBA::fetch($pconfigs)) {
PConfig::setPConfigValue($uid, $pconfig['cat'], $pconfig['k'], $pconfig['v']); $this->config->setP($uid, $pconfig['cat'], $pconfig['k'], $pconfig['v']);
} }
DBA::close($pconfigs); DBA::close($pconfigs);
@ -50,15 +60,13 @@ class PreloadPConfigAdapter implements IPConfigAdapter
if ($refresh) { if ($refresh) {
$config = DBA::selectFirst('pconfig', ['v'], ['uid' => $uid, 'cat' => $cat, 'k' => $k]); $config = DBA::selectFirst('pconfig', ['v'], ['uid' => $uid, 'cat' => $cat, 'k' => $k]);
if (DBA::isResult($config)) { if (DBA::isResult($config)) {
PConfig::setPConfigValue($uid, $cat, $k, $config['v']); $this->config->setP($uid, $cat, $k, $config['v']);
} else { } else {
PConfig::deletePConfigValue($uid, $cat, $k); $this->config->deleteP($uid, $cat, $k);
} }
} }
$return = PConfig::getPConfigValue($uid, $cat, $k, $default_value); return $this->config->getP($uid, $cat, $k, $default_value);;
return $return;
} }
public function set($uid, $cat, $k, $value) public function set($uid, $cat, $k, $value)
@ -71,11 +79,11 @@ class PreloadPConfigAdapter implements IPConfigAdapter
// The exception are array values. // The exception are array values.
$compare_value = !is_array($value) ? (string)$value : $value; $compare_value = !is_array($value) ? (string)$value : $value;
if (PConfig::getPConfigValue($uid, $cat, $k) === $compare_value) { if ($this->config->getP($uid, $cat, $k) === $compare_value) {
return true; return true;
} }
PConfig::setPConfigValue($uid, $cat, $k, $value); $this->config->setP($uid, $cat, $k, $value);
// manage array value // manage array value
$dbvalue = is_array($value) ? serialize($value) : $value; $dbvalue = is_array($value) ? serialize($value) : $value;
@ -94,7 +102,7 @@ class PreloadPConfigAdapter implements IPConfigAdapter
$this->load($uid, $cat); $this->load($uid, $cat);
} }
PConfig::deletePConfigValue($uid, $cat, $k); $this->config->deleteP($uid, $cat, $k);
$result = DBA::delete('pconfig', ['uid' => $uid, 'cat' => $cat, 'k' => $k]); $result = DBA::delete('pconfig', ['uid' => $uid, 'cat' => $cat, 'k' => $k]);

2
src/Core/Logger.php
View file

@ -5,8 +5,8 @@
namespace Friendica\Core; namespace Friendica\Core;
use Friendica\BaseObject; use Friendica\BaseObject;
use Friendica\Factory\LoggerFactory;
use Friendica\Network\HTTPException\InternalServerErrorException; use Friendica\Network\HTTPException\InternalServerErrorException;
use Friendica\Util\LoggerFactory;
use Psr\Log\LoggerInterface; use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel; use Psr\Log\LogLevel;

146
src/Core/PConfig.php
View file

@ -8,8 +8,7 @@
*/ */
namespace Friendica\Core; namespace Friendica\Core;
use Friendica\App; use Friendica\Core\Config\IPConfigCache;
use Friendica\BaseObject;
/** /**
* @brief Management of user configuration storage * @brief Management of user configuration storage
@ -18,29 +17,36 @@ use Friendica\BaseObject;
* The PConfig::get() functions return boolean false for keys that are unset, * The PConfig::get() functions return boolean false for keys that are unset,
* and this could lead to subtle bugs. * and this could lead to subtle bugs.
*/ */
class PConfig extends BaseObject class PConfig
{ {
private static $config;
/** /**
* @var \Friendica\Core\Config\IPConfigAdapter * @var \Friendica\Core\Config\IPConfigAdapter
*/ */
private static $adapter = null; private static $adapter;
public static function init($uid) /**
* @var IPConfigCache
*/
private static $config;
/**
* Initialize the config with only the cache
*
* @param IPConfigCache $config The configuration cache
*/
public static function init($config)
{ {
$a = self::getApp(); self::$config = $config;
}
// Database isn't ready or populated yet /**
if (!$a->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { * Add the adapter for DB-backend
return; *
} * @param $adapter
*/
if (Config::getConfigValue('system', 'config_adapter') == 'preload') { public static function setAdapter($adapter)
self::$adapter = new Config\PreloadPConfigAdapter($uid); {
} else { self::$adapter = $adapter;
self::$adapter = new Config\JITPConfigAdapter();
}
} }
/** /**
@ -57,15 +63,10 @@ class PConfig extends BaseObject
*/ */
public static function load($uid, $family) public static function load($uid, $family)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) {
return; return;
} }
if (empty(self::$adapter)) {
self::init($uid);
}
self::$adapter->load($uid, $family); self::$adapter->load($uid, $family);
} }
@ -83,17 +84,11 @@ class PConfig extends BaseObject
* @param boolean $refresh optional, If true the config is loaded from the db and not from the cache (default: false) * @param boolean $refresh optional, If true the config is loaded from the db and not from the cache (default: false)
* *
* @return mixed Stored value or null if it does not exist * @return mixed Stored value or null if it does not exist
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function get($uid, $family, $key, $default_value = null, $refresh = false) public static function get($uid, $family, $key, $default_value = null, $refresh = false)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { return self::$config->getP($uid, $family, $key, $default_value);
return;
}
if (empty(self::$adapter)) {
self::init($uid);
} }
return self::$adapter->get($uid, $family, $key, $default_value, $refresh); return self::$adapter->get($uid, $family, $key, $default_value, $refresh);
@ -113,17 +108,11 @@ class PConfig extends BaseObject
* @param mixed $value The value to store * @param mixed $value The value to store
* *
* @return bool Operation success * @return bool Operation success
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/ */
public static function set($uid, $family, $key, $value) public static function set($uid, $family, $key, $value)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { return self::$config->setP($uid, $family, $key, $value);
return false;
}
if (empty(self::$adapter)) {
self::init($uid);
} }
return self::$adapter->set($uid, $family, $key, $value); return self::$adapter->set($uid, $family, $key, $value);
@ -144,83 +133,10 @@ class PConfig extends BaseObject
*/ */
public static function delete($uid, $family, $key) public static function delete($uid, $family, $key)
{ {
// Database isn't ready or populated yet if (!isset(self::$adapter)) {
if (!self::getApp()->getMode()->has(App\Mode::DBCONFIGAVAILABLE)) { return self::$config->deleteP($uid, $family, $key);
return false;
}
if (empty(self::$adapter)) {
self::init($uid);
} }
return self::$adapter->delete($uid, $family, $key); return self::$adapter->delete($uid, $family, $key);
} }
/**
* Retrieves a value from the user config cache
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $k Config key
* @param mixed $default Default value if key isn't set
*
* @return string The value of the config entry
*/
public static function getPConfigValue($uid, $cat, $k = null, $default = null)
{
$return = $default;
if (isset(self::$config[$uid][$cat][$k])) {
$return = self::$config[$uid][$cat][$k];
} elseif ($k == null && isset(self::$config[$uid][$cat])) {
$return = self::$config[$uid][$cat];
}
return $return;
}
/**
* Sets a value in the user config cache
*
* Accepts raw output from the pconfig table
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $k Config key
* @param mixed $v Value to set
*/
public static function setPConfigValue($uid, $cat, $k, $v)
{
// Only arrays are serialized in database, so we have to unserialize sparingly
$value = is_string($v) && preg_match("|^a:[0-9]+:{.*}$|s", $v) ? unserialize($v) : $v;
if (!isset(self::$config[$uid]) || !is_array(self::$config[$uid])) {
self::$config[$uid] = [];
}
if (!isset(self::$config[$uid][$cat]) || !is_array(self::$config[$uid][$cat])) {
self::$config[$uid][$cat] = [];
}
if ($k === null) {
self::$config[$uid][$cat] = $value;
} else {
self::$config[$uid][$cat][$k] = $value;
}
}
/**
* Deletes a value from the user config cache
*
* @param int $uid User Id
* @param string $cat Config category
* @param string $k Config key
*/
public static function deletePConfigValue($uid, $cat, $k)
{
if (isset(self::$config[$uid][$cat][$k])) {
unset(self::$config[$uid][$cat][$k]);
}
}
} }

17
src/Core/System.php
View file

@ -286,6 +286,23 @@ class System extends BaseObject
exit(); exit();
} }
/**
* @brief Returns the system user that is executing the script
*
* This mostly returns something like "www-data".
*
* @return string system username
*/
public static function getUser()
{
if (!function_exists('posix_getpwuid') || !function_exists('posix_geteuid')) {
return '';
}
$processUser = posix_getpwuid(posix_geteuid());
return $processUser['name'];
}
/// @todo Move the following functions from boot.php /// @todo Move the following functions from boot.php
/* /*
function killme() function killme()

36
src/Database/DBA.php
View file

@ -2,9 +2,7 @@
namespace Friendica\Database; namespace Friendica\Database;
// Do not use native get/set/load of Core\Config in this class at risk of infinite loop. use Friendica\Core\Config\ConfigCache;
// Please use Core\Config::getConfigVariable() instead.
use Friendica\Core\Config;
use Friendica\Core\Logger; use Friendica\Core\Logger;
use Friendica\Core\System; use Friendica\Core\System;
use Friendica\Util\DateTimeFormat; use Friendica\Util\DateTimeFormat;
@ -33,6 +31,10 @@ class DBA
public static $connected = false; public static $connected = false;
/**
* @var ConfigCache
*/
private static $config;
private static $server_info = ''; private static $server_info = '';
private static $connection; private static $connection;
private static $driver; private static $driver;
@ -48,13 +50,14 @@ class DBA
private static $db_name = ''; private static $db_name = '';
private static $db_charset = ''; private static $db_charset = '';
public static function connect($serveraddr, $user, $pass, $db, $charset = null) public static function connect($config, $serveraddr, $user, $pass, $db, $charset = null)
{ {
if (!is_null(self::$connection) && self::connected()) { if (!is_null(self::$connection) && self::connected()) {
return true; return true;
} }
// We are storing these values for being able to perform a reconnect // We are storing these values for being able to perform a reconnect
self::$config = $config;
self::$db_serveraddr = $serveraddr; self::$db_serveraddr = $serveraddr;
self::$db_user = $user; self::$db_user = $user;
self::$db_pass = $pass; self::$db_pass = $pass;
@ -155,7 +158,7 @@ class DBA
public static function reconnect() { public static function reconnect() {
self::disconnect(); self::disconnect();
$ret = self::connect(self::$db_serveraddr, self::$db_user, self::$db_pass, self::$db_name, self::$db_charset); $ret = self::connect(self::$config, self::$db_serveraddr, self::$db_user, self::$db_pass, self::$db_name, self::$db_charset);
return $ret; return $ret;
} }
@ -209,9 +212,8 @@ class DBA
* @throws \Exception * @throws \Exception
*/ */
private static function logIndex($query) { private static function logIndex($query) {
$a = \get_app();
if (!Config::getConfigValue('system', 'db_log_index')) { if (!self::$config->get('system', 'db_log_index')) {
return; return;
} }
@ -230,18 +232,18 @@ class DBA
return; return;
} }
$watchlist = explode(',', Config::getConfigValue('system', 'db_log_index_watch')); $watchlist = explode(',', self::$config->get('system', 'db_log_index_watch'));
$blacklist = explode(',', Config::getConfigValue('system', 'db_log_index_blacklist')); $blacklist = explode(',', self::$config->get('system', 'db_log_index_blacklist'));
while ($row = self::fetch($r)) { while ($row = self::fetch($r)) {
if ((intval(Config::getConfigValue('system', 'db_loglimit_index')) > 0)) { if ((intval(self::$config->get('system', 'db_loglimit_index')) > 0)) {
$log = (in_array($row['key'], $watchlist) && $log = (in_array($row['key'], $watchlist) &&
($row['rows'] >= intval(Config::getConfigValue('system', 'db_loglimit_index')))); ($row['rows'] >= intval(self::$config->get('system', 'db_loglimit_index'))));
} else { } else {
$log = false; $log = false;
} }
if ((intval(Config::getConfigValue('system', 'db_loglimit_index_high')) > 0) && ($row['rows'] >= intval($Config::getConfigValue('system', 'db_loglimit_index_high')))) { if ((intval(self::$config->get('system', 'db_loglimit_index_high')) > 0) && ($row['rows'] >= intval($Config::getConfigValue('system', 'db_loglimit_index_high')))) {
$log = true; $log = true;
} }
@ -251,7 +253,7 @@ class DBA
if ($log) { if ($log) {
$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
@file_put_contents(Config::getConfigValue('system', 'db_log_index'), DateTimeFormat::utcNow()."\t". @file_put_contents(self::$config->get('system', 'db_log_index'), DateTimeFormat::utcNow()."\t".
$row['key']."\t".$row['rows']."\t".$row['Extra']."\t". $row['key']."\t".$row['rows']."\t".$row['Extra']."\t".
basename($backtrace[1]["file"])."\t". basename($backtrace[1]["file"])."\t".
$backtrace[1]["line"]."\t".$backtrace[2]["function"]."\t". $backtrace[1]["line"]."\t".$backtrace[2]["function"]."\t".
@ -421,7 +423,7 @@ class DBA
$orig_sql = $sql; $orig_sql = $sql;
if (Config::getConfigValue('system', 'db_callstack')) { if (self::$config->get('system', 'db_callstack')) {
$sql = "/*".System::callstack()." */ ".$sql; $sql = "/*".System::callstack()." */ ".$sql;
} }
@ -582,15 +584,15 @@ class DBA
$a->saveTimestamp($stamp1, 'database'); $a->saveTimestamp($stamp1, 'database');
if (Config::getConfigValue('system', 'db_log')) { if (self::$config->get('system', 'db_log')) {
$stamp2 = microtime(true); $stamp2 = microtime(true);
$duration = (float)($stamp2 - $stamp1); $duration = (float)($stamp2 - $stamp1);
if (($duration > Config::getConfigValue('system', 'db_loglimit'))) { if (($duration > self::$config->get('system', 'db_loglimit'))) {
$duration = round($duration, 3); $duration = round($duration, 3);
$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
@file_put_contents(Config::getConfigValue('system', 'db_log'), DateTimeFormat::utcNow()."\t".$duration."\t". @file_put_contents(self::$config->get('system', 'db_log'), DateTimeFormat::utcNow()."\t".$duration."\t".
basename($backtrace[1]["file"])."\t". basename($backtrace[1]["file"])."\t".
$backtrace[1]["line"]."\t".$backtrace[2]["function"]."\t". $backtrace[1]["line"]."\t".$backtrace[2]["function"]."\t".
substr(self::replaceParameters($sql, $args), 0, 2000)."\n", FILE_APPEND); substr(self::replaceParameters($sql, $args), 0, 2000)."\n", FILE_APPEND);

5
src/Database/DBStructure.php
View file

@ -101,12 +101,11 @@ class DBStructure
* @return array * @return array
* @throws Exception * @throws Exception
*/ */
public static function definition($with_addons_structure = true) public static function definition($basepath, $with_addons_structure = true)
{ {
if (!self::$definition) { if (!self::$definition) {
$a = \Friendica\BaseObject::getApp();
$filename = $a->getBasePath() . '/config/dbstructure.config.php'; $filename = $basepath . '/config/dbstructure.config.php';
if (!is_readable($filename)) { if (!is_readable($filename)) {
throw new Exception('Missing database structure config file config/dbstructure.config.php'); throw new Exception('Missing database structure config file config/dbstructure.config.php');

45
src/Factory/ConfigFactory.php Normal file
View file

@ -0,0 +1,45 @@
<?php
namespace Friendica\Factory;
use Friendica\Core\Config;
class ConfigFactory
{
public static function createCache(Config\ConfigCacheLoader $loader)
{
$configCache = new Config\ConfigCache();
$loader->loadConfigFiles($configCache);
return $configCache;
}
/**
* @param string $type The adapter type
* @param Config\IConfigCache $config The config cache of this adapter
* @return Config\IConfigAdapter
*/
public static function createConfig($type, $config)
{
if ($type == 'preload') {
return new Config\PreloadConfigAdapter($config);
} else {
return new Config\JITConfigAdapter($config);
}
}
/**
* @param string $type The adapter type
* @param int $uid The UID of the current user
* @param Config\IPConfigCache $config The config cache of this adapter
* @return Config\IPConfigAdapter
*/
public static function createPConfig($type, $uid, $config)
{
if ($type == 'preload') {
return new Config\PreloadPConfigAdapter($uid, $config);
} else {
return new Config\JITPConfigAdapter($config);
}
}
}

18
src/Util/LoggerFactory.php → src/Factory/LoggerFactory.php
View file

@ -1,7 +1,8 @@
<?php <?php
namespace Friendica\Util; namespace Friendica\Factory;
use Friendica\Core\Config\ConfigCache;
use Friendica\Network\HTTPException\InternalServerErrorException; use Friendica\Network\HTTPException\InternalServerErrorException;
use Friendica\Util\Logger\FriendicaDevelopHandler; use Friendica\Util\Logger\FriendicaDevelopHandler;
use Friendica\Util\Logger\FriendicaIntrospectionProcessor; use Friendica\Util\Logger\FriendicaIntrospectionProcessor;
@ -19,11 +20,12 @@ class LoggerFactory
/** /**
* Creates a new PSR-3 compliant logger instances * Creates a new PSR-3 compliant logger instances
* *
* @param string $channel The channel of the logger instance * @param string $channel The channel of the logger instance
* @param ConfigCache $config The config
* *
* @return LoggerInterface The PSR-3 compliant logger instance * @return LoggerInterface The PSR-3 compliant logger instance
*/ */
public static function create($channel) public static function create($channel, $config = null)
{ {
$logger = new Monolog\Logger($channel); $logger = new Monolog\Logger($channel);
$logger->pushProcessor(new Monolog\Processor\PsrLogMessageProcessor()); $logger->pushProcessor(new Monolog\Processor\PsrLogMessageProcessor());
@ -31,6 +33,16 @@ class LoggerFactory
$logger->pushProcessor(new Monolog\Processor\UidProcessor()); $logger->pushProcessor(new Monolog\Processor\UidProcessor());
$logger->pushProcessor(new FriendicaIntrospectionProcessor(LogLevel::DEBUG, ['Friendica\\Core\\Logger'])); $logger->pushProcessor(new FriendicaIntrospectionProcessor(LogLevel::DEBUG, ['Friendica\\Core\\Logger']));
if (isset($config)) {
$debugging = $config->get('system', 'debugging');
$stream = $config->get('system', 'logfile');
$level = $config->get('system', 'loglevel');
if ($debugging) {
static::addStreamHandler($logger, $stream, $level);
}
}
return $logger; return $logger;
} }

2
src/LegacyModule.php
View file

@ -68,7 +68,7 @@ class LegacyModule extends BaseModule
if (\function_exists($function_name)) { if (\function_exists($function_name)) {
$a = self::getApp(); $a = self::getApp();
return $function_name($a); return $function_name($a, $a->getConfig());
} else { } else {
return parent::{$function_suffix}(); return parent::{$function_suffix}();
} }

93
src/Util/BasePath.php Normal file
View file

@ -0,0 +1,93 @@
<?php
namespace Friendica\Util;
use Friendica\Core;
class BasePath
{
/**
* @brief Returns the base filesystem path of the App
*
* It first checks for the internal variable, then for DOCUMENT_ROOT and
* finally for PWD
*
* @param string|null $basepath
*
* @return string
*
* @throws \Exception if directory isn't usable
*/
public static function create($basepath)
{
if (!$basepath && !empty($_SERVER['DOCUMENT_ROOT'])) {
$basepath = $_SERVER['DOCUMENT_ROOT'];
}
if (!$basepath && !empty($_SERVER['PWD'])) {
$basepath = $_SERVER['PWD'];
}
return self::getRealPath($basepath);
}
/**
* @brief Returns a normalized file path
*
* This is a wrapper for the "realpath" function.
* That function cannot detect the real path when some folders aren't readable.
* Since this could happen with some hosters we need to handle this.
*
* @param string $path The path that is about to be normalized
* @return string normalized path - when possible
*/
public static function getRealPath($path)
{
$normalized = realpath($path);
if (!is_bool($normalized)) {
return $normalized;
} else {
return $path;
}
}
/**
* @brief Checks if a given directory is usable for the system
*
* @param $directory
* @param bool $check_writable
*
* @return boolean the directory is usable
*/
public static function isDirectoryUsable($directory, $check_writable = true)
{
if ($directory == '') {
Core\Logger::log('Directory is empty. This shouldn\'t happen.', Core\Logger::DEBUG);
return false;
}
if (!file_exists($directory)) {
Core\Logger::log('Path "' . $directory . '" does not exist for user ' . Core\System::getUser(), Core\Logger::DEBUG);
return false;
}
if (is_file($directory)) {
Core\Logger::log('Path "' . $directory . '" is a file for user ' . Core\System::getUser(), Core\Logger::DEBUG);
return false;
}
if (!is_dir($directory)) {
Core\Logger::log('Path "' . $directory . '" is not a directory for user ' . Core\System::getUser(), Core\Logger::DEBUG);
return false;
}
if ($check_writable && !is_writable($directory)) {
Core\Logger::log('Path "' . $directory . '" is not writable for user ' . Core\System::getUser(), Core\Logger::DEBUG);
return false;
}
return true;
}
}