nextcloud / server

lib/private/Files/Node/Root.php

Indentation +480 added lines, -480 removed lines

@@ -51,484 +51,484 @@
  * @package OC\Files\Node
  */
 class Root extends Folder implements IRootFolder {
-	private Manager $mountManager;
-	private PublicEmitter $emitter;
-	private ?IUser $user;
-	private CappedMemoryCache $userFolderCache;
-	private IUserMountCache $userMountCache;
-	private LoggerInterface $logger;
-	private IUserManager $userManager;
-	private IEventDispatcher $eventDispatcher;
-	private ICache $pathByIdCache;
-
-	/**
-	 * @param Manager $manager
-	 * @param View $view
-	 * @param IUser|null $user
-	 */
-	public function __construct(
-		$manager,
-		$view,
-		$user,
-		IUserMountCache $userMountCache,
-		LoggerInterface $logger,
-		IUserManager $userManager,
-		IEventDispatcher $eventDispatcher,
-		ICacheFactory $cacheFactory,
-	) {
-		parent::__construct($this, $view, '');
-		$this->mountManager = $manager;
-		$this->user = $user;
-		$this->emitter = new PublicEmitter();
-		$this->userFolderCache = new CappedMemoryCache();
-		$this->userMountCache = $userMountCache;
-		$this->logger = $logger;
-		$this->userManager = $userManager;
-		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
-			$this->userFolderCache = new CappedMemoryCache();
-		});
-		$this->pathByIdCache = $cacheFactory->createLocal('path-by-id');
-	}
-
-	/**
-	 * Get the user for which the filesystem is setup
-	 *
-	 * @return \OC\User\User
-	 */
-	public function getUser() {
-		return $this->user;
-	}
-
-	/**
-	 * @param string $scope
-	 * @param string $method
-	 * @param callable $callback
-	 */
-	public function listen($scope, $method, callable $callback) {
-		$this->emitter->listen($scope, $method, $callback);
-	}
-
-	/**
-	 * @param string $scope optional
-	 * @param string $method optional
-	 * @param callable $callback optional
-	 */
-	public function removeListener($scope = null, $method = null, ?callable $callback = null) {
-		$this->emitter->removeListener($scope, $method, $callback);
-	}
-
-	/**
-	 * @param string $scope
-	 * @param string $method
-	 * @param Node[] $arguments
-	 */
-	public function emit($scope, $method, $arguments = []) {
-		$this->emitter->emit($scope, $method, $arguments);
-	}
-
-	/**
-	 * @param \OC\Files\Storage\Storage $storage
-	 * @param string $mountPoint
-	 * @param array $arguments
-	 */
-	public function mount($storage, $mountPoint, $arguments = []) {
-		$mount = new MountPoint($storage, $mountPoint, $arguments);
-		$this->mountManager->addMount($mount);
-	}
-
-	public function getMount(string $mountPoint): IMountPoint {
-		return $this->mountManager->find($mountPoint);
-	}
-
-	/**
-	 * @param string $mountPoint
-	 * @return \OC\Files\Mount\MountPoint[]
-	 */
-	public function getMountsIn(string $mountPoint): array {
-		return $this->mountManager->findIn($mountPoint);
-	}
-
-	/**
-	 * @param string $storageId
-	 * @return \OC\Files\Mount\MountPoint[]
-	 */
-	public function getMountByStorageId($storageId) {
-		return $this->mountManager->findByStorageId($storageId);
-	}
-
-	/**
-	 * @param int $numericId
-	 * @return MountPoint[]
-	 */
-	public function getMountByNumericStorageId($numericId) {
-		return $this->mountManager->findByNumericId($numericId);
-	}
-
-	/**
-	 * @param \OC\Files\Mount\MountPoint $mount
-	 */
-	public function unMount($mount) {
-		$this->mountManager->remove($mount);
-	}
-
-	public function get($path) {
-		$path = $this->normalizePath($path);
-		if ($this->isValidPath($path)) {
-			$fullPath = $this->getFullPath($path);
-			$fileInfo = $this->view->getFileInfo($fullPath, false);
-			if ($fileInfo) {
-				return $this->createNode($fullPath, $fileInfo, false);
-			} else {
-				throw new NotFoundException($path);
-			}
-		} else {
-			throw new NotPermittedException();
-		}
-	}
-
-	//most operations can't be done on the root
-
-	/**
-	 * @param string $targetPath
-	 * @return Node
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function rename($targetPath) {
-		throw new NotPermittedException();
-	}
-
-	public function delete() {
-		throw new NotPermittedException();
-	}
-
-	/**
-	 * @param string $targetPath
-	 * @return Node
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function copy($targetPath) {
-		throw new NotPermittedException();
-	}
-
-	/**
-	 * @param int $mtime
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function touch($mtime = null) {
-		throw new NotPermittedException();
-	}
-
-	/**
-	 * @return \OC\Files\Storage\Storage
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function getStorage() {
-		throw new NotFoundException();
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getPath() {
-		return '/';
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getInternalPath() {
-		return '';
-	}
-
-	/**
-	 * @return int
-	 */
-	public function getId() {
-		return 0;
-	}
-
-	/**
-	 * @return array
-	 */
-	public function stat() {
-		return [];
-	}
-
-	/**
-	 * @return int
-	 */
-	public function getMTime() {
-		return 0;
-	}
-
-	/**
-	 * @param bool $includeMounts
-	 * @return int|float
-	 */
-	public function getSize($includeMounts = true): int|float {
-		return 0;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getEtag() {
-		return '';
-	}
-
-	/**
-	 * @return int
-	 */
-	public function getPermissions() {
-		return \OCP\Constants::PERMISSION_CREATE;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isReadable() {
-		return false;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isUpdateable() {
-		return false;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isDeletable() {
-		return false;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isShareable() {
-		return false;
-	}
-
-	/**
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function getParent(): INode|IRootFolder {
-		throw new NotFoundException();
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getName() {
-		return '';
-	}
-
-	/**
-	 * Returns a view to user's files folder
-	 *
-	 * @param string $userId user ID
-	 * @return \OCP\Files\Folder
-	 * @throws NoUserException
-	 * @throws NotPermittedException
-	 */
-	public function getUserFolder($userId) {
-		$userObject = $this->userManager->get($userId);
-
-		if (is_null($userObject)) {
-			$e = new NoUserException('Backends provided no user object');
-			$this->logger->error(
-				sprintf(
-					'Backends provided no user object for %s',
-					$userId
-				),
-				[
-					'app' => 'files',
-					'exception' => $e,
-				]
-			);
-			throw $e;
-		}
-
-		$userId = $userObject->getUID();
-
-		if (!$this->userFolderCache->hasKey($userId)) {
-			if ($this->mountManager->getSetupManager()->isSetupComplete($userObject)) {
-				try {
-					$folder = $this->get('/' . $userId . '/files');
-					if (!$folder instanceof \OCP\Files\Folder) {
-						throw new \Exception("Account folder for \"$userId\" exists as a file");
-					}
-				} catch (NotFoundException $e) {
-					if (!$this->nodeExists('/' . $userId)) {
-						$this->newFolder('/' . $userId);
-					}
-					$folder = $this->newFolder('/' . $userId . '/files');
-				}
-			} else {
-				$folder = new LazyUserFolder($this, $userObject, $this->mountManager);
-			}
-
-			$this->userFolderCache->set($userId, $folder);
-		}
-
-		return $this->userFolderCache->get($userId);
-	}
-
-	public function getUserMountCache() {
-		return $this->userMountCache;
-	}
-
-	public function getFirstNodeByIdInPath(int $id, string $path): ?INode {
-		// scope the cache by user, so we don't return nodes for different users
-		if ($this->user) {
-			$cachedPath = $this->pathByIdCache->get($this->user->getUID() . '::' . $id);
-			if ($cachedPath && str_starts_with($cachedPath, $path)) {
-				// getting the node by path is significantly cheaper than finding it by id
-				try {
-					$node = $this->get($cachedPath);
-					// by validating that the cached path still has the requested fileid we can work around the need to invalidate the cached path
-					// if the cached path is invalid or a different file now we fall back to the uncached logic
-					if ($node && $node->getId() === $id) {
-						return $node;
-					}
-				} catch (NotFoundException|NotPermittedException) {
-					// The file may be moved but the old path still in cache
-				}
-			}
-		}
-		$node = current($this->getByIdInPath($id, $path));
-		if (!$node) {
-			return null;
-		}
-
-		if ($this->user) {
-			$this->pathByIdCache->set($this->user->getUID() . '::' . $id, $node->getPath());
-		}
-		return $node;
-	}
-
-	/**
-	 * @param int $id
-	 * @return Node[]
-	 */
-	public function getByIdInPath(int $id, string $path): array {
-		$mountCache = $this->getUserMountCache();
-		if ($path !== '' && strpos($path, '/', 1) > 0) {
-			[, $user] = explode('/', $path);
-		} else {
-			$user = null;
-		}
-		$mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
-
-		// if the mount isn't in the cache yet, perform a setup first, then try again
-		if (count($mountsContainingFile) === 0) {
-			$this->mountManager->getSetupManager()->setupForPath($path, true);
-			$mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
-		}
-
-		// when a user has access through the same storage through multiple paths
-		// (such as an external storage that is both mounted for a user and shared to the user)
-		// the mount cache will only hold a single entry for the storage
-		// this can lead to issues as the different ways the user has access to a storage can have different permissions
-		//
-		// so instead of using the cached entries directly, we instead filter the current mounts by the rootid of the cache entry
-
-		$mountRootIds = array_map(function ($mount) {
-			return $mount->getRootId();
-		}, $mountsContainingFile);
-		$mountRootPaths = array_map(function ($mount) {
-			return $mount->getRootInternalPath();
-		}, $mountsContainingFile);
-		$mountProviders = array_unique(array_map(function ($mount) {
-			return $mount->getMountProvider();
-		}, $mountsContainingFile));
-		$mountRoots = array_combine($mountRootIds, $mountRootPaths);
-
-		$mounts = $this->mountManager->getMountsByMountProvider($path, $mountProviders);
-
-		$mountsContainingFile = array_filter($mounts, function ($mount) use ($mountRoots) {
-			return isset($mountRoots[$mount->getStorageRootId()]);
-		});
-
-		if (count($mountsContainingFile) === 0) {
-			if ($user === $this->getAppDataDirectoryName()) {
-				$folder = $this->get($path);
-				if ($folder instanceof Folder) {
-					return $folder->getByIdInRootMount($id);
-				} else {
-					throw new \Exception('getByIdInPath with non folder');
-				}
-			}
-			return [];
-		}
-
-		$nodes = array_map(function (IMountPoint $mount) use ($id, $mountRoots) {
-			$rootInternalPath = $mountRoots[$mount->getStorageRootId()];
-			$cacheEntry = $mount->getStorage()->getCache()->get($id);
-			if (!$cacheEntry) {
-				return null;
-			}
-
-			// cache jails will hide the "true" internal path
-			$internalPath = ltrim($rootInternalPath . '/' . $cacheEntry->getPath(), '/');
-			$pathRelativeToMount = substr($internalPath, strlen($rootInternalPath));
-			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
-			$absolutePath = rtrim($mount->getMountPoint() . $pathRelativeToMount, '/');
-			$storage = $mount->getStorage();
-			if ($storage === null) {
-				return null;
-			}
-			$ownerId = $storage->getOwner($pathRelativeToMount);
-			if ($ownerId !== false) {
-				$owner = Server::get(IUserManager::class)->get($ownerId);
-			} else {
-				$owner = null;
-			}
-			return $this->createNode($absolutePath, new FileInfo(
-				$absolutePath,
-				$storage,
-				$cacheEntry->getPath(),
-				$cacheEntry,
-				$mount,
-				$owner,
-			));
-		}, $mountsContainingFile);
-
-		$nodes = array_filter($nodes);
-
-		$folders = array_filter($nodes, function (Node $node) use ($path) {
-			return PathHelper::getRelativePath($path, $node->getPath()) !== null;
-		});
-		usort($folders, function ($a, $b) {
-			return $b->getPath() <=> $a->getPath();
-		});
-		return $folders;
-	}
-
-	public function getNodeFromCacheEntryAndMount(ICacheEntry $cacheEntry, IMountPoint $mountPoint): INode {
-		$path = $cacheEntry->getPath();
-		$fullPath = $mountPoint->getMountPoint() . $path;
-		// todo: LazyNode?
-		$info = new FileInfo($fullPath, $mountPoint->getStorage(), $path, $cacheEntry, $mountPoint);
-		$parentPath = dirname($fullPath);
-		$parent = new LazyFolder($this, function () use ($parentPath) {
-			$parent = $this->get($parentPath);
-			if ($parent instanceof \OCP\Files\Folder) {
-				return $parent;
-			} else {
-				throw new \Exception("parent $parentPath is not a folder");
-			}
-		}, [
-			'path' => $parentPath,
-		]);
-		$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
-		$view = new View('');
-		if ($isDir) {
-			return new Folder($this, $view, $fullPath, $info, $parent);
-		} else {
-			return new File($this, $view, $fullPath, $info, $parent);
-		}
-	}
+    private Manager $mountManager;
+    private PublicEmitter $emitter;
+    private ?IUser $user;
+    private CappedMemoryCache $userFolderCache;
+    private IUserMountCache $userMountCache;
+    private LoggerInterface $logger;
+    private IUserManager $userManager;
+    private IEventDispatcher $eventDispatcher;
+    private ICache $pathByIdCache;
+
+    /**
+     * @param Manager $manager
+     * @param View $view
+     * @param IUser|null $user
+     */
+    public function __construct(
+        $manager,
+        $view,
+        $user,
+        IUserMountCache $userMountCache,
+        LoggerInterface $logger,
+        IUserManager $userManager,
+        IEventDispatcher $eventDispatcher,
+        ICacheFactory $cacheFactory,
+    ) {
+        parent::__construct($this, $view, '');
+        $this->mountManager = $manager;
+        $this->user = $user;
+        $this->emitter = new PublicEmitter();
+        $this->userFolderCache = new CappedMemoryCache();
+        $this->userMountCache = $userMountCache;
+        $this->logger = $logger;
+        $this->userManager = $userManager;
+        $eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+            $this->userFolderCache = new CappedMemoryCache();
+        });
+        $this->pathByIdCache = $cacheFactory->createLocal('path-by-id');
+    }
+
+    /**
+     * Get the user for which the filesystem is setup
+     *
+     * @return \OC\User\User
+     */
+    public function getUser() {
+        return $this->user;
+    }
+
+    /**
+     * @param string $scope
+     * @param string $method
+     * @param callable $callback
+     */
+    public function listen($scope, $method, callable $callback) {
+        $this->emitter->listen($scope, $method, $callback);
+    }
+
+    /**
+     * @param string $scope optional
+     * @param string $method optional
+     * @param callable $callback optional
+     */
+    public function removeListener($scope = null, $method = null, ?callable $callback = null) {
+        $this->emitter->removeListener($scope, $method, $callback);
+    }
+
+    /**
+     * @param string $scope
+     * @param string $method
+     * @param Node[] $arguments
+     */
+    public function emit($scope, $method, $arguments = []) {
+        $this->emitter->emit($scope, $method, $arguments);
+    }
+
+    /**
+     * @param \OC\Files\Storage\Storage $storage
+     * @param string $mountPoint
+     * @param array $arguments
+     */
+    public function mount($storage, $mountPoint, $arguments = []) {
+        $mount = new MountPoint($storage, $mountPoint, $arguments);
+        $this->mountManager->addMount($mount);
+    }
+
+    public function getMount(string $mountPoint): IMountPoint {
+        return $this->mountManager->find($mountPoint);
+    }
+
+    /**
+     * @param string $mountPoint
+     * @return \OC\Files\Mount\MountPoint[]
+     */
+    public function getMountsIn(string $mountPoint): array {
+        return $this->mountManager->findIn($mountPoint);
+    }
+
+    /**
+     * @param string $storageId
+     * @return \OC\Files\Mount\MountPoint[]
+     */
+    public function getMountByStorageId($storageId) {
+        return $this->mountManager->findByStorageId($storageId);
+    }
+
+    /**
+     * @param int $numericId
+     * @return MountPoint[]
+     */
+    public function getMountByNumericStorageId($numericId) {
+        return $this->mountManager->findByNumericId($numericId);
+    }
+
+    /**
+     * @param \OC\Files\Mount\MountPoint $mount
+     */
+    public function unMount($mount) {
+        $this->mountManager->remove($mount);
+    }
+
+    public function get($path) {
+        $path = $this->normalizePath($path);
+        if ($this->isValidPath($path)) {
+            $fullPath = $this->getFullPath($path);
+            $fileInfo = $this->view->getFileInfo($fullPath, false);
+            if ($fileInfo) {
+                return $this->createNode($fullPath, $fileInfo, false);
+            } else {
+                throw new NotFoundException($path);
+            }
+        } else {
+            throw new NotPermittedException();
+        }
+    }
+
+    //most operations can't be done on the root
+
+    /**
+     * @param string $targetPath
+     * @return Node
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function rename($targetPath) {
+        throw new NotPermittedException();
+    }
+
+    public function delete() {
+        throw new NotPermittedException();
+    }
+
+    /**
+     * @param string $targetPath
+     * @return Node
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function copy($targetPath) {
+        throw new NotPermittedException();
+    }
+
+    /**
+     * @param int $mtime
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function touch($mtime = null) {
+        throw new NotPermittedException();
+    }
+
+    /**
+     * @return \OC\Files\Storage\Storage
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function getStorage() {
+        throw new NotFoundException();
+    }
+
+    /**
+     * @return string
+     */
+    public function getPath() {
+        return '/';
+    }
+
+    /**
+     * @return string
+     */
+    public function getInternalPath() {
+        return '';
+    }
+
+    /**
+     * @return int
+     */
+    public function getId() {
+        return 0;
+    }
+
+    /**
+     * @return array
+     */
+    public function stat() {
+        return [];
+    }
+
+    /**
+     * @return int
+     */
+    public function getMTime() {
+        return 0;
+    }
+
+    /**
+     * @param bool $includeMounts
+     * @return int|float
+     */
+    public function getSize($includeMounts = true): int|float {
+        return 0;
+    }
+
+    /**
+     * @return string
+     */
+    public function getEtag() {
+        return '';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPermissions() {
+        return \OCP\Constants::PERMISSION_CREATE;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isReadable() {
+        return false;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isUpdateable() {
+        return false;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isDeletable() {
+        return false;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isShareable() {
+        return false;
+    }
+
+    /**
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function getParent(): INode|IRootFolder {
+        throw new NotFoundException();
+    }
+
+    /**
+     * @return string
+     */
+    public function getName() {
+        return '';
+    }
+
+    /**
+     * Returns a view to user's files folder
+     *
+     * @param string $userId user ID
+     * @return \OCP\Files\Folder
+     * @throws NoUserException
+     * @throws NotPermittedException
+     */
+    public function getUserFolder($userId) {
+        $userObject = $this->userManager->get($userId);
+
+        if (is_null($userObject)) {
+            $e = new NoUserException('Backends provided no user object');
+            $this->logger->error(
+                sprintf(
+                    'Backends provided no user object for %s',
+                    $userId
+                ),
+                [
+                    'app' => 'files',
+                    'exception' => $e,
+                ]
+            );
+            throw $e;
+        }
+
+        $userId = $userObject->getUID();
+
+        if (!$this->userFolderCache->hasKey($userId)) {
+            if ($this->mountManager->getSetupManager()->isSetupComplete($userObject)) {
+                try {
+                    $folder = $this->get('/' . $userId . '/files');
+                    if (!$folder instanceof \OCP\Files\Folder) {
+                        throw new \Exception("Account folder for \"$userId\" exists as a file");
+                    }
+                } catch (NotFoundException $e) {
+                    if (!$this->nodeExists('/' . $userId)) {
+                        $this->newFolder('/' . $userId);
+                    }
+                    $folder = $this->newFolder('/' . $userId . '/files');
+                }
+            } else {
+                $folder = new LazyUserFolder($this, $userObject, $this->mountManager);
+            }
+
+            $this->userFolderCache->set($userId, $folder);
+        }
+
+        return $this->userFolderCache->get($userId);
+    }
+
+    public function getUserMountCache() {
+        return $this->userMountCache;
+    }
+
+    public function getFirstNodeByIdInPath(int $id, string $path): ?INode {
+        // scope the cache by user, so we don't return nodes for different users
+        if ($this->user) {
+            $cachedPath = $this->pathByIdCache->get($this->user->getUID() . '::' . $id);
+            if ($cachedPath && str_starts_with($cachedPath, $path)) {
+                // getting the node by path is significantly cheaper than finding it by id
+                try {
+                    $node = $this->get($cachedPath);
+                    // by validating that the cached path still has the requested fileid we can work around the need to invalidate the cached path
+                    // if the cached path is invalid or a different file now we fall back to the uncached logic
+                    if ($node && $node->getId() === $id) {
+                        return $node;
+                    }
+                } catch (NotFoundException|NotPermittedException) {
+                    // The file may be moved but the old path still in cache
+                }
+            }
+        }
+        $node = current($this->getByIdInPath($id, $path));
+        if (!$node) {
+            return null;
+        }
+
+        if ($this->user) {
+            $this->pathByIdCache->set($this->user->getUID() . '::' . $id, $node->getPath());
+        }
+        return $node;
+    }
+
+    /**
+     * @param int $id
+     * @return Node[]
+     */
+    public function getByIdInPath(int $id, string $path): array {
+        $mountCache = $this->getUserMountCache();
+        if ($path !== '' && strpos($path, '/', 1) > 0) {
+            [, $user] = explode('/', $path);
+        } else {
+            $user = null;
+        }
+        $mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
+
+        // if the mount isn't in the cache yet, perform a setup first, then try again
+        if (count($mountsContainingFile) === 0) {
+            $this->mountManager->getSetupManager()->setupForPath($path, true);
+            $mountsContainingFile = $mountCache->getMountsForFileId($id, $user);
+        }
+
+        // when a user has access through the same storage through multiple paths
+        // (such as an external storage that is both mounted for a user and shared to the user)
+        // the mount cache will only hold a single entry for the storage
+        // this can lead to issues as the different ways the user has access to a storage can have different permissions
+        //
+        // so instead of using the cached entries directly, we instead filter the current mounts by the rootid of the cache entry
+
+        $mountRootIds = array_map(function ($mount) {
+            return $mount->getRootId();
+        }, $mountsContainingFile);
+        $mountRootPaths = array_map(function ($mount) {
+            return $mount->getRootInternalPath();
+        }, $mountsContainingFile);
+        $mountProviders = array_unique(array_map(function ($mount) {
+            return $mount->getMountProvider();
+        }, $mountsContainingFile));
+        $mountRoots = array_combine($mountRootIds, $mountRootPaths);
+
+        $mounts = $this->mountManager->getMountsByMountProvider($path, $mountProviders);
+
+        $mountsContainingFile = array_filter($mounts, function ($mount) use ($mountRoots) {
+            return isset($mountRoots[$mount->getStorageRootId()]);
+        });
+
+        if (count($mountsContainingFile) === 0) {
+            if ($user === $this->getAppDataDirectoryName()) {
+                $folder = $this->get($path);
+                if ($folder instanceof Folder) {
+                    return $folder->getByIdInRootMount($id);
+                } else {
+                    throw new \Exception('getByIdInPath with non folder');
+                }
+            }
+            return [];
+        }
+
+        $nodes = array_map(function (IMountPoint $mount) use ($id, $mountRoots) {
+            $rootInternalPath = $mountRoots[$mount->getStorageRootId()];
+            $cacheEntry = $mount->getStorage()->getCache()->get($id);
+            if (!$cacheEntry) {
+                return null;
+            }
+
+            // cache jails will hide the "true" internal path
+            $internalPath = ltrim($rootInternalPath . '/' . $cacheEntry->getPath(), '/');
+            $pathRelativeToMount = substr($internalPath, strlen($rootInternalPath));
+            $pathRelativeToMount = ltrim($pathRelativeToMount, '/');
+            $absolutePath = rtrim($mount->getMountPoint() . $pathRelativeToMount, '/');
+            $storage = $mount->getStorage();
+            if ($storage === null) {
+                return null;
+            }
+            $ownerId = $storage->getOwner($pathRelativeToMount);
+            if ($ownerId !== false) {
+                $owner = Server::get(IUserManager::class)->get($ownerId);
+            } else {
+                $owner = null;
+            }
+            return $this->createNode($absolutePath, new FileInfo(
+                $absolutePath,
+                $storage,
+                $cacheEntry->getPath(),
+                $cacheEntry,
+                $mount,
+                $owner,
+            ));
+        }, $mountsContainingFile);
+
+        $nodes = array_filter($nodes);
+
+        $folders = array_filter($nodes, function (Node $node) use ($path) {
+            return PathHelper::getRelativePath($path, $node->getPath()) !== null;
+        });
+        usort($folders, function ($a, $b) {
+            return $b->getPath() <=> $a->getPath();
+        });
+        return $folders;
+    }
+
+    public function getNodeFromCacheEntryAndMount(ICacheEntry $cacheEntry, IMountPoint $mountPoint): INode {
+        $path = $cacheEntry->getPath();
+        $fullPath = $mountPoint->getMountPoint() . $path;
+        // todo: LazyNode?
+        $info = new FileInfo($fullPath, $mountPoint->getStorage(), $path, $cacheEntry, $mountPoint);
+        $parentPath = dirname($fullPath);
+        $parent = new LazyFolder($this, function () use ($parentPath) {
+            $parent = $this->get($parentPath);
+            if ($parent instanceof \OCP\Files\Folder) {
+                return $parent;
+            } else {
+                throw new \Exception("parent $parentPath is not a folder");
+            }
+        }, [
+            'path' => $parentPath,
+        ]);
+        $isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+        $view = new View('');
+        if ($isDir) {
+            return new Folder($this, $view, $fullPath, $info, $parent);
+        } else {
+            return new File($this, $view, $fullPath, $info, $parent);
+        }
+    }
 }

lib/private/Files/View.php

Indentation +2226 added lines, -2226 removed lines

@@ -57,2230 +57,2230 @@
  * \OC\Files\Storage\Storage object
  */
 class View {
-	private string $fakeRoot = '';
-	private ILockingProvider $lockingProvider;
-	private bool $lockingEnabled;
-	private bool $updaterEnabled = true;
-	private UserManager $userManager;
-	private LoggerInterface $logger;
-
-	/**
-	 * @throws \Exception If $root contains an invalid path
-	 */
-	public function __construct(string $root = '') {
-		if (!Filesystem::isValidPath($root)) {
-			throw new \Exception();
-		}
-
-		$this->fakeRoot = $root;
-		$this->lockingProvider = \OC::$server->get(ILockingProvider::class);
-		$this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
-		$this->userManager = \OC::$server->getUserManager();
-		$this->logger = \OC::$server->get(LoggerInterface::class);
-	}
-
-	/**
-	 * @param ?string $path
-	 * @psalm-template S as string|null
-	 * @psalm-param S $path
-	 * @psalm-return (S is string ? string : null)
-	 */
-	public function getAbsolutePath($path = '/'): ?string {
-		if ($path === null) {
-			return null;
-		}
-		$this->assertPathLength($path);
-		if ($path === '') {
-			$path = '/';
-		}
-		if ($path[0] !== '/') {
-			$path = '/' . $path;
-		}
-		return $this->fakeRoot . $path;
-	}
-
-	/**
-	 * Change the root to a fake root
-	 *
-	 * @param string $fakeRoot
-	 */
-	public function chroot($fakeRoot): void {
-		if (!$fakeRoot == '') {
-			if ($fakeRoot[0] !== '/') {
-				$fakeRoot = '/' . $fakeRoot;
-			}
-		}
-		$this->fakeRoot = $fakeRoot;
-	}
-
-	/**
-	 * Get the fake root
-	 */
-	public function getRoot(): string {
-		return $this->fakeRoot;
-	}
-
-	/**
-	 * get path relative to the root of the view
-	 *
-	 * @param string $path
-	 */
-	public function getRelativePath($path): ?string {
-		$this->assertPathLength($path);
-		if ($this->fakeRoot == '') {
-			return $path;
-		}
-
-		if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
-			return '/';
-		}
-
-		// missing slashes can cause wrong matches!
-		$root = rtrim($this->fakeRoot, '/') . '/';
-
-		if (!str_starts_with($path, $root)) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->fakeRoot));
-			if (strlen($path) === 0) {
-				return '/';
-			} else {
-				return $path;
-			}
-		}
-	}
-
-	/**
-	 * Get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and does not take the chroot into account )
-	 *
-	 * @param string $path
-	 */
-	public function getMountPoint($path): string {
-		return Filesystem::getMountPoint($this->getAbsolutePath($path));
-	}
-
-	/**
-	 * Get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and does not take the chroot into account )
-	 *
-	 * @param string $path
-	 */
-	public function getMount($path): IMountPoint {
-		return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
-	}
-
-	/**
-	 * Resolve a path to a storage and internal path
-	 *
-	 * @param string $path
-	 * @return array{?\OCP\Files\Storage\IStorage, string} an array consisting of the storage and the internal path
-	 */
-	public function resolvePath($path): array {
-		$a = $this->getAbsolutePath($path);
-		$p = Filesystem::normalizePath($a);
-		return Filesystem::resolvePath($p);
-	}
-
-	/**
-	 * Return the path to a local version of the file
-	 * we need this because we can't know if a file is stored local or not from
-	 * outside the filestorage and for some purposes a local file is needed
-	 *
-	 * @param string $path
-	 */
-	public function getLocalFile($path): string|false {
-		$parent = substr($path, 0, strrpos($path, '/') ?: 0);
-		$path = $this->getAbsolutePath($path);
-		[$storage, $internalPath] = Filesystem::resolvePath($path);
-		if (Filesystem::isValidPath($parent) && $storage) {
-			return $storage->getLocalFile($internalPath);
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * the following functions operate with arguments and return values identical
-	 * to those of their PHP built-in equivalents. Mostly they are merely wrappers
-	 * for \OC\Files\Storage\Storage via basicOperation().
-	 */
-	public function mkdir($path) {
-		return $this->basicOperation('mkdir', $path, ['create', 'write']);
-	}
-
-	/**
-	 * remove mount point
-	 *
-	 * @param IMountPoint $mount
-	 * @param string $path relative to data/
-	 */
-	protected function removeMount($mount, $path): bool {
-		if ($mount instanceof MoveableMount) {
-			// cut of /user/files to get the relative path to data/user/files
-			$pathParts = explode('/', $path, 4);
-			$relPath = '/' . $pathParts[3];
-			$this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
-			\OC_Hook::emit(
-				Filesystem::CLASSNAME, 'umount',
-				[Filesystem::signal_param_path => $relPath]
-			);
-			$this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
-			$result = $mount->removeMount();
-			$this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
-			if ($result) {
-				\OC_Hook::emit(
-					Filesystem::CLASSNAME, 'post_umount',
-					[Filesystem::signal_param_path => $relPath]
-				);
-			}
-			$this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
-			return $result;
-		} else {
-			// do not allow deleting the storage's root / the mount point
-			// because for some storages it might delete the whole contents
-			// but isn't supposed to work that way
-			return false;
-		}
-	}
-
-	public function disableCacheUpdate(): void {
-		$this->updaterEnabled = false;
-	}
-
-	public function enableCacheUpdate(): void {
-		$this->updaterEnabled = true;
-	}
-
-	protected function writeUpdate(Storage $storage, string $internalPath, ?int $time = null, ?int $sizeDifference = null): void {
-		if ($this->updaterEnabled) {
-			if (is_null($time)) {
-				$time = time();
-			}
-			$storage->getUpdater()->update($internalPath, $time, $sizeDifference);
-		}
-	}
-
-	protected function removeUpdate(Storage $storage, string $internalPath): void {
-		if ($this->updaterEnabled) {
-			$storage->getUpdater()->remove($internalPath);
-		}
-	}
-
-	protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, string $sourceInternalPath, string $targetInternalPath): void {
-		if ($this->updaterEnabled) {
-			$targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		}
-	}
-
-	protected function copyUpdate(Storage $sourceStorage, Storage $targetStorage, string $sourceInternalPath, string $targetInternalPath): void {
-		if ($this->updaterEnabled) {
-			$targetStorage->getUpdater()->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function rmdir($path) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-		if ($mount->getInternalPath($absolutePath) === '') {
-			return $this->removeMount($mount, $absolutePath);
-		}
-		if ($this->is_dir($path)) {
-			$result = $this->basicOperation('rmdir', $path, ['delete']);
-		} else {
-			$result = false;
-		}
-
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
-			$storage = $mount->getStorage();
-			$internalPath = $mount->getInternalPath($absolutePath);
-			$storage->getUpdater()->remove($internalPath);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @return resource|false
-	 */
-	public function opendir($path) {
-		return $this->basicOperation('opendir', $path, ['read']);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function is_dir($path) {
-		if ($path == '/') {
-			return true;
-		}
-		return $this->basicOperation('is_dir', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function is_file($path) {
-		if ($path == '/') {
-			return false;
-		}
-		return $this->basicOperation('is_file', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function stat($path) {
-		return $this->basicOperation('stat', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filetype($path) {
-		return $this->basicOperation('filetype', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filesize(string $path) {
-		return $this->basicOperation('filesize', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 * @throws InvalidPathException
-	 */
-	public function readfile($path) {
-		$this->assertPathLength($path);
-		if (ob_get_level()) {
-			ob_end_clean();
-		}
-		$handle = $this->fopen($path, 'rb');
-		if ($handle) {
-			$chunkSize = 524288; // 512 kiB chunks
-			while (!feof($handle)) {
-				echo fread($handle, $chunkSize);
-				flush();
-				$this->checkConnectionStatus();
-			}
-			fclose($handle);
-			return $this->filesize($path);
-		}
-		return false;
-	}
-
-	/**
-	 * @param string $path
-	 * @param int $from
-	 * @param int $to
-	 * @return bool|mixed
-	 * @throws InvalidPathException
-	 * @throws \OCP\Files\UnseekableException
-	 */
-	public function readfilePart($path, $from, $to) {
-		$this->assertPathLength($path);
-		if (ob_get_level()) {
-			ob_end_clean();
-		}
-		$handle = $this->fopen($path, 'rb');
-		if ($handle) {
-			$chunkSize = 524288; // 512 kiB chunks
-			$startReading = true;
-
-			if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
-				// forward file handle via chunked fread because fseek seem to have failed
-
-				$end = $from + 1;
-				while (!feof($handle) && ftell($handle) < $end && ftell($handle) !== $from) {
-					$len = $from - ftell($handle);
-					if ($len > $chunkSize) {
-						$len = $chunkSize;
-					}
-					$result = fread($handle, $len);
-
-					if ($result === false) {
-						$startReading = false;
-						break;
-					}
-				}
-			}
-
-			if ($startReading) {
-				$end = $to + 1;
-				while (!feof($handle) && ftell($handle) < $end) {
-					$len = $end - ftell($handle);
-					if ($len > $chunkSize) {
-						$len = $chunkSize;
-					}
-					echo fread($handle, $len);
-					flush();
-					$this->checkConnectionStatus();
-				}
-				return ftell($handle) - $from;
-			}
-
-			throw new \OCP\Files\UnseekableException('fseek error');
-		}
-		return false;
-	}
-
-	private function checkConnectionStatus(): void {
-		$connectionStatus = \connection_status();
-		if ($connectionStatus !== CONNECTION_NORMAL) {
-			throw new ConnectionLostException("Connection lost. Status: $connectionStatus");
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isCreatable($path) {
-		return $this->basicOperation('isCreatable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isReadable($path) {
-		return $this->basicOperation('isReadable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isUpdatable($path) {
-		return $this->basicOperation('isUpdatable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function isDeletable($path) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-		if ($mount->getInternalPath($absolutePath) === '') {
-			return $mount instanceof MoveableMount;
-		}
-		return $this->basicOperation('isDeletable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function isSharable($path) {
-		return $this->basicOperation('isSharable', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function file_exists($path) {
-		if ($path == '/') {
-			return true;
-		}
-		return $this->basicOperation('file_exists', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 */
-	public function filemtime($path) {
-		return $this->basicOperation('filemtime', $path);
-	}
-
-	/**
-	 * @param string $path
-	 * @param int|string $mtime
-	 */
-	public function touch($path, $mtime = null): bool {
-		if (!is_null($mtime) && !is_numeric($mtime)) {
-			$mtime = strtotime($mtime);
-		}
-
-		$hooks = ['touch'];
-
-		if (!$this->file_exists($path)) {
-			$hooks[] = 'create';
-			$hooks[] = 'write';
-		}
-		try {
-			$result = $this->basicOperation('touch', $path, $hooks, $mtime);
-		} catch (\Exception $e) {
-			$this->logger->info('Error while setting modified time', ['app' => 'core', 'exception' => $e]);
-			$result = false;
-		}
-		if (!$result) {
-			// If create file fails because of permissions on external storage like SMB folders,
-			// check file exists and return false if not.
-			if (!$this->file_exists($path)) {
-				return false;
-			}
-			if (is_null($mtime)) {
-				$mtime = time();
-			}
-			//if native touch fails, we emulate it by changing the mtime in the cache
-			$this->putFileInfo($path, ['mtime' => floor($mtime)]);
-		}
-		return true;
-	}
-
-	/**
-	 * @param string $path
-	 * @return string|false
-	 * @throws LockedException
-	 */
-	public function file_get_contents($path) {
-		return $this->basicOperation('file_get_contents', $path, ['read']);
-	}
-
-	protected function emit_file_hooks_pre(bool $exists, string $path, bool &$run): void {
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
-				Filesystem::signal_param_path => $this->getHookPath($path),
-				Filesystem::signal_param_run => &$run,
-			]);
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
-				Filesystem::signal_param_path => $this->getHookPath($path),
-				Filesystem::signal_param_run => &$run,
-			]);
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
-			Filesystem::signal_param_path => $this->getHookPath($path),
-			Filesystem::signal_param_run => &$run,
-		]);
-	}
-
-	protected function emit_file_hooks_post(bool $exists, string $path): void {
-		if (!$exists) {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
-				Filesystem::signal_param_path => $this->getHookPath($path),
-			]);
-		} else {
-			\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
-				Filesystem::signal_param_path => $this->getHookPath($path),
-			]);
-		}
-		\OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
-			Filesystem::signal_param_path => $this->getHookPath($path),
-		]);
-	}
-
-	/**
-	 * @param string $path
-	 * @param string|resource $data
-	 * @return bool|mixed
-	 * @throws LockedException
-	 */
-	public function file_put_contents($path, $data) {
-		if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
-			$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-			if (Filesystem::isValidPath($path)
-				&& !Filesystem::isFileBlacklisted($path)
-			) {
-				$path = $this->getRelativePath($absolutePath);
-				if ($path === null) {
-					throw new InvalidPathException("Path $absolutePath is not in the expected root");
-				}
-
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
-
-				$exists = $this->file_exists($path);
-				if ($this->shouldEmitHooks($path)) {
-					$run = true;
-					$this->emit_file_hooks_pre($exists, $path, $run);
-					if (!$run) {
-						$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-						return false;
-					}
-				}
-
-				try {
-					$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
-				} catch (\Exception $e) {
-					// Release the shared lock before throwing.
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					throw $e;
-				}
-
-				/** @var Storage $storage */
-				[$storage, $internalPath] = $this->resolvePath($path);
-				$target = $storage->fopen($internalPath, 'w');
-				if ($target) {
-					[, $result] = Files::streamCopy($data, $target, true);
-					fclose($target);
-					fclose($data);
-
-					$this->writeUpdate($storage, $internalPath);
-
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
-
-					if ($this->shouldEmitHooks($path) && $result !== false) {
-						$this->emit_file_hooks_post($exists, $path);
-					}
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					return $result;
-				} else {
-					$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-					return false;
-				}
-			} else {
-				return false;
-			}
-		} else {
-			$hooks = $this->file_exists($path) ? ['update', 'write'] : ['create', 'write'];
-			return $this->basicOperation('file_put_contents', $path, $hooks, $data);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool|mixed
-	 */
-	public function unlink($path) {
-		if ($path === '' || $path === '/') {
-			// do not allow deleting the root
-			return false;
-		}
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		$mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
-		if ($mount->getInternalPath($absolutePath) === '') {
-			return $this->removeMount($mount, $absolutePath);
-		}
-		if ($this->is_dir($path)) {
-			$result = $this->basicOperation('rmdir', $path, ['delete']);
-		} else {
-			$result = $this->basicOperation('unlink', $path, ['delete']);
-		}
-		if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
-			$storage = $mount->getStorage();
-			$internalPath = $mount->getInternalPath($absolutePath);
-			$storage->getUpdater()->remove($internalPath);
-			return true;
-		} else {
-			return $result;
-		}
-	}
-
-	/**
-	 * @param string $directory
-	 * @return bool|mixed
-	 */
-	public function deleteAll($directory) {
-		return $this->rmdir($directory);
-	}
-
-	/**
-	 * Rename/move a file or folder from the source path to target path.
-	 *
-	 * @param string $source source path
-	 * @param string $target target path
-	 * @param array $options
-	 *
-	 * @return bool|mixed
-	 * @throws LockedException
-	 */
-	public function rename($source, $target, array $options = []) {
-		$checkSubMounts = $options['checkSubMounts'] ?? true;
-
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
-
-		if (str_starts_with($absolutePath2, $absolutePath1 . '/')) {
-			throw new ForbiddenException('Moving a folder into a child folder is forbidden', false);
-		}
-
-		/** @var IMountManager $mountManager */
-		$mountManager = \OC::$server->get(IMountManager::class);
-
-		$targetParts = explode('/', $absolutePath2);
-		$targetUser = $targetParts[1] ?? null;
-		$result = false;
-		if (
-			Filesystem::isValidPath($target)
-			&& Filesystem::isValidPath($source)
-			&& !Filesystem::isFileBlacklisted($target)
-		) {
-			$source = $this->getRelativePath($absolutePath1);
-			$target = $this->getRelativePath($absolutePath2);
-			$exists = $this->file_exists($target);
-
-			if ($source == null || $target == null) {
-				return false;
-			}
-
-			try {
-				$this->verifyPath(dirname($target), basename($target));
-			} catch (InvalidPathException) {
-				return false;
-			}
-
-			$this->lockFile($source, ILockingProvider::LOCK_SHARED, true);
-			try {
-				$this->lockFile($target, ILockingProvider::LOCK_SHARED, true);
-
-				$run = true;
-				if ($this->shouldEmitHooks($source) && (Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target))) {
-					// if it was a rename from a part file to a regular file it was a write and not a rename operation
-					$this->emit_file_hooks_pre($exists, $target, $run);
-				} elseif ($this->shouldEmitHooks($source)) {
-					$sourcePath = $this->getHookPath($source);
-					$targetPath = $this->getHookPath($target);
-					if ($sourcePath !== null && $targetPath !== null) {
-						\OC_Hook::emit(
-							Filesystem::CLASSNAME, Filesystem::signal_rename,
-							[
-								Filesystem::signal_param_oldpath => $sourcePath,
-								Filesystem::signal_param_newpath => $targetPath,
-								Filesystem::signal_param_run => &$run
-							]
-						);
-					}
-				}
-				if ($run) {
-					$manager = Filesystem::getMountManager();
-					$mount1 = $this->getMount($source);
-					$mount2 = $this->getMount($target);
-					$storage1 = $mount1->getStorage();
-					$storage2 = $mount2->getStorage();
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
-
-					$this->changeLock($source, ILockingProvider::LOCK_EXCLUSIVE, true);
-					try {
-						$this->changeLock($target, ILockingProvider::LOCK_EXCLUSIVE, true);
-
-						if ($checkSubMounts) {
-							$movedMounts = $mountManager->findIn($this->getAbsolutePath($source));
-						} else {
-							$movedMounts = [];
-						}
-
-						if ($internalPath1 === '') {
-							$sourceParentMount = $this->getMount(dirname($source));
-							$movedMounts[] = $mount1;
-							$this->validateMountMove($movedMounts, $sourceParentMount, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
-							/**
-							 * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
-							 */
-							$sourceMountPoint = $mount1->getMountPoint();
-							$result = $mount1->moveMount($absolutePath2);
-							$manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
-
-							// moving a file/folder within the same mount point
-						} elseif ($storage1 === $storage2) {
-							if (count($movedMounts) > 0) {
-								$this->validateMountMove($movedMounts, $mount1, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
-							}
-							if ($storage1) {
-								$result = $storage1->rename($internalPath1, $internalPath2);
-							} else {
-								$result = false;
-							}
-							// moving a file/folder between storages (from $storage1 to $storage2)
-						} else {
-							if (count($movedMounts) > 0) {
-								$this->validateMountMove($movedMounts, $mount1, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
-							}
-							$result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
-						}
-
-						if ((Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target)) && $result !== false) {
-							// if it was a rename from a part file to a regular file it was a write and not a rename operation
-							$this->writeUpdate($storage2, $internalPath2);
-						} elseif ($result) {
-							if ($internalPath1 !== '') { // don't do a cache update for moved mounts
-								$this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
-							}
-						}
-					} catch (\Exception $e) {
-						throw $e;
-					} finally {
-						$this->changeLock($source, ILockingProvider::LOCK_SHARED, true);
-						$this->changeLock($target, ILockingProvider::LOCK_SHARED, true);
-					}
-
-					if ((Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target)) && $result !== false) {
-						if ($this->shouldEmitHooks()) {
-							$this->emit_file_hooks_post($exists, $target);
-						}
-					} elseif ($result) {
-						if ($this->shouldEmitHooks($source) && $this->shouldEmitHooks($target)) {
-							$sourcePath = $this->getHookPath($source);
-							$targetPath = $this->getHookPath($target);
-							if ($sourcePath !== null && $targetPath !== null) {
-								\OC_Hook::emit(
-									Filesystem::CLASSNAME,
-									Filesystem::signal_post_rename,
-									[
-										Filesystem::signal_param_oldpath => $sourcePath,
-										Filesystem::signal_param_newpath => $targetPath,
-									]
-								);
-							}
-						}
-					}
-				}
-			} catch (\Exception $e) {
-				throw $e;
-			} finally {
-				$this->unlockFile($source, ILockingProvider::LOCK_SHARED, true);
-				$this->unlockFile($target, ILockingProvider::LOCK_SHARED, true);
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * @throws ForbiddenException
-	 */
-	private function validateMountMove(array $mounts, IMountPoint $sourceMount, IMountPoint $targetMount, bool $targetIsShared): void {
-		$targetPath = $this->getRelativePath($targetMount->getMountPoint());
-		if ($targetPath) {
-			$targetPath = trim($targetPath, '/');
-		} else {
-			$targetPath = $targetMount->getMountPoint();
-		}
-
-		$l = \OC::$server->get(IFactory::class)->get('files');
-		foreach ($mounts as $mount) {
-			$sourcePath = $this->getRelativePath($mount->getMountPoint());
-			if ($sourcePath) {
-				$sourcePath = trim($sourcePath, '/');
-			} else {
-				$sourcePath = $mount->getMountPoint();
-			}
-
-			if (!$mount instanceof MoveableMount) {
-				throw new ForbiddenException($l->t('Storage %s cannot be moved', [$sourcePath]), false);
-			}
-
-			if ($targetIsShared) {
-				if ($sourceMount instanceof SharedMount) {
-					throw new ForbiddenException($l->t('Moving a share (%s) into a shared folder is not allowed', [$sourcePath]), false);
-				} else {
-					throw new ForbiddenException($l->t('Moving a storage (%s) into a shared folder is not allowed', [$sourcePath]), false);
-				}
-			}
-
-			if ($sourceMount !== $targetMount) {
-				if ($sourceMount instanceof SharedMount) {
-					if ($targetMount instanceof SharedMount) {
-						throw new ForbiddenException($l->t('Moving a share (%s) into another share (%s) is not allowed', [$sourcePath, $targetPath]), false);
-					} else {
-						throw new ForbiddenException($l->t('Moving a share (%s) into another storage (%s) is not allowed', [$sourcePath, $targetPath]), false);
-					}
-				} else {
-					if ($targetMount instanceof SharedMount) {
-						throw new ForbiddenException($l->t('Moving a storage (%s) into a share (%s) is not allowed', [$sourcePath, $targetPath]), false);
-					} else {
-						throw new ForbiddenException($l->t('Moving a storage (%s) into another storage (%s) is not allowed', [$sourcePath, $targetPath]), false);
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * Copy a file/folder from the source path to target path
-	 *
-	 * @param string $source source path
-	 * @param string $target target path
-	 * @param bool $preserveMtime whether to preserve mtime on the copy
-	 *
-	 * @return bool|mixed
-	 */
-	public function copy($source, $target, $preserveMtime = false) {
-		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
-		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
-		$result = false;
-		if (
-			Filesystem::isValidPath($target)
-			&& Filesystem::isValidPath($source)
-			&& !Filesystem::isFileBlacklisted($target)
-		) {
-			$source = $this->getRelativePath($absolutePath1);
-			$target = $this->getRelativePath($absolutePath2);
-
-			if ($source == null || $target == null) {
-				return false;
-			}
-			$run = true;
-
-			$this->lockFile($target, ILockingProvider::LOCK_SHARED);
-			$this->lockFile($source, ILockingProvider::LOCK_SHARED);
-			$lockTypePath1 = ILockingProvider::LOCK_SHARED;
-			$lockTypePath2 = ILockingProvider::LOCK_SHARED;
-
-			try {
-				$exists = $this->file_exists($target);
-				if ($this->shouldEmitHooks($target)) {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						Filesystem::signal_copy,
-						[
-							Filesystem::signal_param_oldpath => $this->getHookPath($source),
-							Filesystem::signal_param_newpath => $this->getHookPath($target),
-							Filesystem::signal_param_run => &$run
-						]
-					);
-					$this->emit_file_hooks_pre($exists, $target, $run);
-				}
-				if ($run) {
-					$mount1 = $this->getMount($source);
-					$mount2 = $this->getMount($target);
-					$storage1 = $mount1->getStorage();
-					$internalPath1 = $mount1->getInternalPath($absolutePath1);
-					$storage2 = $mount2->getStorage();
-					$internalPath2 = $mount2->getInternalPath($absolutePath2);
-
-					$this->changeLock($target, ILockingProvider::LOCK_EXCLUSIVE);
-					$lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
-
-					if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
-						if ($storage1) {
-							$result = $storage1->copy($internalPath1, $internalPath2);
-						} else {
-							$result = false;
-						}
-					} else {
-						$result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
-					}
-
-					if ($result) {
-						$this->copyUpdate($storage1, $storage2, $internalPath1, $internalPath2);
-					}
-
-					$this->changeLock($target, ILockingProvider::LOCK_SHARED);
-					$lockTypePath2 = ILockingProvider::LOCK_SHARED;
-
-					if ($this->shouldEmitHooks($target) && $result !== false) {
-						\OC_Hook::emit(
-							Filesystem::CLASSNAME,
-							Filesystem::signal_post_copy,
-							[
-								Filesystem::signal_param_oldpath => $this->getHookPath($source),
-								Filesystem::signal_param_newpath => $this->getHookPath($target)
-							]
-						);
-						$this->emit_file_hooks_post($exists, $target);
-					}
-				}
-			} catch (\Exception $e) {
-				$this->unlockFile($target, $lockTypePath2);
-				$this->unlockFile($source, $lockTypePath1);
-				throw $e;
-			}
-
-			$this->unlockFile($target, $lockTypePath2);
-			$this->unlockFile($source, $lockTypePath1);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $mode 'r' or 'w'
-	 * @return resource|false
-	 * @throws LockedException
-	 */
-	public function fopen($path, $mode) {
-		$mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
-		$hooks = [];
-		switch ($mode) {
-			case 'r':
-				$hooks[] = 'read';
-				break;
-			case 'r+':
-			case 'w+':
-			case 'x+':
-			case 'a+':
-				$hooks[] = 'read';
-				$hooks[] = 'write';
-				break;
-			case 'w':
-			case 'x':
-			case 'a':
-				$hooks[] = 'write';
-				break;
-			default:
-				$this->logger->error('invalid mode (' . $mode . ') for ' . $path, ['app' => 'core']);
-		}
-
-		if ($mode !== 'r' && $mode !== 'w') {
-			$this->logger->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends', ['app' => 'core']);
-		}
-
-		$handle = $this->basicOperation('fopen', $path, $hooks, $mode);
-		if (!is_resource($handle) && $mode === 'r') {
-			// trying to read a file that isn't on disk, check if the cache is out of sync and rescan if needed
-			$mount = $this->getMount($path);
-			$internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
-			$storage = $mount->getStorage();
-			if ($storage->getCache()->inCache($internalPath) && !$storage->file_exists($path)) {
-				$this->writeUpdate($storage, $internalPath);
-			}
-		}
-		return $handle;
-	}
-
-	/**
-	 * @param string $path
-	 * @throws InvalidPathException
-	 */
-	public function toTmpFile($path): string|false {
-		$this->assertPathLength($path);
-		if (Filesystem::isValidPath($path)) {
-			$source = $this->fopen($path, 'r');
-			if ($source) {
-				$extension = pathinfo($path, PATHINFO_EXTENSION);
-				$tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
-				file_put_contents($tmpFile, $source);
-				return $tmpFile;
-			} else {
-				return false;
-			}
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $tmpFile
-	 * @param string $path
-	 * @return bool|mixed
-	 * @throws InvalidPathException
-	 */
-	public function fromTmpFile($tmpFile, $path) {
-		$this->assertPathLength($path);
-		if (Filesystem::isValidPath($path)) {
-			// Get directory that the file is going into
-			$filePath = dirname($path);
-
-			// Create the directories if any
-			if (!$this->file_exists($filePath)) {
-				$result = $this->createParentDirectories($filePath);
-				if ($result === false) {
-					return false;
-				}
-			}
-
-			$source = fopen($tmpFile, 'r');
-			if ($source) {
-				$result = $this->file_put_contents($path, $source);
-				/**
-				 * $this->file_put_contents() might have already closed
-				 * the resource, so we check it, before trying to close it
-				 * to avoid messages in the error log.
-				 * @psalm-suppress RedundantCondition false-positive
-				 */
-				if (is_resource($source)) {
-					fclose($source);
-				}
-				unlink($tmpFile);
-				return $result;
-			} else {
-				return false;
-			}
-		} else {
-			return false;
-		}
-	}
-
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 * @throws InvalidPathException
-	 */
-	public function getMimeType($path) {
-		$this->assertPathLength($path);
-		return $this->basicOperation('getMimeType', $path);
-	}
-
-	/**
-	 * @param string $type
-	 * @param string $path
-	 * @param bool $raw
-	 */
-	public function hash($type, $path, $raw = false): string|bool {
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		if (Filesystem::isValidPath($path)) {
-			$path = $this->getRelativePath($absolutePath);
-			if ($path == null) {
-				return false;
-			}
-			if ($this->shouldEmitHooks($path)) {
-				\OC_Hook::emit(
-					Filesystem::CLASSNAME,
-					Filesystem::signal_read,
-					[Filesystem::signal_param_path => $this->getHookPath($path)]
-				);
-			}
-			/** @var Storage|null $storage */
-			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
-			if ($storage) {
-				return $storage->hash($type, $internalPath, $raw);
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * @param string $path
-	 * @return mixed
-	 * @throws InvalidPathException
-	 */
-	public function free_space($path = '/') {
-		$this->assertPathLength($path);
-		$result = $this->basicOperation('free_space', $path);
-		if ($result === null) {
-			throw new InvalidPathException();
-		}
-		return $result;
-	}
-
-	/**
-	 * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
-	 *
-	 * @param mixed $extraParam (optional)
-	 * @return mixed
-	 * @throws LockedException
-	 *
-	 * This method takes requests for basic filesystem functions (e.g. reading & writing
-	 * files), processes hooks and proxies, sanitises paths, and finally passes them on to
-	 * \OC\Files\Storage\Storage for delegation to a storage backend for execution
-	 */
-	private function basicOperation(string $operation, string $path, array $hooks = [], $extraParam = null) {
-		$postFix = (substr($path, -1) === '/') ? '/' : '';
-		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		if (Filesystem::isValidPath($path)
-			&& !Filesystem::isFileBlacklisted($path)
-		) {
-			$path = $this->getRelativePath($absolutePath);
-			if ($path == null) {
-				return false;
-			}
-
-			if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
-				// always a shared lock during pre-hooks so the hook can read the file
-				$this->lockFile($path, ILockingProvider::LOCK_SHARED);
-			}
-
-			$run = $this->runHooks($hooks, $path);
-			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
-			if ($run && $storage) {
-				/** @var Storage $storage */
-				if (in_array('write', $hooks) || in_array('delete', $hooks)) {
-					try {
-						$this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
-					} catch (LockedException $e) {
-						// release the shared lock we acquired before quitting
-						$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-						throw $e;
-					}
-				}
-				try {
-					if (!is_null($extraParam)) {
-						$result = $storage->$operation($internalPath, $extraParam);
-					} else {
-						$result = $storage->$operation($internalPath);
-					}
-				} catch (\Exception $e) {
-					if (in_array('write', $hooks) || in_array('delete', $hooks)) {
-						$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-					} elseif (in_array('read', $hooks)) {
-						$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-					}
-					throw $e;
-				}
-
-				if ($result !== false && in_array('delete', $hooks)) {
-					$this->removeUpdate($storage, $internalPath);
-				}
-				if ($result !== false && in_array('write', $hooks, true) && $operation !== 'fopen' && $operation !== 'touch') {
-					$isCreateOperation = $operation === 'mkdir' || ($operation === 'file_put_contents' && in_array('create', $hooks, true));
-					$sizeDifference = $operation === 'mkdir' ? 0 : $result;
-					$this->writeUpdate($storage, $internalPath, null, $isCreateOperation ? $sizeDifference : null);
-				}
-				if ($result !== false && in_array('touch', $hooks)) {
-					$this->writeUpdate($storage, $internalPath, $extraParam, 0);
-				}
-
-				if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
-					$this->changeLock($path, ILockingProvider::LOCK_SHARED);
-				}
-
-				$unlockLater = false;
-				if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
-					$unlockLater = true;
-					// make sure our unlocking callback will still be called if connection is aborted
-					ignore_user_abort(true);
-					$result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
-						if (in_array('write', $hooks)) {
-							$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
-						} elseif (in_array('read', $hooks)) {
-							$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-						}
-					});
-				}
-
-				if ($this->shouldEmitHooks($path) && $result !== false) {
-					if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
-						$this->runHooks($hooks, $path, true);
-					}
-				}
-
-				if (!$unlockLater
-					&& (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
-				) {
-					$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-				}
-				return $result;
-			} else {
-				$this->unlockFile($path, ILockingProvider::LOCK_SHARED);
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * get the path relative to the default root for hook usage
-	 *
-	 * @param string $path
-	 * @return ?string
-	 */
-	private function getHookPath($path): ?string {
-		$view = Filesystem::getView();
-		if (!$view) {
-			return $path;
-		}
-		return $view->getRelativePath($this->getAbsolutePath($path));
-	}
-
-	private function shouldEmitHooks(string $path = ''): bool {
-		if ($path && Cache\Scanner::isPartialFile($path)) {
-			return false;
-		}
-		if (!Filesystem::$loaded) {
-			return false;
-		}
-		$defaultRoot = Filesystem::getRoot();
-		if ($defaultRoot === null) {
-			return false;
-		}
-		if ($this->fakeRoot === $defaultRoot) {
-			return true;
-		}
-		$fullPath = $this->getAbsolutePath($path);
-
-		if ($fullPath === $defaultRoot) {
-			return true;
-		}
-
-		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
-	}
-
-	/**
-	 * @param string[] $hooks
-	 * @param string $path
-	 * @param bool $post
-	 * @return bool
-	 */
-	private function runHooks($hooks, $path, $post = false) {
-		$relativePath = $path;
-		$path = $this->getHookPath($path);
-		$prefix = $post ? 'post_' : '';
-		$run = true;
-		if ($this->shouldEmitHooks($relativePath)) {
-			foreach ($hooks as $hook) {
-				if ($hook != 'read') {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						$prefix . $hook,
-						[
-							Filesystem::signal_param_run => &$run,
-							Filesystem::signal_param_path => $path
-						]
-					);
-				} elseif (!$post) {
-					\OC_Hook::emit(
-						Filesystem::CLASSNAME,
-						$prefix . $hook,
-						[
-							Filesystem::signal_param_path => $path
-						]
-					);
-				}
-			}
-		}
-		return $run;
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public function hasUpdated($path, $time) {
-		return $this->basicOperation('hasUpdated', $path, [], $time);
-	}
-
-	/**
-	 * @param string $ownerId
-	 * @return IUser
-	 */
-	private function getUserObjectForOwner(string $ownerId) {
-		return new LazyUser($ownerId, $this->userManager);
-	}
-
-	/**
-	 * Get file info from cache
-	 *
-	 * If the file is not in cached it will be scanned
-	 * If the file has changed on storage the cache will be updated
-	 *
-	 * @param Storage $storage
-	 * @param string $internalPath
-	 * @param string $relativePath
-	 * @return ICacheEntry|bool
-	 */
-	private function getCacheEntry($storage, $internalPath, $relativePath) {
-		$cache = $storage->getCache($internalPath);
-		$data = $cache->get($internalPath);
-		$watcher = $storage->getWatcher($internalPath);
-
-		try {
-			// if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
-			if (!$data || (isset($data['size']) && $data['size'] === -1)) {
-				if (!$storage->file_exists($internalPath)) {
-					return false;
-				}
-				// don't need to get a lock here since the scanner does it's own locking
-				$scanner = $storage->getScanner($internalPath);
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
-				$data = $cache->get($internalPath);
-			} elseif (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
-				$this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
-				$watcher->update($internalPath, $data);
-				$storage->getPropagator()->propagateChange($internalPath, time());
-				$data = $cache->get($internalPath);
-				$this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
-			}
-		} catch (LockedException $e) {
-			// if the file is locked we just use the old cache info
-		}
-
-		return $data;
-	}
-
-	/**
-	 * get the filesystem info
-	 *
-	 * @param string $path
-	 * @param bool|string $includeMountPoints true to add mountpoint sizes,
-	 *                                        'ext' to add only ext storage mount point sizes. Defaults to true.
-	 * @return \OC\Files\FileInfo|false False if file does not exist
-	 */
-	public function getFileInfo($path, $includeMountPoints = true) {
-		$this->assertPathLength($path);
-		if (!Filesystem::isValidPath($path)) {
-			return false;
-		}
-		$relativePath = $path;
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
-
-		$mount = Filesystem::getMountManager()->find($path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($path);
-		if ($storage) {
-			$data = $this->getCacheEntry($storage, $internalPath, $relativePath);
-
-			if (!$data instanceof ICacheEntry) {
-				if (Cache\Scanner::isPartialFile($relativePath)) {
-					return $this->getPartFileInfo($relativePath);
-				}
-
-				return false;
-			}
-
-			if ($mount instanceof MoveableMount && $internalPath === '') {
-				$data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
-			}
-			if ($internalPath === '' && $data['name']) {
-				$data['name'] = basename($path);
-			}
-
-			$ownerId = $storage->getOwner($internalPath);
-			$owner = null;
-			if ($ownerId !== false) {
-				// ownerId might be null if files are accessed with an access token without file system access
-				$owner = $this->getUserObjectForOwner($ownerId);
-			}
-			$info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
-
-			if (isset($data['fileid'])) {
-				if ($includeMountPoints && $data['mimetype'] === 'httpd/unix-directory') {
-					//add the sizes of other mount points to the folder
-					$extOnly = ($includeMountPoints === 'ext');
-					$this->addSubMounts($info, $extOnly);
-				}
-			}
-
-			return $info;
-		} else {
-			$this->logger->warning('Storage not valid for mountpoint: ' . $mount->getMountPoint(), ['app' => 'core']);
-		}
-
-		return false;
-	}
-
-	/**
-	 * Extend a FileInfo that was previously requested with `$includeMountPoints = false` to include the sub mounts
-	 */
-	public function addSubMounts(FileInfo $info, $extOnly = false): void {
-		$mounts = Filesystem::getMountManager()->findIn($info->getPath());
-		$info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
-			return !($extOnly && $mount instanceof SharedMount);
-		}));
-	}
-
-	/**
-	 * get the content of a directory
-	 *
-	 * @param string $directory path under datadirectory
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
-	 * @return FileInfo[]
-	 */
-	public function getDirectoryContent($directory, $mimetype_filter = '', ?\OCP\Files\FileInfo $directoryInfo = null) {
-		$this->assertPathLength($directory);
-		if (!Filesystem::isValidPath($directory)) {
-			return [];
-		}
-
-		$path = $this->getAbsolutePath($directory);
-		$path = Filesystem::normalizePath($path);
-		$mount = $this->getMount($directory);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($path);
-		if (!$storage) {
-			return [];
-		}
-
-		$cache = $storage->getCache($internalPath);
-		$user = \OC_User::getUser();
-
-		if (!$directoryInfo) {
-			$data = $this->getCacheEntry($storage, $internalPath, $directory);
-			if (!$data instanceof ICacheEntry || !isset($data['fileid'])) {
-				return [];
-			}
-		} else {
-			$data = $directoryInfo;
-		}
-
-		if (!($data->getPermissions() & Constants::PERMISSION_READ)) {
-			return [];
-		}
-
-		$folderId = $data->getId();
-		$contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
-
-		$sharingDisabled = \OCP\Util::isSharingDisabledForUser();
-
-		$fileNames = array_map(function (ICacheEntry $content) {
-			return $content->getName();
-		}, $contents);
-		/**
-		 * @var \OC\Files\FileInfo[] $fileInfos
-		 */
-		$fileInfos = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
-			if ($sharingDisabled) {
-				$content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
-			}
-			$ownerId = $storage->getOwner($content['path']);
-			if ($ownerId !== false) {
-				$owner = $this->getUserObjectForOwner($ownerId);
-			} else {
-				$owner = null;
-			}
-			return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
-		}, $contents);
-		$files = array_combine($fileNames, $fileInfos);
-
-		//add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
-		$mounts = Filesystem::getMountManager()->findIn($path);
-
-		// make sure nested mounts are sorted after their parent mounts
-		// otherwise doesn't propagate the etag across storage boundaries correctly
-		usort($mounts, function (IMountPoint $a, IMountPoint $b) {
-			return $a->getMountPoint() <=> $b->getMountPoint();
-		});
-
-		$dirLength = strlen($path);
-		foreach ($mounts as $mount) {
-			$mountPoint = $mount->getMountPoint();
-			$subStorage = $mount->getStorage();
-			if ($subStorage) {
-				$subCache = $subStorage->getCache('');
-
-				$rootEntry = $subCache->get('');
-				if (!$rootEntry) {
-					$subScanner = $subStorage->getScanner();
-					try {
-						$subScanner->scanFile('');
-					} catch (\OCP\Files\StorageNotAvailableException $e) {
-						continue;
-					} catch (\OCP\Files\StorageInvalidException $e) {
-						continue;
-					} catch (\Exception $e) {
-						// sometimes when the storage is not available it can be any exception
-						$this->logger->error('Exception while scanning storage "' . $subStorage->getId() . '"', [
-							'exception' => $e,
-							'app' => 'core',
-						]);
-						continue;
-					}
-					$rootEntry = $subCache->get('');
-				}
-
-				if ($rootEntry && ($rootEntry->getPermissions() & Constants::PERMISSION_READ)) {
-					$relativePath = trim(substr($mountPoint, $dirLength), '/');
-					if ($pos = strpos($relativePath, '/')) {
-						//mountpoint inside subfolder add size to the correct folder
-						$entryName = substr($relativePath, 0, $pos);
-
-						// Create parent folders if the mountpoint is inside a subfolder that doesn't exist yet
-						if (!isset($files[$entryName])) {
-							try {
-								[$storage, ] = $this->resolvePath($path . '/' . $entryName);
-								// make sure we can create the mountpoint folder, even if the user has a quota of 0
-								if ($storage->instanceOfStorage(Quota::class)) {
-									$storage->enableQuota(false);
-								}
-
-								if ($this->mkdir($path . '/' . $entryName) !== false) {
-									$info = $this->getFileInfo($path . '/' . $entryName);
-									if ($info !== false) {
-										$files[$entryName] = $info;
-									}
-								}
-
-								if ($storage->instanceOfStorage(Quota::class)) {
-									$storage->enableQuota(true);
-								}
-							} catch (\Exception $e) {
-								// Creating the parent folder might not be possible, for example due to a lack of permissions.
-								$this->logger->debug('Failed to create non-existent parent', ['exception' => $e, 'path' => $path . '/' . $entryName]);
-							}
-						}
-
-						if (isset($files[$entryName])) {
-							$files[$entryName]->addSubEntry($rootEntry, $mountPoint);
-						}
-					} else { //mountpoint in this folder, add an entry for it
-						$rootEntry['name'] = $relativePath;
-						$rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
-						$permissions = $rootEntry['permissions'];
-						// do not allow renaming/deleting the mount point if they are not shared files/folders
-						// for shared files/folders we use the permissions given by the owner
-						if ($mount instanceof MoveableMount) {
-							$rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
-						} else {
-							$rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
-						}
-
-						$rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
-
-						// if sharing was disabled for the user we remove the share permissions
-						if ($sharingDisabled) {
-							$rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
-						}
-
-						$ownerId = $subStorage->getOwner('');
-						if ($ownerId !== false) {
-							$owner = $this->getUserObjectForOwner($ownerId);
-						} else {
-							$owner = null;
-						}
-						$files[$rootEntry->getName()] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
-					}
-				}
-			}
-		}
-
-		if ($mimetype_filter) {
-			$files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
-				if (strpos($mimetype_filter, '/')) {
-					return $file->getMimetype() === $mimetype_filter;
-				} else {
-					return $file->getMimePart() === $mimetype_filter;
-				}
-			});
-		}
-
-		return array_values($files);
-	}
-
-	/**
-	 * change file metadata
-	 *
-	 * @param string $path
-	 * @param array|\OCP\Files\FileInfo $data
-	 * @return int
-	 *
-	 * returns the fileid of the updated file
-	 */
-	public function putFileInfo($path, $data) {
-		$this->assertPathLength($path);
-		if ($data instanceof FileInfo) {
-			$data = $data->getData();
-		}
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
-		/**
-		 * @var Storage $storage
-		 * @var string $internalPath
-		 */
-		[$storage, $internalPath] = Filesystem::resolvePath($path);
-		if ($storage) {
-			$cache = $storage->getCache($path);
-
-			if (!$cache->inCache($internalPath)) {
-				$scanner = $storage->getScanner($internalPath);
-				$scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
-			}
-
-			return $cache->put($internalPath, $data);
-		} else {
-			return -1;
-		}
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string $query
-	 * @return FileInfo[]
-	 */
-	public function search($query) {
-		return $this->searchCommon('search', ['%' . $query . '%']);
-	}
-
-	/**
-	 * search for files with the name matching $query
-	 *
-	 * @param string $query
-	 * @return FileInfo[]
-	 */
-	public function searchRaw($query) {
-		return $this->searchCommon('search', [$query]);
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return FileInfo[]
-	 */
-	public function searchByMime($mimetype) {
-		return $this->searchCommon('searchByMime', [$mimetype]);
-	}
-
-	/**
-	 * search for files by tag
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return FileInfo[]
-	 */
-	public function searchByTag($tag, $userId) {
-		return $this->searchCommon('searchByTag', [$tag, $userId]);
-	}
-
-	/**
-	 * @param string $method cache method
-	 * @param array $args
-	 * @return FileInfo[]
-	 */
-	private function searchCommon($method, $args) {
-		$files = [];
-		$rootLength = strlen($this->fakeRoot);
-
-		$mount = $this->getMount('');
-		$mountPoint = $mount->getMountPoint();
-		$storage = $mount->getStorage();
-		$userManager = \OC::$server->getUserManager();
-		if ($storage) {
-			$cache = $storage->getCache('');
-
-			$results = call_user_func_array([$cache, $method], $args);
-			foreach ($results as $result) {
-				if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
-					$internalPath = $result['path'];
-					$path = $mountPoint . $result['path'];
-					$result['path'] = substr($mountPoint . $result['path'], $rootLength);
-					$ownerId = $storage->getOwner($internalPath);
-					if ($ownerId !== false) {
-						$owner = $userManager->get($ownerId);
-					} else {
-						$owner = null;
-					}
-					$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
-				}
-			}
-
-			$mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
-			foreach ($mounts as $mount) {
-				$mountPoint = $mount->getMountPoint();
-				$storage = $mount->getStorage();
-				if ($storage) {
-					$cache = $storage->getCache('');
-
-					$relativeMountPoint = substr($mountPoint, $rootLength);
-					$results = call_user_func_array([$cache, $method], $args);
-					if ($results) {
-						foreach ($results as $result) {
-							$internalPath = $result['path'];
-							$result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
-							$path = rtrim($mountPoint . $internalPath, '/');
-							$ownerId = $storage->getOwner($internalPath);
-							if ($ownerId !== false) {
-								$owner = $userManager->get($ownerId);
-							} else {
-								$owner = null;
-							}
-							$files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
-						}
-					}
-				}
-			}
-		}
-		return $files;
-	}
-
-	/**
-	 * Get the owner for a file or folder
-	 *
-	 * @throws NotFoundException
-	 */
-	public function getOwner(string $path): string {
-		$info = $this->getFileInfo($path);
-		if (!$info) {
-			throw new NotFoundException($path . ' not found while trying to get owner');
-		}
-
-		if ($info->getOwner() === null) {
-			throw new NotFoundException($path . ' has no owner');
-		}
-
-		return $info->getOwner()->getUID();
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string|false
-	 */
-	public function getETag($path) {
-		[$storage, $internalPath] = $this->resolvePath($path);
-		if ($storage) {
-			return $storage->getETag($internalPath);
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Get the path of a file by id, relative to the view
-	 *
-	 * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
-	 *
-	 * @param int $id
-	 * @param int|null $storageId
-	 * @return string
-	 * @throws NotFoundException
-	 */
-	public function getPath($id, ?int $storageId = null): string {
-		$id = (int)$id;
-		$rootFolder = Server::get(Files\IRootFolder::class);
-
-		$node = $rootFolder->getFirstNodeByIdInPath($id, $this->getRoot());
-		if ($node) {
-			if ($storageId === null || $storageId === $node->getStorage()->getCache()->getNumericStorageId()) {
-				return $this->getRelativePath($node->getPath()) ?? '';
-			}
-		} else {
-			throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
-		}
-
-		foreach ($rootFolder->getByIdInPath($id, $this->getRoot()) as $node) {
-			if ($storageId === $node->getStorage()->getCache()->getNumericStorageId()) {
-				return $this->getRelativePath($node->getPath()) ?? '';
-			}
-		}
-
-		throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
-	}
-
-	/**
-	 * @param string $path
-	 * @throws InvalidPathException
-	 */
-	private function assertPathLength($path): void {
-		$maxLen = min(PHP_MAXPATHLEN, 4000);
-		// Check for the string length - performed using isset() instead of strlen()
-		// because isset() is about 5x-40x faster.
-		if (isset($path[$maxLen])) {
-			$pathLen = strlen($path);
-			throw new InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
-		}
-	}
-
-	/**
-	 * check if it is allowed to move a mount point to a given target.
-	 * It is not allowed to move a mount point into a different mount point or
-	 * into an already shared folder
-	 */
-	private function targetIsNotShared(string $user, string $targetPath): bool {
-		$providers = [
-			IShare::TYPE_USER,
-			IShare::TYPE_GROUP,
-			IShare::TYPE_EMAIL,
-			IShare::TYPE_CIRCLE,
-			IShare::TYPE_ROOM,
-			IShare::TYPE_DECK,
-			IShare::TYPE_SCIENCEMESH
-		];
-		$shareManager = Server::get(IManager::class);
-		/** @var IShare[] $shares */
-		$shares = array_merge(...array_map(function (int $type) use ($shareManager, $user) {
-			return $shareManager->getSharesBy($user, $type);
-		}, $providers));
-
-		foreach ($shares as $share) {
-			$sharedPath = $share->getNode()->getPath();
-			if ($targetPath === $sharedPath || str_starts_with($targetPath, $sharedPath . '/')) {
-				$this->logger->debug(
-					'It is not allowed to move one mount point into a shared folder',
-					['app' => 'files']);
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get a fileinfo object for files that are ignored in the cache (part files)
-	 */
-	private function getPartFileInfo(string $path): \OC\Files\FileInfo {
-		$mount = $this->getMount($path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
-		$ownerId = $storage->getOwner($internalPath);
-		if ($ownerId !== false) {
-			$owner = Server::get(IUserManager::class)->get($ownerId);
-		} else {
-			$owner = null;
-		}
-		return new FileInfo(
-			$this->getAbsolutePath($path),
-			$storage,
-			$internalPath,
-			[
-				'fileid' => null,
-				'mimetype' => $storage->getMimeType($internalPath),
-				'name' => basename($path),
-				'etag' => null,
-				'size' => $storage->filesize($internalPath),
-				'mtime' => $storage->filemtime($internalPath),
-				'encrypted' => false,
-				'permissions' => \OCP\Constants::PERMISSION_ALL
-			],
-			$mount,
-			$owner
-		);
-	}
-
-	/**
-	 * @param string $path
-	 * @param string $fileName
-	 * @param bool $readonly Check only if the path is allowed for read-only access
-	 * @throws InvalidPathException
-	 */
-	public function verifyPath($path, $fileName, $readonly = false): void {
-		// All of the view's functions disallow '..' in the path so we can short cut if the path is invalid
-		if (!Filesystem::isValidPath($path ?: '/')) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($l->t('Path contains invalid segments'));
-		}
-
-		// Short cut for read-only validation
-		if ($readonly) {
-			$validator = Server::get(FilenameValidator::class);
-			if ($validator->isForbidden($fileName)) {
-				$l = \OCP\Util::getL10N('lib');
-				throw new InvalidPathException($l->t('Filename is a reserved word'));
-			}
-			return;
-		}
-
-		try {
-			/** @type \OCP\Files\Storage $storage */
-			[$storage, $internalPath] = $this->resolvePath($path);
-			$storage->verifyPath($internalPath, $fileName);
-		} catch (ReservedWordException $ex) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($ex->getMessage() ?: $l->t('Filename is a reserved word'));
-		} catch (InvalidCharacterInPathException $ex) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($ex->getMessage() ?: $l->t('Filename contains at least one invalid character'));
-		} catch (FileNameTooLongException $ex) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($l->t('Filename is too long'));
-		} catch (InvalidDirectoryException $ex) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($l->t('Dot files are not allowed'));
-		} catch (EmptyFileNameException $ex) {
-			$l = \OCP\Util::getL10N('lib');
-			throw new InvalidPathException($l->t('Empty filename is not allowed'));
-		}
-	}
-
-	/**
-	 * get all parent folders of $path
-	 *
-	 * @param string $path
-	 * @return string[]
-	 */
-	private function getParents($path) {
-		$path = trim($path, '/');
-		if (!$path) {
-			return [];
-		}
-
-		$parts = explode('/', $path);
-
-		// remove the single file
-		array_pop($parts);
-		$result = ['/'];
-		$resultPath = '';
-		foreach ($parts as $part) {
-			if ($part) {
-				$resultPath .= '/' . $part;
-				$result[] = $resultPath;
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Returns the mount point for which to lock
-	 *
-	 * @param string $absolutePath absolute path
-	 * @param bool $useParentMount true to return parent mount instead of whatever
-	 *                             is mounted directly on the given path, false otherwise
-	 * @return IMountPoint mount point for which to apply locks
-	 */
-	private function getMountForLock(string $absolutePath, bool $useParentMount = false): IMountPoint {
-		$mount = Filesystem::getMountManager()->find($absolutePath);
-
-		if ($useParentMount) {
-			// find out if something is mounted directly on the path
-			$internalPath = $mount->getInternalPath($absolutePath);
-			if ($internalPath === '') {
-				// resolve the parent mount instead
-				$mount = Filesystem::getMountManager()->find(dirname($absolutePath));
-			}
-		}
-
-		return $mount;
-	}
-
-	/**
-	 * Lock the given path
-	 *
-	 * @param string $path the path of the file to lock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws LockedException if the path is already locked
-	 */
-	private function lockPath($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		try {
-			$storage = $mount->getStorage();
-			if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-				$storage->acquireLock(
-					$mount->getInternalPath($absolutePath),
-					$type,
-					$this->lockingProvider
-				);
-			}
-		} catch (LockedException $e) {
-			// rethrow with the human-readable path
-			throw new LockedException(
-				$path,
-				$e,
-				$e->getExistingLock()
-			);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Change the lock type
-	 *
-	 * @param string $path the path of the file to lock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws LockedException if the path is already locked
-	 */
-	public function changeLock($path, $type, $lockMountPoint = false) {
-		$path = Filesystem::normalizePath($path);
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		try {
-			$storage = $mount->getStorage();
-			if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-				$storage->changeLock(
-					$mount->getInternalPath($absolutePath),
-					$type,
-					$this->lockingProvider
-				);
-			}
-		} catch (LockedException $e) {
-			// rethrow with the a human-readable path
-			throw new LockedException(
-				$path,
-				$e,
-				$e->getExistingLock()
-			);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Unlock the given path
-	 *
-	 * @param string $path the path of the file to unlock, relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws LockedException
-	 */
-	private function unlockPath($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$mount = $this->getMountForLock($absolutePath, $lockMountPoint);
-		$storage = $mount->getStorage();
-		if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
-			$storage->releaseLock(
-				$mount->getInternalPath($absolutePath),
-				$type,
-				$this->lockingProvider
-			);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Lock a path and all its parents up to the root of the view
-	 *
-	 * @param string $path the path of the file to lock relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws LockedException
-	 */
-	public function lockFile($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$this->lockPath($path, $type, $lockMountPoint);
-
-		$parents = $this->getParents($path);
-		foreach ($parents as $parent) {
-			$this->lockPath($parent, ILockingProvider::LOCK_SHARED);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Unlock a path and all its parents up to the root of the view
-	 *
-	 * @param string $path the path of the file to lock relative to the view
-	 * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
-	 * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
-	 *
-	 * @return bool False if the path is excluded from locking, true otherwise
-	 * @throws LockedException
-	 */
-	public function unlockFile($path, $type, $lockMountPoint = false) {
-		$absolutePath = $this->getAbsolutePath($path);
-		$absolutePath = Filesystem::normalizePath($absolutePath);
-		if (!$this->shouldLockFile($absolutePath)) {
-			return false;
-		}
-
-		$this->unlockPath($path, $type, $lockMountPoint);
-
-		$parents = $this->getParents($path);
-		foreach ($parents as $parent) {
-			$this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
-		}
-
-		return true;
-	}
-
-	/**
-	 * Only lock files in data/user/files/
-	 *
-	 * @param string $path Absolute path to the file/folder we try to (un)lock
-	 * @return bool
-	 */
-	protected function shouldLockFile($path) {
-		$path = Filesystem::normalizePath($path);
-
-		$pathSegments = explode('/', $path);
-		if (isset($pathSegments[2])) {
-			// E.g.: /username/files/path-to-file
-			return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
-		}
-
-		return !str_starts_with($path, '/appdata_');
-	}
-
-	/**
-	 * Shortens the given absolute path to be relative to
-	 * "$user/files".
-	 *
-	 * @param string $absolutePath absolute path which is under "files"
-	 *
-	 * @return string path relative to "files" with trimmed slashes or null
-	 *                if the path was NOT relative to files
-	 *
-	 * @throws \InvalidArgumentException if the given path was not under "files"
-	 * @since 8.1.0
-	 */
-	public function getPathRelativeToFiles($absolutePath) {
-		$path = Filesystem::normalizePath($absolutePath);
-		$parts = explode('/', trim($path, '/'), 3);
-		// "$user", "files", "path/to/dir"
-		if (!isset($parts[1]) || $parts[1] !== 'files') {
-			$this->logger->error(
-				'$absolutePath must be relative to "files", value is "{absolutePath}"',
-				[
-					'absolutePath' => $absolutePath,
-				]
-			);
-			throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
-		}
-		if (isset($parts[2])) {
-			return $parts[2];
-		}
-		return '';
-	}
-
-	/**
-	 * @param string $filename
-	 * @return array
-	 * @throws \OC\User\NoUserException
-	 * @throws NotFoundException
-	 */
-	public function getUidAndFilename($filename) {
-		$info = $this->getFileInfo($filename);
-		if (!$info instanceof \OCP\Files\FileInfo) {
-			throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
-		}
-		$uid = $info->getOwner()->getUID();
-		if ($uid != \OC_User::getUser()) {
-			Filesystem::initMountPoints($uid);
-			$ownerView = new View('/' . $uid . '/files');
-			try {
-				$filename = $ownerView->getPath($info['fileid']);
-			} catch (NotFoundException $e) {
-				throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
-			}
-		}
-		return [$uid, $filename];
-	}
-
-	/**
-	 * Creates parent non-existing folders
-	 *
-	 * @param string $filePath
-	 * @return bool
-	 */
-	private function createParentDirectories($filePath) {
-		$directoryParts = explode('/', $filePath);
-		$directoryParts = array_filter($directoryParts);
-		foreach ($directoryParts as $key => $part) {
-			$currentPathElements = array_slice($directoryParts, 0, $key);
-			$currentPath = '/' . implode('/', $currentPathElements);
-			if ($this->is_file($currentPath)) {
-				return false;
-			}
-			if (!$this->file_exists($currentPath)) {
-				$this->mkdir($currentPath);
-			}
-		}
-
-		return true;
-	}
+    private string $fakeRoot = '';
+    private ILockingProvider $lockingProvider;
+    private bool $lockingEnabled;
+    private bool $updaterEnabled = true;
+    private UserManager $userManager;
+    private LoggerInterface $logger;
+
+    /**
+     * @throws \Exception If $root contains an invalid path
+     */
+    public function __construct(string $root = '') {
+        if (!Filesystem::isValidPath($root)) {
+            throw new \Exception();
+        }
+
+        $this->fakeRoot = $root;
+        $this->lockingProvider = \OC::$server->get(ILockingProvider::class);
+        $this->lockingEnabled = !($this->lockingProvider instanceof \OC\Lock\NoopLockingProvider);
+        $this->userManager = \OC::$server->getUserManager();
+        $this->logger = \OC::$server->get(LoggerInterface::class);
+    }
+
+    /**
+     * @param ?string $path
+     * @psalm-template S as string|null
+     * @psalm-param S $path
+     * @psalm-return (S is string ? string : null)
+     */
+    public function getAbsolutePath($path = '/'): ?string {
+        if ($path === null) {
+            return null;
+        }
+        $this->assertPathLength($path);
+        if ($path === '') {
+            $path = '/';
+        }
+        if ($path[0] !== '/') {
+            $path = '/' . $path;
+        }
+        return $this->fakeRoot . $path;
+    }
+
+    /**
+     * Change the root to a fake root
+     *
+     * @param string $fakeRoot
+     */
+    public function chroot($fakeRoot): void {
+        if (!$fakeRoot == '') {
+            if ($fakeRoot[0] !== '/') {
+                $fakeRoot = '/' . $fakeRoot;
+            }
+        }
+        $this->fakeRoot = $fakeRoot;
+    }
+
+    /**
+     * Get the fake root
+     */
+    public function getRoot(): string {
+        return $this->fakeRoot;
+    }
+
+    /**
+     * get path relative to the root of the view
+     *
+     * @param string $path
+     */
+    public function getRelativePath($path): ?string {
+        $this->assertPathLength($path);
+        if ($this->fakeRoot == '') {
+            return $path;
+        }
+
+        if (rtrim($path, '/') === rtrim($this->fakeRoot, '/')) {
+            return '/';
+        }
+
+        // missing slashes can cause wrong matches!
+        $root = rtrim($this->fakeRoot, '/') . '/';
+
+        if (!str_starts_with($path, $root)) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->fakeRoot));
+            if (strlen($path) === 0) {
+                return '/';
+            } else {
+                return $path;
+            }
+        }
+    }
+
+    /**
+     * Get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and does not take the chroot into account )
+     *
+     * @param string $path
+     */
+    public function getMountPoint($path): string {
+        return Filesystem::getMountPoint($this->getAbsolutePath($path));
+    }
+
+    /**
+     * Get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and does not take the chroot into account )
+     *
+     * @param string $path
+     */
+    public function getMount($path): IMountPoint {
+        return Filesystem::getMountManager()->find($this->getAbsolutePath($path));
+    }
+
+    /**
+     * Resolve a path to a storage and internal path
+     *
+     * @param string $path
+     * @return array{?\OCP\Files\Storage\IStorage, string} an array consisting of the storage and the internal path
+     */
+    public function resolvePath($path): array {
+        $a = $this->getAbsolutePath($path);
+        $p = Filesystem::normalizePath($a);
+        return Filesystem::resolvePath($p);
+    }
+
+    /**
+     * Return the path to a local version of the file
+     * we need this because we can't know if a file is stored local or not from
+     * outside the filestorage and for some purposes a local file is needed
+     *
+     * @param string $path
+     */
+    public function getLocalFile($path): string|false {
+        $parent = substr($path, 0, strrpos($path, '/') ?: 0);
+        $path = $this->getAbsolutePath($path);
+        [$storage, $internalPath] = Filesystem::resolvePath($path);
+        if (Filesystem::isValidPath($parent) && $storage) {
+            return $storage->getLocalFile($internalPath);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * the following functions operate with arguments and return values identical
+     * to those of their PHP built-in equivalents. Mostly they are merely wrappers
+     * for \OC\Files\Storage\Storage via basicOperation().
+     */
+    public function mkdir($path) {
+        return $this->basicOperation('mkdir', $path, ['create', 'write']);
+    }
+
+    /**
+     * remove mount point
+     *
+     * @param IMountPoint $mount
+     * @param string $path relative to data/
+     */
+    protected function removeMount($mount, $path): bool {
+        if ($mount instanceof MoveableMount) {
+            // cut of /user/files to get the relative path to data/user/files
+            $pathParts = explode('/', $path, 4);
+            $relPath = '/' . $pathParts[3];
+            $this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
+            \OC_Hook::emit(
+                Filesystem::CLASSNAME, 'umount',
+                [Filesystem::signal_param_path => $relPath]
+            );
+            $this->changeLock($relPath, ILockingProvider::LOCK_EXCLUSIVE, true);
+            $result = $mount->removeMount();
+            $this->changeLock($relPath, ILockingProvider::LOCK_SHARED, true);
+            if ($result) {
+                \OC_Hook::emit(
+                    Filesystem::CLASSNAME, 'post_umount',
+                    [Filesystem::signal_param_path => $relPath]
+                );
+            }
+            $this->unlockFile($relPath, ILockingProvider::LOCK_SHARED, true);
+            return $result;
+        } else {
+            // do not allow deleting the storage's root / the mount point
+            // because for some storages it might delete the whole contents
+            // but isn't supposed to work that way
+            return false;
+        }
+    }
+
+    public function disableCacheUpdate(): void {
+        $this->updaterEnabled = false;
+    }
+
+    public function enableCacheUpdate(): void {
+        $this->updaterEnabled = true;
+    }
+
+    protected function writeUpdate(Storage $storage, string $internalPath, ?int $time = null, ?int $sizeDifference = null): void {
+        if ($this->updaterEnabled) {
+            if (is_null($time)) {
+                $time = time();
+            }
+            $storage->getUpdater()->update($internalPath, $time, $sizeDifference);
+        }
+    }
+
+    protected function removeUpdate(Storage $storage, string $internalPath): void {
+        if ($this->updaterEnabled) {
+            $storage->getUpdater()->remove($internalPath);
+        }
+    }
+
+    protected function renameUpdate(Storage $sourceStorage, Storage $targetStorage, string $sourceInternalPath, string $targetInternalPath): void {
+        if ($this->updaterEnabled) {
+            $targetStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        }
+    }
+
+    protected function copyUpdate(Storage $sourceStorage, Storage $targetStorage, string $sourceInternalPath, string $targetInternalPath): void {
+        if ($this->updaterEnabled) {
+            $targetStorage->getUpdater()->copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function rmdir($path) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+        if ($mount->getInternalPath($absolutePath) === '') {
+            return $this->removeMount($mount, $absolutePath);
+        }
+        if ($this->is_dir($path)) {
+            $result = $this->basicOperation('rmdir', $path, ['delete']);
+        } else {
+            $result = false;
+        }
+
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
+            $storage = $mount->getStorage();
+            $internalPath = $mount->getInternalPath($absolutePath);
+            $storage->getUpdater()->remove($internalPath);
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @return resource|false
+     */
+    public function opendir($path) {
+        return $this->basicOperation('opendir', $path, ['read']);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function is_dir($path) {
+        if ($path == '/') {
+            return true;
+        }
+        return $this->basicOperation('is_dir', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function is_file($path) {
+        if ($path == '/') {
+            return false;
+        }
+        return $this->basicOperation('is_file', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function stat($path) {
+        return $this->basicOperation('stat', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filetype($path) {
+        return $this->basicOperation('filetype', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filesize(string $path) {
+        return $this->basicOperation('filesize', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     * @throws InvalidPathException
+     */
+    public function readfile($path) {
+        $this->assertPathLength($path);
+        if (ob_get_level()) {
+            ob_end_clean();
+        }
+        $handle = $this->fopen($path, 'rb');
+        if ($handle) {
+            $chunkSize = 524288; // 512 kiB chunks
+            while (!feof($handle)) {
+                echo fread($handle, $chunkSize);
+                flush();
+                $this->checkConnectionStatus();
+            }
+            fclose($handle);
+            return $this->filesize($path);
+        }
+        return false;
+    }
+
+    /**
+     * @param string $path
+     * @param int $from
+     * @param int $to
+     * @return bool|mixed
+     * @throws InvalidPathException
+     * @throws \OCP\Files\UnseekableException
+     */
+    public function readfilePart($path, $from, $to) {
+        $this->assertPathLength($path);
+        if (ob_get_level()) {
+            ob_end_clean();
+        }
+        $handle = $this->fopen($path, 'rb');
+        if ($handle) {
+            $chunkSize = 524288; // 512 kiB chunks
+            $startReading = true;
+
+            if ($from !== 0 && $from !== '0' && fseek($handle, $from) !== 0) {
+                // forward file handle via chunked fread because fseek seem to have failed
+
+                $end = $from + 1;
+                while (!feof($handle) && ftell($handle) < $end && ftell($handle) !== $from) {
+                    $len = $from - ftell($handle);
+                    if ($len > $chunkSize) {
+                        $len = $chunkSize;
+                    }
+                    $result = fread($handle, $len);
+
+                    if ($result === false) {
+                        $startReading = false;
+                        break;
+                    }
+                }
+            }
+
+            if ($startReading) {
+                $end = $to + 1;
+                while (!feof($handle) && ftell($handle) < $end) {
+                    $len = $end - ftell($handle);
+                    if ($len > $chunkSize) {
+                        $len = $chunkSize;
+                    }
+                    echo fread($handle, $len);
+                    flush();
+                    $this->checkConnectionStatus();
+                }
+                return ftell($handle) - $from;
+            }
+
+            throw new \OCP\Files\UnseekableException('fseek error');
+        }
+        return false;
+    }
+
+    private function checkConnectionStatus(): void {
+        $connectionStatus = \connection_status();
+        if ($connectionStatus !== CONNECTION_NORMAL) {
+            throw new ConnectionLostException("Connection lost. Status: $connectionStatus");
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isCreatable($path) {
+        return $this->basicOperation('isCreatable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isReadable($path) {
+        return $this->basicOperation('isReadable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isUpdatable($path) {
+        return $this->basicOperation('isUpdatable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function isDeletable($path) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+        if ($mount->getInternalPath($absolutePath) === '') {
+            return $mount instanceof MoveableMount;
+        }
+        return $this->basicOperation('isDeletable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function isSharable($path) {
+        return $this->basicOperation('isSharable', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function file_exists($path) {
+        if ($path == '/') {
+            return true;
+        }
+        return $this->basicOperation('file_exists', $path);
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     */
+    public function filemtime($path) {
+        return $this->basicOperation('filemtime', $path);
+    }
+
+    /**
+     * @param string $path
+     * @param int|string $mtime
+     */
+    public function touch($path, $mtime = null): bool {
+        if (!is_null($mtime) && !is_numeric($mtime)) {
+            $mtime = strtotime($mtime);
+        }
+
+        $hooks = ['touch'];
+
+        if (!$this->file_exists($path)) {
+            $hooks[] = 'create';
+            $hooks[] = 'write';
+        }
+        try {
+            $result = $this->basicOperation('touch', $path, $hooks, $mtime);
+        } catch (\Exception $e) {
+            $this->logger->info('Error while setting modified time', ['app' => 'core', 'exception' => $e]);
+            $result = false;
+        }
+        if (!$result) {
+            // If create file fails because of permissions on external storage like SMB folders,
+            // check file exists and return false if not.
+            if (!$this->file_exists($path)) {
+                return false;
+            }
+            if (is_null($mtime)) {
+                $mtime = time();
+            }
+            //if native touch fails, we emulate it by changing the mtime in the cache
+            $this->putFileInfo($path, ['mtime' => floor($mtime)]);
+        }
+        return true;
+    }
+
+    /**
+     * @param string $path
+     * @return string|false
+     * @throws LockedException
+     */
+    public function file_get_contents($path) {
+        return $this->basicOperation('file_get_contents', $path, ['read']);
+    }
+
+    protected function emit_file_hooks_pre(bool $exists, string $path, bool &$run): void {
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
+                Filesystem::signal_param_path => $this->getHookPath($path),
+                Filesystem::signal_param_run => &$run,
+            ]);
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
+                Filesystem::signal_param_path => $this->getHookPath($path),
+                Filesystem::signal_param_run => &$run,
+            ]);
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
+            Filesystem::signal_param_path => $this->getHookPath($path),
+            Filesystem::signal_param_run => &$run,
+        ]);
+    }
+
+    protected function emit_file_hooks_post(bool $exists, string $path): void {
+        if (!$exists) {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
+                Filesystem::signal_param_path => $this->getHookPath($path),
+            ]);
+        } else {
+            \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
+                Filesystem::signal_param_path => $this->getHookPath($path),
+            ]);
+        }
+        \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
+            Filesystem::signal_param_path => $this->getHookPath($path),
+        ]);
+    }
+
+    /**
+     * @param string $path
+     * @param string|resource $data
+     * @return bool|mixed
+     * @throws LockedException
+     */
+    public function file_put_contents($path, $data) {
+        if (is_resource($data)) { //not having to deal with streams in file_put_contents makes life easier
+            $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+            if (Filesystem::isValidPath($path)
+                && !Filesystem::isFileBlacklisted($path)
+            ) {
+                $path = $this->getRelativePath($absolutePath);
+                if ($path === null) {
+                    throw new InvalidPathException("Path $absolutePath is not in the expected root");
+                }
+
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
+
+                $exists = $this->file_exists($path);
+                if ($this->shouldEmitHooks($path)) {
+                    $run = true;
+                    $this->emit_file_hooks_pre($exists, $path, $run);
+                    if (!$run) {
+                        $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                        return false;
+                    }
+                }
+
+                try {
+                    $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
+                } catch (\Exception $e) {
+                    // Release the shared lock before throwing.
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    throw $e;
+                }
+
+                /** @var Storage $storage */
+                [$storage, $internalPath] = $this->resolvePath($path);
+                $target = $storage->fopen($internalPath, 'w');
+                if ($target) {
+                    [, $result] = Files::streamCopy($data, $target, true);
+                    fclose($target);
+                    fclose($data);
+
+                    $this->writeUpdate($storage, $internalPath);
+
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
+
+                    if ($this->shouldEmitHooks($path) && $result !== false) {
+                        $this->emit_file_hooks_post($exists, $path);
+                    }
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    return $result;
+                } else {
+                    $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        } else {
+            $hooks = $this->file_exists($path) ? ['update', 'write'] : ['create', 'write'];
+            return $this->basicOperation('file_put_contents', $path, $hooks, $data);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return bool|mixed
+     */
+    public function unlink($path) {
+        if ($path === '' || $path === '/') {
+            // do not allow deleting the root
+            return false;
+        }
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        $mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
+        if ($mount->getInternalPath($absolutePath) === '') {
+            return $this->removeMount($mount, $absolutePath);
+        }
+        if ($this->is_dir($path)) {
+            $result = $this->basicOperation('rmdir', $path, ['delete']);
+        } else {
+            $result = $this->basicOperation('unlink', $path, ['delete']);
+        }
+        if (!$result && !$this->file_exists($path)) { //clear ghost files from the cache on delete
+            $storage = $mount->getStorage();
+            $internalPath = $mount->getInternalPath($absolutePath);
+            $storage->getUpdater()->remove($internalPath);
+            return true;
+        } else {
+            return $result;
+        }
+    }
+
+    /**
+     * @param string $directory
+     * @return bool|mixed
+     */
+    public function deleteAll($directory) {
+        return $this->rmdir($directory);
+    }
+
+    /**
+     * Rename/move a file or folder from the source path to target path.
+     *
+     * @param string $source source path
+     * @param string $target target path
+     * @param array $options
+     *
+     * @return bool|mixed
+     * @throws LockedException
+     */
+    public function rename($source, $target, array $options = []) {
+        $checkSubMounts = $options['checkSubMounts'] ?? true;
+
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
+
+        if (str_starts_with($absolutePath2, $absolutePath1 . '/')) {
+            throw new ForbiddenException('Moving a folder into a child folder is forbidden', false);
+        }
+
+        /** @var IMountManager $mountManager */
+        $mountManager = \OC::$server->get(IMountManager::class);
+
+        $targetParts = explode('/', $absolutePath2);
+        $targetUser = $targetParts[1] ?? null;
+        $result = false;
+        if (
+            Filesystem::isValidPath($target)
+            && Filesystem::isValidPath($source)
+            && !Filesystem::isFileBlacklisted($target)
+        ) {
+            $source = $this->getRelativePath($absolutePath1);
+            $target = $this->getRelativePath($absolutePath2);
+            $exists = $this->file_exists($target);
+
+            if ($source == null || $target == null) {
+                return false;
+            }
+
+            try {
+                $this->verifyPath(dirname($target), basename($target));
+            } catch (InvalidPathException) {
+                return false;
+            }
+
+            $this->lockFile($source, ILockingProvider::LOCK_SHARED, true);
+            try {
+                $this->lockFile($target, ILockingProvider::LOCK_SHARED, true);
+
+                $run = true;
+                if ($this->shouldEmitHooks($source) && (Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target))) {
+                    // if it was a rename from a part file to a regular file it was a write and not a rename operation
+                    $this->emit_file_hooks_pre($exists, $target, $run);
+                } elseif ($this->shouldEmitHooks($source)) {
+                    $sourcePath = $this->getHookPath($source);
+                    $targetPath = $this->getHookPath($target);
+                    if ($sourcePath !== null && $targetPath !== null) {
+                        \OC_Hook::emit(
+                            Filesystem::CLASSNAME, Filesystem::signal_rename,
+                            [
+                                Filesystem::signal_param_oldpath => $sourcePath,
+                                Filesystem::signal_param_newpath => $targetPath,
+                                Filesystem::signal_param_run => &$run
+                            ]
+                        );
+                    }
+                }
+                if ($run) {
+                    $manager = Filesystem::getMountManager();
+                    $mount1 = $this->getMount($source);
+                    $mount2 = $this->getMount($target);
+                    $storage1 = $mount1->getStorage();
+                    $storage2 = $mount2->getStorage();
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
+
+                    $this->changeLock($source, ILockingProvider::LOCK_EXCLUSIVE, true);
+                    try {
+                        $this->changeLock($target, ILockingProvider::LOCK_EXCLUSIVE, true);
+
+                        if ($checkSubMounts) {
+                            $movedMounts = $mountManager->findIn($this->getAbsolutePath($source));
+                        } else {
+                            $movedMounts = [];
+                        }
+
+                        if ($internalPath1 === '') {
+                            $sourceParentMount = $this->getMount(dirname($source));
+                            $movedMounts[] = $mount1;
+                            $this->validateMountMove($movedMounts, $sourceParentMount, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
+                            /**
+                             * @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
+                             */
+                            $sourceMountPoint = $mount1->getMountPoint();
+                            $result = $mount1->moveMount($absolutePath2);
+                            $manager->moveMount($sourceMountPoint, $mount1->getMountPoint());
+
+                            // moving a file/folder within the same mount point
+                        } elseif ($storage1 === $storage2) {
+                            if (count($movedMounts) > 0) {
+                                $this->validateMountMove($movedMounts, $mount1, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
+                            }
+                            if ($storage1) {
+                                $result = $storage1->rename($internalPath1, $internalPath2);
+                            } else {
+                                $result = false;
+                            }
+                            // moving a file/folder between storages (from $storage1 to $storage2)
+                        } else {
+                            if (count($movedMounts) > 0) {
+                                $this->validateMountMove($movedMounts, $mount1, $mount2, !$this->targetIsNotShared($targetUser, $absolutePath2));
+                            }
+                            $result = $storage2->moveFromStorage($storage1, $internalPath1, $internalPath2);
+                        }
+
+                        if ((Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target)) && $result !== false) {
+                            // if it was a rename from a part file to a regular file it was a write and not a rename operation
+                            $this->writeUpdate($storage2, $internalPath2);
+                        } elseif ($result) {
+                            if ($internalPath1 !== '') { // don't do a cache update for moved mounts
+                                $this->renameUpdate($storage1, $storage2, $internalPath1, $internalPath2);
+                            }
+                        }
+                    } catch (\Exception $e) {
+                        throw $e;
+                    } finally {
+                        $this->changeLock($source, ILockingProvider::LOCK_SHARED, true);
+                        $this->changeLock($target, ILockingProvider::LOCK_SHARED, true);
+                    }
+
+                    if ((Cache\Scanner::isPartialFile($source) && !Cache\Scanner::isPartialFile($target)) && $result !== false) {
+                        if ($this->shouldEmitHooks()) {
+                            $this->emit_file_hooks_post($exists, $target);
+                        }
+                    } elseif ($result) {
+                        if ($this->shouldEmitHooks($source) && $this->shouldEmitHooks($target)) {
+                            $sourcePath = $this->getHookPath($source);
+                            $targetPath = $this->getHookPath($target);
+                            if ($sourcePath !== null && $targetPath !== null) {
+                                \OC_Hook::emit(
+                                    Filesystem::CLASSNAME,
+                                    Filesystem::signal_post_rename,
+                                    [
+                                        Filesystem::signal_param_oldpath => $sourcePath,
+                                        Filesystem::signal_param_newpath => $targetPath,
+                                    ]
+                                );
+                            }
+                        }
+                    }
+                }
+            } catch (\Exception $e) {
+                throw $e;
+            } finally {
+                $this->unlockFile($source, ILockingProvider::LOCK_SHARED, true);
+                $this->unlockFile($target, ILockingProvider::LOCK_SHARED, true);
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * @throws ForbiddenException
+     */
+    private function validateMountMove(array $mounts, IMountPoint $sourceMount, IMountPoint $targetMount, bool $targetIsShared): void {
+        $targetPath = $this->getRelativePath($targetMount->getMountPoint());
+        if ($targetPath) {
+            $targetPath = trim($targetPath, '/');
+        } else {
+            $targetPath = $targetMount->getMountPoint();
+        }
+
+        $l = \OC::$server->get(IFactory::class)->get('files');
+        foreach ($mounts as $mount) {
+            $sourcePath = $this->getRelativePath($mount->getMountPoint());
+            if ($sourcePath) {
+                $sourcePath = trim($sourcePath, '/');
+            } else {
+                $sourcePath = $mount->getMountPoint();
+            }
+
+            if (!$mount instanceof MoveableMount) {
+                throw new ForbiddenException($l->t('Storage %s cannot be moved', [$sourcePath]), false);
+            }
+
+            if ($targetIsShared) {
+                if ($sourceMount instanceof SharedMount) {
+                    throw new ForbiddenException($l->t('Moving a share (%s) into a shared folder is not allowed', [$sourcePath]), false);
+                } else {
+                    throw new ForbiddenException($l->t('Moving a storage (%s) into a shared folder is not allowed', [$sourcePath]), false);
+                }
+            }
+
+            if ($sourceMount !== $targetMount) {
+                if ($sourceMount instanceof SharedMount) {
+                    if ($targetMount instanceof SharedMount) {
+                        throw new ForbiddenException($l->t('Moving a share (%s) into another share (%s) is not allowed', [$sourcePath, $targetPath]), false);
+                    } else {
+                        throw new ForbiddenException($l->t('Moving a share (%s) into another storage (%s) is not allowed', [$sourcePath, $targetPath]), false);
+                    }
+                } else {
+                    if ($targetMount instanceof SharedMount) {
+                        throw new ForbiddenException($l->t('Moving a storage (%s) into a share (%s) is not allowed', [$sourcePath, $targetPath]), false);
+                    } else {
+                        throw new ForbiddenException($l->t('Moving a storage (%s) into another storage (%s) is not allowed', [$sourcePath, $targetPath]), false);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Copy a file/folder from the source path to target path
+     *
+     * @param string $source source path
+     * @param string $target target path
+     * @param bool $preserveMtime whether to preserve mtime on the copy
+     *
+     * @return bool|mixed
+     */
+    public function copy($source, $target, $preserveMtime = false) {
+        $absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
+        $absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
+        $result = false;
+        if (
+            Filesystem::isValidPath($target)
+            && Filesystem::isValidPath($source)
+            && !Filesystem::isFileBlacklisted($target)
+        ) {
+            $source = $this->getRelativePath($absolutePath1);
+            $target = $this->getRelativePath($absolutePath2);
+
+            if ($source == null || $target == null) {
+                return false;
+            }
+            $run = true;
+
+            $this->lockFile($target, ILockingProvider::LOCK_SHARED);
+            $this->lockFile($source, ILockingProvider::LOCK_SHARED);
+            $lockTypePath1 = ILockingProvider::LOCK_SHARED;
+            $lockTypePath2 = ILockingProvider::LOCK_SHARED;
+
+            try {
+                $exists = $this->file_exists($target);
+                if ($this->shouldEmitHooks($target)) {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        Filesystem::signal_copy,
+                        [
+                            Filesystem::signal_param_oldpath => $this->getHookPath($source),
+                            Filesystem::signal_param_newpath => $this->getHookPath($target),
+                            Filesystem::signal_param_run => &$run
+                        ]
+                    );
+                    $this->emit_file_hooks_pre($exists, $target, $run);
+                }
+                if ($run) {
+                    $mount1 = $this->getMount($source);
+                    $mount2 = $this->getMount($target);
+                    $storage1 = $mount1->getStorage();
+                    $internalPath1 = $mount1->getInternalPath($absolutePath1);
+                    $storage2 = $mount2->getStorage();
+                    $internalPath2 = $mount2->getInternalPath($absolutePath2);
+
+                    $this->changeLock($target, ILockingProvider::LOCK_EXCLUSIVE);
+                    $lockTypePath2 = ILockingProvider::LOCK_EXCLUSIVE;
+
+                    if ($mount1->getMountPoint() == $mount2->getMountPoint()) {
+                        if ($storage1) {
+                            $result = $storage1->copy($internalPath1, $internalPath2);
+                        } else {
+                            $result = false;
+                        }
+                    } else {
+                        $result = $storage2->copyFromStorage($storage1, $internalPath1, $internalPath2);
+                    }
+
+                    if ($result) {
+                        $this->copyUpdate($storage1, $storage2, $internalPath1, $internalPath2);
+                    }
+
+                    $this->changeLock($target, ILockingProvider::LOCK_SHARED);
+                    $lockTypePath2 = ILockingProvider::LOCK_SHARED;
+
+                    if ($this->shouldEmitHooks($target) && $result !== false) {
+                        \OC_Hook::emit(
+                            Filesystem::CLASSNAME,
+                            Filesystem::signal_post_copy,
+                            [
+                                Filesystem::signal_param_oldpath => $this->getHookPath($source),
+                                Filesystem::signal_param_newpath => $this->getHookPath($target)
+                            ]
+                        );
+                        $this->emit_file_hooks_post($exists, $target);
+                    }
+                }
+            } catch (\Exception $e) {
+                $this->unlockFile($target, $lockTypePath2);
+                $this->unlockFile($source, $lockTypePath1);
+                throw $e;
+            }
+
+            $this->unlockFile($target, $lockTypePath2);
+            $this->unlockFile($source, $lockTypePath1);
+        }
+        return $result;
+    }
+
+    /**
+     * @param string $path
+     * @param string $mode 'r' or 'w'
+     * @return resource|false
+     * @throws LockedException
+     */
+    public function fopen($path, $mode) {
+        $mode = str_replace('b', '', $mode); // the binary flag is a windows only feature which we do not support
+        $hooks = [];
+        switch ($mode) {
+            case 'r':
+                $hooks[] = 'read';
+                break;
+            case 'r+':
+            case 'w+':
+            case 'x+':
+            case 'a+':
+                $hooks[] = 'read';
+                $hooks[] = 'write';
+                break;
+            case 'w':
+            case 'x':
+            case 'a':
+                $hooks[] = 'write';
+                break;
+            default:
+                $this->logger->error('invalid mode (' . $mode . ') for ' . $path, ['app' => 'core']);
+        }
+
+        if ($mode !== 'r' && $mode !== 'w') {
+            $this->logger->info('Trying to open a file with a mode other than "r" or "w" can cause severe performance issues with some backends', ['app' => 'core']);
+        }
+
+        $handle = $this->basicOperation('fopen', $path, $hooks, $mode);
+        if (!is_resource($handle) && $mode === 'r') {
+            // trying to read a file that isn't on disk, check if the cache is out of sync and rescan if needed
+            $mount = $this->getMount($path);
+            $internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
+            $storage = $mount->getStorage();
+            if ($storage->getCache()->inCache($internalPath) && !$storage->file_exists($path)) {
+                $this->writeUpdate($storage, $internalPath);
+            }
+        }
+        return $handle;
+    }
+
+    /**
+     * @param string $path
+     * @throws InvalidPathException
+     */
+    public function toTmpFile($path): string|false {
+        $this->assertPathLength($path);
+        if (Filesystem::isValidPath($path)) {
+            $source = $this->fopen($path, 'r');
+            if ($source) {
+                $extension = pathinfo($path, PATHINFO_EXTENSION);
+                $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension);
+                file_put_contents($tmpFile, $source);
+                return $tmpFile;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $tmpFile
+     * @param string $path
+     * @return bool|mixed
+     * @throws InvalidPathException
+     */
+    public function fromTmpFile($tmpFile, $path) {
+        $this->assertPathLength($path);
+        if (Filesystem::isValidPath($path)) {
+            // Get directory that the file is going into
+            $filePath = dirname($path);
+
+            // Create the directories if any
+            if (!$this->file_exists($filePath)) {
+                $result = $this->createParentDirectories($filePath);
+                if ($result === false) {
+                    return false;
+                }
+            }
+
+            $source = fopen($tmpFile, 'r');
+            if ($source) {
+                $result = $this->file_put_contents($path, $source);
+                /**
+                 * $this->file_put_contents() might have already closed
+                 * the resource, so we check it, before trying to close it
+                 * to avoid messages in the error log.
+                 * @psalm-suppress RedundantCondition false-positive
+                 */
+                if (is_resource($source)) {
+                    fclose($source);
+                }
+                unlink($tmpFile);
+                return $result;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+
+    /**
+     * @param string $path
+     * @return mixed
+     * @throws InvalidPathException
+     */
+    public function getMimeType($path) {
+        $this->assertPathLength($path);
+        return $this->basicOperation('getMimeType', $path);
+    }
+
+    /**
+     * @param string $type
+     * @param string $path
+     * @param bool $raw
+     */
+    public function hash($type, $path, $raw = false): string|bool {
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        if (Filesystem::isValidPath($path)) {
+            $path = $this->getRelativePath($absolutePath);
+            if ($path == null) {
+                return false;
+            }
+            if ($this->shouldEmitHooks($path)) {
+                \OC_Hook::emit(
+                    Filesystem::CLASSNAME,
+                    Filesystem::signal_read,
+                    [Filesystem::signal_param_path => $this->getHookPath($path)]
+                );
+            }
+            /** @var Storage|null $storage */
+            [$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
+            if ($storage) {
+                return $storage->hash($type, $internalPath, $raw);
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @param string $path
+     * @return mixed
+     * @throws InvalidPathException
+     */
+    public function free_space($path = '/') {
+        $this->assertPathLength($path);
+        $result = $this->basicOperation('free_space', $path);
+        if ($result === null) {
+            throw new InvalidPathException();
+        }
+        return $result;
+    }
+
+    /**
+     * abstraction layer for basic filesystem functions: wrapper for \OC\Files\Storage\Storage
+     *
+     * @param mixed $extraParam (optional)
+     * @return mixed
+     * @throws LockedException
+     *
+     * This method takes requests for basic filesystem functions (e.g. reading & writing
+     * files), processes hooks and proxies, sanitises paths, and finally passes them on to
+     * \OC\Files\Storage\Storage for delegation to a storage backend for execution
+     */
+    private function basicOperation(string $operation, string $path, array $hooks = [], $extraParam = null) {
+        $postFix = (substr($path, -1) === '/') ? '/' : '';
+        $absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
+        if (Filesystem::isValidPath($path)
+            && !Filesystem::isFileBlacklisted($path)
+        ) {
+            $path = $this->getRelativePath($absolutePath);
+            if ($path == null) {
+                return false;
+            }
+
+            if (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks)) {
+                // always a shared lock during pre-hooks so the hook can read the file
+                $this->lockFile($path, ILockingProvider::LOCK_SHARED);
+            }
+
+            $run = $this->runHooks($hooks, $path);
+            [$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
+            if ($run && $storage) {
+                /** @var Storage $storage */
+                if (in_array('write', $hooks) || in_array('delete', $hooks)) {
+                    try {
+                        $this->changeLock($path, ILockingProvider::LOCK_EXCLUSIVE);
+                    } catch (LockedException $e) {
+                        // release the shared lock we acquired before quitting
+                        $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                        throw $e;
+                    }
+                }
+                try {
+                    if (!is_null($extraParam)) {
+                        $result = $storage->$operation($internalPath, $extraParam);
+                    } else {
+                        $result = $storage->$operation($internalPath);
+                    }
+                } catch (\Exception $e) {
+                    if (in_array('write', $hooks) || in_array('delete', $hooks)) {
+                        $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                    } elseif (in_array('read', $hooks)) {
+                        $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                    }
+                    throw $e;
+                }
+
+                if ($result !== false && in_array('delete', $hooks)) {
+                    $this->removeUpdate($storage, $internalPath);
+                }
+                if ($result !== false && in_array('write', $hooks, true) && $operation !== 'fopen' && $operation !== 'touch') {
+                    $isCreateOperation = $operation === 'mkdir' || ($operation === 'file_put_contents' && in_array('create', $hooks, true));
+                    $sizeDifference = $operation === 'mkdir' ? 0 : $result;
+                    $this->writeUpdate($storage, $internalPath, null, $isCreateOperation ? $sizeDifference : null);
+                }
+                if ($result !== false && in_array('touch', $hooks)) {
+                    $this->writeUpdate($storage, $internalPath, $extraParam, 0);
+                }
+
+                if ((in_array('write', $hooks) || in_array('delete', $hooks)) && ($operation !== 'fopen' || $result === false)) {
+                    $this->changeLock($path, ILockingProvider::LOCK_SHARED);
+                }
+
+                $unlockLater = false;
+                if ($this->lockingEnabled && $operation === 'fopen' && is_resource($result)) {
+                    $unlockLater = true;
+                    // make sure our unlocking callback will still be called if connection is aborted
+                    ignore_user_abort(true);
+                    $result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
+                        if (in_array('write', $hooks)) {
+                            $this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
+                        } elseif (in_array('read', $hooks)) {
+                            $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                        }
+                    });
+                }
+
+                if ($this->shouldEmitHooks($path) && $result !== false) {
+                    if ($operation != 'fopen') { //no post hooks for fopen, the file stream is still open
+                        $this->runHooks($hooks, $path, true);
+                    }
+                }
+
+                if (!$unlockLater
+                    && (in_array('write', $hooks) || in_array('delete', $hooks) || in_array('read', $hooks))
+                ) {
+                    $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+                }
+                return $result;
+            } else {
+                $this->unlockFile($path, ILockingProvider::LOCK_SHARED);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * get the path relative to the default root for hook usage
+     *
+     * @param string $path
+     * @return ?string
+     */
+    private function getHookPath($path): ?string {
+        $view = Filesystem::getView();
+        if (!$view) {
+            return $path;
+        }
+        return $view->getRelativePath($this->getAbsolutePath($path));
+    }
+
+    private function shouldEmitHooks(string $path = ''): bool {
+        if ($path && Cache\Scanner::isPartialFile($path)) {
+            return false;
+        }
+        if (!Filesystem::$loaded) {
+            return false;
+        }
+        $defaultRoot = Filesystem::getRoot();
+        if ($defaultRoot === null) {
+            return false;
+        }
+        if ($this->fakeRoot === $defaultRoot) {
+            return true;
+        }
+        $fullPath = $this->getAbsolutePath($path);
+
+        if ($fullPath === $defaultRoot) {
+            return true;
+        }
+
+        return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
+    }
+
+    /**
+     * @param string[] $hooks
+     * @param string $path
+     * @param bool $post
+     * @return bool
+     */
+    private function runHooks($hooks, $path, $post = false) {
+        $relativePath = $path;
+        $path = $this->getHookPath($path);
+        $prefix = $post ? 'post_' : '';
+        $run = true;
+        if ($this->shouldEmitHooks($relativePath)) {
+            foreach ($hooks as $hook) {
+                if ($hook != 'read') {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        $prefix . $hook,
+                        [
+                            Filesystem::signal_param_run => &$run,
+                            Filesystem::signal_param_path => $path
+                        ]
+                    );
+                } elseif (!$post) {
+                    \OC_Hook::emit(
+                        Filesystem::CLASSNAME,
+                        $prefix . $hook,
+                        [
+                            Filesystem::signal_param_path => $path
+                        ]
+                    );
+                }
+            }
+        }
+        return $run;
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public function hasUpdated($path, $time) {
+        return $this->basicOperation('hasUpdated', $path, [], $time);
+    }
+
+    /**
+     * @param string $ownerId
+     * @return IUser
+     */
+    private function getUserObjectForOwner(string $ownerId) {
+        return new LazyUser($ownerId, $this->userManager);
+    }
+
+    /**
+     * Get file info from cache
+     *
+     * If the file is not in cached it will be scanned
+     * If the file has changed on storage the cache will be updated
+     *
+     * @param Storage $storage
+     * @param string $internalPath
+     * @param string $relativePath
+     * @return ICacheEntry|bool
+     */
+    private function getCacheEntry($storage, $internalPath, $relativePath) {
+        $cache = $storage->getCache($internalPath);
+        $data = $cache->get($internalPath);
+        $watcher = $storage->getWatcher($internalPath);
+
+        try {
+            // if the file is not in the cache or needs to be updated, trigger the scanner and reload the data
+            if (!$data || (isset($data['size']) && $data['size'] === -1)) {
+                if (!$storage->file_exists($internalPath)) {
+                    return false;
+                }
+                // don't need to get a lock here since the scanner does it's own locking
+                $scanner = $storage->getScanner($internalPath);
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+                $data = $cache->get($internalPath);
+            } elseif (!Cache\Scanner::isPartialFile($internalPath) && $watcher->needsUpdate($internalPath, $data)) {
+                $this->lockFile($relativePath, ILockingProvider::LOCK_SHARED);
+                $watcher->update($internalPath, $data);
+                $storage->getPropagator()->propagateChange($internalPath, time());
+                $data = $cache->get($internalPath);
+                $this->unlockFile($relativePath, ILockingProvider::LOCK_SHARED);
+            }
+        } catch (LockedException $e) {
+            // if the file is locked we just use the old cache info
+        }
+
+        return $data;
+    }
+
+    /**
+     * get the filesystem info
+     *
+     * @param string $path
+     * @param bool|string $includeMountPoints true to add mountpoint sizes,
+     *                                        'ext' to add only ext storage mount point sizes. Defaults to true.
+     * @return \OC\Files\FileInfo|false False if file does not exist
+     */
+    public function getFileInfo($path, $includeMountPoints = true) {
+        $this->assertPathLength($path);
+        if (!Filesystem::isValidPath($path)) {
+            return false;
+        }
+        $relativePath = $path;
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+
+        $mount = Filesystem::getMountManager()->find($path);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($path);
+        if ($storage) {
+            $data = $this->getCacheEntry($storage, $internalPath, $relativePath);
+
+            if (!$data instanceof ICacheEntry) {
+                if (Cache\Scanner::isPartialFile($relativePath)) {
+                    return $this->getPartFileInfo($relativePath);
+                }
+
+                return false;
+            }
+
+            if ($mount instanceof MoveableMount && $internalPath === '') {
+                $data['permissions'] |= \OCP\Constants::PERMISSION_DELETE;
+            }
+            if ($internalPath === '' && $data['name']) {
+                $data['name'] = basename($path);
+            }
+
+            $ownerId = $storage->getOwner($internalPath);
+            $owner = null;
+            if ($ownerId !== false) {
+                // ownerId might be null if files are accessed with an access token without file system access
+                $owner = $this->getUserObjectForOwner($ownerId);
+            }
+            $info = new FileInfo($path, $storage, $internalPath, $data, $mount, $owner);
+
+            if (isset($data['fileid'])) {
+                if ($includeMountPoints && $data['mimetype'] === 'httpd/unix-directory') {
+                    //add the sizes of other mount points to the folder
+                    $extOnly = ($includeMountPoints === 'ext');
+                    $this->addSubMounts($info, $extOnly);
+                }
+            }
+
+            return $info;
+        } else {
+            $this->logger->warning('Storage not valid for mountpoint: ' . $mount->getMountPoint(), ['app' => 'core']);
+        }
+
+        return false;
+    }
+
+    /**
+     * Extend a FileInfo that was previously requested with `$includeMountPoints = false` to include the sub mounts
+     */
+    public function addSubMounts(FileInfo $info, $extOnly = false): void {
+        $mounts = Filesystem::getMountManager()->findIn($info->getPath());
+        $info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
+            return !($extOnly && $mount instanceof SharedMount);
+        }));
+    }
+
+    /**
+     * get the content of a directory
+     *
+     * @param string $directory path under datadirectory
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
+     * @return FileInfo[]
+     */
+    public function getDirectoryContent($directory, $mimetype_filter = '', ?\OCP\Files\FileInfo $directoryInfo = null) {
+        $this->assertPathLength($directory);
+        if (!Filesystem::isValidPath($directory)) {
+            return [];
+        }
+
+        $path = $this->getAbsolutePath($directory);
+        $path = Filesystem::normalizePath($path);
+        $mount = $this->getMount($directory);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($path);
+        if (!$storage) {
+            return [];
+        }
+
+        $cache = $storage->getCache($internalPath);
+        $user = \OC_User::getUser();
+
+        if (!$directoryInfo) {
+            $data = $this->getCacheEntry($storage, $internalPath, $directory);
+            if (!$data instanceof ICacheEntry || !isset($data['fileid'])) {
+                return [];
+            }
+        } else {
+            $data = $directoryInfo;
+        }
+
+        if (!($data->getPermissions() & Constants::PERMISSION_READ)) {
+            return [];
+        }
+
+        $folderId = $data->getId();
+        $contents = $cache->getFolderContentsById($folderId); //TODO: mimetype_filter
+
+        $sharingDisabled = \OCP\Util::isSharingDisabledForUser();
+
+        $fileNames = array_map(function (ICacheEntry $content) {
+            return $content->getName();
+        }, $contents);
+        /**
+         * @var \OC\Files\FileInfo[] $fileInfos
+         */
+        $fileInfos = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
+            if ($sharingDisabled) {
+                $content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
+            }
+            $ownerId = $storage->getOwner($content['path']);
+            if ($ownerId !== false) {
+                $owner = $this->getUserObjectForOwner($ownerId);
+            } else {
+                $owner = null;
+            }
+            return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
+        }, $contents);
+        $files = array_combine($fileNames, $fileInfos);
+
+        //add a folder for any mountpoint in this directory and add the sizes of other mountpoints to the folders
+        $mounts = Filesystem::getMountManager()->findIn($path);
+
+        // make sure nested mounts are sorted after their parent mounts
+        // otherwise doesn't propagate the etag across storage boundaries correctly
+        usort($mounts, function (IMountPoint $a, IMountPoint $b) {
+            return $a->getMountPoint() <=> $b->getMountPoint();
+        });
+
+        $dirLength = strlen($path);
+        foreach ($mounts as $mount) {
+            $mountPoint = $mount->getMountPoint();
+            $subStorage = $mount->getStorage();
+            if ($subStorage) {
+                $subCache = $subStorage->getCache('');
+
+                $rootEntry = $subCache->get('');
+                if (!$rootEntry) {
+                    $subScanner = $subStorage->getScanner();
+                    try {
+                        $subScanner->scanFile('');
+                    } catch (\OCP\Files\StorageNotAvailableException $e) {
+                        continue;
+                    } catch (\OCP\Files\StorageInvalidException $e) {
+                        continue;
+                    } catch (\Exception $e) {
+                        // sometimes when the storage is not available it can be any exception
+                        $this->logger->error('Exception while scanning storage "' . $subStorage->getId() . '"', [
+                            'exception' => $e,
+                            'app' => 'core',
+                        ]);
+                        continue;
+                    }
+                    $rootEntry = $subCache->get('');
+                }
+
+                if ($rootEntry && ($rootEntry->getPermissions() & Constants::PERMISSION_READ)) {
+                    $relativePath = trim(substr($mountPoint, $dirLength), '/');
+                    if ($pos = strpos($relativePath, '/')) {
+                        //mountpoint inside subfolder add size to the correct folder
+                        $entryName = substr($relativePath, 0, $pos);
+
+                        // Create parent folders if the mountpoint is inside a subfolder that doesn't exist yet
+                        if (!isset($files[$entryName])) {
+                            try {
+                                [$storage, ] = $this->resolvePath($path . '/' . $entryName);
+                                // make sure we can create the mountpoint folder, even if the user has a quota of 0
+                                if ($storage->instanceOfStorage(Quota::class)) {
+                                    $storage->enableQuota(false);
+                                }
+
+                                if ($this->mkdir($path . '/' . $entryName) !== false) {
+                                    $info = $this->getFileInfo($path . '/' . $entryName);
+                                    if ($info !== false) {
+                                        $files[$entryName] = $info;
+                                    }
+                                }
+
+                                if ($storage->instanceOfStorage(Quota::class)) {
+                                    $storage->enableQuota(true);
+                                }
+                            } catch (\Exception $e) {
+                                // Creating the parent folder might not be possible, for example due to a lack of permissions.
+                                $this->logger->debug('Failed to create non-existent parent', ['exception' => $e, 'path' => $path . '/' . $entryName]);
+                            }
+                        }
+
+                        if (isset($files[$entryName])) {
+                            $files[$entryName]->addSubEntry($rootEntry, $mountPoint);
+                        }
+                    } else { //mountpoint in this folder, add an entry for it
+                        $rootEntry['name'] = $relativePath;
+                        $rootEntry['type'] = $rootEntry['mimetype'] === 'httpd/unix-directory' ? 'dir' : 'file';
+                        $permissions = $rootEntry['permissions'];
+                        // do not allow renaming/deleting the mount point if they are not shared files/folders
+                        // for shared files/folders we use the permissions given by the owner
+                        if ($mount instanceof MoveableMount) {
+                            $rootEntry['permissions'] = $permissions | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
+                        } else {
+                            $rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
+                        }
+
+                        $rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
+
+                        // if sharing was disabled for the user we remove the share permissions
+                        if ($sharingDisabled) {
+                            $rootEntry['permissions'] = $rootEntry['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
+                        }
+
+                        $ownerId = $subStorage->getOwner('');
+                        if ($ownerId !== false) {
+                            $owner = $this->getUserObjectForOwner($ownerId);
+                        } else {
+                            $owner = null;
+                        }
+                        $files[$rootEntry->getName()] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
+                    }
+                }
+            }
+        }
+
+        if ($mimetype_filter) {
+            $files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
+                if (strpos($mimetype_filter, '/')) {
+                    return $file->getMimetype() === $mimetype_filter;
+                } else {
+                    return $file->getMimePart() === $mimetype_filter;
+                }
+            });
+        }
+
+        return array_values($files);
+    }
+
+    /**
+     * change file metadata
+     *
+     * @param string $path
+     * @param array|\OCP\Files\FileInfo $data
+     * @return int
+     *
+     * returns the fileid of the updated file
+     */
+    public function putFileInfo($path, $data) {
+        $this->assertPathLength($path);
+        if ($data instanceof FileInfo) {
+            $data = $data->getData();
+        }
+        $path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+        /**
+         * @var Storage $storage
+         * @var string $internalPath
+         */
+        [$storage, $internalPath] = Filesystem::resolvePath($path);
+        if ($storage) {
+            $cache = $storage->getCache($path);
+
+            if (!$cache->inCache($internalPath)) {
+                $scanner = $storage->getScanner($internalPath);
+                $scanner->scan($internalPath, Cache\Scanner::SCAN_SHALLOW);
+            }
+
+            return $cache->put($internalPath, $data);
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string $query
+     * @return FileInfo[]
+     */
+    public function search($query) {
+        return $this->searchCommon('search', ['%' . $query . '%']);
+    }
+
+    /**
+     * search for files with the name matching $query
+     *
+     * @param string $query
+     * @return FileInfo[]
+     */
+    public function searchRaw($query) {
+        return $this->searchCommon('search', [$query]);
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return FileInfo[]
+     */
+    public function searchByMime($mimetype) {
+        return $this->searchCommon('searchByMime', [$mimetype]);
+    }
+
+    /**
+     * search for files by tag
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return FileInfo[]
+     */
+    public function searchByTag($tag, $userId) {
+        return $this->searchCommon('searchByTag', [$tag, $userId]);
+    }
+
+    /**
+     * @param string $method cache method
+     * @param array $args
+     * @return FileInfo[]
+     */
+    private function searchCommon($method, $args) {
+        $files = [];
+        $rootLength = strlen($this->fakeRoot);
+
+        $mount = $this->getMount('');
+        $mountPoint = $mount->getMountPoint();
+        $storage = $mount->getStorage();
+        $userManager = \OC::$server->getUserManager();
+        if ($storage) {
+            $cache = $storage->getCache('');
+
+            $results = call_user_func_array([$cache, $method], $args);
+            foreach ($results as $result) {
+                if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
+                    $internalPath = $result['path'];
+                    $path = $mountPoint . $result['path'];
+                    $result['path'] = substr($mountPoint . $result['path'], $rootLength);
+                    $ownerId = $storage->getOwner($internalPath);
+                    if ($ownerId !== false) {
+                        $owner = $userManager->get($ownerId);
+                    } else {
+                        $owner = null;
+                    }
+                    $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
+                }
+            }
+
+            $mounts = Filesystem::getMountManager()->findIn($this->fakeRoot);
+            foreach ($mounts as $mount) {
+                $mountPoint = $mount->getMountPoint();
+                $storage = $mount->getStorage();
+                if ($storage) {
+                    $cache = $storage->getCache('');
+
+                    $relativeMountPoint = substr($mountPoint, $rootLength);
+                    $results = call_user_func_array([$cache, $method], $args);
+                    if ($results) {
+                        foreach ($results as $result) {
+                            $internalPath = $result['path'];
+                            $result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
+                            $path = rtrim($mountPoint . $internalPath, '/');
+                            $ownerId = $storage->getOwner($internalPath);
+                            if ($ownerId !== false) {
+                                $owner = $userManager->get($ownerId);
+                            } else {
+                                $owner = null;
+                            }
+                            $files[] = new FileInfo($path, $storage, $internalPath, $result, $mount, $owner);
+                        }
+                    }
+                }
+            }
+        }
+        return $files;
+    }
+
+    /**
+     * Get the owner for a file or folder
+     *
+     * @throws NotFoundException
+     */
+    public function getOwner(string $path): string {
+        $info = $this->getFileInfo($path);
+        if (!$info) {
+            throw new NotFoundException($path . ' not found while trying to get owner');
+        }
+
+        if ($info->getOwner() === null) {
+            throw new NotFoundException($path . ' has no owner');
+        }
+
+        return $info->getOwner()->getUID();
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string|false
+     */
+    public function getETag($path) {
+        [$storage, $internalPath] = $this->resolvePath($path);
+        if ($storage) {
+            return $storage->getETag($internalPath);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Get the path of a file by id, relative to the view
+     *
+     * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
+     *
+     * @param int $id
+     * @param int|null $storageId
+     * @return string
+     * @throws NotFoundException
+     */
+    public function getPath($id, ?int $storageId = null): string {
+        $id = (int)$id;
+        $rootFolder = Server::get(Files\IRootFolder::class);
+
+        $node = $rootFolder->getFirstNodeByIdInPath($id, $this->getRoot());
+        if ($node) {
+            if ($storageId === null || $storageId === $node->getStorage()->getCache()->getNumericStorageId()) {
+                return $this->getRelativePath($node->getPath()) ?? '';
+            }
+        } else {
+            throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
+        }
+
+        foreach ($rootFolder->getByIdInPath($id, $this->getRoot()) as $node) {
+            if ($storageId === $node->getStorage()->getCache()->getNumericStorageId()) {
+                return $this->getRelativePath($node->getPath()) ?? '';
+            }
+        }
+
+        throw new NotFoundException(sprintf('File with id "%s" has not been found.', $id));
+    }
+
+    /**
+     * @param string $path
+     * @throws InvalidPathException
+     */
+    private function assertPathLength($path): void {
+        $maxLen = min(PHP_MAXPATHLEN, 4000);
+        // Check for the string length - performed using isset() instead of strlen()
+        // because isset() is about 5x-40x faster.
+        if (isset($path[$maxLen])) {
+            $pathLen = strlen($path);
+            throw new InvalidPathException("Path length($pathLen) exceeds max path length($maxLen): $path");
+        }
+    }
+
+    /**
+     * check if it is allowed to move a mount point to a given target.
+     * It is not allowed to move a mount point into a different mount point or
+     * into an already shared folder
+     */
+    private function targetIsNotShared(string $user, string $targetPath): bool {
+        $providers = [
+            IShare::TYPE_USER,
+            IShare::TYPE_GROUP,
+            IShare::TYPE_EMAIL,
+            IShare::TYPE_CIRCLE,
+            IShare::TYPE_ROOM,
+            IShare::TYPE_DECK,
+            IShare::TYPE_SCIENCEMESH
+        ];
+        $shareManager = Server::get(IManager::class);
+        /** @var IShare[] $shares */
+        $shares = array_merge(...array_map(function (int $type) use ($shareManager, $user) {
+            return $shareManager->getSharesBy($user, $type);
+        }, $providers));
+
+        foreach ($shares as $share) {
+            $sharedPath = $share->getNode()->getPath();
+            if ($targetPath === $sharedPath || str_starts_with($targetPath, $sharedPath . '/')) {
+                $this->logger->debug(
+                    'It is not allowed to move one mount point into a shared folder',
+                    ['app' => 'files']);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Get a fileinfo object for files that are ignored in the cache (part files)
+     */
+    private function getPartFileInfo(string $path): \OC\Files\FileInfo {
+        $mount = $this->getMount($path);
+        $storage = $mount->getStorage();
+        $internalPath = $mount->getInternalPath($this->getAbsolutePath($path));
+        $ownerId = $storage->getOwner($internalPath);
+        if ($ownerId !== false) {
+            $owner = Server::get(IUserManager::class)->get($ownerId);
+        } else {
+            $owner = null;
+        }
+        return new FileInfo(
+            $this->getAbsolutePath($path),
+            $storage,
+            $internalPath,
+            [
+                'fileid' => null,
+                'mimetype' => $storage->getMimeType($internalPath),
+                'name' => basename($path),
+                'etag' => null,
+                'size' => $storage->filesize($internalPath),
+                'mtime' => $storage->filemtime($internalPath),
+                'encrypted' => false,
+                'permissions' => \OCP\Constants::PERMISSION_ALL
+            ],
+            $mount,
+            $owner
+        );
+    }
+
+    /**
+     * @param string $path
+     * @param string $fileName
+     * @param bool $readonly Check only if the path is allowed for read-only access
+     * @throws InvalidPathException
+     */
+    public function verifyPath($path, $fileName, $readonly = false): void {
+        // All of the view's functions disallow '..' in the path so we can short cut if the path is invalid
+        if (!Filesystem::isValidPath($path ?: '/')) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($l->t('Path contains invalid segments'));
+        }
+
+        // Short cut for read-only validation
+        if ($readonly) {
+            $validator = Server::get(FilenameValidator::class);
+            if ($validator->isForbidden($fileName)) {
+                $l = \OCP\Util::getL10N('lib');
+                throw new InvalidPathException($l->t('Filename is a reserved word'));
+            }
+            return;
+        }
+
+        try {
+            /** @type \OCP\Files\Storage $storage */
+            [$storage, $internalPath] = $this->resolvePath($path);
+            $storage->verifyPath($internalPath, $fileName);
+        } catch (ReservedWordException $ex) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($ex->getMessage() ?: $l->t('Filename is a reserved word'));
+        } catch (InvalidCharacterInPathException $ex) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($ex->getMessage() ?: $l->t('Filename contains at least one invalid character'));
+        } catch (FileNameTooLongException $ex) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($l->t('Filename is too long'));
+        } catch (InvalidDirectoryException $ex) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($l->t('Dot files are not allowed'));
+        } catch (EmptyFileNameException $ex) {
+            $l = \OCP\Util::getL10N('lib');
+            throw new InvalidPathException($l->t('Empty filename is not allowed'));
+        }
+    }
+
+    /**
+     * get all parent folders of $path
+     *
+     * @param string $path
+     * @return string[]
+     */
+    private function getParents($path) {
+        $path = trim($path, '/');
+        if (!$path) {
+            return [];
+        }
+
+        $parts = explode('/', $path);
+
+        // remove the single file
+        array_pop($parts);
+        $result = ['/'];
+        $resultPath = '';
+        foreach ($parts as $part) {
+            if ($part) {
+                $resultPath .= '/' . $part;
+                $result[] = $resultPath;
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Returns the mount point for which to lock
+     *
+     * @param string $absolutePath absolute path
+     * @param bool $useParentMount true to return parent mount instead of whatever
+     *                             is mounted directly on the given path, false otherwise
+     * @return IMountPoint mount point for which to apply locks
+     */
+    private function getMountForLock(string $absolutePath, bool $useParentMount = false): IMountPoint {
+        $mount = Filesystem::getMountManager()->find($absolutePath);
+
+        if ($useParentMount) {
+            // find out if something is mounted directly on the path
+            $internalPath = $mount->getInternalPath($absolutePath);
+            if ($internalPath === '') {
+                // resolve the parent mount instead
+                $mount = Filesystem::getMountManager()->find(dirname($absolutePath));
+            }
+        }
+
+        return $mount;
+    }
+
+    /**
+     * Lock the given path
+     *
+     * @param string $path the path of the file to lock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws LockedException if the path is already locked
+     */
+    private function lockPath($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        try {
+            $storage = $mount->getStorage();
+            if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                $storage->acquireLock(
+                    $mount->getInternalPath($absolutePath),
+                    $type,
+                    $this->lockingProvider
+                );
+            }
+        } catch (LockedException $e) {
+            // rethrow with the human-readable path
+            throw new LockedException(
+                $path,
+                $e,
+                $e->getExistingLock()
+            );
+        }
+
+        return true;
+    }
+
+    /**
+     * Change the lock type
+     *
+     * @param string $path the path of the file to lock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws LockedException if the path is already locked
+     */
+    public function changeLock($path, $type, $lockMountPoint = false) {
+        $path = Filesystem::normalizePath($path);
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        try {
+            $storage = $mount->getStorage();
+            if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+                $storage->changeLock(
+                    $mount->getInternalPath($absolutePath),
+                    $type,
+                    $this->lockingProvider
+                );
+            }
+        } catch (LockedException $e) {
+            // rethrow with the a human-readable path
+            throw new LockedException(
+                $path,
+                $e,
+                $e->getExistingLock()
+            );
+        }
+
+        return true;
+    }
+
+    /**
+     * Unlock the given path
+     *
+     * @param string $path the path of the file to unlock, relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws LockedException
+     */
+    private function unlockPath($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $mount = $this->getMountForLock($absolutePath, $lockMountPoint);
+        $storage = $mount->getStorage();
+        if ($storage && $storage->instanceOfStorage('\OCP\Files\Storage\ILockingStorage')) {
+            $storage->releaseLock(
+                $mount->getInternalPath($absolutePath),
+                $type,
+                $this->lockingProvider
+            );
+        }
+
+        return true;
+    }
+
+    /**
+     * Lock a path and all its parents up to the root of the view
+     *
+     * @param string $path the path of the file to lock relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws LockedException
+     */
+    public function lockFile($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $this->lockPath($path, $type, $lockMountPoint);
+
+        $parents = $this->getParents($path);
+        foreach ($parents as $parent) {
+            $this->lockPath($parent, ILockingProvider::LOCK_SHARED);
+        }
+
+        return true;
+    }
+
+    /**
+     * Unlock a path and all its parents up to the root of the view
+     *
+     * @param string $path the path of the file to lock relative to the view
+     * @param int $type \OCP\Lock\ILockingProvider::LOCK_SHARED or \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE
+     * @param bool $lockMountPoint true to lock the mount point, false to lock the attached mount/storage
+     *
+     * @return bool False if the path is excluded from locking, true otherwise
+     * @throws LockedException
+     */
+    public function unlockFile($path, $type, $lockMountPoint = false) {
+        $absolutePath = $this->getAbsolutePath($path);
+        $absolutePath = Filesystem::normalizePath($absolutePath);
+        if (!$this->shouldLockFile($absolutePath)) {
+            return false;
+        }
+
+        $this->unlockPath($path, $type, $lockMountPoint);
+
+        $parents = $this->getParents($path);
+        foreach ($parents as $parent) {
+            $this->unlockPath($parent, ILockingProvider::LOCK_SHARED);
+        }
+
+        return true;
+    }
+
+    /**
+     * Only lock files in data/user/files/
+     *
+     * @param string $path Absolute path to the file/folder we try to (un)lock
+     * @return bool
+     */
+    protected function shouldLockFile($path) {
+        $path = Filesystem::normalizePath($path);
+
+        $pathSegments = explode('/', $path);
+        if (isset($pathSegments[2])) {
+            // E.g.: /username/files/path-to-file
+            return ($pathSegments[2] === 'files') && (count($pathSegments) > 3);
+        }
+
+        return !str_starts_with($path, '/appdata_');
+    }
+
+    /**
+     * Shortens the given absolute path to be relative to
+     * "$user/files".
+     *
+     * @param string $absolutePath absolute path which is under "files"
+     *
+     * @return string path relative to "files" with trimmed slashes or null
+     *                if the path was NOT relative to files
+     *
+     * @throws \InvalidArgumentException if the given path was not under "files"
+     * @since 8.1.0
+     */
+    public function getPathRelativeToFiles($absolutePath) {
+        $path = Filesystem::normalizePath($absolutePath);
+        $parts = explode('/', trim($path, '/'), 3);
+        // "$user", "files", "path/to/dir"
+        if (!isset($parts[1]) || $parts[1] !== 'files') {
+            $this->logger->error(
+                '$absolutePath must be relative to "files", value is "{absolutePath}"',
+                [
+                    'absolutePath' => $absolutePath,
+                ]
+            );
+            throw new \InvalidArgumentException('$absolutePath must be relative to "files"');
+        }
+        if (isset($parts[2])) {
+            return $parts[2];
+        }
+        return '';
+    }
+
+    /**
+     * @param string $filename
+     * @return array
+     * @throws \OC\User\NoUserException
+     * @throws NotFoundException
+     */
+    public function getUidAndFilename($filename) {
+        $info = $this->getFileInfo($filename);
+        if (!$info instanceof \OCP\Files\FileInfo) {
+            throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
+        }
+        $uid = $info->getOwner()->getUID();
+        if ($uid != \OC_User::getUser()) {
+            Filesystem::initMountPoints($uid);
+            $ownerView = new View('/' . $uid . '/files');
+            try {
+                $filename = $ownerView->getPath($info['fileid']);
+            } catch (NotFoundException $e) {
+                throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
+            }
+        }
+        return [$uid, $filename];
+    }
+
+    /**
+     * Creates parent non-existing folders
+     *
+     * @param string $filePath
+     * @return bool
+     */
+    private function createParentDirectories($filePath) {
+        $directoryParts = explode('/', $filePath);
+        $directoryParts = array_filter($directoryParts);
+        foreach ($directoryParts as $key => $part) {
+            $currentPathElements = array_slice($directoryParts, 0, $key);
+            $currentPath = '/' . implode('/', $currentPathElements);
+            if ($this->is_file($currentPath)) {
+                return false;
+            }
+            if (!$this->file_exists($currentPath)) {
+                $this->mkdir($currentPath);
+            }
+        }
+
+        return true;
+    }
 }

Spacing +49 added lines, -49 removed lines

@@ -94,9 +94,9 @@ 
 			$path = '/';
 		}
 		if ($path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
-		return $this->fakeRoot . $path;
+		return $this->fakeRoot.$path;
 	}
 
 	/**
@@ -107,7 +107,7 @@ 
 	public function chroot($fakeRoot): void {
 		if (!$fakeRoot == '') {
 			if ($fakeRoot[0] !== '/') {
-				$fakeRoot = '/' . $fakeRoot;
+				$fakeRoot = '/'.$fakeRoot;
 			}
 		}
 		$this->fakeRoot = $fakeRoot;
@@ -136,7 +136,7 @@ 
 		}
 
 		// missing slashes can cause wrong matches!
-		$root = rtrim($this->fakeRoot, '/') . '/';
+		$root = rtrim($this->fakeRoot, '/').'/';
 
 		if (!str_starts_with($path, $root)) {
 			return null;
@@ -193,7 +193,7 @@ 
 	 *
 	 * @param string $path
 	 */
-	public function getLocalFile($path): string|false {
+	public function getLocalFile($path): string | false {
 		$parent = substr($path, 0, strrpos($path, '/') ?: 0);
 		$path = $this->getAbsolutePath($path);
 		[$storage, $internalPath] = Filesystem::resolvePath($path);
@@ -223,7 +223,7 @@ 
 		if ($mount instanceof MoveableMount) {
 			// cut of /user/files to get the relative path to data/user/files
 			$pathParts = explode('/', $path, 4);
-			$relPath = '/' . $pathParts[3];
+			$relPath = '/'.$pathParts[3];
 			$this->lockFile($relPath, ILockingProvider::LOCK_SHARED, true);
 			\OC_Hook::emit(
 				Filesystem::CLASSNAME, 'umount',
@@ -667,7 +667,7 @@ 
 		}
 		$postFix = (substr($path, -1) === '/') ? '/' : '';
 		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
-		$mount = Filesystem::getMountManager()->find($absolutePath . $postFix);
+		$mount = Filesystem::getMountManager()->find($absolutePath.$postFix);
 		if ($mount->getInternalPath($absolutePath) === '') {
 			return $this->removeMount($mount, $absolutePath);
 		}
@@ -710,7 +710,7 @@ 
 		$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
 		$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
 
-		if (str_starts_with($absolutePath2, $absolutePath1 . '/')) {
+		if (str_starts_with($absolutePath2, $absolutePath1.'/')) {
 			throw new ForbiddenException('Moving a folder into a child folder is forbidden', false);
 		}
 
@@ -1028,7 +1028,7 @@ 
 				$hooks[] = 'write';
 				break;
 			default:
-				$this->logger->error('invalid mode (' . $mode . ') for ' . $path, ['app' => 'core']);
+				$this->logger->error('invalid mode ('.$mode.') for '.$path, ['app' => 'core']);
 		}
 
 		if ($mode !== 'r' && $mode !== 'w') {
@@ -1052,7 +1052,7 @@ 
 	 * @param string $path
 	 * @throws InvalidPathException
 	 */
-	public function toTmpFile($path): string|false {
+	public function toTmpFile($path): string | false {
 		$this->assertPathLength($path);
 		if (Filesystem::isValidPath($path)) {
 			$source = $this->fopen($path, 'r');
@@ -1127,7 +1127,7 @@ 
 	 * @param string $path
 	 * @param bool $raw
 	 */
-	public function hash($type, $path, $raw = false): string|bool {
+	public function hash($type, $path, $raw = false): string | bool {
 		$postFix = (substr($path, -1) === '/') ? '/' : '';
 		$absolutePath = Filesystem::normalizePath($this->getAbsolutePath($path));
 		if (Filesystem::isValidPath($path)) {
@@ -1143,7 +1143,7 @@ 
 				);
 			}
 			/** @var Storage|null $storage */
-			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
+			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath.$postFix);
 			if ($storage) {
 				return $storage->hash($type, $internalPath, $raw);
 			}
@@ -1193,7 +1193,7 @@ 
 			}
 
 			$run = $this->runHooks($hooks, $path);
-			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath . $postFix);
+			[$storage, $internalPath] = Filesystem::resolvePath($absolutePath.$postFix);
 			if ($run && $storage) {
 				/** @var Storage $storage */
 				if (in_array('write', $hooks) || in_array('delete', $hooks)) {
@@ -1241,7 +1241,7 @@ 
 					$unlockLater = true;
 					// make sure our unlocking callback will still be called if connection is aborted
 					ignore_user_abort(true);
-					$result = CallbackWrapper::wrap($result, null, null, function () use ($hooks, $path) {
+					$result = CallbackWrapper::wrap($result, null, null, function() use ($hooks, $path) {
 						if (in_array('write', $hooks)) {
 							$this->unlockFile($path, ILockingProvider::LOCK_EXCLUSIVE);
 						} elseif (in_array('read', $hooks)) {
@@ -1303,7 +1303,7 @@ 
 			return true;
 		}
 
-		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot . '/');
+		return (strlen($fullPath) > strlen($defaultRoot)) && (substr($fullPath, 0, strlen($defaultRoot) + 1) === $defaultRoot.'/');
 	}
 
 	/**
@@ -1322,7 +1322,7 @@ 
 				if ($hook != 'read') {
 					\OC_Hook::emit(
 						Filesystem::CLASSNAME,
-						$prefix . $hook,
+						$prefix.$hook,
 						[
 							Filesystem::signal_param_run => &$run,
 							Filesystem::signal_param_path => $path
@@ -1331,7 +1331,7 @@ 
 				} elseif (!$post) {
 					\OC_Hook::emit(
 						Filesystem::CLASSNAME,
-						$prefix . $hook,
+						$prefix.$hook,
 						[
 							Filesystem::signal_param_path => $path
 						]
@@ -1415,7 +1415,7 @@ 
 			return false;
 		}
 		$relativePath = $path;
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+		$path = Filesystem::normalizePath($this->fakeRoot.'/'.$path);
 
 		$mount = Filesystem::getMountManager()->find($path);
 		$storage = $mount->getStorage();
@@ -1456,7 +1456,7 @@ 
 
 			return $info;
 		} else {
-			$this->logger->warning('Storage not valid for mountpoint: ' . $mount->getMountPoint(), ['app' => 'core']);
+			$this->logger->warning('Storage not valid for mountpoint: '.$mount->getMountPoint(), ['app' => 'core']);
 		}
 
 		return false;
@@ -1467,7 +1467,7 @@ 
 	 */
 	public function addSubMounts(FileInfo $info, $extOnly = false): void {
 		$mounts = Filesystem::getMountManager()->findIn($info->getPath());
-		$info->setSubMounts(array_filter($mounts, function (IMountPoint $mount) use ($extOnly) {
+		$info->setSubMounts(array_filter($mounts, function(IMountPoint $mount) use ($extOnly) {
 			return !($extOnly && $mount instanceof SharedMount);
 		}));
 	}
@@ -1515,13 +1515,13 @@ 
 
 		$sharingDisabled = \OCP\Util::isSharingDisabledForUser();
 
-		$fileNames = array_map(function (ICacheEntry $content) {
+		$fileNames = array_map(function(ICacheEntry $content) {
 			return $content->getName();
 		}, $contents);
 		/**
 		 * @var \OC\Files\FileInfo[] $fileInfos
 		 */
-		$fileInfos = array_map(function (ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
+		$fileInfos = array_map(function(ICacheEntry $content) use ($path, $storage, $mount, $sharingDisabled) {
 			if ($sharingDisabled) {
 				$content['permissions'] = $content['permissions'] & ~\OCP\Constants::PERMISSION_SHARE;
 			}
@@ -1531,7 +1531,7 @@ 
 			} else {
 				$owner = null;
 			}
-			return new FileInfo($path . '/' . $content['name'], $storage, $content['path'], $content, $mount, $owner);
+			return new FileInfo($path.'/'.$content['name'], $storage, $content['path'], $content, $mount, $owner);
 		}, $contents);
 		$files = array_combine($fileNames, $fileInfos);
 
@@ -1540,7 +1540,7 @@ 
 
 		// make sure nested mounts are sorted after their parent mounts
 		// otherwise doesn't propagate the etag across storage boundaries correctly
-		usort($mounts, function (IMountPoint $a, IMountPoint $b) {
+		usort($mounts, function(IMountPoint $a, IMountPoint $b) {
 			return $a->getMountPoint() <=> $b->getMountPoint();
 		});
 
@@ -1562,7 +1562,7 @@ 
 						continue;
 					} catch (\Exception $e) {
 						// sometimes when the storage is not available it can be any exception
-						$this->logger->error('Exception while scanning storage "' . $subStorage->getId() . '"', [
+						$this->logger->error('Exception while scanning storage "'.$subStorage->getId().'"', [
 							'exception' => $e,
 							'app' => 'core',
 						]);
@@ -1580,14 +1580,14 @@ 
 						// Create parent folders if the mountpoint is inside a subfolder that doesn't exist yet
 						if (!isset($files[$entryName])) {
 							try {
-								[$storage, ] = $this->resolvePath($path . '/' . $entryName);
+								[$storage, ] = $this->resolvePath($path.'/'.$entryName);
 								// make sure we can create the mountpoint folder, even if the user has a quota of 0
 								if ($storage->instanceOfStorage(Quota::class)) {
 									$storage->enableQuota(false);
 								}
 
-								if ($this->mkdir($path . '/' . $entryName) !== false) {
-									$info = $this->getFileInfo($path . '/' . $entryName);
+								if ($this->mkdir($path.'/'.$entryName) !== false) {
+									$info = $this->getFileInfo($path.'/'.$entryName);
 									if ($info !== false) {
 										$files[$entryName] = $info;
 									}
@@ -1598,7 +1598,7 @@ 
 								}
 							} catch (\Exception $e) {
 								// Creating the parent folder might not be possible, for example due to a lack of permissions.
-								$this->logger->debug('Failed to create non-existent parent', ['exception' => $e, 'path' => $path . '/' . $entryName]);
+								$this->logger->debug('Failed to create non-existent parent', ['exception' => $e, 'path' => $path.'/'.$entryName]);
 							}
 						}
 
@@ -1617,7 +1617,7 @@ 
 							$rootEntry['permissions'] = $permissions & (\OCP\Constants::PERMISSION_ALL - (\OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE));
 						}
 
-						$rootEntry['path'] = substr(Filesystem::normalizePath($path . '/' . $rootEntry['name']), strlen($user) + 2); // full path without /$user/
+						$rootEntry['path'] = substr(Filesystem::normalizePath($path.'/'.$rootEntry['name']), strlen($user) + 2); // full path without /$user/
 
 						// if sharing was disabled for the user we remove the share permissions
 						if ($sharingDisabled) {
@@ -1630,14 +1630,14 @@ 
 						} else {
 							$owner = null;
 						}
-						$files[$rootEntry->getName()] = new FileInfo($path . '/' . $rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
+						$files[$rootEntry->getName()] = new FileInfo($path.'/'.$rootEntry['name'], $subStorage, '', $rootEntry, $mount, $owner);
 					}
 				}
 			}
 		}
 
 		if ($mimetype_filter) {
-			$files = array_filter($files, function (FileInfo $file) use ($mimetype_filter) {
+			$files = array_filter($files, function(FileInfo $file) use ($mimetype_filter) {
 				if (strpos($mimetype_filter, '/')) {
 					return $file->getMimetype() === $mimetype_filter;
 				} else {
@@ -1663,7 +1663,7 @@ 
 		if ($data instanceof FileInfo) {
 			$data = $data->getData();
 		}
-		$path = Filesystem::normalizePath($this->fakeRoot . '/' . $path);
+		$path = Filesystem::normalizePath($this->fakeRoot.'/'.$path);
 		/**
 		 * @var Storage $storage
 		 * @var string $internalPath
@@ -1690,7 +1690,7 @@ 
 	 * @return FileInfo[]
 	 */
 	public function search($query) {
-		return $this->searchCommon('search', ['%' . $query . '%']);
+		return $this->searchCommon('search', ['%'.$query.'%']);
 	}
 
 	/**
@@ -1742,10 +1742,10 @@ 
 
 			$results = call_user_func_array([$cache, $method], $args);
 			foreach ($results as $result) {
-				if (substr($mountPoint . $result['path'], 0, $rootLength + 1) === $this->fakeRoot . '/') {
+				if (substr($mountPoint.$result['path'], 0, $rootLength + 1) === $this->fakeRoot.'/') {
 					$internalPath = $result['path'];
-					$path = $mountPoint . $result['path'];
-					$result['path'] = substr($mountPoint . $result['path'], $rootLength);
+					$path = $mountPoint.$result['path'];
+					$result['path'] = substr($mountPoint.$result['path'], $rootLength);
 					$ownerId = $storage->getOwner($internalPath);
 					if ($ownerId !== false) {
 						$owner = $userManager->get($ownerId);
@@ -1768,8 +1768,8 @@ 
 					if ($results) {
 						foreach ($results as $result) {
 							$internalPath = $result['path'];
-							$result['path'] = rtrim($relativeMountPoint . $result['path'], '/');
-							$path = rtrim($mountPoint . $internalPath, '/');
+							$result['path'] = rtrim($relativeMountPoint.$result['path'], '/');
+							$path = rtrim($mountPoint.$internalPath, '/');
 							$ownerId = $storage->getOwner($internalPath);
 							if ($ownerId !== false) {
 								$owner = $userManager->get($ownerId);
@@ -1793,11 +1793,11 @@ 
 	public function getOwner(string $path): string {
 		$info = $this->getFileInfo($path);
 		if (!$info) {
-			throw new NotFoundException($path . ' not found while trying to get owner');
+			throw new NotFoundException($path.' not found while trying to get owner');
 		}
 
 		if ($info->getOwner() === null) {
-			throw new NotFoundException($path . ' has no owner');
+			throw new NotFoundException($path.' has no owner');
 		}
 
 		return $info->getOwner()->getUID();
@@ -1829,7 +1829,7 @@ 
 	 * @throws NotFoundException
 	 */
 	public function getPath($id, ?int $storageId = null): string {
-		$id = (int)$id;
+		$id = (int) $id;
 		$rootFolder = Server::get(Files\IRootFolder::class);
 
 		$node = $rootFolder->getFirstNodeByIdInPath($id, $this->getRoot());
@@ -1881,13 +1881,13 @@ 
 		];
 		$shareManager = Server::get(IManager::class);
 		/** @var IShare[] $shares */
-		$shares = array_merge(...array_map(function (int $type) use ($shareManager, $user) {
+		$shares = array_merge(...array_map(function(int $type) use ($shareManager, $user) {
 			return $shareManager->getSharesBy($user, $type);
 		}, $providers));
 
 		foreach ($shares as $share) {
 			$sharedPath = $share->getNode()->getPath();
-			if ($targetPath === $sharedPath || str_starts_with($targetPath, $sharedPath . '/')) {
+			if ($targetPath === $sharedPath || str_starts_with($targetPath, $sharedPath.'/')) {
 				$this->logger->debug(
 					'It is not allowed to move one mount point into a shared folder',
 					['app' => 'files']);
@@ -1995,7 +1995,7 @@ 
 		$resultPath = '';
 		foreach ($parts as $part) {
 			if ($part) {
-				$resultPath .= '/' . $part;
+				$resultPath .= '/'.$part;
 				$result[] = $resultPath;
 			}
 		}
@@ -2246,16 +2246,16 @@ 
 	public function getUidAndFilename($filename) {
 		$info = $this->getFileInfo($filename);
 		if (!$info instanceof \OCP\Files\FileInfo) {
-			throw new NotFoundException($this->getAbsolutePath($filename) . ' not found');
+			throw new NotFoundException($this->getAbsolutePath($filename).' not found');
 		}
 		$uid = $info->getOwner()->getUID();
 		if ($uid != \OC_User::getUser()) {
 			Filesystem::initMountPoints($uid);
-			$ownerView = new View('/' . $uid . '/files');
+			$ownerView = new View('/'.$uid.'/files');
 			try {
 				$filename = $ownerView->getPath($info['fileid']);
 			} catch (NotFoundException $e) {
-				throw new NotFoundException('File with id ' . $info['fileid'] . ' not found for user ' . $uid);
+				throw new NotFoundException('File with id '.$info['fileid'].' not found for user '.$uid);
 			}
 		}
 		return [$uid, $filename];
@@ -2272,7 +2272,7 @@ 
 		$directoryParts = array_filter($directoryParts);
 		foreach ($directoryParts as $key => $part) {
 			$currentPathElements = array_slice($directoryParts, 0, $key);
-			$currentPath = '/' . implode('/', $currentPathElements);
+			$currentPath = '/'.implode('/', $currentPathElements);
 			if ($this->is_file($currentPath)) {
 				return false;
 			}

apps/files/lib/Service/OwnershipTransferService.php

Indentation +577 added lines, -577 removed lines

@@ -44,581 +44,581 @@
 
 class OwnershipTransferService {
 
-	public function __construct(
-		private IEncryptionManager $encryptionManager,
-		private IShareManager $shareManager,
-		private IMountManager $mountManager,
-		private IUserMountCache $userMountCache,
-		private IUserManager $userManager,
-		private IFactory $l10nFactory,
-		private IRootFolder $rootFolder,
-	) {
-	}
-
-	/**
-	 * @param IUser $sourceUser
-	 * @param IUser $destinationUser
-	 * @param string $path
-	 *
-	 * @param OutputInterface|null $output
-	 * @param bool $move
-	 * @throws TransferOwnershipException
-	 * @throws NoUserException
-	 */
-	public function transfer(
-		IUser $sourceUser,
-		IUser $destinationUser,
-		string $path,
-		?OutputInterface $output = null,
-		bool $move = false,
-		bool $firstLogin = false,
-		bool $includeExternalStorage = false,
-	): void {
-		$output = $output ?? new NullOutput();
-		$sourceUid = $sourceUser->getUID();
-		$destinationUid = $destinationUser->getUID();
-		$sourcePath = rtrim($sourceUid . '/files/' . $path, '/');
-
-		// If encryption is on we have to ensure the user has logged in before and that all encryption modules are ready
-		if (($this->encryptionManager->isEnabled() && $destinationUser->getLastLogin() === 0)
-			|| !$this->encryptionManager->isReadyForUser($destinationUid)) {
-			throw new TransferOwnershipException('The target user is not ready to accept files. The user has at least to have logged in once.', 2);
-		}
-
-		// setup filesystem
-		// Requesting the user folder will set it up if the user hasn't logged in before
-		// We need a setupFS for the full filesystem setup before as otherwise we will just return
-		// a lazy root folder which does not create the destination users folder
-		\OC_Util::setupFS($sourceUser->getUID());
-		\OC_Util::setupFS($destinationUser->getUID());
-		$this->rootFolder->getUserFolder($sourceUser->getUID());
-		$this->rootFolder->getUserFolder($destinationUser->getUID());
-		Filesystem::initMountPoints($sourceUid);
-		Filesystem::initMountPoints($destinationUid);
-
-		$view = new View();
-
-		if ($move) {
-			$finalTarget = "$destinationUid/files/";
-		} else {
-			$l = $this->l10nFactory->get('files', $this->l10nFactory->getUserLanguage($destinationUser));
-			$date = date('Y-m-d H-i-s');
-
-			$cleanUserName = $this->sanitizeFolderName($sourceUser->getDisplayName()) ?: $sourceUid;
-			$finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$cleanUserName, $date]));
-			try {
-				$view->verifyPath(dirname($finalTarget), basename($finalTarget));
-			} catch (InvalidPathException $e) {
-				$finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$sourceUid, $date]));
-			}
-		}
-
-		if (!($view->is_dir($sourcePath) || $view->is_file($sourcePath))) {
-			throw new TransferOwnershipException("Unknown path provided: $path", 1);
-		}
-
-		if ($move && !$view->is_dir($finalTarget)) {
-			// Initialize storage
-			\OC_Util::setupFS($destinationUser->getUID());
-		}
-
-		if ($move && !$firstLogin && count($view->getDirectoryContent($finalTarget)) > 0) {
-			throw new TransferOwnershipException('Destination path does not exists or is not empty', 1);
-		}
-
-
-		// analyse source folder
-		$this->analyse(
-			$sourceUid,
-			$destinationUid,
-			$sourcePath,
-			$view,
-			$output
-		);
-
-		// collect all the shares
-		$shares = $this->collectUsersShares(
-			$sourceUid,
-			$output,
-			$view,
-			$sourcePath
-		);
-
-		$sourceSize = $view->getFileInfo($sourcePath)->getSize();
-
-		// transfer the files
-		$this->transferFiles(
-			$sourceUid,
-			$sourcePath,
-			$finalTarget,
-			$view,
-			$output,
-			$includeExternalStorage,
-		);
-		$sizeDifference = $sourceSize - $view->getFileInfo($finalTarget)->getSize();
-
-		// transfer the incoming shares
-		$sourceShares = $this->collectIncomingShares(
-			$sourceUid,
-			$output,
-			$sourcePath,
-		);
-		$destinationShares = $this->collectIncomingShares(
-			$destinationUid,
-			$output,
-			null,
-		);
-		$this->transferIncomingShares(
-			$sourceUid,
-			$destinationUid,
-			$sourceShares,
-			$destinationShares,
-			$output,
-			$path,
-			$finalTarget,
-			$move
-		);
-
-		$destinationPath = $finalTarget . '/' . $path;
-		// restore the shares
-		$this->restoreShares(
-			$sourceUid,
-			$destinationUid,
-			$destinationPath,
-			$shares,
-			$output
-		);
-		if ($sizeDifference !== 0) {
-			$output->writeln("Transferred folder have a size difference of: $sizeDifference Bytes which means the transfer may be incomplete. Please check the logs if there was any issue during the transfer operation.");
-		}
-	}
-
-	private function sanitizeFolderName(string $name): string {
-		// Remove some characters which are prone to cause errors
-		$name = str_replace(['\\', '/', ':', '.', '?', '#', '\'', '"'], '-', $name);
-		// Replace multiple dashes with one dash
-		return preg_replace('/-{2,}/s', '-', $name);
-	}
-
-	private function walkFiles(View $view, $path, Closure $callBack) {
-		foreach ($view->getDirectoryContent($path) as $fileInfo) {
-			if (!$callBack($fileInfo)) {
-				return;
-			}
-			if ($fileInfo->getType() === FileInfo::TYPE_FOLDER) {
-				$this->walkFiles($view, $fileInfo->getPath(), $callBack);
-			}
-		}
-	}
-
-	/**
-	 * @param OutputInterface $output
-	 *
-	 * @throws TransferOwnershipException
-	 */
-	protected function analyse(
-		string $sourceUid,
-		string $destinationUid,
-		string $sourcePath,
-		View $view,
-		OutputInterface $output,
-		bool $includeExternalStorage = false,
-	): void {
-		$output->writeln('Validating quota');
-		$sourceFileInfo = $view->getFileInfo($sourcePath, false);
-		if ($sourceFileInfo === false) {
-			throw new TransferOwnershipException("Unknown path provided: $sourcePath", 1);
-		}
-		$size = $sourceFileInfo->getSize(false);
-		$freeSpace = $view->free_space($destinationUid . '/files/');
-		if ($size > $freeSpace && $freeSpace !== FileInfo::SPACE_UNKNOWN) {
-			throw new TransferOwnershipException('Target user does not have enough free space available.', 1);
-		}
-
-		$output->writeln("Analysing files of $sourceUid ...");
-		$progress = new ProgressBar($output);
-		$progress->start();
-
-		if ($this->encryptionManager->isEnabled()) {
-			$masterKeyEnabled = Server::get(Util::class)->isMasterKeyEnabled();
-		} else {
-			$masterKeyEnabled = false;
-		}
-		$encryptedFiles = [];
-		if ($sourceFileInfo->getType() === FileInfo::TYPE_FOLDER) {
-			if ($sourceFileInfo->isEncrypted()) {
-				/* Encrypted folder means e2ee encrypted */
-				$encryptedFiles[] = $sourceFileInfo;
-			} else {
-				$this->walkFiles($view, $sourcePath,
-					function (FileInfo $fileInfo) use ($progress, $masterKeyEnabled, &$encryptedFiles, $includeExternalStorage) {
-						if ($fileInfo->getType() === FileInfo::TYPE_FOLDER) {
-							$mount = $fileInfo->getMountPoint();
-							// only analyze into folders from main storage,
-							if (
-								$mount->getMountProvider() instanceof IHomeMountProvider
-								|| ($includeExternalStorage && $mount->getMountProvider() instanceof ConfigAdapter)
-							) {
-								if ($fileInfo->isEncrypted()) {
-									/* Encrypted folder means e2ee encrypted, we cannot transfer it */
-									$encryptedFiles[] = $fileInfo;
-								}
-								return true;
-							} else {
-								return false;
-							}
-						}
-						$progress->advance();
-						if ($fileInfo->isEncrypted() && !$masterKeyEnabled) {
-							/* Encrypted file means SSE, we can only transfer it if master key is enabled */
-							$encryptedFiles[] = $fileInfo;
-						}
-						return true;
-					});
-			}
-		} elseif ($sourceFileInfo->isEncrypted() && !$masterKeyEnabled) {
-			/* Encrypted file means SSE, we can only transfer it if master key is enabled */
-			$encryptedFiles[] = $sourceFileInfo;
-		}
-		$progress->finish();
-		$output->writeln('');
-
-		// no file is allowed to be encrypted
-		if (!empty($encryptedFiles)) {
-			$output->writeln('<error>Some files are encrypted - please decrypt them first.</error>');
-			foreach ($encryptedFiles as $encryptedFile) {
-				/** @var FileInfo $encryptedFile */
-				$output->writeln('  ' . $encryptedFile->getPath());
-			}
-			throw new TransferOwnershipException('Some files are encrypted - please decrypt them first.', 1);
-		}
-	}
-
-	/**
-	 * @return array<array{share: IShare, suffix: string}>
-	 */
-	private function collectUsersShares(
-		string $sourceUid,
-		OutputInterface $output,
-		View $view,
-		string $path,
-	): array {
-		$output->writeln("Collecting all share information for files and folders of $sourceUid ...");
-
-		$shares = [];
-		$progress = new ProgressBar($output);
-
-		$normalizedPath = Filesystem::normalizePath($path);
-
-		$supportedShareTypes = [
-			IShare::TYPE_GROUP,
-			IShare::TYPE_USER,
-			IShare::TYPE_LINK,
-			IShare::TYPE_REMOTE,
-			IShare::TYPE_ROOM,
-			IShare::TYPE_EMAIL,
-			IShare::TYPE_CIRCLE,
-			IShare::TYPE_DECK,
-			IShare::TYPE_SCIENCEMESH,
-		];
-
-		foreach ($supportedShareTypes as $shareType) {
-			$offset = 0;
-			while (true) {
-				$sharePage = $this->shareManager->getSharesBy($sourceUid, $shareType, null, true, 50, $offset, onlyValid: false);
-				$progress->advance(count($sharePage));
-				if (empty($sharePage)) {
-					break;
-				}
-				if ($path !== "$sourceUid/files") {
-					$sharePage = array_filter($sharePage, function (IShare $share) use ($view, $normalizedPath) {
-						try {
-							$sourceNode = $share->getNode();
-							$relativePath = $view->getRelativePath($sourceNode->getPath());
-
-							return str_starts_with($relativePath . '/', $normalizedPath . '/');
-						} catch (Exception $e) {
-							return false;
-						}
-					});
-				}
-				$shares = array_merge($shares, $sharePage);
-				$offset += 50;
-			}
-		}
-
-		$progress->finish();
-		$output->writeln('');
-
-		return array_values(array_filter(array_map(function (IShare $share) use ($view, $normalizedPath, $output, $sourceUid) {
-			try {
-				$nodePath = $view->getRelativePath($share->getNode()->getPath());
-			} catch (NotFoundException $e) {
-				$output->writeln("<error>Failed to find path for shared file {$share->getNodeId()} for user $sourceUid, skipping</error>");
-				return null;
-			}
-
-			return [
-				'share' => $share,
-				'suffix' => substr(Filesystem::normalizePath($nodePath), strlen($normalizedPath)),
-			];
-		}, $shares)));
-	}
-
-	private function collectIncomingShares(
-		string $sourceUid,
-		OutputInterface $output,
-		?string $path,
-	): array {
-		$output->writeln("Collecting all incoming share information for files and folders of $sourceUid ...");
-
-		$shares = [];
-		$progress = new ProgressBar($output);
-		$normalizedPath = Filesystem::normalizePath($path);
-
-		$offset = 0;
-		while (true) {
-			$sharePage = $this->shareManager->getSharedWith($sourceUid, IShare::TYPE_USER, null, 50, $offset);
-			$progress->advance(count($sharePage));
-			if (empty($sharePage)) {
-				break;
-			}
-
-			if ($path !== null && $path !== "$sourceUid/files") {
-				$sharePage = array_filter($sharePage, static function (IShare $share) use ($sourceUid, $normalizedPath) {
-					try {
-						return str_starts_with(Filesystem::normalizePath($sourceUid . '/files' . $share->getTarget() . '/', false), $normalizedPath . '/');
-					} catch (Exception) {
-						return false;
-					}
-				});
-			}
-
-			foreach ($sharePage as $share) {
-				$shares[$share->getNodeId()] = $share;
-			}
-
-			$offset += 50;
-		}
-
-
-		$progress->finish();
-		$output->writeln('');
-		return $shares;
-	}
-
-	/**
-	 * @throws TransferOwnershipException
-	 */
-	protected function transferFiles(
-		string $sourceUid,
-		string $sourcePath,
-		string $finalTarget,
-		View $view,
-		OutputInterface $output,
-		bool $includeExternalStorage,
-	): void {
-		$output->writeln("Transferring files to $finalTarget ...");
-
-		// This change will help user to transfer the folder specified using --path option.
-		// Else only the content inside folder is transferred which is not correct.
-		if ($sourcePath !== "$sourceUid/files") {
-			$view->mkdir($finalTarget);
-			$finalTarget = $finalTarget . '/' . basename($sourcePath);
-		}
-		$sourceInfo = $view->getFileInfo($sourcePath);
-
-		/// handle the external storages mounted at the root, or the admin specifying an external storage with --path
-		if ($sourceInfo->getInternalPath() === '' && $includeExternalStorage) {
-			$this->moveMountContents($view, $sourcePath, $finalTarget);
-		} else {
-			if ($view->rename($sourcePath, $finalTarget, ['checkSubMounts' => false]) === false) {
-				throw new TransferOwnershipException('Could not transfer files.', 1);
-			}
-		}
-
-		if ($includeExternalStorage) {
-			$nestedMounts = $this->mountManager->findIn($sourcePath);
-			foreach ($nestedMounts as $mount) {
-				if ($mount->getMountProvider() === ConfigAdapter::class) {
-					$relativePath = substr(trim($mount->getMountPoint(), '/'), strlen($sourcePath));
-					$this->moveMountContents($view, $mount->getMountPoint(), $finalTarget . $relativePath);
-				}
-			}
-		}
-
-		if (!is_dir("$sourceUid/files")) {
-			// because the files folder is moved away we need to recreate it
-			$view->mkdir("$sourceUid/files");
-		}
-	}
-
-	private function moveMountContents(View $rootView, string $source, string $target) {
-		if ($rootView->copy($source, $target)) {
-			// just doing `rmdir` on the mountpoint would cause it to try and unmount the storage
-			// we need to empty the contents instead
-			$content = $rootView->getDirectoryContent($source);
-			foreach ($content as $item) {
-				if ($item->getType() === FileInfo::TYPE_FOLDER) {
-					$rootView->rmdir($item->getPath());
-				} else {
-					$rootView->unlink($item->getPath());
-				}
-			}
-		} else {
-			throw new TransferOwnershipException("Could not transfer $source to $target");
-		}
-	}
-
-	/**
-	 * @param string $targetLocation New location of the transfered node
-	 * @param array<array{share: IShare, suffix: string}> $shares previously collected share information
-	 */
-	private function restoreShares(
-		string $sourceUid,
-		string $destinationUid,
-		string $targetLocation,
-		array $shares,
-		OutputInterface $output,
-	):void {
-		$output->writeln('Restoring shares ...');
-		$progress = new ProgressBar($output, count($shares));
-
-		foreach ($shares as ['share' => $share, 'suffix' => $suffix]) {
-			try {
-				$output->writeln('Transfering share ' . $share->getId() . ' of type ' . $share->getShareType(), OutputInterface::VERBOSITY_VERBOSE);
-				if ($share->getShareType() === IShare::TYPE_USER
-					&& $share->getSharedWith() === $destinationUid) {
-					// Unmount the shares before deleting, so we don't try to get the storage later on.
-					$shareMountPoint = $this->mountManager->find('/' . $destinationUid . '/files' . $share->getTarget());
-					if ($shareMountPoint) {
-						$this->mountManager->removeMount($shareMountPoint->getMountPoint());
-					}
-					$this->shareManager->deleteShare($share);
-				} else {
-					if ($share->getShareOwner() === $sourceUid) {
-						$share->setShareOwner($destinationUid);
-					}
-					if ($share->getSharedBy() === $sourceUid) {
-						$share->setSharedBy($destinationUid);
-					}
-
-					if ($share->getShareType() === IShare::TYPE_USER
-						&& !$this->userManager->userExists($share->getSharedWith())) {
-						// stray share with deleted user
-						$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted user "' . $share->getSharedWith() . '", deleting</error>');
-						$this->shareManager->deleteShare($share);
-						continue;
-					} else {
-						// trigger refetching of the node so that the new owner and mountpoint are taken into account
-						// otherwise the checks on the share update will fail due to the original node not being available in the new user scope
-						$this->userMountCache->clear();
-
-						try {
-							// Try to get the "old" id.
-							// Normally the ID is preserved,
-							// but for transferes between different storages the ID might change
-							$newNodeId = $share->getNode()->getId();
-						} catch (NotFoundException) {
-							// ID has changed due to transfer between different storages
-							// Try to get the new ID from the target path and suffix of the share
-							$node = $this->rootFolder->get(Filesystem::normalizePath($targetLocation . '/' . $suffix));
-							$newNodeId = $node->getId();
-							$output->writeln('Had to change node id to ' . $newNodeId, OutputInterface::VERBOSITY_VERY_VERBOSE);
-						}
-						$share->setNodeId($newNodeId);
-
-						$this->shareManager->updateShare($share, onlyValid: false);
-					}
-				}
-			} catch (NotFoundException $e) {
-				$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
-			} catch (\Throwable $e) {
-				$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getMessage() . ' : ' . $e->getTraceAsString() . '</error>');
-			}
-			$progress->advance();
-		}
-		$progress->finish();
-		$output->writeln('');
-	}
-
-	private function transferIncomingShares(string $sourceUid,
-		string $destinationUid,
-		array $sourceShares,
-		array $destinationShares,
-		OutputInterface $output,
-		string $path,
-		string $finalTarget,
-		bool $move): void {
-		$output->writeln('Restoring incoming shares ...');
-		$progress = new ProgressBar($output, count($sourceShares));
-		$prefix = "$destinationUid/files";
-		$finalShareTarget = '';
-		if (str_starts_with($finalTarget, $prefix)) {
-			$finalShareTarget = substr($finalTarget, strlen($prefix));
-		}
-		foreach ($sourceShares as $share) {
-			try {
-				// Only restore if share is in given path.
-				$pathToCheck = '/';
-				if (trim($path, '/') !== '') {
-					$pathToCheck = '/' . trim($path) . '/';
-				}
-				if (!str_starts_with($share->getTarget(), $pathToCheck)) {
-					continue;
-				}
-				$shareTarget = $share->getTarget();
-				$shareTarget = $finalShareTarget . $shareTarget;
-				if ($share->getShareType() === IShare::TYPE_USER
-					&& $share->getSharedBy() === $destinationUid) {
-					$this->shareManager->deleteShare($share);
-				} elseif (isset($destinationShares[$share->getNodeId()])) {
-					$destinationShare = $destinationShares[$share->getNodeId()];
-					// Keep the share which has the most permissions and discard the other one.
-					if ($destinationShare->getPermissions() < $share->getPermissions()) {
-						$this->shareManager->deleteShare($destinationShare);
-						$share->setSharedWith($destinationUid);
-						// trigger refetching of the node so that the new owner and mountpoint are taken into account
-						// otherwise the checks on the share update will fail due to the original node not being available in the new user scope
-						$this->userMountCache->clear();
-						$share->setNodeId($share->getNode()->getId());
-						$this->shareManager->updateShare($share);
-						// The share is already transferred.
-						$progress->advance();
-						if ($move) {
-							continue;
-						}
-						$share->setTarget($shareTarget);
-						$this->shareManager->moveShare($share, $destinationUid);
-						continue;
-					}
-					$this->shareManager->deleteShare($share);
-				} elseif ($share->getShareOwner() === $destinationUid) {
-					$this->shareManager->deleteShare($share);
-				} else {
-					$share->setSharedWith($destinationUid);
-					$share->setNodeId($share->getNode()->getId());
-					$this->shareManager->updateShare($share);
-					// trigger refetching of the node so that the new owner and mountpoint are taken into account
-					// otherwise the checks on the share update will fail due to the original node not being available in the new user scope
-					$this->userMountCache->clear();
-					// The share is already transferred.
-					$progress->advance();
-					if ($move) {
-						continue;
-					}
-					$share->setTarget($shareTarget);
-					$this->shareManager->moveShare($share, $destinationUid);
-					continue;
-				}
-			} catch (NotFoundException $e) {
-				$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
-			} catch (\Throwable $e) {
-				$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getTraceAsString() . '</error>');
-			}
-			$progress->advance();
-		}
-		$progress->finish();
-		$output->writeln('');
-	}
+    public function __construct(
+        private IEncryptionManager $encryptionManager,
+        private IShareManager $shareManager,
+        private IMountManager $mountManager,
+        private IUserMountCache $userMountCache,
+        private IUserManager $userManager,
+        private IFactory $l10nFactory,
+        private IRootFolder $rootFolder,
+    ) {
+    }
+
+    /**
+     * @param IUser $sourceUser
+     * @param IUser $destinationUser
+     * @param string $path
+     *
+     * @param OutputInterface|null $output
+     * @param bool $move
+     * @throws TransferOwnershipException
+     * @throws NoUserException
+     */
+    public function transfer(
+        IUser $sourceUser,
+        IUser $destinationUser,
+        string $path,
+        ?OutputInterface $output = null,
+        bool $move = false,
+        bool $firstLogin = false,
+        bool $includeExternalStorage = false,
+    ): void {
+        $output = $output ?? new NullOutput();
+        $sourceUid = $sourceUser->getUID();
+        $destinationUid = $destinationUser->getUID();
+        $sourcePath = rtrim($sourceUid . '/files/' . $path, '/');
+
+        // If encryption is on we have to ensure the user has logged in before and that all encryption modules are ready
+        if (($this->encryptionManager->isEnabled() && $destinationUser->getLastLogin() === 0)
+            || !$this->encryptionManager->isReadyForUser($destinationUid)) {
+            throw new TransferOwnershipException('The target user is not ready to accept files. The user has at least to have logged in once.', 2);
+        }
+
+        // setup filesystem
+        // Requesting the user folder will set it up if the user hasn't logged in before
+        // We need a setupFS for the full filesystem setup before as otherwise we will just return
+        // a lazy root folder which does not create the destination users folder
+        \OC_Util::setupFS($sourceUser->getUID());
+        \OC_Util::setupFS($destinationUser->getUID());
+        $this->rootFolder->getUserFolder($sourceUser->getUID());
+        $this->rootFolder->getUserFolder($destinationUser->getUID());
+        Filesystem::initMountPoints($sourceUid);
+        Filesystem::initMountPoints($destinationUid);
+
+        $view = new View();
+
+        if ($move) {
+            $finalTarget = "$destinationUid/files/";
+        } else {
+            $l = $this->l10nFactory->get('files', $this->l10nFactory->getUserLanguage($destinationUser));
+            $date = date('Y-m-d H-i-s');
+
+            $cleanUserName = $this->sanitizeFolderName($sourceUser->getDisplayName()) ?: $sourceUid;
+            $finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$cleanUserName, $date]));
+            try {
+                $view->verifyPath(dirname($finalTarget), basename($finalTarget));
+            } catch (InvalidPathException $e) {
+                $finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$sourceUid, $date]));
+            }
+        }
+
+        if (!($view->is_dir($sourcePath) || $view->is_file($sourcePath))) {
+            throw new TransferOwnershipException("Unknown path provided: $path", 1);
+        }
+
+        if ($move && !$view->is_dir($finalTarget)) {
+            // Initialize storage
+            \OC_Util::setupFS($destinationUser->getUID());
+        }
+
+        if ($move && !$firstLogin && count($view->getDirectoryContent($finalTarget)) > 0) {
+            throw new TransferOwnershipException('Destination path does not exists or is not empty', 1);
+        }
+
+
+        // analyse source folder
+        $this->analyse(
+            $sourceUid,
+            $destinationUid,
+            $sourcePath,
+            $view,
+            $output
+        );
+
+        // collect all the shares
+        $shares = $this->collectUsersShares(
+            $sourceUid,
+            $output,
+            $view,
+            $sourcePath
+        );
+
+        $sourceSize = $view->getFileInfo($sourcePath)->getSize();
+
+        // transfer the files
+        $this->transferFiles(
+            $sourceUid,
+            $sourcePath,
+            $finalTarget,
+            $view,
+            $output,
+            $includeExternalStorage,
+        );
+        $sizeDifference = $sourceSize - $view->getFileInfo($finalTarget)->getSize();
+
+        // transfer the incoming shares
+        $sourceShares = $this->collectIncomingShares(
+            $sourceUid,
+            $output,
+            $sourcePath,
+        );
+        $destinationShares = $this->collectIncomingShares(
+            $destinationUid,
+            $output,
+            null,
+        );
+        $this->transferIncomingShares(
+            $sourceUid,
+            $destinationUid,
+            $sourceShares,
+            $destinationShares,
+            $output,
+            $path,
+            $finalTarget,
+            $move
+        );
+
+        $destinationPath = $finalTarget . '/' . $path;
+        // restore the shares
+        $this->restoreShares(
+            $sourceUid,
+            $destinationUid,
+            $destinationPath,
+            $shares,
+            $output
+        );
+        if ($sizeDifference !== 0) {
+            $output->writeln("Transferred folder have a size difference of: $sizeDifference Bytes which means the transfer may be incomplete. Please check the logs if there was any issue during the transfer operation.");
+        }
+    }
+
+    private function sanitizeFolderName(string $name): string {
+        // Remove some characters which are prone to cause errors
+        $name = str_replace(['\\', '/', ':', '.', '?', '#', '\'', '"'], '-', $name);
+        // Replace multiple dashes with one dash
+        return preg_replace('/-{2,}/s', '-', $name);
+    }
+
+    private function walkFiles(View $view, $path, Closure $callBack) {
+        foreach ($view->getDirectoryContent($path) as $fileInfo) {
+            if (!$callBack($fileInfo)) {
+                return;
+            }
+            if ($fileInfo->getType() === FileInfo::TYPE_FOLDER) {
+                $this->walkFiles($view, $fileInfo->getPath(), $callBack);
+            }
+        }
+    }
+
+    /**
+     * @param OutputInterface $output
+     *
+     * @throws TransferOwnershipException
+     */
+    protected function analyse(
+        string $sourceUid,
+        string $destinationUid,
+        string $sourcePath,
+        View $view,
+        OutputInterface $output,
+        bool $includeExternalStorage = false,
+    ): void {
+        $output->writeln('Validating quota');
+        $sourceFileInfo = $view->getFileInfo($sourcePath, false);
+        if ($sourceFileInfo === false) {
+            throw new TransferOwnershipException("Unknown path provided: $sourcePath", 1);
+        }
+        $size = $sourceFileInfo->getSize(false);
+        $freeSpace = $view->free_space($destinationUid . '/files/');
+        if ($size > $freeSpace && $freeSpace !== FileInfo::SPACE_UNKNOWN) {
+            throw new TransferOwnershipException('Target user does not have enough free space available.', 1);
+        }
+
+        $output->writeln("Analysing files of $sourceUid ...");
+        $progress = new ProgressBar($output);
+        $progress->start();
+
+        if ($this->encryptionManager->isEnabled()) {
+            $masterKeyEnabled = Server::get(Util::class)->isMasterKeyEnabled();
+        } else {
+            $masterKeyEnabled = false;
+        }
+        $encryptedFiles = [];
+        if ($sourceFileInfo->getType() === FileInfo::TYPE_FOLDER) {
+            if ($sourceFileInfo->isEncrypted()) {
+                /* Encrypted folder means e2ee encrypted */
+                $encryptedFiles[] = $sourceFileInfo;
+            } else {
+                $this->walkFiles($view, $sourcePath,
+                    function (FileInfo $fileInfo) use ($progress, $masterKeyEnabled, &$encryptedFiles, $includeExternalStorage) {
+                        if ($fileInfo->getType() === FileInfo::TYPE_FOLDER) {
+                            $mount = $fileInfo->getMountPoint();
+                            // only analyze into folders from main storage,
+                            if (
+                                $mount->getMountProvider() instanceof IHomeMountProvider
+                                || ($includeExternalStorage && $mount->getMountProvider() instanceof ConfigAdapter)
+                            ) {
+                                if ($fileInfo->isEncrypted()) {
+                                    /* Encrypted folder means e2ee encrypted, we cannot transfer it */
+                                    $encryptedFiles[] = $fileInfo;
+                                }
+                                return true;
+                            } else {
+                                return false;
+                            }
+                        }
+                        $progress->advance();
+                        if ($fileInfo->isEncrypted() && !$masterKeyEnabled) {
+                            /* Encrypted file means SSE, we can only transfer it if master key is enabled */
+                            $encryptedFiles[] = $fileInfo;
+                        }
+                        return true;
+                    });
+            }
+        } elseif ($sourceFileInfo->isEncrypted() && !$masterKeyEnabled) {
+            /* Encrypted file means SSE, we can only transfer it if master key is enabled */
+            $encryptedFiles[] = $sourceFileInfo;
+        }
+        $progress->finish();
+        $output->writeln('');
+
+        // no file is allowed to be encrypted
+        if (!empty($encryptedFiles)) {
+            $output->writeln('<error>Some files are encrypted - please decrypt them first.</error>');
+            foreach ($encryptedFiles as $encryptedFile) {
+                /** @var FileInfo $encryptedFile */
+                $output->writeln('  ' . $encryptedFile->getPath());
+            }
+            throw new TransferOwnershipException('Some files are encrypted - please decrypt them first.', 1);
+        }
+    }
+
+    /**
+     * @return array<array{share: IShare, suffix: string}>
+     */
+    private function collectUsersShares(
+        string $sourceUid,
+        OutputInterface $output,
+        View $view,
+        string $path,
+    ): array {
+        $output->writeln("Collecting all share information for files and folders of $sourceUid ...");
+
+        $shares = [];
+        $progress = new ProgressBar($output);
+
+        $normalizedPath = Filesystem::normalizePath($path);
+
+        $supportedShareTypes = [
+            IShare::TYPE_GROUP,
+            IShare::TYPE_USER,
+            IShare::TYPE_LINK,
+            IShare::TYPE_REMOTE,
+            IShare::TYPE_ROOM,
+            IShare::TYPE_EMAIL,
+            IShare::TYPE_CIRCLE,
+            IShare::TYPE_DECK,
+            IShare::TYPE_SCIENCEMESH,
+        ];
+
+        foreach ($supportedShareTypes as $shareType) {
+            $offset = 0;
+            while (true) {
+                $sharePage = $this->shareManager->getSharesBy($sourceUid, $shareType, null, true, 50, $offset, onlyValid: false);
+                $progress->advance(count($sharePage));
+                if (empty($sharePage)) {
+                    break;
+                }
+                if ($path !== "$sourceUid/files") {
+                    $sharePage = array_filter($sharePage, function (IShare $share) use ($view, $normalizedPath) {
+                        try {
+                            $sourceNode = $share->getNode();
+                            $relativePath = $view->getRelativePath($sourceNode->getPath());
+
+                            return str_starts_with($relativePath . '/', $normalizedPath . '/');
+                        } catch (Exception $e) {
+                            return false;
+                        }
+                    });
+                }
+                $shares = array_merge($shares, $sharePage);
+                $offset += 50;
+            }
+        }
+
+        $progress->finish();
+        $output->writeln('');
+
+        return array_values(array_filter(array_map(function (IShare $share) use ($view, $normalizedPath, $output, $sourceUid) {
+            try {
+                $nodePath = $view->getRelativePath($share->getNode()->getPath());
+            } catch (NotFoundException $e) {
+                $output->writeln("<error>Failed to find path for shared file {$share->getNodeId()} for user $sourceUid, skipping</error>");
+                return null;
+            }
+
+            return [
+                'share' => $share,
+                'suffix' => substr(Filesystem::normalizePath($nodePath), strlen($normalizedPath)),
+            ];
+        }, $shares)));
+    }
+
+    private function collectIncomingShares(
+        string $sourceUid,
+        OutputInterface $output,
+        ?string $path,
+    ): array {
+        $output->writeln("Collecting all incoming share information for files and folders of $sourceUid ...");
+
+        $shares = [];
+        $progress = new ProgressBar($output);
+        $normalizedPath = Filesystem::normalizePath($path);
+
+        $offset = 0;
+        while (true) {
+            $sharePage = $this->shareManager->getSharedWith($sourceUid, IShare::TYPE_USER, null, 50, $offset);
+            $progress->advance(count($sharePage));
+            if (empty($sharePage)) {
+                break;
+            }
+
+            if ($path !== null && $path !== "$sourceUid/files") {
+                $sharePage = array_filter($sharePage, static function (IShare $share) use ($sourceUid, $normalizedPath) {
+                    try {
+                        return str_starts_with(Filesystem::normalizePath($sourceUid . '/files' . $share->getTarget() . '/', false), $normalizedPath . '/');
+                    } catch (Exception) {
+                        return false;
+                    }
+                });
+            }
+
+            foreach ($sharePage as $share) {
+                $shares[$share->getNodeId()] = $share;
+            }
+
+            $offset += 50;
+        }
+
+
+        $progress->finish();
+        $output->writeln('');
+        return $shares;
+    }
+
+    /**
+     * @throws TransferOwnershipException
+     */
+    protected function transferFiles(
+        string $sourceUid,
+        string $sourcePath,
+        string $finalTarget,
+        View $view,
+        OutputInterface $output,
+        bool $includeExternalStorage,
+    ): void {
+        $output->writeln("Transferring files to $finalTarget ...");
+
+        // This change will help user to transfer the folder specified using --path option.
+        // Else only the content inside folder is transferred which is not correct.
+        if ($sourcePath !== "$sourceUid/files") {
+            $view->mkdir($finalTarget);
+            $finalTarget = $finalTarget . '/' . basename($sourcePath);
+        }
+        $sourceInfo = $view->getFileInfo($sourcePath);
+
+        /// handle the external storages mounted at the root, or the admin specifying an external storage with --path
+        if ($sourceInfo->getInternalPath() === '' && $includeExternalStorage) {
+            $this->moveMountContents($view, $sourcePath, $finalTarget);
+        } else {
+            if ($view->rename($sourcePath, $finalTarget, ['checkSubMounts' => false]) === false) {
+                throw new TransferOwnershipException('Could not transfer files.', 1);
+            }
+        }
+
+        if ($includeExternalStorage) {
+            $nestedMounts = $this->mountManager->findIn($sourcePath);
+            foreach ($nestedMounts as $mount) {
+                if ($mount->getMountProvider() === ConfigAdapter::class) {
+                    $relativePath = substr(trim($mount->getMountPoint(), '/'), strlen($sourcePath));
+                    $this->moveMountContents($view, $mount->getMountPoint(), $finalTarget . $relativePath);
+                }
+            }
+        }
+
+        if (!is_dir("$sourceUid/files")) {
+            // because the files folder is moved away we need to recreate it
+            $view->mkdir("$sourceUid/files");
+        }
+    }
+
+    private function moveMountContents(View $rootView, string $source, string $target) {
+        if ($rootView->copy($source, $target)) {
+            // just doing `rmdir` on the mountpoint would cause it to try and unmount the storage
+            // we need to empty the contents instead
+            $content = $rootView->getDirectoryContent($source);
+            foreach ($content as $item) {
+                if ($item->getType() === FileInfo::TYPE_FOLDER) {
+                    $rootView->rmdir($item->getPath());
+                } else {
+                    $rootView->unlink($item->getPath());
+                }
+            }
+        } else {
+            throw new TransferOwnershipException("Could not transfer $source to $target");
+        }
+    }
+
+    /**
+     * @param string $targetLocation New location of the transfered node
+     * @param array<array{share: IShare, suffix: string}> $shares previously collected share information
+     */
+    private function restoreShares(
+        string $sourceUid,
+        string $destinationUid,
+        string $targetLocation,
+        array $shares,
+        OutputInterface $output,
+    ):void {
+        $output->writeln('Restoring shares ...');
+        $progress = new ProgressBar($output, count($shares));
+
+        foreach ($shares as ['share' => $share, 'suffix' => $suffix]) {
+            try {
+                $output->writeln('Transfering share ' . $share->getId() . ' of type ' . $share->getShareType(), OutputInterface::VERBOSITY_VERBOSE);
+                if ($share->getShareType() === IShare::TYPE_USER
+                    && $share->getSharedWith() === $destinationUid) {
+                    // Unmount the shares before deleting, so we don't try to get the storage later on.
+                    $shareMountPoint = $this->mountManager->find('/' . $destinationUid . '/files' . $share->getTarget());
+                    if ($shareMountPoint) {
+                        $this->mountManager->removeMount($shareMountPoint->getMountPoint());
+                    }
+                    $this->shareManager->deleteShare($share);
+                } else {
+                    if ($share->getShareOwner() === $sourceUid) {
+                        $share->setShareOwner($destinationUid);
+                    }
+                    if ($share->getSharedBy() === $sourceUid) {
+                        $share->setSharedBy($destinationUid);
+                    }
+
+                    if ($share->getShareType() === IShare::TYPE_USER
+                        && !$this->userManager->userExists($share->getSharedWith())) {
+                        // stray share with deleted user
+                        $output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted user "' . $share->getSharedWith() . '", deleting</error>');
+                        $this->shareManager->deleteShare($share);
+                        continue;
+                    } else {
+                        // trigger refetching of the node so that the new owner and mountpoint are taken into account
+                        // otherwise the checks on the share update will fail due to the original node not being available in the new user scope
+                        $this->userMountCache->clear();
+
+                        try {
+                            // Try to get the "old" id.
+                            // Normally the ID is preserved,
+                            // but for transferes between different storages the ID might change
+                            $newNodeId = $share->getNode()->getId();
+                        } catch (NotFoundException) {
+                            // ID has changed due to transfer between different storages
+                            // Try to get the new ID from the target path and suffix of the share
+                            $node = $this->rootFolder->get(Filesystem::normalizePath($targetLocation . '/' . $suffix));
+                            $newNodeId = $node->getId();
+                            $output->writeln('Had to change node id to ' . $newNodeId, OutputInterface::VERBOSITY_VERY_VERBOSE);
+                        }
+                        $share->setNodeId($newNodeId);
+
+                        $this->shareManager->updateShare($share, onlyValid: false);
+                    }
+                }
+            } catch (NotFoundException $e) {
+                $output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
+            } catch (\Throwable $e) {
+                $output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getMessage() . ' : ' . $e->getTraceAsString() . '</error>');
+            }
+            $progress->advance();
+        }
+        $progress->finish();
+        $output->writeln('');
+    }
+
+    private function transferIncomingShares(string $sourceUid,
+        string $destinationUid,
+        array $sourceShares,
+        array $destinationShares,
+        OutputInterface $output,
+        string $path,
+        string $finalTarget,
+        bool $move): void {
+        $output->writeln('Restoring incoming shares ...');
+        $progress = new ProgressBar($output, count($sourceShares));
+        $prefix = "$destinationUid/files";
+        $finalShareTarget = '';
+        if (str_starts_with($finalTarget, $prefix)) {
+            $finalShareTarget = substr($finalTarget, strlen($prefix));
+        }
+        foreach ($sourceShares as $share) {
+            try {
+                // Only restore if share is in given path.
+                $pathToCheck = '/';
+                if (trim($path, '/') !== '') {
+                    $pathToCheck = '/' . trim($path) . '/';
+                }
+                if (!str_starts_with($share->getTarget(), $pathToCheck)) {
+                    continue;
+                }
+                $shareTarget = $share->getTarget();
+                $shareTarget = $finalShareTarget . $shareTarget;
+                if ($share->getShareType() === IShare::TYPE_USER
+                    && $share->getSharedBy() === $destinationUid) {
+                    $this->shareManager->deleteShare($share);
+                } elseif (isset($destinationShares[$share->getNodeId()])) {
+                    $destinationShare = $destinationShares[$share->getNodeId()];
+                    // Keep the share which has the most permissions and discard the other one.
+                    if ($destinationShare->getPermissions() < $share->getPermissions()) {
+                        $this->shareManager->deleteShare($destinationShare);
+                        $share->setSharedWith($destinationUid);
+                        // trigger refetching of the node so that the new owner and mountpoint are taken into account
+                        // otherwise the checks on the share update will fail due to the original node not being available in the new user scope
+                        $this->userMountCache->clear();
+                        $share->setNodeId($share->getNode()->getId());
+                        $this->shareManager->updateShare($share);
+                        // The share is already transferred.
+                        $progress->advance();
+                        if ($move) {
+                            continue;
+                        }
+                        $share->setTarget($shareTarget);
+                        $this->shareManager->moveShare($share, $destinationUid);
+                        continue;
+                    }
+                    $this->shareManager->deleteShare($share);
+                } elseif ($share->getShareOwner() === $destinationUid) {
+                    $this->shareManager->deleteShare($share);
+                } else {
+                    $share->setSharedWith($destinationUid);
+                    $share->setNodeId($share->getNode()->getId());
+                    $this->shareManager->updateShare($share);
+                    // trigger refetching of the node so that the new owner and mountpoint are taken into account
+                    // otherwise the checks on the share update will fail due to the original node not being available in the new user scope
+                    $this->userMountCache->clear();
+                    // The share is already transferred.
+                    $progress->advance();
+                    if ($move) {
+                        continue;
+                    }
+                    $share->setTarget($shareTarget);
+                    $this->shareManager->moveShare($share, $destinationUid);
+                    continue;
+                }
+            } catch (NotFoundException $e) {
+                $output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
+            } catch (\Throwable $e) {
+                $output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getTraceAsString() . '</error>');
+            }
+            $progress->advance();
+        }
+        $progress->finish();
+        $output->writeln('');
+    }
 }

Spacing +25 added lines, -25 removed lines

@@ -77,7 +77,7 @@ 
 		$output = $output ?? new NullOutput();
 		$sourceUid = $sourceUser->getUID();
 		$destinationUid = $destinationUser->getUID();
-		$sourcePath = rtrim($sourceUid . '/files/' . $path, '/');
+		$sourcePath = rtrim($sourceUid.'/files/'.$path, '/');
 
 		// If encryption is on we have to ensure the user has logged in before and that all encryption modules are ready
 		if (($this->encryptionManager->isEnabled() && $destinationUser->getLastLogin() === 0)
@@ -105,11 +105,11 @@ 
 			$date = date('Y-m-d H-i-s');
 
 			$cleanUserName = $this->sanitizeFolderName($sourceUser->getDisplayName()) ?: $sourceUid;
-			$finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$cleanUserName, $date]));
+			$finalTarget = "$destinationUid/files/".$this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$cleanUserName, $date]));
 			try {
 				$view->verifyPath(dirname($finalTarget), basename($finalTarget));
 			} catch (InvalidPathException $e) {
-				$finalTarget = "$destinationUid/files/" . $this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$sourceUid, $date]));
+				$finalTarget = "$destinationUid/files/".$this->sanitizeFolderName($l->t('Transferred from %1$s on %2$s', [$sourceUid, $date]));
 			}
 		}
 
@@ -179,7 +179,7 @@ 
 			$move
 		);
 
-		$destinationPath = $finalTarget . '/' . $path;
+		$destinationPath = $finalTarget.'/'.$path;
 		// restore the shares
 		$this->restoreShares(
 			$sourceUid,
@@ -230,7 +230,7 @@ 
 			throw new TransferOwnershipException("Unknown path provided: $sourcePath", 1);
 		}
 		$size = $sourceFileInfo->getSize(false);
-		$freeSpace = $view->free_space($destinationUid . '/files/');
+		$freeSpace = $view->free_space($destinationUid.'/files/');
 		if ($size > $freeSpace && $freeSpace !== FileInfo::SPACE_UNKNOWN) {
 			throw new TransferOwnershipException('Target user does not have enough free space available.', 1);
 		}
@@ -251,7 +251,7 @@ 
 				$encryptedFiles[] = $sourceFileInfo;
 			} else {
 				$this->walkFiles($view, $sourcePath,
-					function (FileInfo $fileInfo) use ($progress, $masterKeyEnabled, &$encryptedFiles, $includeExternalStorage) {
+					function(FileInfo $fileInfo) use ($progress, $masterKeyEnabled, &$encryptedFiles, $includeExternalStorage) {
 						if ($fileInfo->getType() === FileInfo::TYPE_FOLDER) {
 							$mount = $fileInfo->getMountPoint();
 							// only analyze into folders from main storage,
@@ -288,7 +288,7 @@ 
 			$output->writeln('<error>Some files are encrypted - please decrypt them first.</error>');
 			foreach ($encryptedFiles as $encryptedFile) {
 				/** @var FileInfo $encryptedFile */
-				$output->writeln('  ' . $encryptedFile->getPath());
+				$output->writeln('  '.$encryptedFile->getPath());
 			}
 			throw new TransferOwnershipException('Some files are encrypted - please decrypt them first.', 1);
 		}
@@ -331,12 +331,12 @@ 
 					break;
 				}
 				if ($path !== "$sourceUid/files") {
-					$sharePage = array_filter($sharePage, function (IShare $share) use ($view, $normalizedPath) {
+					$sharePage = array_filter($sharePage, function(IShare $share) use ($view, $normalizedPath) {
 						try {
 							$sourceNode = $share->getNode();
 							$relativePath = $view->getRelativePath($sourceNode->getPath());
 
-							return str_starts_with($relativePath . '/', $normalizedPath . '/');
+							return str_starts_with($relativePath.'/', $normalizedPath.'/');
 						} catch (Exception $e) {
 							return false;
 						}
@@ -350,7 +350,7 @@ 
 		$progress->finish();
 		$output->writeln('');
 
-		return array_values(array_filter(array_map(function (IShare $share) use ($view, $normalizedPath, $output, $sourceUid) {
+		return array_values(array_filter(array_map(function(IShare $share) use ($view, $normalizedPath, $output, $sourceUid) {
 			try {
 				$nodePath = $view->getRelativePath($share->getNode()->getPath());
 			} catch (NotFoundException $e) {
@@ -385,9 +385,9 @@ 
 			}
 
 			if ($path !== null && $path !== "$sourceUid/files") {
-				$sharePage = array_filter($sharePage, static function (IShare $share) use ($sourceUid, $normalizedPath) {
+				$sharePage = array_filter($sharePage, static function(IShare $share) use ($sourceUid, $normalizedPath) {
 					try {
-						return str_starts_with(Filesystem::normalizePath($sourceUid . '/files' . $share->getTarget() . '/', false), $normalizedPath . '/');
+						return str_starts_with(Filesystem::normalizePath($sourceUid.'/files'.$share->getTarget().'/', false), $normalizedPath.'/');
 					} catch (Exception) {
 						return false;
 					}
@@ -424,7 +424,7 @@ 
 		// Else only the content inside folder is transferred which is not correct.
 		if ($sourcePath !== "$sourceUid/files") {
 			$view->mkdir($finalTarget);
-			$finalTarget = $finalTarget . '/' . basename($sourcePath);
+			$finalTarget = $finalTarget.'/'.basename($sourcePath);
 		}
 		$sourceInfo = $view->getFileInfo($sourcePath);
 
@@ -442,7 +442,7 @@ 
 			foreach ($nestedMounts as $mount) {
 				if ($mount->getMountProvider() === ConfigAdapter::class) {
 					$relativePath = substr(trim($mount->getMountPoint(), '/'), strlen($sourcePath));
-					$this->moveMountContents($view, $mount->getMountPoint(), $finalTarget . $relativePath);
+					$this->moveMountContents($view, $mount->getMountPoint(), $finalTarget.$relativePath);
 				}
 			}
 		}
@@ -486,11 +486,11 @@ 
 
 		foreach ($shares as ['share' => $share, 'suffix' => $suffix]) {
 			try {
-				$output->writeln('Transfering share ' . $share->getId() . ' of type ' . $share->getShareType(), OutputInterface::VERBOSITY_VERBOSE);
+				$output->writeln('Transfering share '.$share->getId().' of type '.$share->getShareType(), OutputInterface::VERBOSITY_VERBOSE);
 				if ($share->getShareType() === IShare::TYPE_USER
 					&& $share->getSharedWith() === $destinationUid) {
 					// Unmount the shares before deleting, so we don't try to get the storage later on.
-					$shareMountPoint = $this->mountManager->find('/' . $destinationUid . '/files' . $share->getTarget());
+					$shareMountPoint = $this->mountManager->find('/'.$destinationUid.'/files'.$share->getTarget());
 					if ($shareMountPoint) {
 						$this->mountManager->removeMount($shareMountPoint->getMountPoint());
 					}
@@ -506,7 +506,7 @@ 
 					if ($share->getShareType() === IShare::TYPE_USER
 						&& !$this->userManager->userExists($share->getSharedWith())) {
 						// stray share with deleted user
-						$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted user "' . $share->getSharedWith() . '", deleting</error>');
+						$output->writeln('<error>Share with id '.$share->getId().' points at deleted user "'.$share->getSharedWith().'", deleting</error>');
 						$this->shareManager->deleteShare($share);
 						continue;
 					} else {
@@ -522,9 +522,9 @@ 
 						} catch (NotFoundException) {
 							// ID has changed due to transfer between different storages
 							// Try to get the new ID from the target path and suffix of the share
-							$node = $this->rootFolder->get(Filesystem::normalizePath($targetLocation . '/' . $suffix));
+							$node = $this->rootFolder->get(Filesystem::normalizePath($targetLocation.'/'.$suffix));
 							$newNodeId = $node->getId();
-							$output->writeln('Had to change node id to ' . $newNodeId, OutputInterface::VERBOSITY_VERY_VERBOSE);
+							$output->writeln('Had to change node id to '.$newNodeId, OutputInterface::VERBOSITY_VERY_VERBOSE);
 						}
 						$share->setNodeId($newNodeId);
 
@@ -532,9 +532,9 @@ 
 					}
 				}
 			} catch (NotFoundException $e) {
-				$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
+				$output->writeln('<error>Share with id '.$share->getId().' points at deleted file, skipping</error>');
 			} catch (\Throwable $e) {
-				$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getMessage() . ' : ' . $e->getTraceAsString() . '</error>');
+				$output->writeln('<error>Could not restore share with id '.$share->getId().':'.$e->getMessage().' : '.$e->getTraceAsString().'</error>');
 			}
 			$progress->advance();
 		}
@@ -562,13 +562,13 @@ 
 				// Only restore if share is in given path.
 				$pathToCheck = '/';
 				if (trim($path, '/') !== '') {
-					$pathToCheck = '/' . trim($path) . '/';
+					$pathToCheck = '/'.trim($path).'/';
 				}
 				if (!str_starts_with($share->getTarget(), $pathToCheck)) {
 					continue;
 				}
 				$shareTarget = $share->getTarget();
-				$shareTarget = $finalShareTarget . $shareTarget;
+				$shareTarget = $finalShareTarget.$shareTarget;
 				if ($share->getShareType() === IShare::TYPE_USER
 					&& $share->getSharedBy() === $destinationUid) {
 					$this->shareManager->deleteShare($share);
@@ -612,9 +612,9 @@ 
 					continue;
 				}
 			} catch (NotFoundException $e) {
-				$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
+				$output->writeln('<error>Share with id '.$share->getId().' points at deleted file, skipping</error>');
 			} catch (\Throwable $e) {
-				$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getTraceAsString() . '</error>');
+				$output->writeln('<error>Could not restore share with id '.$share->getId().':'.$e->getTraceAsString().'</error>');
 			}
 			$progress->advance();
 		}

tests/lib/Files/ViewTest.php

Indentation +2826 added lines, -2826 removed lines

@@ -51,40 +51,40 @@ 
 use Test\Traits\UserTrait;
 
 class TemporaryNoTouch extends Temporary {
-	public function touch(string $path, ?int $mtime = null): bool {
-		return false;
-	}
+    public function touch(string $path, ?int $mtime = null): bool {
+        return false;
+    }
 }
 
 class TemporaryNoCross extends Temporary {
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
-		return Common::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime);
-	}
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
+        return Common::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime);
+    }
 
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return Common::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return Common::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
 }
 
 class TemporaryNoLocal extends Temporary {
-	public function instanceOfStorage(string $class): bool {
-		if ($class === '\OC\Files\Storage\Local') {
-			return false;
-		} else {
-			return parent::instanceOfStorage($class);
-		}
-	}
+    public function instanceOfStorage(string $class): bool {
+        if ($class === '\OC\Files\Storage\Local') {
+            return false;
+        } else {
+            return parent::instanceOfStorage($class);
+        }
+    }
 }
 
 class TestEventHandler {
-	public function umount() {
-	}
-	public function post_umount() {
-	}
-	public function preCallback() {
-	}
-	public function postCallback() {
-	}
+    public function umount() {
+    }
+    public function post_umount() {
+    }
+    public function preCallback() {
+    }
+    public function postCallback() {
+    }
 }
 
 /**
@@ -95,2809 +95,2809 @@ 
  * @package Test\Files
  */
 class ViewTest extends \Test\TestCase {
-	use UserTrait;
-
-	/**
-	 * @var Storage[] $storages
-	 */
-	private $storages = [];
-
-	/**
-	 * @var string
-	 */
-	private $user;
-
-	/**
-	 * @var IUser
-	 */
-	private $userObject;
-
-	/**
-	 * @var IGroup
-	 */
-	private $groupObject;
-
-	/** @var Storage */
-	private $tempStorage;
-
-	protected function setUp(): void {
-		parent::setUp();
-		\OC_Hook::clear();
-
-		Server::get(IUserManager::class)->clearBackends();
-		Server::get(IUserManager::class)->registerBackend(new \Test\Util\User\Dummy());
-
-		//login
-		$userManager = Server::get(IUserManager::class);
-		$groupManager = Server::get(IGroupManager::class);
-		$this->user = 'test';
-		$this->userObject = $userManager->createUser('test', 'test');
-
-		$this->groupObject = $groupManager->createGroup('group1');
-		$this->groupObject->addUser($this->userObject);
-
-		self::loginAsUser($this->user);
-
-		/** @var IMountManager $manager */
-		$manager = Server::get(IMountManager::class);
-		$manager->removeMount('/test');
-
-		$this->tempStorage = null;
-	}
-
-	protected function tearDown(): void {
-		\OC_User::setUserId($this->user);
-		foreach ($this->storages as $storage) {
-			$cache = $storage->getCache();
-			$ids = $cache->getAll();
-			$cache->clear();
-		}
-
-		if ($this->tempStorage) {
-			system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
-		}
-
-		self::logout();
-
-		/** @var SetupManager $setupManager */
-		$setupManager = Server::get(SetupManager::class);
-		$setupManager->setupRoot();
-
-		$this->userObject->delete();
-		$this->groupObject->delete();
-
-		$mountProviderCollection = Server::get(IMountProviderCollection::class);
-		self::invokePrivate($mountProviderCollection, 'providers', [[]]);
-
-		parent::tearDown();
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCacheAPI(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
-		Filesystem::mount($storage2, [], $root . '/substorage');
-		Filesystem::mount($storage3, [], $root . '/folder/anotherstorage');
-		$textSize = strlen("dummy file data\n");
-		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo/logo.png');
-		$storageSize = $textSize * 2 + $imageSize;
-
-		$storageInfo = $storage3->getCache()->get('');
-		$this->assertEquals($storageSize, $storageInfo['size']);
-
-		$rootView = new View($root);
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertEquals($textSize, $cachedData['size']);
-		$this->assertEquals('text/plain', $cachedData['mimetype']);
-		$this->assertNotEquals(-1, $cachedData['permissions']);
-
-		$cachedData = $rootView->getFileInfo('/');
-		$this->assertEquals($storageSize * 3, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		// get cached data excluding mount points
-		$cachedData = $rootView->getFileInfo('/', false);
-		$this->assertEquals($storageSize, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		$cachedData = $rootView->getFileInfo('/folder');
-		$this->assertEquals($storageSize + $textSize, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		$folderData = $rootView->getDirectoryContent('/');
-		/**
-		 * expected entries:
-		 * folder
-		 * foo.png
-		 * foo.txt
-		 * substorage
-		 */
-		$this->assertCount(4, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-		$this->assertEquals('substorage', $folderData[3]['name']);
-
-		$this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
-		$this->assertEquals($imageSize, $folderData[1]['size']);
-		$this->assertEquals($textSize, $folderData[2]['size']);
-		$this->assertEquals($storageSize, $folderData[3]['size']);
-
-		$folderData = $rootView->getDirectoryContent('/substorage');
-		/**
-		 * expected entries:
-		 * folder
-		 * foo.png
-		 * foo.txt
-		 */
-		$this->assertCount(3, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-
-		$folderView = new View($root . '/folder');
-		$this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertFalse($cachedData['encrypted']);
-		$id = $rootView->putFileInfo('/foo.txt', ['encrypted' => true]);
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertTrue($cachedData['encrypted']);
-		$this->assertEquals($cachedData['fileid'], $id);
-
-		$this->assertFalse($rootView->getFileInfo('/non/existing'));
-		$this->assertEquals([], $rootView->getDirectoryContent('/non/existing'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testGetPath(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('test');
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-
-		Filesystem::mount($storage1, [], '/test/files');
-		Filesystem::mount($storage2, [], '/test/files/substorage');
-		Filesystem::mount($storage3, [], '/test/files/folder/anotherstorage');
-
-		$userMountCache = Server::get(IUserMountCache::class);
-		$userMountCache->registerMounts($user, [
-			new MountPoint($storage1, '/test/files'),
-			new MountPoint($storage2, '/test/files/substorage'),
-			new MountPoint($storage3, '/test/files/folder/anotherstorage'),
-		]);
-
-		$rootView = new View('/test/files');
-
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$id1 = $cachedData->getId();
-		$this->assertEquals('/foo.txt', $rootView->getPath($id1));
-
-		$cachedData = $rootView->getFileInfo('/substorage/foo.txt');
-		$id2 = $cachedData->getId();
-		$this->assertEquals('/substorage/foo.txt', $rootView->getPath($id2));
-
-		$folderView = new View('/test/files/substorage');
-		$this->assertEquals('/foo.txt', $folderView->getPath($id2));
-	}
-
-
-	public function testGetPathNotExisting(): void {
-		$this->expectException(NotFoundException::class);
-
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$rootView = new View('');
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		/** @var int $id1 */
-		$id1 = $cachedData['fileid'];
-		$folderView = new View('/substorage');
-		$this->assertNull($folderView->getPath($id1));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMountPointOverwrite(): void {
-		$storage1 = $this->getTestStorage(false);
-		$storage2 = $this->getTestStorage();
-		$storage1->mkdir('substorage');
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$folderContent = $rootView->getDirectoryContent('/');
-		$this->assertCount(4, $folderContent);
-	}
-
-	public static function sharingDisabledPermissionProvider(): array {
-		return [
-			['no', '', true],
-			['yes', 'group1', false],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('sharingDisabledPermissionProvider')]
-	public function testRemoveSharePermissionWhenSharingDisabledForUser($excludeGroups, $excludeGroupsList, $expectedShareable): void {
-		// Reset sharing disabled for users cache
-		self::invokePrivate(Server::get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
-
-		$config = Server::get(IConfig::class);
-		$oldExcludeGroupsFlag = $config->getAppValue('core', 'shareapi_exclude_groups', 'no');
-		$oldExcludeGroupsList = $config->getAppValue('core', 'shareapi_exclude_groups_list', '');
-		$config->setAppValue('core', 'shareapi_exclude_groups', $excludeGroups);
-		$config->setAppValue('core', 'shareapi_exclude_groups_list', $excludeGroupsList);
-
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/mount');
-
-		$view = new View('/');
-
-		$folderContent = $view->getDirectoryContent('');
-		$this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
-
-		$folderContent = $view->getDirectoryContent('mount');
-		$this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
-
-		$config->setAppValue('core', 'shareapi_exclude_groups', $oldExcludeGroupsFlag);
-		$config->setAppValue('core', 'shareapi_exclude_groups_list', $oldExcludeGroupsList);
-
-		// Reset sharing disabled for users cache
-		self::invokePrivate(Server::get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
-	}
-
-	public function testCacheIncompleteFolder(): void {
-		$storage1 = $this->getTestStorage(false);
-		Filesystem::mount($storage1, [], '/incomplete');
-		$rootView = new View('/incomplete');
-
-		$entries = $rootView->getDirectoryContent('/');
-		$this->assertCount(3, $entries);
-
-		// /folder will already be in the cache but not scanned
-		$entries = $rootView->getDirectoryContent('/folder');
-		$this->assertCount(1, $entries);
-	}
-
-	public function testAutoScan(): void {
-		$storage1 = $this->getTestStorage(false);
-		$storage2 = $this->getTestStorage(false);
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-		$textSize = strlen("dummy file data\n");
-
-		$rootView = new View('');
-
-		$cachedData = $rootView->getFileInfo('/');
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-		$this->assertEquals(-1, $cachedData['size']);
-
-		$folderData = $rootView->getDirectoryContent('/substorage/folder');
-		$this->assertEquals('text/plain', $folderData[0]['mimetype']);
-		$this->assertEquals($textSize, $folderData[0]['size']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testSearch(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-		Filesystem::mount($storage3, [], '/folder/anotherstorage');
-
-		$rootView = new View('');
-
-		$results = $rootView->search('foo');
-		$this->assertCount(6, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$this->assertEquals($result['path'], Filesystem::normalizePath($result['path']));
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/foo.txt', $paths);
-		$this->assertContains('/foo.png', $paths);
-		$this->assertContains('/substorage/foo.txt', $paths);
-		$this->assertContains('/substorage/foo.png', $paths);
-		$this->assertContains('/folder/anotherstorage/foo.txt', $paths);
-		$this->assertContains('/folder/anotherstorage/foo.png', $paths);
-
-		$folderView = new View('/folder');
-		$results = $folderView->search('bar');
-		$this->assertCount(2, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/anotherstorage/folder/bar.txt', $paths);
-		$this->assertContains('/bar.txt', $paths);
-
-		$results = $folderView->search('foo');
-		$this->assertCount(2, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/anotherstorage/foo.txt', $paths);
-		$this->assertContains('/anotherstorage/foo.png', $paths);
-
-		$this->assertCount(6, $rootView->searchByMime('text'));
-		$this->assertCount(3, $folderView->searchByMime('text'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testWatcher(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		$storage1->getWatcher()->setPolicy(Watcher::CHECK_ALWAYS);
-
-		$rootView = new View('');
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(16, $cachedData['size']);
-
-		$rootView->putFileInfo('foo.txt', ['storage_mtime' => 10]);
-		$storage1->file_put_contents('foo.txt', 'foo');
-		clearstatcache();
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(3, $cachedData['size']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageNoCross(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageCross(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageCrossNonLocal(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	public function copyBetweenStorages($storage1, $storage2) {
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->mkdir('substorage/emptyfolder');
-		$rootView->copy('substorage', 'anotherfolder');
-		$this->assertTrue($rootView->is_dir('/anotherfolder'));
-		$this->assertTrue($rootView->is_dir('/substorage'));
-		$this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
-		$this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
-		$this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
-		$this->assertTrue($rootView->file_exists('/substorage/foo.png'));
-		$this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageNoCross(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageCross(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageCrossNonLocal(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	public function moveBetweenStorages($storage1, $storage2) {
-		Filesystem::mount($storage1, [], '/' . $this->user . '/');
-		Filesystem::mount($storage2, [], '/' . $this->user . '/substorage');
-
-		$rootView = new View('/' . $this->user);
-		$rootView->rename('foo.txt', 'substorage/folder/foo.txt');
-		$this->assertFalse($rootView->file_exists('foo.txt'));
-		$this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
-		$rootView->rename('substorage/folder', 'anotherfolder');
-		$this->assertFalse($rootView->is_dir('substorage/folder'));
-		$this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
-		$this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testUnlink(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$rootView->file_put_contents('/substorage/bar.txt', 'asd');
-
-		$this->assertTrue($rootView->file_exists('foo.txt'));
-		$this->assertTrue($rootView->file_exists('substorage/bar.txt'));
-
-		$this->assertTrue($rootView->unlink('foo.txt'));
-		$this->assertTrue($rootView->unlink('substorage/bar.txt'));
-
-		$this->assertFalse($rootView->file_exists('foo.txt'));
-		$this->assertFalse($rootView->file_exists('substorage/bar.txt'));
-	}
-
-	public static function rmdirOrUnlinkDataProvider(): array {
-		return [['rmdir'], ['unlink']];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('rmdirOrUnlinkDataProvider')]
-	public function testRmdir($method): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$rootView = new View('');
-		$rootView->mkdir('sub');
-		$rootView->mkdir('sub/deep');
-		$rootView->file_put_contents('/sub/deep/foo.txt', 'asd');
-
-		$this->assertTrue($rootView->file_exists('sub/deep/foo.txt'));
-
-		$this->assertTrue($rootView->$method('sub'));
-
-		$this->assertFalse($rootView->file_exists('sub'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testUnlinkRootMustFail(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$rootView->file_put_contents('/substorage/bar.txt', 'asd');
-
-		$this->assertFalse($rootView->unlink(''));
-		$this->assertFalse($rootView->unlink('/'));
-		$this->assertFalse($rootView->unlink('substorage'));
-		$this->assertFalse($rootView->unlink('/substorage'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testTouch(): void {
-		$storage = $this->getTestStorage(true, TemporaryNoTouch::class);
-
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		$oldCachedData = $rootView->getFileInfo('foo.txt');
-
-		$rootView->touch('foo.txt', 500);
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(500, $cachedData['mtime']);
-		$this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
-
-		$rootView->putFileInfo('foo.txt', ['storage_mtime' => 1000]); //make sure the watcher detects the change
-		$rootView->file_put_contents('foo.txt', 'asd');
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertGreaterThanOrEqual($oldCachedData['mtime'], $cachedData['mtime']);
-		$this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testTouchFloat(): void {
-		$storage = $this->getTestStorage(true, TemporaryNoTouch::class);
-
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		$oldCachedData = $rootView->getFileInfo('foo.txt');
-
-		$rootView->touch('foo.txt', 500.5);
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(500, $cachedData['mtime']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testViewHooks(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '/substorage');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
-
-		$rootView = new View('');
-		$subView = new View($defaultRoot . '/substorage');
-		$this->hookPath = null;
-
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$this->assertNull($this->hookPath);
-
-		$subView->file_put_contents('/foo.txt', 'asd');
-		$this->assertEquals('/substorage/foo.txt', $this->hookPath);
-	}
-
-	private $hookPath;
-
-	public function dummyHook($params) {
-		$this->hookPath = $params['path'];
-	}
-
-	public function testSearchNotOutsideView(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		$storage1->rename('folder', 'foo');
-		$scanner = $storage1->getScanner();
-		$scanner->scan('');
-
-		$view = new View('/foo');
-
-		$result = $view->search('.txt');
-		$this->assertCount(1, $result);
-	}
-
-	/**
-	 * @param bool $scan
-	 * @param string $class
-	 * @return Storage
-	 */
-	private function getTestStorage($scan = true, $class = Temporary::class) {
-		/**
-		 * @var Storage $storage
-		 */
-		$storage = new $class([]);
-		$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);
-
-		if ($scan) {
-			$scanner = $storage->getScanner();
-			$scanner->scan('');
-		}
-		$this->storages[] = $storage;
-		return $storage;
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testViewHooksIfRootStartsTheSame(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '_substorage');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
-
-		$subView = new View($defaultRoot . '_substorage');
-		$this->hookPath = null;
-
-		$subView->file_put_contents('/foo.txt', 'asd');
-		$this->assertNull($this->hookPath);
-	}
-
-	private $hookWritePath;
-	private $hookCreatePath;
-	private $hookUpdatePath;
-
-	public function dummyHookWrite($params) {
-		$this->hookWritePath = $params['path'];
-	}
-
-	public function dummyHookUpdate($params) {
-		$this->hookUpdatePath = $params['path'];
-	}
-
-	public function dummyHookCreate($params) {
-		$this->hookCreatePath = $params['path'];
-	}
-
-	public function testEditNoCreateHook(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot);
-		\OC_Hook::connect('OC_Filesystem', 'post_create', $this, 'dummyHookCreate');
-		\OC_Hook::connect('OC_Filesystem', 'post_update', $this, 'dummyHookUpdate');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHookWrite');
-
-		$view = new View($defaultRoot);
-		$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
-
-		$view->file_put_contents('/asd.txt', 'foo');
-		$this->assertEquals('/asd.txt', $this->hookCreatePath);
-		$this->assertNull($this->hookUpdatePath);
-		$this->assertEquals('/asd.txt', $this->hookWritePath);
-
-		$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
-
-		$view->file_put_contents('/asd.txt', 'foo');
-		$this->assertNull($this->hookCreatePath);
-		$this->assertEquals('/asd.txt', $this->hookUpdatePath);
-		$this->assertEquals('/asd.txt', $this->hookWritePath);
-
-		\OC_Hook::clear('OC_Filesystem', 'post_create');
-		\OC_Hook::clear('OC_Filesystem', 'post_update');
-		\OC_Hook::clear('OC_Filesystem', 'post_write');
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('resolvePathTestProvider')]
-	public function testResolvePath($expected, $pathToTest): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$view = new View('');
-
-		$result = $view->resolvePath($pathToTest);
-		$this->assertEquals($expected, $result[1]);
-
-		$exists = $view->file_exists($pathToTest);
-		$this->assertTrue($exists);
-
-		$exists = $view->file_exists($result[1]);
-		$this->assertTrue($exists);
-	}
-
-	public static function resolvePathTestProvider(): array {
-		return [
-			['foo.txt', 'foo.txt'],
-			['foo.txt', '/foo.txt'],
-			['folder', 'folder'],
-			['folder', '/folder'],
-			['folder', 'folder/'],
-			['folder', '/folder/'],
-			['folder/bar.txt', 'folder/bar.txt'],
-			['folder/bar.txt', '/folder/bar.txt'],
-			['', ''],
-			['', '/'],
-		];
-	}
-
-	public function testUTF8Names(): void {
-		$names = ['虚', '和知しゃ和で', 'regular ascii', 'sɨˈrɪlɪk', 'ѨѬ', 'أنا أحب القراءة كثيرا'];
-
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		foreach ($names as $name) {
-			$rootView->file_put_contents('/' . $name, 'dummy content');
-		}
-
-		$list = $rootView->getDirectoryContent('/');
-
-		$this->assertCount(count($names), $list);
-		foreach ($list as $item) {
-			$this->assertContains($item['name'], $names);
-		}
-
-		$cache = $storage->getCache();
-		$scanner = $storage->getScanner();
-		$scanner->scan('');
-
-		$list = $cache->getFolderContents('');
-
-		$this->assertCount(count($names), $list);
-		foreach ($list as $item) {
-			$this->assertContains($item['name'], $names);
-		}
-	}
-
-	public function xtestLongPath() {
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-
-		$longPath = '';
-		$ds = DIRECTORY_SEPARATOR;
-		/*
+    use UserTrait;
+
+    /**
+     * @var Storage[] $storages
+     */
+    private $storages = [];
+
+    /**
+     * @var string
+     */
+    private $user;
+
+    /**
+     * @var IUser
+     */
+    private $userObject;
+
+    /**
+     * @var IGroup
+     */
+    private $groupObject;
+
+    /** @var Storage */
+    private $tempStorage;
+
+    protected function setUp(): void {
+        parent::setUp();
+        \OC_Hook::clear();
+
+        Server::get(IUserManager::class)->clearBackends();
+        Server::get(IUserManager::class)->registerBackend(new \Test\Util\User\Dummy());
+
+        //login
+        $userManager = Server::get(IUserManager::class);
+        $groupManager = Server::get(IGroupManager::class);
+        $this->user = 'test';
+        $this->userObject = $userManager->createUser('test', 'test');
+
+        $this->groupObject = $groupManager->createGroup('group1');
+        $this->groupObject->addUser($this->userObject);
+
+        self::loginAsUser($this->user);
+
+        /** @var IMountManager $manager */
+        $manager = Server::get(IMountManager::class);
+        $manager->removeMount('/test');
+
+        $this->tempStorage = null;
+    }
+
+    protected function tearDown(): void {
+        \OC_User::setUserId($this->user);
+        foreach ($this->storages as $storage) {
+            $cache = $storage->getCache();
+            $ids = $cache->getAll();
+            $cache->clear();
+        }
+
+        if ($this->tempStorage) {
+            system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
+        }
+
+        self::logout();
+
+        /** @var SetupManager $setupManager */
+        $setupManager = Server::get(SetupManager::class);
+        $setupManager->setupRoot();
+
+        $this->userObject->delete();
+        $this->groupObject->delete();
+
+        $mountProviderCollection = Server::get(IMountProviderCollection::class);
+        self::invokePrivate($mountProviderCollection, 'providers', [[]]);
+
+        parent::tearDown();
+    }
+
+    /**
+     * @medium
+     */
+    public function testCacheAPI(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+        $root = self::getUniqueID('/');
+        Filesystem::mount($storage1, [], $root . '/');
+        Filesystem::mount($storage2, [], $root . '/substorage');
+        Filesystem::mount($storage3, [], $root . '/folder/anotherstorage');
+        $textSize = strlen("dummy file data\n");
+        $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+        $storageSize = $textSize * 2 + $imageSize;
+
+        $storageInfo = $storage3->getCache()->get('');
+        $this->assertEquals($storageSize, $storageInfo['size']);
+
+        $rootView = new View($root);
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertEquals($textSize, $cachedData['size']);
+        $this->assertEquals('text/plain', $cachedData['mimetype']);
+        $this->assertNotEquals(-1, $cachedData['permissions']);
+
+        $cachedData = $rootView->getFileInfo('/');
+        $this->assertEquals($storageSize * 3, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        // get cached data excluding mount points
+        $cachedData = $rootView->getFileInfo('/', false);
+        $this->assertEquals($storageSize, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        $cachedData = $rootView->getFileInfo('/folder');
+        $this->assertEquals($storageSize + $textSize, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        $folderData = $rootView->getDirectoryContent('/');
+        /**
+         * expected entries:
+         * folder
+         * foo.png
+         * foo.txt
+         * substorage
+         */
+        $this->assertCount(4, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+        $this->assertEquals('substorage', $folderData[3]['name']);
+
+        $this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
+        $this->assertEquals($imageSize, $folderData[1]['size']);
+        $this->assertEquals($textSize, $folderData[2]['size']);
+        $this->assertEquals($storageSize, $folderData[3]['size']);
+
+        $folderData = $rootView->getDirectoryContent('/substorage');
+        /**
+         * expected entries:
+         * folder
+         * foo.png
+         * foo.txt
+         */
+        $this->assertCount(3, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+
+        $folderView = new View($root . '/folder');
+        $this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertFalse($cachedData['encrypted']);
+        $id = $rootView->putFileInfo('/foo.txt', ['encrypted' => true]);
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertTrue($cachedData['encrypted']);
+        $this->assertEquals($cachedData['fileid'], $id);
+
+        $this->assertFalse($rootView->getFileInfo('/non/existing'));
+        $this->assertEquals([], $rootView->getDirectoryContent('/non/existing'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testGetPath(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('test');
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+
+        Filesystem::mount($storage1, [], '/test/files');
+        Filesystem::mount($storage2, [], '/test/files/substorage');
+        Filesystem::mount($storage3, [], '/test/files/folder/anotherstorage');
+
+        $userMountCache = Server::get(IUserMountCache::class);
+        $userMountCache->registerMounts($user, [
+            new MountPoint($storage1, '/test/files'),
+            new MountPoint($storage2, '/test/files/substorage'),
+            new MountPoint($storage3, '/test/files/folder/anotherstorage'),
+        ]);
+
+        $rootView = new View('/test/files');
+
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $id1 = $cachedData->getId();
+        $this->assertEquals('/foo.txt', $rootView->getPath($id1));
+
+        $cachedData = $rootView->getFileInfo('/substorage/foo.txt');
+        $id2 = $cachedData->getId();
+        $this->assertEquals('/substorage/foo.txt', $rootView->getPath($id2));
+
+        $folderView = new View('/test/files/substorage');
+        $this->assertEquals('/foo.txt', $folderView->getPath($id2));
+    }
+
+
+    public function testGetPathNotExisting(): void {
+        $this->expectException(NotFoundException::class);
+
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $rootView = new View('');
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        /** @var int $id1 */
+        $id1 = $cachedData['fileid'];
+        $folderView = new View('/substorage');
+        $this->assertNull($folderView->getPath($id1));
+    }
+
+    /**
+     * @medium
+     */
+    public function testMountPointOverwrite(): void {
+        $storage1 = $this->getTestStorage(false);
+        $storage2 = $this->getTestStorage();
+        $storage1->mkdir('substorage');
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $folderContent = $rootView->getDirectoryContent('/');
+        $this->assertCount(4, $folderContent);
+    }
+
+    public static function sharingDisabledPermissionProvider(): array {
+        return [
+            ['no', '', true],
+            ['yes', 'group1', false],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('sharingDisabledPermissionProvider')]
+    public function testRemoveSharePermissionWhenSharingDisabledForUser($excludeGroups, $excludeGroupsList, $expectedShareable): void {
+        // Reset sharing disabled for users cache
+        self::invokePrivate(Server::get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
+
+        $config = Server::get(IConfig::class);
+        $oldExcludeGroupsFlag = $config->getAppValue('core', 'shareapi_exclude_groups', 'no');
+        $oldExcludeGroupsList = $config->getAppValue('core', 'shareapi_exclude_groups_list', '');
+        $config->setAppValue('core', 'shareapi_exclude_groups', $excludeGroups);
+        $config->setAppValue('core', 'shareapi_exclude_groups_list', $excludeGroupsList);
+
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/mount');
+
+        $view = new View('/');
+
+        $folderContent = $view->getDirectoryContent('');
+        $this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
+
+        $folderContent = $view->getDirectoryContent('mount');
+        $this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
+
+        $config->setAppValue('core', 'shareapi_exclude_groups', $oldExcludeGroupsFlag);
+        $config->setAppValue('core', 'shareapi_exclude_groups_list', $oldExcludeGroupsList);
+
+        // Reset sharing disabled for users cache
+        self::invokePrivate(Server::get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
+    }
+
+    public function testCacheIncompleteFolder(): void {
+        $storage1 = $this->getTestStorage(false);
+        Filesystem::mount($storage1, [], '/incomplete');
+        $rootView = new View('/incomplete');
+
+        $entries = $rootView->getDirectoryContent('/');
+        $this->assertCount(3, $entries);
+
+        // /folder will already be in the cache but not scanned
+        $entries = $rootView->getDirectoryContent('/folder');
+        $this->assertCount(1, $entries);
+    }
+
+    public function testAutoScan(): void {
+        $storage1 = $this->getTestStorage(false);
+        $storage2 = $this->getTestStorage(false);
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+        $textSize = strlen("dummy file data\n");
+
+        $rootView = new View('');
+
+        $cachedData = $rootView->getFileInfo('/');
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+        $this->assertEquals(-1, $cachedData['size']);
+
+        $folderData = $rootView->getDirectoryContent('/substorage/folder');
+        $this->assertEquals('text/plain', $folderData[0]['mimetype']);
+        $this->assertEquals($textSize, $folderData[0]['size']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testSearch(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+        Filesystem::mount($storage3, [], '/folder/anotherstorage');
+
+        $rootView = new View('');
+
+        $results = $rootView->search('foo');
+        $this->assertCount(6, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $this->assertEquals($result['path'], Filesystem::normalizePath($result['path']));
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/foo.txt', $paths);
+        $this->assertContains('/foo.png', $paths);
+        $this->assertContains('/substorage/foo.txt', $paths);
+        $this->assertContains('/substorage/foo.png', $paths);
+        $this->assertContains('/folder/anotherstorage/foo.txt', $paths);
+        $this->assertContains('/folder/anotherstorage/foo.png', $paths);
+
+        $folderView = new View('/folder');
+        $results = $folderView->search('bar');
+        $this->assertCount(2, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/anotherstorage/folder/bar.txt', $paths);
+        $this->assertContains('/bar.txt', $paths);
+
+        $results = $folderView->search('foo');
+        $this->assertCount(2, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/anotherstorage/foo.txt', $paths);
+        $this->assertContains('/anotherstorage/foo.png', $paths);
+
+        $this->assertCount(6, $rootView->searchByMime('text'));
+        $this->assertCount(3, $folderView->searchByMime('text'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testWatcher(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        $storage1->getWatcher()->setPolicy(Watcher::CHECK_ALWAYS);
+
+        $rootView = new View('');
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(16, $cachedData['size']);
+
+        $rootView->putFileInfo('foo.txt', ['storage_mtime' => 10]);
+        $storage1->file_put_contents('foo.txt', 'foo');
+        clearstatcache();
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(3, $cachedData['size']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageNoCross(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageCross(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageCrossNonLocal(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    public function copyBetweenStorages($storage1, $storage2) {
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->mkdir('substorage/emptyfolder');
+        $rootView->copy('substorage', 'anotherfolder');
+        $this->assertTrue($rootView->is_dir('/anotherfolder'));
+        $this->assertTrue($rootView->is_dir('/substorage'));
+        $this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
+        $this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
+        $this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
+        $this->assertTrue($rootView->file_exists('/substorage/foo.png'));
+        $this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageNoCross(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageCross(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageCrossNonLocal(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    public function moveBetweenStorages($storage1, $storage2) {
+        Filesystem::mount($storage1, [], '/' . $this->user . '/');
+        Filesystem::mount($storage2, [], '/' . $this->user . '/substorage');
+
+        $rootView = new View('/' . $this->user);
+        $rootView->rename('foo.txt', 'substorage/folder/foo.txt');
+        $this->assertFalse($rootView->file_exists('foo.txt'));
+        $this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
+        $rootView->rename('substorage/folder', 'anotherfolder');
+        $this->assertFalse($rootView->is_dir('substorage/folder'));
+        $this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
+        $this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testUnlink(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $rootView->file_put_contents('/substorage/bar.txt', 'asd');
+
+        $this->assertTrue($rootView->file_exists('foo.txt'));
+        $this->assertTrue($rootView->file_exists('substorage/bar.txt'));
+
+        $this->assertTrue($rootView->unlink('foo.txt'));
+        $this->assertTrue($rootView->unlink('substorage/bar.txt'));
+
+        $this->assertFalse($rootView->file_exists('foo.txt'));
+        $this->assertFalse($rootView->file_exists('substorage/bar.txt'));
+    }
+
+    public static function rmdirOrUnlinkDataProvider(): array {
+        return [['rmdir'], ['unlink']];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('rmdirOrUnlinkDataProvider')]
+    public function testRmdir($method): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $rootView = new View('');
+        $rootView->mkdir('sub');
+        $rootView->mkdir('sub/deep');
+        $rootView->file_put_contents('/sub/deep/foo.txt', 'asd');
+
+        $this->assertTrue($rootView->file_exists('sub/deep/foo.txt'));
+
+        $this->assertTrue($rootView->$method('sub'));
+
+        $this->assertFalse($rootView->file_exists('sub'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testUnlinkRootMustFail(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $rootView->file_put_contents('/substorage/bar.txt', 'asd');
+
+        $this->assertFalse($rootView->unlink(''));
+        $this->assertFalse($rootView->unlink('/'));
+        $this->assertFalse($rootView->unlink('substorage'));
+        $this->assertFalse($rootView->unlink('/substorage'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testTouch(): void {
+        $storage = $this->getTestStorage(true, TemporaryNoTouch::class);
+
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        $oldCachedData = $rootView->getFileInfo('foo.txt');
+
+        $rootView->touch('foo.txt', 500);
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(500, $cachedData['mtime']);
+        $this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
+
+        $rootView->putFileInfo('foo.txt', ['storage_mtime' => 1000]); //make sure the watcher detects the change
+        $rootView->file_put_contents('foo.txt', 'asd');
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertGreaterThanOrEqual($oldCachedData['mtime'], $cachedData['mtime']);
+        $this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testTouchFloat(): void {
+        $storage = $this->getTestStorage(true, TemporaryNoTouch::class);
+
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        $oldCachedData = $rootView->getFileInfo('foo.txt');
+
+        $rootView->touch('foo.txt', 500.5);
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(500, $cachedData['mtime']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testViewHooks(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot . '/substorage');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
+
+        $rootView = new View('');
+        $subView = new View($defaultRoot . '/substorage');
+        $this->hookPath = null;
+
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $this->assertNull($this->hookPath);
+
+        $subView->file_put_contents('/foo.txt', 'asd');
+        $this->assertEquals('/substorage/foo.txt', $this->hookPath);
+    }
+
+    private $hookPath;
+
+    public function dummyHook($params) {
+        $this->hookPath = $params['path'];
+    }
+
+    public function testSearchNotOutsideView(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        $storage1->rename('folder', 'foo');
+        $scanner = $storage1->getScanner();
+        $scanner->scan('');
+
+        $view = new View('/foo');
+
+        $result = $view->search('.txt');
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * @param bool $scan
+     * @param string $class
+     * @return Storage
+     */
+    private function getTestStorage($scan = true, $class = Temporary::class) {
+        /**
+         * @var Storage $storage
+         */
+        $storage = new $class([]);
+        $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);
+
+        if ($scan) {
+            $scanner = $storage->getScanner();
+            $scanner->scan('');
+        }
+        $this->storages[] = $storage;
+        return $storage;
+    }
+
+    /**
+     * @medium
+     */
+    public function testViewHooksIfRootStartsTheSame(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot . '_substorage');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
+
+        $subView = new View($defaultRoot . '_substorage');
+        $this->hookPath = null;
+
+        $subView->file_put_contents('/foo.txt', 'asd');
+        $this->assertNull($this->hookPath);
+    }
+
+    private $hookWritePath;
+    private $hookCreatePath;
+    private $hookUpdatePath;
+
+    public function dummyHookWrite($params) {
+        $this->hookWritePath = $params['path'];
+    }
+
+    public function dummyHookUpdate($params) {
+        $this->hookUpdatePath = $params['path'];
+    }
+
+    public function dummyHookCreate($params) {
+        $this->hookCreatePath = $params['path'];
+    }
+
+    public function testEditNoCreateHook(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot);
+        \OC_Hook::connect('OC_Filesystem', 'post_create', $this, 'dummyHookCreate');
+        \OC_Hook::connect('OC_Filesystem', 'post_update', $this, 'dummyHookUpdate');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHookWrite');
+
+        $view = new View($defaultRoot);
+        $this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
+
+        $view->file_put_contents('/asd.txt', 'foo');
+        $this->assertEquals('/asd.txt', $this->hookCreatePath);
+        $this->assertNull($this->hookUpdatePath);
+        $this->assertEquals('/asd.txt', $this->hookWritePath);
+
+        $this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
+
+        $view->file_put_contents('/asd.txt', 'foo');
+        $this->assertNull($this->hookCreatePath);
+        $this->assertEquals('/asd.txt', $this->hookUpdatePath);
+        $this->assertEquals('/asd.txt', $this->hookWritePath);
+
+        \OC_Hook::clear('OC_Filesystem', 'post_create');
+        \OC_Hook::clear('OC_Filesystem', 'post_update');
+        \OC_Hook::clear('OC_Filesystem', 'post_write');
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('resolvePathTestProvider')]
+    public function testResolvePath($expected, $pathToTest): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $view = new View('');
+
+        $result = $view->resolvePath($pathToTest);
+        $this->assertEquals($expected, $result[1]);
+
+        $exists = $view->file_exists($pathToTest);
+        $this->assertTrue($exists);
+
+        $exists = $view->file_exists($result[1]);
+        $this->assertTrue($exists);
+    }
+
+    public static function resolvePathTestProvider(): array {
+        return [
+            ['foo.txt', 'foo.txt'],
+            ['foo.txt', '/foo.txt'],
+            ['folder', 'folder'],
+            ['folder', '/folder'],
+            ['folder', 'folder/'],
+            ['folder', '/folder/'],
+            ['folder/bar.txt', 'folder/bar.txt'],
+            ['folder/bar.txt', '/folder/bar.txt'],
+            ['', ''],
+            ['', '/'],
+        ];
+    }
+
+    public function testUTF8Names(): void {
+        $names = ['虚', '和知しゃ和で', 'regular ascii', 'sɨˈrɪlɪk', 'ѨѬ', 'أنا أحب القراءة كثيرا'];
+
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        foreach ($names as $name) {
+            $rootView->file_put_contents('/' . $name, 'dummy content');
+        }
+
+        $list = $rootView->getDirectoryContent('/');
+
+        $this->assertCount(count($names), $list);
+        foreach ($list as $item) {
+            $this->assertContains($item['name'], $names);
+        }
+
+        $cache = $storage->getCache();
+        $scanner = $storage->getScanner();
+        $scanner->scan('');
+
+        $list = $cache->getFolderContents('');
+
+        $this->assertCount(count($names), $list);
+        foreach ($list as $item) {
+            $this->assertContains($item['name'], $names);
+        }
+    }
+
+    public function xtestLongPath() {
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+
+        $longPath = '';
+        $ds = DIRECTORY_SEPARATOR;
+        /*
 		 * 4096 is the maximum path length in file_cache.path in *nix
 		 * 1024 is the max path length in mac
 		 */
-		$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
-		$tmpdirLength = strlen(Server::get(ITempManager::class)->getTemporaryFolder());
-		if (\OC_Util::runningOnMac()) {
-			$depth = ((1024 - $tmpdirLength) / 57);
-		} else {
-			$depth = ((4000 - $tmpdirLength) / 57);
-		}
-		foreach (range(0, $depth - 1) as $i) {
-			$longPath .= $ds . $folderName;
-			$result = $rootView->mkdir($longPath);
-			$this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
-
-			$result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
-			$this->assertEquals(5, $result, "file_put_contents failed on $i");
-
-			$this->assertTrue($rootView->file_exists($longPath));
-			$this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
-		}
-
-		$cache = $storage->getCache();
-		$scanner = $storage->getScanner();
-		$scanner->scan('');
-
-		$longPath = $folderName;
-		foreach (range(0, $depth - 1) as $i) {
-			$cachedFolder = $cache->get($longPath);
-			$this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
-			$this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
-
-			$cachedFile = $cache->get($longPath . '/test.txt');
-			$this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
-			$this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
-
-			$longPath .= $ds . $folderName;
-		}
-	}
-
-	public function testTouchNotSupported(): void {
-		$storage = new TemporaryNoTouch([]);
-		$scanner = $storage->getScanner();
-		Filesystem::mount($storage, [], '/test/');
-		$past = time() - 100;
-		$storage->file_put_contents('test', 'foobar');
-		$scanner->scan('');
-		$view = new View('');
-		$info = $view->getFileInfo('/test/test');
-
-		$view->touch('/test/test', $past);
-		$scanner->scanFile('test', Scanner::REUSE_ETAG);
-
-		$info2 = $view->getFileInfo('/test/test');
-		$this->assertSame($info['etag'], $info2['etag']);
-	}
-
-	public function testWatcherEtagCrossStorage(): void {
-		$storage1 = new Temporary([]);
-		$storage2 = new Temporary([]);
-		$scanner1 = $storage1->getScanner();
-		$scanner2 = $storage2->getScanner();
-		$storage1->mkdir('sub');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		$past = time() - 100;
-		$storage2->file_put_contents('test.txt', 'foobar');
-		$scanner1->scan('');
-		$scanner2->scan('');
-		$view = new View('');
-
-		$storage2->getWatcher('')->setPolicy(Watcher::CHECK_ALWAYS);
-
-		$oldFileInfo = $view->getFileInfo('/test/sub/storage/test.txt');
-		$oldFolderInfo = $view->getFileInfo('/test');
-
-		$storage2->getCache()->update($oldFileInfo->getId(), [
-			'storage_mtime' => $past,
-		]);
-
-		$oldEtag = $oldFolderInfo->getEtag();
-
-		$view->getFileInfo('/test/sub/storage/test.txt');
-		$newFolderInfo = $view->getFileInfo('/test');
-
-		$this->assertNotEquals($newFolderInfo->getEtag(), $oldEtag);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('absolutePathProvider')]
-	public function testGetAbsolutePath($expectedPath, $relativePath): void {
-		$view = new View('/files');
-		$this->assertEquals($expectedPath, $view->getAbsolutePath($relativePath));
-	}
-
-	public function testPartFileInfo(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		Filesystem::mount($storage, [], '/test/');
-		$sizeWritten = $storage->file_put_contents('test.part', 'foobar');
-		$scanner->scan('');
-		$view = new View('/test');
-		$info = $view->getFileInfo('test.part');
-
-		$this->assertInstanceOf('\OCP\Files\FileInfo', $info);
-		$this->assertNull($info->getId());
-		$this->assertEquals(6, $sizeWritten);
-		$this->assertEquals(6, $info->getSize());
-		$this->assertEquals('foobar', $view->file_get_contents('test.part'));
-	}
-
-	public static function absolutePathProvider(): array {
-		return [
-			['/files/', ''],
-			['/files/0', '0'],
-			['/files/false', 'false'],
-			['/files/true', 'true'],
-			['/files/', '/'],
-			['/files/test', 'test'],
-			['/files/test', '/test'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('chrootRelativePathProvider')]
-	public function testChrootGetRelativePath($root, $absolutePath, $expectedPath): void {
-		$view = new View('/files');
-		$view->chroot($root);
-		$this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
-	}
-
-	public static function chrootRelativePathProvider(): array {
-		return self::relativePathProvider('/');
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('initRelativePathProvider')]
-	public function testInitGetRelativePath($root, $absolutePath, $expectedPath): void {
-		$view = new View($root);
-		$this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
-	}
-
-	public static function initRelativePathProvider(): array {
-		return self::relativePathProvider(null);
-	}
-
-	public static function relativePathProvider($missingRootExpectedPath): array {
-		return [
-			// No root - returns the path
-			['', '/files', '/files'],
-			['', '/files/', '/files/'],
-
-			// Root equals path - /
-			['/files/', '/files/', '/'],
-			['/files/', '/files', '/'],
-			['/files', '/files/', '/'],
-			['/files', '/files', '/'],
-
-			// False negatives: chroot fixes those by adding the leading slash.
-			// But setting them up with this root (instead of chroot($root))
-			// will fail them, although they should be the same.
-			// TODO init should be fixed, so it also adds the leading slash
-			['files/', '/files/', $missingRootExpectedPath],
-			['files', '/files/', $missingRootExpectedPath],
-			['files/', '/files', $missingRootExpectedPath],
-			['files', '/files', $missingRootExpectedPath],
-
-			// False negatives: Paths provided to the method should have a leading slash
-			// TODO input should be checked to have a leading slash
-			['/files/', 'files/', null],
-			['/files', 'files/', null],
-			['/files/', 'files', null],
-			['/files', 'files', null],
-
-			// with trailing slashes
-			['/files/', '/files/0', '0'],
-			['/files/', '/files/false', 'false'],
-			['/files/', '/files/true', 'true'],
-			['/files/', '/files/test', 'test'],
-			['/files/', '/files/test/foo', 'test/foo'],
-
-			// without trailing slashes
-			// TODO false expectation: Should match "with trailing slashes"
-			['/files', '/files/0', '/0'],
-			['/files', '/files/false', '/false'],
-			['/files', '/files/true', '/true'],
-			['/files', '/files/test', '/test'],
-			['/files', '/files/test/foo', '/test/foo'],
-
-			// leading slashes
-			['/files/', '/files_trashbin/', null],
-			['/files', '/files_trashbin/', null],
-			['/files/', '/files_trashbin', null],
-			['/files', '/files_trashbin', null],
-
-			// no leading slashes
-			['files/', 'files_trashbin/', null],
-			['files', 'files_trashbin/', null],
-			['files/', 'files_trashbin', null],
-			['files', 'files_trashbin', null],
-
-			// mixed leading slashes
-			['files/', '/files_trashbin/', null],
-			['/files/', 'files_trashbin/', null],
-			['files', '/files_trashbin/', null],
-			['/files', 'files_trashbin/', null],
-			['files/', '/files_trashbin', null],
-			['/files/', 'files_trashbin', null],
-			['files', '/files_trashbin', null],
-			['/files', 'files_trashbin', null],
-
-			['files', 'files_trashbin/test', null],
-			['/files', '/files_trashbin/test', null],
-			['/files', 'files_trashbin/test', null],
-		];
-	}
-
-	public function testFileView(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-		$view = new View('/test/foo.txt');
-
-		$this->assertEquals('bar', $view->file_get_contents(''));
-		$fh = tmpfile();
-		fwrite($fh, 'foo');
-		rewind($fh);
-		$view->file_put_contents('', $fh);
-		$this->assertEquals('foo', $view->file_get_contents(''));
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('tooLongPathDataProvider')]
-	public function testTooLongPath($operation, $param0 = null): void {
-		$this->expectException(InvalidPathException::class);
-
-
-		$longPath = '';
-		// 4000 is the maximum path length in file_cache.path
-		$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
-		$depth = (4000 / 57);
-		foreach (range(0, $depth + 1) as $i) {
-			$longPath .= '/' . $folderName;
-		}
-
-		$storage = new Temporary([]);
-		$this->tempStorage = $storage; // for later hard cleanup
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-
-		if ($param0 === '@0') {
-			$param0 = $longPath;
-		}
-
-		if ($operation === 'hash') {
-			$param0 = $longPath;
-			$longPath = 'md5';
-		}
-
-		call_user_func([$rootView, $operation], $longPath, $param0);
-	}
-
-	public static function tooLongPathDataProvider(): array {
-		return [
-			['getAbsolutePath'],
-			['getRelativePath'],
-			['getMountPoint'],
-			['resolvePath'],
-			['getLocalFile'],
-			['mkdir'],
-			['rmdir'],
-			['opendir'],
-			['is_dir'],
-			['is_file'],
-			['stat'],
-			['filetype'],
-			['filesize'],
-			['readfile'],
-			['isCreatable'],
-			['isReadable'],
-			['isUpdatable'],
-			['isDeletable'],
-			['isSharable'],
-			['file_exists'],
-			['filemtime'],
-			['touch'],
-			['file_get_contents'],
-			['unlink'],
-			['deleteAll'],
-			['toTmpFile'],
-			['getMimeType'],
-			['free_space'],
-			['getFileInfo'],
-			['getDirectoryContent'],
-			['getOwner'],
-			['getETag'],
-			['file_put_contents', 'ipsum'],
-			['rename', '@0'],
-			['copy', '@0'],
-			['fopen', 'r'],
-			['fromTmpFile', '@0'],
-			['hash'],
-			['hasUpdated', 0],
-			['putFileInfo', []],
-		];
-	}
-
-	public function testRenameCrossStoragePreserveMtime(): void {
-		$storage1 = new Temporary([]);
-		$storage2 = new Temporary([]);
-		$storage1->mkdir('sub');
-		$storage1->mkdir('foo');
-		$storage1->file_put_contents('foo.txt', 'asd');
-		$storage1->file_put_contents('foo/bar.txt', 'asd');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		$view = new View('');
-		$time = time() - 200;
-		$view->touch('/test/foo.txt', $time);
-		$view->touch('/test/foo', $time);
-		$view->touch('/test/foo/bar.txt', $time);
-
-		$view->rename('/test/foo.txt', '/test/sub/storage/foo.txt');
-
-		$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo.txt'));
-
-		$view->rename('/test/foo', '/test/sub/storage/foo');
-
-		$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo/bar.txt'));
-	}
-
-	public function testRenameFailDeleteTargetKeepSource(): void {
-		$this->doTestCopyRenameFail('rename');
-	}
-
-	public function testCopyFailDeleteTargetKeepSource(): void {
-		$this->doTestCopyRenameFail('copy');
-	}
-
-	private function doTestCopyRenameFail($operation) {
-		$storage1 = new Temporary([]);
-		/** @var \PHPUnit\Framework\MockObject\MockObject|Temporary $storage2 */
-		$storage2 = $this->getMockBuilder(TemporaryNoCross::class)
-			->setConstructorArgs([[]])
-			->onlyMethods(['fopen', 'writeStream'])
-			->getMock();
-
-		$storage2->method('writeStream')
-			->willThrowException(new GenericFileException('Failed to copy stream'));
-
-		$storage1->mkdir('sub');
-		$storage1->file_put_contents('foo.txt', '0123456789ABCDEFGH');
-		$storage1->mkdir('dirtomove');
-		$storage1->file_put_contents('dirtomove/indir1.txt', '0123456'); // fits
-		$storage1->file_put_contents('dirtomove/indir2.txt', '0123456789ABCDEFGH'); // doesn't fit
-		$storage2->file_put_contents('existing.txt', '0123');
-		$storage1->getScanner()->scan('');
-		$storage2->getScanner()->scan('');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		// move file
-		$view = new View('');
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-		$this->assertFalse($storage2->file_exists('foo.txt'));
-		$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/foo.txt'));
-		$this->assertFalse($storage2->file_exists('foo.txt'));
-		$this->assertFalse($storage2->getCache()->get('foo.txt'));
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-
-		// if target exists, it will be deleted too
-		$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/existing.txt'));
-		$this->assertFalse($storage2->file_exists('existing.txt'));
-		$this->assertFalse($storage2->getCache()->get('existing.txt'));
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-
-		// move folder
-		$this->assertFalse($view->$operation('/test/dirtomove/', '/test/sub/storage/dirtomove/'));
-		// since the move failed, the full source tree is kept
-		$this->assertTrue($storage1->file_exists('dirtomove/indir1.txt'));
-		$this->assertTrue($storage1->file_exists('dirtomove/indir2.txt'));
-		// second file not moved/copied
-		$this->assertFalse($storage2->file_exists('dirtomove/indir2.txt'));
-		$this->assertFalse($storage2->getCache()->get('dirtomove/indir2.txt'));
-	}
-
-	public function testDeleteFailKeepCache(): void {
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->setConstructorArgs([[]])
-			->onlyMethods(['unlink'])
-			->getMock();
-		$storage->expects($this->once())
-			->method('unlink')
-			->willReturn(false);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->file_put_contents('foo.txt', 'asd');
-		$scanner->scan('');
-		Filesystem::mount($storage, [], '/test/');
-
-		$view = new View('/test');
-
-		$this->assertFalse($view->unlink('foo.txt'));
-		$this->assertTrue($cache->inCache('foo.txt'));
-	}
-
-	public static function directoryTraversalProvider(): array {
-		return [
-			['../test/'],
-			['..\\test\\my/../folder'],
-			['/test/my/../foo\\'],
-		];
-	}
-
-	/**
-	 * @param string $root
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('directoryTraversalProvider')]
-	public function testConstructDirectoryTraversalException($root): void {
-		$this->expectException(\Exception::class);
-
-		new View($root);
-	}
-
-	public function testRenameOverWrite(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->mkdir('sub');
-		$storage->mkdir('foo');
-		$storage->file_put_contents('foo.txt', 'asd');
-		$storage->file_put_contents('foo/bar.txt', 'asd');
-		$scanner->scan('');
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('');
-		$this->assertTrue($view->rename('/test/foo.txt', '/test/foo/bar.txt'));
-	}
-
-	public function testSetMountOptionsInStorage(): void {
-		$mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['foo' => 'bar']);
-		Filesystem::getMountManager()->addMount($mount);
-		/** @var Common $storage */
-		$storage = $mount->getStorage();
-		$this->assertEquals($storage->getMountOption('foo'), 'bar');
-	}
-
-	public function testSetMountOptionsWatcherPolicy(): void {
-		$mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['filesystem_check_changes' => Watcher::CHECK_NEVER]);
-		Filesystem::getMountManager()->addMount($mount);
-		/** @var Common $storage */
-		$storage = $mount->getStorage();
-		$watcher = $storage->getWatcher();
-		$this->assertEquals(Watcher::CHECK_NEVER, $watcher->getPolicy());
-	}
-
-	public function testGetAbsolutePathOnNull(): void {
-		$view = new View();
-		$this->assertNull($view->getAbsolutePath(null));
-	}
-
-	public function testGetRelativePathOnNull(): void {
-		$view = new View();
-		$this->assertNull($view->getRelativePath(null));
-	}
-
-
-	public function testNullAsRoot(): void {
-		$this->expectException(\TypeError::class);
-
-		new View(null);
-	}
-
-	/**
-	 * e.g. reading from a folder that's being renamed
-	 *
-	 *
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
-	public function testReadFromWriteLockedPath($rootPath, $pathPrefix): void {
-		$this->expectException(LockedException::class);
-
-		$rootPath = str_replace('{folder}', 'files', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
-	}
-
-	/**
-	 * Reading from a files_encryption folder that's being renamed
-	 *
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
-	public function testReadFromWriteUnlockablePath($rootPath, $pathPrefix): void {
-		$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
-	}
-
-	/**
-	 * e.g. writing a file that's being downloaded
-	 *
-	 *
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
-	public function testWriteToReadLockedFile($rootPath, $pathPrefix): void {
-		$this->expectException(LockedException::class);
-
-		$rootPath = str_replace('{folder}', 'files', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
-	}
-
-	/**
-	 * Writing a file that's being downloaded
-	 *
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
-	public function testWriteToReadUnlockableFile($rootPath, $pathPrefix): void {
-		$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-	}
-
-	/**
-	 * Test that locks are on mount point paths instead of mount root
-	 */
-	public function testLockLocalMountPointPathInsteadOfStorageRoot(): void {
-		$lockingProvider = Server::get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
-
-		$this->assertTrue(
-			$view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, true),
-			'Can lock mount point'
-		);
-
-		// no exception here because storage root was not locked
-		$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$thrown = false;
-		try {
-			$storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Mount point path was locked on root storage');
-
-		$lockingProvider->releaseAll();
-	}
-
-	/**
-	 * Test that locks are on mount point paths and also mount root when requested
-	 */
-	public function testLockStorageRootButNotLocalMountPoint(): void {
-		$lockingProvider = Server::get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
-
-		$this->assertTrue(
-			$view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, false),
-			'Can lock mount point'
-		);
-
-		$thrown = false;
-		try {
-			$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Mount point storage root was locked on original storage');
-
-		// local mount point was not locked
-		$storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$lockingProvider->releaseAll();
-	}
-
-	/**
-	 * Test that locks are on mount point paths and also mount root when requested
-	 */
-	public function testLockMountPointPathFailReleasesBoth(): void {
-		$lockingProvider = Server::get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint.txt');
-
-		// this would happen if someone is writing on the mount point
-		$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$thrown = false;
-		try {
-			// this actually acquires two locks, one on the mount point and one on the storage root,
-			// but the one on the storage root will fail
-			$view->lockFile('/mountpoint.txt', ILockingProvider::LOCK_SHARED);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Cannot acquire shared lock because storage root is already locked');
-
-		// from here we expect that the lock on the local mount point was released properly
-		// so acquiring an exclusive lock will succeed
-		$storage->acquireLock('/testuser/files/mountpoint.txt', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$lockingProvider->releaseAll();
-	}
-
-	public static function dataLockPaths(): array {
-		return [
-			['/testuser/{folder}', ''],
-			['/testuser', '/{folder}'],
-			['', '/testuser/{folder}'],
-		];
-	}
-
-	public static function pathRelativeToFilesProvider(): array {
-		return [
-			['admin/files', ''],
-			['admin/files/x', 'x'],
-			['/admin/files', ''],
-			['/admin/files/sub', 'sub'],
-			['/admin/files/sub/', 'sub'],
-			['/admin/files/sub/sub2', 'sub/sub2'],
-			['//admin//files/sub//sub2', 'sub/sub2'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('pathRelativeToFilesProvider')]
-	public function testGetPathRelativeToFiles($path, $expectedPath): void {
-		$view = new View();
-		$this->assertEquals($expectedPath, $view->getPathRelativeToFiles($path));
-	}
-
-	public static function pathRelativeToFilesProviderExceptionCases(): array {
-		return [
-			[''],
-			['x'],
-			['files'],
-			['/files'],
-			['/admin/files_versions/abc'],
-		];
-	}
-
-	/**
-	 * @param string $path
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('pathRelativeToFilesProviderExceptionCases')]
-	public function testGetPathRelativeToFilesWithInvalidArgument($path): void {
-		$this->expectException(\InvalidArgumentException::class);
-		$this->expectExceptionMessage('$absolutePath must be relative to "files"');
-
-		$view = new View();
-		$view->getPathRelativeToFiles($path);
-	}
-
-	public function testChangeLock(): void {
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$view->lockFile('/test/sub', ILockingProvider::LOCK_SHARED);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-
-		$view->changeLock('//test/sub', ILockingProvider::LOCK_EXCLUSIVE);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-
-		$view->changeLock('test/sub', ILockingProvider::LOCK_SHARED);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-
-		$view->unlockFile('/test/sub/', ILockingProvider::LOCK_SHARED);
-
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-	}
-
-	public static function hookPathProvider(): array {
-		return [
-			['/foo/files', '/foo', true],
-			['/foo/files/bar', '/foo', true],
-			['/foo', '/foo', false],
-			['/foo', '/files/foo', true],
-			['/foo', 'filesfoo', false],
-			['', '/foo/files', true],
-			['', '/foo/files/bar.txt', true],
-		];
-	}
-
-	/**
-	 * @param $root
-	 * @param $path
-	 * @param $shouldEmit
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('hookPathProvider')]
-	public function testHookPaths($root, $path, $shouldEmit): void {
-		$filesystemReflection = new \ReflectionClass(Filesystem::class);
-		$defaultRootValue = $filesystemReflection->getProperty('defaultInstance');
-		$defaultRootValue->setAccessible(true);
-		$oldRoot = $defaultRootValue->getValue();
-		$defaultView = new View('/foo/files');
-		$defaultRootValue->setValue(null, $defaultView);
-		$view = new View($root);
-		$result = self::invokePrivate($view, 'shouldEmitHooks', [$path]);
-		$defaultRootValue->setValue(null, $oldRoot);
-		$this->assertEquals($shouldEmit, $result);
-	}
-
-	/**
-	 * Create test movable mount points
-	 *
-	 * @param array $mountPoints array of mount point locations
-	 * @return array array of MountPoint objects
-	 */
-	private function createTestMovableMountPoints($mountPoints) {
-		$mounts = [];
-		foreach ($mountPoints as $mountPoint) {
-			$storage = $this->getMockBuilder(Storage::class)
-				->onlyMethods([])
-				->getMock();
-			$storage->method('getId')->willReturn('non-null-id');
-			$storage->method('getStorageCache')->willReturnCallback(function () use ($storage) {
-				return new \OC\Files\Cache\Storage($storage, true, Server::get(IDBConnection::class));
-			});
-
-			$mounts[] = $this->getMockBuilder(TestMoveableMountPoint::class)
-				->onlyMethods(['moveMount'])
-				->setConstructorArgs([$storage, $mountPoint])
-				->getMock();
-		}
-
-		/** @var IMountProvider|\PHPUnit\Framework\MockObject\MockObject $mountProvider */
-		$mountProvider = $this->createMock(IMountProvider::class);
-		$mountProvider->expects($this->any())
-			->method('getMountsForUser')
-			->willReturn($mounts);
-
-		$mountProviderCollection = Server::get(IMountProviderCollection::class);
-		$mountProviderCollection->registerProvider($mountProvider);
-
-		return $mounts;
-	}
-
-	/**
-	 * Test mount point move
-	 */
-	public function testMountPointMove(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-		$mount1->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$mount2->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('sub');
-
-		$this->assertTrue($view->rename('mount1', 'renamed_mount'), 'Can rename mount point');
-		$this->assertTrue($view->rename('mount2', 'sub/moved_mount'), 'Can move a mount point into a subdirectory');
-	}
-
-	public function testMoveMountPointOverwrite(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->never())
-			->method('moveMount');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$this->expectException(ForbiddenException::class);
-		$view->rename('mount1', 'mount2');
-	}
-
-	public function testMoveMountPointIntoMount(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->never())
-			->method('moveMount');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$this->expectException(ForbiddenException::class);
-		$view->rename('mount1', 'mount2/sub');
-	}
-
-	/**
-	 * Test that moving a mount point into a shared folder is forbidden
-	 */
-	public function testMoveMountPointIntoSharedFolder(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('shareddir');
-		$view->mkdir('shareddir/sub');
-		$view->mkdir('shareddir/sub2');
-		// Create a similar named but non-shared folder
-		$view->mkdir('shareddir notshared');
-
-		$fileId = $view->getFileInfo('shareddir')->getId();
-		$userObject = Server::get(IUserManager::class)->createUser('test2', 'IHateNonMockableStaticClasses');
-
-		$userFolder = \OC::$server->getUserFolder($this->user);
-		$shareDir = $userFolder->get('shareddir');
-		$shareManager = Server::get(IShareManager::class);
-		$share = $shareManager->newShare();
-		$share->setSharedWith('test2')
-			->setSharedBy($this->user)
-			->setShareType(IShare::TYPE_USER)
-			->setPermissions(Constants::PERMISSION_READ)
-			->setNode($shareDir);
-		$shareManager->createShare($share);
-
-		try {
-			$view->rename('mount1', 'shareddir');
-			$this->fail('Cannot overwrite shared folder');
-		} catch (ForbiddenException $e) {
-
-		}
-		try {
-			$view->rename('mount1', 'shareddir/sub');
-			$this->fail('Cannot move mount point into shared folder');
-		} catch (ForbiddenException $e) {
-
-		}
-		try {
-			$view->rename('mount1', 'shareddir/sub/sub2');
-			$this->fail('Cannot move mount point into shared subfolder');
-		} catch (ForbiddenException $e) {
-
-		}
-		$this->assertTrue($view->rename('mount2', 'shareddir notshared/sub'), 'Can move mount point into a similarly named but non-shared folder');
-
-		$shareManager->deleteShare($share);
-		$userObject->delete();
-	}
-
-	public static function basicOperationProviderForLocks(): array {
-		return [
-			// --- write hook ----
-			[
-				'touch',
-				['touch-create.txt'],
-				'touch-create.txt',
-				'create',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'fopen',
-				['test-write.txt', 'w'],
-				'test-write.txt',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				null,
-				// exclusive lock stays until fclose
-				ILockingProvider::LOCK_EXCLUSIVE,
-			],
-			[
-				'mkdir',
-				['newdir'],
-				'newdir',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'file_put_contents',
-				['file_put_contents.txt', 'blah'],
-				'file_put_contents.txt',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				0,
-			],
-
-			// ---- delete hook ----
-			[
-				'rmdir',
-				['dir'],
-				'dir',
-				'delete',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'unlink',
-				['test.txt'],
-				'test.txt',
-				'delete',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-
-			// ---- read hook (no post hooks) ----
-			[
-				'file_get_contents',
-				['test.txt'],
-				'test.txt',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				null,
-				false,
-			],
-			[
-				'fopen',
-				['test.txt', 'r'],
-				'test.txt',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-			],
-			[
-				'opendir',
-				['dir'],
-				'dir',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-			],
-
-			// ---- no lock, touch hook ---
-			['touch', ['test.txt'], 'test.txt', 'touch', null, null, null],
-
-			// ---- no hooks, no locks ---
-			['is_dir', ['dir'], 'dir', null],
-			['is_file', ['dir'], 'dir', null],
-			[
-				'stat',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-			[
-				'filetype',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-			[
-				'filesize',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				/* Return an int */
-				100
-			],
-			['isCreatable', ['dir'], 'dir', null],
-			['isReadable', ['dir'], 'dir', null],
-			['isUpdatable', ['dir'], 'dir', null],
-			['isDeletable', ['dir'], 'dir', null],
-			['isSharable', ['dir'], 'dir', null],
-			['file_exists', ['dir'], 'dir', null],
-			[
-				'filemtime',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-		];
-	}
-
-	/**
-	 * Test whether locks are set before and after the operation
-	 *
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $lockedPath path of the locked item to check
-	 * @param string $hookType hook type
-	 * @param int $expectedLockBefore expected lock during pre hooks
-	 * @param int $expectedLockDuring expected lock during operation
-	 * @param int $expectedLockAfter expected lock during post hooks
-	 * @param int $expectedStrayLock expected lock after returning, should
-	 *                               be null (unlock) for most operations
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
-	public function testLockBasicOperation(
-		$operation,
-		$operationArgs,
-		$lockedPath,
-		$hookType,
-		$expectedLockBefore = ILockingProvider::LOCK_SHARED,
-		$expectedLockDuring = ILockingProvider::LOCK_SHARED,
-		$expectedLockAfter = ILockingProvider::LOCK_SHARED,
-		$expectedStrayLock = null,
-		$returnValue = true,
-	): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary&MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		/* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
-		Server::get(ITrashManager::class)->pauseTrash();
-		/* Same thing with encryption wrapper */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		// work directly on disk because mkdir might be mocked
-		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function () use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
-					$lockTypeDuring = $this->getFileLockType($view, $lockedPath);
-
-					return $returnValue;
-				}
-			);
-
-		$this->assertNull($this->getFileLockType($view, $lockedPath), 'File not locked before operation');
-
-		$this->connectMockHooks($hookType, $view, $lockedPath, $lockTypePre, $lockTypePost);
-
-		// do operation
-		call_user_func_array([$view, $operation], $operationArgs);
-
-		if ($hookType !== null) {
-			$this->assertEquals($expectedLockBefore, $lockTypePre, 'File locked properly during pre-hook');
-			$this->assertEquals($expectedLockAfter, $lockTypePost, 'File locked properly during post-hook');
-			$this->assertEquals($expectedLockDuring, $lockTypeDuring, 'File locked properly during operation');
-		} else {
-			$this->assertNull($lockTypeDuring, 'File not locked during operation');
-		}
-
-		$this->assertEquals($expectedStrayLock, $this->getFileLockType($view, $lockedPath));
-
-		/* Resume trash to avoid side effects */
-		Server::get(ITrashManager::class)->resumeTrash();
-	}
-
-	/**
-	 * Test locks for file_put_content with stream.
-	 * This code path uses $storage->fopen instead
-	 */
-	public function testLockFilePutContentWithStream(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$path = 'test_file_put_contents.txt';
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['fopen'])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		$storage->expects($this->once())
-			->method('fopen')
-			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
-					$lockTypeDuring = $this->getFileLockType($view, $path);
-
-					return fopen('php://temp', 'r+');
-				}
-			);
-
-		$this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
-
-		// do operation
-		$view->file_put_contents($path, fopen('php://temp', 'r+'));
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePost, 'File locked properly during post-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
-
-		$this->assertNull($this->getFileLockType($view, $path));
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 */
-	public function testLockFopen(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$path = 'test_file_put_contents.txt';
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['fopen'])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		$storage->expects($this->once())
-			->method('fopen')
-			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
-					$lockTypeDuring = $this->getFileLockType($view, $path);
-
-					return fopen('php://temp', 'r+');
-				}
-			);
-
-		$this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
-
-		// do operation
-		$res = $view->fopen($path, 'w');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
-		$this->assertNull($lockTypePost, 'No post hook, no lock check possible');
-
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File still locked after fopen');
-
-		fclose($res);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File unlocked after fclose');
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 *
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $path path of the locked item to check
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
-	public function testLockBasicOperationUnlocksAfterException(
-		$operation,
-		$operationArgs,
-		$path,
-	): void {
-		if ($operation === 'touch') {
-			$this->markTestSkipped('touch handles storage exceptions internally');
-		}
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		/* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
-		Server::get(ITrashManager::class)->pauseTrash();
-		/* Same thing with encryption wrapper */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		// work directly on disk because mkdir might be mocked
-		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function (): void {
-					throw new \Exception('Simulated exception');
-				}
-			);
-
-		$thrown = false;
-		try {
-			call_user_func_array([$view, $operation], $operationArgs);
-		} catch (\Exception $e) {
-			$thrown = true;
-			$this->assertEquals('Simulated exception', $e->getMessage());
-		}
-		$this->assertTrue($thrown, 'Exception was rethrown');
-		$this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
-
-		/* Resume trash to avoid side effects */
-		Server::get(ITrashManager::class)->resumeTrash();
-	}
-
-	public function testLockBasicOperationUnlocksAfterLockException(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$storage = new Temporary([]);
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		$storage->mkdir('files');
-		$storage->mkdir('files/dir');
-		$storage->file_put_contents('files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		// get a shared lock
-		$handle = $view->fopen('test.txt', 'r');
-
-		$thrown = false;
-		try {
-			// try (and fail) to get a write lock
-			$view->unlink('test.txt');
-		} catch (\Exception $e) {
-			$thrown = true;
-			$this->assertInstanceOf(LockedException::class, $e);
-		}
-		$this->assertTrue($thrown, 'Exception was rethrown');
-
-		// clean shared lock
-		fclose($handle);
-
-		$this->assertNull($this->getFileLockType($view, 'test.txt'), 'File got unlocked');
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 *
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $path path of the locked item to check
-	 * @param string $hookType hook type
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
-	public function testLockBasicOperationUnlocksAfterCancelledHook(
-		$operation,
-		$operationArgs,
-		$path,
-		$hookType,
-	): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			$hookType,
-			HookHelper::class,
-			'cancellingCallback'
-		);
-
-		call_user_func_array([$view, $operation], $operationArgs);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
-	}
-
-	public static function lockFileRenameOrCopyDataProvider(): array {
-		return [
-			['rename', ILockingProvider::LOCK_EXCLUSIVE],
-			['copy', ILockingProvider::LOCK_SHARED],
-		];
-	}
-
-	/**
-	 * Test locks for rename or copy operation
-	 *
-	 *
-	 * @param string $operation operation to be done on the view
-	 * @param int $expectedLockTypeSourceDuring expected lock type on source file during
-	 *                                          the operation
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('lockFileRenameOrCopyDataProvider')]
-	public function testLockFileRename($operation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation, 'getMetaData', 'filemtime'])
-			->getMock();
-
-		$storage->expects($this->any())
-			->method('getMetaData')
-			->willReturn([
-				'mtime' => 1885434487,
-				'etag' => '',
-				'mimetype' => 'text/plain',
-				'permissions' => Constants::PERMISSION_ALL,
-				'size' => 3
-			]);
-		$storage->expects($this->any())
-			->method('filemtime')
-			->willReturn(123456789);
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks($operation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks($operation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		$view->$operation($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
-		$this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-	}
-
-	/**
-	 * simulate a failed copy operation.
-	 * We expect that we catch the exception, free the lock and re-throw it.
-	 *
-	 */
-	public function testLockFileCopyException(): void {
-		$this->expectException(\Exception::class);
-
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['copy'])
-			->getMock();
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-
-		$storage->expects($this->once())
-			->method('copy')
-			->willReturnCallback(
-				function (): void {
-					throw new \Exception();
-				}
-			);
-
-		$this->connectMockHooks('copy', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks('copy', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		try {
-			$view->copy($sourcePath, $targetPath);
-		} catch (\Exception $e) {
-			$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-			$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-			throw $e;
-		}
-	}
-
-	/**
-	 * Test rename operation: unlock first path when second path was locked
-	 */
-	public function testLockFileRenameUnlockOnException(): void {
-		self::loginAsUser('test');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-		$view->file_put_contents($sourcePath, 'meh');
-
-		// simulate that the target path is already locked
-		$view->lockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file is locked before operation');
-
-		$thrown = false;
-		try {
-			$view->rename($sourcePath, $targetPath);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-
-		$this->assertTrue($thrown, 'LockedException thrown');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file still locked after operation');
-
-		$view->unlockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
-	}
-
-	/**
-	 * Test rename operation: unlock first path when second path was locked
-	 */
-	public function testGetOwner(): void {
-		self::loginAsUser('test');
-
-		$view = new View('/test/files/');
-
-		$path = 'foo.txt';
-		$view->file_put_contents($path, 'meh');
-
-		$this->assertEquals('test', $view->getFileInfo($path)->getOwner()->getUID());
-
-		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
-			return $info->getName() === 'foo.txt';
-		}));
-
-		$this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
-
-		$subStorage = new Temporary();
-		Filesystem::mount($subStorage, [], '/test/files/asd');
-
-		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
-			return $info->getName() === 'asd';
-		}));
-
-		$this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
-	}
-
-	public static function lockFileRenameOrCopyCrossStorageDataProvider(): array {
-		return [
-			['rename', 'moveFromStorage', ILockingProvider::LOCK_EXCLUSIVE],
-			['copy', 'copyFromStorage', ILockingProvider::LOCK_SHARED],
-		];
-	}
-
-	/**
-	 * Test locks for rename or copy operation cross-storage
-	 *
-	 *
-	 * @param string $viewOperation operation to be done on the view
-	 * @param string $storageOperation operation to be mocked on the storage
-	 * @param int $expectedLockTypeSourceDuring expected lock type on source file during
-	 *                                          the operation
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('lockFileRenameOrCopyCrossStorageDataProvider')]
-	public function testLockFileRenameCrossStorage($viewOperation, $storageOperation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$storageOperation])
-			->getMock();
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage2 */
-		$storage2 = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$storageOperation, 'getMetaData', 'filemtime'])
-			->getMock();
-
-		$storage2->expects($this->any())
-			->method('getMetaData')
-			->willReturn([
-				'mtime' => 1885434487,
-				'etag' => '',
-				'mimetype' => 'text/plain',
-				'permissions' => Constants::PERMISSION_ALL,
-				'size' => 3
-			]);
-		$storage2->expects($this->any())
-			->method('filemtime')
-			->willReturn(123456789);
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'substorage/target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		Filesystem::mount($storage2, [], $this->user . '/files/substorage');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-		$storage2->getUpdater()->update('');
-
-		$storage->expects($this->never())
-			->method($storageOperation);
-		$storage2->expects($this->once())
-			->method($storageOperation)
-			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks($viewOperation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks($viewOperation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		$view->$viewOperation($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
-		$this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-	}
-
-	/**
-	 * Test locks when moving a mount point
-	 */
-	public function testLockMoveMountPoint(): void {
-		self::loginAsUser('test');
-
-		[$mount] = $this->createTestMovableMountPoints([
-			$this->user . '/files/substorage',
-		]);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('subdir');
-
-		$sourcePath = 'substorage';
-		$targetPath = 'subdir/substorage_moved';
-
-		$mount->expects($this->once())
-			->method('moveMount')
-			->willReturnCallback(
-				function ($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath, true);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath, true);
-
-					$lockTypeSharedRootDuring = $this->getFileLockType($view, $sourcePath, false);
-
-					$mount->setMountPoint($target);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost, true);
-		$this->connectMockHooks('rename', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost, true);
-		// in pre-hook, mount point is still on $sourcePath
-		$this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSharedRootPre, $dummy, false);
-		// in post-hook, mount point is now on $targetPath
-		$this->connectMockHooks('rename', $view, $targetPath, $dummy, $lockTypeSharedRootPost, false);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked before operation');
-
-		$view->rename($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source path locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeSourceDuring, 'Source path locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source path locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target path locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target path locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target path locked properly during post-hook');
-
-		$this->assertNull($lockTypeSharedRootPre, 'Shared storage root not locked during pre-hook');
-		$this->assertNull($lockTypeSharedRootDuring, 'Shared storage root not locked during move');
-		$this->assertNull($lockTypeSharedRootPost, 'Shared storage root not locked during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked after operation');
-	}
-
-	/**
-	 * Connect hook callbacks for hook type
-	 *
-	 * @param string $hookType hook type or null for none
-	 * @param View $view view to check the lock on
-	 * @param string $path path for which to check the lock
-	 * @param int $lockTypePre variable to receive lock type that was active in the pre-hook
-	 * @param int $lockTypePost variable to receive lock type that was active in the post-hook
-	 * @param bool $onMountPoint true to check the mount point instead of the
-	 *                           mounted storage
-	 */
-	private function connectMockHooks($hookType, $view, $path, &$lockTypePre, &$lockTypePost, $onMountPoint = false) {
-		if ($hookType === null) {
-			return;
-		}
-
-		$eventHandler = $this->getMockBuilder(TestEventHandler::class)
-			->onlyMethods(['preCallback', 'postCallback'])
-			->getMock();
-
-		$eventHandler->expects($this->any())
-			->method('preCallback')
-			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePre): void {
-					$lockTypePre = $this->getFileLockType($view, $path, $onMountPoint);
-				}
-			);
-		$eventHandler->expects($this->any())
-			->method('postCallback')
-			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePost): void {
-					$lockTypePost = $this->getFileLockType($view, $path, $onMountPoint);
-				}
-			);
-
-		if ($hookType !== null) {
-			Util::connectHook(
-				Filesystem::CLASSNAME,
-				$hookType,
-				$eventHandler,
-				'preCallback'
-			);
-			Util::connectHook(
-				Filesystem::CLASSNAME,
-				'post_' . $hookType,
-				$eventHandler,
-				'postCallback'
-			);
-		}
-	}
-
-	/**
-	 * Returns the file lock type
-	 *
-	 * @param View $view view
-	 * @param string $path path
-	 * @param bool $onMountPoint true to check the mount point instead of the
-	 *                           mounted storage
-	 *
-	 * @return int lock type or null if file was not locked
-	 */
-	private function getFileLockType(View $view, $path, $onMountPoint = false) {
-		if ($this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE, $onMountPoint)) {
-			return ILockingProvider::LOCK_EXCLUSIVE;
-		} elseif ($this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED, $onMountPoint)) {
-			return ILockingProvider::LOCK_SHARED;
-		}
-		return null;
-	}
-
-
-	public function testRemoveMoveableMountPoint(): void {
-		$mountPoint = '/' . $this->user . '/files/mount/';
-
-		// Mock the mount point
-		/** @var TestMoveableMountPoint|\PHPUnit\Framework\MockObject\MockObject $mount */
-		$mount = $this->createMock(TestMoveableMountPoint::class);
-		$mount->expects($this->once())
-			->method('getMountPoint')
-			->willReturn($mountPoint);
-		$mount->expects($this->once())
-			->method('removeMount')
-			->willReturn('foo');
-		$mount->expects($this->any())
-			->method('getInternalPath')
-			->willReturn('');
-
-		// Register mount
-		Filesystem::getMountManager()->addMount($mount);
-
-		// Listen for events
-		$eventHandler = $this->getMockBuilder(TestEventHandler::class)
-			->onlyMethods(['umount', 'post_umount'])
-			->getMock();
-		$eventHandler->expects($this->once())
-			->method('umount')
-			->with([Filesystem::signal_param_path => '/mount']);
-		$eventHandler->expects($this->once())
-			->method('post_umount')
-			->with([Filesystem::signal_param_path => '/mount']);
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			'umount',
-			$eventHandler,
-			'umount'
-		);
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			'post_umount',
-			$eventHandler,
-			'post_umount'
-		);
-
-		//Delete the mountpoint
-		$view = new View('/' . $this->user . '/files');
-		$this->assertEquals('foo', $view->rmdir('mount'));
-	}
-
-	public static function mimeFilterProvider(): array {
-		return [
-			[null, ['test1.txt', 'test2.txt', 'test3.md', 'test4.png']],
-			['text/plain', ['test1.txt', 'test2.txt']],
-			['text/markdown', ['test3.md']],
-			['text', ['test1.txt', 'test2.txt', 'test3.md']],
-		];
-	}
-
-	/**
-	 * @param string $filter
-	 * @param string[] $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('mimeFilterProvider')]
-	public function testGetDirectoryContentMimeFilter($filter, $expected): void {
-		$storage1 = new Temporary();
-		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
-		$view = new View($root);
-
-		$view->file_put_contents('test1.txt', 'asd');
-		$view->file_put_contents('test2.txt', 'asd');
-		$view->file_put_contents('test3.md', 'asd');
-		$view->file_put_contents('test4.png', '');
-
-		$content = $view->getDirectoryContent('', $filter);
-
-		$files = array_map(function (FileInfo $info) {
-			return $info->getName();
-		}, $content);
-		sort($files);
-
-		$this->assertEquals($expected, $files);
-	}
-
-	public function testFilePutContentsClearsChecksum(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$view = new View('/test/foo.txt');
-		$view->putFileInfo('.', ['checksum' => '42']);
-
-		$this->assertEquals('bar', $view->file_get_contents(''));
-		$fh = tmpfile();
-		fwrite($fh, 'fooo');
-		rewind($fh);
-		clearstatcache();
-		$view->file_put_contents('', $fh);
-		$this->assertEquals('fooo', $view->file_get_contents(''));
-		$data = $view->getFileInfo('.');
-		$this->assertEquals('', $data->getChecksum());
-	}
-
-	public function testDeleteGhostFile(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$storage->unlink('foo.txt');
-
-		$this->assertTrue($cache->inCache('foo.txt'));
-
-		$view = new View('/test');
-		$rootInfo = $view->getFileInfo('');
-		$this->assertEquals(3, $rootInfo->getSize());
-		$view->unlink('foo.txt');
-		$newInfo = $view->getFileInfo('');
-
-		$this->assertFalse($cache->inCache('foo.txt'));
-		$this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
-		$this->assertEquals(0, $newInfo->getSize());
-	}
-
-	public function testDeleteGhostFolder(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->mkdir('foo');
-		$storage->file_put_contents('foo/foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$storage->rmdir('foo');
-
-		$this->assertTrue($cache->inCache('foo'));
-		$this->assertTrue($cache->inCache('foo/foo.txt'));
-
-		$view = new View('/test');
-		$rootInfo = $view->getFileInfo('');
-		$this->assertEquals(3, $rootInfo->getSize());
-		$view->rmdir('foo');
-		$newInfo = $view->getFileInfo('');
-
-		$this->assertFalse($cache->inCache('foo'));
-		$this->assertFalse($cache->inCache('foo/foo.txt'));
-		$this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
-		$this->assertEquals(0, $newInfo->getSize());
-	}
-
-	public function testCreateParentDirectories(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()
-			->onlyMethods([
-				'is_file',
-				'file_exists',
-				'mkdir',
-			])
-			->getMock();
-
-		$view->expects($this->exactly(3))
-			->method('is_file')
-			->willReturnMap([
-				['/new', false],
-				['/new/folder', false],
-				['/new/folder/structure', false],
-			]);
-		$view->expects($this->exactly(3))
-			->method('file_exists')
-			->willReturnMap([
-				['/new', true],
-				['/new/folder', false],
-				['/new/folder/structure', false],
-			]);
-
-		$calls = ['/new/folder', '/new/folder/structure'];
-		$view->expects($this->exactly(2))
-			->method('mkdir')
-			->willReturnCallback(function ($dir) use (&$calls): void {
-				$expected = array_shift($calls);
-				$this->assertEquals($expected, $dir);
-			});
-
-		$this->assertTrue(self::invokePrivate($view, 'createParentDirectories', ['/new/folder/structure']));
-	}
-
-	public function testCreateParentDirectoriesWithExistingFile(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()
-			->onlyMethods([
-				'is_file',
-				'file_exists',
-				'mkdir',
-			])
-			->getMock();
-
-		$view
-			->expects($this->once())
-			->method('is_file')
-			->with('/file.txt')
-			->willReturn(true);
-		$this->assertFalse(self::invokePrivate($view, 'createParentDirectories', ['/file.txt/folder/structure']));
-	}
-
-	public function testCacheExtension(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		$scanner->scan('');
-
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('/test');
-
-		$info = $view->getFileInfo('/foo.txt');
-		$this->assertEquals(0, $info->getUploadTime());
-		$this->assertEquals(0, $info->getCreationTime());
-
-		$view->putFileInfo('/foo.txt', ['upload_time' => 25]);
-
-		$info = $view->getFileInfo('/foo.txt');
-		$this->assertEquals(25, $info->getUploadTime());
-		$this->assertEquals(0, $info->getCreationTime());
-	}
-
-	public function testFopenGone(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		$scanner->scan('');
-		$cache = $storage->getCache();
-
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('/test');
-
-		$storage->unlink('foo.txt');
-
-		$this->assertTrue($cache->inCache('foo.txt'));
-
-		$this->assertFalse($view->fopen('foo.txt', 'r'));
-
-		$this->assertFalse($cache->inCache('foo.txt'));
-	}
-
-	public function testMountpointParentsCreated(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage2, [], '/A/B/C');
-
-		$rootView = new View('');
-
-		$folderData = $rootView->getDirectoryContent('/');
-		$this->assertCount(4, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-		$this->assertEquals('A', $folderData[3]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A');
-		$this->assertCount(1, $folderData);
-		$this->assertEquals('B', $folderData[0]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A/B');
-		$this->assertCount(1, $folderData);
-		$this->assertEquals('C', $folderData[0]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A/B/C');
-		$this->assertCount(3, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-	}
-
-	public function testCopyPreservesContent() {
-		$viewUser1 = new View('/' . 'userId' . '/files');
-		$viewUser1->mkdir('');
-		$viewUser1->file_put_contents('foo.txt', 'foo');
-		$viewUser1->copy('foo.txt', 'bar.txt');
-		$this->assertEquals('foo', $viewUser1->file_get_contents('bar.txt'));
-	}
+        $folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
+        $tmpdirLength = strlen(Server::get(ITempManager::class)->getTemporaryFolder());
+        if (\OC_Util::runningOnMac()) {
+            $depth = ((1024 - $tmpdirLength) / 57);
+        } else {
+            $depth = ((4000 - $tmpdirLength) / 57);
+        }
+        foreach (range(0, $depth - 1) as $i) {
+            $longPath .= $ds . $folderName;
+            $result = $rootView->mkdir($longPath);
+            $this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
+
+            $result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
+            $this->assertEquals(5, $result, "file_put_contents failed on $i");
+
+            $this->assertTrue($rootView->file_exists($longPath));
+            $this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
+        }
+
+        $cache = $storage->getCache();
+        $scanner = $storage->getScanner();
+        $scanner->scan('');
+
+        $longPath = $folderName;
+        foreach (range(0, $depth - 1) as $i) {
+            $cachedFolder = $cache->get($longPath);
+            $this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
+            $this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
+
+            $cachedFile = $cache->get($longPath . '/test.txt');
+            $this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
+            $this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
+
+            $longPath .= $ds . $folderName;
+        }
+    }
+
+    public function testTouchNotSupported(): void {
+        $storage = new TemporaryNoTouch([]);
+        $scanner = $storage->getScanner();
+        Filesystem::mount($storage, [], '/test/');
+        $past = time() - 100;
+        $storage->file_put_contents('test', 'foobar');
+        $scanner->scan('');
+        $view = new View('');
+        $info = $view->getFileInfo('/test/test');
+
+        $view->touch('/test/test', $past);
+        $scanner->scanFile('test', Scanner::REUSE_ETAG);
+
+        $info2 = $view->getFileInfo('/test/test');
+        $this->assertSame($info['etag'], $info2['etag']);
+    }
+
+    public function testWatcherEtagCrossStorage(): void {
+        $storage1 = new Temporary([]);
+        $storage2 = new Temporary([]);
+        $scanner1 = $storage1->getScanner();
+        $scanner2 = $storage2->getScanner();
+        $storage1->mkdir('sub');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        $past = time() - 100;
+        $storage2->file_put_contents('test.txt', 'foobar');
+        $scanner1->scan('');
+        $scanner2->scan('');
+        $view = new View('');
+
+        $storage2->getWatcher('')->setPolicy(Watcher::CHECK_ALWAYS);
+
+        $oldFileInfo = $view->getFileInfo('/test/sub/storage/test.txt');
+        $oldFolderInfo = $view->getFileInfo('/test');
+
+        $storage2->getCache()->update($oldFileInfo->getId(), [
+            'storage_mtime' => $past,
+        ]);
+
+        $oldEtag = $oldFolderInfo->getEtag();
+
+        $view->getFileInfo('/test/sub/storage/test.txt');
+        $newFolderInfo = $view->getFileInfo('/test');
+
+        $this->assertNotEquals($newFolderInfo->getEtag(), $oldEtag);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('absolutePathProvider')]
+    public function testGetAbsolutePath($expectedPath, $relativePath): void {
+        $view = new View('/files');
+        $this->assertEquals($expectedPath, $view->getAbsolutePath($relativePath));
+    }
+
+    public function testPartFileInfo(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        Filesystem::mount($storage, [], '/test/');
+        $sizeWritten = $storage->file_put_contents('test.part', 'foobar');
+        $scanner->scan('');
+        $view = new View('/test');
+        $info = $view->getFileInfo('test.part');
+
+        $this->assertInstanceOf('\OCP\Files\FileInfo', $info);
+        $this->assertNull($info->getId());
+        $this->assertEquals(6, $sizeWritten);
+        $this->assertEquals(6, $info->getSize());
+        $this->assertEquals('foobar', $view->file_get_contents('test.part'));
+    }
+
+    public static function absolutePathProvider(): array {
+        return [
+            ['/files/', ''],
+            ['/files/0', '0'],
+            ['/files/false', 'false'],
+            ['/files/true', 'true'],
+            ['/files/', '/'],
+            ['/files/test', 'test'],
+            ['/files/test', '/test'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('chrootRelativePathProvider')]
+    public function testChrootGetRelativePath($root, $absolutePath, $expectedPath): void {
+        $view = new View('/files');
+        $view->chroot($root);
+        $this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
+    }
+
+    public static function chrootRelativePathProvider(): array {
+        return self::relativePathProvider('/');
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('initRelativePathProvider')]
+    public function testInitGetRelativePath($root, $absolutePath, $expectedPath): void {
+        $view = new View($root);
+        $this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
+    }
+
+    public static function initRelativePathProvider(): array {
+        return self::relativePathProvider(null);
+    }
+
+    public static function relativePathProvider($missingRootExpectedPath): array {
+        return [
+            // No root - returns the path
+            ['', '/files', '/files'],
+            ['', '/files/', '/files/'],
+
+            // Root equals path - /
+            ['/files/', '/files/', '/'],
+            ['/files/', '/files', '/'],
+            ['/files', '/files/', '/'],
+            ['/files', '/files', '/'],
+
+            // False negatives: chroot fixes those by adding the leading slash.
+            // But setting them up with this root (instead of chroot($root))
+            // will fail them, although they should be the same.
+            // TODO init should be fixed, so it also adds the leading slash
+            ['files/', '/files/', $missingRootExpectedPath],
+            ['files', '/files/', $missingRootExpectedPath],
+            ['files/', '/files', $missingRootExpectedPath],
+            ['files', '/files', $missingRootExpectedPath],
+
+            // False negatives: Paths provided to the method should have a leading slash
+            // TODO input should be checked to have a leading slash
+            ['/files/', 'files/', null],
+            ['/files', 'files/', null],
+            ['/files/', 'files', null],
+            ['/files', 'files', null],
+
+            // with trailing slashes
+            ['/files/', '/files/0', '0'],
+            ['/files/', '/files/false', 'false'],
+            ['/files/', '/files/true', 'true'],
+            ['/files/', '/files/test', 'test'],
+            ['/files/', '/files/test/foo', 'test/foo'],
+
+            // without trailing slashes
+            // TODO false expectation: Should match "with trailing slashes"
+            ['/files', '/files/0', '/0'],
+            ['/files', '/files/false', '/false'],
+            ['/files', '/files/true', '/true'],
+            ['/files', '/files/test', '/test'],
+            ['/files', '/files/test/foo', '/test/foo'],
+
+            // leading slashes
+            ['/files/', '/files_trashbin/', null],
+            ['/files', '/files_trashbin/', null],
+            ['/files/', '/files_trashbin', null],
+            ['/files', '/files_trashbin', null],
+
+            // no leading slashes
+            ['files/', 'files_trashbin/', null],
+            ['files', 'files_trashbin/', null],
+            ['files/', 'files_trashbin', null],
+            ['files', 'files_trashbin', null],
+
+            // mixed leading slashes
+            ['files/', '/files_trashbin/', null],
+            ['/files/', 'files_trashbin/', null],
+            ['files', '/files_trashbin/', null],
+            ['/files', 'files_trashbin/', null],
+            ['files/', '/files_trashbin', null],
+            ['/files/', 'files_trashbin', null],
+            ['files', '/files_trashbin', null],
+            ['/files', 'files_trashbin', null],
+
+            ['files', 'files_trashbin/test', null],
+            ['/files', '/files_trashbin/test', null],
+            ['/files', 'files_trashbin/test', null],
+        ];
+    }
+
+    public function testFileView(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+        $view = new View('/test/foo.txt');
+
+        $this->assertEquals('bar', $view->file_get_contents(''));
+        $fh = tmpfile();
+        fwrite($fh, 'foo');
+        rewind($fh);
+        $view->file_put_contents('', $fh);
+        $this->assertEquals('foo', $view->file_get_contents(''));
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('tooLongPathDataProvider')]
+    public function testTooLongPath($operation, $param0 = null): void {
+        $this->expectException(InvalidPathException::class);
+
+
+        $longPath = '';
+        // 4000 is the maximum path length in file_cache.path
+        $folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
+        $depth = (4000 / 57);
+        foreach (range(0, $depth + 1) as $i) {
+            $longPath .= '/' . $folderName;
+        }
+
+        $storage = new Temporary([]);
+        $this->tempStorage = $storage; // for later hard cleanup
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+
+        if ($param0 === '@0') {
+            $param0 = $longPath;
+        }
+
+        if ($operation === 'hash') {
+            $param0 = $longPath;
+            $longPath = 'md5';
+        }
+
+        call_user_func([$rootView, $operation], $longPath, $param0);
+    }
+
+    public static function tooLongPathDataProvider(): array {
+        return [
+            ['getAbsolutePath'],
+            ['getRelativePath'],
+            ['getMountPoint'],
+            ['resolvePath'],
+            ['getLocalFile'],
+            ['mkdir'],
+            ['rmdir'],
+            ['opendir'],
+            ['is_dir'],
+            ['is_file'],
+            ['stat'],
+            ['filetype'],
+            ['filesize'],
+            ['readfile'],
+            ['isCreatable'],
+            ['isReadable'],
+            ['isUpdatable'],
+            ['isDeletable'],
+            ['isSharable'],
+            ['file_exists'],
+            ['filemtime'],
+            ['touch'],
+            ['file_get_contents'],
+            ['unlink'],
+            ['deleteAll'],
+            ['toTmpFile'],
+            ['getMimeType'],
+            ['free_space'],
+            ['getFileInfo'],
+            ['getDirectoryContent'],
+            ['getOwner'],
+            ['getETag'],
+            ['file_put_contents', 'ipsum'],
+            ['rename', '@0'],
+            ['copy', '@0'],
+            ['fopen', 'r'],
+            ['fromTmpFile', '@0'],
+            ['hash'],
+            ['hasUpdated', 0],
+            ['putFileInfo', []],
+        ];
+    }
+
+    public function testRenameCrossStoragePreserveMtime(): void {
+        $storage1 = new Temporary([]);
+        $storage2 = new Temporary([]);
+        $storage1->mkdir('sub');
+        $storage1->mkdir('foo');
+        $storage1->file_put_contents('foo.txt', 'asd');
+        $storage1->file_put_contents('foo/bar.txt', 'asd');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        $view = new View('');
+        $time = time() - 200;
+        $view->touch('/test/foo.txt', $time);
+        $view->touch('/test/foo', $time);
+        $view->touch('/test/foo/bar.txt', $time);
+
+        $view->rename('/test/foo.txt', '/test/sub/storage/foo.txt');
+
+        $this->assertEquals($time, $view->filemtime('/test/sub/storage/foo.txt'));
+
+        $view->rename('/test/foo', '/test/sub/storage/foo');
+
+        $this->assertEquals($time, $view->filemtime('/test/sub/storage/foo/bar.txt'));
+    }
+
+    public function testRenameFailDeleteTargetKeepSource(): void {
+        $this->doTestCopyRenameFail('rename');
+    }
+
+    public function testCopyFailDeleteTargetKeepSource(): void {
+        $this->doTestCopyRenameFail('copy');
+    }
+
+    private function doTestCopyRenameFail($operation) {
+        $storage1 = new Temporary([]);
+        /** @var \PHPUnit\Framework\MockObject\MockObject|Temporary $storage2 */
+        $storage2 = $this->getMockBuilder(TemporaryNoCross::class)
+            ->setConstructorArgs([[]])
+            ->onlyMethods(['fopen', 'writeStream'])
+            ->getMock();
+
+        $storage2->method('writeStream')
+            ->willThrowException(new GenericFileException('Failed to copy stream'));
+
+        $storage1->mkdir('sub');
+        $storage1->file_put_contents('foo.txt', '0123456789ABCDEFGH');
+        $storage1->mkdir('dirtomove');
+        $storage1->file_put_contents('dirtomove/indir1.txt', '0123456'); // fits
+        $storage1->file_put_contents('dirtomove/indir2.txt', '0123456789ABCDEFGH'); // doesn't fit
+        $storage2->file_put_contents('existing.txt', '0123');
+        $storage1->getScanner()->scan('');
+        $storage2->getScanner()->scan('');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        // move file
+        $view = new View('');
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+        $this->assertFalse($storage2->file_exists('foo.txt'));
+        $this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/foo.txt'));
+        $this->assertFalse($storage2->file_exists('foo.txt'));
+        $this->assertFalse($storage2->getCache()->get('foo.txt'));
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+
+        // if target exists, it will be deleted too
+        $this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/existing.txt'));
+        $this->assertFalse($storage2->file_exists('existing.txt'));
+        $this->assertFalse($storage2->getCache()->get('existing.txt'));
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+
+        // move folder
+        $this->assertFalse($view->$operation('/test/dirtomove/', '/test/sub/storage/dirtomove/'));
+        // since the move failed, the full source tree is kept
+        $this->assertTrue($storage1->file_exists('dirtomove/indir1.txt'));
+        $this->assertTrue($storage1->file_exists('dirtomove/indir2.txt'));
+        // second file not moved/copied
+        $this->assertFalse($storage2->file_exists('dirtomove/indir2.txt'));
+        $this->assertFalse($storage2->getCache()->get('dirtomove/indir2.txt'));
+    }
+
+    public function testDeleteFailKeepCache(): void {
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->setConstructorArgs([[]])
+            ->onlyMethods(['unlink'])
+            ->getMock();
+        $storage->expects($this->once())
+            ->method('unlink')
+            ->willReturn(false);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->file_put_contents('foo.txt', 'asd');
+        $scanner->scan('');
+        Filesystem::mount($storage, [], '/test/');
+
+        $view = new View('/test');
+
+        $this->assertFalse($view->unlink('foo.txt'));
+        $this->assertTrue($cache->inCache('foo.txt'));
+    }
+
+    public static function directoryTraversalProvider(): array {
+        return [
+            ['../test/'],
+            ['..\\test\\my/../folder'],
+            ['/test/my/../foo\\'],
+        ];
+    }
+
+    /**
+     * @param string $root
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('directoryTraversalProvider')]
+    public function testConstructDirectoryTraversalException($root): void {
+        $this->expectException(\Exception::class);
+
+        new View($root);
+    }
+
+    public function testRenameOverWrite(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->mkdir('sub');
+        $storage->mkdir('foo');
+        $storage->file_put_contents('foo.txt', 'asd');
+        $storage->file_put_contents('foo/bar.txt', 'asd');
+        $scanner->scan('');
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('');
+        $this->assertTrue($view->rename('/test/foo.txt', '/test/foo/bar.txt'));
+    }
+
+    public function testSetMountOptionsInStorage(): void {
+        $mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['foo' => 'bar']);
+        Filesystem::getMountManager()->addMount($mount);
+        /** @var Common $storage */
+        $storage = $mount->getStorage();
+        $this->assertEquals($storage->getMountOption('foo'), 'bar');
+    }
+
+    public function testSetMountOptionsWatcherPolicy(): void {
+        $mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['filesystem_check_changes' => Watcher::CHECK_NEVER]);
+        Filesystem::getMountManager()->addMount($mount);
+        /** @var Common $storage */
+        $storage = $mount->getStorage();
+        $watcher = $storage->getWatcher();
+        $this->assertEquals(Watcher::CHECK_NEVER, $watcher->getPolicy());
+    }
+
+    public function testGetAbsolutePathOnNull(): void {
+        $view = new View();
+        $this->assertNull($view->getAbsolutePath(null));
+    }
+
+    public function testGetRelativePathOnNull(): void {
+        $view = new View();
+        $this->assertNull($view->getRelativePath(null));
+    }
+
+
+    public function testNullAsRoot(): void {
+        $this->expectException(\TypeError::class);
+
+        new View(null);
+    }
+
+    /**
+     * e.g. reading from a folder that's being renamed
+     *
+     *
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
+    public function testReadFromWriteLockedPath($rootPath, $pathPrefix): void {
+        $this->expectException(LockedException::class);
+
+        $rootPath = str_replace('{folder}', 'files', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+        $view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
+    }
+
+    /**
+     * Reading from a files_encryption folder that's being renamed
+     *
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
+    public function testReadFromWriteUnlockablePath($rootPath, $pathPrefix): void {
+        $rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
+    }
+
+    /**
+     * e.g. writing a file that's being downloaded
+     *
+     *
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
+    public function testWriteToReadLockedFile($rootPath, $pathPrefix): void {
+        $this->expectException(LockedException::class);
+
+        $rootPath = str_replace('{folder}', 'files', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
+        $view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
+    }
+
+    /**
+     * Writing a file that's being downloaded
+     *
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataLockPaths')]
+    public function testWriteToReadUnlockableFile($rootPath, $pathPrefix): void {
+        $rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+    }
+
+    /**
+     * Test that locks are on mount point paths instead of mount root
+     */
+    public function testLockLocalMountPointPathInsteadOfStorageRoot(): void {
+        $lockingProvider = Server::get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
+
+        $this->assertTrue(
+            $view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, true),
+            'Can lock mount point'
+        );
+
+        // no exception here because storage root was not locked
+        $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $thrown = false;
+        try {
+            $storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Mount point path was locked on root storage');
+
+        $lockingProvider->releaseAll();
+    }
+
+    /**
+     * Test that locks are on mount point paths and also mount root when requested
+     */
+    public function testLockStorageRootButNotLocalMountPoint(): void {
+        $lockingProvider = Server::get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
+
+        $this->assertTrue(
+            $view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, false),
+            'Can lock mount point'
+        );
+
+        $thrown = false;
+        try {
+            $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Mount point storage root was locked on original storage');
+
+        // local mount point was not locked
+        $storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $lockingProvider->releaseAll();
+    }
+
+    /**
+     * Test that locks are on mount point paths and also mount root when requested
+     */
+    public function testLockMountPointPathFailReleasesBoth(): void {
+        $lockingProvider = Server::get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint.txt');
+
+        // this would happen if someone is writing on the mount point
+        $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $thrown = false;
+        try {
+            // this actually acquires two locks, one on the mount point and one on the storage root,
+            // but the one on the storage root will fail
+            $view->lockFile('/mountpoint.txt', ILockingProvider::LOCK_SHARED);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Cannot acquire shared lock because storage root is already locked');
+
+        // from here we expect that the lock on the local mount point was released properly
+        // so acquiring an exclusive lock will succeed
+        $storage->acquireLock('/testuser/files/mountpoint.txt', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $lockingProvider->releaseAll();
+    }
+
+    public static function dataLockPaths(): array {
+        return [
+            ['/testuser/{folder}', ''],
+            ['/testuser', '/{folder}'],
+            ['', '/testuser/{folder}'],
+        ];
+    }
+
+    public static function pathRelativeToFilesProvider(): array {
+        return [
+            ['admin/files', ''],
+            ['admin/files/x', 'x'],
+            ['/admin/files', ''],
+            ['/admin/files/sub', 'sub'],
+            ['/admin/files/sub/', 'sub'],
+            ['/admin/files/sub/sub2', 'sub/sub2'],
+            ['//admin//files/sub//sub2', 'sub/sub2'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('pathRelativeToFilesProvider')]
+    public function testGetPathRelativeToFiles($path, $expectedPath): void {
+        $view = new View();
+        $this->assertEquals($expectedPath, $view->getPathRelativeToFiles($path));
+    }
+
+    public static function pathRelativeToFilesProviderExceptionCases(): array {
+        return [
+            [''],
+            ['x'],
+            ['files'],
+            ['/files'],
+            ['/admin/files_versions/abc'],
+        ];
+    }
+
+    /**
+     * @param string $path
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('pathRelativeToFilesProviderExceptionCases')]
+    public function testGetPathRelativeToFilesWithInvalidArgument($path): void {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('$absolutePath must be relative to "files"');
+
+        $view = new View();
+        $view->getPathRelativeToFiles($path);
+    }
+
+    public function testChangeLock(): void {
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $view->lockFile('/test/sub', ILockingProvider::LOCK_SHARED);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+
+        $view->changeLock('//test/sub', ILockingProvider::LOCK_EXCLUSIVE);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+
+        $view->changeLock('test/sub', ILockingProvider::LOCK_SHARED);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+
+        $view->unlockFile('/test/sub/', ILockingProvider::LOCK_SHARED);
+
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+    }
+
+    public static function hookPathProvider(): array {
+        return [
+            ['/foo/files', '/foo', true],
+            ['/foo/files/bar', '/foo', true],
+            ['/foo', '/foo', false],
+            ['/foo', '/files/foo', true],
+            ['/foo', 'filesfoo', false],
+            ['', '/foo/files', true],
+            ['', '/foo/files/bar.txt', true],
+        ];
+    }
+
+    /**
+     * @param $root
+     * @param $path
+     * @param $shouldEmit
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('hookPathProvider')]
+    public function testHookPaths($root, $path, $shouldEmit): void {
+        $filesystemReflection = new \ReflectionClass(Filesystem::class);
+        $defaultRootValue = $filesystemReflection->getProperty('defaultInstance');
+        $defaultRootValue->setAccessible(true);
+        $oldRoot = $defaultRootValue->getValue();
+        $defaultView = new View('/foo/files');
+        $defaultRootValue->setValue(null, $defaultView);
+        $view = new View($root);
+        $result = self::invokePrivate($view, 'shouldEmitHooks', [$path]);
+        $defaultRootValue->setValue(null, $oldRoot);
+        $this->assertEquals($shouldEmit, $result);
+    }
+
+    /**
+     * Create test movable mount points
+     *
+     * @param array $mountPoints array of mount point locations
+     * @return array array of MountPoint objects
+     */
+    private function createTestMovableMountPoints($mountPoints) {
+        $mounts = [];
+        foreach ($mountPoints as $mountPoint) {
+            $storage = $this->getMockBuilder(Storage::class)
+                ->onlyMethods([])
+                ->getMock();
+            $storage->method('getId')->willReturn('non-null-id');
+            $storage->method('getStorageCache')->willReturnCallback(function () use ($storage) {
+                return new \OC\Files\Cache\Storage($storage, true, Server::get(IDBConnection::class));
+            });
+
+            $mounts[] = $this->getMockBuilder(TestMoveableMountPoint::class)
+                ->onlyMethods(['moveMount'])
+                ->setConstructorArgs([$storage, $mountPoint])
+                ->getMock();
+        }
+
+        /** @var IMountProvider|\PHPUnit\Framework\MockObject\MockObject $mountProvider */
+        $mountProvider = $this->createMock(IMountProvider::class);
+        $mountProvider->expects($this->any())
+            ->method('getMountsForUser')
+            ->willReturn($mounts);
+
+        $mountProviderCollection = Server::get(IMountProviderCollection::class);
+        $mountProviderCollection->registerProvider($mountProvider);
+
+        return $mounts;
+    }
+
+    /**
+     * Test mount point move
+     */
+    public function testMountPointMove(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+        $mount1->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $mount2->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('sub');
+
+        $this->assertTrue($view->rename('mount1', 'renamed_mount'), 'Can rename mount point');
+        $this->assertTrue($view->rename('mount2', 'sub/moved_mount'), 'Can move a mount point into a subdirectory');
+    }
+
+    public function testMoveMountPointOverwrite(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->never())
+            ->method('moveMount');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $this->expectException(ForbiddenException::class);
+        $view->rename('mount1', 'mount2');
+    }
+
+    public function testMoveMountPointIntoMount(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->never())
+            ->method('moveMount');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $this->expectException(ForbiddenException::class);
+        $view->rename('mount1', 'mount2/sub');
+    }
+
+    /**
+     * Test that moving a mount point into a shared folder is forbidden
+     */
+    public function testMoveMountPointIntoSharedFolder(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('shareddir');
+        $view->mkdir('shareddir/sub');
+        $view->mkdir('shareddir/sub2');
+        // Create a similar named but non-shared folder
+        $view->mkdir('shareddir notshared');
+
+        $fileId = $view->getFileInfo('shareddir')->getId();
+        $userObject = Server::get(IUserManager::class)->createUser('test2', 'IHateNonMockableStaticClasses');
+
+        $userFolder = \OC::$server->getUserFolder($this->user);
+        $shareDir = $userFolder->get('shareddir');
+        $shareManager = Server::get(IShareManager::class);
+        $share = $shareManager->newShare();
+        $share->setSharedWith('test2')
+            ->setSharedBy($this->user)
+            ->setShareType(IShare::TYPE_USER)
+            ->setPermissions(Constants::PERMISSION_READ)
+            ->setNode($shareDir);
+        $shareManager->createShare($share);
+
+        try {
+            $view->rename('mount1', 'shareddir');
+            $this->fail('Cannot overwrite shared folder');
+        } catch (ForbiddenException $e) {
+
+        }
+        try {
+            $view->rename('mount1', 'shareddir/sub');
+            $this->fail('Cannot move mount point into shared folder');
+        } catch (ForbiddenException $e) {
+
+        }
+        try {
+            $view->rename('mount1', 'shareddir/sub/sub2');
+            $this->fail('Cannot move mount point into shared subfolder');
+        } catch (ForbiddenException $e) {
+
+        }
+        $this->assertTrue($view->rename('mount2', 'shareddir notshared/sub'), 'Can move mount point into a similarly named but non-shared folder');
+
+        $shareManager->deleteShare($share);
+        $userObject->delete();
+    }
+
+    public static function basicOperationProviderForLocks(): array {
+        return [
+            // --- write hook ----
+            [
+                'touch',
+                ['touch-create.txt'],
+                'touch-create.txt',
+                'create',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'fopen',
+                ['test-write.txt', 'w'],
+                'test-write.txt',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                null,
+                // exclusive lock stays until fclose
+                ILockingProvider::LOCK_EXCLUSIVE,
+            ],
+            [
+                'mkdir',
+                ['newdir'],
+                'newdir',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'file_put_contents',
+                ['file_put_contents.txt', 'blah'],
+                'file_put_contents.txt',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                0,
+            ],
+
+            // ---- delete hook ----
+            [
+                'rmdir',
+                ['dir'],
+                'dir',
+                'delete',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'unlink',
+                ['test.txt'],
+                'test.txt',
+                'delete',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+
+            // ---- read hook (no post hooks) ----
+            [
+                'file_get_contents',
+                ['test.txt'],
+                'test.txt',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                null,
+                false,
+            ],
+            [
+                'fopen',
+                ['test.txt', 'r'],
+                'test.txt',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+            ],
+            [
+                'opendir',
+                ['dir'],
+                'dir',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+            ],
+
+            // ---- no lock, touch hook ---
+            ['touch', ['test.txt'], 'test.txt', 'touch', null, null, null],
+
+            // ---- no hooks, no locks ---
+            ['is_dir', ['dir'], 'dir', null],
+            ['is_file', ['dir'], 'dir', null],
+            [
+                'stat',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+            [
+                'filetype',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+            [
+                'filesize',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                /* Return an int */
+                100
+            ],
+            ['isCreatable', ['dir'], 'dir', null],
+            ['isReadable', ['dir'], 'dir', null],
+            ['isUpdatable', ['dir'], 'dir', null],
+            ['isDeletable', ['dir'], 'dir', null],
+            ['isSharable', ['dir'], 'dir', null],
+            ['file_exists', ['dir'], 'dir', null],
+            [
+                'filemtime',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+        ];
+    }
+
+    /**
+     * Test whether locks are set before and after the operation
+     *
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $lockedPath path of the locked item to check
+     * @param string $hookType hook type
+     * @param int $expectedLockBefore expected lock during pre hooks
+     * @param int $expectedLockDuring expected lock during operation
+     * @param int $expectedLockAfter expected lock during post hooks
+     * @param int $expectedStrayLock expected lock after returning, should
+     *                               be null (unlock) for most operations
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
+    public function testLockBasicOperation(
+        $operation,
+        $operationArgs,
+        $lockedPath,
+        $hookType,
+        $expectedLockBefore = ILockingProvider::LOCK_SHARED,
+        $expectedLockDuring = ILockingProvider::LOCK_SHARED,
+        $expectedLockAfter = ILockingProvider::LOCK_SHARED,
+        $expectedStrayLock = null,
+        $returnValue = true,
+    ): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary&MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        /* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
+        Server::get(ITrashManager::class)->pauseTrash();
+        /* Same thing with encryption wrapper */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        // work directly on disk because mkdir might be mocked
+        $realPath = $storage->getSourcePath('');
+        mkdir($realPath . '/files');
+        mkdir($realPath . '/files/dir');
+        file_put_contents($realPath . '/files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function () use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
+                    $lockTypeDuring = $this->getFileLockType($view, $lockedPath);
+
+                    return $returnValue;
+                }
+            );
+
+        $this->assertNull($this->getFileLockType($view, $lockedPath), 'File not locked before operation');
+
+        $this->connectMockHooks($hookType, $view, $lockedPath, $lockTypePre, $lockTypePost);
+
+        // do operation
+        call_user_func_array([$view, $operation], $operationArgs);
+
+        if ($hookType !== null) {
+            $this->assertEquals($expectedLockBefore, $lockTypePre, 'File locked properly during pre-hook');
+            $this->assertEquals($expectedLockAfter, $lockTypePost, 'File locked properly during post-hook');
+            $this->assertEquals($expectedLockDuring, $lockTypeDuring, 'File locked properly during operation');
+        } else {
+            $this->assertNull($lockTypeDuring, 'File not locked during operation');
+        }
+
+        $this->assertEquals($expectedStrayLock, $this->getFileLockType($view, $lockedPath));
+
+        /* Resume trash to avoid side effects */
+        Server::get(ITrashManager::class)->resumeTrash();
+    }
+
+    /**
+     * Test locks for file_put_content with stream.
+     * This code path uses $storage->fopen instead
+     */
+    public function testLockFilePutContentWithStream(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $path = 'test_file_put_contents.txt';
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['fopen'])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        $storage->expects($this->once())
+            ->method('fopen')
+            ->willReturnCallback(
+                function () use ($view, $path, &$lockTypeDuring) {
+                    $lockTypeDuring = $this->getFileLockType($view, $path);
+
+                    return fopen('php://temp', 'r+');
+                }
+            );
+
+        $this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
+
+        // do operation
+        $view->file_put_contents($path, fopen('php://temp', 'r+'));
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePost, 'File locked properly during post-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
+
+        $this->assertNull($this->getFileLockType($view, $path));
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     */
+    public function testLockFopen(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $path = 'test_file_put_contents.txt';
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['fopen'])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        $storage->expects($this->once())
+            ->method('fopen')
+            ->willReturnCallback(
+                function () use ($view, $path, &$lockTypeDuring) {
+                    $lockTypeDuring = $this->getFileLockType($view, $path);
+
+                    return fopen('php://temp', 'r+');
+                }
+            );
+
+        $this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
+
+        // do operation
+        $res = $view->fopen($path, 'w');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
+        $this->assertNull($lockTypePost, 'No post hook, no lock check possible');
+
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File still locked after fopen');
+
+        fclose($res);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File unlocked after fclose');
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     *
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $path path of the locked item to check
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
+    public function testLockBasicOperationUnlocksAfterException(
+        $operation,
+        $operationArgs,
+        $path,
+    ): void {
+        if ($operation === 'touch') {
+            $this->markTestSkipped('touch handles storage exceptions internally');
+        }
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        /* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
+        Server::get(ITrashManager::class)->pauseTrash();
+        /* Same thing with encryption wrapper */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        // work directly on disk because mkdir might be mocked
+        $realPath = $storage->getSourcePath('');
+        mkdir($realPath . '/files');
+        mkdir($realPath . '/files/dir');
+        file_put_contents($realPath . '/files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function (): void {
+                    throw new \Exception('Simulated exception');
+                }
+            );
+
+        $thrown = false;
+        try {
+            call_user_func_array([$view, $operation], $operationArgs);
+        } catch (\Exception $e) {
+            $thrown = true;
+            $this->assertEquals('Simulated exception', $e->getMessage());
+        }
+        $this->assertTrue($thrown, 'Exception was rethrown');
+        $this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
+
+        /* Resume trash to avoid side effects */
+        Server::get(ITrashManager::class)->resumeTrash();
+    }
+
+    public function testLockBasicOperationUnlocksAfterLockException(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $storage = new Temporary([]);
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        $storage->mkdir('files');
+        $storage->mkdir('files/dir');
+        $storage->file_put_contents('files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        // get a shared lock
+        $handle = $view->fopen('test.txt', 'r');
+
+        $thrown = false;
+        try {
+            // try (and fail) to get a write lock
+            $view->unlink('test.txt');
+        } catch (\Exception $e) {
+            $thrown = true;
+            $this->assertInstanceOf(LockedException::class, $e);
+        }
+        $this->assertTrue($thrown, 'Exception was rethrown');
+
+        // clean shared lock
+        fclose($handle);
+
+        $this->assertNull($this->getFileLockType($view, 'test.txt'), 'File got unlocked');
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     *
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $path path of the locked item to check
+     * @param string $hookType hook type
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('basicOperationProviderForLocks')]
+    public function testLockBasicOperationUnlocksAfterCancelledHook(
+        $operation,
+        $operationArgs,
+        $path,
+        $hookType,
+    ): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            $hookType,
+            HookHelper::class,
+            'cancellingCallback'
+        );
+
+        call_user_func_array([$view, $operation], $operationArgs);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
+    }
+
+    public static function lockFileRenameOrCopyDataProvider(): array {
+        return [
+            ['rename', ILockingProvider::LOCK_EXCLUSIVE],
+            ['copy', ILockingProvider::LOCK_SHARED],
+        ];
+    }
+
+    /**
+     * Test locks for rename or copy operation
+     *
+     *
+     * @param string $operation operation to be done on the view
+     * @param int $expectedLockTypeSourceDuring expected lock type on source file during
+     *                                          the operation
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('lockFileRenameOrCopyDataProvider')]
+    public function testLockFileRename($operation, $expectedLockTypeSourceDuring): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation, 'getMetaData', 'filemtime'])
+            ->getMock();
+
+        $storage->expects($this->any())
+            ->method('getMetaData')
+            ->willReturn([
+                'mtime' => 1885434487,
+                'etag' => '',
+                'mimetype' => 'text/plain',
+                'permissions' => Constants::PERMISSION_ALL,
+                'size' => 3
+            ]);
+        $storage->expects($this->any())
+            ->method('filemtime')
+            ->willReturn(123456789);
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks($operation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks($operation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        $view->$operation($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
+        $this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+    }
+
+    /**
+     * simulate a failed copy operation.
+     * We expect that we catch the exception, free the lock and re-throw it.
+     *
+     */
+    public function testLockFileCopyException(): void {
+        $this->expectException(\Exception::class);
+
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['copy'])
+            ->getMock();
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+
+        $storage->expects($this->once())
+            ->method('copy')
+            ->willReturnCallback(
+                function (): void {
+                    throw new \Exception();
+                }
+            );
+
+        $this->connectMockHooks('copy', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks('copy', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        try {
+            $view->copy($sourcePath, $targetPath);
+        } catch (\Exception $e) {
+            $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+            $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+            throw $e;
+        }
+    }
+
+    /**
+     * Test rename operation: unlock first path when second path was locked
+     */
+    public function testLockFileRenameUnlockOnException(): void {
+        self::loginAsUser('test');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+        $view->file_put_contents($sourcePath, 'meh');
+
+        // simulate that the target path is already locked
+        $view->lockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file is locked before operation');
+
+        $thrown = false;
+        try {
+            $view->rename($sourcePath, $targetPath);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+
+        $this->assertTrue($thrown, 'LockedException thrown');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file still locked after operation');
+
+        $view->unlockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
+    }
+
+    /**
+     * Test rename operation: unlock first path when second path was locked
+     */
+    public function testGetOwner(): void {
+        self::loginAsUser('test');
+
+        $view = new View('/test/files/');
+
+        $path = 'foo.txt';
+        $view->file_put_contents($path, 'meh');
+
+        $this->assertEquals('test', $view->getFileInfo($path)->getOwner()->getUID());
+
+        $folderInfo = $view->getDirectoryContent('');
+        $folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+            return $info->getName() === 'foo.txt';
+        }));
+
+        $this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
+
+        $subStorage = new Temporary();
+        Filesystem::mount($subStorage, [], '/test/files/asd');
+
+        $folderInfo = $view->getDirectoryContent('');
+        $folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+            return $info->getName() === 'asd';
+        }));
+
+        $this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
+    }
+
+    public static function lockFileRenameOrCopyCrossStorageDataProvider(): array {
+        return [
+            ['rename', 'moveFromStorage', ILockingProvider::LOCK_EXCLUSIVE],
+            ['copy', 'copyFromStorage', ILockingProvider::LOCK_SHARED],
+        ];
+    }
+
+    /**
+     * Test locks for rename or copy operation cross-storage
+     *
+     *
+     * @param string $viewOperation operation to be done on the view
+     * @param string $storageOperation operation to be mocked on the storage
+     * @param int $expectedLockTypeSourceDuring expected lock type on source file during
+     *                                          the operation
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('lockFileRenameOrCopyCrossStorageDataProvider')]
+    public function testLockFileRenameCrossStorage($viewOperation, $storageOperation, $expectedLockTypeSourceDuring): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$storageOperation])
+            ->getMock();
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage2 */
+        $storage2 = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$storageOperation, 'getMetaData', 'filemtime'])
+            ->getMock();
+
+        $storage2->expects($this->any())
+            ->method('getMetaData')
+            ->willReturn([
+                'mtime' => 1885434487,
+                'etag' => '',
+                'mimetype' => 'text/plain',
+                'permissions' => Constants::PERMISSION_ALL,
+                'size' => 3
+            ]);
+        $storage2->expects($this->any())
+            ->method('filemtime')
+            ->willReturn(123456789);
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'substorage/target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+        $storage2->getUpdater()->update('');
+
+        $storage->expects($this->never())
+            ->method($storageOperation);
+        $storage2->expects($this->once())
+            ->method($storageOperation)
+            ->willReturnCallback(
+                function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks($viewOperation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks($viewOperation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        $view->$viewOperation($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
+        $this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+    }
+
+    /**
+     * Test locks when moving a mount point
+     */
+    public function testLockMoveMountPoint(): void {
+        self::loginAsUser('test');
+
+        [$mount] = $this->createTestMovableMountPoints([
+            $this->user . '/files/substorage',
+        ]);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('subdir');
+
+        $sourcePath = 'substorage';
+        $targetPath = 'subdir/substorage_moved';
+
+        $mount->expects($this->once())
+            ->method('moveMount')
+            ->willReturnCallback(
+                function ($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath, true);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath, true);
+
+                    $lockTypeSharedRootDuring = $this->getFileLockType($view, $sourcePath, false);
+
+                    $mount->setMountPoint($target);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost, true);
+        $this->connectMockHooks('rename', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost, true);
+        // in pre-hook, mount point is still on $sourcePath
+        $this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSharedRootPre, $dummy, false);
+        // in post-hook, mount point is now on $targetPath
+        $this->connectMockHooks('rename', $view, $targetPath, $dummy, $lockTypeSharedRootPost, false);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked before operation');
+
+        $view->rename($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source path locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeSourceDuring, 'Source path locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source path locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target path locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target path locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target path locked properly during post-hook');
+
+        $this->assertNull($lockTypeSharedRootPre, 'Shared storage root not locked during pre-hook');
+        $this->assertNull($lockTypeSharedRootDuring, 'Shared storage root not locked during move');
+        $this->assertNull($lockTypeSharedRootPost, 'Shared storage root not locked during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked after operation');
+    }
+
+    /**
+     * Connect hook callbacks for hook type
+     *
+     * @param string $hookType hook type or null for none
+     * @param View $view view to check the lock on
+     * @param string $path path for which to check the lock
+     * @param int $lockTypePre variable to receive lock type that was active in the pre-hook
+     * @param int $lockTypePost variable to receive lock type that was active in the post-hook
+     * @param bool $onMountPoint true to check the mount point instead of the
+     *                           mounted storage
+     */
+    private function connectMockHooks($hookType, $view, $path, &$lockTypePre, &$lockTypePost, $onMountPoint = false) {
+        if ($hookType === null) {
+            return;
+        }
+
+        $eventHandler = $this->getMockBuilder(TestEventHandler::class)
+            ->onlyMethods(['preCallback', 'postCallback'])
+            ->getMock();
+
+        $eventHandler->expects($this->any())
+            ->method('preCallback')
+            ->willReturnCallback(
+                function () use ($view, $path, $onMountPoint, &$lockTypePre): void {
+                    $lockTypePre = $this->getFileLockType($view, $path, $onMountPoint);
+                }
+            );
+        $eventHandler->expects($this->any())
+            ->method('postCallback')
+            ->willReturnCallback(
+                function () use ($view, $path, $onMountPoint, &$lockTypePost): void {
+                    $lockTypePost = $this->getFileLockType($view, $path, $onMountPoint);
+                }
+            );
+
+        if ($hookType !== null) {
+            Util::connectHook(
+                Filesystem::CLASSNAME,
+                $hookType,
+                $eventHandler,
+                'preCallback'
+            );
+            Util::connectHook(
+                Filesystem::CLASSNAME,
+                'post_' . $hookType,
+                $eventHandler,
+                'postCallback'
+            );
+        }
+    }
+
+    /**
+     * Returns the file lock type
+     *
+     * @param View $view view
+     * @param string $path path
+     * @param bool $onMountPoint true to check the mount point instead of the
+     *                           mounted storage
+     *
+     * @return int lock type or null if file was not locked
+     */
+    private function getFileLockType(View $view, $path, $onMountPoint = false) {
+        if ($this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE, $onMountPoint)) {
+            return ILockingProvider::LOCK_EXCLUSIVE;
+        } elseif ($this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED, $onMountPoint)) {
+            return ILockingProvider::LOCK_SHARED;
+        }
+        return null;
+    }
+
+
+    public function testRemoveMoveableMountPoint(): void {
+        $mountPoint = '/' . $this->user . '/files/mount/';
+
+        // Mock the mount point
+        /** @var TestMoveableMountPoint|\PHPUnit\Framework\MockObject\MockObject $mount */
+        $mount = $this->createMock(TestMoveableMountPoint::class);
+        $mount->expects($this->once())
+            ->method('getMountPoint')
+            ->willReturn($mountPoint);
+        $mount->expects($this->once())
+            ->method('removeMount')
+            ->willReturn('foo');
+        $mount->expects($this->any())
+            ->method('getInternalPath')
+            ->willReturn('');
+
+        // Register mount
+        Filesystem::getMountManager()->addMount($mount);
+
+        // Listen for events
+        $eventHandler = $this->getMockBuilder(TestEventHandler::class)
+            ->onlyMethods(['umount', 'post_umount'])
+            ->getMock();
+        $eventHandler->expects($this->once())
+            ->method('umount')
+            ->with([Filesystem::signal_param_path => '/mount']);
+        $eventHandler->expects($this->once())
+            ->method('post_umount')
+            ->with([Filesystem::signal_param_path => '/mount']);
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            'umount',
+            $eventHandler,
+            'umount'
+        );
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            'post_umount',
+            $eventHandler,
+            'post_umount'
+        );
+
+        //Delete the mountpoint
+        $view = new View('/' . $this->user . '/files');
+        $this->assertEquals('foo', $view->rmdir('mount'));
+    }
+
+    public static function mimeFilterProvider(): array {
+        return [
+            [null, ['test1.txt', 'test2.txt', 'test3.md', 'test4.png']],
+            ['text/plain', ['test1.txt', 'test2.txt']],
+            ['text/markdown', ['test3.md']],
+            ['text', ['test1.txt', 'test2.txt', 'test3.md']],
+        ];
+    }
+
+    /**
+     * @param string $filter
+     * @param string[] $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('mimeFilterProvider')]
+    public function testGetDirectoryContentMimeFilter($filter, $expected): void {
+        $storage1 = new Temporary();
+        $root = self::getUniqueID('/');
+        Filesystem::mount($storage1, [], $root . '/');
+        $view = new View($root);
+
+        $view->file_put_contents('test1.txt', 'asd');
+        $view->file_put_contents('test2.txt', 'asd');
+        $view->file_put_contents('test3.md', 'asd');
+        $view->file_put_contents('test4.png', '');
+
+        $content = $view->getDirectoryContent('', $filter);
+
+        $files = array_map(function (FileInfo $info) {
+            return $info->getName();
+        }, $content);
+        sort($files);
+
+        $this->assertEquals($expected, $files);
+    }
+
+    public function testFilePutContentsClearsChecksum(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $view = new View('/test/foo.txt');
+        $view->putFileInfo('.', ['checksum' => '42']);
+
+        $this->assertEquals('bar', $view->file_get_contents(''));
+        $fh = tmpfile();
+        fwrite($fh, 'fooo');
+        rewind($fh);
+        clearstatcache();
+        $view->file_put_contents('', $fh);
+        $this->assertEquals('fooo', $view->file_get_contents(''));
+        $data = $view->getFileInfo('.');
+        $this->assertEquals('', $data->getChecksum());
+    }
+
+    public function testDeleteGhostFile(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $storage->unlink('foo.txt');
+
+        $this->assertTrue($cache->inCache('foo.txt'));
+
+        $view = new View('/test');
+        $rootInfo = $view->getFileInfo('');
+        $this->assertEquals(3, $rootInfo->getSize());
+        $view->unlink('foo.txt');
+        $newInfo = $view->getFileInfo('');
+
+        $this->assertFalse($cache->inCache('foo.txt'));
+        $this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
+        $this->assertEquals(0, $newInfo->getSize());
+    }
+
+    public function testDeleteGhostFolder(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->mkdir('foo');
+        $storage->file_put_contents('foo/foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $storage->rmdir('foo');
+
+        $this->assertTrue($cache->inCache('foo'));
+        $this->assertTrue($cache->inCache('foo/foo.txt'));
+
+        $view = new View('/test');
+        $rootInfo = $view->getFileInfo('');
+        $this->assertEquals(3, $rootInfo->getSize());
+        $view->rmdir('foo');
+        $newInfo = $view->getFileInfo('');
+
+        $this->assertFalse($cache->inCache('foo'));
+        $this->assertFalse($cache->inCache('foo/foo.txt'));
+        $this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
+        $this->assertEquals(0, $newInfo->getSize());
+    }
+
+    public function testCreateParentDirectories(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods([
+                'is_file',
+                'file_exists',
+                'mkdir',
+            ])
+            ->getMock();
+
+        $view->expects($this->exactly(3))
+            ->method('is_file')
+            ->willReturnMap([
+                ['/new', false],
+                ['/new/folder', false],
+                ['/new/folder/structure', false],
+            ]);
+        $view->expects($this->exactly(3))
+            ->method('file_exists')
+            ->willReturnMap([
+                ['/new', true],
+                ['/new/folder', false],
+                ['/new/folder/structure', false],
+            ]);
+
+        $calls = ['/new/folder', '/new/folder/structure'];
+        $view->expects($this->exactly(2))
+            ->method('mkdir')
+            ->willReturnCallback(function ($dir) use (&$calls): void {
+                $expected = array_shift($calls);
+                $this->assertEquals($expected, $dir);
+            });
+
+        $this->assertTrue(self::invokePrivate($view, 'createParentDirectories', ['/new/folder/structure']));
+    }
+
+    public function testCreateParentDirectoriesWithExistingFile(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods([
+                'is_file',
+                'file_exists',
+                'mkdir',
+            ])
+            ->getMock();
+
+        $view
+            ->expects($this->once())
+            ->method('is_file')
+            ->with('/file.txt')
+            ->willReturn(true);
+        $this->assertFalse(self::invokePrivate($view, 'createParentDirectories', ['/file.txt/folder/structure']));
+    }
+
+    public function testCacheExtension(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        $scanner->scan('');
+
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('/test');
+
+        $info = $view->getFileInfo('/foo.txt');
+        $this->assertEquals(0, $info->getUploadTime());
+        $this->assertEquals(0, $info->getCreationTime());
+
+        $view->putFileInfo('/foo.txt', ['upload_time' => 25]);
+
+        $info = $view->getFileInfo('/foo.txt');
+        $this->assertEquals(25, $info->getUploadTime());
+        $this->assertEquals(0, $info->getCreationTime());
+    }
+
+    public function testFopenGone(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        $scanner->scan('');
+        $cache = $storage->getCache();
+
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('/test');
+
+        $storage->unlink('foo.txt');
+
+        $this->assertTrue($cache->inCache('foo.txt'));
+
+        $this->assertFalse($view->fopen('foo.txt', 'r'));
+
+        $this->assertFalse($cache->inCache('foo.txt'));
+    }
+
+    public function testMountpointParentsCreated(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage2, [], '/A/B/C');
+
+        $rootView = new View('');
+
+        $folderData = $rootView->getDirectoryContent('/');
+        $this->assertCount(4, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+        $this->assertEquals('A', $folderData[3]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A');
+        $this->assertCount(1, $folderData);
+        $this->assertEquals('B', $folderData[0]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A/B');
+        $this->assertCount(1, $folderData);
+        $this->assertEquals('C', $folderData[0]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A/B/C');
+        $this->assertCount(3, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+    }
+
+    public function testCopyPreservesContent() {
+        $viewUser1 = new View('/' . 'userId' . '/files');
+        $viewUser1->mkdir('');
+        $viewUser1->file_put_contents('foo.txt', 'foo');
+        $viewUser1->copy('foo.txt', 'bar.txt');
+        $this->assertEquals('foo', $viewUser1->file_get_contents('bar.txt'));
+    }
 }