nextcloud / server

lib/public/Files/Config/Event/UserMountAddedEvent.php

Indentation +5 added lines, -5 removed lines

@@ -19,9 +19,9 @@
  * @since 31.0.0
  */
 class UserMountAddedEvent extends Event {
-	public function __construct(
-		public readonly IMountPoint|ICachedMountInfo $mountPoint,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        public readonly IMountPoint|ICachedMountInfo $mountPoint,
+    ) {
+        parent::__construct();
+    }
 }

lib/public/Files/Config/Event/UserMountRemovedEvent.php

Indentation +5 added lines, -5 removed lines

@@ -19,9 +19,9 @@
  * @since 31.0.0
  */
 class UserMountRemovedEvent extends Event {
-	public function __construct(
-		public readonly IMountPoint|ICachedMountInfo $mountPoint,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        public readonly IMountPoint|ICachedMountInfo $mountPoint,
+    ) {
+        parent::__construct();
+    }
 }

lib/public/Files/Config/Event/UserMountUpdatedEvent.php

Indentation +6 added lines, -6 removed lines

@@ -19,10 +19,10 @@
  * @since 31.0.0
  */
 class UserMountUpdatedEvent extends Event {
-	public function __construct(
-		public readonly IMountPoint|ICachedMountInfo $oldMountPoint,
-		public readonly IMountPoint|ICachedMountInfo $newMountPoint,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        public readonly IMountPoint|ICachedMountInfo $oldMountPoint,
+        public readonly IMountPoint|ICachedMountInfo $newMountPoint,
+    ) {
+        parent::__construct();
+    }
 }

lib/private/Files/Config/UserMountCache.php

Indentation +470 added lines, -470 removed lines

@@ -29,474 +29,474 @@
  */
 class UserMountCache implements IUserMountCache {
 
-	/**
-	 * Cached mount info.
-	 * @var CappedMemoryCache<ICachedMountInfo[]>
-	 **/
-	private CappedMemoryCache $mountsForUsers;
-	/**
-	 * fileid => internal path mapping for cached mount info.
-	 * @var CappedMemoryCache<string>
-	 **/
-	private CappedMemoryCache $internalPathCache;
-	/** @var CappedMemoryCache<array> */
-	private CappedMemoryCache $cacheInfoCache;
-
-	/**
-	 * UserMountCache constructor.
-	 */
-	public function __construct(
-		private IDBConnection $connection,
-		private IUserManager $userManager,
-		private LoggerInterface $logger,
-		private IEventLogger $eventLogger,
-		private IEventDispatcher $eventDispatcher,
-	) {
-		$this->cacheInfoCache = new CappedMemoryCache();
-		$this->internalPathCache = new CappedMemoryCache();
-		$this->mountsForUsers = new CappedMemoryCache();
-	}
-
-	public function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null) {
-		$this->eventLogger->start('fs:setup:user:register', 'Registering mounts for user');
-		/** @var array<string, ICachedMountInfo> $newMounts */
-		$newMounts = [];
-		foreach ($mounts as $mount) {
-			// filter out any storages which aren't scanned yet since we aren't interested in files from those storages (yet)
-			if ($mount->getStorageRootId() !== -1) {
-				$mountInfo = new LazyStorageMountInfo($user, $mount);
-				$newMounts[$mountInfo->getKey()] = $mountInfo;
-			}
-		}
-
-		$cachedMounts = $this->getMountsForUser($user);
-		if (is_array($mountProviderClasses)) {
-			$cachedMounts = array_filter($cachedMounts, function (ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
-				// for existing mounts that didn't have a mount provider set
-				// we still want the ones that map to new mounts
-				if ($mountInfo->getMountProvider() === '' && isset($newMounts[$mountInfo->getKey()])) {
-					return true;
-				}
-				return in_array($mountInfo->getMountProvider(), $mountProviderClasses);
-			});
-		}
-
-		$addedMounts = [];
-		$removedMounts = [];
-
-		foreach ($newMounts as $mountKey => $newMount) {
-			if (!isset($cachedMounts[$mountKey])) {
-				$addedMounts[] = $newMount;
-			}
-		}
-
-		foreach ($cachedMounts as $mountKey => $cachedMount) {
-			if (!isset($newMounts[$mountKey])) {
-				$removedMounts[] = $cachedMount;
-			}
-		}
-
-		$changedMounts = $this->findChangedMounts($newMounts, $cachedMounts);
-
-		if ($addedMounts || $removedMounts || $changedMounts) {
-			$this->connection->beginTransaction();
-			$userUID = $user->getUID();
-			try {
-				foreach ($addedMounts as $mount) {
-					$this->logger->debug("Adding mount '{$mount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $mount->getMountProvider()]);
-					$this->addToCache($mount);
-					/** @psalm-suppress InvalidArgument */
-					$this->mountsForUsers[$userUID][$mount->getKey()] = $mount;
-				}
-				foreach ($removedMounts as $mount) {
-					$this->logger->debug("Removing mount '{$mount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $mount->getMountProvider()]);
-					$this->removeFromCache($mount);
-					unset($this->mountsForUsers[$userUID][$mount->getKey()]);
-				}
-				foreach ($changedMounts as $mountPair) {
-					$newMount = $mountPair[1];
-					$this->logger->debug("Updating mount '{$newMount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $newMount->getMountProvider()]);
-					$this->updateCachedMount($newMount);
-					/** @psalm-suppress InvalidArgument */
-					$this->mountsForUsers[$userUID][$newMount->getKey()] = $newMount;
-				}
-				$this->connection->commit();
-			} catch (\Throwable $e) {
-				$this->connection->rollBack();
-				throw $e;
-			}
-
-			// Only fire events after all mounts have already been adjusted in the database.
-			foreach ($addedMounts as $mount) {
-				$this->eventDispatcher->dispatchTyped(new UserMountAddedEvent($mount));
-			}
-			foreach ($removedMounts as $mount) {
-				$this->eventDispatcher->dispatchTyped(new UserMountRemovedEvent($mount));
-			}
-			foreach ($changedMounts as $mountPair) {
-				$this->eventDispatcher->dispatchTyped(new UserMountUpdatedEvent($mountPair[0], $mountPair[1]));
-			}
-		}
-		$this->eventLogger->end('fs:setup:user:register');
-	}
-
-	/**
-	 * @param array<string, ICachedMountInfo> $newMounts
-	 * @param array<string, ICachedMountInfo> $cachedMounts
-	 * @return list<list{0: ICachedMountInfo, 1: ICachedMountInfo}> Pairs of old and new mounts
-	 */
-	private function findChangedMounts(array $newMounts, array $cachedMounts): array {
-		$changed = [];
-		foreach ($cachedMounts as $key => $cachedMount) {
-			if (isset($newMounts[$key])) {
-				$newMount = $newMounts[$key];
-				if (
-					$newMount->getStorageId() !== $cachedMount->getStorageId() ||
-					$newMount->getMountId() !== $cachedMount->getMountId() ||
-					$newMount->getMountProvider() !== $cachedMount->getMountProvider()
-				) {
-					$changed[] = [$cachedMount, $newMount];
-				}
-			}
-		}
-		return $changed;
-	}
-
-	private function addToCache(ICachedMountInfo $mount) {
-		if ($mount->getStorageId() !== -1) {
-			$this->connection->insertIfNotExist('*PREFIX*mounts', [
-				'storage_id' => $mount->getStorageId(),
-				'root_id' => $mount->getRootId(),
-				'user_id' => $mount->getUser()->getUID(),
-				'mount_point' => $mount->getMountPoint(),
-				'mount_id' => $mount->getMountId(),
-				'mount_provider_class' => $mount->getMountProvider(),
-			], ['root_id', 'user_id', 'mount_point']);
-		} else {
-			// in some cases this is legitimate, like orphaned shares
-			$this->logger->debug('Could not get storage info for mount at ' . $mount->getMountPoint());
-		}
-	}
-
-	private function updateCachedMount(ICachedMountInfo $mount) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('mounts')
-			->set('storage_id', $builder->createNamedParameter($mount->getStorageId()))
-			->set('mount_point', $builder->createNamedParameter($mount->getMountPoint()))
-			->set('mount_id', $builder->createNamedParameter($mount->getMountId(), IQueryBuilder::PARAM_INT))
-			->set('mount_provider_class', $builder->createNamedParameter($mount->getMountProvider()))
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
-			->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)));
-
-		$query->executeStatement();
-	}
-
-	private function removeFromCache(ICachedMountInfo $mount) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
-			->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)))
-			->andWhere($builder->expr()->eq('mount_point', $builder->createNamedParameter($mount->getMountPoint())));
-		$query->executeStatement();
-	}
-
-	/**
-	 * @param array $row
-	 * @param (callable(CachedMountInfo): string)|null $pathCallback
-	 * @return CachedMountInfo
-	 */
-	private function dbRowToMountInfo(array $row, ?callable $pathCallback = null): ICachedMountInfo {
-		$user = new LazyUser($row['user_id'], $this->userManager);
-		$mount_id = $row['mount_id'];
-		if (!is_null($mount_id)) {
-			$mount_id = (int)$mount_id;
-		}
-		if ($pathCallback) {
-			return new LazyPathCachedMountInfo(
-				$user,
-				(int)$row['storage_id'],
-				(int)$row['root_id'],
-				$row['mount_point'],
-				$row['mount_provider_class'] ?? '',
-				$mount_id,
-				$pathCallback,
-			);
-		} else {
-			return new CachedMountInfo(
-				$user,
-				(int)$row['storage_id'],
-				(int)$row['root_id'],
-				$row['mount_point'],
-				$row['mount_provider_class'] ?? '',
-				$mount_id,
-				$row['path'] ?? '',
-			);
-		}
-	}
-
-	/**
-	 * @param IUser $user
-	 * @return ICachedMountInfo[]
-	 */
-	public function getMountsForUser(IUser $user) {
-		$userUID = $user->getUID();
-		if (!$this->userManager->userExists($userUID)) {
-			return [];
-		}
-		if (!isset($this->mountsForUsers[$userUID])) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'mount_provider_class')
-				->from('mounts', 'm')
-				->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userUID)));
-
-			$result = $query->executeQuery();
-			$rows = $result->fetchAll();
-			$result->closeCursor();
-
-			/** @var array<string, ICachedMountInfo> $mounts */
-			$mounts = [];
-			foreach ($rows as $row) {
-				$mount = $this->dbRowToMountInfo($row, [$this, 'getInternalPathForMountInfo']);
-				if ($mount !== null) {
-					$mounts[$mount->getKey()] = $mount;
-				}
-			}
-			$this->mountsForUsers[$userUID] = $mounts;
-		}
-		return $this->mountsForUsers[$userUID];
-	}
-
-	public function getInternalPathForMountInfo(CachedMountInfo $info): string {
-		$cached = $this->internalPathCache->get($info->getRootId());
-		if ($cached !== null) {
-			return $cached;
-		}
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('path')
-			->from('filecache')
-			->where($builder->expr()->eq('fileid', $builder->createNamedParameter($info->getRootId())));
-		return $query->executeQuery()->fetchOne() ?: '';
-	}
-
-	/**
-	 * @param int $numericStorageId
-	 * @param string|null $user limit the results to a single user
-	 * @return CachedMountInfo[]
-	 */
-	public function getMountsForStorageId($numericStorageId, $user = null) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-			->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($numericStorageId, IQueryBuilder::PARAM_INT)));
-
-		if ($user) {
-			$query->andWhere($builder->expr()->eq('user_id', $builder->createNamedParameter($user)));
-		}
-
-		$result = $query->executeQuery();
-		$rows = $result->fetchAll();
-		$result->closeCursor();
-
-		return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
-	}
-
-	/**
-	 * @param int $rootFileId
-	 * @return CachedMountInfo[]
-	 */
-	public function getMountsForRootId($rootFileId) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
-			->where($builder->expr()->eq('root_id', $builder->createNamedParameter($rootFileId, IQueryBuilder::PARAM_INT)));
-
-		$result = $query->executeQuery();
-		$rows = $result->fetchAll();
-		$result->closeCursor();
-
-		return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
-	}
-
-	/**
-	 * @param $fileId
-	 * @return array{int, string, int}
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	private function getCacheInfoFromFileId($fileId): array {
-		if (!isset($this->cacheInfoCache[$fileId])) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->select('storage', 'path', 'mimetype')
-				->from('filecache')
-				->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
-
-			$result = $query->executeQuery();
-			$row = $result->fetch();
-			$result->closeCursor();
-
-			if (is_array($row)) {
-				$this->cacheInfoCache[$fileId] = [
-					(int)$row['storage'],
-					(string)$row['path'],
-					(int)$row['mimetype']
-				];
-			} else {
-				throw new NotFoundException('File with id "' . $fileId . '" not found');
-			}
-		}
-		return $this->cacheInfoCache[$fileId];
-	}
-
-	/**
-	 * @param int $fileId
-	 * @param string|null $user optionally restrict the results to a single user
-	 * @return ICachedMountFileInfo[]
-	 * @since 9.0.0
-	 */
-	public function getMountsForFileId($fileId, $user = null) {
-		try {
-			[$storageId, $internalPath] = $this->getCacheInfoFromFileId($fileId);
-		} catch (NotFoundException $e) {
-			return [];
-		}
-		$mountsForStorage = $this->getMountsForStorageId($storageId, $user);
-
-		// filter mounts that are from the same storage but not a parent of the file we care about
-		$filteredMounts = array_filter($mountsForStorage, function (ICachedMountInfo $mount) use ($internalPath, $fileId) {
-			if ($fileId === $mount->getRootId()) {
-				return true;
-			}
-			$internalMountPath = $mount->getRootInternalPath();
-
-			return $internalMountPath === '' || str_starts_with($internalPath, $internalMountPath . '/');
-		});
-
-		$filteredMounts = array_values(array_filter($filteredMounts, function (ICachedMountInfo $mount) {
-			return $this->userManager->userExists($mount->getUser()->getUID());
-		}));
-
-		return array_map(function (ICachedMountInfo $mount) use ($internalPath) {
-			return new CachedMountFileInfo(
-				$mount->getUser(),
-				$mount->getStorageId(),
-				$mount->getRootId(),
-				$mount->getMountPoint(),
-				$mount->getMountId(),
-				$mount->getMountProvider(),
-				$mount->getRootInternalPath(),
-				$internalPath
-			);
-		}, $filteredMounts);
-	}
-
-	/**
-	 * Remove all cached mounts for a user
-	 *
-	 * @param IUser $user
-	 */
-	public function removeUserMounts(IUser $user) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($user->getUID())));
-		$query->executeStatement();
-	}
-
-	public function removeUserStorageMount($storageId, $userId) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userId)))
-			->andWhere($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
-		$query->executeStatement();
-	}
-
-	public function remoteStorageMounts($storageId) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->delete('mounts')
-			->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
-		$query->executeStatement();
-	}
-
-	/**
-	 * @param array $users
-	 * @return array
-	 */
-	public function getUsedSpaceForUsers(array $users) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$slash = $builder->createNamedParameter('/');
-
-		$mountPoint = $builder->func()->concat(
-			$builder->func()->concat($slash, 'user_id'),
-			$slash
-		);
-
-		$userIds = array_map(function (IUser $user) {
-			return $user->getUID();
-		}, $users);
-
-		$query = $builder->select('m.user_id', 'f.size')
-			->from('mounts', 'm')
-			->innerJoin('m', 'filecache', 'f',
-				$builder->expr()->andX(
-					$builder->expr()->eq('m.storage_id', 'f.storage'),
-					$builder->expr()->eq('f.path_hash', $builder->createNamedParameter(md5('files')))
-				))
-			->where($builder->expr()->eq('m.mount_point', $mountPoint))
-			->andWhere($builder->expr()->in('m.user_id', $builder->createNamedParameter($userIds, IQueryBuilder::PARAM_STR_ARRAY)));
-
-		$result = $query->executeQuery();
-
-		$results = [];
-		while ($row = $result->fetch()) {
-			$results[$row['user_id']] = $row['size'];
-		}
-		$result->closeCursor();
-		return $results;
-	}
-
-	public function clear(): void {
-		$this->cacheInfoCache = new CappedMemoryCache();
-		$this->mountsForUsers = new CappedMemoryCache();
-	}
-
-	public function getMountForPath(IUser $user, string $path): ICachedMountInfo {
-		$mounts = $this->getMountsForUser($user);
-		$mountPoints = array_map(function (ICachedMountInfo $mount) {
-			return $mount->getMountPoint();
-		}, $mounts);
-		$mounts = array_combine($mountPoints, $mounts);
-
-		$current = rtrim($path, '/');
-		// walk up the directory tree until we find a path that has a mountpoint set
-		// the loop will return if a mountpoint is found or break if none are found
-		while (true) {
-			$mountPoint = $current . '/';
-			if (isset($mounts[$mountPoint])) {
-				return $mounts[$mountPoint];
-			} elseif ($current === '') {
-				break;
-			}
-
-			$current = dirname($current);
-			if ($current === '.' || $current === '/') {
-				$current = '';
-			}
-		}
-
-		throw new NotFoundException('No cached mount for path ' . $path);
-	}
-
-	public function getMountsInPath(IUser $user, string $path): array {
-		$path = rtrim($path, '/') . '/';
-		$mounts = $this->getMountsForUser($user);
-		return array_filter($mounts, function (ICachedMountInfo $mount) use ($path) {
-			return $mount->getMountPoint() !== $path && str_starts_with($mount->getMountPoint(), $path);
-		});
-	}
+    /**
+     * Cached mount info.
+     * @var CappedMemoryCache<ICachedMountInfo[]>
+     **/
+    private CappedMemoryCache $mountsForUsers;
+    /**
+     * fileid => internal path mapping for cached mount info.
+     * @var CappedMemoryCache<string>
+     **/
+    private CappedMemoryCache $internalPathCache;
+    /** @var CappedMemoryCache<array> */
+    private CappedMemoryCache $cacheInfoCache;
+
+    /**
+     * UserMountCache constructor.
+     */
+    public function __construct(
+        private IDBConnection $connection,
+        private IUserManager $userManager,
+        private LoggerInterface $logger,
+        private IEventLogger $eventLogger,
+        private IEventDispatcher $eventDispatcher,
+    ) {
+        $this->cacheInfoCache = new CappedMemoryCache();
+        $this->internalPathCache = new CappedMemoryCache();
+        $this->mountsForUsers = new CappedMemoryCache();
+    }
+
+    public function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null) {
+        $this->eventLogger->start('fs:setup:user:register', 'Registering mounts for user');
+        /** @var array<string, ICachedMountInfo> $newMounts */
+        $newMounts = [];
+        foreach ($mounts as $mount) {
+            // filter out any storages which aren't scanned yet since we aren't interested in files from those storages (yet)
+            if ($mount->getStorageRootId() !== -1) {
+                $mountInfo = new LazyStorageMountInfo($user, $mount);
+                $newMounts[$mountInfo->getKey()] = $mountInfo;
+            }
+        }
+
+        $cachedMounts = $this->getMountsForUser($user);
+        if (is_array($mountProviderClasses)) {
+            $cachedMounts = array_filter($cachedMounts, function (ICachedMountInfo $mountInfo) use ($mountProviderClasses, $newMounts) {
+                // for existing mounts that didn't have a mount provider set
+                // we still want the ones that map to new mounts
+                if ($mountInfo->getMountProvider() === '' && isset($newMounts[$mountInfo->getKey()])) {
+                    return true;
+                }
+                return in_array($mountInfo->getMountProvider(), $mountProviderClasses);
+            });
+        }
+
+        $addedMounts = [];
+        $removedMounts = [];
+
+        foreach ($newMounts as $mountKey => $newMount) {
+            if (!isset($cachedMounts[$mountKey])) {
+                $addedMounts[] = $newMount;
+            }
+        }
+
+        foreach ($cachedMounts as $mountKey => $cachedMount) {
+            if (!isset($newMounts[$mountKey])) {
+                $removedMounts[] = $cachedMount;
+            }
+        }
+
+        $changedMounts = $this->findChangedMounts($newMounts, $cachedMounts);
+
+        if ($addedMounts || $removedMounts || $changedMounts) {
+            $this->connection->beginTransaction();
+            $userUID = $user->getUID();
+            try {
+                foreach ($addedMounts as $mount) {
+                    $this->logger->debug("Adding mount '{$mount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $mount->getMountProvider()]);
+                    $this->addToCache($mount);
+                    /** @psalm-suppress InvalidArgument */
+                    $this->mountsForUsers[$userUID][$mount->getKey()] = $mount;
+                }
+                foreach ($removedMounts as $mount) {
+                    $this->logger->debug("Removing mount '{$mount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $mount->getMountProvider()]);
+                    $this->removeFromCache($mount);
+                    unset($this->mountsForUsers[$userUID][$mount->getKey()]);
+                }
+                foreach ($changedMounts as $mountPair) {
+                    $newMount = $mountPair[1];
+                    $this->logger->debug("Updating mount '{$newMount->getKey()}' for user '$userUID'", ['app' => 'files', 'mount_provider' => $newMount->getMountProvider()]);
+                    $this->updateCachedMount($newMount);
+                    /** @psalm-suppress InvalidArgument */
+                    $this->mountsForUsers[$userUID][$newMount->getKey()] = $newMount;
+                }
+                $this->connection->commit();
+            } catch (\Throwable $e) {
+                $this->connection->rollBack();
+                throw $e;
+            }
+
+            // Only fire events after all mounts have already been adjusted in the database.
+            foreach ($addedMounts as $mount) {
+                $this->eventDispatcher->dispatchTyped(new UserMountAddedEvent($mount));
+            }
+            foreach ($removedMounts as $mount) {
+                $this->eventDispatcher->dispatchTyped(new UserMountRemovedEvent($mount));
+            }
+            foreach ($changedMounts as $mountPair) {
+                $this->eventDispatcher->dispatchTyped(new UserMountUpdatedEvent($mountPair[0], $mountPair[1]));
+            }
+        }
+        $this->eventLogger->end('fs:setup:user:register');
+    }
+
+    /**
+     * @param array<string, ICachedMountInfo> $newMounts
+     * @param array<string, ICachedMountInfo> $cachedMounts
+     * @return list<list{0: ICachedMountInfo, 1: ICachedMountInfo}> Pairs of old and new mounts
+     */
+    private function findChangedMounts(array $newMounts, array $cachedMounts): array {
+        $changed = [];
+        foreach ($cachedMounts as $key => $cachedMount) {
+            if (isset($newMounts[$key])) {
+                $newMount = $newMounts[$key];
+                if (
+                    $newMount->getStorageId() !== $cachedMount->getStorageId() ||
+                    $newMount->getMountId() !== $cachedMount->getMountId() ||
+                    $newMount->getMountProvider() !== $cachedMount->getMountProvider()
+                ) {
+                    $changed[] = [$cachedMount, $newMount];
+                }
+            }
+        }
+        return $changed;
+    }
+
+    private function addToCache(ICachedMountInfo $mount) {
+        if ($mount->getStorageId() !== -1) {
+            $this->connection->insertIfNotExist('*PREFIX*mounts', [
+                'storage_id' => $mount->getStorageId(),
+                'root_id' => $mount->getRootId(),
+                'user_id' => $mount->getUser()->getUID(),
+                'mount_point' => $mount->getMountPoint(),
+                'mount_id' => $mount->getMountId(),
+                'mount_provider_class' => $mount->getMountProvider(),
+            ], ['root_id', 'user_id', 'mount_point']);
+        } else {
+            // in some cases this is legitimate, like orphaned shares
+            $this->logger->debug('Could not get storage info for mount at ' . $mount->getMountPoint());
+        }
+    }
+
+    private function updateCachedMount(ICachedMountInfo $mount) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('mounts')
+            ->set('storage_id', $builder->createNamedParameter($mount->getStorageId()))
+            ->set('mount_point', $builder->createNamedParameter($mount->getMountPoint()))
+            ->set('mount_id', $builder->createNamedParameter($mount->getMountId(), IQueryBuilder::PARAM_INT))
+            ->set('mount_provider_class', $builder->createNamedParameter($mount->getMountProvider()))
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
+            ->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)));
+
+        $query->executeStatement();
+    }
+
+    private function removeFromCache(ICachedMountInfo $mount) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($mount->getUser()->getUID())))
+            ->andWhere($builder->expr()->eq('root_id', $builder->createNamedParameter($mount->getRootId(), IQueryBuilder::PARAM_INT)))
+            ->andWhere($builder->expr()->eq('mount_point', $builder->createNamedParameter($mount->getMountPoint())));
+        $query->executeStatement();
+    }
+
+    /**
+     * @param array $row
+     * @param (callable(CachedMountInfo): string)|null $pathCallback
+     * @return CachedMountInfo
+     */
+    private function dbRowToMountInfo(array $row, ?callable $pathCallback = null): ICachedMountInfo {
+        $user = new LazyUser($row['user_id'], $this->userManager);
+        $mount_id = $row['mount_id'];
+        if (!is_null($mount_id)) {
+            $mount_id = (int)$mount_id;
+        }
+        if ($pathCallback) {
+            return new LazyPathCachedMountInfo(
+                $user,
+                (int)$row['storage_id'],
+                (int)$row['root_id'],
+                $row['mount_point'],
+                $row['mount_provider_class'] ?? '',
+                $mount_id,
+                $pathCallback,
+            );
+        } else {
+            return new CachedMountInfo(
+                $user,
+                (int)$row['storage_id'],
+                (int)$row['root_id'],
+                $row['mount_point'],
+                $row['mount_provider_class'] ?? '',
+                $mount_id,
+                $row['path'] ?? '',
+            );
+        }
+    }
+
+    /**
+     * @param IUser $user
+     * @return ICachedMountInfo[]
+     */
+    public function getMountsForUser(IUser $user) {
+        $userUID = $user->getUID();
+        if (!$this->userManager->userExists($userUID)) {
+            return [];
+        }
+        if (!isset($this->mountsForUsers[$userUID])) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'mount_provider_class')
+                ->from('mounts', 'm')
+                ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userUID)));
+
+            $result = $query->executeQuery();
+            $rows = $result->fetchAll();
+            $result->closeCursor();
+
+            /** @var array<string, ICachedMountInfo> $mounts */
+            $mounts = [];
+            foreach ($rows as $row) {
+                $mount = $this->dbRowToMountInfo($row, [$this, 'getInternalPathForMountInfo']);
+                if ($mount !== null) {
+                    $mounts[$mount->getKey()] = $mount;
+                }
+            }
+            $this->mountsForUsers[$userUID] = $mounts;
+        }
+        return $this->mountsForUsers[$userUID];
+    }
+
+    public function getInternalPathForMountInfo(CachedMountInfo $info): string {
+        $cached = $this->internalPathCache->get($info->getRootId());
+        if ($cached !== null) {
+            return $cached;
+        }
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('path')
+            ->from('filecache')
+            ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($info->getRootId())));
+        return $query->executeQuery()->fetchOne() ?: '';
+    }
+
+    /**
+     * @param int $numericStorageId
+     * @param string|null $user limit the results to a single user
+     * @return CachedMountInfo[]
+     */
+    public function getMountsForStorageId($numericStorageId, $user = null) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+            ->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($numericStorageId, IQueryBuilder::PARAM_INT)));
+
+        if ($user) {
+            $query->andWhere($builder->expr()->eq('user_id', $builder->createNamedParameter($user)));
+        }
+
+        $result = $query->executeQuery();
+        $rows = $result->fetchAll();
+        $result->closeCursor();
+
+        return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
+    }
+
+    /**
+     * @param int $rootFileId
+     * @return CachedMountInfo[]
+     */
+    public function getMountsForRootId($rootFileId) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select('storage_id', 'root_id', 'user_id', 'mount_point', 'mount_id', 'f.path', 'mount_provider_class')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f', $builder->expr()->eq('m.root_id', 'f.fileid'))
+            ->where($builder->expr()->eq('root_id', $builder->createNamedParameter($rootFileId, IQueryBuilder::PARAM_INT)));
+
+        $result = $query->executeQuery();
+        $rows = $result->fetchAll();
+        $result->closeCursor();
+
+        return array_filter(array_map([$this, 'dbRowToMountInfo'], $rows));
+    }
+
+    /**
+     * @param $fileId
+     * @return array{int, string, int}
+     * @throws \OCP\Files\NotFoundException
+     */
+    private function getCacheInfoFromFileId($fileId): array {
+        if (!isset($this->cacheInfoCache[$fileId])) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->select('storage', 'path', 'mimetype')
+                ->from('filecache')
+                ->where($builder->expr()->eq('fileid', $builder->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+
+            $result = $query->executeQuery();
+            $row = $result->fetch();
+            $result->closeCursor();
+
+            if (is_array($row)) {
+                $this->cacheInfoCache[$fileId] = [
+                    (int)$row['storage'],
+                    (string)$row['path'],
+                    (int)$row['mimetype']
+                ];
+            } else {
+                throw new NotFoundException('File with id "' . $fileId . '" not found');
+            }
+        }
+        return $this->cacheInfoCache[$fileId];
+    }
+
+    /**
+     * @param int $fileId
+     * @param string|null $user optionally restrict the results to a single user
+     * @return ICachedMountFileInfo[]
+     * @since 9.0.0
+     */
+    public function getMountsForFileId($fileId, $user = null) {
+        try {
+            [$storageId, $internalPath] = $this->getCacheInfoFromFileId($fileId);
+        } catch (NotFoundException $e) {
+            return [];
+        }
+        $mountsForStorage = $this->getMountsForStorageId($storageId, $user);
+
+        // filter mounts that are from the same storage but not a parent of the file we care about
+        $filteredMounts = array_filter($mountsForStorage, function (ICachedMountInfo $mount) use ($internalPath, $fileId) {
+            if ($fileId === $mount->getRootId()) {
+                return true;
+            }
+            $internalMountPath = $mount->getRootInternalPath();
+
+            return $internalMountPath === '' || str_starts_with($internalPath, $internalMountPath . '/');
+        });
+
+        $filteredMounts = array_values(array_filter($filteredMounts, function (ICachedMountInfo $mount) {
+            return $this->userManager->userExists($mount->getUser()->getUID());
+        }));
+
+        return array_map(function (ICachedMountInfo $mount) use ($internalPath) {
+            return new CachedMountFileInfo(
+                $mount->getUser(),
+                $mount->getStorageId(),
+                $mount->getRootId(),
+                $mount->getMountPoint(),
+                $mount->getMountId(),
+                $mount->getMountProvider(),
+                $mount->getRootInternalPath(),
+                $internalPath
+            );
+        }, $filteredMounts);
+    }
+
+    /**
+     * Remove all cached mounts for a user
+     *
+     * @param IUser $user
+     */
+    public function removeUserMounts(IUser $user) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($user->getUID())));
+        $query->executeStatement();
+    }
+
+    public function removeUserStorageMount($storageId, $userId) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('user_id', $builder->createNamedParameter($userId)))
+            ->andWhere($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+        $query->executeStatement();
+    }
+
+    public function remoteStorageMounts($storageId) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->delete('mounts')
+            ->where($builder->expr()->eq('storage_id', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+        $query->executeStatement();
+    }
+
+    /**
+     * @param array $users
+     * @return array
+     */
+    public function getUsedSpaceForUsers(array $users) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $slash = $builder->createNamedParameter('/');
+
+        $mountPoint = $builder->func()->concat(
+            $builder->func()->concat($slash, 'user_id'),
+            $slash
+        );
+
+        $userIds = array_map(function (IUser $user) {
+            return $user->getUID();
+        }, $users);
+
+        $query = $builder->select('m.user_id', 'f.size')
+            ->from('mounts', 'm')
+            ->innerJoin('m', 'filecache', 'f',
+                $builder->expr()->andX(
+                    $builder->expr()->eq('m.storage_id', 'f.storage'),
+                    $builder->expr()->eq('f.path_hash', $builder->createNamedParameter(md5('files')))
+                ))
+            ->where($builder->expr()->eq('m.mount_point', $mountPoint))
+            ->andWhere($builder->expr()->in('m.user_id', $builder->createNamedParameter($userIds, IQueryBuilder::PARAM_STR_ARRAY)));
+
+        $result = $query->executeQuery();
+
+        $results = [];
+        while ($row = $result->fetch()) {
+            $results[$row['user_id']] = $row['size'];
+        }
+        $result->closeCursor();
+        return $results;
+    }
+
+    public function clear(): void {
+        $this->cacheInfoCache = new CappedMemoryCache();
+        $this->mountsForUsers = new CappedMemoryCache();
+    }
+
+    public function getMountForPath(IUser $user, string $path): ICachedMountInfo {
+        $mounts = $this->getMountsForUser($user);
+        $mountPoints = array_map(function (ICachedMountInfo $mount) {
+            return $mount->getMountPoint();
+        }, $mounts);
+        $mounts = array_combine($mountPoints, $mounts);
+
+        $current = rtrim($path, '/');
+        // walk up the directory tree until we find a path that has a mountpoint set
+        // the loop will return if a mountpoint is found or break if none are found
+        while (true) {
+            $mountPoint = $current . '/';
+            if (isset($mounts[$mountPoint])) {
+                return $mounts[$mountPoint];
+            } elseif ($current === '') {
+                break;
+            }
+
+            $current = dirname($current);
+            if ($current === '.' || $current === '/') {
+                $current = '';
+            }
+        }
+
+        throw new NotFoundException('No cached mount for path ' . $path);
+    }
+
+    public function getMountsInPath(IUser $user, string $path): array {
+        $path = rtrim($path, '/') . '/';
+        $mounts = $this->getMountsForUser($user);
+        return array_filter($mounts, function (ICachedMountInfo $mount) use ($path) {
+            return $mount->getMountPoint() !== $path && str_starts_with($mount->getMountPoint(), $path);
+        });
+    }
 }

tests/lib/Files/Config/UserMountCacheTest.php

Indentation +457 added lines, -457 removed lines

@@ -34,566 +34,566 @@
  * @group DB
  */
 class UserMountCacheTest extends TestCase {
-	private IDBConnection $connection;
-	private IUserManager $userManager;
-	private IEventDispatcher $eventDispatcher;
-	private UserMountCache $cache;
-	private array $fileIds = [];
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->fileIds = [];
-
-		$this->connection = \OC::$server->getDatabaseConnection();
-
-		$config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$config
-			->expects($this->any())
-			->method('getUserValue')
-			->willReturnArgument(3);
-		$config
-			->expects($this->any())
-			->method('getAppValue')
-			->willReturnArgument(2);
-
-		$this->userManager = new Manager($config, $this->createMock(ICacheFactory::class), $this->createMock(IEventDispatcher::class), $this->createMock(LoggerInterface::class));
-		$userBackend = new Dummy();
-		$userBackend->createUser('u1', '');
-		$userBackend->createUser('u2', '');
-		$userBackend->createUser('u3', '');
-		$this->userManager->registerBackend($userBackend);
-
-		$this->eventDispatcher = $this->createMock(IEventDispatcher::class);
+    private IDBConnection $connection;
+    private IUserManager $userManager;
+    private IEventDispatcher $eventDispatcher;
+    private UserMountCache $cache;
+    private array $fileIds = [];
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->fileIds = [];
+
+        $this->connection = \OC::$server->getDatabaseConnection();
+
+        $config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $config
+            ->expects($this->any())
+            ->method('getUserValue')
+            ->willReturnArgument(3);
+        $config
+            ->expects($this->any())
+            ->method('getAppValue')
+            ->willReturnArgument(2);
+
+        $this->userManager = new Manager($config, $this->createMock(ICacheFactory::class), $this->createMock(IEventDispatcher::class), $this->createMock(LoggerInterface::class));
+        $userBackend = new Dummy();
+        $userBackend->createUser('u1', '');
+        $userBackend->createUser('u2', '');
+        $userBackend->createUser('u3', '');
+        $this->userManager->registerBackend($userBackend);
+
+        $this->eventDispatcher = $this->createMock(IEventDispatcher::class);
 
-		$this->cache = new UserMountCache($this->connection,
-			$this->userManager,
-			$this->createMock(LoggerInterface::class),
-			$this->createMock(IEventLogger::class),
-			$this->eventDispatcher,
-		);
-	}
-
-	protected function tearDown(): void {
-		$builder = $this->connection->getQueryBuilder();
-
-		$builder->delete('mounts')->execute();
-
-		$builder = $this->connection->getQueryBuilder();
-
-		foreach ($this->fileIds as $fileId) {
-			$builder->delete('filecache')
-				->where($builder->expr()->eq('fileid', new Literal($fileId)))
-				->execute();
-		}
-	}
-
-	private function getStorage($storageId, $rootInternalPath = '') {
-		$rootId = $this->createCacheEntry($rootInternalPath, $storageId);
-
-		$storageCache = $this->createMock(\OC\Files\Cache\Storage::class);
-		$storageCache->expects($this->any())
-			->method('getNumericId')
-			->willReturn($storageId);
-
-		$cache = $this->createMock(Cache::class);
-		$cache->expects($this->any())
-			->method('getId')
-			->willReturn($rootId);
-		$cache->method('getNumericStorageId')
-			->willReturn($storageId);
+        $this->cache = new UserMountCache($this->connection,
+            $this->userManager,
+            $this->createMock(LoggerInterface::class),
+            $this->createMock(IEventLogger::class),
+            $this->eventDispatcher,
+        );
+    }
+
+    protected function tearDown(): void {
+        $builder = $this->connection->getQueryBuilder();
+
+        $builder->delete('mounts')->execute();
+
+        $builder = $this->connection->getQueryBuilder();
+
+        foreach ($this->fileIds as $fileId) {
+            $builder->delete('filecache')
+                ->where($builder->expr()->eq('fileid', new Literal($fileId)))
+                ->execute();
+        }
+    }
+
+    private function getStorage($storageId, $rootInternalPath = '') {
+        $rootId = $this->createCacheEntry($rootInternalPath, $storageId);
+
+        $storageCache = $this->createMock(\OC\Files\Cache\Storage::class);
+        $storageCache->expects($this->any())
+            ->method('getNumericId')
+            ->willReturn($storageId);
+
+        $cache = $this->createMock(Cache::class);
+        $cache->expects($this->any())
+            ->method('getId')
+            ->willReturn($rootId);
+        $cache->method('getNumericStorageId')
+            ->willReturn($storageId);
 
-		$storage = $this->createMock(Storage::class);
-		$storage->expects($this->any())
-			->method('getStorageCache')
-			->willReturn($storageCache);
-		$storage->expects($this->any())
-			->method('getCache')
-			->willReturn($cache);
+        $storage = $this->createMock(Storage::class);
+        $storage->expects($this->any())
+            ->method('getStorageCache')
+            ->willReturn($storageCache);
+        $storage->expects($this->any())
+            ->method('getCache')
+            ->willReturn($cache);
 
-		return [$storage, $rootId];
-	}
-
-	private function clearCache() {
-		$this->invokePrivate($this->cache, 'mountsForUsers', [new CappedMemoryCache()]);
-	}
-
-	private function keyForMount(MountPoint $mount): string {
-		return $mount->getStorageRootId() . '::' . $mount->getMountPoint();
-	}
-
-	public function testNewMounts(): void {
-		$this->eventDispatcher
-			->expects($this->once())
-			->method('dispatchTyped')
-			->with($this->callback(fn (UserMountAddedEvent $event) => $event->mountPoint->getMountPoint() === '/asd/'));
-
-		$user = $this->userManager->get('u1');
+        return [$storage, $rootId];
+    }
+
+    private function clearCache() {
+        $this->invokePrivate($this->cache, 'mountsForUsers', [new CappedMemoryCache()]);
+    }
+
+    private function keyForMount(MountPoint $mount): string {
+        return $mount->getStorageRootId() . '::' . $mount->getMountPoint();
+    }
+
+    public function testNewMounts(): void {
+        $this->eventDispatcher
+            ->expects($this->once())
+            ->method('dispatchTyped')
+            ->with($this->callback(fn (UserMountAddedEvent $event) => $event->mountPoint->getMountPoint() === '/asd/'));
+
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/asd/', $cachedMount->getMountPoint());
-		$this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
-		$this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
-		$this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/asd/', $cachedMount->getMountPoint());
+        $this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
+        $this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
+        $this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
+    }
 
-	public function testSameMounts(): void {
-		$this->eventDispatcher
-			->expects($this->once())
-			->method('dispatchTyped')
-			->with($this->callback(fn (UserMountAddedEvent $event) => $event->mountPoint->getMountPoint() === '/asd/'));
+    public function testSameMounts(): void {
+        $this->eventDispatcher
+            ->expects($this->once())
+            ->method('dispatchTyped')
+            ->with($this->callback(fn (UserMountAddedEvent $event) => $event->mountPoint->getMountPoint() === '/asd/'));
 
-		$user = $this->userManager->get('u1');
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/asd/', $cachedMount->getMountPoint());
-		$this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
-		$this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
-		$this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/asd/', $cachedMount->getMountPoint());
+        $this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
+        $this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
+        $this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
+    }
 
-	public function testRemoveMounts(): void {
-		$operation = 0;
-		$this->eventDispatcher
-			->expects($this->exactly(2))
-			->method('dispatchTyped')
-			->with($this->callback(function (UserMountAddedEvent|UserMountRemovedEvent $event) use (&$operation) {
-				return match(++$operation) {
-					1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/asd/',
-					2 => $event instanceof UserMountRemovedEvent && $event->mountPoint->getMountPoint() === '/asd/',
-					default => false,
-				};
-			}));
+    public function testRemoveMounts(): void {
+        $operation = 0;
+        $this->eventDispatcher
+            ->expects($this->exactly(2))
+            ->method('dispatchTyped')
+            ->with($this->callback(function (UserMountAddedEvent|UserMountRemovedEvent $event) use (&$operation) {
+                return match(++$operation) {
+                    1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/asd/',
+                    2 => $event instanceof UserMountRemovedEvent && $event->mountPoint->getMountPoint() === '/asd/',
+                    default => false,
+                };
+            }));
 
-		$user = $this->userManager->get('u1');
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$this->cache->registerMounts($user, []);
+        $this->cache->registerMounts($user, []);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(0, $cachedMounts);
-	}
+        $this->assertCount(0, $cachedMounts);
+    }
 
-	public function testChangeMounts(): void {
-		$operation = 0;
-		$this->eventDispatcher
-			->expects($this->exactly(3))
-			->method('dispatchTyped')
-			->with($this->callback(function (UserMountAddedEvent|UserMountRemovedEvent $event) use (&$operation) {
-				return match(++$operation) {
-					1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/bar/',
-					2 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/foo/',
-					3 => $event instanceof UserMountRemovedEvent && $event->mountPoint->getMountPoint() === '/bar/',
-					default => false,
-				};
-			}));
+    public function testChangeMounts(): void {
+        $operation = 0;
+        $this->eventDispatcher
+            ->expects($this->exactly(3))
+            ->method('dispatchTyped')
+            ->with($this->callback(function (UserMountAddedEvent|UserMountRemovedEvent $event) use (&$operation) {
+                return match(++$operation) {
+                    1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/bar/',
+                    2 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/foo/',
+                    3 => $event instanceof UserMountRemovedEvent && $event->mountPoint->getMountPoint() === '/bar/',
+                    default => false,
+                };
+            }));
 
-		$user = $this->userManager->get('u1');
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/bar/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/bar/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$mount = new MountPoint($storage, '/foo/');
+        $mount = new MountPoint($storage, '/foo/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/foo/', $cachedMount->getMountPoint());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/foo/', $cachedMount->getMountPoint());
+    }
 
-	public function testChangeMountId(): void {
-		$operation = 0;
-		$this->eventDispatcher
-			->expects($this->exactly(2))
-			->method('dispatchTyped')
-			->with($this->callback(function (UserMountAddedEvent|UserMountUpdatedEvent $event) use (&$operation) {
-				return match(++$operation) {
-					1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/foo/',
-					2 => $event instanceof UserMountUpdatedEvent && $event->oldMountPoint->getMountId() === null && $event->newMountPoint->getMountId() === 1,
-					default => false,
-				};
-			}));
+    public function testChangeMountId(): void {
+        $operation = 0;
+        $this->eventDispatcher
+            ->expects($this->exactly(2))
+            ->method('dispatchTyped')
+            ->with($this->callback(function (UserMountAddedEvent|UserMountUpdatedEvent $event) use (&$operation) {
+                return match(++$operation) {
+                    1 => $event instanceof UserMountAddedEvent && $event->mountPoint->getMountPoint() === '/foo/',
+                    2 => $event instanceof UserMountUpdatedEvent && $event->oldMountPoint->getMountId() === null && $event->newMountPoint->getMountId() === 1,
+                    default => false,
+                };
+            }));
 
-		$user = $this->userManager->get('u1');
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/foo/', null, null, null, null);
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/foo/', null, null, null, null);
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$mount = new MountPoint($storage, '/foo/', null, null, null, 1);
+        $mount = new MountPoint($storage, '/foo/', null, null, null, 1);
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals(1, $cachedMount->getMountId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals(1, $cachedMount->getMountId());
+    }
 
-	public function testGetMountsForUser(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
-		$user3 = $this->userManager->get('u3');
+    public function testGetMountsForUser(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
+        $user3 = $this->userManager->get('u3');
 
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2, 'foo/bar');
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2, 'foo/bar');
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
 
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
-		$this->cache->registerMounts($user3, [$mount2]);
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
+        $this->cache->registerMounts($user3, [$mount2]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$user3->delete();
+        $user3->delete();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
+        $cachedMounts = $this->cache->getMountsForUser($user1);
 
-		$this->assertCount(2, $cachedMounts);
-		$this->assertEquals('/foo/', $cachedMounts[$this->keyForMount($mount1)]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount1)]->getUser()->getUID());
-		$this->assertEquals($id1, $cachedMounts[$this->keyForMount($mount1)]->getRootId());
-		$this->assertEquals(1, $cachedMounts[$this->keyForMount($mount1)]->getStorageId());
-		$this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getRootInternalPath());
-
-		$this->assertEquals('/bar/', $cachedMounts[$this->keyForMount($mount2)]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount2)]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[$this->keyForMount($mount2)]->getRootId());
-		$this->assertEquals(2, $cachedMounts[$this->keyForMount($mount2)]->getStorageId());
-		$this->assertEquals('foo/bar', $cachedMounts[$this->keyForMount($mount2)]->getRootInternalPath());
-
-		$cachedMounts = $this->cache->getMountsForUser($user3);
-		$this->assertEmpty($cachedMounts);
-	}
-
-	public function testGetMountsByStorageId(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
-
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
-
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
-
-		$this->clearCache();
-
-		$cachedMounts = $this->cache->getMountsForStorageId(2);
-		$this->sortMounts($cachedMounts);
-
-		$this->assertCount(2, $cachedMounts);
-
-		$this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-
-		$this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
-		$this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[1]->getRootId());
-		$this->assertEquals(2, $cachedMounts[1]->getStorageId());
-	}
-
-	public function testGetMountsByRootId(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
-
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
+        $this->assertCount(2, $cachedMounts);
+        $this->assertEquals('/foo/', $cachedMounts[$this->keyForMount($mount1)]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount1)]->getUser()->getUID());
+        $this->assertEquals($id1, $cachedMounts[$this->keyForMount($mount1)]->getRootId());
+        $this->assertEquals(1, $cachedMounts[$this->keyForMount($mount1)]->getStorageId());
+        $this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getRootInternalPath());
+
+        $this->assertEquals('/bar/', $cachedMounts[$this->keyForMount($mount2)]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount2)]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[$this->keyForMount($mount2)]->getRootId());
+        $this->assertEquals(2, $cachedMounts[$this->keyForMount($mount2)]->getStorageId());
+        $this->assertEquals('foo/bar', $cachedMounts[$this->keyForMount($mount2)]->getRootInternalPath());
+
+        $cachedMounts = $this->cache->getMountsForUser($user3);
+        $this->assertEmpty($cachedMounts);
+    }
+
+    public function testGetMountsByStorageId(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
+
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
+
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
+
+        $this->clearCache();
+
+        $cachedMounts = $this->cache->getMountsForStorageId(2);
+        $this->sortMounts($cachedMounts);
+
+        $this->assertCount(2, $cachedMounts);
+
+        $this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+
+        $this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
+        $this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[1]->getRootId());
+        $this->assertEquals(2, $cachedMounts[1]->getStorageId());
+    }
+
+    public function testGetMountsByRootId(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
+
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
 
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
 
-		$this->clearCache();
-
-		$cachedMounts = $this->cache->getMountsForRootId($id2);
-		$this->sortMounts($cachedMounts);
-
-		$this->assertCount(2, $cachedMounts);
-
-		$this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-
-		$this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
-		$this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[1]->getRootId());
-		$this->assertEquals(2, $cachedMounts[1]->getStorageId());
-	}
-
-	private function sortMounts(&$mounts) {
-		usort($mounts, function (ICachedMountInfo $a, ICachedMountInfo $b) {
-			return strcmp($a->getUser()->getUID(), $b->getUser()->getUID());
-		});
-	}
-
-	private function createCacheEntry($internalPath, $storageId, $size = 0) {
-		$internalPath = trim($internalPath, '/');
-		try {
-			$query = $this->connection->getQueryBuilder();
-			$query->insert('filecache')
-				->values([
-					'storage' => $query->createNamedParameter($storageId),
-					'path' => $query->createNamedParameter($internalPath),
-					'path_hash' => $query->createNamedParameter(md5($internalPath)),
-					'parent' => $query->createNamedParameter(-1, IQueryBuilder::PARAM_INT),
-					'name' => $query->createNamedParameter(basename($internalPath)),
-					'mimetype' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'mimepart' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'size' => $query->createNamedParameter($size),
-					'storage_mtime' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'encrypted' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'unencrypted_size' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'etag' => $query->createNamedParameter(''),
-					'permissions' => $query->createNamedParameter(31, IQueryBuilder::PARAM_INT),
-				]);
-			$query->executeStatement();
-			$id = $query->getLastInsertId();
-			$this->fileIds[] = $id;
-		} catch (DbalException $e) {
-			if ($e->getReason() === DbalException::REASON_UNIQUE_CONSTRAINT_VIOLATION) {
-				$query = $this->connection->getQueryBuilder();
-				$query->select('fileid')
-					->from('filecache')
-					->where($query->expr()->eq('storage', $query->createNamedParameter($storageId)))
-					->andWhere($query->expr()->eq('path_hash', $query->createNamedParameter(md5($internalPath))));
-				$id = (int)$query->execute()->fetchColumn();
-			} else {
-				throw $e;
-			}
-		}
-		return $id;
-	}
+        $this->clearCache();
+
+        $cachedMounts = $this->cache->getMountsForRootId($id2);
+        $this->sortMounts($cachedMounts);
+
+        $this->assertCount(2, $cachedMounts);
+
+        $this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+
+        $this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
+        $this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[1]->getRootId());
+        $this->assertEquals(2, $cachedMounts[1]->getStorageId());
+    }
+
+    private function sortMounts(&$mounts) {
+        usort($mounts, function (ICachedMountInfo $a, ICachedMountInfo $b) {
+            return strcmp($a->getUser()->getUID(), $b->getUser()->getUID());
+        });
+    }
+
+    private function createCacheEntry($internalPath, $storageId, $size = 0) {
+        $internalPath = trim($internalPath, '/');
+        try {
+            $query = $this->connection->getQueryBuilder();
+            $query->insert('filecache')
+                ->values([
+                    'storage' => $query->createNamedParameter($storageId),
+                    'path' => $query->createNamedParameter($internalPath),
+                    'path_hash' => $query->createNamedParameter(md5($internalPath)),
+                    'parent' => $query->createNamedParameter(-1, IQueryBuilder::PARAM_INT),
+                    'name' => $query->createNamedParameter(basename($internalPath)),
+                    'mimetype' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'mimepart' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'size' => $query->createNamedParameter($size),
+                    'storage_mtime' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'encrypted' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'unencrypted_size' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'etag' => $query->createNamedParameter(''),
+                    'permissions' => $query->createNamedParameter(31, IQueryBuilder::PARAM_INT),
+                ]);
+            $query->executeStatement();
+            $id = $query->getLastInsertId();
+            $this->fileIds[] = $id;
+        } catch (DbalException $e) {
+            if ($e->getReason() === DbalException::REASON_UNIQUE_CONSTRAINT_VIOLATION) {
+                $query = $this->connection->getQueryBuilder();
+                $query->select('fileid')
+                    ->from('filecache')
+                    ->where($query->expr()->eq('storage', $query->createNamedParameter($storageId)))
+                    ->andWhere($query->expr()->eq('path_hash', $query->createNamedParameter(md5($internalPath))));
+                $id = (int)$query->execute()->fetchColumn();
+            } else {
+                throw $e;
+            }
+        }
+        return $id;
+    }
 
-	public function testGetMountsForFileIdRootId(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdRootId(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
+        [$storage1, $rootId] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($rootId);
+        $cachedMounts = $this->cache->getMountsForFileId($rootId);
 
-		$this->assertCount(1, $cachedMounts);
+        $this->assertCount(1, $cachedMounts);
 
-		$this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($rootId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-	}
+        $this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($rootId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+    }
 
-	public function testGetMountsForFileIdSubFolder(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdSubFolder(): void {
+        $user1 = $this->userManager->get('u1');
 
-		$fileId = $this->createCacheEntry('/foo/bar', 2);
+        $fileId = $this->createCacheEntry('/foo/bar', 2);
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
+        [$storage1, $rootId] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
-
-		$this->assertCount(1, $cachedMounts);
-
-		$this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($rootId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-		$this->assertEquals('foo/bar', $cachedMounts[0]->getInternalPath());
-		$this->assertEquals('/foo/foo/bar', $cachedMounts[0]->getPath());
-	}
-
-	public function testGetMountsForFileIdSubFolderMount(): void {
-		$user1 = $this->userManager->get('u1');
-
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('/foo', 2);
-		$fileId = $this->createCacheEntry('/foo/bar', 2);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
+
+        $this->assertCount(1, $cachedMounts);
+
+        $this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($rootId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+        $this->assertEquals('foo/bar', $cachedMounts[0]->getInternalPath());
+        $this->assertEquals('/foo/foo/bar', $cachedMounts[0]->getPath());
+    }
+
+    public function testGetMountsForFileIdSubFolderMount(): void {
+        $user1 = $this->userManager->get('u1');
+
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('/foo', 2);
+        $fileId = $this->createCacheEntry('/foo/bar', 2);
 
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/'])
-			->onlyMethods(['getStorageRootId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/'])
+            ->onlyMethods(['getStorageRootId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($folderId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($folderId);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
 
-		$this->assertCount(1, $cachedMounts);
+        $this->assertCount(1, $cachedMounts);
 
-		$this->assertEquals('/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($folderId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-		$this->assertEquals('foo', $cachedMounts[0]->getRootInternalPath());
-		$this->assertEquals('bar', $cachedMounts[0]->getInternalPath());
-		$this->assertEquals('/bar', $cachedMounts[0]->getPath());
-	}
+        $this->assertEquals('/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($folderId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+        $this->assertEquals('foo', $cachedMounts[0]->getRootInternalPath());
+        $this->assertEquals('bar', $cachedMounts[0]->getInternalPath());
+        $this->assertEquals('/bar', $cachedMounts[0]->getPath());
+    }
 
-	public function testGetMountsForFileIdSubFolderMountOutside(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdSubFolderMountOutside(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('/foo', 2);
-		$fileId = $this->createCacheEntry('/bar/asd', 2);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('/foo', 2);
+        $fileId = $this->createCacheEntry('/bar/asd', 2);
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/foo/'])
-			->onlyMethods(['getStorageRootId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/foo/'])
+            ->onlyMethods(['getStorageRootId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($folderId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($folderId);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
 
-		$this->assertCount(0, $cachedMounts);
-	}
+        $this->assertCount(0, $cachedMounts);
+    }
 
 
-	public function testGetMountsForFileIdDeletedUser(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdDeletedUser(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$rootId = $this->createCacheEntry('', 2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$this->cache->registerMounts($user1, [$mount1]);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $rootId = $this->createCacheEntry('', 2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$user1->delete();
-		$this->clearCache();
+        $user1->delete();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($rootId);
-		$this->assertEmpty($cachedMounts);
-	}
+        $cachedMounts = $this->cache->getMountsForFileId($rootId);
+        $this->assertEmpty($cachedMounts);
+    }
 
-	public function testGetUsedSpaceForUsers(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
+    public function testGetUsedSpaceForUsers(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
 
-		/** @var Storage $storage1 */
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('files', 2, 100);
-		$fileId = $this->createCacheEntry('files/foo', 2, 7);
-		$storage1->getCache()->put($folderId, ['size' => 100]);
-		$storage1->getCache()->update($fileId, ['size' => 70]);
+        /** @var Storage $storage1 */
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('files', 2, 100);
+        $fileId = $this->createCacheEntry('files/foo', 2, 7);
+        $storage1->getCache()->put($folderId, ['size' => 100]);
+        $storage1->getCache()->update($fileId, ['size' => 70]);
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/u1/'])
-			->onlyMethods(['getStorageRootId', 'getNumericStorageId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/u1/'])
+            ->onlyMethods(['getStorageRootId', 'getNumericStorageId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($rootId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($rootId);
 
-		$mount1->expects($this->any())
-			->method('getNumericStorageId')
-			->willReturn(2);
+        $mount1->expects($this->any())
+            ->method('getNumericStorageId')
+            ->willReturn(2);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$result = $this->cache->getUsedSpaceForUsers([$user1, $user2]);
-		$this->assertEquals(['u1' => 100], $result);
-	}
+        $result = $this->cache->getUsedSpaceForUsers([$user1, $user2]);
+        $this->assertEquals(['u1' => 100], $result);
+    }
 
 
-	public function testMigrateMountProvider(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testMigrateMountProvider(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$rootId = $this->createCacheEntry('', 2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$this->cache->registerMounts($user1, [$mount1]);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $rootId = $this->createCacheEntry('', 2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
-		$this->assertCount(1, $cachedMounts);
-		$this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
+        $cachedMounts = $this->cache->getMountsForUser($user1);
+        $this->assertCount(1, $cachedMounts);
+        $this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
 
-		$mount1 = new MountPoint($storage1, '/foo/', null, null, null, null, 'dummy');
-		$this->cache->registerMounts($user1, [$mount1], ['dummy']);
+        $mount1 = new MountPoint($storage1, '/foo/', null, null, null, null, 'dummy');
+        $this->cache->registerMounts($user1, [$mount1], ['dummy']);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
-		$this->assertCount(1, $cachedMounts);
-		$this->assertEquals('dummy', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
-	}
+        $cachedMounts = $this->cache->getMountsForUser($user1);
+        $this->assertCount(1, $cachedMounts);
+        $this->assertEquals('dummy', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
+    }
 }