bitPickups/friendica_2020-09-1_sharedHosting
1
0
Fork 0
Code Pull requests Activity

Merge remote-tracking branch 'upstream/develop' into diaspora-item

Browse source
This commit is contained in:
Michael 2023-01-07 19:52:23 +00:00
parent d86045058e f37edc06e1
commit 24c32cff0d
99 changed files with 2750 additions and 2500 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
bin/auth_ejabberd.php
View file

@ -82,6 +82,10 @@ $dice = $dice->addRule(LoggerInterface::class,['constructParams' => ['auth_ejabb
\Friendica\DI::init($dice);
\Friendica\Core\Logger\Handler\ErrorHandler::register($dice->create(\Psr\Log\LoggerInterface::class));
// Check the database structure and possibly fixes it
\Friendica\Core\Update::check(\Friendica\DI::basePath(), true);
$appMode = $dice->create(Mode::class);
if ($appMode->isNormal()) {

9
bin/daemon.php
View file

@ -33,6 +33,7 @@ if (php_sapi_name() !== 'cli') {
use Dice\Dice;
use Friendica\App\Mode;
use Friendica\Core\Logger;
use Friendica\Core\Update;
use Friendica\Core\Worker;
use Friendica\Database\DBA;
use Friendica\DI;
@ -63,7 +64,6 @@ $dice = $dice->addRule(LoggerInterface::class,['constructParams' => ['daemon']])
DI::init($dice);
\Friendica\Core\Logger\Handler\ErrorHandler::register($dice->create(\Psr\Log\LoggerInterface::class));
$a = DI::app();
if (DI::mode()->isInstall()) {
die("Friendica isn't properly installed yet.\n");
@ -71,7 +71,7 @@ if (DI::mode()->isInstall()) {
DI::mode()->setExecutor(Mode::DAEMON);
DI::config()->load();
DI::config()->reload();
if (empty(DI::config()->get('system', 'pidfile'))) {
die(<<<TXT
@ -126,7 +126,7 @@ if ($mode == 'status') {
unlink($pidfile);
DI::config()->set('system', 'worker_daemon_mode', false);
DI::keyValue()->set('worker_daemon_mode', false);
die("Daemon process $pid isn't running.\n");
}
@ -193,6 +193,9 @@ $last_cron = 0;
// Now running as a daemon.
while (true) {
// Check the database structure and possibly fixes it
Update::check(DI::basePath(), true);
if (!$do_cron && ($last_cron + $wait_interval) < time()) {
Logger::info('Forcing cron worker call.', ['pid' => $pid]);
$do_cron = true;

3
bin/worker.php
View file

@ -58,12 +58,11 @@ $dice = $dice->addRule(LoggerInterface::class,['constructParams' => ['worker']])
DI::init($dice);
\Friendica\Core\Logger\Handler\ErrorHandler::register($dice->create(\Psr\Log\LoggerInterface::class));
$a = DI::app();
DI::mode()->setExecutor(Mode::WORKER);
// Check the database structure and possibly fixes it
Update::check($a->getBasePath(), true, DI::mode());
Update::check(DI::basePath(), true);
// Quit when in maintenance
if (!DI::mode()->has(App\Mode::MAINTENANCEDISABLED)) {

14
database.sql
View file

@ -1,6 +1,6 @@
-- ------------------------------------------
-- Friendica 2023.03-dev (Giant Rhubarb)
-- DB_UPDATE_VERSION 1507
-- DB_UPDATE_VERSION 1509
-- ------------------------------------------
@ -494,18 +494,6 @@ CREATE TABLE IF NOT EXISTS `cache` (
INDEX `k_expires` (`k`,`expires`)
) DEFAULT COLLATE utf8mb4_general_ci COMMENT='Stores temporary data';
--
-- TABLE config
--
CREATE TABLE IF NOT EXISTS `config` (
`id` int unsigned NOT NULL auto_increment COMMENT '',
`cat` varbinary(50) NOT NULL DEFAULT '' COMMENT '',
`k` varbinary(50) NOT NULL DEFAULT '' COMMENT '',
`v` mediumtext COMMENT '',
PRIMARY KEY(`id`),
UNIQUE INDEX `cat_k` (`cat`,`k`)
) DEFAULT COLLATE utf8mb4_general_ci COMMENT='main configuration storage';
--
-- TABLE contact-relation
--

1
doc/database.md
View file

@ -18,7 +18,6 @@ Database Tables
| [arrived-activity](help/database/db_arrived-activity) | Id of arrived activities |
| [attach](help/database/db_attach) | file attachments |
| [cache](help/database/db_cache) | Stores temporary data |
| [config](help/database/db_config) | main configuration storage |
| [contact](help/database/db_contact) | contact table |
| [contact-relation](help/database/db_contact-relation) | Contact relations |
| [conv](help/database/db_conv) | private messages |

25
doc/database/db_config.md
View file

@ -1,25 +0,0 @@
Table config
===========
main configuration storage
Fields
------
| Field | Description | Type | Null | Key | Default | Extra |
| ----- | ----------- | ------------- | ---- | --- | ------- | -------------- |
| id | | int unsigned | NO | PRI | NULL | auto_increment |
| cat | | varbinary(50) | NO | | | |
| k | | varbinary(50) | NO | | | |
| v | | mediumtext | YES | | NULL | |
Indexes
------------
| Name | Fields |
| ------- | -------------- |
| PRIMARY | id |
| cat_k | UNIQUE, cat, k |
Return to [database documentation](help/database)

49
mod/item.php
View file

@ -49,7 +49,7 @@ use Friendica\Util\DateTimeFormat;
function item_post(App $a) {
$uid = DI::userSession()->getLocalUserId();
if (!DI::userSession()->isAuthenticated() || !$uid) {
if (!$uid) {
throw new HTTPException\ForbiddenException();
}
@ -68,11 +68,11 @@ function item_post(App $a) {
* after it's been previewed
*/
if (!$preview && !empty($_REQUEST['post_id_random'])) {
if (!empty($_SESSION['post-random']) && $_SESSION['post-random'] == $_REQUEST['post_id_random']) {
if (DI::session()->get('post-random') == $_REQUEST['post_id_random']) {
Logger::warning('duplicate post');
item_post_return(DI::baseUrl(), $return_path);
} else {
$_SESSION['post-random'] = $_REQUEST['post_id_random'];
DI::session()->set('post-random', $_REQUEST['post_id_random']);
}
}
@ -90,16 +90,15 @@ function item_drop(int $uid, string $dropitems)
Item::deleteForUser(['id' => $item], $uid);
}
$json = ['success' => 1];
System::jsonExit($json);
System::jsonExit(['success' => 1]);
}
function item_edit(int $uid, array $request, bool $preview, string $return_path)
{
$post = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $request['post_id'], 'uid' => $uid]);
if (!DBA::isResult($post)) {
DI::sysmsg()->addNotice(DI::l10n()->t('Unable to locate original post.'));
if ($return_path) {
DI::sysmsg()->addNotice(DI::l10n()->t('Unable to locate original post.'));
DI::baseUrl()->redirect($return_path);
}
throw new HTTPException\NotFoundException(DI::l10n()->t('Unable to locate original post.'));
@ -141,15 +140,12 @@ function item_edit(int $uid, array $request, bool $preview, string $return_path)
function item_insert(int $uid, array $request, bool $preview, string $return_path)
{
$emailcc = trim($request['emailcc'] ?? '');
$post = ['uid' => $uid];
$post = DI::contentItem()->initializePost($post);
$post['edit'] = null;
$post['post-type'] = $request['post_type'] ?? '';
$post['wall'] = $request['wall'] ?? true;
$post['parent'] = intval($request['parent'] ?? 0);
$post['pubmail'] = $request['pubmail_enable'] ?? false;
$post['created'] = $request['created_at'] ?? DateTimeFormat::utcNow();
$post['edited'] = $post['changed'] = $post['commented'] = $post['created'];
@ -158,25 +154,20 @@ function item_insert(int $uid, array $request, bool $preview, string $return_pat
$post['postopts'] = '';
$post['file'] = '';
if ($post['parent']) {
if ($post['parent']) {
$parent_item = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $post['parent']]);
}
if (!empty($request['parent'])) {
$parent_item = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $request['parent']]);
if ($parent_item) {
// if this isn't the top-level parent of the conversation, find it
if (DBA::isResult($parent_item)) {
// The URI and the contact is taken from the direct parent which needn't to be the top parent
$post['thr-parent'] = $parent_item['uri'];
$toplevel_item = $parent_item;
if ($parent_item['gravity'] != Item::GRAVITY_PARENT) {
$toplevel_item = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $toplevel_item['parent']]);
$toplevel_item = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $parent_item['parent']]);
} else {
$toplevel_item = $parent_item;
}
}
if (!DBA::isResult($toplevel_item)) {
DI::sysmsg()->addNotice(DI::l10n()->t('Unable to locate original post.'));
if (empty($toplevel_item)) {
if ($return_path) {
DI::sysmsg()->addNotice(DI::l10n()->t('Unable to locate original post.'));
DI::baseUrl()->redirect($return_path);
}
throw new HTTPException\NotFoundException(DI::l10n()->t('Unable to locate original post.'));
@ -187,17 +178,13 @@ function item_insert(int $uid, array $request, bool $preview, string $return_pat
if ($toplevel_item['uid'] == 0) {
$stored = Item::storeForUserByUriId($toplevel_item['uri-id'], $post['uid'], ['post-reason' => Item::PR_ACTIVITY]);
Logger::info('Public item stored for user', ['uri-id' => $toplevel_item['uri-id'], 'uid' => $post['uid'], 'stored' => $stored]);
if ($stored) {
$toplevel_item = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $stored]);
}
}
$post['parent'] = $toplevel_item['id'];
$post['gravity'] = Item::GRAVITY_COMMENT;
$post['thr-parent'] = $parent_item['uri'];
$post['wall'] = $toplevel_item['wall'];
} else {
$parent_item = [];
$post['parent'] = 0;
$post['gravity'] = Item::GRAVITY_PARENT;
$post['thr-parent'] = $post['uri'];
}
@ -210,8 +197,8 @@ function item_insert(int $uid, array $request, bool $preview, string $return_pat
$post_id = Item::insert($post);
if (!$post_id) {
DI::sysmsg()->addNotice(DI::l10n()->t('Item wasn\'t stored.'));
if ($return_path) {
DI::sysmsg()->addNotice(DI::l10n()->t('Item wasn\'t stored.'));
DI::baseUrl()->redirect($return_path);
}
@ -219,7 +206,7 @@ function item_insert(int $uid, array $request, bool $preview, string $return_pat
}
$post = Post::selectFirst(Item::ITEM_FIELDLIST, ['id' => $post_id]);
if (!DBA::isResult($post)) {
if (!$post) {
Logger::error('Item couldn\'t be fetched.', ['post_id' => $post_id]);
if ($return_path) {
DI::baseUrl()->redirect($return_path);
@ -228,7 +215,7 @@ function item_insert(int $uid, array $request, bool $preview, string $return_pat
throw new HTTPException\InternalServerErrorException(DI::l10n()->t('Item couldn\'t be fetched.'));
}
$recipients = explode(',', $emailcc);
$recipients = explode(',', $request['emailcc'] ?? '');
DI::contentItem()->postProcessPost($post, $recipients);
@ -270,8 +257,8 @@ function item_process(array $post, array $request, bool $preview, string $return
System::jsonExit(['preview' => '']);
}
DI::sysmsg()->addNotice(DI::l10n()->t('Empty post discarded.'));
if ($return_path) {
DI::sysmsg()->addNotice(DI::l10n()->t('Empty post discarded.'));
DI::baseUrl()->redirect($return_path);
}

128
mod/oexchange.php
View file

@ -1,128 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
use Friendica\App;
use Friendica\Content\Text\BBCode;
use Friendica\Content\Text\HTML;
use Friendica\Core\System;
use Friendica\DI;
use Friendica\Module\Response;
use Friendica\Module\Security\Login;
use Friendica\Util\XML;
function oexchange_init(App $a)
{
if ((DI::args()->getArgc() <= 1) || (DI::args()->getArgv()[1] != 'xrd')) {
return;
}
$baseURL = DI::baseUrl()->get();
$xml = null;
XML::fromArray([
'XRD' => [
'@attributes' => [
'xmlns' => 'http://docs.oasis-open.org/ns/xri/xrd-1.0',
],
'Subject' => $baseURL,
'1:Property' => [
'@attributes' => [
'type' => 'http://www.oexchange.org/spec/0.8/prop/vendor',
],
'Friendica'
],
'2:Property' => [
'@attributes' => [
'type' => 'http://www.oexchange.org/spec/0.8/prop/title',
],
'Friendica Social Network'
],
'3:Property' => [
'@attributes' => [
'type' => 'http://www.oexchange.org/spec/0.8/prop/name',
],
'Friendica'
],
'4:Property' => [
'@attributes' => [
'type' => 'http://www.oexchange.org/spec/0.8/prop/prompt',
],
'Send to Friendica'
],
'1:link' => [
'@attributes' => [
'rel' => 'icon',
'type' => 'image/png',
'href' => $baseURL . '/images/friendica-16.png'
]
],
'2:link' => [
'@attributes' => [
'rel' => 'icon32',
'type' => 'image/png',
'href' => $baseURL . '/images/friendica-32.png'
]
],
'3:link' => [
'@attributes' => [
'rel' => 'http://www.oexchange.org/spec/0.8/rel/offer',
'type' => 'text/html',
'href' => $baseURL . '/oexchange'
]
],
],
], $xml);
System::httpExit($xml->saveXML(), Response::TYPE_XML, 'application/xrd+xml');
}
function oexchange_content(App $a)
{
if (!DI::userSession()->getLocalUserId()) {
$o = Login::form();
return $o;
}
if ((DI::args()->getArgc() > 1) && DI::args()->getArgv()[1] === 'done') {
return;
}
$url = !empty($_REQUEST['url']) ? trim($_REQUEST['url']) : '';
$title = !empty($_REQUEST['title']) ? trim($_REQUEST['title']) : '';
$description = !empty($_REQUEST['description']) ? trim($_REQUEST['description']) : '';
$tags = !empty($_REQUEST['tags']) ? trim($_REQUEST['tags']) : '';
$s = BBCode::embedURL($url, true, $title, $description, $tags);
if (!strlen($s)) {
return;
}
$post = [];
$post['return'] = '/oexchange/done';
$post['body'] = HTML::toBBCode($s);
$_REQUEST = $post;
require_once 'mod/item.php';
item_post($a);
}

10
mod/photos.php
View file

@ -937,11 +937,17 @@ function photos_content(App $a)
$nxt = null;
foreach ($prvnxt as $z => $entry) {
if ($entry['resource-id'] == $ph[0]['resource-id']) {
$prv = $z - 1;
$nxt = $z + 1;
$prv = $order_field === 'created' ? $z - 1 : $z + 1;
$nxt = $order_field === 'created' ? $z + 1 : $z - 1;
if ($prv < 0) {
$prv = count($prvnxt) - 1;
}
if ($nxt < 0) {
$nxt = count($prvnxt) - 1;
}
if ($prv >= count($prvnxt)) {
$prv = 0;
}
if ($nxt >= count($prvnxt)) {
$nxt = 0;
}

2
mod/update_contact.php
View file

@ -30,7 +30,7 @@ use Friendica\Model\Contact;
function update_contact_content(App $a)
{
if (!empty(DI::args()->get(1)) && (!empty($_GET['force']) || !DI::pConfig()->get(DI::userSession()->getLocalUserId(), 'system', 'no_auto_update'))) {
if (!empty(DI::args()->get(1)) && !empty($_GET['force'])) {
$contact = Contact::getById(DI::args()->get(1), ['id', 'deleted']);
if (DBA::isResult($contact) && empty($contact['deleted'])) {
DI::page()['aside'] = '';

7
src/App.php
View file

@ -296,8 +296,7 @@ class App
*/
public function getBasePath(): string
{
// Don't use the basepath of the config table for basepath (it should always be the config-file one)
return $this->config->getCache()->get('system', 'basepath');
return $this->config->get('system', 'basepath');
}
/**
@ -360,7 +359,7 @@ class App
$this->profiler->update($this->config);
Core\Hook::loadHooks();
$loader = (new Config())->createConfigFileLoader($this->getBasePath(), $_SERVER);
$loader = (new Config())->createConfigFileManager($this->getBasePath(), $_SERVER);
Core\Hook::callAll('load_config', $loader);
// Hooks are now working, reload the whole definitions with hook enabled
@ -660,7 +659,7 @@ class App
$this->baseURL->redirect('install');
} else {
$this->checkURL();
Core\Update::check($this->getBasePath(), false, $this->mode);
Core\Update::check($this->getBasePath(), false);
Core\Addon::loadAddons();
Core\Hook::loadHooks();
}

41
src/App/BaseURL.php
View file

@ -172,53 +172,32 @@ class BaseURL
*/
public function save($hostname = null, $sslPolicy = null, $urlPath = null): bool
{
$currHostname = $this->hostname;
$currSSLPolicy = $this->sslPolicy;
$currURLPath = $this->urlPath;
$currUrl = $this->url;
$configTransaction = $this->config->beginTransaction();
if (!empty($hostname) && $hostname !== $this->hostname) {
if ($this->config->set('config', 'hostname', $hostname)) {
$configTransaction->set('config', 'hostname', $hostname);
$this->hostname = $hostname;
} else {
return false;
}
}
if (isset($sslPolicy) && $sslPolicy !== $this->sslPolicy) {
if ($this->config->set('system', 'ssl_policy', $sslPolicy)) {
$configTransaction->set('system', 'ssl_policy', $sslPolicy);
$this->sslPolicy = $sslPolicy;
} else {
$this->hostname = $currHostname;
$this->config->set('config', 'hostname', $this->hostname);
return false;
}
}
if (isset($urlPath) && $urlPath !== $this->urlPath) {
if ($this->config->set('system', 'urlpath', $urlPath)) {
$configTransaction->set('system', 'urlpath', $urlPath);
$this->urlPath = $urlPath;
} else {
$this->hostname = $currHostname;
$this->sslPolicy = $currSSLPolicy;
$this->config->set('config', 'hostname', $this->hostname);
$this->config->set('system', 'ssl_policy', $this->sslPolicy);
return false;
}
}
$this->determineBaseUrl();
if (!$this->config->set('system', 'url', $this->url)) {
$this->hostname = $currHostname;
$this->sslPolicy = $currSSLPolicy;
$this->urlPath = $currURLPath;
$this->determineBaseUrl();
$this->config->set('config', 'hostname', $this->hostname);
$this->config->set('system', 'ssl_policy', $this->sslPolicy);
$this->config->set('system', 'urlpath', $this->urlPath);
return false;
if ($this->url !== $currUrl) {
$configTransaction->set('system', 'url', $this->url);
}
$configTransaction->commit();
return true;
}

16
src/App/Mode.php
View file

@ -149,16 +149,7 @@ class Mode
$mode |= Mode::DBAVAILABLE;
if ($database->fetchFirst("SHOW TABLES LIKE 'config'") === false) {
return new Mode($mode);
}
$mode |= Mode::DBCONFIGAVAILABLE;
if (!empty($configCache->get('system', 'maintenance')) ||
// Don't use Config or Configuration here because we're possibly BEFORE initializing the Configuration,
// so this could lead to a dependency circle
!empty($database->selectFirst('config', ['v'], ['cat' => 'system', 'k' => 'maintenance'])['v'])) {
if (!empty($configCache->get('system', 'maintenance'))) {
return new Mode($mode);
}
@ -232,14 +223,14 @@ class Mode
}
/**
* Install mode is when the local config file is missing or the DB schema hasn't been installed yet.
* Install mode is when the local config file is missing or the database isn't available.
*
* @return bool Whether installation mode is active (local/database configuration files present or not)
*/
public function isInstall(): bool
{
return !$this->has(Mode::LOCALCONFIGPRESENT) ||
!$this->has(MODE::DBCONFIGAVAILABLE);
!$this->has(MODE::DBAVAILABLE);
}
/**
@ -251,7 +242,6 @@ class Mode
{
return $this->has(Mode::LOCALCONFIGPRESENT) &&
$this->has(Mode::DBAVAILABLE) &&
$this->has(Mode::DBCONFIGAVAILABLE) &&
$this->has(Mode::MAINTENANCEDISABLED);
}

2
src/Console/Cache.php
View file

@ -99,7 +99,7 @@ HELP;
$this->out('Options: ' . var_export($this->options, true));
}
if (!$this->appMode->has(App\Mode::DBCONFIGAVAILABLE)) {
if (!$this->appMode->has(App\Mode::DBAVAILABLE)) {
$this->out('Database isn\'t ready or populated yet, database cache won\'t be available');
}

12
src/Console/Config.php
View file

@ -115,10 +115,6 @@ HELP;
throw new CommandArgsException('Too many arguments');
}
if (!$this->appMode->has(App\Mode::DBCONFIGAVAILABLE)) {
$this->out('Database isn\'t ready or populated yet, showing file config only');
}
if (count($this->args) == 3) {
$cat = $this->getArgument(0);
$key = $this->getArgument(1);
@ -157,7 +153,7 @@ HELP;
if (count($this->args) == 1) {
$cat = $this->getArgument(0);
$this->config->load($cat);
$this->config->reload();
$configCache = $this->config->getCache();
if ($configCache->get($cat) !== null) {
@ -178,11 +174,7 @@ HELP;
}
if (count($this->args) == 0) {
$this->config->load();
if ($this->config->get('system', 'config_adapter') == 'jit' && $this->appMode->has(App\Mode::DBCONFIGAVAILABLE)) {
$this->out('Warning: The JIT (Just In Time) Config adapter doesn\'t support loading the entire configuration, showing file config only');
}
$this->config->reload();
$config = $this->config->getCache()->getAll();
foreach ($config as $cat => $section) {

2
src/Console/Lock.php
View file

@ -93,7 +93,7 @@ HELP;
$this->out('Options: ' . var_export($this->options, true));
}
if (!$this->appMode->has(App\Mode::DBCONFIGAVAILABLE)) {
if (!$this->appMode->has(App\Mode::DBAVAILABLE)) {
$this->out('Database isn\'t ready or populated yet, database cache won\'t be available');
}

10
src/Console/Maintenance.php
View file

@ -100,16 +100,20 @@ HELP;
$enabled = intval($this->getArgument(0));
$this->config->set('system', 'maintenance', $enabled);
$transactionConfig = $this->config->beginTransaction();
$transactionConfig->set('system', 'maintenance', $enabled);
$reason = $this->getArgument(1);
if ($enabled && $this->getArgument(1)) {
$this->config->set('system', 'maintenance_reason', $this->getArgument(1));
$transactionConfig->set('system', 'maintenance_reason', $this->getArgument(1));
} else {
$this->config->set('system', 'maintenance_reason', '');
$transactionConfig->delete('system', 'maintenance_reason');
}
$transactionConfig->commit();
if ($enabled) {
$mode_str = "maintenance mode";
} else {

13
src/Console/Relocate.php
View file

@ -101,9 +101,10 @@ HELP;
$old_host = str_replace('http://', '@', Strings::normaliseLink($old_url));
$this->out('Entering maintenance mode');
$this->config->set('system', 'maintenance', true);
$this->config->set('system', 'maintenance_reason', 'Relocating node to ' . $new_url);
$this->config->beginTransaction()
->set('system', 'maintenance', true)
->set('system', 'maintenance_reason', 'Relocating node to ' . $new_url)
->commit();
try {
if (!$this->database->transaction()) {
throw new \Exception('Unable to start a transaction, please retry later.');
@ -189,8 +190,10 @@ HELP;
return 1;
} finally {
$this->out('Leaving maintenance mode');
$this->config->set('system', 'maintenance', false);
$this->config->set('system', 'maintenance_reason', '');
$this->config->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
}
// send relocate

8
src/Content/Item.php
View file

@ -856,7 +856,7 @@ class Item
}
$user = User::getById($post['uid'], ['allow_cid', 'allow_gid', 'deny_cid', 'deny_gid']);
if (!DBA::isResult($user)) {
if (!$user) {
throw new HTTPException\NotFoundException($this->l10n->t('Unable to locate original post.'));
}
@ -876,7 +876,7 @@ class Item
$post['allow_cid'] .= $this->aclFormatter->toString(Contact::getPublicIdByUserId($post['uid']));
}
if (strlen($post['allow_gid']) || strlen($post['allow_cid']) || strlen($post['deny_gid']) || strlen($post['deny_cid'])) {
if ($post['allow_gid'] || $post['allow_cid'] || $post['deny_gid'] || $post['deny_cid']) {
$post['private'] = ItemModel::PRIVATE;
} elseif ($this->pConfig->get($post['uid'], 'system', 'unlisted')) {
$post['private'] = ItemModel::UNLISTED;
@ -898,7 +898,7 @@ class Item
if (empty($attachment)) {
continue;
}
if (strlen($post['attach'])) {
if ($post['attach']) {
$post['attach'] .= ',';
}
$post['attach'] .= Post\Media::getAttachElement($this->baseURL->get() . '/attach/' . $attachment['id'],
@ -1013,7 +1013,7 @@ class Item
foreach ($recipients as $recipient) {
$address = trim($recipient);
if (!strlen($address)) {
if (!$address) {
continue;
}

53
src/Core/Addon.php
View file

@ -21,7 +21,6 @@
namespace Friendica\Core;
use Friendica\Database\DBA;
use Friendica\DI;
use Friendica\Model\Contact;
use Friendica\Util\Strings;
@ -85,15 +84,19 @@ class Addon
public static function getAdminList()
{
$addons_admin = [];
$addonsAdminStmt = DBA::select('addon', ['name'], ['plugin_admin' => 1], ['order' => ['name']]);
while ($addon = DBA::fetch($addonsAdminStmt)) {
$addons_admin[$addon['name']] = [
'url' => 'admin/addons/' . $addon['name'],
'name' => $addon['name'],
$addons = DI::config()->get('addons');
ksort($addons);
foreach ($addons as $name => $data) {
if (empty($data['admin'])) {
continue;
}
$addons_admin[$name] = [
'url' => 'admin/addons/' . $name,
'name' => $name,
'class' => 'addon'
];
}
DBA::close($addonsAdminStmt);
return $addons_admin;
}
@ -113,8 +116,7 @@ class Addon
*/
public static function loadAddons()
{
$installed_addons = DBA::selectToArray('addon', ['name'], ['installed' => true]);
self::$addons = array_column($installed_addons, 'name');
self::$addons = array_keys(DI::config()->get('addons') ?? []);
}
/**
@ -129,7 +131,7 @@ class Addon
$addon = Strings::sanitizeFilePathItem($addon);
Logger::debug("Addon {addon}: {action}", ['action' => 'uninstall', 'addon' => $addon]);
DBA::delete('addon', ['name' => $addon]);
DI::config()->delete('addons', $addon);
@include_once('addon/' . $addon . '/' . $addon . '.php');
if (function_exists($addon . '_uninstall')) {
@ -168,12 +170,9 @@ class Addon
$func(DI::app());
}
DBA::insert('addon', [
'name' => $addon,
'installed' => true,
'timestamp' => $t,
'plugin_admin' => function_exists($addon . '_addon_admin'),
'hidden' => file_exists('addon/' . $addon . '/.hidden')
DI::config()->set('addons', $addon, [
'last_update' => $t,
'admin' => function_exists($addon . '_addon_admin'),
]);
if (!self::isEnabled($addon)) {
@ -190,20 +189,20 @@ class Addon
*/
public static function reload()
{
$addons = DBA::selectToArray('addon', [], ['installed' => true]);
$addons = DI::config()->get('addons');
foreach ($addons as $addon) {
$addonname = Strings::sanitizeFilePathItem(trim($addon['name']));
foreach ($addons as $name => $data) {
$addonname = Strings::sanitizeFilePathItem(trim($name));
$addon_file_path = 'addon/' . $addonname . '/' . $addonname . '.php';
if (file_exists($addon_file_path) && $addon['timestamp'] == filemtime($addon_file_path)) {
if (file_exists($addon_file_path) && $data['last_update'] == filemtime($addon_file_path)) {
// Addon unmodified, skipping
continue;
}
Logger::debug("Addon {addon}: {action}", ['action' => 'reload', 'addon' => $addon['name']]);
Logger::debug("Addon {addon}: {action}", ['action' => 'reload', 'addon' => $name]);
self::uninstall($addon['name']);
self::install($addon['name']);
self::uninstall($name);
self::install($name);
}
}
@ -313,11 +312,9 @@ class Addon
public static function getVisibleList(): array
{
$visible_addons = [];
$stmt = DBA::select('addon', ['name'], ['hidden' => false, 'installed' => true]);
if (DBA::isResult($stmt)) {
foreach (DBA::toArray($stmt) as $addon) {
$visible_addons[] = $addon['name'];
}
$addons = DI::config()->get('addons');
foreach ($addons as $name => $data) {
$visible_addons[] = $name;
}
return $visible_addons;

36
src/Core/Config/Capability/IManageConfigValues.php
View file

@ -22,6 +22,7 @@
namespace Friendica\Core\Config\Capability;
use Friendica\Core\Config\Exception\ConfigPersistenceException;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
/**
@ -30,36 +31,46 @@ use Friendica\Core\Config\ValueObject\Cache;
interface IManageConfigValues
{
/**
* Loads all configuration values of family into a cached storage.
* Reloads all configuration values (from filesystem and environment variables)
*
* All configuration values of the system are stored in the cache.
*
* @param string $cat The category of the configuration value
*
* @return void
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function load(string $cat = 'config');
public function reload();
/**
* Get a particular user's config variable given the category name
* ($cat) and a $key.
*
* Get a particular config value from the given category ($cat)
* and the $key from a cached storage either from the database or from the cache.
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to query
* @param ?string $key The configuration key to query (if null, the whole array at the category will get returned)
* @param mixed $default_value Deprecated, use `Config->get($cat, $key, null, $refresh) ?? $default_value` instead
* @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
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*
*/
public function get(string $cat, string $key, $default_value = null, bool $refresh = false);
public function get(string $cat, string $key = null, $default_value = null);
/**
* Load all configuration values from a given cache and saves it back in the configuration node store
* @see ConfigFileManager::CONFIG_DATA_FILE
*
* All configuration values of the system are stored in the cache.
*
* @param Cache $cache a new cache
*
* @return void
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function load(Cache $cache);
/**
* Sets a configuration value for system config
@ -78,6 +89,15 @@ interface IManageConfigValues
*/
public function set(string $cat, string $key, $value): bool;
/**
* Creates a transactional config value store, which is used to set a bunch of values at once
*
* It relies on the current instance, so after save(), the values of this config class will get altered at once too.
*
* @return ISetConfigValuesTransactionally
*/
public function beginTransaction(): ISetConfigValuesTransactionally;
/**
* Deletes the given key from the system configuration.
*

64
src/Core/Config/Capability/ISetConfigValuesTransactionally.php Normal file
View file

@ -0,0 +1,64 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Capability;
use Friendica\Core\Config\Exception\ConfigPersistenceException;
/**
* Interface for transactional saving of config values
* It buffers every set/delete until "save()" is called
*/
interface ISetConfigValuesTransactionally
{
/**
* Sets a configuration value for system config
*
* Stores a config value ($value) in the category ($cat) under the key ($key)
*
* Note: Please do not store booleans - convert to 0/1 integer values!
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to set
* @param mixed $value The value to store
*
* @return static the current instance
*/
public function set(string $cat, string $key, $value): self;
/**
* Deletes the given key from the system configuration.
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to delete
*
* @return static the current instance
*
*/
public function delete(string $cat, string $key): self;
/**
* Commits the changes of the current transaction
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function commit(): void;
}

36
src/Core/Config/Factory/Config.php
View file

@ -21,12 +21,12 @@
namespace Friendica\Core\Config\Factory;
use Friendica\Core\Config\Capability;
use Friendica\Core\Config\Repository;
use Friendica\Core\Config\Type;
use Friendica\Core\Config\Util;
use Friendica\Core\Config\ValueObject\Cache;
/**
* The config factory for creating either the cache or the whole model
*/
class Config
{
/**
@ -54,9 +54,9 @@ class Config
* @param string $basePath The basepath of FRIENDICA
* @param array $server The $_SERVER array
*
* @return Util\ConfigFileLoader
* @return Util\ConfigFileManager
*/
public function createConfigFileLoader(string $basePath, array $server = []): Util\ConfigFileLoader
public function createConfigFileManager(string $basePath, array $server = []): Util\ConfigFileManager
{
if (!empty($server[self::CONFIG_DIR_ENV]) && is_dir($server[self::CONFIG_DIR_ENV])) {
$configDir = $server[self::CONFIG_DIR_ENV];
@ -65,37 +65,19 @@ class Config
}
$staticDir = $basePath . DIRECTORY_SEPARATOR . self::STATIC_DIR;
return new Util\ConfigFileLoader($basePath, $configDir, $staticDir);
return new Util\ConfigFileManager($basePath, $configDir, $staticDir, $server);
}
/**
* @param Util\ConfigFileLoader $loader The Config Cache loader (INI/config/.htconfig)
* @param array $server
* @param Util\ConfigFileManager $configFileManager The Config Cache manager (INI/config/.htconfig)
*
* @return Cache
*/
public function createCache(Util\ConfigFileLoader $loader, array $server = []): Cache
public function createCache(Util\ConfigFileManager $configFileManager): Cache
{
$configCache = new Cache();
$loader->setupCache($configCache, $server);
$configFileManager->setupCache($configCache);
return $configCache;
}
/**
* @param Cache $configCache The config cache of this adapter
* @param Repository\Config $configRepo The configuration repository
*
* @return Capability\IManageConfigValues
*/
public function create(Cache $configCache, Repository\Config $configRepo)
{
if ($configCache->get('system', 'config_adapter') === 'preload') {
$configuration = new Type\PreloadConfig($configCache, $configRepo);
} else {
$configuration = new Type\JitConfig($configCache, $configRepo);
}
return $configuration;
}
}

126
src/Core/Config/Model/Config.php Normal file
View file

@ -0,0 +1,126 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Model;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Capability\ISetConfigValuesTransactionally;
use Friendica\Core\Config\Exception\ConfigFileException;
use Friendica\Core\Config\Exception\ConfigPersistenceException;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
/**
* Configuration model, which manages the whole system configuration
*/
class Config implements IManageConfigValues
{
/** @var Cache */
protected $configCache;
/** @var ConfigFileManager */
protected $configFileManager;
/**
* @param ConfigFileManager $configFileManager The configuration file manager to save back configs
* @param Cache $configCache The configuration cache (based on the config-files)
*/
public function __construct(ConfigFileManager $configFileManager, Cache $configCache)
{
$this->configFileManager = $configFileManager;
$this->configCache = $configCache;
}
/**
* {@inheritDoc}
*/
public function getCache(): Cache
{
return $this->configCache;
}
/** {@inheritDoc} */
public function beginTransaction(): ISetConfigValuesTransactionally
{
return new ConfigTransaction($this);
}
/**
* Saves the current Configuration back into the data config.
* @see ConfigFileManager::CONFIG_DATA_FILE
*/
protected function save()
{
try {
$this->configFileManager->saveData($this->configCache);
} catch (ConfigFileException $e) {
throw new ConfigPersistenceException('Cannot save config', $e);
}
}
/** {@inheritDoc} */
public function reload()
{
$configCache = new Cache();
try {
$this->configFileManager->setupCache($configCache);
} catch (ConfigFileException $e) {
throw new ConfigPersistenceException('Cannot reload config', $e);
}
$this->configCache = $configCache;
}
/** {@inheritDoc} */
public function load(Cache $cache)
{
$this->configCache = $cache;
$this->save();
}
/** {@inheritDoc} */
public function get(string $cat, string $key = null, $default_value = null)
{
return $this->configCache->get($cat, $key) ?? $default_value;
}
/** {@inheritDoc} */
public function set(string $cat, string $key, $value): bool
{
if ($this->configCache->set($cat, $key, $value, Cache::SOURCE_DATA)) {
$this->save();
return true;
} else {
return false;
}
}
/** {@inheritDoc} */
public function delete(string $cat, string $key): bool
{
if ($this->configCache->delete($cat, $key, Cache::SOURCE_DATA)) {
$this->save();
return true;
} else {
return false;
}
}
}

81
src/Core/Config/Model/ConfigTransaction.php Normal file
View file

@ -0,0 +1,81 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Model;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Capability\ISetConfigValuesTransactionally;
use Friendica\Core\Config\Exception\ConfigPersistenceException;
use Friendica\Core\Config\ValueObject\Cache;
/**
* Transaction class for configurations, which sets values into a temporary buffer until "save()" is called
*/
class ConfigTransaction implements ISetConfigValuesTransactionally
{
/** @var IManageConfigValues */
protected $config;
/** @var Cache */
protected $cache;
/** @var bool field to check if something is to save */
protected $changedConfig = false;
public function __construct(IManageConfigValues $config)
{
$this->config = $config;
$this->cache = clone $config->getCache();
}
/** {@inheritDoc} */
public function set(string $cat, string $key, $value): ISetConfigValuesTransactionally
{
$this->cache->set($cat, $key, $value, Cache::SOURCE_DATA);
$this->changedConfig = true;
return $this;
}
/** {@inheritDoc} */
public function delete(string $cat, string $key): ISetConfigValuesTransactionally
{
$this->cache->delete($cat, $key, Cache::SOURCE_DATA);
$this->changedConfig = true;
return $this;
}
/** {@inheritDoc} */
public function commit(): void
{
// If nothing changed, just do nothing :)
if (!$this->changedConfig) {
return;
}
try {
$this->config->load($this->cache);
$this->cache = clone $this->config->getCache();
} catch (\Exception $e) {
throw new ConfigPersistenceException('Cannot save config', $e);
}
}
}

191
src/Core/Config/Repository/Config.php
View file

@ -1,191 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Repository;
use Friendica\App\Mode;
use Friendica\Core\Config\Exception\ConfigPersistenceException;
use Friendica\Core\Config\Util\ValueConversion;
use Friendica\Database\Database;
/**
* The Config Repository, which is using the general DB-model backend for configs
*/
class Config
{
/** @var Database */
protected $db;
/** @var Mode */
protected $mode;
public function __construct(Database $db, Mode $mode)
{
$this->db = $db;
$this->mode = $mode;
}
protected static $table_name = 'config';
/**
* Checks if the model is currently connected
*
* @return bool
*/
public function isConnected(): bool
{
return $this->db->isConnected() && !$this->mode->isInstall();
}
/**
* Loads all configuration values and returns the loaded category as an array.
*
* @param string|null $cat The category of the configuration values to load
*
* @return array The config array
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function load(?string $cat = null): array
{
$return = [];
try {
if (empty($cat)) {
$configs = $this->db->select(static::$table_name, ['cat', 'v', 'k']);
} else {
$configs = $this->db->select(static::$table_name, ['cat', 'v', 'k'], ['cat' => $cat]);
}
while ($config = $this->db->fetch($configs)) {
$key = $config['k'];
$value = ValueConversion::toConfigValue($config['v']);
// just save it in case it is set
if (isset($value)) {
$return[$config['cat']][$key] = $value;
}
}
} catch (\Exception $exception) {
throw new ConfigPersistenceException(sprintf('Cannot load config category %s', $cat), $exception);
} finally {
$this->db->close($configs);
}
return $return;
}
/**
* Get a particular, system-wide config variable out of the DB with the
* given category name ($cat) and a key ($key).
*
* Note: Boolean variables are defined as 0/1 in the database
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to query
*
* @return array|string|null Stored value or null if it does not exist
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function get(string $cat, string $key)
{
if (!$this->isConnected()) {
return null;
}
try {
$config = $this->db->selectFirst(static::$table_name, ['v'], ['cat' => $cat, 'k' => $key]);
if ($this->db->isResult($config)) {
$value = ValueConversion::toConfigValue($config['v']);
// just return it in case it is set
if (isset($value)) {
return $value;
}
}
} catch (\Exception $exception) {
throw new ConfigPersistenceException(sprintf('Cannot get config with category %s and key %s', $cat, $key), $exception);
}
return null;
}
/**
* Stores a config value ($value) in the category ($cat) under the key ($key).
*
* Note: Please do not store booleans - convert to 0/1 integer values!
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to set
* @param mixed $value The value to store
*
* @return bool Operation success
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function set(string $cat, string $key, $value): bool
{
if (!$this->isConnected()) {
return false;
}
// We store our setting values in a string variable.
// So we have to do the conversion here so that the compare below works.
// The exception are array values.
$compare_value = (!is_array($value) ? (string)$value : $value);
$stored_value = $this->get($cat, $key);
if (isset($stored_value) && ($stored_value === $compare_value)) {
return true;
}
$dbValue = ValueConversion::toDbValue($value);
try {
return $this->db->update(static::$table_name, ['v' => $dbValue], ['cat' => $cat, 'k' => $key], true);
} catch (\Exception $exception) {
throw new ConfigPersistenceException(sprintf('Cannot set config with category %s and key %s', $cat, $key), $exception);
}
}
/**
* Removes the configured value from the database.
*
* @param string $cat The category of the configuration value
* @param string $key The configuration key to delete
*
* @return bool Operation success
*
* @throws ConfigPersistenceException In case the persistence layer throws errors
*/
public function delete(string $cat, string $key): bool
{
if (!$this->isConnected()) {
return false;
}
try {
return $this->db->delete(static::$table_name, ['cat' => $cat, 'k' => $key]);
} catch (\Exception $exception) {
throw new ConfigPersistenceException(sprintf('Cannot delete config with category %s and key %s', $cat, $key), $exception);
}
}
}

63
src/Core/Config/Type/AbstractConfig.php
View file

@ -1,63 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Type;
use Friendica\Core\Config\Repository\Config;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Config\Capability\IManageConfigValues;
/**
* This class is responsible for all system-wide configuration values in Friendica
* There are two types of storage
* - The Config-Files (loaded into the FileCache @see Cache)
* - The Config-Repository (per Config-Repository @see Config )
*/
abstract class AbstractConfig implements IManageConfigValues
{
/**
* @var Cache
*/
protected $configCache;
/**
* @var Config
*/
protected $configRepo;
/**
* @param Cache $configCache The configuration cache (based on the config-files)
* @param Config $configRepo The configuration repository
*/
public function __construct(Cache $configCache, Config $configRepo)
{
$this->configCache = $configCache;
$this->configRepo = $configRepo;
}
/**
* {@inheritDoc}
*/
public function getCache(): Cache
{
return $this->configCache;
}
}

139
src/Core/Config/Type/JitConfig.php
View file

@ -1,139 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Type;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Config\Repository\Config;
/**
* This class implements the Just-In-Time configuration, which will cache
* config values in a cache, once they are retrieved.
*
* Default Configuration type.
* Provides the best performance for pages loading few configuration variables.
*/
class JitConfig extends AbstractConfig
{
/**
* @var array Array of already loaded db values (even if there was no value)
*/
private $db_loaded;
/**
* @param Cache $configCache The configuration cache (based on the config-files)
* @param Config $configRepo The configuration model
*/
public function __construct(Cache $configCache, Config $configRepo)
{
parent::__construct($configCache, $configRepo);
$this->db_loaded = [];
$this->load();
}
/**
* {@inheritDoc}
*/
public function load(string $cat = 'config')
{
// If not connected, do nothing
if (!$this->configRepo->isConnected()) {
return;
}
$config = $this->configRepo->load($cat);
if (!empty($config[$cat])) {
foreach ($config[$cat] as $key => $value) {
$this->db_loaded[$cat][$key] = true;
}
}
// load the whole category out of the DB into the cache
$this->configCache->load($config, Cache::SOURCE_DB);
}
/**
* {@inheritDoc}
*/
public function get(string $cat, string $key, $default_value = null, bool $refresh = false)
{
// if the value isn't loaded or refresh is needed, load it to the cache
if ($this->configRepo->isConnected() &&
(empty($this->db_loaded[$cat][$key]) ||
$refresh)) {
$dbValue = $this->configRepo->get($cat, $key);
if (isset($dbValue)) {
$this->configCache->set($cat, $key, $dbValue, Cache::SOURCE_DB);
unset($dbValue);
}
$this->db_loaded[$cat][$key] = true;
}
// use the config cache for return
$result = $this->configCache->get($cat, $key);
return (isset($result)) ? $result : $default_value;
}
/**
* {@inheritDoc}
*/
public function set(string $cat, string $key, $value): bool
{
// set the cache first
$cached = $this->configCache->set($cat, $key, $value, Cache::SOURCE_DB);
// If there is no connected adapter, we're finished
if (!$this->configRepo->isConnected()) {
return $cached;
}
$stored = $this->configRepo->set($cat, $key, $value);
$this->db_loaded[$cat][$key] = $stored;
return $cached && $stored;
}
/**
* {@inheritDoc}
*/
public function delete(string $cat, string $key): bool
{
$cacheRemoved = $this->configCache->delete($cat, $key);
if (isset($this->db_loaded[$cat][$key])) {
unset($this->db_loaded[$cat][$key]);
}
if (!$this->configRepo->isConnected()) {
return $cacheRemoved;
}
$storeRemoved = $this->configRepo->delete($cat, $key);
return $cacheRemoved || $storeRemoved;
}
}

135
src/Core/Config/Type/PreloadConfig.php
View file

@ -1,135 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Type;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Config\Repository\Config;
/**
* This class implements the preload configuration, which will cache
* all config values per call in a cache.
*
* Minimizes the number of database queries to retrieve configuration values at the cost of memory.
*/
class PreloadConfig extends AbstractConfig
{
/** @var bool */
private $config_loaded;
/**
* @param Cache $configCache The configuration cache (based on the config-files)
* @param Config $configRepo The configuration model
*/
public function __construct(Cache $configCache, Config $configRepo)
{
parent::__construct($configCache, $configRepo);
$this->config_loaded = false;
$this->load();
}
/**
* {@inheritDoc}
*
* This loads all config values everytime load is called
*/
public function load(string $cat = 'config')
{
// Don't load the whole configuration twice
if ($this->config_loaded) {
return;
}
// If not connected, do nothing
if (!$this->configRepo->isConnected()) {
return;
}
$config = $this->configRepo->load();
$this->config_loaded = true;
// load the whole category out of the DB into the cache
$this->configCache->load($config, Cache::SOURCE_DB);
}
/**
* {@inheritDoc}
*/
public function get(string $cat, string $key, $default_value = null, bool $refresh = false)
{
if ($refresh) {
if ($this->configRepo->isConnected()) {
$config = $this->configRepo->get($cat, $key);
if (isset($config)) {
$this->configCache->set($cat, $key, $config, Cache::SOURCE_DB);
}
}
}
// use the config cache for return
$result = $this->configCache->get($cat, $key);
return (isset($result)) ? $result : $default_value;
}
/**
* {@inheritDoc}
*/
public function set(string $cat, string $key, $value): bool
{
if (!$this->config_loaded) {
$this->load();
}
// set the cache first
$cached = $this->configCache->set($cat, $key, $value, Cache::SOURCE_DB);
// If there is no connected adapter, we're finished
if (!$this->configRepo->isConnected()) {
return $cached;
}
$stored = $this->configRepo->set($cat, $key, $value);
return $cached && $stored;
}
/**
* {@inheritDoc}
*/
public function delete(string $cat, string $key): bool
{
if ($this->config_loaded) {
$this->load();
}
$cacheRemoved = $this->configCache->delete($cat, $key);
if (!$this->configRepo->isConnected()) {
return $cacheRemoved;
}
$storeRemoved = $this->configRepo->delete($cat, $key);
return $cacheRemoved || $storeRemoved;
}
}

234
src/Core/Config/Util/ConfigFileLoader.php → src/Core/Config/Util/ConfigFileManager.php
View file

@ -26,22 +26,15 @@ use Friendica\Core\Config\Exception\ConfigFileException;
use Friendica\Core\Config\ValueObject\Cache;
/**
* The ConfigFileLoader loads config-files and stores them in a ConfigCache ( @see Cache )
* The ConfigFileLoader loads and saves config-files and stores them in a ConfigCache ( @see Cache )
*
* It is capable of loading the following config files:
* - *.config.php (current)
* - *.ini.php (deprecated)
* - *.htconfig.php (deprecated)
*/
class ConfigFileLoader
class ConfigFileManager
{
/**
* The default name of the user defined ini file
*
* @var string
*/
const CONFIG_INI = 'local';
/**
* The default name of the user defined legacy config file
*
@ -49,6 +42,13 @@ class ConfigFileLoader
*/
const CONFIG_HTCONFIG = 'htconfig';
/**
* The config file, where overrides per admin page/console are saved at
*
* @var string
*/
const CONFIG_DATA_FILE = 'node.config.php';
/**
* The sample string inside the configs, which shouldn't get loaded
*
@ -69,16 +69,22 @@ class ConfigFileLoader
*/
private $staticDir;
/**
* @var array
*/
private $server;
/**
* @param string $baseDir The base
* @param string $configDir
* @param string $staticDir
*/
public function __construct(string $baseDir, string $configDir, string $staticDir)
public function __construct(string $baseDir, string $configDir, string $staticDir, array $server = [])
{
$this->baseDir = $baseDir;
$this->configDir = $configDir;
$this->staticDir = $staticDir;
$this->server = $server;
}
/**
@ -87,31 +93,33 @@ class ConfigFileLoader
* First loads the default value for all the configuration keys, then the legacy configuration files, then the
* expected local.config.php
*
* @param Cache $config The config cache to load to
* @param array $server The $_SERVER array
* @param bool $raw Setup the raw config format
* @param Cache $configCache The config cache to load to
* @param bool $raw Set up the raw config format
*
* @throws ConfigFileException
*/
public function setupCache(Cache $config, array $server = [], bool $raw = false)
public function setupCache(Cache $configCache, bool $raw = false)
{
// Load static config files first, the order is important
$config->load($this->loadStaticConfig('defaults'), Cache::SOURCE_STATIC);
$config->load($this->loadStaticConfig('settings'), Cache::SOURCE_STATIC);
$configCache->load($this->loadStaticConfig('defaults'), Cache::SOURCE_STATIC);
$configCache->load($this->loadStaticConfig('settings'), Cache::SOURCE_STATIC);
// try to load the legacy config first
$config->load($this->loadLegacyConfig('htpreconfig'), Cache::SOURCE_FILE);
$config->load($this->loadLegacyConfig('htconfig'), Cache::SOURCE_FILE);
$configCache->load($this->loadLegacyConfig('htpreconfig'), Cache::SOURCE_FILE);
$configCache->load($this->loadLegacyConfig('htconfig'), Cache::SOURCE_FILE);
// Now load every other config you find inside the 'config/' directory
$this->loadCoreConfig($config);
$this->loadCoreConfig($configCache);
$config->load($this->loadEnvConfig($server), Cache::SOURCE_ENV);
// Now load the node.config.php file with the node specific config values (based on admin gui/console actions)
$this->loadDataConfig($configCache);
$configCache->load($this->loadEnvConfig(), Cache::SOURCE_ENV);
// In case of install mode, add the found basepath (because there isn't a basepath set yet
if (!$raw && empty($config->get('system', 'basepath'))) {
if (!$raw && empty($configCache->get('system', 'basepath'))) {
// Setting at least the basepath we know
$config->set('system', 'basepath', $this->baseDir, Cache::SOURCE_FILE);
$configCache->set('system', 'basepath', $this->baseDir, Cache::SOURCE_FILE);
}
}
@ -131,7 +139,7 @@ class ConfigFileLoader
if (file_exists($configName)) {
return $this->loadConfigFile($configName);
} elseif (file_exists($iniName)) {
} else if (file_exists($iniName)) {
return $this->loadINIConfigFile($iniName);
} else {
return [];
@ -141,20 +149,172 @@ class ConfigFileLoader
/**
* Tries to load the specified core-configuration into the config cache.
*
* @param Cache $config The Config cache
* @param Cache $configCache The Config cache
*
* @throws ConfigFileException if the configuration file isn't readable
*/
private function loadCoreConfig(Cache $config)
private function loadCoreConfig(Cache $configCache)
{
// try to load legacy ini-files first
foreach ($this->getConfigFiles(true) as $configFile) {
$config->load($this->loadINIConfigFile($configFile), Cache::SOURCE_FILE);
$configCache->load($this->loadINIConfigFile($configFile), Cache::SOURCE_FILE);
}
// try to load supported config at last to overwrite it
foreach ($this->getConfigFiles() as $configFile) {
$config->load($this->loadConfigFile($configFile), Cache::SOURCE_FILE);
$configCache->load($this->loadConfigFile($configFile), Cache::SOURCE_FILE);
}
}
/**
* Tries to load the data config file with the overridden data
*
* @param Cache $configCache The Config cache
*
* @throws ConfigFileException In case the config file isn't loadable
*/
private function loadDataConfig(Cache $configCache)
{
$filename = $this->configDir . '/' . self::CONFIG_DATA_FILE;
if (file_exists($filename)) {
// The fallback empty return content
$content = '<?php return [];';
/**
* This code-block creates a readonly node.config.php content stream (fopen() with "r")
* The stream is locked shared (LOCK_SH), so not exclusively, but the OS knows that there's a lock
*
* Any exclusive locking (LOCK_EX) would need to wait until all LOCK_SHs are unlocked
*/
$configStream = fopen($filename, 'r');
try {
if (flock($configStream, LOCK_SH)) {
$content = fread($configStream, filesize($filename));
if (!$content) {
throw new ConfigFileException(sprintf('Couldn\'t read file %s', $filename));
}
}
} finally {
// unlock and close the stream for every circumstances
flock($configStream, LOCK_UN);
fclose($configStream);
}
/**
* Evaluate the content string as PHP code
*
* @see https://www.php.net/manual/en/function.eval.php
*
* @note
* To leave the PHP mode, we have to use the appropriate PHP tags '?>' as prefix.
*/
$dataArray = eval('?>' . $content);
if (is_array($dataArray)) {
$configCache->load($dataArray, Cache::SOURCE_DATA);
}
}
}
/**
* Checks, if the node.config.php is writable
*
* @return bool
*/
public function dataIsWritable(): bool
{
$filename = $this->configDir . '/' . self::CONFIG_DATA_FILE;
if (file_exists($filename)) {
return is_writable($filename);
} else {
return is_writable($this->configDir);
}
}
/**
* Saves overridden config entries back into the data.config.php
*
* @param Cache $configCache The config cache
*
* @throws ConfigFileException In case the config file isn't writeable or the data is invalid
*/
public function saveData(Cache $configCache)
{
$filename = $this->configDir . '/' . self::CONFIG_DATA_FILE;
if (file_exists($filename)) {
$fileExists = true;
} else {
$fileExists = false;
}
/**
* Creates a read-write stream
*
* @see https://www.php.net/manual/en/function.fopen.php
* @note Open the file for reading and writing. If the file does not exist, it is created.
* If it exists, it is neither truncated (as opposed to 'w'), nor the call to this function fails
* (as is the case with 'x'). The file pointer is positioned on the beginning of the file.
*
*/
if (($configStream = @fopen($filename, 'c+')) === false) {
throw new ConfigFileException(sprintf('Cannot open file "%s" in mode c+', $filename));
}
try {
// We do want an exclusive lock, so we wait until every LOCK_SH (config reading) is unlocked
if (flock($configStream, LOCK_EX)) {
/**
* If the file exists, we read the whole file again to avoid a race condition with concurrent threads that could have modified the file between the first config read of this thread and now
* Since we're currently exclusive locked, no other process can now change the config again
*/
if ($fileExists) {
// When reading the config file too fast, we get a wrong filesize, "clearstatcache" prevents that
clearstatcache(true, $filename);
$content = fread($configStream, filesize($filename));
if (!$content) {
throw new ConfigFileException(sprintf('Cannot read file %s', $filename));
}
// Event truncating the whole content wouldn't automatically rewind the stream,
// so we need to do it manually
rewind($configStream);
$dataArray = eval('?>' . $content);
// Merge the new content into the existing file based config cache and use it
// as the new config cache
if (is_array($dataArray)) {
$fileConfigCache = new Cache();
$fileConfigCache->load($dataArray, Cache::SOURCE_DATA);
$configCache = $fileConfigCache->merge($configCache);
}
}
// Only SOURCE_DATA is wanted, the rest isn't part of the node.config.php file
$data = $configCache->getDataBySource(Cache::SOURCE_DATA);
$encodedData = ConfigFileTransformer::encode($data);
if (!$encodedData) {
throw new ConfigFileException('config source cannot get encoded');
}
// Once again to avoid wrong, implicit "filesize" calls during the fwrite() or ftruncate() call
clearstatcache(true, $filename);
if (!ftruncate($configStream, 0) ||
!fwrite($configStream, $encodedData) ||
!fflush($configStream)) {
throw new ConfigFileException(sprintf('Cannot modify locked file %s', $filename));
}
}
} finally {
// unlock and close the stream for every circumstances
flock($configStream, LOCK_UN);
fclose($configStream);
}
}
@ -172,7 +332,7 @@ class ConfigFileLoader
$filepath = $this->baseDir . DIRECTORY_SEPARATOR . // /var/www/html/
Addon::DIRECTORY . DIRECTORY_SEPARATOR . // addon/
$name . DIRECTORY_SEPARATOR . // openstreetmap/
'config'. DIRECTORY_SEPARATOR . // config/
'config' . DIRECTORY_SEPARATOR . // config/
$name . ".config.php"; // openstreetmap.config.php
if (file_exists($filepath)) {
@ -185,13 +345,11 @@ class ConfigFileLoader
/**
* Tries to load environment specific variables, based on the `env.config.php` mapping table
*
* @param array $server The $_SERVER variable
*
* @return array The config array (empty if no config was found)
*
* @throws ConfigFileException if the configuration file isn't readable
*/
public function loadEnvConfig(array $server): array
protected function loadEnvConfig(): array
{
$filepath = $this->staticDir . DIRECTORY_SEPARATOR . // /var/www/html/static/
"env.config.php"; // env.config.php
@ -205,8 +363,8 @@ class ConfigFileLoader
$return = [];
foreach ($envConfig as $envKey => $configStructure) {
if (isset($server[$envKey])) {
$return[$configStructure[0]][$configStructure[1]] = $server[$envKey];
if (isset($this->server[$envKey])) {
$return[$configStructure[0]][$configStructure[1]] = $this->server[$envKey];
}
}
@ -231,7 +389,9 @@ class ConfigFileLoader
$sampleEnd = self::SAMPLE_END . ($ini ? '.ini.php' : '.config.php');
foreach ($files as $filename) {
if (fnmatch($filePattern, $filename) && substr_compare($filename, $sampleEnd, -strlen($sampleEnd))) {
if (fnmatch($filePattern, $filename) &&
substr_compare($filename, $sampleEnd, -strlen($sampleEnd)) &&
$filename !== self::CONFIG_DATA_FILE) {
$found[] = $this->configDir . '/' . $filename;
}
}
@ -353,12 +513,16 @@ class ConfigFileLoader
*/
private function loadConfigFile(string $filepath): array
{
$config = include($filepath);
if (file_exists($filepath)) {
$config = include $filepath;
if (!is_array($config)) {
throw new ConfigFileException('Error loading config file ' . $filepath);
}
return $config;
} else {
return [];
}
}
}

92
src/Core/Config/Util/ConfigFileTransformer.php Normal file
View file

@ -0,0 +1,92 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Core\Config\Util;
/**
* Util to transform back the config array into a string
*/
class ConfigFileTransformer
{
public static function encode(array $data): string
{
$dataString = '<?php' . PHP_EOL . PHP_EOL;
$dataString .= 'return [' . PHP_EOL;
$categories = array_keys($data);
foreach ($categories as $category) {
if (is_null($data[$category])) {
$dataString .= "\t'$category' => null," . PHP_EOL;
continue;
}
$dataString .= "\t'$category' => [" . PHP_EOL;
if (is_array($data[$category])) {
$keys = array_keys($data[$category]);
foreach ($keys as $key) {
$dataString .= static::mapConfigValue($key, $data[$category][$key]);
}
}
$dataString .= "\t]," . PHP_EOL;
}
$dataString .= "];" . PHP_EOL;
return $dataString;
}
protected static function extractArray(array $config, int $level = 0): string
{
$string = '';
foreach ($config as $configKey => $configValue) {
$string .= static::mapConfigValue($configKey, $configValue, $level);
}
return $string;
}
protected static function mapConfigValue(string $key, $value, $level = 0): string
{
$string = str_repeat("\t", $level + 2) . "'$key' => ";
if (is_null($value)) {
$string .= "null,";
} elseif (is_array($value)) {
$string .= "[" . PHP_EOL;
$string .= static::extractArray($value, ++$level);
$string .= str_repeat("\t", $level + 1) . '],';
} elseif (is_bool($value)) {
$string .= ($value ? 'true' : 'false') . ",";
} elseif (is_numeric($value)) {
$string .= $value . ",";
} else {
$string .= sprintf('\'%s\',', addcslashes($value, '\'\\'));
}
$string .= PHP_EOL;
return $string;
}
}

162
src/Core/Config/ValueObject/Cache.php
View file

@ -21,13 +21,13 @@
namespace Friendica\Core\Config\ValueObject;
use Friendica\Core\Config\Util\ConfigFileLoader;
use Friendica\Core\Config\Util\ConfigFileManager;
use ParagonIE\HiddenString\HiddenString;
/**
* The Friendica config cache for the application
* Initial, all *.config.php files are loaded into this cache with the
* ConfigFileLoader ( @see ConfigFileLoader )
* ConfigFileManager ( @see ConfigFileManager )
*/
class Cache
{
@ -35,8 +35,8 @@ class Cache
const SOURCE_STATIC = 0;
/** @var int Indicates that the cache entry is set by file - Low Priority */
const SOURCE_FILE = 1;
/** @var int Indicates that the cache entry is set by the DB config table - Middle Priority */
const SOURCE_DB = 2;
/** @var int Indicates that the cache entry is manually set by the application (per admin page/console) - Middle Priority */
const SOURCE_DATA = 2;
/** @var int Indicates that the cache entry is set by a server environment variable - High Priority */
const SOURCE_ENV = 3;
/** @var int Indicates that the cache entry is fixed and must not be changed */
@ -65,7 +65,7 @@ class Cache
* @param bool $hidePasswordOutput True, if cache variables should take extra care of password values
* @param int $source Sets a source of the initial config values
*/
public function __construct(array $config = [], bool $hidePasswordOutput = true, $source = self::SOURCE_DEFAULT)
public function __construct(array $config = [], bool $hidePasswordOutput = true, int $source = self::SOURCE_DEFAULT)
{
$this->hidePasswordOutput = $hidePasswordOutput;
$this->load($config, $source);
@ -87,11 +87,10 @@ class Cache
$keys = array_keys($config[$category]);
foreach ($keys as $key) {
$value = $config[$category][$key];
if (isset($value)) {
$this->set($category, $key, $value, $source);
}
$this->set($category, $key, $config[$category][$key] ?? null, $source);
}
} else {
$this->set($category, null, $config[$category], $source);
}
}
}
@ -128,62 +127,132 @@ class Cache
return $this->source[$cat][$key] ?? -1;
}
/**
* Returns the whole config array based on the given source type
*
* @param int $source Indicates the source of the config entry
*
* @return array The config array part of the given source
*/
public function getDataBySource(int $source): array
{
$data = [];
$categories = array_keys($this->source);
foreach ($categories as $category) {
if (is_array($this->source[$category])) {
$keys = array_keys($this->source[$category]);
foreach ($keys as $key) {
if ($this->source[$category][$key] === $source) {
$data[$category][$key] = $this->config[$category][$key];
}
}
} elseif (is_int($this->source[$category])) {
$data[$category] = null;
}
}
return $data;
}
/**
* 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
* @param ?string $key Config key
* @param ?mixed $value Value to set
* @param int $source The source of the current config key
*
* @return bool True, if the value is set
*/
public function set(string $cat, string $key, $value, int $source = self::SOURCE_DEFAULT): bool
public function set(string $cat, string $key = null, $value = null, int $source = self::SOURCE_DEFAULT): bool
{
if (!isset($this->config[$cat])) {
if (!isset($this->config[$cat]) && $key !== null) {
$this->config[$cat] = [];
$this->source[$cat] = [];
}
if (isset($this->source[$cat][$key]) &&
$source < $this->source[$cat][$key]) {
if ((isset($this->source[$cat][$key]) && $source < $this->source[$cat][$key]) ||
(is_int($this->source[$cat] ?? null) && $source < $this->source[$cat])) {
return false;
}
if ($this->hidePasswordOutput &&
$key == 'password' &&
is_string($value)) {
$this->config[$cat][$key] = new HiddenString((string)$value);
$this->setCatKeyValueSource($cat, $key, new HiddenString($value), $source);
} else if (is_string($value)) {
$this->setCatKeyValueSource($cat, $key, self::toConfigValue($value), $source);
} else {
$this->config[$cat][$key] = $value;
$this->setCatKeyValueSource($cat, $key, $value, $source);
}
$this->source[$cat][$key] = $source;
return true;
}
private function setCatKeyValueSource(string $cat, string $key = null, $value = null, int $source = self::SOURCE_DEFAULT)
{
if (isset($key)) {
$this->config[$cat][$key] = $value;
$this->source[$cat][$key] = $source;
} else {
$this->config[$cat] = $value;
$this->source[$cat] = $source;
}
}
/**
* Formats a DB value to a config value
* - null = The db-value isn't set
* - bool = The db-value is either '0' or '1'
* - array = The db-value is a serialized array
* - string = The db-value is a string
*
* Keep in mind that there aren't any numeric/integer config values in the database
*
* @param string|null $value
*
* @return null|array|string
*/
public static function toConfigValue(?string $value)
{
if (!isset($value)) {
return null;
}
if (preg_match("|^a:[0-9]+:{.*}$|s", $value)) {
return unserialize($value);
} else {
return $value;
}
}
/**
* Deletes a value from the config cache.
*
* @param string $cat Config category
* @param string $key Config key
* @param ?string $key Config key (if not set, the whole category will get deleted)
* @param int $source The source of the current config key
*
* @return bool true, if deleted
*/
public function delete(string $cat, string $key): bool
public function delete(string $cat, string $key = null, int $source = self::SOURCE_DEFAULT): bool
{
if (isset($this->config[$cat][$key])) {
unset($this->config[$cat][$key]);
unset($this->source[$cat][$key]);
if (count($this->config[$cat]) == 0) {
unset($this->config[$cat]);
unset($this->source[$cat]);
$this->config[$cat][$key] = null;
$this->source[$cat][$key] = $source;
if (empty(array_filter($this->config[$cat], function($value) { return !is_null($value); }))) {
$this->config[$cat] = null;
$this->source[$cat] = $source;
}
} elseif (isset($this->config[$cat])) {
$this->config[$cat] = null;
$this->source[$cat] = $source;
}
return true;
} else {
return false;
}
}
/**
@ -223,4 +292,39 @@ class Cache
return $return;
}
/**
* Merges a new Cache into the existing one and returns the merged Cache
*
* @param Cache $cache The cache, which should get merged into this Cache
*
* @return Cache The merged Cache
*/
public function merge(Cache $cache): Cache
{
$newConfig = $this->config;
$newSource = $this->source;
$categories = array_keys($cache->config);
foreach ($categories as $category) {
if (is_array($cache->config[$category])) {
$keys = array_keys($cache->config[$category]);
foreach ($keys as $key) {
$newConfig[$category][$key] = $cache->config[$category][$key];
$newSource[$category][$key] = $cache->source[$category][$key];
}
} else {
$newConfig[$category] = $cache->config[$category];
$newSource[$category] = $cache->source[$category];
}
}
$newCache = new Cache();
$newCache->config = $newConfig;
$newCache->source = $newSource;
return $newCache;
}
}

2
src/Core/KeyValueStorage/Type/DBKeyValueStorage.php
View file

@ -21,7 +21,7 @@
namespace Friendica\Core\KeyValueStorage\Type;
use Friendica\Core\Config\Util\ValueConversion;
use Friendica\Core\PConfig\Util\ValueConversion;
use Friendica\Core\KeyValueStorage\Exceptions\KeyValueStoragePersistenceException;
use Friendica\Database\Database;

11
src/Core/L10n.php
View file

@ -85,10 +85,15 @@ class L10n
* @var Database
*/
private $dba;
/**
* @var IManageConfigValues
*/
private $config;
public function __construct(IManageConfigValues $config, Database $dba, IHandleSessions $session, array $server, array $get)
{
$this->dba = $dba;
$this->config = $config;
$this->loadTranslationTable(L10n::detectLanguage($server, $get, $config->get('system', 'language', self::DEFAULT)));
$this->setSessionVariable($session);
@ -157,9 +162,9 @@ class L10n
$a->strings = [];
// load enabled addons strings
$addons = $this->dba->select('addon', ['name'], ['installed' => true]);
while ($p = $this->dba->fetch($addons)) {
$name = Strings::sanitizeFilePathItem($p['name']);
$addons = array_keys($this->config->get('addons') ?? []);
foreach ($addons as $addon) {
$name = Strings::sanitizeFilePathItem($addon);
if (file_exists(__DIR__ . "/../../addon/$name/lang/$lang/strings.php")) {
include __DIR__ . "/../../addon/$name/lang/$lang/strings.php";
}

2
src/Core/PConfig/Repository/PConfig.php
View file

@ -22,7 +22,7 @@
namespace Friendica\Core\PConfig\Repository;
use Friendica\App\Mode;
use Friendica\Core\Config\Util\ValueConversion;
use Friendica\Core\PConfig\Util\ValueConversion;
use Friendica\Core\PConfig\Exception\PConfigPersistenceException;
use Friendica\Database\Database;

2
src/Core/Config/Util/ValueConversion.php → src/Core/PConfig/Util/ValueConversion.php
View file

@ -19,7 +19,7 @@
*
*/
namespace Friendica\Core\Config\Util;
namespace Friendica\Core\PConfig\Util;
/**
* Util class to help to convert from/to (p)config values

4
src/Core/Storage/Type/ExternalResource.php
View file

@ -62,10 +62,14 @@ class ExternalResource implements ICanReadFromStorage
if (!empty($fetchResult) && $fetchResult->isSuccess()) {
Logger::debug('Got picture', ['Content-Type' => $fetchResult->getHeader('Content-Type'), 'uid' => $data->uid, 'url' => $data->url]);
return $fetchResult->getBody();
} else {
if (empty($fetchResult)) {
throw new ReferenceStorageException(sprintf('External resource failed to get %s', $reference));
} else {
throw new ReferenceStorageException(sprintf('External resource failed to get %s', $reference), $fetchResult->getReturnCode(), new Exception($fetchResult->getBody()));
}
}
}
/**
* @inheritDoc

2
src/Core/System.php
View file

@ -294,7 +294,7 @@ class System
}
DI::apiResponse()->setType(Response::TYPE_XML);
DI::apiResponse()->addContent(XML::fromArray(["result" => $result], $xml));
DI::apiResponse()->addContent(XML::fromArray(['result' => $result]));
DI::page()->exit(DI::apiResponse()->generate());
self::exit();

70
src/Core/Update.php
View file

@ -47,23 +47,33 @@ class Update
* @return void
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/
public static function check(string $basePath, bool $via_worker, App\Mode $mode)
public static function check(string $basePath, bool $via_worker)
{
if (!DBA::connected()) {
return;
}
// Don't check the status if the last update was failed
if (DI::config()->get('system', 'update', Update::SUCCESS, true) == Update::FAILED) {
if (DI::config()->get('system', 'update', Update::SUCCESS) == Update::FAILED) {
return;
}
$build = DI::config()->get('system', 'build');
if (empty($build)) {
// legacy option - check if there's something in the Config table
if (DBStructure::existsTable('config')) {
$dbConfig = DBA::selectFirst('config', ['v'], ['cat' => 'system', 'k' => 'build']);
if (!empty($dbConfig)) {
$build = $dbConfig['v'];
}
}
if (empty($build)) {
DI::config()->set('system', 'build', DB_UPDATE_VERSION - 1);
$build = DB_UPDATE_VERSION - 1;
}
}
// We don't support upgrading from very old versions anymore
if ($build < self::NEW_TABLE_STRUCTURE_VERSION) {
@ -119,11 +129,21 @@ class Update
DI::lock()->release('dbupdate', true);
}
$build = DI::config()->get('system', 'build', null, true);
$build = DI::config()->get('system', 'build');
if (empty($build)) {
// legacy option - check if there's something in the Config table
if (DBStructure::existsTable('config')) {
$dbConfig = DBA::selectFirst('config', ['v'], ['cat' => 'system', 'k' => 'build']);
if (!empty($dbConfig)) {
$build = $dbConfig['v'];
}
}
if (empty($build) || ($build > DB_UPDATE_VERSION)) {
DI::config()->set('system', 'build', DB_UPDATE_VERSION - 1);
$build = DB_UPDATE_VERSION - 1;
DI::config()->set('system', 'build', $build);
}
}
if ($build != DB_UPDATE_VERSION || $force) {
@ -132,7 +152,7 @@ class Update
$stored = intval($build);
$current = intval(DB_UPDATE_VERSION);
if ($stored < $current || $force) {
DI::config()->load('database');
DI::config()->reload();
// Compare the current structure with the defined structure
// If the Lock is acquired, never release it automatically to avoid double updates
@ -141,12 +161,22 @@ class Update
Logger::notice('Update starting.', ['from' => $stored, 'to' => $current]);
// Checks if the build changed during Lock acquiring (so no double update occurs)
$retryBuild = DI::config()->get('system', 'build', null, true);
if ($retryBuild !== $build) {
Logger::notice('Update already done.', ['from' => $stored, 'to' => $current]);
$retryBuild = DI::config()->get('system', 'build');
if ($retryBuild != $build) {
// legacy option - check if there's something in the Config table
if (DBStructure::existsTable('config')) {
$dbConfig = DBA::selectFirst('config', ['v'], ['cat' => 'system', 'k' => 'build']);
if (!empty($dbConfig)) {
$retryBuild = intval($dbConfig['v']);
}
}
if ($retryBuild != $build) {
Logger::notice('Update already done.', ['from' => $build, 'retry' => $retryBuild, 'to' => $current]);
DI::lock()->release('dbupdate');
return '';
}
}
DI::config()->set('system', 'maintenance', 1);
@ -160,8 +190,10 @@ class Update
Logger::warning('Pre update failed', ['version' => $version]);
DI::config()->set('system', 'update', Update::FAILED);
DI::lock()->release('dbupdate');
DI::config()->set('system', 'maintenance', 0);
DI::config()->set('system', 'maintenance_reason', '');
DI::config()->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
return $r;
} else {
Logger::notice('Pre update executed.', ['version' => $version]);
@ -181,8 +213,10 @@ class Update
Logger::error('Update ERROR.', ['from' => $stored, 'to' => $current, 'retval' => $retval]);
DI::config()->set('system', 'update', Update::FAILED);
DI::lock()->release('dbupdate');
DI::config()->set('system', 'maintenance', 0);
DI::config()->set('system', 'maintenance_reason', '');
DI::config()->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
return $retval;
} else {
Logger::notice('Database structure update finished.', ['from' => $stored, 'to' => $current]);
@ -198,8 +232,10 @@ class Update
Logger::warning('Post update failed', ['version' => $version]);
DI::config()->set('system', 'update', Update::FAILED);
DI::lock()->release('dbupdate');
DI::config()->set('system', 'maintenance', 0);
DI::config()->set('system', 'maintenance_reason', '');
DI::config()->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
return $r;
} else {
DI::config()->set('system', 'build', $version);
@ -210,8 +246,10 @@ class Update
DI::config()->set('system', 'build', $current);
DI::config()->set('system', 'update', Update::SUCCESS);
DI::lock()->release('dbupdate');
DI::config()->set('system', 'maintenance', 0);
DI::config()->set('system', 'maintenance_reason', '');
DI::config()->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
Logger::notice('Update success.', ['from' => $stored, 'to' => $current]);
if ($sendMail) {

6
src/Core/Worker.php
View file

@ -331,7 +331,7 @@ class Worker
$mypid = getmypid();
// Quit when in maintenance
if (DI::config()->get('system', 'maintenance', false, true)) {
if (DI::config()->get('system', 'maintenance', false)) {
Logger::notice('Maintenance mode - quit process', ['pid' => $mypid]);
return false;
}
@ -1315,8 +1315,8 @@ class Worker
return $added;
}
// Quit on daemon mode
if (Worker\Daemon::isMode()) {
// Quit on daemon mode, except the priority is critical (like for db updates)
if (Worker\Daemon::isMode() && $priority !== self::PRIORITY_CRITICAL) {
return $added;
}

5
src/DI.php
View file

@ -181,6 +181,11 @@ abstract class DI
return self::$dice->create(Core\Config\Capability\IManageConfigValues::class);
}
public static function configFileManager(): Core\Config\Util\ConfigFileManager
{
return self::$dice->create(Core\Config\Util\ConfigFileManager::class);
}
public static function keyValue(): Core\KeyValueStorage\Capabilities\IManageKeyValuePairs
{
return self::$dice->create(Core\KeyValueStorage\Capabilities\IManageKeyValuePairs::class);

10
src/Database/DBStructure.php
View file

@ -74,7 +74,7 @@ class DBStructure
$old_tables = ['fserver', 'gcign', 'gcontact', 'gcontact-relation', 'gfollower' ,'glink', 'item-delivery-data',
'item-activity', 'item-content', 'item_id', 'participation', 'poll', 'poll_result', 'queue', 'retriever_rule',
'deliverq', 'dsprphotoq', 'ffinder', 'sign', 'spam', 'term', 'user-item', 'thread', 'item', 'challenge',
'auth_codes', 'tokens', 'clients', 'profile_check', 'host', 'conversation', 'fcontact'];
'auth_codes', 'tokens', 'clients', 'profile_check', 'host', 'conversation', 'fcontact', 'config', 'addon'];
$tables = DBA::selectToArray('INFORMATION_SCHEMA.TABLES', ['TABLE_NAME'],
['TABLE_SCHEMA' => DBA::databaseName(), 'TABLE_TYPE' => 'BASE TABLE']);
@ -176,14 +176,16 @@ class DBStructure
public static function performUpdate(bool $enable_maintenance_mode = true, bool $verbose = false): string
{
if ($enable_maintenance_mode) {
DI::config()->set('system', 'maintenance', 1);
DI::config()->set('system', 'maintenance', true);
}
$status = self::update($verbose, true);
if ($enable_maintenance_mode) {
DI::config()->set('system', 'maintenance', 0);
DI::config()->set('system', 'maintenance_reason', '');
DI::config()->beginTransaction()
->set('system', 'maintenance', false)
->delete('system', 'maintenance_reason')
->commit();
}
return $status;

47
src/Model/GServer.php
View file

@ -44,7 +44,9 @@ use Friendica\Util\Network;
use Friendica\Util\Strings;
use Friendica\Util\XML;
use Friendica\Network\HTTPException;
use Friendica\Worker\UpdateGServer;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\UriInterface;
/**
* This class handles GServer related functions
@ -99,11 +101,11 @@ class GServer
*/
public static function add(string $url, bool $only_nodeinfo = false)
{
if (self::getID($url, false)) {
if (self::getID($url)) {
return;
}
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $url, $only_nodeinfo);
UpdateGServer::add(Worker::PRIORITY_LOW, $url, $only_nodeinfo);
}
/**
@ -191,8 +193,9 @@ class GServer
return false;
} else {
if (strtotime($gserver['next_contact']) < time()) {
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['url'], false);
UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['url']);
}
return self::isDefunct($gserver);
}
}
@ -210,8 +213,9 @@ class GServer
return true;
} else {
if (strtotime($gserver['next_contact']) < time()) {
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['url'], false);
UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['url']);
}
return !$gserver['failed'] && in_array($gserver['network'], Protocol::FEDERATED);
}
}
@ -252,7 +256,7 @@ class GServer
}
if (!empty($server) && (empty($gserver) || strtotime($gserver['next_contact']) < time())) {
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $server, false);
UpdateGServer::add(Worker::PRIORITY_LOW, $server);
}
return $reachable;
@ -375,7 +379,7 @@ class GServer
Logger::info('Reset failed status for server', ['url' => $gserver['url']]);
if (strtotime($gserver['next_contact']) < time()) {
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['url'], false);
UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['url']);
}
}
}
@ -393,7 +397,7 @@ class GServer
Logger::info('Set failed status for server', ['url' => $gserver['url']]);
if (strtotime($gserver['next_contact']) < time()) {
Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['url'], false);
UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['url']);
}
}
}
@ -442,18 +446,41 @@ class GServer
*
* @return string cleaned URL
* @throws Exception
* @deprecated since 2023.03 Use cleanUri instead
*/
public static function cleanURL(string $dirtyUrl): string
{
try {
$url = str_replace('/index.php', '', trim($dirtyUrl, '/'));
return (string)(new Uri($url))->withUserInfo('')->withQuery('')->withFragment('');
return (string)self::cleanUri(new Uri($dirtyUrl));
} catch (\Throwable $e) {
Logger::warning('Invalid URL', ['dirtyUrl' => $dirtyUrl, 'url' => $url]);
Logger::warning('Invalid URL', ['dirtyUrl' => $dirtyUrl]);
return '';
}
}
/**
* Remove unwanted content from the given URI
*
* @param UriInterface $dirtyUri
*
* @return UriInterface cleaned URI
* @throws Exception
*/
public static function cleanUri(UriInterface $dirtyUri): string
{
return $dirtyUri
->withUserInfo('')
->withQuery('')
->withFragment('')
->withPath(
preg_replace(
'#(?:^|/)index\.php#',
'',
rtrim($dirtyUri->getPath(), '/')
)
);
}
/**
* Detect server data (type, protocol, version number, ...)
* The detected data is then updated or inserted in the gserver table.

2
src/Model/Post/Link.php
View file

@ -126,7 +126,7 @@ class Link
$timeout = DI::config()->get('system', 'xrd_timeout');
$curlResult = HTTPSignature::fetchRaw($url, 0, [HttpClientOptions::TIMEOUT => $timeout, HttpClientOptions::ACCEPT_CONTENT => $accept]);
if (!$curlResult->isSuccess()) {
if (empty($curlResult) || !$curlResult->isSuccess()) {
return [];
}
$fields = ['mimetype' => $curlResult->getHeader('Content-Type')[0]];

172
src/Module/Admin/Site.php
View file

@ -48,8 +48,6 @@ class Site extends BaseAdmin
self::checkFormSecurityTokenRedirectOnError('/admin/site', 'admin_site');
$a = DI::app();
if (!empty($_POST['republish_directory'])) {
Worker::add(Worker::PRIORITY_LOW, 'Directory');
return;
@ -146,9 +144,11 @@ class Site extends BaseAdmin
$relay_user_tags = !empty($_POST['relay_user_tags']);
$active_panel = (!empty($_POST['active_panel']) ? "#" . trim($_POST['active_panel']) : '');
$transactionConfig = DI::config()->beginTransaction();
// Has the directory url changed? If yes, then resubmit the existing profiles there
if ($global_directory != DI::config()->get('system', 'directory') && ($global_directory != '')) {
DI::config()->set('system', 'directory', $global_directory);
$transactionConfig->set('system', 'directory', $global_directory);
Worker::add(Worker::PRIORITY_LOW, 'Directory');
}
@ -194,131 +194,133 @@ class Site extends BaseAdmin
);
}
}
DI::config()->set('system', 'ssl_policy' , $ssl_policy);
DI::config()->set('system', 'maxloadavg' , $maxloadavg);
DI::config()->set('system', 'min_memory' , $min_memory);
DI::config()->set('system', 'optimize_tables' , $optimize_tables);
DI::config()->set('system', 'contact_discovery' , $contact_discovery);
DI::config()->set('system', 'synchronize_directory' , $synchronize_directory);
DI::config()->set('system', 'poco_requery_days' , $poco_requery_days);
DI::config()->set('system', 'poco_discovery' , $poco_discovery);
DI::config()->set('system', 'poco_local_search' , $poco_local_search);
DI::config()->set('system', 'nodeinfo' , $nodeinfo);
DI::config()->set('config', 'sitename' , $sitename);
DI::config()->set('config', 'sender_email' , $sender_email);
DI::config()->set('system', 'suppress_tags' , $suppress_tags);
DI::config()->set('system', 'shortcut_icon' , $shortcut_icon);
DI::config()->set('system', 'touch_icon' , $touch_icon);
$transactionConfig->set('system', 'ssl_policy' , $ssl_policy);
$transactionConfig->set('system', 'maxloadavg' , $maxloadavg);
$transactionConfig->set('system', 'min_memory' , $min_memory);
$transactionConfig->set('system', 'optimize_tables' , $optimize_tables);
$transactionConfig->set('system', 'contact_discovery' , $contact_discovery);
$transactionConfig->set('system', 'synchronize_directory' , $synchronize_directory);
$transactionConfig->set('system', 'poco_requery_days' , $poco_requery_days);
$transactionConfig->set('system', 'poco_discovery' , $poco_discovery);
$transactionConfig->set('system', 'poco_local_search' , $poco_local_search);
$transactionConfig->set('system', 'nodeinfo' , $nodeinfo);
$transactionConfig->set('config', 'sitename' , $sitename);
$transactionConfig->set('config', 'sender_email' , $sender_email);
$transactionConfig->set('system', 'suppress_tags' , $suppress_tags);
$transactionConfig->set('system', 'shortcut_icon' , $shortcut_icon);
$transactionConfig->set('system', 'touch_icon' , $touch_icon);
if ($banner == "") {
DI::config()->delete('system', 'banner');
$transactionConfig->delete('system', 'banner');
} else {
DI::config()->set('system', 'banner', $banner);
$transactionConfig->set('system', 'banner', $banner);
}
if (empty($email_banner)) {
DI::config()->delete('system', 'email_banner');
$transactionConfig->delete('system', 'email_banner');
} else {
DI::config()->set('system', 'email_banner', $email_banner);
$transactionConfig->set('system', 'email_banner', $email_banner);
}
if (empty($additional_info)) {
DI::config()->delete('config', 'info');
$transactionConfig->delete('config', 'info');
} else {
DI::config()->set('config', 'info', $additional_info);
$transactionConfig->set('config', 'info', $additional_info);
}
DI::config()->set('system', 'language', $language);
DI::config()->set('system', 'theme', $theme);
$transactionConfig->set('system', 'language', $language);
$transactionConfig->set('system', 'theme', $theme);
Theme::install($theme);
if ($theme_mobile == '---') {
DI::config()->delete('system', 'mobile-theme');
$transactionConfig->delete('system', 'mobile-theme');
} else {
DI::config()->set('system', 'mobile-theme', $theme_mobile);
$transactionConfig->set('system', 'mobile-theme', $theme_mobile);
}
if ($singleuser == '---') {
DI::config()->delete('system', 'singleuser');
$transactionConfig->delete('system', 'singleuser');
} else {
DI::config()->set('system', 'singleuser', $singleuser);
$transactionConfig->set('system', 'singleuser', $singleuser);
}
if (preg_match('/\d+(?:\s*[kmg])?/i', $maximagesize)) {
DI::config()->set('system', 'maximagesize', $maximagesize);
$transactionConfig->set('system', 'maximagesize', $maximagesize);
} else {
DI::sysmsg()->addNotice(DI::l10n()->t('%s is no valid input for maximum image size', $maximagesize));
}
DI::config()->set('system', 'max_image_length' , $maximagelength);
DI::config()->set('system', 'jpeg_quality' , $jpegimagequality);
$transactionConfig->set('system', 'max_image_length' , $maximagelength);
$transactionConfig->set('system', 'jpeg_quality' , $jpegimagequality);
DI::config()->set('config', 'register_policy' , $register_policy);
DI::config()->set('system', 'max_daily_registrations', $daily_registrations);
DI::config()->set('system', 'account_abandon_days' , $abandon_days);
DI::config()->set('config', 'register_text' , $register_text);
DI::config()->set('system', 'allowed_sites' , $allowed_sites);
DI::config()->set('system', 'allowed_email' , $allowed_email);
DI::config()->set('system', 'forbidden_nicknames' , $forbidden_nicknames);
DI::config()->set('system', 'system_actor_name' , $system_actor_name);
DI::config()->set('system', 'no_oembed_rich_content' , $no_oembed_rich_content);
DI::config()->set('system', 'allowed_oembed' , $allowed_oembed);
DI::config()->set('system', 'block_public' , $block_public);
DI::config()->set('system', 'publish_all' , $force_publish);
DI::config()->set('system', 'newuser_private' , $newuser_private);
DI::config()->set('system', 'enotify_no_content' , $enotify_no_content);
DI::config()->set('system', 'disable_embedded' , $disable_embedded);
DI::config()->set('system', 'allow_users_remote_self', $allow_users_remote_self);
DI::config()->set('system', 'explicit_content' , $explicit_content);
DI::config()->set('system', 'proxify_content' , $proxify_content);
DI::config()->set('system', 'cache_contact_avatar' , $cache_contact_avatar);
DI::config()->set('system', 'check_new_version_url' , $check_new_version_url);
$transactionConfig->set('config', 'register_policy' , $register_policy);
$transactionConfig->set('system', 'max_daily_registrations', $daily_registrations);
$transactionConfig->set('system', 'account_abandon_days' , $abandon_days);
$transactionConfig->set('config', 'register_text' , $register_text);
$transactionConfig->set('system', 'allowed_sites' , $allowed_sites);
$transactionConfig->set('system', 'allowed_email' , $allowed_email);
$transactionConfig->set('system', 'forbidden_nicknames' , $forbidden_nicknames);
$transactionConfig->set('system', 'system_actor_name' , $system_actor_name);
$transactionConfig->set('system', 'no_oembed_rich_content' , $no_oembed_rich_content);
$transactionConfig->set('system', 'allowed_oembed' , $allowed_oembed);
$transactionConfig->set('system', 'block_public' , $block_public);
$transactionConfig->set('system', 'publish_all' , $force_publish);
$transactionConfig->set('system', 'newuser_private' , $newuser_private);
$transactionConfig->set('system', 'enotify_no_content' , $enotify_no_content);
$transactionConfig->set('system', 'disable_embedded' , $disable_embedded);
$transactionConfig->set('system', 'allow_users_remote_self', $allow_users_remote_self);
$transactionConfig->set('system', 'explicit_content' , $explicit_content);
$transactionConfig->set('system', 'proxify_content' , $proxify_content);
$transactionConfig->set('system', 'cache_contact_avatar' , $cache_contact_avatar);
$transactionConfig->set('system', 'check_new_version_url' , $check_new_version_url);
DI::config()->set('system', 'block_extended_register', !$enable_multi_reg);
DI::config()->set('system', 'no_openid' , !$enable_openid);
DI::config()->set('system', 'no_regfullname' , !$enable_regfullname);
DI::config()->set('system', 'register_notification' , $register_notification);
DI::config()->set('system', 'community_page_style' , $community_page_style);
DI::config()->set('system', 'max_author_posts_community_page', $max_author_posts_community_page);
DI::config()->set('system', 'verifyssl' , $verifyssl);
DI::config()->set('system', 'proxyuser' , $proxyuser);
DI::config()->set('system', 'proxy' , $proxy);
DI::config()->set('system', 'curl_timeout' , $timeout);
DI::config()->set('system', 'imap_disabled' , !$mail_enabled && function_exists('imap_open'));
DI::config()->set('system', 'ostatus_disabled' , !$ostatus_enabled);
DI::config()->set('system', 'diaspora_enabled' , $diaspora_enabled);
$transactionConfig->set('system', 'block_extended_register', !$enable_multi_reg);
$transactionConfig->set('system', 'no_openid' , !$enable_openid);
$transactionConfig->set('system', 'no_regfullname' , !$enable_regfullname);
$transactionConfig->set('system', 'register_notification' , $register_notification);
$transactionConfig->set('system', 'community_page_style' , $community_page_style);
$transactionConfig->set('system', 'max_author_posts_community_page', $max_author_posts_community_page);
$transactionConfig->set('system', 'verifyssl' , $verifyssl);
$transactionConfig->set('system', 'proxyuser' , $proxyuser);
$transactionConfig->set('system', 'proxy' , $proxy);
$transactionConfig->set('system', 'curl_timeout' , $timeout);
$transactionConfig->set('system', 'imap_disabled' , !$mail_enabled && function_exists('imap_open'));
$transactionConfig->set('system', 'ostatus_disabled' , !$ostatus_enabled);
$transactionConfig->set('system', 'diaspora_enabled' , $diaspora_enabled);
DI::config()->set('config', 'private_addons' , $private_addons);
$transactionConfig->set('config', 'private_addons' , $private_addons);
DI::config()->set('system', 'force_ssl' , $force_ssl);
DI::config()->set('system', 'hide_help' , !$show_help);
$transactionConfig->set('system', 'force_ssl' , $force_ssl);
$transactionConfig->set('system', 'hide_help' , !$show_help);
DI::config()->set('system', 'dbclean' , $dbclean);
DI::config()->set('system', 'dbclean-expire-days' , $dbclean_expire_days);
DI::config()->set('system', 'dbclean_expire_conversation', $dbclean_expire_conv);
$transactionConfig->set('system', 'dbclean' , $dbclean);
$transactionConfig->set('system', 'dbclean-expire-days' , $dbclean_expire_days);
$transactionConfig->set('system', 'dbclean_expire_conversation', $dbclean_expire_conv);
if ($dbclean_unclaimed == 0) {
$dbclean_unclaimed = $dbclean_expire_days;
}
DI::config()->set('system', 'dbclean-expire-unclaimed', $dbclean_unclaimed);
$transactionConfig->set('system', 'dbclean-expire-unclaimed', $dbclean_unclaimed);
DI::config()->set('system', 'max_comments', $max_comments);
DI::config()->set('system', 'max_display_comments', $max_display_comments);
$transactionConfig->set('system', 'max_comments', $max_comments);
$transactionConfig->set('system', 'max_display_comments', $max_display_comments);
if ($temppath != '') {
$temppath = BasePath::getRealPath($temppath);
}
DI::config()->set('system', 'temppath', $temppath);
$transactionConfig->set('system', 'temppath', $temppath);
DI::config()->set('system', 'only_tag_search' , $only_tag_search);
DI::config()->set('system', 'compute_group_counts', $compute_group_counts);
$transactionConfig->set('system', 'only_tag_search' , $only_tag_search);
$transactionConfig->set('system', 'compute_group_counts', $compute_group_counts);
DI::config()->set('system', 'worker_queues' , $worker_queues);
DI::config()->set('system', 'worker_fastlane' , $worker_fastlane);
$transactionConfig->set('system', 'worker_queues' , $worker_queues);
$transactionConfig->set('system', 'worker_fastlane' , $worker_fastlane);
DI::config()->set('system', 'relay_directly' , $relay_directly);
DI::config()->set('system', 'relay_scope' , $relay_scope);
DI::config()->set('system', 'relay_server_tags', $relay_server_tags);
DI::config()->set('system', 'relay_deny_tags' , $relay_deny_tags);
DI::config()->set('system', 'relay_user_tags' , $relay_user_tags);
$transactionConfig->set('system', 'relay_directly' , $relay_directly);
$transactionConfig->set('system', 'relay_scope' , $relay_scope);
$transactionConfig->set('system', 'relay_server_tags', $relay_server_tags);
$transactionConfig->set('system', 'relay_deny_tags' , $relay_deny_tags);
$transactionConfig->set('system', 'relay_user_tags' , $relay_user_tags);
$transactionConfig->commit();
DI::baseUrl()->redirect('admin/site' . $active_panel);
}

7
src/Module/Admin/Summary.php
View file

@ -23,6 +23,7 @@ namespace Friendica\Module\Admin;
use Friendica\App;
use Friendica\Core\Addon;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Logger;
use Friendica\Core\Renderer;
@ -114,6 +115,10 @@ class Summary extends BaseAdmin
$warningtext[] = DI::l10n()->t('Friendica\'s configuration now is stored in config/local.config.php, please copy config/local-sample.config.php and move your config from <code>config/local.ini.php</code>. See <a href="%s">the Config help page</a> for help with the transition.', DI::baseUrl()->get() . '/help/Config');
}
if (!DI::configFileManager()->dataIsWritable()) {
$warningtext[] = DI::l10n()->t('Friendica\'s configuration store "%s" isn\'t writable. Until then database updates won\'t be applied automatically, admin settings and console configuration changes won\'t be saved.', ConfigFileManager::CONFIG_DATA_FILE);
}
// Check server vitality
if (!self::checkSelfHostMeta()) {
$well_known = DI::baseUrl()->get() . Probe::HOST_META;
@ -154,7 +159,7 @@ class Summary extends BaseAdmin
}
// check legacy basepath settings
$configLoader = (new Config())->createConfigFileLoader($a->getBasePath(), $_SERVER);
$configLoader = (new Config())->createConfigFileManager($a->getBasePath(), $_SERVER);
$configCache = new Cache();
$configLoader->setupCache($configCache);
$confBasepath = $configCache->get('system', 'basepath');

2
src/Module/Api/ApiResponse.php
View file

@ -99,7 +99,7 @@ class ApiResponse extends Response
$data3 = [$root_element => $data2];
return XML::fromArray($data3, $xml, false, $namespaces);
return XML::fromArray($data3, $dummy, false, $namespaces);
}
/**

2
src/Module/Friendica.php
View file

@ -157,7 +157,7 @@ class Friendica extends BaseModule
$visible_addons = Addon::getVisibleList();
$config->load('feature_lock');
$config->reload();
$locked_features = [];
$featureLocks = $config->get('config', 'feature_lock');
if (isset($featureLocks)) {

2
src/Module/OpenSearch.php
View file

@ -43,8 +43,6 @@ class OpenSearch extends BaseModule
$baseUrl = DI::baseUrl()->get();
/** @var DOMDocument $xml */
$xml = null;
XML::fromArray([
'OpenSearchDescription' => [
'@attributes' => [

3
src/Module/ReallySimpleDiscovery.php
View file

@ -34,7 +34,6 @@ class ReallySimpleDiscovery extends BaseModule
{
protected function rawContent(array $request = [])
{
$xml = null;
$content = XML::fromArray([
'rsd' => [
'@attributes' => [
@ -67,7 +66,7 @@ class ReallySimpleDiscovery extends BaseModule
],
],
],
], $xml);
]);
System::httpExit($content, Response::TYPE_XML);
}
}

4
src/Module/Settings/Display.php
View file

@ -79,7 +79,6 @@ class Display extends BaseSettings
$first_day_of_week = !empty($request['first_day_of_week']) ? intval($request['first_day_of_week']) : 0;
$calendar_default_view = !empty($request['calendar_default_view']) ? trim($request['calendar_default_view']) : 'month';
$infinite_scroll = !empty($request['infinite_scroll']) ? intval($request['infinite_scroll']) : 0;
$no_auto_update = !empty($request['no_auto_update']) ? intval($request['no_auto_update']) : 0;
$enable_smart_threading = !empty($request['enable_smart_threading']) ? intval($request['enable_smart_threading']) : 0;
$enable_dislike = !empty($request['enable_dislike']) ? intval($request['enable_dislike']) : 0;
$display_resharer = !empty($request['display_resharer']) ? intval($request['display_resharer']) : 0;
@ -113,7 +112,6 @@ class Display extends BaseSettings
$this->pConfig->set($uid, 'system', 'itemspage_network' , $itemspage_network);
$this->pConfig->set($uid, 'system', 'itemspage_mobile_network', $itemspage_mobile_network);
$this->pConfig->set($uid, 'system', 'update_interval' , $browser_update);
$this->pConfig->set($uid, 'system', 'no_auto_update' , $no_auto_update);
$this->pConfig->set($uid, 'system', 'no_smilies' , !$enable_smile);
$this->pConfig->set($uid, 'system', 'infinite_scroll' , $infinite_scroll);
$this->pConfig->set($uid, 'system', 'no_smart_threading' , !$enable_smart_threading);
@ -202,7 +200,6 @@ class Display extends BaseSettings
$browser_update = (($browser_update == 0) ? 40 : $browser_update / 1000); // default if not set: 40 seconds
}
$no_auto_update = $this->pConfig->get($uid, 'system', 'no_auto_update', 0);
$enable_smile = !$this->pConfig->get($uid, 'system', 'no_smilies', 0);
$infinite_scroll = $this->pConfig->get($uid, 'system', 'infinite_scroll', 0);
$enable_smart_threading = !$this->pConfig->get($uid, 'system', 'no_smart_threading', 0);
@ -265,7 +262,6 @@ class Display extends BaseSettings
'$itemspage_network' => ['itemspage_network' , $this->t('Number of items to display per page:'), $itemspage_network, $this->t('Maximum of 100 items')],
'$itemspage_mobile_network' => ['itemspage_mobile_network', $this->t('Number of items to display per page when viewed from mobile device:'), $itemspage_mobile_network, $this->t('Maximum of 100 items')],
'$ajaxint' => ['browser_update' , $this->t('Update browser every xx seconds'), $browser_update, $this->t('Minimum of 10 seconds. Enter -1 to disable it.')],
'$no_auto_update' => ['no_auto_update' , $this->t('Automatic updates only at the top of the post stream pages'), $no_auto_update, $this->t('Auto update may add new posts at the top of the post stream pages, which can affect the scroll position and perturb normal reading if it happens anywhere else the top of the page.')],
'$enable_smile' => ['enable_smile' , $this->t('Display emoticons'), $enable_smile, $this->t('When enabled, emoticons are replaced with matching symbols.')],
'$infinite_scroll' => ['infinite_scroll' , $this->t('Infinite scroll'), $infinite_scroll, $this->t('Automatic fetch new items when reaching the page end.')],
'$enable_smart_threading' => ['enable_smart_threading' , $this->t('Enable Smart Threading'), $enable_smart_threading, $this->t('Enable the automatic suppression of extraneous thread indentation.')],

2
src/Module/Update/Community.php
View file

@ -38,7 +38,7 @@ class Community extends CommunityModule
$this->parseRequest();
$o = '';
if (!empty($_GET['force']) || !DI::pConfig()->get(DI::userSession()->getLocalUserId(), 'system', 'no_auto_update')) {
if (!empty($request['force'])) {
$o = DI::conversation()->create(self::getItems(), 'community', true, false, 'commented', DI::userSession()->getLocalUserId());
}

16
src/Module/Update/Network.php
View file

@ -31,19 +31,22 @@ class Network extends NetworkModule
{
protected function rawContent(array $request = [])
{
if (!isset($_GET['p']) || !isset($_GET['item'])) {
if (!isset($request['p']) || !isset($request['item'])) {
System::exit();
}
$this->parseRequest($_GET);
$this->parseRequest($request);
$profile_uid = intval($_GET['p']);
$profile_uid = intval($request['p']);
$o = '';
if (!DI::pConfig()->get($profile_uid, 'system', 'no_auto_update') || ($_GET['force'] == 1)) {
if (!empty($_GET['item'])) {
$item = Post::selectFirst(['parent'], ['id' => $_GET['item']]);
if (empty($request['force'])) {
System::htmlUpdateExit($o);
}
if (!empty($request['item'])) {
$item = Post::selectFirst(['parent'], ['id' => $request['item']]);
$parent = $item['parent'] ?? 0;
} else {
$parent = 0;
@ -76,7 +79,6 @@ class Network extends NetworkModule
}
$o = DI::conversation()->create($items, 'network', $profile_uid, false, $ordering, DI::userSession()->getLocalUserId());
}
System::htmlUpdateExit($o);
}

8
src/Module/Update/Profile.php
View file

@ -39,7 +39,7 @@ class Profile extends BaseModule
$a = DI::app();
// Ensure we've got a profile owner if updating.
$a->setProfileOwner((int)($_GET['p'] ?? 0));
$a->setProfileOwner((int)($request['p'] ?? 0));
if (DI::config()->get('system', 'block_public') && !DI::userSession()->getLocalUserId() && !DI::userSession()->getRemoteContactID($a->getProfileOwner())) {
throw new ForbiddenException();
@ -58,7 +58,7 @@ class Profile extends BaseModule
$o = '';
if (empty($_GET['force']) && DI::pConfig()->get(DI::userSession()->getLocalUserId(), 'system', 'no_auto_update')) {
if (empty($request['force'])) {
System::htmlUpdateExit($o);
}
@ -73,9 +73,9 @@ class Profile extends BaseModule
AND `visible` AND (NOT `deleted` OR `gravity` = ?)
AND `wall` " . $sql_extra, $a->getProfileOwner(), Item::GRAVITY_ACTIVITY];
if ($_GET['force'] && !empty($_GET['item'])) {
if ($request['force'] && !empty($request['item'])) {
// When the parent is provided, we only fetch this
$condition = DBA::mergeConditions($condition, ['parent' => $_GET['item']]);
$condition = DBA::mergeConditions($condition, ['parent' => $request['item']]);
} elseif ($is_owner || !$last_updated) {
// If the page user is the owner of the page we should query for unseen
// items. Otherwise use a timestamp of the last succesful update request.

8
src/Module/WellKnown/HostMeta.php
View file

@ -48,7 +48,6 @@ class HostMeta extends BaseModule
$domain = DI::baseUrl()->get();
$xml = null;
XML::fromArray([
'XRD' => [
'@attributes' => [
@ -81,13 +80,6 @@ class HostMeta extends BaseModule
'href' => $domain . '/amcd'
]
],
'5:link' => [
'@attributes' => [
'rel' => 'http://oexchange.org/spec/0.8/rel/resident-target',
'type' => 'application/xrd+xml',
'href' => $domain . '/oexchange/xrd'
]
],
'Property' => [
'@attributes' => [
'type' => 'http://salmon-protocol.org/ns/magic-key',

8
src/Module/Xrd.php
View file

@ -230,9 +230,7 @@ class Xrd extends BaseModule
{
$baseURL = $this->baseUrl->get();
$xml = null;
XML::fromArray([
$xmlString = XML::fromArray([
'XRD' => [
'@attributes' => [
'xmlns' => 'http://docs.oasis-open.org/ns/xri/xrd-1.0',
@ -319,10 +317,10 @@ class Xrd extends BaseModule
]
],
],
], $xml);
]);
header('Access-Control-Allow-Origin: *');
System::httpExit($xml->saveXML(), Response::TYPE_XML, 'application/xrd+xml');
System::httpExit($xmlString, Response::TYPE_XML, 'application/xrd+xml');
}
}

10
src/Object/Api/Mastodon/Subscription.php
View file

@ -50,11 +50,11 @@ class Subscription extends BaseDataTransferObject
$this->id = (string)$subscription['id'];
$this->endpoint = $subscription['endpoint'];
$this->alerts = [
Notification::TYPE_FOLLOW => $subscription[Notification::TYPE_FOLLOW],
Notification::TYPE_LIKE => $subscription[Notification::TYPE_LIKE],
Notification::TYPE_RESHARE => $subscription[Notification::TYPE_RESHARE],
Notification::TYPE_MENTION => $subscription[Notification::TYPE_MENTION],
Notification::TYPE_POLL => $subscription[Notification::TYPE_POLL],
Notification::TYPE_FOLLOW => (bool)$subscription[Notification::TYPE_FOLLOW],
Notification::TYPE_LIKE => (bool)$subscription[Notification::TYPE_LIKE],
Notification::TYPE_RESHARE => (bool)$subscription[Notification::TYPE_RESHARE],
Notification::TYPE_MENTION => (bool)$subscription[Notification::TYPE_MENTION],
Notification::TYPE_POLL => (bool)$subscription[Notification::TYPE_POLL],
];
$this->server_key = $vapid;

7
src/Protocol/Diaspora.php
View file

@ -2855,7 +2855,7 @@ class Diaspora
$namespaces = ['me' => ActivityNamespace::SALMON_ME];
return XML::fromArray($xmldata, $xml, false, $namespaces);
return XML::fromArray($xmldata, $dummy, false, $namespaces);
}
/**
@ -2974,12 +2974,11 @@ class Diaspora
* @param array $message The message data
*
* @return string The post XML
* @throws \Exception
*/
public static function buildPostXml(string $type, array $message): string
{
$data = [$type => $message];
return XML::fromArray($data, $xml);
return XML::fromArray([$type => $message]);
}
/**

10
src/Protocol/Salmon.php
View file

@ -160,7 +160,7 @@ class Salmon
$namespaces = ['me' => ActivityNamespace::SALMON_ME];
$salmon = XML::fromArray($xmldata, $xml, false, $namespaces);
$salmon = XML::fromArray($xmldata, $dummy, false, $namespaces);
// slap them
$postResult = DI::httpClient()->post($url, $salmon, [
@ -187,9 +187,7 @@ class Salmon
]
];
$namespaces = ['me' => ActivityNamespace::SALMON_ME];
$salmon = XML::fromArray($xmldata, $xml, false, $namespaces);
$salmon = XML::fromArray($xmldata, $dummy, false, $namespaces);
// slap them
$postResult = DI::httpClient()->post($url, $salmon, [
@ -214,9 +212,7 @@ class Salmon
]
];
$namespaces = ['me' => ActivityNamespace::SALMON_ME];
$salmon = XML::fromArray($xmldata, $xml, false, $namespaces);
$salmon = XML::fromArray($xmldata, $dummy, false, $namespaces);
// slap them
$postResult = DI::httpClient()->post($url, $salmon, [

24
src/Util/Network.php
View file

@ -29,6 +29,7 @@ use Friendica\Network\HTTPClient\Client\HttpClientAccept;
use Friendica\Network\HTTPClient\Client\HttpClientOptions;
use Friendica\Network\HTTPException\NotModifiedException;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\UriInterface;
class Network
{
@ -177,11 +178,28 @@ class Network
* @param string $url The url to check the domain from
*
* @return boolean
*
* @deprecated since 2023.03 Use isUriBlocked instead
*/
public static function isUrlBlocked(string $url): bool
{
$host = @parse_url($url, PHP_URL_HOST);
if (!$host) {
try {
return self::isUriBlocked(new Uri($url));
} catch (\Throwable $e) {
Logger::warning('Invalid URL', ['url' => $url]);
return false;
}
}
/**
* Checks if the provided URI domain is on the domain blocklist.
*
* @param UriInterface $uri
* @return boolean
*/
public static function isUriBlocked(UriInterface $uri): bool
{
if (!$uri->getHost()) {
return false;
}
@ -191,7 +209,7 @@ class Network
}
foreach ($domain_blocklist as $domain_block) {
if (fnmatch(strtolower($domain_block['domain']), strtolower($host))) {
if (fnmatch(strtolower($domain_block['domain']), strtolower($uri->getHost()))) {
return true;
}
}

7
src/Util/XML.php
View file

@ -38,13 +38,14 @@ class XML
* Creates an XML structure out of a given array
*
* @param array $array The array of the XML structure that will be generated
* @param object $xml The created XML will be returned by reference
* @param object|null $xml The created XML will be returned by reference
* @param bool $remove_header Should the XML header be removed or not?
* @param array $namespaces List of namespaces
* @param bool $root interally used parameter. Mustn't be used from outside.
* @return string
* @throws \Exception
*/
public static function fromArray(array $array, &$xml, bool $remove_header = false, array $namespaces = [], bool $root = true): string
public static function fromArray(array $array, object &$xml = null, bool $remove_header = false, array $namespaces = [], bool $root = true): string
{
if ($root) {
foreach ($array as $key => $value) {
@ -125,7 +126,7 @@ class XML
if (!is_array($value)) {
$element = $xml->addChild($key, self::escape($value ?? ''), $namespace);
} elseif (is_array($value)) {
} else {
$element = $xml->addChild($key, null, $namespace);
self::fromArray($value, $element, $remove_header, $namespaces, false);
}

2
src/Worker/DBUpdate.php
View file

@ -32,7 +32,7 @@ class DBUpdate
public static function execute()
{
// Just in case the last update wasn't failed
if (DI::config()->get('system', 'update', Update::SUCCESS, true) != Update::FAILED) {
if (DI::config()->get('system', 'update', Update::SUCCESS) != Update::FAILED) {
Update::run(DI::app()->getBasePath());
}
}

11
src/Worker/UpdateContact.php
View file

@ -25,6 +25,7 @@ use Friendica\Core\Logger;
use Friendica\Core\Worker;
use Friendica\Model\Contact;
use Friendica\Network\HTTPException\InternalServerErrorException;
use Friendica\Util\Network;
class UpdateContact
{
@ -38,6 +39,11 @@ class UpdateContact
*/
public static function execute(int $contact_id)
{
// Silently dropping the task if the contact is blocked
if (Contact::isBlocked($contact_id)) {
return;
}
$success = Contact::updateFromProbe($contact_id);
Logger::info('Updated from probe', ['id' => $contact_id, 'success' => $success]);
@ -55,6 +61,11 @@ class UpdateContact
throw new \InvalidArgumentException('Invalid value provided for contact_id');
}
// Dropping the task if the contact is blocked
if (Contact::isBlocked($contact_id)) {
return 0;
}
return Worker::add($run_parameters, 'UpdateContact', $contact_id);
}
}

32
src/Worker/UpdateGServer.php
View file

@ -22,9 +22,14 @@
namespace Friendica\Worker;
use Friendica\Core\Logger;
use Friendica\Core\Worker;
use Friendica\Database\DBA;
use Friendica\Model\GServer;
use Friendica\Network\HTTPException\InternalServerErrorException;
use Friendica\Util\Network;
use Friendica\Util\Strings;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\UriInterface;
class UpdateGServer
{
@ -34,8 +39,9 @@ class UpdateGServer
* @param string $server_url Server URL
* @param boolean $only_nodeinfo Only use nodeinfo for server detection
* @return void
* @throws \Exception
*/
public static function execute(string $server_url, bool $only_nodeinfo = false)
public static function execute(string $server_url, bool $only_nodeinfo)
{
if (empty($server_url)) {
return;
@ -47,6 +53,11 @@ class UpdateGServer
return;
}
// Silently dropping the worker task if the server domain is blocked
if (Network::isUrlBlocked($filtered)) {
return;
}
if (($filtered != $server_url) && DBA::exists('gserver', ['nurl' => Strings::normaliseLink($server_url)])) {
GServer::setFailureByUrl($server_url);
return;
@ -61,4 +72,23 @@ class UpdateGServer
$ret = GServer::check($filtered, '', true, $only_nodeinfo);
Logger::info('Updated gserver', ['url' => $filtered, 'result' => $ret]);
}
/**
* @param array|int $run_parameters Priority constant or array of options described in Worker::add
* @param string $serverUrl
* @param bool $onlyNodeInfo Only use NodeInfo for server detection
* @return int
* @throws InternalServerErrorException
*/
public static function add($run_parameters, string $serverUrl, bool $onlyNodeInfo = false): int
{
// Dropping the worker task if the server domain is blocked
if (Network::isUrlBlocked($serverUrl)) {
return 0;
}
// We have to convert the Uri back to string because worker parameters are saved in JSON format which
// doesn't allow for structured objects.
return Worker::add($run_parameters, 'UpdateGServer', $serverUrl, $onlyNodeInfo);
}
}

5
src/Worker/UpdateGServers.php
View file

@ -27,6 +27,7 @@ use Friendica\Database\DBA;
use Friendica\DI;
use Friendica\Util\DateTimeFormat;
use Friendica\Util\Strings;
use GuzzleHttp\Psr7\Uri;
class UpdateGServers
{
@ -63,12 +64,12 @@ class UpdateGServers
// There are duplicated "url" but not "nurl". So we check both addresses instead of just overwriting them,
// since that would mean loosing data.
if (!empty($gserver['url'])) {
if (Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['url'])) {
if (UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['url'])) {
$count++;
}
}
if (!empty($gserver['nurl']) && ($gserver['nurl'] != Strings::normaliseLink($gserver['url']))) {
if (Worker::add(Worker::PRIORITY_LOW, 'UpdateGServer', $gserver['nurl'])) {
if (UpdateGServer::add(Worker::PRIORITY_LOW, $gserver['nurl'])) {
$count++;
}
}

15
static/dbstructure.config.php
View file

@ -55,7 +55,7 @@
use Friendica\Database\DBA;
if (!defined('DB_UPDATE_VERSION')) {
define('DB_UPDATE_VERSION', 1507);
define('DB_UPDATE_VERSION', 1509);
}
return [
@ -553,19 +553,6 @@ return [
"k_expires" => ["k", "expires"],
]
],
"config" => [
"comment" => "main configuration storage",
"fields" => [
"id" => ["type" => "int unsigned", "not null" => "1", "extra" => "auto_increment", "primary" => "1", "comment" => ""],
"cat" => ["type" => "varbinary(50)", "not null" => "1", "default" => "", "comment" => ""],
"k" => ["type" => "varbinary(50)", "not null" => "1", "default" => "", "comment" => ""],
"v" => ["type" => "mediumtext", "comment" => ""],
],
"indexes" => [
"PRIMARY" => ["id"],
"cat_k" => ["UNIQUE", "cat", "k"],
]
],
"contact-relation" => [
"comment" => "Contact relations",
"fields" => [

12
static/dependencies.config.php
View file

@ -76,10 +76,10 @@ return [
$_SERVER
]
],
Config\Util\ConfigFileLoader::class => [
Config\Util\ConfigFileManager::class => [
'instanceOf' => Config\Factory\Config::class,
'call' => [
['createConfigFileLoader', [
['createConfigFileManager', [
[Dice::INSTANCE => '$basepath'],
$_SERVER,
], Dice::CHAIN_CALL],
@ -88,7 +88,7 @@ return [
Config\ValueObject\Cache::class => [
'instanceOf' => Config\Factory\Config::class,
'call' => [
['createCache', [$_SERVER], Dice::CHAIN_CALL],
['createCache', [], Dice::CHAIN_CALL],
],
],
App\Mode::class => [
@ -98,9 +98,9 @@ return [
],
],
Config\Capability\IManageConfigValues::class => [
'instanceOf' => Config\Factory\Config::class,
'call' => [
['create', [], Dice::CHAIN_CALL],
'instanceOf' => Config\Model\Config::class,
'constructParams' => [
$_SERVER,
],
],
PConfig\Capability\IManagePersonalConfigValues::class => [

4
static/settings.config.php
View file

@ -52,10 +52,6 @@ return [
// Enter 0 for no time limit.
'account_abandon_days' => 0,
// addon (Comma-separated list)
// Manual list of addons which are enabled on this system.
'addon' => '',
// add_missing_posts (boolean)
// Checks for missing entries in "post", "post-thread" or "post-thread-user" and creates them
'add_missing_posts' => false,

13
tests/FixtureTest.php
View file

@ -25,20 +25,24 @@ namespace Friendica\Test;
use Dice\Dice;
use Friendica\App\Arguments;
use Friendica\App\Router;
use Friendica\Core\Config\Factory\Config;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Session\Capability\IHandleSessions;
use Friendica\Core\Session\Type\Memory;
use Friendica\Database\Database;
use Friendica\Database\DBStructure;
use Friendica\DI;
use Friendica\Test\Util\Database\StaticDatabase;
use Friendica\Test\Util\VFSTrait;
/**
* Parent class for test cases requiring fixtures
*/
abstract class FixtureTest extends DatabaseTest
{
use VFSTrait;
/** @var Dice */
protected $dice;
@ -47,6 +51,8 @@ abstract class FixtureTest extends DatabaseTest
*/
protected function setUp(): void
{
$this->setUpVfsDir();
parent::setUp();
$server = $_SERVER;
@ -54,6 +60,10 @@ abstract class FixtureTest extends DatabaseTest
$this->dice = (new Dice())
->addRules(include __DIR__ . '/../static/dependencies.config.php')
->addRule(ConfigFileManager::class, [
'instanceOf' => Config::class,
'call' => [['createConfigFileManager', [$this->root->url(), $server,],
Dice::CHAIN_CALL]]])
->addRule(Database::class, ['instanceOf' => StaticDatabase::class, 'shared' => true])
->addRule(IHandleSessions::class, ['instanceOf' => Memory::class, 'shared' => true, 'call' => null])
->addRule(Arguments::class, [
@ -64,7 +74,6 @@ abstract class FixtureTest extends DatabaseTest
]);
DI::init($this->dice);
/** @var IManageConfigValues $config */
$configCache = $this->dice->create(Cache::class);
$configCache->set('database', 'disable_pdo', true);

15
tests/Util/VFSTrait.php
View file

@ -54,6 +54,21 @@ trait VFSTrait
$this->setConfigFile('defaults.config.php', true);
$this->setConfigFile('settings.config.php', true);
$this->setConfigFile('local.config.php');
$this->setDataFile('node.config.php');
}
protected function setDataFile(string $filename)
{
$file = dirname(__DIR__) . DIRECTORY_SEPARATOR .
'datasets' . DIRECTORY_SEPARATOR .
'config' . DIRECTORY_SEPARATOR .
$filename;
if (file_exists($file)) {
vfsStream::newFile($filename)
->at($this->root->getChild('config'))
->setContent(file_get_contents($file));
}
}
/**

27
tests/datasets/api.fixture.php
View file

@ -36,33 +36,6 @@ return [
'mail',
'post-delivery-data',
// Base test config to avoid notice messages
'config' => [
[
'cat' => 'system',
'k' => 'url',
'v' => 'http://localhost',
],
[
'cat' => 'config',
'k' => 'hostname',
'v' => 'localhost',
],
[
'cat' => 'system',
'k' => 'worker_dont_fork',
'v' => '1',
],
[
'cat' => 'system',
'k' => 'curl_timeout',
'v' => '1',
],
[
'cat' => 'system',
'k' => 'xrd_timeout',
'v' => '1',
],
],
'user' => [
[
'uid' => 42,

22
tests/datasets/config/A.node.config.php Normal file
View file

@ -0,0 +1,22 @@
<?php
return [
'database' => [
'hostname' => 'testhost',
'username' => 'testuser',
'password' => 'testpw',
'database' => 'testdb',
'charset' => 'utf8mb4',
],
'config' => [
'admin_email' => 'admin@test.it',
'sitename' => 'Friendica Social Network',
'register_policy' => 2,
'register_text' => '',
],
'system' => [
'default_timezone' => 'UTC',
'language' => 'en',
'theme' => 'frio',
],
];

39
tests/datasets/config/B.node.config.php Normal file
View file

@ -0,0 +1,39 @@
<?php
return [
'database' => [
'hostname' => 'testhost',
'username' => 'testuser',
'password' => 'testpw',
'database' => 'testdb',
'charset' => 'utf8mb4',
],
'config' => [
'admin_email' => 'admin@test.it',
'sitename' => 'Friendica Social Network',
'register_policy' => 2,
'register_text' => '',
'test' => [
'a' => [
'next' => 'value',
'bool' => false,
'innerArray' => [
'a' => 4.55,
'b' => false,
'string2' => 'false',
],
],
'v' => true,
'v3' => 1,
'v4' => 5.6443,
],
],
'system' => [
'default_timezone' => 'UTC',
'language' => 'en',
'theme' => 'frio',
'int' => 23,
'float' => 2.5,
'with special chars' => 'I can\'t follow this "$&§%"$%§$%&\'[),',
],
];

48
tests/datasets/config/C.node.config.php Normal file
View file

@ -0,0 +1,48 @@
<?php
return [
'config' => [
'hostname' => 'friendica.local',
],
'system' => [
'disable_email_validation' => 1,
'disable_password_exposed' => 1,
'throttle_limit_day' => 100,
'throttle_limit_week' => 100,
'throttle_limit_month' => 100,
'temppath' => '/tmp/friendica.local',
'theme' => 'frio',
'url' => 'https://friendica.local',
'urlpath' => '',
'build' => 1508,
'maintenance' => false,
'dbupdate' => 1,
'update' => 0,
'spoolpath' => '/tmp/localhost/spool',
'actor_name' => 'friendica',
'site_prvkey' => '-----BEGIN PRIVATE KEY-----
MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALgypZoZ2X7rYCHT
pXZRPKZYOJrtzAZoAD6a2FESfax/mW7tGF8/XGcsu4E8a0WUs18CDb09iDlECs0r
WFkyxOsS55FyDPVNOVheU6ziqmjTNggr1qR8iIpPW2xHAnFjCfvJxgaUfszdoeUV
mhA++BrxFGRpfcH49O+dVcjisJEVAgMBAAECgYEAq0QsRkSSvjgMgmdQCdsvEVwm
BafldG9vCsbfK0KOJ73c5A8AAk/fku88yMVs2J2SylwWekakStrBUFNlKkrSXEv3
r1l0b+dfniaTGJkawqgRh+U/0G9LN+cdZYt5EuhNhCbmIQB+FOI12jAx6COwEENi
824zrrwn0BU1VTOMwwECQQDnBqq0J9JCJAtjqX+3xd8DvTRYjYvtvXlQ8fwrGxBc
GwURNG8aMGTaj+sn2kVWNt4wLQqj/CTJ42y0bkKYMJftAkEAzBwSqfuMZD/+nEkM
wDQb1G2z+BaxLh5JJQo80WX9tORbspOkbEuPgFprO6NB0/vNH5m4AaL3jymokH1p
JfVoyQJBAN+GSsmOMdf+qepeiA0V7OXgPXJkWXvHtEZGK1bFk7maBvgThF+RbTMu
xjZD8IwvACEao03wWuPfIEEe4V4Avi0CQCc5FdUYg+gX7CO4XfzphpeR5U29fprw
MvotN3a99L04TO7KNISjGJZ/ya+SNeo4rzhtX9DgslYOmVf64aPrvxECQQDB79vF
Kx2HyacBSErXrlqqkPdFo8KxhKCAVhrs0VBU1WPswolzsZvRdFuielhGP49DjjE7
JV1Als1hl1xTduNb
-----END PRIVATE KEY-----
',
'site_pubkey' => '-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC4MqWaGdl+62Ah06V2UTymWDia
7cwGaAA+mthREn2sf5lu7RhfP1xnLLuBPGtFlLNfAg29PYg5RArNK1hZMsTrEueR
cgz1TTlYXlOs4qpo0zYIK9akfIiKT1tsRwJxYwn7ycYGlH7M3aHlFZoQPvga8RRk
aX3B+PTvnVXI4rCRFQIDAQAB
-----END PUBLIC KEY-----
',
],
];

13
tests/datasets/config/node.config.php Normal file
View file

@ -0,0 +1,13 @@
<?php
return [
'config' => [
'hostname' => 'localhost',
],
'system' => [
'url' => 'http://localhost',
"worker_dont_fork" => 1,
"curl_timeout"=> 1,
"xrd_timeout"=> 1,
],
];

11
tests/functional/DependencyCheckTest.php
View file

@ -31,7 +31,7 @@ use Friendica\Core\Lock\Capability\ICanLock;
use Friendica\Database\Database;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\BasePath;
use Friendica\Core\Config\Util\ConfigFileLoader;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Util\Profiler;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
@ -73,13 +73,13 @@ class DependencyCheckTest extends TestCase
*/
public function testConfigFileLoader()
{
/** @var ConfigFileLoader $configFileLoader */
$configFileLoader = $this->dice->create(ConfigFileLoader::class);
/** @var ConfigFileManager $configFileManager */
$configFileManager = $this->dice->create(ConfigFileManager::class);
self::assertInstanceOf(ConfigFileLoader::class, $configFileLoader);
self::assertInstanceOf(ConfigFileManager::class, $configFileManager);
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
$configFileManager->setupCache($configCache);
self::assertNotEmpty($configCache->getAll());
self::assertArrayHasKey('database', $configCache->getAll());
@ -150,7 +150,6 @@ class DependencyCheckTest extends TestCase
self::assertTrue($mode->has(App\Mode::LOCALCONFIGPRESENT), 'No local config present');
self::assertTrue($mode->has(App\Mode::DBAVAILABLE), 'Database is not available');
self::assertTrue($mode->has(App\Mode::DBCONFIGAVAILABLE), 'Database config is not available');
self::assertTrue($mode->has(App\Mode::MAINTENANCEDISABLED), 'In maintenance mode');
self::assertTrue($mode->isNormal(), 'Not in normal mode');

31
tests/src/App/ModeTest.php
View file

@ -102,29 +102,11 @@ class ModeTest extends MockedTest
self::assertFalse($mode->has(Mode::DBAVAILABLE));
}
public function testWithoutDatabaseSetup()
{
$this->basePathMock->shouldReceive('getPath')->andReturn($this->root->url())->once();
$this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
$this->databaseMock->shouldReceive('fetchFirst')
->with('SHOW TABLES LIKE \'config\'')->andReturn(false)->once();
$mode = (new Mode())->determine($this->basePathMock, $this->databaseMock, $this->configCacheMock);
self::assertFalse($mode->isNormal());
self::assertTrue($mode->isInstall());
self::assertTrue($mode->has(Mode::LOCALCONFIGPRESENT));
}
public function testWithMaintenanceMode()
{
$this->basePathMock->shouldReceive('getPath')->andReturn($this->root->url())->once();
$this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
$this->databaseMock->shouldReceive('fetchFirst')
->with('SHOW TABLES LIKE \'config\'')->andReturn(true)->once();
$this->configCacheMock->shouldReceive('get')->with('system', 'maintenance')
->andReturn(true)->once();
@ -133,7 +115,6 @@ class ModeTest extends MockedTest
self::assertFalse($mode->isNormal());
self::assertFalse($mode->isInstall());
self::assertTrue($mode->has(Mode::DBCONFIGAVAILABLE));
self::assertFalse($mode->has(Mode::MAINTENANCEDISABLED));
}
@ -142,20 +123,14 @@ class ModeTest extends MockedTest
$this->basePathMock->shouldReceive('getPath')->andReturn($this->root->url())->once();
$this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
$this->databaseMock->shouldReceive('fetchFirst')
->with('SHOW TABLES LIKE \'config\'')->andReturn(true)->once();
$this->configCacheMock->shouldReceive('get')->with('system', 'maintenance')
->andReturn(false)->once();
$this->databaseMock->shouldReceive('selectFirst')
->with('config', ['v'], ['cat' => 'system', 'k' => 'maintenance'])
->andReturn(['v' => null])->once();
$mode = (new Mode())->determine($this->basePathMock, $this->databaseMock, $this->configCacheMock);
self::assertTrue($mode->isNormal());
self::assertFalse($mode->isInstall());
self::assertTrue($mode->has(Mode::DBCONFIGAVAILABLE));
self::assertTrue($mode->has(Mode::MAINTENANCEDISABLED));
}
@ -167,20 +142,14 @@ class ModeTest extends MockedTest
$this->basePathMock->shouldReceive('getPath')->andReturn($this->root->url())->once();
$this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
$this->databaseMock->shouldReceive('fetchFirst')
->with('SHOW TABLES LIKE \'config\'')->andReturn(true)->once();
$this->configCacheMock->shouldReceive('get')->with('system', 'maintenance')
->andReturn(false)->once();
$this->databaseMock->shouldReceive('selectFirst')
->with('config', ['v'], ['cat' => 'system', 'k' => 'maintenance'])
->andReturn(['v' => '0'])->once();
$mode = (new Mode())->determine($this->basePathMock, $this->databaseMock, $this->configCacheMock);
self::assertTrue($mode->isNormal());
self::assertFalse($mode->isInstall());
self::assertTrue($mode->has(Mode::DBCONFIGAVAILABLE));
self::assertTrue($mode->has(Mode::MAINTENANCEDISABLED));
}

4
tests/src/Core/Cache/DatabaseCacheTest.php
View file

@ -55,8 +55,8 @@ class DatabaseCacheTest extends CacheTest
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new Config();
$loader = (new Config())->createConfigFileLoader($this->root->url(), []);
$configCache = $configFactory->createCache($loader);
$configFileManager = (new Config())->createConfigFileManager($this->root->url(), []);
$configCache = $configFactory->createCache($configFileManager);
$dbaDefinition = (new DbaDefinition($configCache->get('system', 'basepath')))->load();
$viewDefinition = (new ViewDefinition($configCache->get('system', 'basepath')))->load();

237
tests/src/Core/Config/Cache/CacheTest.php
View file

@ -21,7 +21,7 @@
namespace Friendica\Test\src\Core\Config\Cache;
use Friendica\Core\Config\Cache;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use ParagonIE\HiddenString\HiddenString;
use stdClass;
@ -49,7 +49,7 @@ class CacheTest extends MockedTest
];
}
private function assertConfigValues($data, \Friendica\Core\Config\ValueObject\Cache $configCache)
private function assertConfigValues($data, Cache $configCache)
{
foreach ($data as $cat => $values) {
foreach ($values as $key => $value) {
@ -64,7 +64,7 @@ class CacheTest extends MockedTest
*/
public function testLoadConfigArray($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configCache->load($data);
self::assertConfigValues($data, $configCache);
@ -83,27 +83,27 @@ class CacheTest extends MockedTest
]
];
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache->load($data, \Friendica\Core\Config\ValueObject\Cache::SOURCE_DB);
$configCache = new Cache();
$configCache->load($data, Cache::SOURCE_DATA);
// doesn't override - Low Priority due Config file
$configCache->load($override, \Friendica\Core\Config\ValueObject\Cache::SOURCE_FILE);
$configCache->load($override, Cache::SOURCE_FILE);
self::assertConfigValues($data, $configCache);
// override the value - High Prio due Server Env
$configCache->load($override, \Friendica\Core\Config\ValueObject\Cache::SOURCE_ENV);
$configCache->load($override, Cache::SOURCE_ENV);
self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
// Don't overwrite server ENV variables - even in load mode
$configCache->load($data, \Friendica\Core\Config\ValueObject\Cache::SOURCE_DB);
$configCache->load($data, Cache::SOURCE_DATA);
self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
// Overwrite ENV variables with ENV variables
$configCache->load($data, \Friendica\Core\Config\ValueObject\Cache::SOURCE_ENV);
$configCache->load($data, Cache::SOURCE_ENV);
self::assertConfigValues($data, $configCache);
self::assertNotEquals($override['system']['test'], $configCache->get('system', 'test'));
@ -111,11 +111,11 @@ class CacheTest extends MockedTest
}
/**
* Test the loadConfigArray() method with wrong/empty datasets
* Test the loadConfigArray() method with only a category
*/
public function testLoadConfigArrayWrong()
public function testLoadConfigArrayWithOnlyCategory()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
// empty dataset
$configCache->load([]);
@ -123,9 +123,10 @@ class CacheTest extends MockedTest
// wrong dataset
$configCache->load(['system' => 'not_array']);
self::assertEmpty($configCache->getAll());
self::assertEquals(['system' => 'not_array'], $configCache->getAll());
// incomplete dataset (key is integer ID of the array)
$configCache = new Cache();
$configCache->load(['system' => ['value']]);
self::assertEquals('value', $configCache->get('system', 0));
}
@ -136,7 +137,7 @@ class CacheTest extends MockedTest
*/
public function testGetAll($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configCache->load($data);
$all = $configCache->getAll();
@ -151,7 +152,7 @@ class CacheTest extends MockedTest
*/
public function testSetGet($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
foreach ($data as $cat => $values) {
foreach ($values as $key => $value) {
@ -167,7 +168,7 @@ class CacheTest extends MockedTest
*/
public function testGetEmpty()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
self::assertNull($configCache->get('something', 'value'));
}
@ -177,7 +178,7 @@ class CacheTest extends MockedTest
*/
public function testGetCat()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'system' => [
'key1' => 'value1',
'key2' => 'value2',
@ -205,15 +206,18 @@ class CacheTest extends MockedTest
*/
public function testDelete($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache($data);
$configCache = new Cache($data);
$assertion = [];
foreach ($data as $cat => $values) {
$assertion[$cat] = null;
foreach ($values as $key => $value) {
$configCache->delete($cat, $key);
}
}
self::assertEmpty($configCache->getAll());
self::assertEquals($assertion, $configCache->getAll());
}
/**
@ -222,7 +226,7 @@ class CacheTest extends MockedTest
*/
public function testKeyDiffWithResult($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache($data);
$configCache = new Cache($data);
$diffConfig = [
'fakeCat' => [
@ -239,7 +243,7 @@ class CacheTest extends MockedTest
*/
public function testKeyDiffWithoutResult($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache($data);
$configCache = new Cache($data);
$diffConfig = $configCache->getAll();
@ -251,7 +255,7 @@ class CacheTest extends MockedTest
*/
public function testPasswordHide()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'database' => [
'password' => 'supersecure',
'username' => 'notsecured',
@ -268,7 +272,7 @@ class CacheTest extends MockedTest
*/
public function testPasswordShow()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'database' => [
'password' => 'supersecure',
'username' => 'notsecured',
@ -285,7 +289,7 @@ class CacheTest extends MockedTest
*/
public function testEmptyPassword()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'database' => [
'password' => '',
'username' => '',
@ -299,7 +303,7 @@ class CacheTest extends MockedTest
public function testWrongTypePassword()
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'database' => [
'password' => new stdClass(),
'username' => '',
@ -309,7 +313,7 @@ class CacheTest extends MockedTest
self::assertNotEmpty($configCache->get('database', 'password'));
self::assertEmpty($configCache->get('database', 'username'));
$configCache = new \Friendica\Core\Config\ValueObject\Cache([
$configCache = new Cache([
'database' => [
'password' => 23,
'username' => '',
@ -327,19 +331,190 @@ class CacheTest extends MockedTest
public function testSetOverrides($data)
{
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache->load($data, \Friendica\Core\Config\ValueObject\Cache::SOURCE_DB);
$configCache = new Cache();
$configCache->load($data, Cache::SOURCE_DATA);
// test with wrong override
self::assertFalse($configCache->set('system', 'test', '1234567', \Friendica\Core\Config\ValueObject\Cache::SOURCE_FILE));
self::assertFalse($configCache->set('system', 'test', '1234567', Cache::SOURCE_FILE));
self::assertEquals($data['system']['test'], $configCache->get('system', 'test'));
// test with override (equal)
self::assertTrue($configCache->set('system', 'test', '8910', \Friendica\Core\Config\ValueObject\Cache::SOURCE_DB));
self::assertTrue($configCache->set('system', 'test', '8910', Cache::SOURCE_DATA));
self::assertEquals('8910', $configCache->get('system', 'test'));
// test with override (over)
self::assertTrue($configCache->set('system', 'test', '111213', \Friendica\Core\Config\ValueObject\Cache::SOURCE_ENV));
self::assertTrue($configCache->set('system', 'test', '111213', Cache::SOURCE_ENV));
self::assertEquals('111213', $configCache->get('system', 'test'));
}
/**
* @dataProvider dataTests
*
* @return void
*/
public function testSetData($data)
{
$configCache = new Cache();
$configCache->load($data, Cache::SOURCE_FILE);
$configCache->set('system', 'test_2','with_data', Cache::SOURCE_DATA);
$this->assertEquals(['system' => ['test_2' => 'with_data']], $configCache->getDataBySource(Cache::SOURCE_DATA));
$this->assertEquals($data, $configCache->getDataBySource(Cache::SOURCE_FILE));
}
/**
* @dataProvider dataTests
*/
public function testMerge($data)
{
$configCache = new Cache();
$configCache->load($data, Cache::SOURCE_FILE);
$configCache->set('system', 'test_2','with_data', Cache::SOURCE_DATA);
$configCache->set('config', 'test_override','with_another_data', Cache::SOURCE_DATA);
$configCache->set('old_category', 'test_45','given category', Cache::SOURCE_DATA);
$newCache = new Cache();
$newCache->set('config', 'test_override','override it again', Cache::SOURCE_DATA);
$newCache->set('system', 'test_3','new value', Cache::SOURCE_DATA);
$newCache->set('new_category', 'test_23','added category', Cache::SOURCE_DATA);
$mergedCache = $configCache->merge($newCache);
self::assertEquals('with_data', $mergedCache->get('system', 'test_2'));
self::assertEquals('override it again', $mergedCache->get('config', 'test_override'));
self::assertEquals('new value', $mergedCache->get('system', 'test_3'));
self::assertEquals('given category', $mergedCache->get('old_category', 'test_45'));
self::assertEquals('added category', $mergedCache->get('new_category', 'test_23'));
}
public function dataTestCat()
{
return [
'test_with_hashmap' => [
'data' => [
'test_with_hashmap' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => true,
],
'blockbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_hashmap',
'assertion' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => true,
],
'blockbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
],
'test_with_keys' => [
'data' => [
'test_with_keys' => [
[
'last_update' => 1671051565,
'admin' => true,
],
[
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_keys',
'assertion' => [
[
'last_update' => 1671051565,
'admin' => true,
],
[
'last_update' => 1658952852,
'admin' => true,
],
],
],
'test_with_inner_array' => [
'data' => [
'test_with_inner_array' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => [
'yes' => true,
'no' => 1.5,
],
],
'blogbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_inner_array',
'assertion' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => [
'yes' => true,
'no' => 1.5,
],
],
'blogbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
],
];
}
/**
* Tests that the Cache can return a whole category at once
*
* @dataProvider dataTestCat
*/
public function testGetCategory(array $data, string $category, array $assertion)
{
$cache = new Cache($data);
self::assertEquals($assertion, $cache->get($category));
}
}

177
tests/src/Core/Config/Cache/ConfigFileLoaderTest.php → tests/src/Core/Config/Cache/ConfigFileManagerTest.php
View file

@ -21,14 +21,14 @@
namespace Friendica\Test\src\Core\Config\Cache;
use Friendica\Core\Config\Cache;
use Friendica\Core\Config\Factory\Config;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\VFSTrait;
use Friendica\Core\Config\Util\ConfigFileLoader;
use Friendica\Core\Config\Util\ConfigFileManager;
use org\bovigo\vfs\vfsStream;
class ConfigFileLoaderTest extends MockedTest
class ConfigFileManagerTest extends MockedTest
{
use VFSTrait;
@ -46,12 +46,13 @@ class ConfigFileLoaderTest extends MockedTest
{
$this->delConfigFile('local.config.php');
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -72,12 +73,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent('<?php return true;');
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
}
@ -101,12 +102,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent(file_get_contents($file));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -138,12 +139,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent(file_get_contents($file));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -174,12 +175,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root)
->setContent(file_get_contents($file));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -228,7 +229,7 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('addon')->getChild('test')->getChild('config'))
->setContent(file_get_contents($file));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
@ -265,12 +266,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -299,12 +300,12 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.ini.php'));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -333,12 +334,13 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.ini.php'));
$configFileLoader = new ConfigFileLoader(
$configFileLoader = new ConfigFileManager(
$this->root->url(),
$this->root->url() . DIRECTORY_SEPARATOR . Config::CONFIG_DIR,
$this->root->url() . DIRECTORY_SEPARATOR . Config::STATIC_DIR
);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
@ -353,10 +355,10 @@ class ConfigFileLoaderTest extends MockedTest
{
$this->delConfigFile('local.config.php');
$configFileLoader = (new Config())->createConfigFileLoader($this->root->url(), ['FRIENDICA_CONFIG_DIR' => '/a/wrong/dir/']);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configFileManager = (new Config())->createConfigFileManager($this->root->url(), ['FRIENDICA_CONFIG_DIR' => '/a/wrong/dir/']);
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
$configFileManager->setupCache($configCache);
self::assertEquals($this->root->url(), $configCache->get('system', 'basepath'));
}
@ -379,11 +381,134 @@ class ConfigFileLoaderTest extends MockedTest
->at($this->root->getChild('config2'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
$configFileLoader = (new Config())->createConfigFileLoader($this->root->url(), ['FRIENDICA_CONFIG_DIR' => $this->root->getChild('config2')->url()]);
$configCache = new \Friendica\Core\Config\ValueObject\Cache();
$configFileManager = (new Config())->createConfigFileManager($this->root->url(),
[
'FRIENDICA_CONFIG_DIR' => $this->root->getChild('config2')->url(),
]);
$configCache = new Cache();
$configFileLoader->setupCache($configCache);
$configFileManager->setupCache($configCache);
self::assertEquals('newValue', $configCache->get('system', 'newKey'));
}
public function testSaveData()
{
$this->delConfigFile('local.config.php');
$fileDir = dirname(__DIR__) . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'datasets' . DIRECTORY_SEPARATOR .
'config' . DIRECTORY_SEPARATOR;
vfsStream::newFile('B.config.php')
->at($this->root->getChild('config2'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
$configFileManager = (new Config())->createConfigFileManager($this->root->url(),
[
'FRIENDICA_CONFIG_DIR' => $this->root->getChild('config2')->url(),
]);
$configCache = new Cache();
$configFileManager->setupCache($configCache);
$specialChars = '!"§$%&/()(/&%$\'><?$a,;:[]}{}\\?¿¿ß';
// overwrite some data and save it back to the config file
$configCache->set('system', 'test', 'it', Cache::SOURCE_DATA);
$configCache->set('config', 'test', 'it', Cache::SOURCE_DATA);
$configCache->set('system', 'test_2', 2, Cache::SOURCE_DATA);
$configCache->set('special_chars', 'special', $specialChars, Cache::SOURCE_DATA);
$configFileManager->saveData($configCache);
// Reload the configCache with the new values
$configCache2 = new Cache();
$configFileManager->setupCache($configCache2);
self::assertEquals($configCache, $configCache2);
self::assertEquals([
'system' => [
'test' => 'it',
'test_2' => 2
],
'config' => [
'test' => 'it',
],
'special_chars' => [
'special' => $specialChars,
]], $configCache2->getDataBySource(Cache::SOURCE_DATA));
}
/**
* If we delete something with the Cache::delete() functionality, be sure to override the underlying source as well
*/
public function testDeleteKeyOverwrite()
{
$this->delConfigFile('node.config.php');
$fileDir = dirname(__DIR__) . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'datasets' . DIRECTORY_SEPARATOR .
'config' . DIRECTORY_SEPARATOR;
vfsStream::newFile('B.config.php')
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
$configFileManager = (new Config())->createConfigFileManager($this->root->url());
$configCache = new Cache();
$configFileManager->setupCache($configCache);
$configCache->delete('system', 'default_timezone', Cache::SOURCE_DATA);
$configFileManager->saveData($configCache);
// assert that system.default_timezone is now null, even it's set with settings.conf.php
$configCache = new Cache();
$configFileManager->setupCache($configCache);
self::assertNull($configCache->get('system', 'default_timezone'));
}
/**
* If we delete something with the Cache::delete() functionality, be sure to override the underlying source as well
*/
public function testDeleteCategoryOverwrite()
{
$this->delConfigFile('node.config.php');
$fileDir = dirname(__DIR__) . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'..' . DIRECTORY_SEPARATOR .
'datasets' . DIRECTORY_SEPARATOR .
'config' . DIRECTORY_SEPARATOR;
vfsStream::newFile('B.config.php')
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
$configFileManager = (new Config())->createConfigFileManager($this->root->url());
$configCache = new Cache();
$configFileManager->setupCache($configCache);
$configCache->delete('system');
$configFileManager->saveData($configCache);
// assert that system.default_timezone is now null, even it's set with settings.conf.php
$configCache = new Cache();
$configFileManager->setupCache($configCache);
self::assertNull($configCache->get('system', 'default_timezone'));
}
}

309
tests/src/Core/Config/ConfigTest.php
View file

@ -23,22 +23,25 @@ namespace Friendica\Test\src\Core\Config;
use DMS\PHPUnitExtensions\ArraySubset\ArraySubsetAsserts;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Repository\Config as ConfigModel;
use Friendica\Core\Config\Model\Config;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\Util\ConfigFileTransformer;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use Mockery\MockInterface;
use Mockery;
use Friendica\Test\Util\VFSTrait;
use org\bovigo\vfs\vfsStream;
abstract class ConfigTest extends MockedTest
class ConfigTest extends MockedTest
{
use ArraySubsetAsserts;
/** @var ConfigModel|MockInterface */
protected $configModel;
use VFSTrait;
/** @var Cache */
protected $configCache;
/** @var ConfigFileManager */
protected $configFileManager;
/** @var IManageConfigValues */
protected $testedConfig;
@ -60,17 +63,22 @@ abstract class ConfigTest extends MockedTest
protected function setUp(): void
{
$this->setUpVfsDir();
parent::setUp();
// Create the config model
$this->configModel = Mockery::mock(ConfigModel::class);
$this->configCache = new Cache();
$this->configFileManager = new ConfigFileManager($this->root->url(), $this->root->url() . '/config/', $this->root->url() . '/static/');
}
/**
* @return IManageConfigValues
*/
abstract public function getInstance();
public function getInstance()
{
$this->configFileManager->setupCache($this->configCache);
return new Config($this->configFileManager, $this->configCache);
}
public function dataTests()
{
@ -156,12 +164,13 @@ abstract class ConfigTest extends MockedTest
/**
* Test the configuration initialization
* @dataProvider dataConfigLoad
*/
public function testSetUp(array $data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->once();
vfsStream::newFile(ConfigFileManager::CONFIG_DATA_FILE)
->at($this->root->getChild('config'))
->setContent(ConfigFileTransformer::encode($data));
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
@ -171,19 +180,23 @@ abstract class ConfigTest extends MockedTest
}
/**
* Test the configuration load() method
* Test the configuration reload() method
*
* @param array $data
* @param array $load
*
* @dataProvider dataConfigLoad
*/
public function testLoad(array $data, array $load)
public function testReload(array $data, array $load)
{
vfsStream::newFile(ConfigFileManager::CONFIG_DATA_FILE)
->at($this->root->getChild('config'))
->setContent(ConfigFileTransformer::encode($data));
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($load as $loadedCats) {
$this->testedConfig->load($loadedCats);
}
$this->testedConfig->reload();
// Assert at least loaded cats are loaded
foreach ($load as $loadedCats) {
@ -256,23 +269,31 @@ abstract class ConfigTest extends MockedTest
/**
* Test the configuration load() method with overwrite
*
* @dataProvider dataDoubleLoad
*/
public function testCacheLoadDouble(array $data1, array $data2, array $expect = [])
{
vfsStream::newFile(ConfigFileManager::CONFIG_DATA_FILE)
->at($this->root->getChild('config'))
->setContent(ConfigFileTransformer::encode($data1));
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($data1 as $cat => $data) {
$this->testedConfig->load($cat);
}
// Assert at least loaded cats are loaded
foreach ($data1 as $cat => $data) {
self::assertConfig($cat, $data);
}
vfsStream::newFile(ConfigFileManager::CONFIG_DATA_FILE)
->at($this->root->getChild('config'))
->setContent(ConfigFileTransformer::encode($data2));
$this->testedConfig->reload();
foreach ($data2 as $cat => $data) {
$this->testedConfig->load($cat);
self::assertConfig($cat, $data);
}
}
@ -281,44 +302,19 @@ abstract class ConfigTest extends MockedTest
*/
public function testLoadWrong()
{
$this->configModel->shouldReceive('isConnected')->andReturn(true)->once();
$this->configModel->shouldReceive('load')->withAnyArgs()->andReturn([])->once();
$this->testedConfig = $this->getInstance();
$this->testedConfig = new Config($this->configFileManager, new Cache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
* Test the configuration get() and set() methods without adapter
* Test the configuration get() and set() methods
*
* @dataProvider dataTests
*/
public function testSetGetWithoutDB($data)
public function testSetGet($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(false)
->times(3);
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertTrue($this->testedConfig->set('test', 'it', $data));
self::assertEquals($data, $this->testedConfig->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
}
/**
* Test the configuration get() and set() methods with a model/db
*
* @dataProvider dataTests
*/
public function testSetGetWithDB($data)
{
$this->configModel->shouldReceive('set')->with('test', 'it', $data)->andReturn(true)->once();
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
@ -349,41 +345,16 @@ abstract class ConfigTest extends MockedTest
self::assertEquals('default', $this->testedConfig->get('test', 'it', 'default', true));
}
/**
* Test the configuration get() method with refresh
*
* @dataProvider dataTests
*/
public function testGetWithRefresh($data)
{
$this->configCache->load(['test' => ['it' => 'now']], Cache::SOURCE_FILE);
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// without refresh
self::assertEquals('now', $this->testedConfig->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
// with refresh
self::assertEquals($data, $this->testedConfig->get('test', 'it', null, true));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
// without refresh and wrong value and default
self::assertEquals('default', $this->testedConfig->get('test', 'not', 'default'));
self::assertNull($this->testedConfig->getCache()->get('test', 'not'));
}
/**
* Test the configuration delete() method without a model/db
*
* @dataProvider dataTests
*/
public function testDeleteWithoutDB($data)
public function testDelete($data)
{
$this->configCache->load(['test' => ['it' => $data]], Cache::SOURCE_FILE);
$this->testedConfig = $this->getInstance();
$this->testedConfig = new Config($this->configFileManager, $this->configCache);
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertEquals($data, $this->testedConfig->get('test', 'it'));
@ -393,52 +364,7 @@ abstract class ConfigTest extends MockedTest
self::assertNull($this->testedConfig->get('test', 'it'));
self::assertNull($this->testedConfig->getCache()->get('test', 'it'));
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
* Test the configuration delete() method with a model/db
*/
public function testDeleteWithDB()
{
$this->configCache->load(['test' => ['it' => 'now', 'quarter' => 'true']], Cache::SOURCE_FILE);
$this->configModel->shouldReceive('delete')
->with('test', 'it')
->andReturn(false)
->once();
$this->configModel->shouldReceive('delete')
->with('test', 'second')
->andReturn(true)
->once();
$this->configModel->shouldReceive('delete')
->with('test', 'third')
->andReturn(false)
->once();
$this->configModel->shouldReceive('delete')
->with('test', 'quarter')
->andReturn(true)
->once();
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// directly set the value to the cache
$this->testedConfig->getCache()->set('test', 'it', 'now');
self::assertEquals('now', $this->testedConfig->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
// delete from cache only
self::assertTrue($this->testedConfig->delete('test', 'it'));
// delete from db only
self::assertTrue($this->testedConfig->delete('test', 'second'));
// no delete
self::assertFalse($this->testedConfig->delete('test', 'third'));
// delete both
self::assertTrue($this->testedConfig->delete('test', 'quarter'));
self::assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEquals(['test' => null], $this->testedConfig->getCache()->getAll());
}
/**
@ -462,6 +388,12 @@ abstract class ConfigTest extends MockedTest
*/
public function testSetGetLowPrio()
{
vfsStream::newFile(ConfigFileManager::CONFIG_DATA_FILE)
->at($this->root->getChild('config'))
->setContent(ConfigFileTransformer::encode([
'config' => ['test' => 'it'],
]));
$this->testedConfig = $this->getInstance();
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertEquals('it', $this->testedConfig->get('config', 'test'));
@ -471,4 +403,133 @@ abstract class ConfigTest extends MockedTest
self::assertFalse($this->testedConfig->set('config', 'test', '123'));
self::assertEquals('prio', $this->testedConfig->get('config', 'test', '', true));
}
public function dataTestCat()
{
return [
'test_with_hashmap' => [
'data' => [
'test_with_hashmap' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => true,
],
'blockbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_hashmap',
'assertion' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => true,
],
'blockbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
],
'test_with_keys' => [
'data' => [
'test_with_keys' => [
[
'last_update' => 1671051565,
'admin' => true,
],
[
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_keys',
'assertion' => [
[
'last_update' => 1671051565,
'admin' => true,
],
[
'last_update' => 1658952852,
'admin' => true,
],
],
],
'test_with_inner_array' => [
'data' => [
'test_with_inner_array' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => [
'yes' => true,
'no' => 1.5,
],
],
'blogbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
'config' => [
'register_policy' => 2,
'register_text' => '',
'sitename' => 'Friendica Social Network23',
'hostname' => 'friendica.local',
'private_addons' => false,
],
'system' => [
'dbclean_expire_conversation' => 90,
],
],
'cat' => 'test_with_inner_array',
'assertion' => [
'notifyall' => [
'last_update' => 1671051565,
'admin' => [
'yes' => true,
'no' => 1.5,
],
],
'blogbot' => [
'last_update' => 1658952852,
'admin' => true,
],
],
],
];
}
/**
* @dataProvider dataTestCat
*/
public function testGetCategory(array $data, string $category, array $assertion)
{
$this->configCache = new Cache($data);
$config = new Config($this->configFileManager, $this->configCache);
self::assertEquals($assertion, $config->get($category));
}
}

142
tests/src/Core/Config/ConfigTransactionTest.php Normal file
View file

@ -0,0 +1,142 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Test\src\Core\Config;
use Friendica\Core\Config\Capability\ISetConfigValuesTransactionally;
use Friendica\Core\Config\Model\Config;
use Friendica\Core\Config\Model\ConfigTransaction;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\VFSTrait;
use Mockery\Exception\InvalidCountException;
class ConfigTransactionTest extends MockedTest
{
use VFSTrait;
/** @var ConfigFileManager */
protected $configFileManager;
protected function setUp(): void
{
parent::setUp();
$this->setUpVfsDir();
$this->configFileManager = new ConfigFileManager($this->root->url(), $this->root->url() . '/config/', $this->root->url() . '/static/');
}
public function dataTests(): array
{
return [
'default' => [
'data' => include dirname(__FILE__, 4) . '/datasets/B.node.config.php',
]
];
}
public function testInstance()
{
$config = new Config($this->configFileManager, new Cache());
$configTransaction = new ConfigTransaction($config);
self::assertInstanceOf(ISetConfigValuesTransactionally::class, $configTransaction);
self::assertInstanceOf(ConfigTransaction::class, $configTransaction);
}
public function testConfigTransaction()
{
$config = new Config($this->configFileManager, new Cache());
$config->set('config', 'key1', 'value1');
$config->set('system', 'key2', 'value2');
$config->set('system', 'keyDel', 'valueDel');
$config->set('delete', 'keyDel', 'catDel');
$configTransaction = new ConfigTransaction($config);
// the config file knows it as well immediately
$tempData = include $this->root->url() . '/config/' . ConfigFileManager::CONFIG_DATA_FILE;
self::assertEquals('value1', $tempData['config']['key1'] ?? null);
self::assertEquals('value2', $tempData['system']['key2'] ?? null);
// new key-value
$configTransaction->set('transaction', 'key3', 'value3');
// overwrite key-value
$configTransaction->set('config', 'key1', 'changedValue1');
// delete key-value
$configTransaction->delete('system', 'keyDel');
// delete last key of category - so the category is gone
$configTransaction->delete('delete', 'keyDel');
// The main config still doesn't know about the change
self::assertNull($config->get('transaction', 'key3'));
self::assertEquals('value1', $config->get('config', 'key1'));
self::assertEquals('valueDel', $config->get('system', 'keyDel'));
self::assertEquals('catDel', $config->get('delete', 'keyDel'));
// The config file still doesn't know it either
$tempData = include $this->root->url() . '/config/' . ConfigFileManager::CONFIG_DATA_FILE;
self::assertEquals('value1', $tempData['config']['key1'] ?? null);
self::assertEquals('value2', $tempData['system']['key2'] ?? null);
self::assertEquals('catDel', $tempData['delete']['keyDel'] ?? null);
self::assertNull($tempData['transaction']['key3'] ?? null);
// save it back!
$configTransaction->commit();
// Now every config and file knows the change
self::assertEquals('changedValue1', $config->get('config', 'key1'));
self::assertEquals('value3', $config->get('transaction', 'key3'));
self::assertNull($config->get('system', 'keyDel'));
self::assertNull($config->get('delete', 'keyDel'));
$tempData = include $this->root->url() . '/config/' . ConfigFileManager::CONFIG_DATA_FILE;
self::assertEquals('changedValue1', $tempData['config']['key1'] ?? null);
self::assertEquals('value2', $tempData['system']['key2'] ?? null);
self::assertEquals('value3', $tempData['transaction']['key3'] ?? null);
self::assertNull($tempData['system']['keyDel'] ?? null);
self::assertNull($tempData['delete']['keyDel'] ?? null);
// the whole category should be gone
self::assertNull($tempData['delete'] ?? null);
}
/**
* This test asserts that in empty transactions, no saveData is called, thus no config file writing was performed
*/
public function testNothingToDo()
{
$this->configFileManager = \Mockery::spy(ConfigFileManager::class);
$config = new Config($this->configFileManager, new Cache());
$configTransaction = new ConfigTransaction($config);
// commit empty transaction
$configTransaction->commit();
try {
$this->configFileManager->shouldNotHaveReceived('saveData');
} catch (InvalidCountException $exception) {
self::fail($exception);
}
// If not failed, the test ends successfully :)
self::assertTrue(true);
}
}

255
tests/src/Core/Config/JitConfigTest.php
View file

@ -1,255 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Test\src\Core\Config;
use Friendica\Core\Config\Type\JitConfig;
class JitConfigTest extends ConfigTest
{
public function getInstance()
{
return new JitConfig($this->configCache, $this->configModel);
}
/**
* @dataProvider dataConfigLoad
*/
public function testSetUp(array $data)
{
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => $data['config']])
->once();
parent::testSetUp($data);
}
/**
* @dataProvider dataConfigLoad
*
* @param array $data
* @param array $load
*/
public function testLoad(array $data, array $load)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(count($load) + 1);
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => $data['config']])
->once();
foreach ($load as $loadCat) {
$this->configModel->shouldReceive('load')
->with($loadCat)
->andReturn([$loadCat => $data[$loadCat]])
->once();
}
parent::testLoad($data, $load);
}
/**
* @dataProvider dataDoubleLoad
*/
public function testCacheLoadDouble(array $data1, array $data2, array $expect = [])
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(count($data1) + count($data2) + 1);
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => $data1['config']])
->once();
foreach ($data1 as $cat => $data) {
$this->configModel->shouldReceive('load')
->with($cat)
->andReturn([$cat => $data])
->once();
}
foreach ($data2 as $cat => $data) {
$this->configModel->shouldReceive('load')
->with($cat)
->andReturn([$cat => $data])
->once();
}
parent::testCacheLoadDouble($data1, $data2);
// Assert the expected categories
foreach ($data2 as $cat => $data) {
self::assertConfig($cat, $expect[$cat]);
}
}
/**
* @dataProvider dataTests
*/
public function testSetGetWithDB($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(3);
$this->configModel->shouldReceive('load')->with('config')->andReturn(['config' => []])->once();
parent::testSetGetWithDB($data);
}
/**
* @dataProvider dataTests
*/
public function testGetWithRefresh($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(4);
// constructor loading
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => []])
->once();
// mocking one get without result
$this->configModel->shouldReceive('get')
->with('test', 'it')
->andReturn(null)
->once();
// mocking the data get
$this->configModel->shouldReceive('get')
->with('test', 'it')
->andReturn($data)
->once();
// mocking second get
$this->configModel->shouldReceive('get')
->with('test', 'not')
->andReturn(null)
->once();
parent::testGetWithRefresh($data);
}
public function testGetWrongWithoutDB()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(false)
->times(4);
parent::testGetWrongWithoutDB();
}
/**
* @dataProvider dataTests
*/
public function testDeleteWithoutDB($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(false)
->times(4);
parent::testDeleteWithoutDB($data);
}
public function testDeleteWithDB()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(6);
// constructor loading
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => []])
->once();
// mocking one get without result
$this->configModel->shouldReceive('get')
->with('test', 'it')
->andReturn(null)
->once();
parent::testDeleteWithDB();
}
public function testSetGetHighPrio()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true);
// constructor loading
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => []])
->once();
$this->configModel->shouldReceive('get')
->with('config', 'test')
->andReturn('prio')
->once();
$this->configModel->shouldReceive('set')
->with('config', 'test', '123')
->andReturn(true)
->once();
$this->configModel->shouldReceive('get')
->with('config', 'test')
->andReturn('123')
->once();
parent::testSetGetHighPrio();
}
public function testSetGetLowPrio()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true);
// constructor loading
$this->configModel->shouldReceive('load')
->with('config')
->andReturn(['config' => ['test' => 'it']])
->once();
$this->configModel->shouldReceive('set')
->with('config', 'test', '123')
->andReturn(true)
->once();
// mocking one get without result
$this->configModel->shouldReceive('get')
->with('config', 'test')
->andReturn('it')
->once();
parent::testSetGetLowPrio();
}
}

213
tests/src/Core/Config/PreloadConfigTest.php
View file

@ -1,213 +0,0 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Test\src\Core\Config;
use Friendica\Core\Config\Type\PreloadConfig;
class PreloadConfigTest extends ConfigTest
{
public function getInstance()
{
return new PreloadConfig($this->configCache, $this->configModel);
}
/**
* @dataProvider dataConfigLoad
*/
public function testSetUp(array $data)
{
$this->configModel->shouldReceive('load')
->andReturn($data)
->once();
parent::testSetUp($data);
}
/**
* @dataProvider dataConfigLoad
*
* @param array $data
* @param array $load
*/
public function testLoad(array $data, array $load)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->once();
$this->configModel->shouldReceive('load')
->andReturn($data)
->once();
parent::testLoad($data, $load);
// Assert that every category is loaded everytime
foreach ($data as $cat => $values) {
self::assertConfig($cat, $values);
}
}
/**
* @dataProvider dataDoubleLoad
*
* @param array $data1
* @param array $data2
*/
public function testCacheLoadDouble(array $data1, array $data2, array $expect = [])
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->once();
$this->configModel->shouldReceive('load')
->andReturn($data1)
->once();
parent::testCacheLoadDouble($data1, $data2);
// Assert that every category is loaded everytime and is NOT overwritten
foreach ($data1 as $cat => $values) {
self::assertConfig($cat, $values);
}
}
/**
* @dataProvider dataTests
*/
public function testSetGetWithDB($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(2);
$this->configModel->shouldReceive('load')->andReturn(['config' => []])->once();
parent::testSetGetWithDB($data);
}
/**
* @dataProvider dataTests
*/
public function testGetWithRefresh($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(2);
// constructor loading
$this->configModel->shouldReceive('load')
->andReturn(['config' => []])
->once();
// mocking one get
$this->configModel->shouldReceive('get')
->with('test', 'it')
->andReturn($data)
->once();
parent::testGetWithRefresh($data);
}
public function testGetWrongWithoutDB()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(false)
->times(2);
parent::testGetWrongWithoutDB();
}
/**
* @dataProvider dataTests
*/
public function testDeleteWithoutDB($data)
{
$this->configModel->shouldReceive('isConnected')
->andReturn(false)
->times(2);
parent::testDeleteWithoutDB($data);
}
public function testDeleteWithDB()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true)
->times(5);
// constructor loading
$this->configModel->shouldReceive('load')
->andReturn(['config' => []])
->once();
parent::testDeleteWithDB();
}
public function testSetGetHighPrio()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true);
// constructor loading
$this->configModel->shouldReceive('load')
->andReturn(['config' => []])
->once();
$this->configModel->shouldReceive('set')
->with('config', 'test', '123')
->andReturn(true)
->once();
$this->configModel->shouldReceive('get')
->with('config', 'test')
->andReturn('123')
->once();
parent::testSetGetHighPrio();
}
public function testSetGetLowPrio()
{
$this->configModel->shouldReceive('isConnected')
->andReturn(true);
// constructor loading
$this->configModel->shouldReceive('load')
->andReturn(['config' => ['test' => 'it']])
->once();
$this->configModel->shouldReceive('set')
->with('config', 'test', '123')
->andReturn(true)
->once();
// mocking one get without result
$this->configModel->shouldReceive('get')
->with('config', 'test')
->andReturn('it')
->once();
parent::testSetGetLowPrio();
}
}

57
tests/src/Core/Config/Util/ConfigFileTransformerTest.php Normal file
View file

@ -0,0 +1,57 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Test\src\Core\Config\Util;
use Friendica\Core\Config\Util\ConfigFileTransformer;
use Friendica\Test\MockedTest;
class ConfigFileTransformerTest extends MockedTest
{
public function dataTests()
{
return [
'default' => [
'configFile' => (dirname(__DIR__, 4) . '/datasets/config/A.node.config.php'),
],
'extended' => [
'configFile' => (dirname(__DIR__, 4) . '/datasets/config/B.node.config.php'),
],
'friendica.local' => [
'configFile' => (dirname(__DIR__, 4) . '/datasets/config/C.node.config.php'),
],
];
}
/**
* Tests if the given config will be decoded into an array and encoded into the same string again
*
* @dataProvider dataTests
*/
public function testConfigFile(string $configFile)
{
$dataArray = include $configFile;
$newConfig = ConfigFileTransformer::encode($dataArray);
self::assertEquals(file_get_contents($configFile), $newConfig);
}
}

10
tests/src/Core/Lock/SemaphoreLockTest.php
View file

@ -24,7 +24,10 @@ namespace Friendica\Test\src\Core\Lock;
use Dice\Dice;
use Friendica\App;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Model\Config;
use Friendica\Core\Config\Type\JitConfig;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Core\Lock\Type\SemaphoreLock;
use Friendica\Core\System;
use Friendica\DI;
@ -42,11 +45,8 @@ class SemaphoreLockTest extends LockTest
$app->shouldReceive('getHostname')->andReturn('friendica.local');
$dice->shouldReceive('create')->with(App::class)->andReturn($app);
$configMock = Mockery::mock(JitConfig::class);
$configMock
->shouldReceive('get')
->with('system', 'temppath')
->andReturn('/tmp/');
$configCache = new Cache(['system' => ['temppath' => '/tmp']]);
$configMock = new Config(Mockery::mock(ConfigFileManager::class), $configCache);
$dice->shouldReceive('create')->with(IManageConfigValues::class)->andReturn($configMock);
// @todo Because "get_temppath()" is using static methods, we have to initialize the BaseObject

4
tests/src/Core/Storage/DatabaseStorageTest.php
View file

@ -54,8 +54,8 @@ class DatabaseStorageTest extends StorageTest
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new Config();
$loader = (new Config())->createConfigFileLoader($this->root->url(), []);
$configCache = $configFactory->createCache($loader);
$configFileManager = (new Config())->createConfigFileManager($this->root->url());
$configCache = $configFactory->createCache($configFileManager);
$dbaDefinition = (new DbaDefinition($configCache->get('system', 'basepath')))->load();
$viewDefinition = (new ViewDefinition($configCache->get('system', 'basepath')))->load();

14
tests/src/Core/Storage/Repository/StorageManagerTest.php
View file

@ -22,9 +22,7 @@
namespace Friendica\Test\src\Core\Storage\Repository;
use Dice\Dice;
use Friendica\App\Mode;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Type\PreloadConfig;
use Friendica\Core\Hook;
use Friendica\Core\L10n;
use Friendica\Core\Session\Capability\IHandleSessions;
@ -41,7 +39,6 @@ use Friendica\Database\Definition\DbaDefinition;
use Friendica\Database\Definition\ViewDefinition;
use Friendica\DI;
use Friendica\Core\Config\Factory\Config;
use Friendica\Core\Config\Repository;
use Friendica\Core\Storage\Type;
use Friendica\Test\DatabaseTest;
use Friendica\Test\Util\Database\StaticDatabase;
@ -55,6 +52,7 @@ use Friendica\Test\Util\SampleStorageBackend;
class StorageManagerTest extends DatabaseTest
{
use VFSTrait;
/** @var Database */
private $dba;
/** @var IManageConfigValues */
@ -81,18 +79,18 @@ class StorageManagerTest extends DatabaseTest
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new Config();
$loader = $configFactory->createConfigFileLoader($this->root->url(), []);
$configCache = $configFactory->createCache($loader);
$configFileManager = $configFactory->createConfigFileManager($this->root->url());
$configCache = $configFactory->createCache($configFileManager);
$dbaDefinition = (new DbaDefinition($configCache->get('system', 'basepath')))->load();
$viewDefinition = (new ViewDefinition($configCache->get('system', 'basepath')))->load();
$this->dba = new StaticDatabase($configCache, $profiler, $dbaDefinition, $viewDefinition);
$configModel = new Repository\Config($this->dba, new Mode(Mode::DBCONFIGAVAILABLE));
$this->config = new PreloadConfig($configCache, $configModel);
$this->config = new \Friendica\Core\Config\Model\Config($configFileManager, $configCache);
$this->config->set('storage', 'name', 'Database');
$this->config->set('storage', 'filesystem_path', $this->root->getChild(Type\FilesystemConfig::DEFAULT_BASE_FOLDER)->url());
$this->config->set('storage', 'filesystem_path', $this->root->getChild(Type\FilesystemConfig::DEFAULT_BASE_FOLDER)
->url());
$this->l10n = \Mockery::mock(L10n::class);
}

5
tests/src/Database/DBATest.php
View file

@ -52,10 +52,7 @@ class DBATest extends DatabaseTest
*/
public function testExists() {
self::assertTrue(DBA::exists('config', []));
self::assertTrue(DBA::exists('user', []));
self::assertFalse(DBA::exists('notable', []));
self::assertTrue(DBA::exists('config', ['k' => 'hostname']));
self::assertFalse(DBA::exists('config', ['k' => 'nonsense']));
}
}

28
tests/src/Database/DBStructureTest.php
View file

@ -44,30 +44,30 @@ class DBStructureTest extends DatabaseTest
* @small
*/
public function testExists() {
self::assertTrue(DBStructure::existsTable('config'));
self::assertTrue(DBStructure::existsTable('user'));
self::assertFalse(DBStructure::existsTable('notatable'));
self::assertTrue(DBStructure::existsColumn('config', ['k']));
self::assertFalse(DBStructure::existsColumn('config', ['nonsense']));
self::assertFalse(DBStructure::existsColumn('config', ['k', 'nonsense']));
self::assertTrue(DBStructure::existsColumn('user', ['uid']));
self::assertFalse(DBStructure::existsColumn('user', ['nonsense']));
self::assertFalse(DBStructure::existsColumn('user', ['uid', 'nonsense']));
}
/**
* @small
*/
public function testRename() {
$fromColumn = 'k';
$toColumn = 'key';
$fromType = 'varbinary(255) not null';
$toType = 'varbinary(255) not null comment \'Test To Type\'';
$fromColumn = 'email';
$toColumn = 'email_key';
$fromType = 'varchar(255) NOT NULL DEFAULT \'\' COMMENT \'the users email address\'';
$toType = 'varchar(255) NOT NULL DEFAULT \'\' COMMENT \'Adapted column\'';
self::assertTrue(DBStructure::rename('config', [ $fromColumn => [ $toColumn, $toType ]]));
self::assertTrue(DBStructure::existsColumn('config', [ $toColumn ]));
self::assertFalse(DBStructure::existsColumn('config', [ $fromColumn ]));
self::assertTrue(DBStructure::rename('user', [ $fromColumn => [ $toColumn, $toType ]]));
self::assertTrue(DBStructure::existsColumn('user', [ $toColumn ]));
self::assertFalse(DBStructure::existsColumn('user', [ $fromColumn ]));
self::assertTrue(DBStructure::rename('config', [ $toColumn => [ $fromColumn, $fromType ]]));
self::assertTrue(DBStructure::existsColumn('config', [ $fromColumn ]));
self::assertFalse(DBStructure::existsColumn('config', [ $toColumn ]));
self::assertTrue(DBStructure::rename('user', [ $toColumn => [ $fromColumn, $fromType ]]));
self::assertTrue(DBStructure::existsColumn('user', [ $fromColumn ]));
self::assertFalse(DBStructure::existsColumn('user', [ $toColumn ]));
}
/**

76
tests/src/Model/GServerTest.php Normal file
View file

@ -0,0 +1,76 @@
<?php
/**
* @copyright Copyright (C) 2010-2023, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Test\src\Model;
use Friendica\Model\GServer;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\UriInterface;
class GServerTest extends \PHPUnit\Framework\TestCase
{
public function dataCleanUri(): array
{
return [
'full-monty' => [
'expected' => new Uri('https://example.com/path'),
'dirtyUri' => new Uri('https://user:password@example.com/path?query=string#fragment'),
],
'index.php' => [
'expected' => new Uri('https://example.com'),
'dirtyUri' => new Uri('https://example.com/index.php'),
],
'index.php-2' => [
'expected' => new Uri('https://example.com/path/to/resource'),
'dirtyUri' => new Uri('https://example.com/index.php/path/to/resource'),
],
'index.php-path' => [
'expected' => new Uri('https://example.com/path/to'),
'dirtyUri' => new Uri('https://example.com/path/to/index.php'),
],
'index.php-path-2' => [
'expected' => new Uri('https://example.com/path/to/path/to/resource'),
'dirtyUri' => new Uri('https://example.com/path/to/index.php/path/to/resource'),
],
'index.php-slash' => [
'expected' => new Uri('https://example.com'),
'dirtyUri' => new Uri('https://example.com/index.php/'),
],
'index.php-slash-2' => [
'expected' => new Uri('https://example.com/path/to/resource'),
'dirtyUri' => new Uri('https://example.com/index.php/path/to/resource/'),
],
];
}
/**
* @dataProvider dataCleanUri
*
* @param UriInterface $expected
* @param UriInterface $dirtyUri
* @return void
* @throws \Exception
*/
public function testCleanUri(UriInterface $expected, UriInterface $dirtyUri)
{
$this->assertEquals($expected, GServer::cleanUri($dirtyUri));
}
}

1
tests/src/Module/Api/GnuSocial/GnuSocial/ConfigTest.php
View file

@ -26,6 +26,7 @@ use Friendica\App\Router;
use Friendica\DI;
use Friendica\Module\Api\GNUSocial\GNUSocial\Config;
use Friendica\Test\src\Module\Api\ApiTest;
use Friendica\Test\Util\VFSTrait;
class ConfigTest extends ApiTest
{

159
tests/src/Util/BaseURLTest.php
View file

@ -23,10 +23,25 @@ namespace Friendica\Test\src\Util;
use Friendica\App\BaseURL;
use Friendica\Core\Config\Capability\IManageConfigValues;
use Friendica\Core\Config\Capability\ISetConfigValuesTransactionally;
use Friendica\Core\Config\Model\Config;
use Friendica\Core\Config\Model\ConfigTransaction;
use Friendica\Core\Config\Util\ConfigFileManager;
use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\VFSTrait;
class BaseURLTest extends MockedTest
{
use VFSTrait;
protected function setUp(): void
{
parent::setUp();
$this->setUpVfsDir();
}
public function dataDefault()
{
return [
@ -231,6 +246,21 @@ class BaseURLTest extends MockedTest
public function dataSave()
{
return [
'no_change' => [
'input' => [
'hostname' => 'friendica.local',
'urlPath' => 'path',
'sslPolicy' => BaseURL::SSL_POLICY_FULL,
'url' => 'https://friendica.local/path',
'force_ssl' => true,
],
'save' => [
'hostname' => 'friendica.local',
'urlPath' => 'path',
'sslPolicy' => BaseURL::SSL_POLICY_FULL,
],
'url' => 'https://friendica.local/path',
],
'default' => [
'input' => [
'hostname' => 'friendica.old',
@ -315,28 +345,20 @@ class BaseURLTest extends MockedTest
*/
public function testSave($input, $save, $url)
{
$configMock = \Mockery::mock(IManageConfigValues::class);
$configMock->shouldReceive('get')->with('config', 'hostname')->andReturn($input['hostname']);
$configMock->shouldReceive('get')->with('system', 'urlpath')->andReturn($input['urlPath']);
$configMock->shouldReceive('get')->with('system', 'ssl_policy')->andReturn($input['sslPolicy']);
$configMock->shouldReceive('get')->with('system', 'url')->andReturn($input['url']);
$configMock->shouldReceive('get')->with('system', 'force_ssl')->andReturn($input['force_ssl']);
$configFileManager = new ConfigFileManager($this->root->url(), $this->root->url() . '/config/', $this->root->url() . '/static/');
$config = new Config($configFileManager, new Cache([
'config' => [
'hostname' => $input['hostname'] ?? null,
],
'system' => [
'urlpath' => $input['urlPath'] ?? null,
'ssl_policy' => $input['sslPolicy'] ?? null,
'url' => $input['url'] ?? null,
'force_ssl' => $input['force_ssl'] ?? null,
],
]));
$baseUrl = new BaseURL($configMock, []);
if (isset($save['hostname'])) {
$configMock->shouldReceive('set')->with('config', 'hostname', $save['hostname'])->andReturn(true)->once();
}
if (isset($save['urlPath'])) {
$configMock->shouldReceive('set')->with('system', 'urlpath', $save['urlPath'])->andReturn(true)->once();
}
if (isset($save['sslPolicy'])) {
$configMock->shouldReceive('set')->with('system', 'ssl_policy', $save['sslPolicy'])->andReturn(true)->once();
}
$configMock->shouldReceive('set')->with('system', 'url', $url)->andReturn(true)->once();
$baseUrl = new BaseURL($config, []);
$baseUrl->save($save['hostname'], $save['sslPolicy'], $save['urlPath']);
@ -353,28 +375,20 @@ class BaseURLTest extends MockedTest
*/
public function testSaveByUrl($input, $save, $url)
{
$configMock = \Mockery::mock(IManageConfigValues::class);
$configMock->shouldReceive('get')->with('config', 'hostname')->andReturn($input['hostname']);
$configMock->shouldReceive('get')->with('system', 'urlpath')->andReturn($input['urlPath']);
$configMock->shouldReceive('get')->with('system', 'ssl_policy')->andReturn($input['sslPolicy']);
$configMock->shouldReceive('get')->with('system', 'url')->andReturn($input['url']);
$configMock->shouldReceive('get')->with('system', 'force_ssl')->andReturn($input['force_ssl']);
$configFileManager = new ConfigFileManager($this->root->url(), $this->root->url() . '/config/', $this->root->url() . '/static/');
$config = new Config($configFileManager, new Cache([
'config' => [
'hostname' => $input['hostname'] ?? null,
],
'system' => [
'urlpath' => $input['urlPath'] ?? null,
'ssl_policy' => $input['sslPolicy'] ?? null,
'url' => $input['url'] ?? null,
'force_ssl' => $input['force_ssl'] ?? null,
],
]));
$baseUrl = new BaseURL($configMock, []);
if (isset($save['hostname'])) {
$configMock->shouldReceive('set')->with('config', 'hostname', $save['hostname'])->andReturn(true)->once();
}
if (isset($save['urlPath'])) {
$configMock->shouldReceive('set')->with('system', 'urlpath', $save['urlPath'])->andReturn(true)->once();
}
if (isset($save['sslPolicy'])) {
$configMock->shouldReceive('set')->with('system', 'ssl_policy', $save['sslPolicy'])->andReturn(true)->once();
}
$configMock->shouldReceive('set')->with('system', 'url', $url)->andReturn(true)->once();
$baseUrl = new BaseURL($config, []);
$baseUrl->saveByURL($url);
@ -498,65 +512,4 @@ class BaseURLTest extends MockedTest
self::assertEquals($redirect, $baseUrl->checkRedirectHttps());
}
public function dataWrongSave()
{
return [
'wrongHostname' => [
'fail' => 'hostname',
],
'wrongSSLPolicy' => [
'fail' => 'sslPolicy',
],
'wrongURLPath' => [
'fail' => 'urlPath',
],
'wrongURL' => [
'fail' => 'url',
],
];
}
/**
* Test the save() method with wrong parameters
* @dataProvider dataWrongSave
*/
public function testWrongSave($fail)
{
$configMock = \Mockery::mock(IManageConfigValues::class);
$configMock->shouldReceive('get')->with('config', 'hostname')->andReturn('friendica.local');
$configMock->shouldReceive('get')->with('system', 'urlpath')->andReturn('new/test');
$configMock->shouldReceive('get')->with('system', 'ssl_policy')->andReturn(BaseURL::DEFAULT_SSL_SCHEME);
$configMock->shouldReceive('get')->with('system', 'url')->andReturn('http://friendica.local/new/test');
switch ($fail) {
case 'hostname':
$configMock->shouldReceive('set')->with('config', 'hostname', \Mockery::any())->andReturn(false)->once();
break;
case 'sslPolicy':
$configMock->shouldReceive('set')->with('config', 'hostname', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'ssl_policy', \Mockery::any())->andReturn(false)->once();
break;
case 'urlPath':
$configMock->shouldReceive('set')->with('config', 'hostname', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'ssl_policy', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'urlpath', \Mockery::any())->andReturn(false)->once();
break;
case 'url':
$configMock->shouldReceive('set')->with('config', 'hostname', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'ssl_policy', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'urlpath', \Mockery::any())->andReturn(true)->twice();
$configMock->shouldReceive('set')->with('system', 'url', \Mockery::any())->andReturn(false)->once();
break;
}
$baseUrl = new BaseURL($configMock, []);
self::assertFalse($baseUrl->save('test', 10, 'nope'));
// nothing should have changed because we never successfully saved anything
self::assertEquals('friendica.local', $baseUrl->getHostname());
self::assertEquals('new/test', $baseUrl->getUrlPath());
self::assertEquals(BaseURL::DEFAULT_SSL_SCHEME, $baseUrl->getSSLPolicy());
self::assertEquals('http://friendica.local/new/test', $baseUrl->get());
}
}

37
update.php
View file

@ -1148,6 +1148,10 @@ function update_1502()
function update_1505()
{
if (!DBStructure::existsTable('config')) {
return Update::SUCCESS;
}
$conditions = [
"((`cat` = ?) AND ((`k` LIKE ?) OR (`k` = ?) OR (`k` LIKE ?) OR (`k` = ?))) OR " .
"((`cat` != ?) AND (`k` LIKE ?)) OR " .
@ -1175,3 +1179,36 @@ function update_1505()
return DBA::delete('config', $conditions) ? Update::SUCCESS : Update::FAILED;
}
function update_1508()
{
$config = DBA::selectToArray('config');
$newConfig = DI::config()->beginTransaction();
foreach ($config as $entry) {
$newConfig->set($entry['cat'], $entry['k'], $entry['v']);
}
$newConfig->commit();
return Update::SUCCESS;
}
function update_1509()
{
$addons = DBA::selectToArray('addon');
$newConfig = DI::config()->beginTransaction();
foreach ($addons as $addon) {
$newConfig->set('addons', $addon['name'], [
'last_update' => $addon['timestamp'],
'admin' => (bool)$addon['plugin_admin'],
]);
}
$newConfig->commit();
return Update::SUCCESS;
}

747
view/lang/C/messages.po
View file

File diff suppressed because it is too large Load diff

1
view/templates/settings/display.tpl
View file

@ -13,7 +13,6 @@
{{include file="field_input.tpl" field=$itemspage_mobile_network}}
{{include file="field_input.tpl" field=$ajaxint}}
{{include file="field_checkbox.tpl" field=$no_auto_update}}
{{include file="field_checkbox.tpl" field=$enable_smile}}
{{include file="field_checkbox.tpl" field=$infinite_scroll}}
{{include file="field_checkbox.tpl" field=$enable_smart_threading}}

2
view/theme/frio/style.php
View file

@ -49,7 +49,7 @@ $login_bg_color = '';
$modified = time();
if (DI::mode()->has(\Friendica\App\Mode::MAINTENANCEDISABLED)) {
DI::config()->load('frio');
DI::config()->reload();
// Default to hard-coded values for empty settings
$scheme = DI::config()->get('frio', 'scheme', DI::config()->get('frio', 'schema'));

2
view/theme/frio/templates/photo_view.tpl
View file

@ -1,4 +1,4 @@
{{* Template for singele photo view *}}
{{* Template for single photo view *}}
{{* "live-photos" is needed for js autoupdate *}}
<div id="live-photos"></div>

1
view/theme/frio/templates/settings/display.tpl
View file

@ -60,7 +60,6 @@
{{include file="field_input.tpl" field=$itemspage_network}}
{{include file="field_input.tpl" field=$itemspage_mobile_network}}
{{include file="field_input.tpl" field=$ajaxint}}
{{include file="field_checkbox.tpl" field=$no_auto_update}}
{{include file="field_checkbox.tpl" field=$enable_smile}}
{{include file="field_checkbox.tpl" field=$infinite_scroll}}
{{include file="field_checkbox.tpl" field=$enable_smart_threading}}