X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCore%2FStorageManager.php;h=64e53c10b9f1f62883fa28c23919809774c8947e;hb=1701ea2034feb1cb8b7cce8455ff8e3c1f8875c6;hp=6a8fac5b808f9968ab0c10f41884bdd4f6533b41;hpb=84cff912832a5b77e1a303ede18002094568e16b;p=friendica.git

diff --git a/src/Core/StorageManager.php b/src/Core/StorageManager.php
index 6a8fac5b80..64e53c10b9 100644
--- a/src/Core/StorageManager.php
+++ b/src/Core/StorageManager.php
@@ -1,17 +1,36 @@
 <?php
+/**
+ * @copyright Copyright (C) 2010-2021, 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;
 
 use Exception;
-use Friendica\Core\Config\IConfiguration;
-use Friendica\Core\L10n\L10n;
+use Friendica\Core\Config\IConfig;
 use Friendica\Database\Database;
 use Friendica\Model\Storage;
+use Friendica\Network\IHTTPRequest;
 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.
@@ -36,37 +55,41 @@ class StorageManager
 
 	/** @var Database */
 	private $dba;
-	/** @var IConfiguration */
+	/** @var IConfig */
 	private $config;
 	/** @var LoggerInterface */
 	private $logger;
 	/** @var L10n */
 	private $l10n;
+	/** @var IHTTPRequest */
+	private $httpRequest;
 
 	/** @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, L10n $l10n)
+	public function __construct(Database $dba, IConfig $config, LoggerInterface $logger, L10n $l10n, IHTTPRequest $httpRequest)
 	{
-		$this->dba      = $dba;
-		$this->config   = $config;
-		$this->logger   = $logger;
-		$this->l10n     = $l10n;
+		$this->dba         = $dba;
+		$this->config      = $config;
+		$this->logger      = $logger;
+		$this->l10n        = $l10n;
+		$this->httpRequest = $httpRequest;
 		$this->backends = $config->get('storage', 'backends', self::DEFAULT_BACKENDS);
 
 		$currentName = $this->config->get('storage', 'name', '');
 
-		$this->currentBackend = $this->getByName($currentName);
+		// 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
 	 */
@@ -76,21 +99,24 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Return storage backend class by registered name
+	 * Return storage backend class by registered name
 	 *
-	 * @param string|null $name        Backend name
-	 * @param boolean     $userBackend Just return instances in case it's a user backend (e.g. not SystemResource)
+	 * @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 = null, $userBackend = true)
+	public function getByName(string $name = null, $onlyUserBackend = false)
 	{
+		// @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, $userBackend)) {
+			if ($this->isValidBackend($name, $onlyUserBackend)) {
 				switch ($name) {
 					// Try the filesystem backend
 					case Storage\Filesystem::getName():
@@ -102,11 +128,14 @@ class StorageManager
 						break;
 					// at least, try if there's an addon for the backend
 					case Storage\SystemResource::getName():
-						$this->backendInstances[$name] =  new Storage\SystemResource();
+						$this->backendInstances[$name] = new Storage\SystemResource();
+						break;
+					case Storage\ExternalResource::getName():
+						$this->backendInstances[$name] = new Storage\ExternalResource($this->httpRequest);
 						break;
 					default:
 						$data = [
-							'name' => $name,
+							'name'    => $name,
 							'storage' => null,
 						];
 						Hook::callAll('storage_instance', $data);
@@ -128,19 +157,38 @@ class StorageManager
 	/**
 	 * Checks, if the storage is a valid backend
 	 *
-	 * @param string|null $name        The name or class of the backend
-	 * @param boolean     $userBackend True, if just user backend should get returned (e.g. not SystemResource)
+	 * @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 = null, bool $userBackend = true)
+	public function isValidBackend(string $name = null, bool $onlyUserBackend = false)
 	{
 		return array_key_exists($name, $this->backends) ||
-		       (!$userBackend && $name === Storage\SystemResource::getName());
+		       (!$onlyUserBackend && in_array($name, [Storage\SystemResource::getName(), Storage\ExternalResource::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)
+	{
+		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
 	 *
@@ -148,12 +196,12 @@ class StorageManager
 	 */
 	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->getByName($name);
+			$this->currentBackend = $this->getByName($name, false);
 			return true;
 		} else {
 			return false;
@@ -161,7 +209,7 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Get registered backends
+	 * Get registered backends
 	 *
 	 * @return array
 	 */
@@ -184,7 +232,7 @@ class StorageManager
 		if (is_subclass_of($class, Storage\IStorage::class)) {
 			/** @var Storage\IStorage $class */
 
-			$backends        = $this->backends;
+			$backends                    = $this->backends;
 			$backends[$class::getName()] = $class;
 
 			if ($this->config->set('storage', 'backends', $backends)) {
@@ -199,7 +247,7 @@ class StorageManager
 	}
 
 	/**
-	 * @brief Unregister a storage backend class
+	 * Unregister a storage backend class
 	 *
 	 * @param string $class Backend class name
 	 *
@@ -213,7 +261,7 @@ class StorageManager
 			unset($this->backends[$class::getName()]);
 
 			if ($this->currentBackend instanceof $class) {
-			    $this->config->set('storage', 'name', null);
+				$this->config->set('storage', 'name', null);
 				$this->currentBackend = null;
 			}
 
@@ -224,7 +272,7 @@ class StorageManager
 	}
 
 	/**
-	 * @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.
@@ -239,8 +287,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;
@@ -264,13 +312,13 @@ class StorageManager
 					$data = $source->get($sourceRef);
 				}
 
-				$this->logger->info('Save data to new backend.', ['newBackend' => $destination]);
+				$this->logger->info('Save data to new backend.', ['newBackend' => $destination::getName()]);
 				$destinationRef = $destination->put($data);
 				$this->logger->info('Saved data.', ['newReference' => $destinationRef]);
 
 				if ($destinationRef !== '') {
 					$this->logger->info('update row');
-					if ($this->dba->update($table, ['backend-class' => $destination, 'backend-ref' => $destinationRef, 'data' => ''], ['id' => $id])) {
+					if ($this->dba->update($table, ['backend-class' => $destination::getName(), 'backend-ref' => $destinationRef, 'data' => ''], ['id' => $id])) {
 						if (!empty($source)) {
 							$this->logger->info('Delete data from old backend.', ['oldBackend' => $source, 'oldReference' => $sourceRef]);
 							$source->delete($sourceRef);