nextcloud / server

lib/public/Files/Cache/IWatcher.php

Indentation +70 added lines, -70 removed lines

@@ -13,84 +13,84 @@
  * @since 9.0.0
  */
 interface IWatcher {
-	/**
-	 * @since 9.0.0
-	 */
-	public const CHECK_NEVER = 0; // never check the underlying filesystem for updates
+    /**
+     * @since 9.0.0
+     */
+    public const CHECK_NEVER = 0; // never check the underlying filesystem for updates
 
-	/**
-	 * @since 9.0.0
-	 */
-	public const CHECK_ONCE = 1; // check the underlying filesystem for updates once every request for each file
+    /**
+     * @since 9.0.0
+     */
+    public const CHECK_ONCE = 1; // check the underlying filesystem for updates once every request for each file
 
-	/**
-	 * @since 9.0.0
-	 */
-	public const CHECK_ALWAYS = 2; // always check the underlying filesystem for updates
+    /**
+     * @since 9.0.0
+     */
+    public const CHECK_ALWAYS = 2; // always check the underlying filesystem for updates
 
-	/**
-	 * @param int $policy either IWatcher::CHECK_NEVER, IWatcher::CHECK_ONCE, IWatcher::CHECK_ALWAYS
-	 * @since 9.0.0
-	 */
-	public function setPolicy($policy);
+    /**
+     * @param int $policy either IWatcher::CHECK_NEVER, IWatcher::CHECK_ONCE, IWatcher::CHECK_ALWAYS
+     * @since 9.0.0
+     */
+    public function setPolicy($policy);
 
-	/**
-	 * Set a filter regex, only paths matching the regex will be checked for updates.
-	 *
-	 * When set to `null`, every path will be checked for updates
-	 *
-	 * @param ?string $filter
-	 * @return void
-	 * @since 33.0.0
-	 */
-	public function setCheckFilter(?string $filter): void;
+    /**
+     * Set a filter regex, only paths matching the regex will be checked for updates.
+     *
+     * When set to `null`, every path will be checked for updates
+     *
+     * @param ?string $filter
+     * @return void
+     * @since 33.0.0
+     */
+    public function setCheckFilter(?string $filter): void;
 
-	/**
-	 * @return int either IWatcher::CHECK_NEVER, IWatcher::CHECK_ONCE, IWatcher::CHECK_ALWAYS
-	 * @since 9.0.0
-	 */
-	public function getPolicy();
+    /**
+     * @return int either IWatcher::CHECK_NEVER, IWatcher::CHECK_ONCE, IWatcher::CHECK_ALWAYS
+     * @since 9.0.0
+     */
+    public function getPolicy();
 
-	/**
-	 * check $path for updates and update if needed
-	 *
-	 * @param string $path
-	 * @param ICacheEntry|null $cachedEntry
-	 * @return boolean true if path was updated
-	 * @since 9.0.0
-	 */
-	public function checkUpdate($path, $cachedEntry = null);
+    /**
+     * check $path for updates and update if needed
+     *
+     * @param string $path
+     * @param ICacheEntry|null $cachedEntry
+     * @return boolean true if path was updated
+     * @since 9.0.0
+     */
+    public function checkUpdate($path, $cachedEntry = null);
 
-	/**
-	 * Update the cache for changes to $path
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 * @since 9.0.0
-	 */
-	public function update($path, $cachedData);
+    /**
+     * Update the cache for changes to $path
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     * @since 9.0.0
+     */
+    public function update($path, $cachedData);
 
-	/**
-	 * Check if the cache for $path needs to be updated
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 * @return bool
-	 * @since 9.0.0
-	 */
-	public function needsUpdate($path, $cachedData);
+    /**
+     * Check if the cache for $path needs to be updated
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     * @return bool
+     * @since 9.0.0
+     */
+    public function needsUpdate($path, $cachedData);
 
-	/**
-	 * remove deleted files in $path from the cache
-	 *
-	 * @param string $path
-	 * @since 9.0.0
-	 */
-	public function cleanFolder($path);
+    /**
+     * remove deleted files in $path from the cache
+     *
+     * @param string $path
+     * @since 9.0.0
+     */
+    public function cleanFolder($path);
 
-	/**
-	 * register a callback to be called whenever the watcher triggers and update
-	 * @since 31.0.0
-	 */
-	public function onUpdate(callable $callback): void;
+    /**
+     * register a callback to be called whenever the watcher triggers and update
+     * @since 31.0.0
+     */
+    public function onUpdate(callable $callback): void;
 }

lib/private/Files/Cache/Watcher.php

Indentation +138 added lines, -138 removed lines

@@ -17,142 +17,142 @@
  * check the storage backends for updates and change the cache accordingly
  */
 class Watcher implements IWatcher {
-	protected $watchPolicy = self::CHECK_ONCE;
-
-	protected $checkedPaths = [];
-
-	/**
-	 * @var IStorage $storage
-	 */
-	protected $storage;
-
-	/**
-	 * @var ICache $cache
-	 */
-	protected $cache;
-
-	/**
-	 * @var IScanner $scanner ;
-	 */
-	protected $scanner;
-
-	/** @var callable[] */
-	protected $onUpdate = [];
-
-	protected ?string $checkFilter = null;
-
-	public function __construct(IStorage $storage) {
-		$this->storage = $storage;
-		$this->cache = $storage->getCache();
-		$this->scanner = $storage->getScanner();
-	}
-
-	/**
-	 * @param int $policy either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
-	 */
-	public function setPolicy($policy) {
-		$this->watchPolicy = $policy;
-	}
-
-	public function setCheckFilter(?string $filter): void {
-		$this->checkFilter = $filter;
-	}
-
-	/**
-	 * @return int either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
-	 */
-	public function getPolicy() {
-		return $this->watchPolicy;
-	}
-
-	/**
-	 * check $path for updates and update if needed
-	 *
-	 * @param string $path
-	 * @param ICacheEntry|null $cachedEntry
-	 * @return boolean true if path was updated
-	 */
-	public function checkUpdate($path, $cachedEntry = null) {
-		if (is_null($cachedEntry)) {
-			$cachedEntry = $this->cache->get($path);
-		}
-		if ($cachedEntry === false || $this->needsUpdate($path, $cachedEntry)) {
-			$this->update($path, $cachedEntry);
-
-			if ($cachedEntry === false) {
-				return true;
-			} else {
-				// storage backends can sometimes return false positives, only return true if the scanner actually found a change
-				$newEntry = $this->cache->get($path);
-				return $newEntry->getStorageMTime() > $cachedEntry->getStorageMTime();
-			}
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Update the cache for changes to $path
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 */
-	public function update($path, $cachedData) {
-		if ($this->storage->is_dir($path)) {
-			$this->scanner->scan($path, Scanner::SCAN_SHALLOW);
-		} else {
-			$this->scanner->scanFile($path);
-		}
-		if (is_array($cachedData) && $cachedData['mimetype'] === 'httpd/unix-directory') {
-			$this->cleanFolder($path);
-		}
-		if ($this->cache instanceof Cache) {
-			$this->cache->correctFolderSize($path);
-		}
-		foreach ($this->onUpdate as $callback) {
-			$callback($path);
-		}
-	}
-
-	/**
-	 * Check if the cache for $path needs to be updated
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 * @return bool
-	 */
-	public function needsUpdate($path, $cachedData) {
-		if ($this->checkFilter !== null) {
-			if (!preg_match($this->checkFilter, $path)) {
-				return false;
-			}
-		}
-
-		if ($this->watchPolicy === self::CHECK_ALWAYS || ($this->watchPolicy === self::CHECK_ONCE && !in_array($path, $this->checkedPaths))) {
-			$this->checkedPaths[] = $path;
-			return $cachedData['storage_mtime'] === null || $this->storage->hasUpdated($path, $cachedData['storage_mtime']);
-		}
-		return false;
-	}
-
-	/**
-	 * remove deleted files in $path from the cache
-	 *
-	 * @param string $path
-	 */
-	public function cleanFolder($path) {
-		$cachedContent = $this->cache->getFolderContents($path);
-		foreach ($cachedContent as $entry) {
-			if (!$this->storage->file_exists($entry['path'])) {
-				$this->cache->remove($entry['path']);
-			}
-		}
-	}
-
-	/**
-	 * register a callback to be called whenever the watcher triggers and update
-	 */
-	public function onUpdate(callable $callback): void {
-		$this->onUpdate[] = $callback;
-	}
+    protected $watchPolicy = self::CHECK_ONCE;
+
+    protected $checkedPaths = [];
+
+    /**
+     * @var IStorage $storage
+     */
+    protected $storage;
+
+    /**
+     * @var ICache $cache
+     */
+    protected $cache;
+
+    /**
+     * @var IScanner $scanner ;
+     */
+    protected $scanner;
+
+    /** @var callable[] */
+    protected $onUpdate = [];
+
+    protected ?string $checkFilter = null;
+
+    public function __construct(IStorage $storage) {
+        $this->storage = $storage;
+        $this->cache = $storage->getCache();
+        $this->scanner = $storage->getScanner();
+    }
+
+    /**
+     * @param int $policy either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
+     */
+    public function setPolicy($policy) {
+        $this->watchPolicy = $policy;
+    }
+
+    public function setCheckFilter(?string $filter): void {
+        $this->checkFilter = $filter;
+    }
+
+    /**
+     * @return int either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
+     */
+    public function getPolicy() {
+        return $this->watchPolicy;
+    }
+
+    /**
+     * check $path for updates and update if needed
+     *
+     * @param string $path
+     * @param ICacheEntry|null $cachedEntry
+     * @return boolean true if path was updated
+     */
+    public function checkUpdate($path, $cachedEntry = null) {
+        if (is_null($cachedEntry)) {
+            $cachedEntry = $this->cache->get($path);
+        }
+        if ($cachedEntry === false || $this->needsUpdate($path, $cachedEntry)) {
+            $this->update($path, $cachedEntry);
+
+            if ($cachedEntry === false) {
+                return true;
+            } else {
+                // storage backends can sometimes return false positives, only return true if the scanner actually found a change
+                $newEntry = $this->cache->get($path);
+                return $newEntry->getStorageMTime() > $cachedEntry->getStorageMTime();
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Update the cache for changes to $path
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     */
+    public function update($path, $cachedData) {
+        if ($this->storage->is_dir($path)) {
+            $this->scanner->scan($path, Scanner::SCAN_SHALLOW);
+        } else {
+            $this->scanner->scanFile($path);
+        }
+        if (is_array($cachedData) && $cachedData['mimetype'] === 'httpd/unix-directory') {
+            $this->cleanFolder($path);
+        }
+        if ($this->cache instanceof Cache) {
+            $this->cache->correctFolderSize($path);
+        }
+        foreach ($this->onUpdate as $callback) {
+            $callback($path);
+        }
+    }
+
+    /**
+     * Check if the cache for $path needs to be updated
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     * @return bool
+     */
+    public function needsUpdate($path, $cachedData) {
+        if ($this->checkFilter !== null) {
+            if (!preg_match($this->checkFilter, $path)) {
+                return false;
+            }
+        }
+
+        if ($this->watchPolicy === self::CHECK_ALWAYS || ($this->watchPolicy === self::CHECK_ONCE && !in_array($path, $this->checkedPaths))) {
+            $this->checkedPaths[] = $path;
+            return $cachedData['storage_mtime'] === null || $this->storage->hasUpdated($path, $cachedData['storage_mtime']);
+        }
+        return false;
+    }
+
+    /**
+     * remove deleted files in $path from the cache
+     *
+     * @param string $path
+     */
+    public function cleanFolder($path) {
+        $cachedContent = $this->cache->getFolderContents($path);
+        foreach ($cachedContent as $entry) {
+            if (!$this->storage->file_exists($entry['path'])) {
+                $this->cache->remove($entry['path']);
+            }
+        }
+    }
+
+    /**
+     * register a callback to be called whenever the watcher triggers and update
+     */
+    public function onUpdate(callable $callback): void {
+        $this->onUpdate[] = $callback;
+    }
 }

lib/private/Files/Storage/Common.php

Indentation +716 added lines, -716 removed lines

@@ -53,720 +53,720 @@
  * 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));
-			$this->watcher->setCheckFilter($this->getMountOption('filesystem_check_filter'));
-		}
-		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);
-	}
-
-	#[Override]
-	public function getDirectDownload(string $path): array|false {
-		return false;
-	}
-
-	#[Override]
-	public function getDirectDownloadById(string $fileId): array|false {
-		return false;
-	}
-
-	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));
+            $this->watcher->setCheckFilter($this->getMountOption('filesystem_check_filter'));
+        }
+        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);
+    }
+
+    #[Override]
+    public function getDirectDownload(string $path): array|false {
+        return false;
+    }
+
+    #[Override]
+    public function getDirectDownloadById(string $fileId): array|false {
+        return false;
+    }
+
+    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;
+                    }
+                }
+            }
+        }
+    }
 }

tests/lib/Files/Cache/WatcherTest.php

Indentation +196 added lines, -196 removed lines

@@ -25,214 +25,214 @@
 #[\PHPUnit\Framework\Attributes\Medium]
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class WatcherTest extends \Test\TestCase {
-	/**
-	 * @var Storage[] $storages
-	 */
-	private $storages = [];
+    /**
+     * @var Storage[] $storages
+     */
+    private $storages = [];
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->loginAsUser();
-	}
+        $this->loginAsUser();
+    }
 
-	protected function tearDown(): void {
-		foreach ($this->storages as $storage) {
-			$cache = $storage->getCache();
-			$ids = $cache->getAll();
-			$cache->clear();
-		}
+    protected function tearDown(): void {
+        foreach ($this->storages as $storage) {
+            $cache = $storage->getCache();
+            $ids = $cache->getAll();
+            $cache->clear();
+        }
 
-		$this->logout();
-		parent::tearDown();
-	}
+        $this->logout();
+        parent::tearDown();
+    }
 
-	public function testWatcher(): void {
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-		$updater->setPolicy(Watcher::CHECK_ONCE);
+    public function testWatcher(): void {
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+        $updater->setPolicy(Watcher::CHECK_ONCE);
 
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', ['storage_mtime' => 10]);
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('', ['storage_mtime' => 10]);
 
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$this->assertTrue($cache->inCache('folder/bar2.txt'));
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $this->assertTrue($cache->inCache('folder/bar2.txt'));
 
-		$this->assertFalse($cache->inCache('bar.test'));
-		$storage->file_put_contents('bar.test', 'foo');
-		$updater->checkUpdate('');
-		$this->assertTrue($cache->inCache('bar.test'));
-		$cachedData = $cache->get('bar.test');
-		$this->assertEquals(3, $cachedData['size']);
+        $this->assertFalse($cache->inCache('bar.test'));
+        $storage->file_put_contents('bar.test', 'foo');
+        $updater->checkUpdate('');
+        $this->assertTrue($cache->inCache('bar.test'));
+        $cachedData = $cache->get('bar.test');
+        $this->assertEquals(3, $cachedData['size']);
 
-		$cache->put('bar.test', ['storage_mtime' => 10]);
-		$storage->file_put_contents('bar.test', 'test data');
+        $cache->put('bar.test', ['storage_mtime' => 10]);
+        $storage->file_put_contents('bar.test', 'test data');
 
-		// make sure that PHP can read the new size correctly
-		clearstatcache();
+        // make sure that PHP can read the new size correctly
+        clearstatcache();
 
-		$updater->checkUpdate('bar.test');
-		$cachedData = $cache->get('bar.test');
-		$this->assertEquals(9, $cachedData['size']);
+        $updater->checkUpdate('bar.test');
+        $cachedData = $cache->get('bar.test');
+        $this->assertEquals(9, $cachedData['size']);
 
-		$cache->put('folder', ['storage_mtime' => 10]);
+        $cache->put('folder', ['storage_mtime' => 10]);
 
-		$storage->unlink('folder/bar2.txt');
-		$updater->checkUpdate('folder');
+        $storage->unlink('folder/bar2.txt');
+        $updater->checkUpdate('folder');
 
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$this->assertFalse($cache->inCache('folder/bar2.txt'));
-	}
-
-
-	public function testFileToFolder(): void {
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-		$updater->setPolicy(Watcher::CHECK_ONCE);
-
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', ['storage_mtime' => 10]);
-
-		$storage->unlink('foo.txt');
-		$storage->rename('folder', 'foo.txt');
-		$updater->checkUpdate('');
-
-		$entry = $cache->get('foo.txt');
-		$this->assertEquals('httpd/unix-directory', $entry['mimetype']);
-		$this->assertFalse($cache->inCache('folder'));
-		$this->assertFalse($cache->inCache('folder/bar.txt'));
-
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-		$updater->setPolicy(Watcher::CHECK_ONCE);
-
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', ['storage_mtime' => 10]);
-
-		$storage->unlink('foo.txt');
-		$storage->rename('folder', 'foo.txt');
-		$updater->checkUpdate('foo.txt');
-
-		$entry = $cache->get('foo.txt');
-		$this->assertEquals('httpd/unix-directory', $entry['mimetype']);
-		$this->assertTrue($cache->inCache('foo.txt/bar.txt'));
-	}
-
-	public function testPolicyNever(): void {
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', ['storage_mtime' => 10]);
-
-		$updater->setPolicy(Watcher::CHECK_NEVER);
-
-		$storage->file_put_contents('foo.txt', 'q');
-		$this->assertFalse($updater->checkUpdate('foo.txt'));
-
-		$cache->put('foo.txt', ['storage_mtime' => 20]);
-		$storage->file_put_contents('foo.txt', 'w');
-		$this->assertFalse($updater->checkUpdate('foo.txt'));
-	}
-
-	public function testPolicyOnce(): void {
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', ['storage_mtime' => 10]);
-
-		$updater->setPolicy(Watcher::CHECK_ONCE);
-
-		$storage->file_put_contents('foo.txt', 'q');
-		$this->assertTrue($updater->checkUpdate('foo.txt'));
-
-		$cache->put('foo.txt', ['storage_mtime' => 20]);
-		$storage->file_put_contents('foo.txt', 'w');
-		$this->assertFalse($updater->checkUpdate('foo.txt'));
-	}
-
-	public function testPolicyAlways(): void {
-		$storage = $this->getTestStorage();
-		$cache = $storage->getCache();
-		$updater = $storage->getWatcher();
-
-		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', ['storage_mtime' => 10]);
-
-		$updater->setPolicy(Watcher::CHECK_ALWAYS);
-
-		$storage->file_put_contents('foo.txt', 'q');
-		$this->assertTrue($updater->checkUpdate('foo.txt'));
-
-		$cache->put('foo.txt', ['storage_mtime' => 20]);
-		$storage->file_put_contents('foo.txt', 'w');
-		$this->assertTrue($updater->checkUpdate('foo.txt'));
-	}
-
-	/**
-	 * @param bool $scan
-	 * @return Storage
-	 */
-	private function getTestStorage($scan = true) {
-		$storage = new Temporary([]);
-		$textData = "dummy file data\n";
-		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
-		$storage->mkdir('folder');
-		$storage->file_put_contents('foo.txt', $textData);
-		$storage->file_put_contents('foo.png', $imgData);
-		$storage->file_put_contents('folder/bar.txt', $textData);
-		$storage->file_put_contents('folder/bar2.txt', $textData);
-
-		if ($scan) {
-			$scanner = $storage->getScanner();
-			$scanner->scan('');
-		}
-		$this->storages[] = $storage;
-		return $storage;
-	}
-
-	public static function checkFilterProvider(): array {
-		return [
-			[null, [
-				'' => true,
-				'foo' => true,
-				'foo.txt' => true,
-			]],
-			['/^.+$/', [
-				'' => false,
-				'foo' => true,
-				'foo.txt' => true,
-			]],
-			['/^.+\..+$/', [
-				'' => false,
-				'foo' => false,
-				'foo.txt' => true,
-			]]
-		];
-	}
-
-	#[DataProvider('checkFilterProvider')]
-	public function testCheckFilter($filter, $paths) {
-		$storage = $this->createMock(IStorage::class);
-		$storage->method('hasUpdated')
-			->willReturn(true);
-		$watcher = new Watcher($storage);
-		$watcher->setPolicy(IWatcher::CHECK_ALWAYS);
-
-		$watcher->setCheckFilter($filter);
-
-		$entry = new CacheEntry([
-			'storage_mtime' => 0,
-		]);
-
-		foreach ($paths as $patch => $shouldUpdate) {
-			$this->assertEquals($shouldUpdate, $watcher->needsUpdate($patch, $entry));
-		}
-	}
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $this->assertFalse($cache->inCache('folder/bar2.txt'));
+    }
+
+
+    public function testFileToFolder(): void {
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+        $updater->setPolicy(Watcher::CHECK_ONCE);
+
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('', ['storage_mtime' => 10]);
+
+        $storage->unlink('foo.txt');
+        $storage->rename('folder', 'foo.txt');
+        $updater->checkUpdate('');
+
+        $entry = $cache->get('foo.txt');
+        $this->assertEquals('httpd/unix-directory', $entry['mimetype']);
+        $this->assertFalse($cache->inCache('folder'));
+        $this->assertFalse($cache->inCache('folder/bar.txt'));
+
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+        $updater->setPolicy(Watcher::CHECK_ONCE);
+
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('foo.txt', ['storage_mtime' => 10]);
+
+        $storage->unlink('foo.txt');
+        $storage->rename('folder', 'foo.txt');
+        $updater->checkUpdate('foo.txt');
+
+        $entry = $cache->get('foo.txt');
+        $this->assertEquals('httpd/unix-directory', $entry['mimetype']);
+        $this->assertTrue($cache->inCache('foo.txt/bar.txt'));
+    }
+
+    public function testPolicyNever(): void {
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('foo.txt', ['storage_mtime' => 10]);
+
+        $updater->setPolicy(Watcher::CHECK_NEVER);
+
+        $storage->file_put_contents('foo.txt', 'q');
+        $this->assertFalse($updater->checkUpdate('foo.txt'));
+
+        $cache->put('foo.txt', ['storage_mtime' => 20]);
+        $storage->file_put_contents('foo.txt', 'w');
+        $this->assertFalse($updater->checkUpdate('foo.txt'));
+    }
+
+    public function testPolicyOnce(): void {
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('foo.txt', ['storage_mtime' => 10]);
+
+        $updater->setPolicy(Watcher::CHECK_ONCE);
+
+        $storage->file_put_contents('foo.txt', 'q');
+        $this->assertTrue($updater->checkUpdate('foo.txt'));
+
+        $cache->put('foo.txt', ['storage_mtime' => 20]);
+        $storage->file_put_contents('foo.txt', 'w');
+        $this->assertFalse($updater->checkUpdate('foo.txt'));
+    }
+
+    public function testPolicyAlways(): void {
+        $storage = $this->getTestStorage();
+        $cache = $storage->getCache();
+        $updater = $storage->getWatcher();
+
+        //set the mtime to the past so it can detect an mtime change
+        $cache->put('foo.txt', ['storage_mtime' => 10]);
+
+        $updater->setPolicy(Watcher::CHECK_ALWAYS);
+
+        $storage->file_put_contents('foo.txt', 'q');
+        $this->assertTrue($updater->checkUpdate('foo.txt'));
+
+        $cache->put('foo.txt', ['storage_mtime' => 20]);
+        $storage->file_put_contents('foo.txt', 'w');
+        $this->assertTrue($updater->checkUpdate('foo.txt'));
+    }
+
+    /**
+     * @param bool $scan
+     * @return Storage
+     */
+    private function getTestStorage($scan = true) {
+        $storage = new Temporary([]);
+        $textData = "dummy file data\n";
+        $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+        $storage->mkdir('folder');
+        $storage->file_put_contents('foo.txt', $textData);
+        $storage->file_put_contents('foo.png', $imgData);
+        $storage->file_put_contents('folder/bar.txt', $textData);
+        $storage->file_put_contents('folder/bar2.txt', $textData);
+
+        if ($scan) {
+            $scanner = $storage->getScanner();
+            $scanner->scan('');
+        }
+        $this->storages[] = $storage;
+        return $storage;
+    }
+
+    public static function checkFilterProvider(): array {
+        return [
+            [null, [
+                '' => true,
+                'foo' => true,
+                'foo.txt' => true,
+            ]],
+            ['/^.+$/', [
+                '' => false,
+                'foo' => true,
+                'foo.txt' => true,
+            ]],
+            ['/^.+\..+$/', [
+                '' => false,
+                'foo' => false,
+                'foo.txt' => true,
+            ]]
+        ];
+    }
+
+    #[DataProvider('checkFilterProvider')]
+    public function testCheckFilter($filter, $paths) {
+        $storage = $this->createMock(IStorage::class);
+        $storage->method('hasUpdated')
+            ->willReturn(true);
+        $watcher = new Watcher($storage);
+        $watcher->setPolicy(IWatcher::CHECK_ALWAYS);
+
+        $watcher->setCheckFilter($filter);
+
+        $entry = new CacheEntry([
+            'storage_mtime' => 0,
+        ]);
+
+        foreach ($paths as $patch => $shouldUpdate) {
+            $this->assertEquals($shouldUpdate, $watcher->needsUpdate($patch, $entry));
+        }
+    }
 }