nextcloud / server

lib/private/Files/Storage/Wrapper/Availability.php

Indentation +261 added lines, -261 removed lines

@@ -18,265 +18,265 @@
  * Throws a StorageNotAvailableException for storages with known failures
  */
 class Availability extends Wrapper {
-	public const RECHECK_TTL_SEC = 600; // 10 minutes
-
-	/** @var IConfig */
-	protected $config;
-	protected ?bool $available = null;
-
-	public function __construct(array $parameters) {
-		$this->config = $parameters['config'] ?? \OCP\Server::get(IConfig::class);
-		parent::__construct($parameters);
-	}
-
-	public static function shouldRecheck($availability): bool {
-		if (!$availability['available']) {
-			// trigger a recheck if TTL reached
-			if ((time() - $availability['last_checked']) > self::RECHECK_TTL_SEC) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Only called if availability === false
-	 */
-	private function updateAvailability(): bool {
-		// reset availability to false so that multiple requests don't recheck concurrently
-		$this->setAvailability(false);
-		try {
-			$result = $this->test();
-		} catch (\Exception $e) {
-			$result = false;
-		}
-		$this->setAvailability($result);
-		return $result;
-	}
-
-	private function isAvailable(): bool {
-		if (is_null($this->available)) {
-			$availability = $this->getAvailability();
-			if (self::shouldRecheck($availability)) {
-				return $this->updateAvailability();
-			}
-			$this->available = $availability['available'];
-		}
-		return $this->available;
-	}
-
-	/**
-	 * @throws StorageNotAvailableException
-	 */
-	private function checkAvailability(): void {
-		if (!$this->isAvailable()) {
-			throw new StorageNotAvailableException();
-		}
-	}
-
-	/**
-	 * Handles availability checks and delegates method calls dynamically
-	 */
-	private function handleAvailability(string $method, mixed ...$args): mixed {
-		$this->checkAvailability();
-		try {
-			return call_user_func_array([parent::class, $method], $args);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return false;
-		}
-	}
-
-	public function mkdir(string $path): bool {
-		return $this->handleAvailability('mkdir', $path);
-	}
-
-	public function rmdir(string $path): bool {
-		return $this->handleAvailability('rmdir', $path);
-	}
-
-	public function opendir(string $path) {
-		return $this->handleAvailability('opendir', $path);
-	}
-
-	public function is_dir(string $path): bool {
-		return $this->handleAvailability('is_dir', $path);
-	}
-
-	public function is_file(string $path): bool {
-		return $this->handleAvailability('is_file', $path);
-	}
-
-	public function stat(string $path): array|false {
-		return $this->handleAvailability('stat', $path);
-	}
-
-	public function filetype(string $path): string|false {
-		return $this->handleAvailability('filetype', $path);
-	}
-
-	public function filesize(string $path): int|float|false {
-		return $this->handleAvailability('filesize', $path);
-	}
-
-	public function isCreatable(string $path): bool {
-		return $this->handleAvailability('isCreatable', $path);
-	}
-
-	public function isReadable(string $path): bool {
-		return $this->handleAvailability('isReadable', $path);
-	}
-
-	public function isUpdatable(string $path): bool {
-		return $this->handleAvailability('isUpdatable', $path);
-	}
-
-	public function isDeletable(string $path): bool {
-		return $this->handleAvailability('isDeletable', $path);
-	}
-
-	public function isSharable(string $path): bool {
-		return $this->handleAvailability('isSharable', $path);
-	}
-
-	public function getPermissions(string $path): int {
-		return $this->handleAvailability('getPermissions', $path);
-	}
-
-	public function file_exists(string $path): bool {
-		if ($path === '') {
-			return true;
-		}
-		return $this->handleAvailability('file_exists', $path);
-	}
-
-	public function filemtime(string $path): int|false {
-		return $this->handleAvailability('filemtime', $path);
-	}
-
-	public function file_get_contents(string $path): string|false {
-		return $this->handleAvailability('file_get_contents', $path);
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		return $this->handleAvailability('file_put_contents', $path, $data);
-	}
-
-	public function unlink(string $path): bool {
-		return $this->handleAvailability('unlink', $path);
-	}
-
-	public function rename(string $source, string $target): bool {
-		return $this->handleAvailability('rename', $source, $target);
-	}
-
-	public function copy(string $source, string $target): bool {
-		return $this->handleAvailability('copy', $source, $target);
-	}
-
-	public function fopen(string $path, string $mode) {
-		return $this->handleAvailability('fopen', $path, $mode);
-	}
-
-	public function getMimeType(string $path): string|false {
-		return $this->handleAvailability('getMimeType', $path);
-	}
-
-	public function hash(string $type, string $path, bool $raw = false): string|false {
-		return $this->handleAvailability('hash', $type, $path, $raw);
-	}
-
-	public function free_space(string $path): int|float|false {
-		return $this->handleAvailability('free_space', $path);
-	}
-
-	public function touch(string $path, ?int $mtime = null): bool {
-		return $this->handleAvailability('touch', $path, $mtime);
-	}
-
-	public function getLocalFile(string $path): string|false {
-		return $this->handleAvailability('getLocalFile', $path);
-	}
-
-	public function hasUpdated(string $path, int $time): bool {
-		if (!$this->isAvailable()) {
-			return false;
-		}
-		try {
-			return parent::hasUpdated($path, $time);
-		} catch (StorageNotAvailableException $e) {
-			// set unavailable but don't rethrow
-			$this->setUnavailable(null);
-			return false;
-		}
-	}
-
-	public function getOwner(string $path): string|false {
-		try {
-			return parent::getOwner($path);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return false;
-		}
-	}
-
-	public function getETag(string $path): string|false {
-		return $this->handleAvailability('getETag', $path);
-	}
-
-	public function getDirectDownload(string $path): array|false {
-		return $this->handleAvailability('getDirectDownload', $path);
-	}
-
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return $this->handleAvailability('copyFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return $this->handleAvailability('moveFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
-
-	public function getMetaData(string $path): ?array {
-		$this->checkAvailability();
-		try {
-			return parent::getMetaData($path);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return null;
-		}
-	}
-
-	/**
-	 * @template T of StorageNotAvailableException|null
-	 * @param T $e
-	 * @psalm-return (T is null ? void : never)
-	 * @throws StorageNotAvailableException
-	 */
-	protected function setUnavailable(?StorageNotAvailableException $e): void {
-		$delay = self::RECHECK_TTL_SEC;
-		if ($e instanceof StorageAuthException) {
-			$delay = max(
-				// 30min
-				$this->config->getSystemValueInt('external_storage.auth_availability_delay', 1800),
-				self::RECHECK_TTL_SEC
-			);
-		}
-		$this->available = false;
-		$this->getStorageCache()->setAvailability(false, $delay);
-		if ($e !== null) {
-			throw $e;
-		}
-	}
-
-
-
-	public function getDirectoryContent(string $directory): \Traversable {
-		$this->checkAvailability();
-		try {
-			return parent::getDirectoryContent($directory);
-		} catch (StorageNotAvailableException $e) {
-			$this->setUnavailable($e);
-			return new \EmptyIterator();
-		}
-	}
+    public const RECHECK_TTL_SEC = 600; // 10 minutes
+
+    /** @var IConfig */
+    protected $config;
+    protected ?bool $available = null;
+
+    public function __construct(array $parameters) {
+        $this->config = $parameters['config'] ?? \OCP\Server::get(IConfig::class);
+        parent::__construct($parameters);
+    }
+
+    public static function shouldRecheck($availability): bool {
+        if (!$availability['available']) {
+            // trigger a recheck if TTL reached
+            if ((time() - $availability['last_checked']) > self::RECHECK_TTL_SEC) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Only called if availability === false
+     */
+    private function updateAvailability(): bool {
+        // reset availability to false so that multiple requests don't recheck concurrently
+        $this->setAvailability(false);
+        try {
+            $result = $this->test();
+        } catch (\Exception $e) {
+            $result = false;
+        }
+        $this->setAvailability($result);
+        return $result;
+    }
+
+    private function isAvailable(): bool {
+        if (is_null($this->available)) {
+            $availability = $this->getAvailability();
+            if (self::shouldRecheck($availability)) {
+                return $this->updateAvailability();
+            }
+            $this->available = $availability['available'];
+        }
+        return $this->available;
+    }
+
+    /**
+     * @throws StorageNotAvailableException
+     */
+    private function checkAvailability(): void {
+        if (!$this->isAvailable()) {
+            throw new StorageNotAvailableException();
+        }
+    }
+
+    /**
+     * Handles availability checks and delegates method calls dynamically
+     */
+    private function handleAvailability(string $method, mixed ...$args): mixed {
+        $this->checkAvailability();
+        try {
+            return call_user_func_array([parent::class, $method], $args);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return false;
+        }
+    }
+
+    public function mkdir(string $path): bool {
+        return $this->handleAvailability('mkdir', $path);
+    }
+
+    public function rmdir(string $path): bool {
+        return $this->handleAvailability('rmdir', $path);
+    }
+
+    public function opendir(string $path) {
+        return $this->handleAvailability('opendir', $path);
+    }
+
+    public function is_dir(string $path): bool {
+        return $this->handleAvailability('is_dir', $path);
+    }
+
+    public function is_file(string $path): bool {
+        return $this->handleAvailability('is_file', $path);
+    }
+
+    public function stat(string $path): array|false {
+        return $this->handleAvailability('stat', $path);
+    }
+
+    public function filetype(string $path): string|false {
+        return $this->handleAvailability('filetype', $path);
+    }
+
+    public function filesize(string $path): int|float|false {
+        return $this->handleAvailability('filesize', $path);
+    }
+
+    public function isCreatable(string $path): bool {
+        return $this->handleAvailability('isCreatable', $path);
+    }
+
+    public function isReadable(string $path): bool {
+        return $this->handleAvailability('isReadable', $path);
+    }
+
+    public function isUpdatable(string $path): bool {
+        return $this->handleAvailability('isUpdatable', $path);
+    }
+
+    public function isDeletable(string $path): bool {
+        return $this->handleAvailability('isDeletable', $path);
+    }
+
+    public function isSharable(string $path): bool {
+        return $this->handleAvailability('isSharable', $path);
+    }
+
+    public function getPermissions(string $path): int {
+        return $this->handleAvailability('getPermissions', $path);
+    }
+
+    public function file_exists(string $path): bool {
+        if ($path === '') {
+            return true;
+        }
+        return $this->handleAvailability('file_exists', $path);
+    }
+
+    public function filemtime(string $path): int|false {
+        return $this->handleAvailability('filemtime', $path);
+    }
+
+    public function file_get_contents(string $path): string|false {
+        return $this->handleAvailability('file_get_contents', $path);
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        return $this->handleAvailability('file_put_contents', $path, $data);
+    }
+
+    public function unlink(string $path): bool {
+        return $this->handleAvailability('unlink', $path);
+    }
+
+    public function rename(string $source, string $target): bool {
+        return $this->handleAvailability('rename', $source, $target);
+    }
+
+    public function copy(string $source, string $target): bool {
+        return $this->handleAvailability('copy', $source, $target);
+    }
+
+    public function fopen(string $path, string $mode) {
+        return $this->handleAvailability('fopen', $path, $mode);
+    }
+
+    public function getMimeType(string $path): string|false {
+        return $this->handleAvailability('getMimeType', $path);
+    }
+
+    public function hash(string $type, string $path, bool $raw = false): string|false {
+        return $this->handleAvailability('hash', $type, $path, $raw);
+    }
+
+    public function free_space(string $path): int|float|false {
+        return $this->handleAvailability('free_space', $path);
+    }
+
+    public function touch(string $path, ?int $mtime = null): bool {
+        return $this->handleAvailability('touch', $path, $mtime);
+    }
+
+    public function getLocalFile(string $path): string|false {
+        return $this->handleAvailability('getLocalFile', $path);
+    }
+
+    public function hasUpdated(string $path, int $time): bool {
+        if (!$this->isAvailable()) {
+            return false;
+        }
+        try {
+            return parent::hasUpdated($path, $time);
+        } catch (StorageNotAvailableException $e) {
+            // set unavailable but don't rethrow
+            $this->setUnavailable(null);
+            return false;
+        }
+    }
+
+    public function getOwner(string $path): string|false {
+        try {
+            return parent::getOwner($path);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return false;
+        }
+    }
+
+    public function getETag(string $path): string|false {
+        return $this->handleAvailability('getETag', $path);
+    }
+
+    public function getDirectDownload(string $path): array|false {
+        return $this->handleAvailability('getDirectDownload', $path);
+    }
+
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return $this->handleAvailability('copyFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return $this->handleAvailability('moveFromStorage', $sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
+
+    public function getMetaData(string $path): ?array {
+        $this->checkAvailability();
+        try {
+            return parent::getMetaData($path);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return null;
+        }
+    }
+
+    /**
+     * @template T of StorageNotAvailableException|null
+     * @param T $e
+     * @psalm-return (T is null ? void : never)
+     * @throws StorageNotAvailableException
+     */
+    protected function setUnavailable(?StorageNotAvailableException $e): void {
+        $delay = self::RECHECK_TTL_SEC;
+        if ($e instanceof StorageAuthException) {
+            $delay = max(
+                // 30min
+                $this->config->getSystemValueInt('external_storage.auth_availability_delay', 1800),
+                self::RECHECK_TTL_SEC
+            );
+        }
+        $this->available = false;
+        $this->getStorageCache()->setAvailability(false, $delay);
+        if ($e !== null) {
+            throw $e;
+        }
+    }
+
+
+
+    public function getDirectoryContent(string $directory): \Traversable {
+        $this->checkAvailability();
+        try {
+            return parent::getDirectoryContent($directory);
+        } catch (StorageNotAvailableException $e) {
+            $this->setUnavailable($e);
+            return new \EmptyIterator();
+        }
+    }
 }

lib/private/Files/Storage/Common.php

Indentation +714 added lines, -714 removed lines

@@ -52,718 +52,718 @@
  * in classes which extend it, e.g. $this->stat() .
  */
 abstract class Common implements Storage, ILockingStorage, IWriteStreamStorage, IConstructableStorage {
-	use LocalTempFileTrait;
-
-	protected ?Cache $cache = null;
-	protected ?Scanner $scanner = null;
-	protected ?Watcher $watcher = null;
-	protected ?Propagator $propagator = null;
-	protected $storageCache;
-	protected ?Updater $updater = null;
-
-	protected array $mountOptions = [];
-	protected $owner = null;
-
-	private ?bool $shouldLogLocks = null;
-	private ?LoggerInterface $logger = null;
-	private ?IFilenameValidator $filenameValidator = null;
-
-	public function __construct(array $parameters) {
-	}
-
-	protected function remove(string $path): bool {
-		if ($this->file_exists($path)) {
-			if ($this->is_dir($path)) {
-				return $this->rmdir($path);
-			} elseif ($this->is_file($path)) {
-				return $this->unlink($path);
-			}
-		}
-		return false;
-	}
-
-	public function is_dir(string $path): bool {
-		return $this->filetype($path) === 'dir';
-	}
-
-	public function is_file(string $path): bool {
-		return $this->filetype($path) === 'file';
-	}
-
-	public function filesize(string $path): int|float|false {
-		if ($this->is_dir($path)) {
-			return 0; //by definition
-		} else {
-			$stat = $this->stat($path);
-			return isset($stat['size']) ? $stat['size'] : 0;
-		}
-	}
-
-	public function isReadable(string $path): bool {
-		// at least check whether it exists
-		// subclasses might want to implement this more thoroughly
-		return $this->file_exists($path);
-	}
-
-	public function isUpdatable(string $path): bool {
-		// at least check whether it exists
-		// subclasses might want to implement this more thoroughly
-		// a non-existing file/folder isn't updatable
-		return $this->file_exists($path);
-	}
-
-	public function isCreatable(string $path): bool {
-		if ($this->is_dir($path) && $this->isUpdatable($path)) {
-			return true;
-		}
-		return false;
-	}
-
-	public function isDeletable(string $path): bool {
-		if ($path === '' || $path === '/') {
-			return $this->isUpdatable($path);
-		}
-		$parent = dirname($path);
-		return $this->isUpdatable($parent) && $this->isUpdatable($path);
-	}
-
-	public function isSharable(string $path): bool {
-		return $this->isReadable($path);
-	}
-
-	public function getPermissions(string $path): int {
-		$permissions = 0;
-		if ($this->isCreatable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_CREATE;
-		}
-		if ($this->isReadable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_READ;
-		}
-		if ($this->isUpdatable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_UPDATE;
-		}
-		if ($this->isDeletable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_DELETE;
-		}
-		if ($this->isSharable($path)) {
-			$permissions |= \OCP\Constants::PERMISSION_SHARE;
-		}
-		return $permissions;
-	}
-
-	public function filemtime(string $path): int|false {
-		$stat = $this->stat($path);
-		if (isset($stat['mtime']) && $stat['mtime'] > 0) {
-			return $stat['mtime'];
-		} else {
-			return 0;
-		}
-	}
-
-	public function file_get_contents(string $path): string|false {
-		$handle = $this->fopen($path, 'r');
-		if (!$handle) {
-			return false;
-		}
-		$data = stream_get_contents($handle);
-		fclose($handle);
-		return $data;
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		$handle = $this->fopen($path, 'w');
-		if (!$handle) {
-			return false;
-		}
-		$this->removeCachedFile($path);
-		$count = fwrite($handle, $data);
-		fclose($handle);
-		return $count;
-	}
-
-	public function rename(string $source, string $target): bool {
-		$this->remove($target);
-
-		$this->removeCachedFile($source);
-		return $this->copy($source, $target) && $this->remove($source);
-	}
-
-	public function copy(string $source, string $target): bool {
-		if ($this->is_dir($source)) {
-			$this->remove($target);
-			$dir = $this->opendir($source);
-			$this->mkdir($target);
-			while (($file = readdir($dir)) !== false) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					if (!$this->copy($source . '/' . $file, $target . '/' . $file)) {
-						closedir($dir);
-						return false;
-					}
-				}
-			}
-			closedir($dir);
-			return true;
-		} else {
-			$sourceStream = $this->fopen($source, 'r');
-			$targetStream = $this->fopen($target, 'w');
-			[, $result] = Files::streamCopy($sourceStream, $targetStream, true);
-			if (!$result) {
-				Server::get(LoggerInterface::class)->warning("Failed to write data while copying $source to $target");
-			}
-			$this->removeCachedFile($target);
-			return $result;
-		}
-	}
-
-	public function getMimeType(string $path): string|false {
-		if ($this->is_dir($path)) {
-			return 'httpd/unix-directory';
-		} elseif ($this->file_exists($path)) {
-			return \OC::$server->getMimeTypeDetector()->detectPath($path);
-		} else {
-			return false;
-		}
-	}
-
-	public function hash(string $type, string $path, bool $raw = false): string|false {
-		$fh = $this->fopen($path, 'rb');
-		if (!$fh) {
-			return false;
-		}
-		$ctx = hash_init($type);
-		hash_update_stream($ctx, $fh);
-		fclose($fh);
-		return hash_final($ctx, $raw);
-	}
-
-	public function getLocalFile(string $path): string|false {
-		return $this->getCachedFile($path);
-	}
-
-	private function addLocalFolder(string $path, string $target): void {
-		$dh = $this->opendir($path);
-		if (is_resource($dh)) {
-			while (($file = readdir($dh)) !== false) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					if ($this->is_dir($path . '/' . $file)) {
-						mkdir($target . '/' . $file);
-						$this->addLocalFolder($path . '/' . $file, $target . '/' . $file);
-					} else {
-						$tmp = $this->toTmpFile($path . '/' . $file);
-						rename($tmp, $target . '/' . $file);
-					}
-				}
-			}
-		}
-	}
-
-	protected function searchInDir(string $query, string $dir = ''): array {
-		$files = [];
-		$dh = $this->opendir($dir);
-		if (is_resource($dh)) {
-			while (($item = readdir($dh)) !== false) {
-				if (Filesystem::isIgnoredDir($item)) {
-					continue;
-				}
-				if (strstr(strtolower($item), strtolower($query)) !== false) {
-					$files[] = $dir . '/' . $item;
-				}
-				if ($this->is_dir($dir . '/' . $item)) {
-					$files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
-				}
-			}
-		}
-		closedir($dh);
-		return $files;
-	}
-
-	/**
-	 * @inheritDoc
-	 * Check if a file or folder has been updated since $time
-	 *
-	 * The method is only used to check if the cache needs to be updated. Storage backends that don't support checking
-	 * the mtime should always return false here. As a result storage implementations that always return false expect
-	 * exclusive access to the backend and will not pick up files that have been added in a way that circumvents
-	 * Nextcloud filesystem.
-	 */
-	public function hasUpdated(string $path, int $time): bool {
-		return $this->filemtime($path) > $time;
-	}
-
-	protected function getCacheDependencies(): CacheDependencies {
-		static $dependencies = null;
-		if (!$dependencies) {
-			$dependencies = Server::get(CacheDependencies::class);
-		}
-		return $dependencies;
-	}
-
-	public function getCache(string $path = '', ?IStorage $storage = null): ICache {
-		if (!$storage) {
-			$storage = $this;
-		}
-		/** @var self $storage */
-		if (!isset($storage->cache)) {
-			$storage->cache = new Cache($storage, $this->getCacheDependencies());
-		}
-		return $storage->cache;
-	}
-
-	public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		if (!isset($storage->scanner)) {
-			$storage->scanner = new Scanner($storage);
-		}
-		return $storage->scanner;
-	}
-
-	public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!isset($this->watcher)) {
-			$this->watcher = new Watcher($storage);
-			$globalPolicy = Server::get(IConfig::class)->getSystemValueInt('filesystem_check_changes', Watcher::CHECK_NEVER);
-			$this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
-		}
-		return $this->watcher;
-	}
-
-	public function getPropagator(?IStorage $storage = null): IPropagator {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		/** @var self $storage */
-		if (!isset($storage->propagator)) {
-			$config = Server::get(IConfig::class);
-			$storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getSystemValueString('instanceid')]);
-		}
-		return $storage->propagator;
-	}
-
-	public function getUpdater(?IStorage $storage = null): IUpdater {
-		if (!$storage) {
-			$storage = $this;
-		}
-		if (!$storage->instanceOfStorage(self::class)) {
-			throw new \InvalidArgumentException('Storage is not of the correct class');
-		}
-		/** @var self $storage */
-		if (!isset($storage->updater)) {
-			$storage->updater = new Updater($storage);
-		}
-		return $storage->updater;
-	}
-
-	public function getStorageCache(?IStorage $storage = null): \OC\Files\Cache\Storage {
-		/** @var Cache $cache */
-		$cache = $this->getCache(storage: $storage);
-		return $cache->getStorageCache();
-	}
-
-	public function getOwner(string $path): string|false {
-		if ($this->owner === null) {
-			$this->owner = \OC_User::getUser();
-		}
-
-		return $this->owner;
-	}
-
-	public function getETag(string $path): string|false {
-		return uniqid();
-	}
-
-	/**
-	 * clean a path, i.e. remove all redundant '.' and '..'
-	 * making sure that it can't point to higher than '/'
-	 *
-	 * @param string $path The path to clean
-	 * @return string cleaned path
-	 */
-	public function cleanPath(string $path): string {
-		if (strlen($path) == 0 || $path[0] != '/') {
-			$path = '/' . $path;
-		}
-
-		$output = [];
-		foreach (explode('/', $path) as $chunk) {
-			if ($chunk == '..') {
-				array_pop($output);
-			} elseif ($chunk == '.') {
-			} else {
-				$output[] = $chunk;
-			}
-		}
-		return implode('/', $output);
-	}
-
-	/**
-	 * Test a storage for availability
-	 */
-	public function test(): bool {
-		try {
-			if ($this->stat('')) {
-				return true;
-			}
-			Server::get(LoggerInterface::class)->info('External storage not available: stat() failed');
-			return false;
-		} catch (\Exception $e) {
-			Server::get(LoggerInterface::class)->warning(
-				'External storage not available: ' . $e->getMessage(),
-				['exception' => $e]
-			);
-			return false;
-		}
-	}
-
-	public function free_space(string $path): int|float|false {
-		return \OCP\Files\FileInfo::SPACE_UNKNOWN;
-	}
-
-	public function isLocal(): bool {
-		// the common implementation returns a temporary file by
-		// default, which is not local
-		return false;
-	}
-
-	/**
-	 * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
-	 */
-	public function instanceOfStorage(string $class): bool {
-		if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
-			// FIXME Temporary fix to keep existing checks working
-			$class = '\OCA\Files_Sharing\SharedStorage';
-		}
-		return is_a($this, $class);
-	}
-
-	/**
-	 * A custom storage implementation can return an url for direct download of a give file.
-	 *
-	 * For now the returned array can hold the parameter url - in future more attributes might follow.
-	 */
-	public function getDirectDownload(string $path): array|false {
-		return [];
-	}
-
-	public function verifyPath(string $path, string $fileName): void {
-		$this->getFilenameValidator()
-			->validateFilename($fileName);
-
-		// verify also the path is valid
-		if ($path && $path !== '/' && $path !== '.') {
-			try {
-				$this->verifyPath(dirname($path), basename($path));
-			} catch (InvalidPathException $e) {
-				// Ignore invalid file type exceptions on directories
-				if ($e->getCode() !== FilenameValidator::INVALID_FILE_TYPE) {
-					$l = \OCP\Util::getL10N('lib');
-					throw new InvalidPathException($l->t('Invalid parent path'), previous: $e);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Get the filename validator
-	 * (cached for performance)
-	 */
-	protected function getFilenameValidator(): IFilenameValidator {
-		if ($this->filenameValidator === null) {
-			$this->filenameValidator = Server::get(IFilenameValidator::class);
-		}
-		return $this->filenameValidator;
-	}
-
-	public function setMountOptions(array $options): void {
-		$this->mountOptions = $options;
-	}
-
-	public function getMountOption(string $name, mixed $default = null): mixed {
-		return $this->mountOptions[$name] ?? $default;
-	}
-
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $targetInternalPath);
-		}
-
-		if ($sourceStorage->is_dir($sourceInternalPath)) {
-			$dh = $sourceStorage->opendir($sourceInternalPath);
-			$result = $this->mkdir($targetInternalPath);
-			if (is_resource($dh)) {
-				$result = true;
-				while ($result && ($file = readdir($dh)) !== false) {
-					if (!Filesystem::isIgnoredDir($file)) {
-						$result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
-					}
-				}
-			}
-		} else {
-			$source = $sourceStorage->fopen($sourceInternalPath, 'r');
-			$result = false;
-			if ($source) {
-				try {
-					$this->writeStream($targetInternalPath, $source);
-					$result = true;
-				} catch (\Exception $e) {
-					Server::get(LoggerInterface::class)->warning('Failed to copy stream to storage', ['exception' => $e]);
-				}
-			}
-
-			if ($result && $preserveMtime) {
-				$mtime = $sourceStorage->filemtime($sourceInternalPath);
-				$this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
-			}
-
-			if (!$result) {
-				// delete partially written target file
-				$this->unlink($targetInternalPath);
-				// delete cache entry that was created by fopen
-				$this->getCache()->remove($targetInternalPath);
-			}
-		}
-		return (bool)$result;
-	}
-
-	/**
-	 * Check if a storage is the same as the current one, including wrapped storages
-	 */
-	private function isSameStorage(IStorage $storage): bool {
-		while ($storage->instanceOfStorage(Wrapper::class)) {
-			/**
-			 * @var Wrapper $storage
-			 */
-			$storage = $storage->getWrapperStorage();
-		}
-
-		return $storage === $this;
-	}
-
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		if (
-			!$sourceStorage->instanceOfStorage(Encryption::class)
-			&& $this->isSameStorage($sourceStorage)
-		) {
-			// resolve any jailed paths
-			while ($sourceStorage->instanceOfStorage(Jail::class)) {
-				/**
-				 * @var Jail $sourceStorage
-				 */
-				$sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
-				$sourceStorage = $sourceStorage->getUnjailedStorage();
-			}
-
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-
-		if (!$sourceStorage->isDeletable($sourceInternalPath)) {
-			return false;
-		}
-
-		$result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
-		if ($result) {
-			if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
-				/** @var ObjectStoreStorage $sourceStorage */
-				$sourceStorage->setPreserveCacheOnDelete(true);
-			}
-			try {
-				if ($sourceStorage->is_dir($sourceInternalPath)) {
-					$result = $sourceStorage->rmdir($sourceInternalPath);
-				} else {
-					$result = $sourceStorage->unlink($sourceInternalPath);
-				}
-			} finally {
-				if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
-					/** @var ObjectStoreStorage $sourceStorage */
-					$sourceStorage->setPreserveCacheOnDelete(false);
-				}
-			}
-		}
-		return $result;
-	}
-
-	public function getMetaData(string $path): ?array {
-		if (Filesystem::isFileBlacklisted($path)) {
-			throw new ForbiddenException('Invalid path: ' . $path, false);
-		}
-
-		$permissions = $this->getPermissions($path);
-		if (!$permissions & \OCP\Constants::PERMISSION_READ) {
-			//can't read, nothing we can do
-			return null;
-		}
-
-		$data = [];
-		$data['mimetype'] = $this->getMimeType($path);
-		$data['mtime'] = $this->filemtime($path);
-		if ($data['mtime'] === false) {
-			$data['mtime'] = time();
-		}
-		if ($data['mimetype'] == 'httpd/unix-directory') {
-			$data['size'] = -1; //unknown
-		} else {
-			$data['size'] = $this->filesize($path);
-		}
-		$data['etag'] = $this->getETag($path);
-		$data['storage_mtime'] = $data['mtime'];
-		$data['permissions'] = $permissions;
-		$data['name'] = basename($path);
-
-		return $data;
-	}
-
-	public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'acquire %s lock on "%s" on storage "%s"',
-					$typeString,
-					$path,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
-		} catch (LockedException $e) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'release %s lock on "%s" on storage "%s"',
-					$typeString,
-					$path,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->releaseLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
-		} catch (LockedException $e) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	public function changeLock(string $path, int $type, ILockingProvider $provider): void {
-		$logger = $this->getLockLogger();
-		if ($logger) {
-			$typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
-			$logger->info(
-				sprintf(
-					'change lock on "%s" to %s on storage "%s"',
-					$path,
-					$typeString,
-					$this->getId()
-				),
-				[
-					'app' => 'locking',
-				]
-			);
-		}
-		try {
-			$provider->changeLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
-		} catch (LockedException $e) {
-			$e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
-			if ($logger) {
-				$logger->info($e->getMessage(), ['exception' => $e]);
-			}
-			throw $e;
-		}
-	}
-
-	private function getLockLogger(): ?LoggerInterface {
-		if (is_null($this->shouldLogLocks)) {
-			$this->shouldLogLocks = Server::get(IConfig::class)->getSystemValueBool('filelocking.debug', false);
-			$this->logger = $this->shouldLogLocks ? Server::get(LoggerInterface::class) : null;
-		}
-		return $this->logger;
-	}
-
-	/**
-	 * @return array{available: bool, last_checked: int}
-	 */
-	public function getAvailability(): array {
-		return $this->getStorageCache()->getAvailability();
-	}
-
-	public function setAvailability(bool $isAvailable): void {
-		$this->getStorageCache()->setAvailability($isAvailable);
-	}
-
-	public function setOwner(?string $user): void {
-		$this->owner = $user;
-	}
-
-	public function needsPartFile(): bool {
-		return true;
-	}
-
-	public function writeStream(string $path, $stream, ?int $size = null): int {
-		$target = $this->fopen($path, 'w');
-		if (!$target) {
-			throw new GenericFileException("Failed to open $path for writing");
-		}
-		try {
-			[$count, $result] = Files::streamCopy($stream, $target, true);
-			if (!$result) {
-				throw new GenericFileException('Failed to copy stream');
-			}
-		} finally {
-			fclose($target);
-			fclose($stream);
-		}
-		return $count;
-	}
-
-	public function getDirectoryContent(string $directory): \Traversable {
-		$dh = $this->opendir($directory);
-
-		if ($dh === false) {
-			throw new StorageNotAvailableException('Directory listing failed');
-		}
-
-		if (is_resource($dh)) {
-			$basePath = rtrim($directory, '/');
-			while (($file = readdir($dh)) !== false) {
-				if (!Filesystem::isIgnoredDir($file)) {
-					$childPath = $basePath . '/' . trim($file, '/');
-					$metadata = $this->getMetaData($childPath);
-					if ($metadata !== null) {
-						yield $metadata;
-					}
-				}
-			}
-		}
-	}
+    use LocalTempFileTrait;
+
+    protected ?Cache $cache = null;
+    protected ?Scanner $scanner = null;
+    protected ?Watcher $watcher = null;
+    protected ?Propagator $propagator = null;
+    protected $storageCache;
+    protected ?Updater $updater = null;
+
+    protected array $mountOptions = [];
+    protected $owner = null;
+
+    private ?bool $shouldLogLocks = null;
+    private ?LoggerInterface $logger = null;
+    private ?IFilenameValidator $filenameValidator = null;
+
+    public function __construct(array $parameters) {
+    }
+
+    protected function remove(string $path): bool {
+        if ($this->file_exists($path)) {
+            if ($this->is_dir($path)) {
+                return $this->rmdir($path);
+            } elseif ($this->is_file($path)) {
+                return $this->unlink($path);
+            }
+        }
+        return false;
+    }
+
+    public function is_dir(string $path): bool {
+        return $this->filetype($path) === 'dir';
+    }
+
+    public function is_file(string $path): bool {
+        return $this->filetype($path) === 'file';
+    }
+
+    public function filesize(string $path): int|float|false {
+        if ($this->is_dir($path)) {
+            return 0; //by definition
+        } else {
+            $stat = $this->stat($path);
+            return isset($stat['size']) ? $stat['size'] : 0;
+        }
+    }
+
+    public function isReadable(string $path): bool {
+        // at least check whether it exists
+        // subclasses might want to implement this more thoroughly
+        return $this->file_exists($path);
+    }
+
+    public function isUpdatable(string $path): bool {
+        // at least check whether it exists
+        // subclasses might want to implement this more thoroughly
+        // a non-existing file/folder isn't updatable
+        return $this->file_exists($path);
+    }
+
+    public function isCreatable(string $path): bool {
+        if ($this->is_dir($path) && $this->isUpdatable($path)) {
+            return true;
+        }
+        return false;
+    }
+
+    public function isDeletable(string $path): bool {
+        if ($path === '' || $path === '/') {
+            return $this->isUpdatable($path);
+        }
+        $parent = dirname($path);
+        return $this->isUpdatable($parent) && $this->isUpdatable($path);
+    }
+
+    public function isSharable(string $path): bool {
+        return $this->isReadable($path);
+    }
+
+    public function getPermissions(string $path): int {
+        $permissions = 0;
+        if ($this->isCreatable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_CREATE;
+        }
+        if ($this->isReadable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_READ;
+        }
+        if ($this->isUpdatable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_UPDATE;
+        }
+        if ($this->isDeletable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_DELETE;
+        }
+        if ($this->isSharable($path)) {
+            $permissions |= \OCP\Constants::PERMISSION_SHARE;
+        }
+        return $permissions;
+    }
+
+    public function filemtime(string $path): int|false {
+        $stat = $this->stat($path);
+        if (isset($stat['mtime']) && $stat['mtime'] > 0) {
+            return $stat['mtime'];
+        } else {
+            return 0;
+        }
+    }
+
+    public function file_get_contents(string $path): string|false {
+        $handle = $this->fopen($path, 'r');
+        if (!$handle) {
+            return false;
+        }
+        $data = stream_get_contents($handle);
+        fclose($handle);
+        return $data;
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        $handle = $this->fopen($path, 'w');
+        if (!$handle) {
+            return false;
+        }
+        $this->removeCachedFile($path);
+        $count = fwrite($handle, $data);
+        fclose($handle);
+        return $count;
+    }
+
+    public function rename(string $source, string $target): bool {
+        $this->remove($target);
+
+        $this->removeCachedFile($source);
+        return $this->copy($source, $target) && $this->remove($source);
+    }
+
+    public function copy(string $source, string $target): bool {
+        if ($this->is_dir($source)) {
+            $this->remove($target);
+            $dir = $this->opendir($source);
+            $this->mkdir($target);
+            while (($file = readdir($dir)) !== false) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    if (!$this->copy($source . '/' . $file, $target . '/' . $file)) {
+                        closedir($dir);
+                        return false;
+                    }
+                }
+            }
+            closedir($dir);
+            return true;
+        } else {
+            $sourceStream = $this->fopen($source, 'r');
+            $targetStream = $this->fopen($target, 'w');
+            [, $result] = Files::streamCopy($sourceStream, $targetStream, true);
+            if (!$result) {
+                Server::get(LoggerInterface::class)->warning("Failed to write data while copying $source to $target");
+            }
+            $this->removeCachedFile($target);
+            return $result;
+        }
+    }
+
+    public function getMimeType(string $path): string|false {
+        if ($this->is_dir($path)) {
+            return 'httpd/unix-directory';
+        } elseif ($this->file_exists($path)) {
+            return \OC::$server->getMimeTypeDetector()->detectPath($path);
+        } else {
+            return false;
+        }
+    }
+
+    public function hash(string $type, string $path, bool $raw = false): string|false {
+        $fh = $this->fopen($path, 'rb');
+        if (!$fh) {
+            return false;
+        }
+        $ctx = hash_init($type);
+        hash_update_stream($ctx, $fh);
+        fclose($fh);
+        return hash_final($ctx, $raw);
+    }
+
+    public function getLocalFile(string $path): string|false {
+        return $this->getCachedFile($path);
+    }
+
+    private function addLocalFolder(string $path, string $target): void {
+        $dh = $this->opendir($path);
+        if (is_resource($dh)) {
+            while (($file = readdir($dh)) !== false) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    if ($this->is_dir($path . '/' . $file)) {
+                        mkdir($target . '/' . $file);
+                        $this->addLocalFolder($path . '/' . $file, $target . '/' . $file);
+                    } else {
+                        $tmp = $this->toTmpFile($path . '/' . $file);
+                        rename($tmp, $target . '/' . $file);
+                    }
+                }
+            }
+        }
+    }
+
+    protected function searchInDir(string $query, string $dir = ''): array {
+        $files = [];
+        $dh = $this->opendir($dir);
+        if (is_resource($dh)) {
+            while (($item = readdir($dh)) !== false) {
+                if (Filesystem::isIgnoredDir($item)) {
+                    continue;
+                }
+                if (strstr(strtolower($item), strtolower($query)) !== false) {
+                    $files[] = $dir . '/' . $item;
+                }
+                if ($this->is_dir($dir . '/' . $item)) {
+                    $files = array_merge($files, $this->searchInDir($query, $dir . '/' . $item));
+                }
+            }
+        }
+        closedir($dh);
+        return $files;
+    }
+
+    /**
+     * @inheritDoc
+     * Check if a file or folder has been updated since $time
+     *
+     * The method is only used to check if the cache needs to be updated. Storage backends that don't support checking
+     * the mtime should always return false here. As a result storage implementations that always return false expect
+     * exclusive access to the backend and will not pick up files that have been added in a way that circumvents
+     * Nextcloud filesystem.
+     */
+    public function hasUpdated(string $path, int $time): bool {
+        return $this->filemtime($path) > $time;
+    }
+
+    protected function getCacheDependencies(): CacheDependencies {
+        static $dependencies = null;
+        if (!$dependencies) {
+            $dependencies = Server::get(CacheDependencies::class);
+        }
+        return $dependencies;
+    }
+
+    public function getCache(string $path = '', ?IStorage $storage = null): ICache {
+        if (!$storage) {
+            $storage = $this;
+        }
+        /** @var self $storage */
+        if (!isset($storage->cache)) {
+            $storage->cache = new Cache($storage, $this->getCacheDependencies());
+        }
+        return $storage->cache;
+    }
+
+    public function getScanner(string $path = '', ?IStorage $storage = null): IScanner {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        if (!isset($storage->scanner)) {
+            $storage->scanner = new Scanner($storage);
+        }
+        return $storage->scanner;
+    }
+
+    public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!isset($this->watcher)) {
+            $this->watcher = new Watcher($storage);
+            $globalPolicy = Server::get(IConfig::class)->getSystemValueInt('filesystem_check_changes', Watcher::CHECK_NEVER);
+            $this->watcher->setPolicy((int)$this->getMountOption('filesystem_check_changes', $globalPolicy));
+        }
+        return $this->watcher;
+    }
+
+    public function getPropagator(?IStorage $storage = null): IPropagator {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        /** @var self $storage */
+        if (!isset($storage->propagator)) {
+            $config = Server::get(IConfig::class);
+            $storage->propagator = new Propagator($storage, \OC::$server->getDatabaseConnection(), ['appdata_' . $config->getSystemValueString('instanceid')]);
+        }
+        return $storage->propagator;
+    }
+
+    public function getUpdater(?IStorage $storage = null): IUpdater {
+        if (!$storage) {
+            $storage = $this;
+        }
+        if (!$storage->instanceOfStorage(self::class)) {
+            throw new \InvalidArgumentException('Storage is not of the correct class');
+        }
+        /** @var self $storage */
+        if (!isset($storage->updater)) {
+            $storage->updater = new Updater($storage);
+        }
+        return $storage->updater;
+    }
+
+    public function getStorageCache(?IStorage $storage = null): \OC\Files\Cache\Storage {
+        /** @var Cache $cache */
+        $cache = $this->getCache(storage: $storage);
+        return $cache->getStorageCache();
+    }
+
+    public function getOwner(string $path): string|false {
+        if ($this->owner === null) {
+            $this->owner = \OC_User::getUser();
+        }
+
+        return $this->owner;
+    }
+
+    public function getETag(string $path): string|false {
+        return uniqid();
+    }
+
+    /**
+     * clean a path, i.e. remove all redundant '.' and '..'
+     * making sure that it can't point to higher than '/'
+     *
+     * @param string $path The path to clean
+     * @return string cleaned path
+     */
+    public function cleanPath(string $path): string {
+        if (strlen($path) == 0 || $path[0] != '/') {
+            $path = '/' . $path;
+        }
+
+        $output = [];
+        foreach (explode('/', $path) as $chunk) {
+            if ($chunk == '..') {
+                array_pop($output);
+            } elseif ($chunk == '.') {
+            } else {
+                $output[] = $chunk;
+            }
+        }
+        return implode('/', $output);
+    }
+
+    /**
+     * Test a storage for availability
+     */
+    public function test(): bool {
+        try {
+            if ($this->stat('')) {
+                return true;
+            }
+            Server::get(LoggerInterface::class)->info('External storage not available: stat() failed');
+            return false;
+        } catch (\Exception $e) {
+            Server::get(LoggerInterface::class)->warning(
+                'External storage not available: ' . $e->getMessage(),
+                ['exception' => $e]
+            );
+            return false;
+        }
+    }
+
+    public function free_space(string $path): int|float|false {
+        return \OCP\Files\FileInfo::SPACE_UNKNOWN;
+    }
+
+    public function isLocal(): bool {
+        // the common implementation returns a temporary file by
+        // default, which is not local
+        return false;
+    }
+
+    /**
+     * Check if the storage is an instance of $class or is a wrapper for a storage that is an instance of $class
+     */
+    public function instanceOfStorage(string $class): bool {
+        if (ltrim($class, '\\') === 'OC\Files\Storage\Shared') {
+            // FIXME Temporary fix to keep existing checks working
+            $class = '\OCA\Files_Sharing\SharedStorage';
+        }
+        return is_a($this, $class);
+    }
+
+    /**
+     * A custom storage implementation can return an url for direct download of a give file.
+     *
+     * For now the returned array can hold the parameter url - in future more attributes might follow.
+     */
+    public function getDirectDownload(string $path): array|false {
+        return [];
+    }
+
+    public function verifyPath(string $path, string $fileName): void {
+        $this->getFilenameValidator()
+            ->validateFilename($fileName);
+
+        // verify also the path is valid
+        if ($path && $path !== '/' && $path !== '.') {
+            try {
+                $this->verifyPath(dirname($path), basename($path));
+            } catch (InvalidPathException $e) {
+                // Ignore invalid file type exceptions on directories
+                if ($e->getCode() !== FilenameValidator::INVALID_FILE_TYPE) {
+                    $l = \OCP\Util::getL10N('lib');
+                    throw new InvalidPathException($l->t('Invalid parent path'), previous: $e);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the filename validator
+     * (cached for performance)
+     */
+    protected function getFilenameValidator(): IFilenameValidator {
+        if ($this->filenameValidator === null) {
+            $this->filenameValidator = Server::get(IFilenameValidator::class);
+        }
+        return $this->filenameValidator;
+    }
+
+    public function setMountOptions(array $options): void {
+        $this->mountOptions = $options;
+    }
+
+    public function getMountOption(string $name, mixed $default = null): mixed {
+        return $this->mountOptions[$name] ?? $default;
+    }
+
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $targetInternalPath);
+        }
+
+        if ($sourceStorage->is_dir($sourceInternalPath)) {
+            $dh = $sourceStorage->opendir($sourceInternalPath);
+            $result = $this->mkdir($targetInternalPath);
+            if (is_resource($dh)) {
+                $result = true;
+                while ($result && ($file = readdir($dh)) !== false) {
+                    if (!Filesystem::isIgnoredDir($file)) {
+                        $result &= $this->copyFromStorage($sourceStorage, $sourceInternalPath . '/' . $file, $targetInternalPath . '/' . $file);
+                    }
+                }
+            }
+        } else {
+            $source = $sourceStorage->fopen($sourceInternalPath, 'r');
+            $result = false;
+            if ($source) {
+                try {
+                    $this->writeStream($targetInternalPath, $source);
+                    $result = true;
+                } catch (\Exception $e) {
+                    Server::get(LoggerInterface::class)->warning('Failed to copy stream to storage', ['exception' => $e]);
+                }
+            }
+
+            if ($result && $preserveMtime) {
+                $mtime = $sourceStorage->filemtime($sourceInternalPath);
+                $this->touch($targetInternalPath, is_int($mtime) ? $mtime : null);
+            }
+
+            if (!$result) {
+                // delete partially written target file
+                $this->unlink($targetInternalPath);
+                // delete cache entry that was created by fopen
+                $this->getCache()->remove($targetInternalPath);
+            }
+        }
+        return (bool)$result;
+    }
+
+    /**
+     * Check if a storage is the same as the current one, including wrapped storages
+     */
+    private function isSameStorage(IStorage $storage): bool {
+        while ($storage->instanceOfStorage(Wrapper::class)) {
+            /**
+             * @var Wrapper $storage
+             */
+            $storage = $storage->getWrapperStorage();
+        }
+
+        return $storage === $this;
+    }
+
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        if (
+            !$sourceStorage->instanceOfStorage(Encryption::class)
+            && $this->isSameStorage($sourceStorage)
+        ) {
+            // resolve any jailed paths
+            while ($sourceStorage->instanceOfStorage(Jail::class)) {
+                /**
+                 * @var Jail $sourceStorage
+                 */
+                $sourceInternalPath = $sourceStorage->getUnjailedPath($sourceInternalPath);
+                $sourceStorage = $sourceStorage->getUnjailedStorage();
+            }
+
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+
+        if (!$sourceStorage->isDeletable($sourceInternalPath)) {
+            return false;
+        }
+
+        $result = $this->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, true);
+        if ($result) {
+            if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
+                /** @var ObjectStoreStorage $sourceStorage */
+                $sourceStorage->setPreserveCacheOnDelete(true);
+            }
+            try {
+                if ($sourceStorage->is_dir($sourceInternalPath)) {
+                    $result = $sourceStorage->rmdir($sourceInternalPath);
+                } else {
+                    $result = $sourceStorage->unlink($sourceInternalPath);
+                }
+            } finally {
+                if ($sourceStorage->instanceOfStorage(ObjectStoreStorage::class)) {
+                    /** @var ObjectStoreStorage $sourceStorage */
+                    $sourceStorage->setPreserveCacheOnDelete(false);
+                }
+            }
+        }
+        return $result;
+    }
+
+    public function getMetaData(string $path): ?array {
+        if (Filesystem::isFileBlacklisted($path)) {
+            throw new ForbiddenException('Invalid path: ' . $path, false);
+        }
+
+        $permissions = $this->getPermissions($path);
+        if (!$permissions & \OCP\Constants::PERMISSION_READ) {
+            //can't read, nothing we can do
+            return null;
+        }
+
+        $data = [];
+        $data['mimetype'] = $this->getMimeType($path);
+        $data['mtime'] = $this->filemtime($path);
+        if ($data['mtime'] === false) {
+            $data['mtime'] = time();
+        }
+        if ($data['mimetype'] == 'httpd/unix-directory') {
+            $data['size'] = -1; //unknown
+        } else {
+            $data['size'] = $this->filesize($path);
+        }
+        $data['etag'] = $this->getETag($path);
+        $data['storage_mtime'] = $data['mtime'];
+        $data['permissions'] = $permissions;
+        $data['name'] = basename($path);
+
+        return $data;
+    }
+
+    public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'acquire %s lock on "%s" on storage "%s"',
+                    $typeString,
+                    $path,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->acquireLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type, $this->getId() . '::' . $path);
+        } catch (LockedException $e) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'release %s lock on "%s" on storage "%s"',
+                    $typeString,
+                    $path,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->releaseLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+        } catch (LockedException $e) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    public function changeLock(string $path, int $type, ILockingProvider $provider): void {
+        $logger = $this->getLockLogger();
+        if ($logger) {
+            $typeString = ($type === ILockingProvider::LOCK_SHARED) ? 'shared' : 'exclusive';
+            $logger->info(
+                sprintf(
+                    'change lock on "%s" to %s on storage "%s"',
+                    $path,
+                    $typeString,
+                    $this->getId()
+                ),
+                [
+                    'app' => 'locking',
+                ]
+            );
+        }
+        try {
+            $provider->changeLock('files/' . md5($this->getId() . '::' . trim($path, '/')), $type);
+        } catch (LockedException $e) {
+            $e = new LockedException($e->getPath(), $e, $e->getExistingLock(), $path);
+            if ($logger) {
+                $logger->info($e->getMessage(), ['exception' => $e]);
+            }
+            throw $e;
+        }
+    }
+
+    private function getLockLogger(): ?LoggerInterface {
+        if (is_null($this->shouldLogLocks)) {
+            $this->shouldLogLocks = Server::get(IConfig::class)->getSystemValueBool('filelocking.debug', false);
+            $this->logger = $this->shouldLogLocks ? Server::get(LoggerInterface::class) : null;
+        }
+        return $this->logger;
+    }
+
+    /**
+     * @return array{available: bool, last_checked: int}
+     */
+    public function getAvailability(): array {
+        return $this->getStorageCache()->getAvailability();
+    }
+
+    public function setAvailability(bool $isAvailable): void {
+        $this->getStorageCache()->setAvailability($isAvailable);
+    }
+
+    public function setOwner(?string $user): void {
+        $this->owner = $user;
+    }
+
+    public function needsPartFile(): bool {
+        return true;
+    }
+
+    public function writeStream(string $path, $stream, ?int $size = null): int {
+        $target = $this->fopen($path, 'w');
+        if (!$target) {
+            throw new GenericFileException("Failed to open $path for writing");
+        }
+        try {
+            [$count, $result] = Files::streamCopy($stream, $target, true);
+            if (!$result) {
+                throw new GenericFileException('Failed to copy stream');
+            }
+        } finally {
+            fclose($target);
+            fclose($stream);
+        }
+        return $count;
+    }
+
+    public function getDirectoryContent(string $directory): \Traversable {
+        $dh = $this->opendir($directory);
+
+        if ($dh === false) {
+            throw new StorageNotAvailableException('Directory listing failed');
+        }
+
+        if (is_resource($dh)) {
+            $basePath = rtrim($directory, '/');
+            while (($file = readdir($dh)) !== false) {
+                if (!Filesystem::isIgnoredDir($file)) {
+                    $childPath = $basePath . '/' . trim($file, '/');
+                    $metadata = $this->getMetaData($childPath);
+                    if ($metadata !== null) {
+                        yield $metadata;
+                    }
+                }
+            }
+        }
+    }
 }

lib/private/Files/Cache/Storage.php

Indentation +208 added lines, -208 removed lines

@@ -24,212 +24,212 @@
  * @package OC\Files\Cache
  */
 class Storage {
-	/** @var StorageGlobal|null */
-	private static $globalCache = null;
-	private $storageId;
-	private $numericId;
-
-	/**
-	 * @return StorageGlobal
-	 */
-	public static function getGlobalCache() {
-		if (is_null(self::$globalCache)) {
-			self::$globalCache = new StorageGlobal(\OC::$server->getDatabaseConnection());
-		}
-		return self::$globalCache;
-	}
-
-	/**
-	 * @param \OC\Files\Storage\Storage|string $storage
-	 * @param bool $isAvailable
-	 * @throws \RuntimeException
-	 */
-	public function __construct($storage, $isAvailable, IDBConnection $connection) {
-		if ($storage instanceof IStorage) {
-			$this->storageId = $storage->getId();
-		} else {
-			$this->storageId = $storage;
-		}
-		$this->storageId = self::adjustStorageId($this->storageId);
-
-		if ($row = self::getStorageById($this->storageId)) {
-			$this->numericId = (int)$row['numeric_id'];
-		} else {
-			$available = $isAvailable ? 1 : 0;
-			if ($connection->insertIfNotExist('*PREFIX*storages', ['id' => $this->storageId, 'available' => $available])) {
-				$this->numericId = $connection->lastInsertId('*PREFIX*storages');
-			} else {
-				if ($row = self::getStorageById($this->storageId)) {
-					$this->numericId = (int)$row['numeric_id'];
-				} else {
-					throw new \RuntimeException('Storage could neither be inserted nor be selected from the database: ' . $this->storageId);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param string $storageId
-	 * @return array
-	 */
-	public static function getStorageById($storageId) {
-		return self::getGlobalCache()->getStorageInfo($storageId);
-	}
-
-	/**
-	 * Adjusts the storage id to use md5 if too long
-	 * @param string $storageId storage id
-	 * @return string unchanged $storageId if its length is less than 64 characters,
-	 *                else returns the md5 of $storageId
-	 */
-	public static function adjustStorageId($storageId) {
-		if (strlen($storageId) > 64) {
-			return md5($storageId);
-		}
-		return $storageId;
-	}
-
-	/**
-	 * Get the numeric id for the storage
-	 *
-	 * @return int
-	 */
-	public function getNumericId() {
-		return $this->numericId;
-	}
-
-	/**
-	 * Get the string id for the storage
-	 *
-	 * @param int $numericId
-	 * @return string|null either the storage id string or null if the numeric id is not known
-	 */
-	public static function getStorageId(int $numericId): ?string {
-		$storage = self::getGlobalCache()->getStorageInfoByNumericId($numericId);
-		return $storage['id'] ?? null;
-	}
-
-	/**
-	 * Get the numeric of the storage with the provided string id
-	 *
-	 * @param $storageId
-	 * @return int|null either the numeric storage id or null if the storage id is not known
-	 */
-	public static function getNumericStorageId($storageId) {
-		$storageId = self::adjustStorageId($storageId);
-
-		if ($row = self::getStorageById($storageId)) {
-			return (int)$row['numeric_id'];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @return array{available: bool, last_checked: int}
-	 */
-	public function getAvailability() {
-		if ($row = self::getStorageById($this->storageId)) {
-			return [
-				'available' => (int)$row['available'] === 1,
-				'last_checked' => $row['last_checked']
-			];
-		} else {
-			return [
-				'available' => true,
-				'last_checked' => time(),
-			];
-		}
-	}
-
-	/**
-	 * @param bool $isAvailable
-	 * @param int $delay amount of seconds to delay reconsidering that storage further
-	 */
-	public function setAvailability($isAvailable, int $delay = 0) {
-		$available = $isAvailable ? 1 : 0;
-		if (!$isAvailable) {
-			\OCP\Server::get(LoggerInterface::class)->info('Storage with ' . $this->storageId . ' marked as unavailable', ['app' => 'lib']);
-		}
-
-		$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query->update('storages')
-			->set('available', $query->createNamedParameter($available))
-			->set('last_checked', $query->createNamedParameter(time() + $delay))
-			->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
-		$query->executeStatement();
-	}
-
-	/**
-	 * Check if a string storage id is known
-	 *
-	 * @param string $storageId
-	 * @return bool
-	 */
-	public static function exists($storageId) {
-		return !is_null(self::getNumericStorageId($storageId));
-	}
-
-	/**
-	 * remove the entry for the storage
-	 *
-	 * @param string $storageId
-	 */
-	public static function remove($storageId) {
-		$storageId = self::adjustStorageId($storageId);
-		$numericId = self::getNumericStorageId($storageId);
-
-		$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query->delete('storages')
-			->where($query->expr()->eq('id', $query->createNamedParameter($storageId)));
-		$query->executeStatement();
-
-		if (!is_null($numericId)) {
-			$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-			$query->delete('filecache')
-				->where($query->expr()->eq('storage', $query->createNamedParameter($numericId)));
-			$query->executeStatement();
-		}
-	}
-
-	/**
-	 * remove the entry for the storage by the mount id
-	 *
-	 * @param int $mountId
-	 */
-	public static function cleanByMountId(int $mountId) {
-		$db = \OC::$server->getDatabaseConnection();
-
-		try {
-			$db->beginTransaction();
-
-			$query = $db->getQueryBuilder();
-			$query->select('storage_id')
-				->from('mounts')
-				->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-			$storageIds = $query->executeQuery()->fetchAll(\PDO::FETCH_COLUMN);
-			$storageIds = array_unique($storageIds);
-
-			$query = $db->getQueryBuilder();
-			$query->delete('filecache')
-				->where($query->expr()->in('storage', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
-			$query->runAcrossAllShards();
-			$query->executeStatement();
-
-			$query = $db->getQueryBuilder();
-			$query->delete('storages')
-				->where($query->expr()->in('numeric_id', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
-			$query->executeStatement();
-
-			$query = $db->getQueryBuilder();
-			$query->delete('mounts')
-				->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-			$query->executeStatement();
-
-			$db->commit();
-		} catch (\Exception $e) {
-			$db->rollBack();
-			throw $e;
-		}
-	}
+    /** @var StorageGlobal|null */
+    private static $globalCache = null;
+    private $storageId;
+    private $numericId;
+
+    /**
+     * @return StorageGlobal
+     */
+    public static function getGlobalCache() {
+        if (is_null(self::$globalCache)) {
+            self::$globalCache = new StorageGlobal(\OC::$server->getDatabaseConnection());
+        }
+        return self::$globalCache;
+    }
+
+    /**
+     * @param \OC\Files\Storage\Storage|string $storage
+     * @param bool $isAvailable
+     * @throws \RuntimeException
+     */
+    public function __construct($storage, $isAvailable, IDBConnection $connection) {
+        if ($storage instanceof IStorage) {
+            $this->storageId = $storage->getId();
+        } else {
+            $this->storageId = $storage;
+        }
+        $this->storageId = self::adjustStorageId($this->storageId);
+
+        if ($row = self::getStorageById($this->storageId)) {
+            $this->numericId = (int)$row['numeric_id'];
+        } else {
+            $available = $isAvailable ? 1 : 0;
+            if ($connection->insertIfNotExist('*PREFIX*storages', ['id' => $this->storageId, 'available' => $available])) {
+                $this->numericId = $connection->lastInsertId('*PREFIX*storages');
+            } else {
+                if ($row = self::getStorageById($this->storageId)) {
+                    $this->numericId = (int)$row['numeric_id'];
+                } else {
+                    throw new \RuntimeException('Storage could neither be inserted nor be selected from the database: ' . $this->storageId);
+                }
+            }
+        }
+    }
+
+    /**
+     * @param string $storageId
+     * @return array
+     */
+    public static function getStorageById($storageId) {
+        return self::getGlobalCache()->getStorageInfo($storageId);
+    }
+
+    /**
+     * Adjusts the storage id to use md5 if too long
+     * @param string $storageId storage id
+     * @return string unchanged $storageId if its length is less than 64 characters,
+     *                else returns the md5 of $storageId
+     */
+    public static function adjustStorageId($storageId) {
+        if (strlen($storageId) > 64) {
+            return md5($storageId);
+        }
+        return $storageId;
+    }
+
+    /**
+     * Get the numeric id for the storage
+     *
+     * @return int
+     */
+    public function getNumericId() {
+        return $this->numericId;
+    }
+
+    /**
+     * Get the string id for the storage
+     *
+     * @param int $numericId
+     * @return string|null either the storage id string or null if the numeric id is not known
+     */
+    public static function getStorageId(int $numericId): ?string {
+        $storage = self::getGlobalCache()->getStorageInfoByNumericId($numericId);
+        return $storage['id'] ?? null;
+    }
+
+    /**
+     * Get the numeric of the storage with the provided string id
+     *
+     * @param $storageId
+     * @return int|null either the numeric storage id or null if the storage id is not known
+     */
+    public static function getNumericStorageId($storageId) {
+        $storageId = self::adjustStorageId($storageId);
+
+        if ($row = self::getStorageById($storageId)) {
+            return (int)$row['numeric_id'];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @return array{available: bool, last_checked: int}
+     */
+    public function getAvailability() {
+        if ($row = self::getStorageById($this->storageId)) {
+            return [
+                'available' => (int)$row['available'] === 1,
+                'last_checked' => $row['last_checked']
+            ];
+        } else {
+            return [
+                'available' => true,
+                'last_checked' => time(),
+            ];
+        }
+    }
+
+    /**
+     * @param bool $isAvailable
+     * @param int $delay amount of seconds to delay reconsidering that storage further
+     */
+    public function setAvailability($isAvailable, int $delay = 0) {
+        $available = $isAvailable ? 1 : 0;
+        if (!$isAvailable) {
+            \OCP\Server::get(LoggerInterface::class)->info('Storage with ' . $this->storageId . ' marked as unavailable', ['app' => 'lib']);
+        }
+
+        $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query->update('storages')
+            ->set('available', $query->createNamedParameter($available))
+            ->set('last_checked', $query->createNamedParameter(time() + $delay))
+            ->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
+        $query->executeStatement();
+    }
+
+    /**
+     * Check if a string storage id is known
+     *
+     * @param string $storageId
+     * @return bool
+     */
+    public static function exists($storageId) {
+        return !is_null(self::getNumericStorageId($storageId));
+    }
+
+    /**
+     * remove the entry for the storage
+     *
+     * @param string $storageId
+     */
+    public static function remove($storageId) {
+        $storageId = self::adjustStorageId($storageId);
+        $numericId = self::getNumericStorageId($storageId);
+
+        $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query->delete('storages')
+            ->where($query->expr()->eq('id', $query->createNamedParameter($storageId)));
+        $query->executeStatement();
+
+        if (!is_null($numericId)) {
+            $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+            $query->delete('filecache')
+                ->where($query->expr()->eq('storage', $query->createNamedParameter($numericId)));
+            $query->executeStatement();
+        }
+    }
+
+    /**
+     * remove the entry for the storage by the mount id
+     *
+     * @param int $mountId
+     */
+    public static function cleanByMountId(int $mountId) {
+        $db = \OC::$server->getDatabaseConnection();
+
+        try {
+            $db->beginTransaction();
+
+            $query = $db->getQueryBuilder();
+            $query->select('storage_id')
+                ->from('mounts')
+                ->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+            $storageIds = $query->executeQuery()->fetchAll(\PDO::FETCH_COLUMN);
+            $storageIds = array_unique($storageIds);
+
+            $query = $db->getQueryBuilder();
+            $query->delete('filecache')
+                ->where($query->expr()->in('storage', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
+            $query->runAcrossAllShards();
+            $query->executeStatement();
+
+            $query = $db->getQueryBuilder();
+            $query->delete('storages')
+                ->where($query->expr()->in('numeric_id', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
+            $query->executeStatement();
+
+            $query = $db->getQueryBuilder();
+            $query->delete('mounts')
+                ->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+            $query->executeStatement();
+
+            $db->commit();
+        } catch (\Exception $e) {
+            $db->rollBack();
+            throw $e;
+        }
+    }
 }

tests/lib/Files/Storage/Wrapper/AvailabilityTest.php

Indentation +167 added lines, -167 removed lines

@@ -14,171 +14,171 @@
 use OCP\Files\StorageNotAvailableException;
 
 class AvailabilityTest extends \Test\TestCase {
-	/** @var \PHPUnit\Framework\MockObject\MockObject|StorageCache */
-	protected $storageCache;
-	/** @var \PHPUnit\Framework\MockObject\MockObject|Temporary */
-	protected $storage;
-	/** @var Availability */
-	protected $wrapper;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->storageCache = $this->createMock(StorageCache::class);
-
-		$this->storage = $this->createMock(Temporary::class);
-		$this->storage->expects($this->any())
-			->method('getStorageCache')
-			->willReturn($this->storageCache);
-
-		$this->wrapper = new Availability(['storage' => $this->storage]);
-	}
-
-	/**
-	 * Storage is available
-	 */
-	public function testAvailable(): void {
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => true, 'last_checked' => 0]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage->expects($this->once())
-			->method('mkdir');
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	/**
-	 * Storage marked unavailable, TTL not expired
-	 *
-	 */
-	public function testUnavailable(): void {
-		$this->expectException(StorageNotAvailableException::class);
-
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => false, 'last_checked' => time()]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage->expects($this->never())
-			->method('mkdir');
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	/**
-	 * Storage marked unavailable, TTL expired
-	 */
-	public function testUnavailableRecheck(): void {
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => false, 'last_checked' => 0]);
-		$this->storage->expects($this->once())
-			->method('test')
-			->willReturn(true);
-		$calls = [
-			false, // prevents concurrent rechecks
-			true, // sets correct availability
-		];
-		$this->storage->expects($this->exactly(2))
-			->method('setAvailability')
-			->willReturnCallback(function ($value) use (&$calls): void {
-				$expected = array_shift($calls);
-				$this->assertEquals($expected, $value);
-			});
-		$this->storage->expects($this->once())
-			->method('mkdir');
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	/**
-	 * Storage marked available, but throws StorageNotAvailableException
-	 *
-	 */
-	public function testAvailableThrowStorageNotAvailable(): void {
-		$this->expectException(StorageNotAvailableException::class);
-
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => true, 'last_checked' => 0]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage->expects($this->once())
-			->method('mkdir')
-			->willThrowException(new StorageNotAvailableException());
-		$this->storageCache->expects($this->once())
-			->method('setAvailability')
-			->with($this->equalTo(false));
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	/**
-	 * Storage available, but call fails
-	 * Method failure does not indicate storage unavailability
-	 */
-	public function testAvailableFailure(): void {
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => true, 'last_checked' => 0]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage->expects($this->once())
-			->method('mkdir')
-			->willReturn(false);
-		$this->storage->expects($this->never())
-			->method('setAvailability');
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	/**
-	 * Storage available, but throws exception
-	 * Standard exception does not indicate storage unavailability
-	 *
-	 */
-	public function testAvailableThrow(): void {
-		$this->expectException(\Exception::class);
-
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => true, 'last_checked' => 0]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage->expects($this->once())
-			->method('mkdir')
-			->willThrowException(new \Exception());
-		$this->storage->expects($this->never())
-			->method('setAvailability');
-
-		$this->wrapper->mkdir('foobar');
-	}
-
-	public function testUnavailableMultiple(): void {
-		$this->storage->expects($this->once())
-			->method('getAvailability')
-			->willReturn(['available' => true, 'last_checked' => 0]);
-		$this->storage->expects($this->never())
-			->method('test');
-		$this->storage
-			->expects($this->once()) // load-bearing `once`
-			->method('mkdir')
-			->willThrowException(new StorageNotAvailableException());
-
-		try {
-			$this->wrapper->mkdir('foobar');
-			$this->fail();
-		} catch (StorageNotAvailableException) {
-		}
-
-		$this->storage->expects($this->never())->method('file_exists');
-
-		try {
-			$this->wrapper->mkdir('foobar');
-			$this->fail();
-		} catch (StorageNotAvailableException) {
-		}
-	}
+    /** @var \PHPUnit\Framework\MockObject\MockObject|StorageCache */
+    protected $storageCache;
+    /** @var \PHPUnit\Framework\MockObject\MockObject|Temporary */
+    protected $storage;
+    /** @var Availability */
+    protected $wrapper;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->storageCache = $this->createMock(StorageCache::class);
+
+        $this->storage = $this->createMock(Temporary::class);
+        $this->storage->expects($this->any())
+            ->method('getStorageCache')
+            ->willReturn($this->storageCache);
+
+        $this->wrapper = new Availability(['storage' => $this->storage]);
+    }
+
+    /**
+     * Storage is available
+     */
+    public function testAvailable(): void {
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => true, 'last_checked' => 0]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage->expects($this->once())
+            ->method('mkdir');
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    /**
+     * Storage marked unavailable, TTL not expired
+     *
+     */
+    public function testUnavailable(): void {
+        $this->expectException(StorageNotAvailableException::class);
+
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => false, 'last_checked' => time()]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage->expects($this->never())
+            ->method('mkdir');
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    /**
+     * Storage marked unavailable, TTL expired
+     */
+    public function testUnavailableRecheck(): void {
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => false, 'last_checked' => 0]);
+        $this->storage->expects($this->once())
+            ->method('test')
+            ->willReturn(true);
+        $calls = [
+            false, // prevents concurrent rechecks
+            true, // sets correct availability
+        ];
+        $this->storage->expects($this->exactly(2))
+            ->method('setAvailability')
+            ->willReturnCallback(function ($value) use (&$calls): void {
+                $expected = array_shift($calls);
+                $this->assertEquals($expected, $value);
+            });
+        $this->storage->expects($this->once())
+            ->method('mkdir');
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    /**
+     * Storage marked available, but throws StorageNotAvailableException
+     *
+     */
+    public function testAvailableThrowStorageNotAvailable(): void {
+        $this->expectException(StorageNotAvailableException::class);
+
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => true, 'last_checked' => 0]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage->expects($this->once())
+            ->method('mkdir')
+            ->willThrowException(new StorageNotAvailableException());
+        $this->storageCache->expects($this->once())
+            ->method('setAvailability')
+            ->with($this->equalTo(false));
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    /**
+     * Storage available, but call fails
+     * Method failure does not indicate storage unavailability
+     */
+    public function testAvailableFailure(): void {
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => true, 'last_checked' => 0]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage->expects($this->once())
+            ->method('mkdir')
+            ->willReturn(false);
+        $this->storage->expects($this->never())
+            ->method('setAvailability');
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    /**
+     * Storage available, but throws exception
+     * Standard exception does not indicate storage unavailability
+     *
+     */
+    public function testAvailableThrow(): void {
+        $this->expectException(\Exception::class);
+
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => true, 'last_checked' => 0]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage->expects($this->once())
+            ->method('mkdir')
+            ->willThrowException(new \Exception());
+        $this->storage->expects($this->never())
+            ->method('setAvailability');
+
+        $this->wrapper->mkdir('foobar');
+    }
+
+    public function testUnavailableMultiple(): void {
+        $this->storage->expects($this->once())
+            ->method('getAvailability')
+            ->willReturn(['available' => true, 'last_checked' => 0]);
+        $this->storage->expects($this->never())
+            ->method('test');
+        $this->storage
+            ->expects($this->once()) // load-bearing `once`
+            ->method('mkdir')
+            ->willThrowException(new StorageNotAvailableException());
+
+        try {
+            $this->wrapper->mkdir('foobar');
+            $this->fail();
+        } catch (StorageNotAvailableException) {
+        }
+
+        $this->storage->expects($this->never())->method('file_exists');
+
+        try {
+            $this->wrapper->mkdir('foobar');
+            $this->fail();
+        } catch (StorageNotAvailableException) {
+        }
+    }
 }