X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCore%2FStorageManager.php;h=c8385783e9f4c1bebe3d6e0041a5eebebc4b6926;hb=0d1fa70e2ecb372d158871285e0cda5f6d77194a;hp=ede8966f41b47b227b5eb2777d1ebf667e1352be;hpb=08edeae2f996854d0028d0f73a08a1f3ee7741da;p=friendica.git

diff --git a/src/Core/StorageManager.php b/src/Core/StorageManager.php
index ede8966f41..c8385783e9 100644
--- a/src/Core/StorageManager.php
+++ b/src/Core/StorageManager.php
@@ -1,17 +1,35 @@
 <?php
+/**
+ * @copyright Copyright (C) 2020, Friendica
+ *
+ * @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;
 
-use Dice\Dice;
 use Exception;
-use Friendica\Core\Config\IConfiguration;
+use Friendica\Core\Config\IConfig;
 use Friendica\Database\Database;
 use Friendica\Model\Storage;
 use Psr\Log\LoggerInterface;
 
 
 /**
- * @brief Manage storage backends
+ * Manage storage backends
  *
  * Core code uses this class to get and set current storage backend class.
  * Addons use this class to register and unregister additional backends.
@@ -29,42 +47,45 @@ class StorageManager
 
 	private $backends = [];
 
+	/**
+	 * @var Storage\IStorage[] A local cache for storage instances
+	 */
+	private $backendInstances = [];
+
 	/** @var Database */
 	private $dba;
-	/** @var IConfiguration */
+	/** @var IConfig */
 	private $config;
 	/** @var LoggerInterface */
 	private $logger;
-	/** @var Dice */
-	private $dice;
+	/** @var L10n */
+	private $l10n;
 
 	/** @var Storage\IStorage */
 	private $currentBackend;
 
 	/**
 	 * @param Database        $dba
-	 * @param IConfiguration  $config
+	 * @param IConfig         $config
 	 * @param LoggerInterface $logger
+	 * @param L10n            $l10n
 	 */
-	public function __construct(Database $dba, IConfiguration $config, LoggerInterface $logger, Dice $dice)
+	public function __construct(Database $dba, IConfig $config, LoggerInterface $logger, L10n $l10n)
 	{
 		$this->dba      = $dba;
 		$this->config   = $config;
 		$this->logger   = $logger;
-		$this->dice     = $dice;
+		$this->l10n     = $l10n;
 		$this->backends = $config->get('storage', 'backends', self::DEFAULT_BACKENDS);
 
 		$currentName = $this->config->get('storage', 'name', '');
 
-		if ($this->isValidBackend($currentName)) {
-			$this->currentBackend = $this->dice->create($this->backends[$currentName]);
-		} else {
-			$this->currentBackend = null;
-		}
+		// you can only use user backends as a "default" backend, so the second parameter is true
+		$this->currentBackend = $this->getByName($currentName, true);
 	}
 
 	/**
-	 * @brief Return current storage backend class
+	 * Return current storage backend class
 	 *
 	 * @return Storage\IStorage|null
 	 */
@@ -74,48 +95,106 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Return storage backend class by registered name
+	 * Return storage backend class by registered name
 	 *
-	 * @param string $name Backend name
+	 * @param string|null $name            Backend name
+	 * @param boolean     $onlyUserBackend True, if just user specific instances should be returrned (e.g. not SystemResource)
 	 *
 	 * @return Storage\IStorage|null null if no backend registered at $name
+	 *
+	 * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 	 */
-	public function getByName(string $name)
+	public function getByName(string $name = null, $onlyUserBackend = false)
 	{
-		if (!$this->isValidBackend($name)) {
-			return null;
+		// @todo 2020.09 Remove this call after 2 releases
+		$name = $this->checkLegacyBackend($name);
+
+		// If there's no cached instance create a new instance
+		if (!isset($this->backendInstances[$name])) {
+			// If the current name isn't a valid backend (or the SystemResource instance) create it
+			if ($this->isValidBackend($name, $onlyUserBackend)) {
+				switch ($name) {
+					// Try the filesystem backend
+					case Storage\Filesystem::getName():
+						$this->backendInstances[$name] = new Storage\Filesystem($this->config, $this->logger, $this->l10n);
+						break;
+					// try the database backend
+					case Storage\Database::getName():
+						$this->backendInstances[$name] = new Storage\Database($this->dba, $this->logger, $this->l10n);
+						break;
+					// at least, try if there's an addon for the backend
+					case Storage\SystemResource::getName():
+						$this->backendInstances[$name] = new Storage\SystemResource();
+						break;
+					default:
+						$data = [
+							'name'    => $name,
+							'storage' => null,
+						];
+						Hook::callAll('storage_instance', $data);
+						if (($data['storage'] ?? null) instanceof Storage\IStorage) {
+							$this->backendInstances[$data['name'] ?? $name] = $data['storage'];
+						} else {
+							return null;
+						}
+						break;
+				}
+			} else {
+				return null;
+			}
 		}
 
-		return $this->dice->create($this->backends[$name]);
+		return $this->backendInstances[$name];
 	}
 
 	/**
 	 * Checks, if the storage is a valid backend
 	 *
-	 * @param string $name The name or class of the backend
+	 * @param string|null $name            The name or class of the backend
+	 * @param boolean     $onlyUserBackend True, if just user backend should get returned (e.g. not SystemResource)
 	 *
 	 * @return boolean True, if the backend is a valid backend
 	 */
-	public function isValidBackend(string $name)
+	public function isValidBackend(string $name = null, bool $onlyUserBackend = false)
+	{
+		return array_key_exists($name, $this->backends) ||
+		       (!$onlyUserBackend && $name === Storage\SystemResource::getName());
+	}
+
+	/**
+	 * Check for legacy backend storage class names (= full model class name)
+	 *
+	 * @todo 2020.09 Remove this function after 2 releases, because there shouldn't be any legacy backend classes left
+	 *
+	 * @param string|null $name a potential, legacy storage name ("Friendica\Model\Storage\...")
+	 *
+	 * @return string|null The current storage name
+	 */
+	private function checkLegacyBackend(string $name = null)
 	{
-		return array_key_exists($name, $this->backends);
+		if (stristr($name, 'Friendica\Model\Storage\\')) {
+			$this->logger->notice('Using deprecated storage class value', ['name' => $name]);
+			return substr($name, 24);
+		}
+
+		return $name;
 	}
 
 	/**
-	 * @brief Set current storage backend class
+	 * Set current storage backend class
 	 *
 	 * @param string $name Backend class name
 	 *
 	 * @return boolean True, if the set was successful
 	 */
-	public function setBackend(string $name)
+	public function setBackend(string $name = null)
 	{
-		if (!$this->isValidBackend($name)) {
+		if (!$this->isValidBackend($name, false)) {
 			return false;
 		}
 
 		if ($this->config->set('storage', 'name', $name)) {
-			$this->currentBackend = $this->dice->create($this->backends[$name]);
+			$this->currentBackend = $this->getByName($name, false);
 			return true;
 		} else {
 			return false;
@@ -123,7 +202,7 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Get registered backends
+	 * Get registered backends
 	 *
 	 * @return array
 	 */
@@ -133,45 +212,60 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Register a storage backend class
+	 * Register a storage backend class
+	 *
+	 * You have to register the hook "storage_instance" as well to make this class work!
 	 *
-	 * @param string $name  User readable backend name
 	 * @param string $class Backend class name
 	 *
 	 * @return boolean True, if the registration was successful
 	 */
-	public function register(string $name, string $class)
+	public function register(string $class)
 	{
-		if (!is_subclass_of($class, Storage\IStorage::class)) {
-			return false;
-		}
+		if (is_subclass_of($class, Storage\IStorage::class)) {
+			/** @var Storage\IStorage $class */
 
-		$backends        = $this->backends;
-		$backends[$name] = $class;
+			$backends                    = $this->backends;
+			$backends[$class::getName()] = $class;
 
-		if ($this->config->set('storage', 'backends', $this->backends)) {
-			$this->backends = $backends;
-			return true;
+			if ($this->config->set('storage', 'backends', $backends)) {
+				$this->backends = $backends;
+				return true;
+			} else {
+				return false;
+			}
 		} else {
 			return false;
 		}
 	}
 
 	/**
-	 * @brief Unregister a storage backend class
+	 * Unregister a storage backend class
 	 *
-	 * @param string $name User readable backend name
+	 * @param string $class Backend class name
 	 *
 	 * @return boolean True, if unregistering was successful
 	 */
-	public function unregister(string $name)
+	public function unregister(string $class)
 	{
-		unset($this->backends[$name]);
-		return $this->config->set('storage', 'backends', $this->backends);
+		if (is_subclass_of($class, Storage\IStorage::class)) {
+			/** @var Storage\IStorage $class */
+
+			unset($this->backends[$class::getName()]);
+
+			if ($this->currentBackend instanceof $class) {
+				$this->config->set('storage', 'name', null);
+				$this->currentBackend = null;
+			}
+
+			return $this->config->set('storage', 'backends', $this->backends);
+		} else {
+			return false;
+		}
 	}
 
 	/**
-	 * @brief Move up to 5000 resources to storage $dest
+	 * Move up to 5000 resources to storage $dest
 	 *
 	 * Copy existing data to destination storage and delete from source.
 	 * This method cannot move to legacy in-table `data` field.
@@ -186,8 +280,8 @@ class StorageManager
 	 */
 	public function move(Storage\IStorage $destination, array $tables = self::TABLES, int $limit = 5000)
 	{
-		if ($destination === null) {
-			throw new Storage\StorageException('Can\'t move to NULL storage backend');
+		if (!$this->isValidBackend($destination, true)) {
+			throw new Storage\StorageException(sprintf("Can't move to storage backend '%s'", $destination::getName()));
 		}
 
 		$moved = 0;
@@ -196,7 +290,7 @@ class StorageManager
 			$resources = $this->dba->select(
 				$table,
 				['id', 'data', 'backend-class', 'backend-ref'],
-				['`backend-class` IS NULL or `backend-class` != ?', $destination],
+				['`backend-class` IS NULL or `backend-class` != ?', $destination::getName()],
 				['limit' => $limit]
 			);