nextcloud / server

lib/public/Files/Config/IPartialMountProvider.php

Indentation +23 added lines, -23 removed lines

@@ -19,27 +19,27 @@
  */
 interface IPartialMountProvider extends IMountProvider {
 
-	/**
-	 * Called during the Filesystem setup of a specific path.
-	 *
-	 * The provided arguments give information about the path being set up,
-	 * as well as information about mount points known to be provided by the
-	 * mount provider and contained in the path or in its sub-paths.
-	 *
-	 * Implementations should verify the IMountProviderArgs and return the
-	 * corresponding IMountPoint instances.
-	 *
-	 * @param string $path path for which the mounts are set up
-	 * @param bool $forChildren when true, only child mounts for path should be returned
-	 * @param IMountProviderArgs[] $mountProviderArgs
-	 * @param IStorageFactory $loader
-	 * @return array<string, IMountPoint> IMountPoint instances, indexed by
-	 *                                    mount-point
-	 */
-	public function getMountsForPath(
-		string $path,
-		bool $forChildren,
-		array $mountProviderArgs,
-		IStorageFactory $loader,
-	): array;
+    /**
+     * Called during the Filesystem setup of a specific path.
+     *
+     * The provided arguments give information about the path being set up,
+     * as well as information about mount points known to be provided by the
+     * mount provider and contained in the path or in its sub-paths.
+     *
+     * Implementations should verify the IMountProviderArgs and return the
+     * corresponding IMountPoint instances.
+     *
+     * @param string $path path for which the mounts are set up
+     * @param bool $forChildren when true, only child mounts for path should be returned
+     * @param IMountProviderArgs[] $mountProviderArgs
+     * @param IStorageFactory $loader
+     * @return array<string, IMountPoint> IMountPoint instances, indexed by
+     *                                    mount-point
+     */
+    public function getMountsForPath(
+        string $path,
+        bool $forChildren,
+        array $mountProviderArgs,
+        IStorageFactory $loader,
+    ): array;
 }

lib/private/Files/Config/MountProviderCollection.php

Indentation +263 added lines, -263 removed lines

@@ -26,267 +26,267 @@
 use function in_array;
 
 class MountProviderCollection implements IMountProviderCollection, Emitter {
-	use EmitterTrait;
-
-	/**
-	 * @var list<IHomeMountProvider>
-	 */
-	private array $homeProviders = [];
-
-	/**
-	 * @var array<class-string<IMountProvider>, IMountProvider>
-	 */
-	private array $providers = [];
-
-	/** @var list<IRootMountProvider> */
-	private array $rootProviders = [];
-
-	/** @var list<callable> */
-	private array $mountFilters = [];
-
-	public function __construct(
-		private IStorageFactory $loader,
-		private IUserMountCache $mountCache,
-		private IEventLogger $eventLogger,
-	) {
-	}
-
-	/**
-	 * @return list<IMountPoint>
-	 */
-	private function getMountsFromProvider(IMountProvider $provider, IUser $user, IStorageFactory $loader): array {
-		$class = str_replace('\\', '_', get_class($provider));
-		$uid = $user->getUID();
-		$this->eventLogger->start('fs:setup:provider:' . $class, "Getting mounts from $class for $uid");
-		$mounts = $provider->getMountsForUser($user, $loader) ?? [];
-		$this->eventLogger->end('fs:setup:provider:' . $class);
-		return array_values($mounts);
-	}
-
-	/**
-	 * @param list<IMountProvider> $providers
-	 * @return list<IMountPoint>
-	 */
-	private function getUserMountsForProviders(IUser $user, array $providers): array {
-		$loader = $this->loader;
-		$mounts = array_map(function (IMountProvider $provider) use ($user, $loader) {
-			return $this->getMountsFromProvider($provider, $user, $loader);
-		}, $providers);
-		$mounts = array_merge(...$mounts);
-		return $this->filterMounts($user, $mounts);
-	}
-
-	/**
-	 * @return list<IMountPoint>
-	 */
-	public function getMountsForUser(IUser $user): array {
-		return $this->getUserMountsForProviders($user, array_values($this->providers));
-	}
-
-	/**
-	 * @param IMountProviderArgs[] $mountProviderArgs
-	 * @return array<string, IMountPoint> IMountPoint array indexed by mount
-	 *                                    point.
-	 */
-	public function getUserMountsFromProviderByPath(
-		string $providerClass,
-		string $path,
-		bool $forChildren,
-		array $mountProviderArgs,
-	): array {
-		$provider = $this->providers[$providerClass] ?? null;
-		if ($provider === null) {
-			return [];
-		}
-
-		if (!is_a($providerClass, IPartialMountProvider::class, true)) {
-			throw new \LogicException(
-				'Mount provider does not support partial mounts'
-			);
-		}
-
-		/** @var IPartialMountProvider $provider */
-		return $provider->getMountsForPath(
-			$path,
-			$forChildren,
-			$mountProviderArgs,
-			$this->loader,
-		);
-	}
-
-	/**
-	 * Returns the mounts for the user from the specified provider classes.
-	 * Providers not registered in the MountProviderCollection will be skipped.
-	 *
-	 * @inheritdoc
-	 *
-	 * @return list<IMountPoint>
-	 */
-	public function getUserMountsForProviderClasses(IUser $user, array $mountProviderClasses): array {
-		$providers = array_filter(
-			$this->providers,
-			fn (string $providerClass) => in_array($providerClass, $mountProviderClasses),
-			ARRAY_FILTER_USE_KEY
-		);
-		return $this->getUserMountsForProviders($user, array_values($providers));
-	}
-
-	/**
-	 * @return list<IMountPoint>
-	 */
-	public function addMountForUser(IUser $user, IMountManager $mountManager, ?callable $providerFilter = null): array {
-		// shared mount provider gets to go last since it needs to know existing files
-		// to check for name collisions
-		$firstMounts = [];
-		if ($providerFilter) {
-			$providers = array_filter($this->providers, $providerFilter, ARRAY_FILTER_USE_KEY);
-		} else {
-			$providers = $this->providers;
-		}
-		$firstProviders
-			= array_filter(
-				$providers,
-				fn (string $providerClass) => ($providerClass !== MountProvider::class),
-				ARRAY_FILTER_USE_KEY
-			);
-		$lastProviders = array_filter(
-			$providers,
-			fn (string $providerClass) => $providerClass === MountProvider::class,
-			ARRAY_FILTER_USE_KEY
-		);
-		foreach ($firstProviders as $provider) {
-			$mounts = $this->getMountsFromProvider($provider, $user, $this->loader);
-			$firstMounts = array_merge($firstMounts, $mounts);
-		}
-		$firstMounts = $this->filterMounts($user, $firstMounts);
-		array_walk($firstMounts, [$mountManager, 'addMount']);
-
-		$lateMounts = [];
-		foreach ($lastProviders as $provider) {
-			$mounts = $this->getMountsFromProvider($provider, $user, $this->loader);
-			$lateMounts = array_merge($lateMounts, $mounts);
-		}
-
-		$lateMounts = $this->filterMounts($user, $lateMounts);
-		$this->eventLogger->start('fs:setup:add-mounts', 'Add mounts to the filesystem');
-		array_walk($lateMounts, [$mountManager, 'addMount']);
-		$this->eventLogger->end('fs:setup:add-mounts');
-
-		return array_values(array_merge($lateMounts, $firstMounts));
-	}
-
-	/**
-	 * Get the configured home mount for this user
-	 *
-	 * @since 9.1.0
-	 */
-	public function getHomeMountForUser(IUser $user): IMountPoint {
-		$providers = array_reverse($this->homeProviders); // call the latest registered provider first to give apps an opportunity to overwrite builtin
-		foreach ($providers as $homeProvider) {
-			if ($mount = $homeProvider->getHomeMountForUser($user, $this->loader)) {
-				$mount->setMountPoint('/' . $user->getUID()); //make sure the mountpoint is what we expect
-				return $mount;
-			}
-		}
-		throw new \Exception('No home storage configured for user ' . $user);
-	}
-
-	/**
-	 * Add a provider for mount points
-	 */
-	public function registerProvider(IMountProvider $provider): void {
-		$this->providers[get_class($provider)] = $provider;
-
-		$this->emit('\OC\Files\Config', 'registerMountProvider', [$provider]);
-	}
-
-	public function registerMountFilter(callable $filter): void {
-		$this->mountFilters[] = $filter;
-	}
-
-	/**
-	 * @param list<IMountPoint> $mountPoints
-	 * @return list<IMountPoint>
-	 */
-	private function filterMounts(IUser $user, array $mountPoints): array {
-		return array_values(array_filter($mountPoints, function (IMountPoint $mountPoint) use ($user) {
-			foreach ($this->mountFilters as $filter) {
-				if ($filter($mountPoint, $user) === false) {
-					return false;
-				}
-			}
-			return true;
-		}));
-	}
-
-	/**
-	 * Add a provider for home mount points
-	 *
-	 * @param IHomeMountProvider $provider
-	 * @since 9.1.0
-	 */
-	public function registerHomeProvider(IHomeMountProvider $provider) {
-		$this->homeProviders[] = $provider;
-		$this->emit('\OC\Files\Config', 'registerHomeMountProvider', [$provider]);
-	}
-
-	/**
-	 * Get the mount cache which can be used to search for mounts without setting up the filesystem
-	 */
-	public function getMountCache(): IUserMountCache {
-		return $this->mountCache;
-	}
-
-	public function registerRootProvider(IRootMountProvider $provider): void {
-		$this->rootProviders[] = $provider;
-	}
-
-	/**
-	 * Get all root mountpoints
-	 *
-	 * @return list<IMountPoint>
-	 * @since 20.0.0
-	 */
-	public function getRootMounts(): array {
-		$loader = $this->loader;
-		$mounts = array_map(function (IRootMountProvider $provider) use ($loader) {
-			return $provider->getRootMounts($loader);
-		}, $this->rootProviders);
-		$mounts = array_reduce($mounts, function (array $mounts, array $providerMounts) {
-			return array_merge($mounts, $providerMounts);
-		}, []);
-
-		if (count($mounts) === 0) {
-			throw new \Exception('No root mounts provided by any provider');
-		}
-
-		return array_values($mounts);
-	}
-
-	public function clearProviders(): void {
-		$this->providers = [];
-		$this->homeProviders = [];
-		$this->rootProviders = [];
-	}
-
-	/**
-	 * @return list<IMountProvider>
-	 */
-	public function getProviders(): array {
-		return array_values($this->providers);
-	}
-
-	/**
-	 * @return list<IHomeMountProvider>
-	 */
-	public function getHomeProviders(): array {
-		return $this->homeProviders;
-	}
-
-	/**
-	 * @return list<IRootMountProvider>
-	 */
-	public function getRootProviders(): array {
-		return $this->rootProviders;
-	}
+    use EmitterTrait;
+
+    /**
+     * @var list<IHomeMountProvider>
+     */
+    private array $homeProviders = [];
+
+    /**
+     * @var array<class-string<IMountProvider>, IMountProvider>
+     */
+    private array $providers = [];
+
+    /** @var list<IRootMountProvider> */
+    private array $rootProviders = [];
+
+    /** @var list<callable> */
+    private array $mountFilters = [];
+
+    public function __construct(
+        private IStorageFactory $loader,
+        private IUserMountCache $mountCache,
+        private IEventLogger $eventLogger,
+    ) {
+    }
+
+    /**
+     * @return list<IMountPoint>
+     */
+    private function getMountsFromProvider(IMountProvider $provider, IUser $user, IStorageFactory $loader): array {
+        $class = str_replace('\\', '_', get_class($provider));
+        $uid = $user->getUID();
+        $this->eventLogger->start('fs:setup:provider:' . $class, "Getting mounts from $class for $uid");
+        $mounts = $provider->getMountsForUser($user, $loader) ?? [];
+        $this->eventLogger->end('fs:setup:provider:' . $class);
+        return array_values($mounts);
+    }
+
+    /**
+     * @param list<IMountProvider> $providers
+     * @return list<IMountPoint>
+     */
+    private function getUserMountsForProviders(IUser $user, array $providers): array {
+        $loader = $this->loader;
+        $mounts = array_map(function (IMountProvider $provider) use ($user, $loader) {
+            return $this->getMountsFromProvider($provider, $user, $loader);
+        }, $providers);
+        $mounts = array_merge(...$mounts);
+        return $this->filterMounts($user, $mounts);
+    }
+
+    /**
+     * @return list<IMountPoint>
+     */
+    public function getMountsForUser(IUser $user): array {
+        return $this->getUserMountsForProviders($user, array_values($this->providers));
+    }
+
+    /**
+     * @param IMountProviderArgs[] $mountProviderArgs
+     * @return array<string, IMountPoint> IMountPoint array indexed by mount
+     *                                    point.
+     */
+    public function getUserMountsFromProviderByPath(
+        string $providerClass,
+        string $path,
+        bool $forChildren,
+        array $mountProviderArgs,
+    ): array {
+        $provider = $this->providers[$providerClass] ?? null;
+        if ($provider === null) {
+            return [];
+        }
+
+        if (!is_a($providerClass, IPartialMountProvider::class, true)) {
+            throw new \LogicException(
+                'Mount provider does not support partial mounts'
+            );
+        }
+
+        /** @var IPartialMountProvider $provider */
+        return $provider->getMountsForPath(
+            $path,
+            $forChildren,
+            $mountProviderArgs,
+            $this->loader,
+        );
+    }
+
+    /**
+     * Returns the mounts for the user from the specified provider classes.
+     * Providers not registered in the MountProviderCollection will be skipped.
+     *
+     * @inheritdoc
+     *
+     * @return list<IMountPoint>
+     */
+    public function getUserMountsForProviderClasses(IUser $user, array $mountProviderClasses): array {
+        $providers = array_filter(
+            $this->providers,
+            fn (string $providerClass) => in_array($providerClass, $mountProviderClasses),
+            ARRAY_FILTER_USE_KEY
+        );
+        return $this->getUserMountsForProviders($user, array_values($providers));
+    }
+
+    /**
+     * @return list<IMountPoint>
+     */
+    public function addMountForUser(IUser $user, IMountManager $mountManager, ?callable $providerFilter = null): array {
+        // shared mount provider gets to go last since it needs to know existing files
+        // to check for name collisions
+        $firstMounts = [];
+        if ($providerFilter) {
+            $providers = array_filter($this->providers, $providerFilter, ARRAY_FILTER_USE_KEY);
+        } else {
+            $providers = $this->providers;
+        }
+        $firstProviders
+            = array_filter(
+                $providers,
+                fn (string $providerClass) => ($providerClass !== MountProvider::class),
+                ARRAY_FILTER_USE_KEY
+            );
+        $lastProviders = array_filter(
+            $providers,
+            fn (string $providerClass) => $providerClass === MountProvider::class,
+            ARRAY_FILTER_USE_KEY
+        );
+        foreach ($firstProviders as $provider) {
+            $mounts = $this->getMountsFromProvider($provider, $user, $this->loader);
+            $firstMounts = array_merge($firstMounts, $mounts);
+        }
+        $firstMounts = $this->filterMounts($user, $firstMounts);
+        array_walk($firstMounts, [$mountManager, 'addMount']);
+
+        $lateMounts = [];
+        foreach ($lastProviders as $provider) {
+            $mounts = $this->getMountsFromProvider($provider, $user, $this->loader);
+            $lateMounts = array_merge($lateMounts, $mounts);
+        }
+
+        $lateMounts = $this->filterMounts($user, $lateMounts);
+        $this->eventLogger->start('fs:setup:add-mounts', 'Add mounts to the filesystem');
+        array_walk($lateMounts, [$mountManager, 'addMount']);
+        $this->eventLogger->end('fs:setup:add-mounts');
+
+        return array_values(array_merge($lateMounts, $firstMounts));
+    }
+
+    /**
+     * Get the configured home mount for this user
+     *
+     * @since 9.1.0
+     */
+    public function getHomeMountForUser(IUser $user): IMountPoint {
+        $providers = array_reverse($this->homeProviders); // call the latest registered provider first to give apps an opportunity to overwrite builtin
+        foreach ($providers as $homeProvider) {
+            if ($mount = $homeProvider->getHomeMountForUser($user, $this->loader)) {
+                $mount->setMountPoint('/' . $user->getUID()); //make sure the mountpoint is what we expect
+                return $mount;
+            }
+        }
+        throw new \Exception('No home storage configured for user ' . $user);
+    }
+
+    /**
+     * Add a provider for mount points
+     */
+    public function registerProvider(IMountProvider $provider): void {
+        $this->providers[get_class($provider)] = $provider;
+
+        $this->emit('\OC\Files\Config', 'registerMountProvider', [$provider]);
+    }
+
+    public function registerMountFilter(callable $filter): void {
+        $this->mountFilters[] = $filter;
+    }
+
+    /**
+     * @param list<IMountPoint> $mountPoints
+     * @return list<IMountPoint>
+     */
+    private function filterMounts(IUser $user, array $mountPoints): array {
+        return array_values(array_filter($mountPoints, function (IMountPoint $mountPoint) use ($user) {
+            foreach ($this->mountFilters as $filter) {
+                if ($filter($mountPoint, $user) === false) {
+                    return false;
+                }
+            }
+            return true;
+        }));
+    }
+
+    /**
+     * Add a provider for home mount points
+     *
+     * @param IHomeMountProvider $provider
+     * @since 9.1.0
+     */
+    public function registerHomeProvider(IHomeMountProvider $provider) {
+        $this->homeProviders[] = $provider;
+        $this->emit('\OC\Files\Config', 'registerHomeMountProvider', [$provider]);
+    }
+
+    /**
+     * Get the mount cache which can be used to search for mounts without setting up the filesystem
+     */
+    public function getMountCache(): IUserMountCache {
+        return $this->mountCache;
+    }
+
+    public function registerRootProvider(IRootMountProvider $provider): void {
+        $this->rootProviders[] = $provider;
+    }
+
+    /**
+     * Get all root mountpoints
+     *
+     * @return list<IMountPoint>
+     * @since 20.0.0
+     */
+    public function getRootMounts(): array {
+        $loader = $this->loader;
+        $mounts = array_map(function (IRootMountProvider $provider) use ($loader) {
+            return $provider->getRootMounts($loader);
+        }, $this->rootProviders);
+        $mounts = array_reduce($mounts, function (array $mounts, array $providerMounts) {
+            return array_merge($mounts, $providerMounts);
+        }, []);
+
+        if (count($mounts) === 0) {
+            throw new \Exception('No root mounts provided by any provider');
+        }
+
+        return array_values($mounts);
+    }
+
+    public function clearProviders(): void {
+        $this->providers = [];
+        $this->homeProviders = [];
+        $this->rootProviders = [];
+    }
+
+    /**
+     * @return list<IMountProvider>
+     */
+    public function getProviders(): array {
+        return array_values($this->providers);
+    }
+
+    /**
+     * @return list<IHomeMountProvider>
+     */
+    public function getHomeProviders(): array {
+        return $this->homeProviders;
+    }
+
+    /**
+     * @return list<IRootMountProvider>
+     */
+    public function getRootProviders(): array {
+        return $this->rootProviders;
+    }
 }

lib/private/Files/SetupManager.php

Indentation +677 added lines, -677 removed lines

@@ -62,683 +62,683 @@
 use function in_array;
 
 class SetupManager {
-	private bool $rootSetup = false;
-	// List of users for which at least one mount is setup
-	private array $setupUsers = [];
-	// List of users for which all mounts are setup
-	private array $setupUsersComplete = [];
-	/**
-	 * An array of provider classes that have been set up, indexed by UserUID.
-	 *
-	 * @var array<string, class-string<IMountProvider>[]>
-	 */
-	private array $setupUserMountProviders = [];
-	/**
-	 * An array of paths that have already been set up
-	 *
-	 * @var array<string, int>
-	 */
-	private array $setupMountProviderPaths = [];
-	private ICache $cache;
-	private bool $listeningForProviders;
-	private array $fullSetupRequired = [];
-	private bool $setupBuiltinWrappersDone = false;
-	private bool $forceFullSetup = false;
-	private const SETUP_WITH_CHILDREN = 1;
-	private const SETUP_WITHOUT_CHILDREN = 0;
-
-	public function __construct(
-		private IEventLogger $eventLogger,
-		private MountProviderCollection $mountProviderCollection,
-		private IMountManager $mountManager,
-		private IUserManager $userManager,
-		private IEventDispatcher $eventDispatcher,
-		private IUserMountCache $userMountCache,
-		private ILockdownManager $lockdownManager,
-		private IUserSession $userSession,
-		ICacheFactory $cacheFactory,
-		private LoggerInterface $logger,
-		private IConfig $config,
-		private ShareDisableChecker $shareDisableChecker,
-		private IAppManager $appManager,
-		private FileAccess $fileAccess,
-	) {
-		$this->cache = $cacheFactory->createDistributed('setupmanager::');
-		$this->listeningForProviders = false;
-		$this->forceFullSetup = $this->config->getSystemValueBool('debug.force-full-fs-setup');
-
-		$this->setupListeners();
-	}
-
-	private function isSetupStarted(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsers, true);
-	}
-
-	public function isSetupComplete(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsersComplete, true);
-	}
-
-	/**
-	 * Checks if a path has been cached either directly or through a full setup
-	 * of one of its parents.
-	 */
-	private function isPathSetup(string $path): bool {
-		// if the exact path was already setup with or without children
-		if (array_key_exists($path, $this->setupMountProviderPaths)) {
-			return true;
-		}
-
-		// or if any of the ancestors was fully setup
-		while (($path = dirname($path)) !== '/') {
-			$setupPath = $this->setupMountProviderPaths[$path . '/'] ?? null;
-			if ($setupPath === self::SETUP_WITH_CHILDREN) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private function setupBuiltinWrappers() {
-		if ($this->setupBuiltinWrappersDone) {
-			return;
-		}
-		$this->setupBuiltinWrappersDone = true;
-
-		// load all filesystem apps before, so no setup-hook gets lost
-		$this->appManager->loadApps(['filesystem']);
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($storage->instanceOfStorage(Common::class)) {
-				$options = array_merge($mount->getOptions(), ['mount_point' => $mountPoint]);
-				$storage->setMountOptions($options);
-			}
-			return $storage;
-		});
-
-		$reSharingEnabled = Share::isResharingAllowed();
-		$user = $this->userSession->getUser();
-		$sharingEnabledForUser = $user ? !$this->shareDisableChecker->sharingDisabledForUser($user->getUID()) : true;
-		Filesystem::addStorageWrapper(
-			'sharing_mask',
-			function ($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
-				$sharingEnabledForMount = $mount->getOption('enable_sharing', true);
-				$isShared = $mount instanceof ISharedMountPoint;
-				if (!$sharingEnabledForMount || !$sharingEnabledForUser || (!$reSharingEnabled && $isShared)) {
-					return new PermissionsMask([
-						'storage' => $storage,
-						'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
-					]);
-				}
-				return $storage;
-			}
-		);
-
-		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			$externalMount = $mount instanceof ExternalMountPoint || $mount instanceof Mount;
-			if ($externalMount && !$storage->isLocal()) {
-				return new Availability(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($mount->getOption('encoding_compatibility', false) && !$mount instanceof SharedMount) {
-				return new Encoding(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		$quotaIncludeExternal = $this->config->getSystemValue('quota_include_external_storage', false);
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
-			// set up quota for home storages, even for other users
-			// which can happen when using sharing
-			if ($mount instanceof HomeMountPoint) {
-				$user = $mount->getUser();
-				return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
-					return $user->getQuotaBytes();
-				}, 'root' => 'files', 'include_external_storage' => $quotaIncludeExternal]);
-			}
-
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			/*
+    private bool $rootSetup = false;
+    // List of users for which at least one mount is setup
+    private array $setupUsers = [];
+    // List of users for which all mounts are setup
+    private array $setupUsersComplete = [];
+    /**
+     * An array of provider classes that have been set up, indexed by UserUID.
+     *
+     * @var array<string, class-string<IMountProvider>[]>
+     */
+    private array $setupUserMountProviders = [];
+    /**
+     * An array of paths that have already been set up
+     *
+     * @var array<string, int>
+     */
+    private array $setupMountProviderPaths = [];
+    private ICache $cache;
+    private bool $listeningForProviders;
+    private array $fullSetupRequired = [];
+    private bool $setupBuiltinWrappersDone = false;
+    private bool $forceFullSetup = false;
+    private const SETUP_WITH_CHILDREN = 1;
+    private const SETUP_WITHOUT_CHILDREN = 0;
+
+    public function __construct(
+        private IEventLogger $eventLogger,
+        private MountProviderCollection $mountProviderCollection,
+        private IMountManager $mountManager,
+        private IUserManager $userManager,
+        private IEventDispatcher $eventDispatcher,
+        private IUserMountCache $userMountCache,
+        private ILockdownManager $lockdownManager,
+        private IUserSession $userSession,
+        ICacheFactory $cacheFactory,
+        private LoggerInterface $logger,
+        private IConfig $config,
+        private ShareDisableChecker $shareDisableChecker,
+        private IAppManager $appManager,
+        private FileAccess $fileAccess,
+    ) {
+        $this->cache = $cacheFactory->createDistributed('setupmanager::');
+        $this->listeningForProviders = false;
+        $this->forceFullSetup = $this->config->getSystemValueBool('debug.force-full-fs-setup');
+
+        $this->setupListeners();
+    }
+
+    private function isSetupStarted(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsers, true);
+    }
+
+    public function isSetupComplete(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsersComplete, true);
+    }
+
+    /**
+     * Checks if a path has been cached either directly or through a full setup
+     * of one of its parents.
+     */
+    private function isPathSetup(string $path): bool {
+        // if the exact path was already setup with or without children
+        if (array_key_exists($path, $this->setupMountProviderPaths)) {
+            return true;
+        }
+
+        // or if any of the ancestors was fully setup
+        while (($path = dirname($path)) !== '/') {
+            $setupPath = $this->setupMountProviderPaths[$path . '/'] ?? null;
+            if ($setupPath === self::SETUP_WITH_CHILDREN) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function setupBuiltinWrappers() {
+        if ($this->setupBuiltinWrappersDone) {
+            return;
+        }
+        $this->setupBuiltinWrappersDone = true;
+
+        // load all filesystem apps before, so no setup-hook gets lost
+        $this->appManager->loadApps(['filesystem']);
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($storage->instanceOfStorage(Common::class)) {
+                $options = array_merge($mount->getOptions(), ['mount_point' => $mountPoint]);
+                $storage->setMountOptions($options);
+            }
+            return $storage;
+        });
+
+        $reSharingEnabled = Share::isResharingAllowed();
+        $user = $this->userSession->getUser();
+        $sharingEnabledForUser = $user ? !$this->shareDisableChecker->sharingDisabledForUser($user->getUID()) : true;
+        Filesystem::addStorageWrapper(
+            'sharing_mask',
+            function ($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
+                $sharingEnabledForMount = $mount->getOption('enable_sharing', true);
+                $isShared = $mount instanceof ISharedMountPoint;
+                if (!$sharingEnabledForMount || !$sharingEnabledForUser || (!$reSharingEnabled && $isShared)) {
+                    return new PermissionsMask([
+                        'storage' => $storage,
+                        'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
+                    ]);
+                }
+                return $storage;
+            }
+        );
+
+        // install storage availability wrapper, before most other wrappers
+        Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            $externalMount = $mount instanceof ExternalMountPoint || $mount instanceof Mount;
+            if ($externalMount && !$storage->isLocal()) {
+                return new Availability(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($mount->getOption('encoding_compatibility', false) && !$mount instanceof SharedMount) {
+                return new Encoding(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        $quotaIncludeExternal = $this->config->getSystemValue('quota_include_external_storage', false);
+        Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
+            // set up quota for home storages, even for other users
+            // which can happen when using sharing
+            if ($mount instanceof HomeMountPoint) {
+                $user = $mount->getUser();
+                return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
+                    return $user->getQuotaBytes();
+                }, 'root' => 'files', 'include_external_storage' => $quotaIncludeExternal]);
+            }
+
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            /*
 			 * Do not allow any operations that modify the storage
 			 */
-			if ($mount->getOption('readonly', false)) {
-				return new PermissionsMask([
-					'storage' => $storage,
-					'mask' => Constants::PERMISSION_ALL & ~(
-						Constants::PERMISSION_UPDATE
-						| Constants::PERMISSION_CREATE
-						| Constants::PERMISSION_DELETE
-					),
-				]);
-			}
-			return $storage;
-		});
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-	}
-
-	/**
-	 * Setup the full filesystem for the specified user
-	 */
-	public function setupForUser(IUser $user): void {
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-		$this->setupUsersComplete[] = $user->getUID();
-
-		$this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
-
-		$this->setupUserMountProviders[$user->getUID()] ??= [];
-		$previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
-
-		$this->setupForUserWith($user, function () use ($user) {
-			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
-				string $providerClass,
-			) use ($user) {
-				return !in_array($providerClass, $this->setupUserMountProviders[$user->getUID()]);
-			});
-		});
-		$this->afterUserFullySetup($user, $previouslySetupProviders);
-		$this->eventLogger->end('fs:setup:user:full');
-	}
-
-	/**
-	 * Part of the user setup that is run only once per user.
-	 */
-	private function oneTimeUserSetup(IUser $user) {
-		if ($this->isSetupStarted($user)) {
-			return;
-		}
-		$this->setupUsers[] = $user->getUID();
-
-		$this->setupRoot();
-
-		$this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
-
-		$this->setupBuiltinWrappers();
-
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		// TODO remove hook
-		OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
-
-		$event = new BeforeFileSystemSetupEvent($user);
-		$this->eventDispatcher->dispatchTyped($event);
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-
-		$userDir = '/' . $user->getUID() . '/files';
-
-		Filesystem::initInternal($userDir);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
-			// home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
-			$homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
-			$this->mountManager->addMount($homeMount);
-
-			if ($homeMount->getStorageRootId() === -1) {
-				$this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
-				$homeMount->getStorage()->mkdir('');
-				$homeMount->getStorage()->getScanner()->scan('');
-				$this->eventLogger->end('fs:setup:user:home:scan');
-			}
-			$this->eventLogger->end('fs:setup:user:home');
-		} else {
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID()
-			));
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
-			));
-			$this->setupUsersComplete[] = $user->getUID();
-		}
-
-		$this->listenForNewMountProviders();
-
-		$this->eventLogger->end('fs:setup:user:onetime');
-	}
-
-	/**
-	 * Final housekeeping after a user has been fully setup
-	 */
-	private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
-		$this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
-		$userRoot = '/' . $user->getUID() . '/';
-		$mounts = $this->mountManager->getAll();
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
-			return str_starts_with($mount->getMountPoint(), $userRoot);
-		});
-		$allProviders = array_map(function (IMountProvider|IHomeMountProvider|IRootMountProvider $provider) {
-			return get_class($provider);
-		}, array_merge(
-			$this->mountProviderCollection->getProviders(),
-			$this->mountProviderCollection->getHomeProviders(),
-			$this->mountProviderCollection->getRootProviders(),
-		));
-		$newProviders = array_diff($allProviders, $previouslySetupProviders);
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
-			return !in_array($mount->getMountProvider(), $previouslySetupProviders);
-		});
-		$this->registerMounts($user, $mounts, $newProviders);
-
-		$cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
-		if ($cacheDuration > 0) {
-			$this->cache->set($user->getUID(), true, $cacheDuration);
-			$this->fullSetupRequired[$user->getUID()] = false;
-		}
-		$this->eventLogger->end('fs:setup:user:full:post');
-	}
-
-	/**
-	 * Executes the one-time user setup and, if the user can access the
-	 * filesystem, executes $mountCallback.
-	 *
-	 * @param IUser $user
-	 * @param IMountPoint $mounts
-	 * @return void
-	 * @throws \OCP\HintException
-	 * @throws \OC\ServerNotAvailableException
-	 * @see self::oneTimeUserSetup()
-	 *
-	 */
-	private function setupForUserWith(IUser $user, callable $mountCallback): void {
-		$this->oneTimeUserSetup($user);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$mountCallback();
-		}
-		$this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
-		$this->eventLogger->end('fs:setup:user:post-init-mountpoint');
-
-		$userDir = '/' . $user->getUID() . '/files';
-		$this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
-		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
-		$this->eventLogger->end('fs:setup:user:setup-hook');
-	}
-
-	/**
-	 * Set up the root filesystem
-	 */
-	public function setupRoot(): void {
-		//setting up the filesystem twice can only lead to trouble
-		if ($this->rootSetup) {
-			return;
-		}
-
-		$this->setupBuiltinWrappers();
-
-		$this->rootSetup = true;
-
-		$this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
-
-		$rootMounts = $this->mountProviderCollection->getRootMounts();
-		foreach ($rootMounts as $rootMountProvider) {
-			$this->mountManager->addMount($rootMountProvider);
-		}
-
-		$this->eventLogger->end('fs:setup:root');
-	}
-
-	/**
-	 * Get the user to setup for a path or `null` if the root needs to be setup
-	 *
-	 * @param string $path
-	 * @return IUser|null
-	 */
-	private function getUserForPath(string $path) {
-		if (str_starts_with($path, '/__groupfolders')) {
-			return null;
-		} elseif (substr_count($path, '/') < 2) {
-			if ($user = $this->userSession->getUser()) {
-				return $user;
-			} else {
-				return null;
-			}
-		} elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
-			return null;
-		} else {
-			[, $userId] = explode('/', $path);
-		}
-
-		return $this->userManager->get($userId);
-	}
-
-	/**
-	 * Set up the filesystem for the specified path, optionally including all
-	 * children mounts.
-	 */
-	public function setupForPath(string $path, bool $includeChildren = false): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		// for the user's home folder, and includes children we need everything always
-		if (rtrim($path) === '/' . $user->getUID() . '/files' && $includeChildren) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		if (!isset($this->setupUserMountProviders[$user->getUID()])) {
-			$this->setupUserMountProviders[$user->getUID()] = [];
-		}
-		$setupProviders = &$this->setupUserMountProviders[$user->getUID()];
-		$currentProviders = [];
-
-		try {
-			$cachedMount = $this->userMountCache->getMountForPath($user, $path);
-		} catch (NotFoundException $e) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->oneTimeUserSetup($user);
-
-		$this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
-		$this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
-
-		$fullProviderMounts = [];
-		$authoritativeMounts = [];
-
-		$mountProvider = $cachedMount->getMountProvider();
-		$mountPoint = $cachedMount->getMountPoint();
-		$isMountProviderSetup = in_array($mountProvider, $setupProviders);
-		$isPathSetupAsAuthoritative
-			= $this->isPathSetup($mountPoint);
-		if (!$isMountProviderSetup && !$isPathSetupAsAuthoritative) {
-			if ($mountProvider === '') {
-				$this->logger->debug('mount at ' . $cachedMount->getMountPoint() . ' has no provider set, performing full setup');
-				$this->eventLogger->end('fs:setup:user:path:find');
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			}
-
-			if (is_a($mountProvider, IPartialMountProvider::class, true)) {
-				$rootId = $cachedMount->getRootId();
-				$rootMetadata = $this->fileAccess->getByFileId($rootId);
-				$providerArgs = new IMountProviderArgs($cachedMount, $rootMetadata);
-				// mark the path as cached (without children for now...)
-				$this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITHOUT_CHILDREN;
-				$authoritativeMounts[] = array_values(
-					$this->mountProviderCollection->getUserMountsFromProviderByPath(
-						$mountProvider,
-						$path,
-						false,
-						[$providerArgs]
-					)
-				);
-			} else {
-				$currentProviders[] = $mountProvider;
-				$setupProviders[] = $mountProvider;
-				$fullProviderMounts[]
-					= $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$mountProvider]);
-			}
-		}
-
-		if ($includeChildren) {
-			$subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
-			$this->eventLogger->end('fs:setup:user:path:find');
-
-			$needsFullSetup
-				= array_any(
-					$subCachedMounts,
-					fn (ICachedMountInfo $info) => $info->getMountProvider() === ''
-				);
-
-			if ($needsFullSetup) {
-				$this->logger->debug('mount has no provider set, performing full setup');
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			}
-
-			/** @var array<class-string<IMountProvider>, ICachedMountInfo[]> $authoritativeCachedMounts */
-			$authoritativeCachedMounts = [];
-			foreach ($subCachedMounts as $cachedMount) {
-				/** @var class-string<IMountProvider> $mountProvider */
-				$mountProvider = $cachedMount->getMountProvider();
-
-				// skip setup for already set up providers
-				if (in_array($mountProvider, $setupProviders)) {
-					continue;
-				}
-
-				if (is_a($mountProvider, IPartialMountProvider::class, true)) {
-					// skip setup if path was set up as authoritative before
-					if ($this->isPathSetup($cachedMount->getMountPoint())) {
-						continue;
-					}
-					// collect cached mount points for authoritative providers
-					$authoritativeCachedMounts[$mountProvider] ??= [];
-					$authoritativeCachedMounts[$mountProvider][] = $cachedMount;
-					continue;
-				}
-
-				$currentProviders[] = $mountProvider;
-				$setupProviders[] = $mountProvider;
-				$fullProviderMounts[]
-					= $this->mountProviderCollection->getUserMountsForProviderClasses(
-						$user,
-						[$mountProvider]
-					);
-			}
-
-			if (!empty($authoritativeCachedMounts)) {
-				$rootIds = array_map(
-					fn (ICachedMountInfo $mount) => $mount->getRootId(),
-					array_merge(...array_values($authoritativeCachedMounts)),
-				);
-
-				$rootsMetadata = [];
-				foreach (array_chunk($rootIds, 1000) as $chunk) {
-					foreach ($this->fileAccess->getByFileIds($chunk) as $id => $fileMetadata) {
-						$rootsMetadata[$id] = $fileMetadata;
-					}
-				}
-				$this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITH_CHILDREN;
-				foreach ($authoritativeCachedMounts as $providerClass => $cachedMounts) {
-					$providerArgs = array_filter(array_map(
-						static function (ICachedMountInfo $info) use ($rootsMetadata) {
-							$rootMetadata = $rootsMetadata[$info->getRootId()] ?? null;
-
-							return $rootMetadata
-								? new IMountProviderArgs($info, $rootMetadata)
-								: null;
-						},
-						$cachedMounts
-					));
-					$authoritativeMounts[]
-						= $this->mountProviderCollection->getUserMountsFromProviderByPath(
-							$providerClass,
-							$path,
-							true,
-							$providerArgs,
-						);
-				}
-			}
-		} else {
-			$this->eventLogger->end('fs:setup:user:path:find');
-		}
-
-		$fullProviderMounts = array_merge(...$fullProviderMounts);
-		$authoritativeMounts = array_merge(...$authoritativeMounts);
-
-		if (count($fullProviderMounts) || count($authoritativeMounts)) {
-			if (count($fullProviderMounts)) {
-				$this->registerMounts($user, $fullProviderMounts, $currentProviders);
-			}
-
-			$this->setupForUserWith($user, function () use ($fullProviderMounts, $authoritativeMounts) {
-				$allMounts = [...$fullProviderMounts, ...$authoritativeMounts];
-				array_walk($allMounts, $this->mountManager->addMount(...));
-			});
-		} elseif (!$this->isSetupStarted($user)) {
-			$this->oneTimeUserSetup($user);
-		}
-		$this->eventLogger->end('fs:setup:user:path');
-	}
-
-	private function fullSetupRequired(IUser $user): bool {
-		if ($this->forceFullSetup) {
-			return true;
-		}
-
-		// we perform a "cached" setup only after having done the full setup recently
-		// this is also used to trigger a full setup after handling events that are likely
-		// to change the available mounts
-		if (!isset($this->fullSetupRequired[$user->getUID()])) {
-			$this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
-		}
-		return $this->fullSetupRequired[$user->getUID()];
-	}
-
-	/**
-	 * @param string $path
-	 * @param string[] $providers
-	 */
-	public function setupForProvider(string $path, array $providers): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for ' . implode(', ', $providers));
-
-		$this->oneTimeUserSetup($user);
-
-		// home providers are always used
-		$providers = array_filter($providers, function (string $provider) {
-			return !is_subclass_of($provider, IHomeMountProvider::class);
-		});
-
-		if (in_array('', $providers)) {
-			$this->setupForUser($user);
-			return;
-		}
-		$setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
-
-		$providers = array_diff($providers, $setupProviders);
-		if (count($providers) === 0) {
-			if (!$this->isSetupStarted($user)) {
-				$this->oneTimeUserSetup($user);
-			}
-			$this->eventLogger->end('fs:setup:user:providers');
-			return;
-		} else {
-			$this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
-			$mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
-		}
-
-		$this->registerMounts($user, $mounts, $providers);
-		$this->setupForUserWith($user, function () use ($mounts) {
-			array_walk($mounts, [$this->mountManager, 'addMount']);
-		});
-		$this->eventLogger->end('fs:setup:user:providers');
-	}
-
-	public function tearDown() {
-		$this->setupUsers = [];
-		$this->setupUsersComplete = [];
-		$this->setupUserMountProviders = [];
-		$this->setupMountProviderPaths = [];
-		$this->fullSetupRequired = [];
-		$this->rootSetup = false;
-		$this->mountManager->clear();
-		$this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
-	}
-
-	/**
-	 * Get mounts from mount providers that are registered after setup
-	 */
-	private function listenForNewMountProviders() {
-		if (!$this->listeningForProviders) {
-			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
-				IMountProvider $provider,
-			) {
-				foreach ($this->setupUsers as $userId) {
-					$user = $this->userManager->get($userId);
-					if ($user) {
-						$mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
-						array_walk($mounts, [$this->mountManager, 'addMount']);
-					}
-				}
-			});
-		}
-	}
-
-	private function setupListeners() {
-		// note that this event handling is intentionally pessimistic
-		// clearing the cache to often is better than not enough
-
-		$this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
-			$this->cache->remove($event->getShare()->getSharedWith());
-		});
-		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event,
-		) {
-			if ($user = $event->getUser()) {
-				$this->cache->remove($user->getUID());
-			} else {
-				$this->cache->clear();
-			}
-		});
-
-		$genericEvents = [
-			'OCA\Circles\Events\CreatingCircleEvent',
-			'OCA\Circles\Events\DestroyingCircleEvent',
-			'OCA\Circles\Events\AddingCircleMemberEvent',
-			'OCA\Circles\Events\RemovingCircleMemberEvent',
-		];
-
-		foreach ($genericEvents as $genericEvent) {
-			$this->eventDispatcher->addListener($genericEvent, function ($event) {
-				$this->cache->clear();
-			});
-		}
-	}
-
-	private function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null): void {
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$this->userMountCache->registerMounts($user, $mounts, $mountProviderClasses);
-		}
-	}
+            if ($mount->getOption('readonly', false)) {
+                return new PermissionsMask([
+                    'storage' => $storage,
+                    'mask' => Constants::PERMISSION_ALL & ~(
+                        Constants::PERMISSION_UPDATE
+                        | Constants::PERMISSION_CREATE
+                        | Constants::PERMISSION_DELETE
+                    ),
+                ]);
+            }
+            return $storage;
+        });
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+    }
+
+    /**
+     * Setup the full filesystem for the specified user
+     */
+    public function setupForUser(IUser $user): void {
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+        $this->setupUsersComplete[] = $user->getUID();
+
+        $this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
+
+        $this->setupUserMountProviders[$user->getUID()] ??= [];
+        $previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
+
+        $this->setupForUserWith($user, function () use ($user) {
+            $this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
+                string $providerClass,
+            ) use ($user) {
+                return !in_array($providerClass, $this->setupUserMountProviders[$user->getUID()]);
+            });
+        });
+        $this->afterUserFullySetup($user, $previouslySetupProviders);
+        $this->eventLogger->end('fs:setup:user:full');
+    }
+
+    /**
+     * Part of the user setup that is run only once per user.
+     */
+    private function oneTimeUserSetup(IUser $user) {
+        if ($this->isSetupStarted($user)) {
+            return;
+        }
+        $this->setupUsers[] = $user->getUID();
+
+        $this->setupRoot();
+
+        $this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
+
+        $this->setupBuiltinWrappers();
+
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        // TODO remove hook
+        OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
+
+        $event = new BeforeFileSystemSetupEvent($user);
+        $this->eventDispatcher->dispatchTyped($event);
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+
+        $userDir = '/' . $user->getUID() . '/files';
+
+        Filesystem::initInternal($userDir);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
+            // home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
+            $homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
+            $this->mountManager->addMount($homeMount);
+
+            if ($homeMount->getStorageRootId() === -1) {
+                $this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
+                $homeMount->getStorage()->mkdir('');
+                $homeMount->getStorage()->getScanner()->scan('');
+                $this->eventLogger->end('fs:setup:user:home:scan');
+            }
+            $this->eventLogger->end('fs:setup:user:home');
+        } else {
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID()
+            ));
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID() . '/files'
+            ));
+            $this->setupUsersComplete[] = $user->getUID();
+        }
+
+        $this->listenForNewMountProviders();
+
+        $this->eventLogger->end('fs:setup:user:onetime');
+    }
+
+    /**
+     * Final housekeeping after a user has been fully setup
+     */
+    private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
+        $this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
+        $userRoot = '/' . $user->getUID() . '/';
+        $mounts = $this->mountManager->getAll();
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
+            return str_starts_with($mount->getMountPoint(), $userRoot);
+        });
+        $allProviders = array_map(function (IMountProvider|IHomeMountProvider|IRootMountProvider $provider) {
+            return get_class($provider);
+        }, array_merge(
+            $this->mountProviderCollection->getProviders(),
+            $this->mountProviderCollection->getHomeProviders(),
+            $this->mountProviderCollection->getRootProviders(),
+        ));
+        $newProviders = array_diff($allProviders, $previouslySetupProviders);
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
+            return !in_array($mount->getMountProvider(), $previouslySetupProviders);
+        });
+        $this->registerMounts($user, $mounts, $newProviders);
+
+        $cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
+        if ($cacheDuration > 0) {
+            $this->cache->set($user->getUID(), true, $cacheDuration);
+            $this->fullSetupRequired[$user->getUID()] = false;
+        }
+        $this->eventLogger->end('fs:setup:user:full:post');
+    }
+
+    /**
+     * Executes the one-time user setup and, if the user can access the
+     * filesystem, executes $mountCallback.
+     *
+     * @param IUser $user
+     * @param IMountPoint $mounts
+     * @return void
+     * @throws \OCP\HintException
+     * @throws \OC\ServerNotAvailableException
+     * @see self::oneTimeUserSetup()
+     *
+     */
+    private function setupForUserWith(IUser $user, callable $mountCallback): void {
+        $this->oneTimeUserSetup($user);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $mountCallback();
+        }
+        $this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
+        $this->eventLogger->end('fs:setup:user:post-init-mountpoint');
+
+        $userDir = '/' . $user->getUID() . '/files';
+        $this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
+        OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
+        $this->eventLogger->end('fs:setup:user:setup-hook');
+    }
+
+    /**
+     * Set up the root filesystem
+     */
+    public function setupRoot(): void {
+        //setting up the filesystem twice can only lead to trouble
+        if ($this->rootSetup) {
+            return;
+        }
+
+        $this->setupBuiltinWrappers();
+
+        $this->rootSetup = true;
+
+        $this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
+
+        $rootMounts = $this->mountProviderCollection->getRootMounts();
+        foreach ($rootMounts as $rootMountProvider) {
+            $this->mountManager->addMount($rootMountProvider);
+        }
+
+        $this->eventLogger->end('fs:setup:root');
+    }
+
+    /**
+     * Get the user to setup for a path or `null` if the root needs to be setup
+     *
+     * @param string $path
+     * @return IUser|null
+     */
+    private function getUserForPath(string $path) {
+        if (str_starts_with($path, '/__groupfolders')) {
+            return null;
+        } elseif (substr_count($path, '/') < 2) {
+            if ($user = $this->userSession->getUser()) {
+                return $user;
+            } else {
+                return null;
+            }
+        } elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
+            return null;
+        } else {
+            [, $userId] = explode('/', $path);
+        }
+
+        return $this->userManager->get($userId);
+    }
+
+    /**
+     * Set up the filesystem for the specified path, optionally including all
+     * children mounts.
+     */
+    public function setupForPath(string $path, bool $includeChildren = false): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        // for the user's home folder, and includes children we need everything always
+        if (rtrim($path) === '/' . $user->getUID() . '/files' && $includeChildren) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        if (!isset($this->setupUserMountProviders[$user->getUID()])) {
+            $this->setupUserMountProviders[$user->getUID()] = [];
+        }
+        $setupProviders = &$this->setupUserMountProviders[$user->getUID()];
+        $currentProviders = [];
+
+        try {
+            $cachedMount = $this->userMountCache->getMountForPath($user, $path);
+        } catch (NotFoundException $e) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->oneTimeUserSetup($user);
+
+        $this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
+        $this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
+
+        $fullProviderMounts = [];
+        $authoritativeMounts = [];
+
+        $mountProvider = $cachedMount->getMountProvider();
+        $mountPoint = $cachedMount->getMountPoint();
+        $isMountProviderSetup = in_array($mountProvider, $setupProviders);
+        $isPathSetupAsAuthoritative
+            = $this->isPathSetup($mountPoint);
+        if (!$isMountProviderSetup && !$isPathSetupAsAuthoritative) {
+            if ($mountProvider === '') {
+                $this->logger->debug('mount at ' . $cachedMount->getMountPoint() . ' has no provider set, performing full setup');
+                $this->eventLogger->end('fs:setup:user:path:find');
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            }
+
+            if (is_a($mountProvider, IPartialMountProvider::class, true)) {
+                $rootId = $cachedMount->getRootId();
+                $rootMetadata = $this->fileAccess->getByFileId($rootId);
+                $providerArgs = new IMountProviderArgs($cachedMount, $rootMetadata);
+                // mark the path as cached (without children for now...)
+                $this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITHOUT_CHILDREN;
+                $authoritativeMounts[] = array_values(
+                    $this->mountProviderCollection->getUserMountsFromProviderByPath(
+                        $mountProvider,
+                        $path,
+                        false,
+                        [$providerArgs]
+                    )
+                );
+            } else {
+                $currentProviders[] = $mountProvider;
+                $setupProviders[] = $mountProvider;
+                $fullProviderMounts[]
+                    = $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$mountProvider]);
+            }
+        }
+
+        if ($includeChildren) {
+            $subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
+            $this->eventLogger->end('fs:setup:user:path:find');
+
+            $needsFullSetup
+                = array_any(
+                    $subCachedMounts,
+                    fn (ICachedMountInfo $info) => $info->getMountProvider() === ''
+                );
+
+            if ($needsFullSetup) {
+                $this->logger->debug('mount has no provider set, performing full setup');
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            }
+
+            /** @var array<class-string<IMountProvider>, ICachedMountInfo[]> $authoritativeCachedMounts */
+            $authoritativeCachedMounts = [];
+            foreach ($subCachedMounts as $cachedMount) {
+                /** @var class-string<IMountProvider> $mountProvider */
+                $mountProvider = $cachedMount->getMountProvider();
+
+                // skip setup for already set up providers
+                if (in_array($mountProvider, $setupProviders)) {
+                    continue;
+                }
+
+                if (is_a($mountProvider, IPartialMountProvider::class, true)) {
+                    // skip setup if path was set up as authoritative before
+                    if ($this->isPathSetup($cachedMount->getMountPoint())) {
+                        continue;
+                    }
+                    // collect cached mount points for authoritative providers
+                    $authoritativeCachedMounts[$mountProvider] ??= [];
+                    $authoritativeCachedMounts[$mountProvider][] = $cachedMount;
+                    continue;
+                }
+
+                $currentProviders[] = $mountProvider;
+                $setupProviders[] = $mountProvider;
+                $fullProviderMounts[]
+                    = $this->mountProviderCollection->getUserMountsForProviderClasses(
+                        $user,
+                        [$mountProvider]
+                    );
+            }
+
+            if (!empty($authoritativeCachedMounts)) {
+                $rootIds = array_map(
+                    fn (ICachedMountInfo $mount) => $mount->getRootId(),
+                    array_merge(...array_values($authoritativeCachedMounts)),
+                );
+
+                $rootsMetadata = [];
+                foreach (array_chunk($rootIds, 1000) as $chunk) {
+                    foreach ($this->fileAccess->getByFileIds($chunk) as $id => $fileMetadata) {
+                        $rootsMetadata[$id] = $fileMetadata;
+                    }
+                }
+                $this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITH_CHILDREN;
+                foreach ($authoritativeCachedMounts as $providerClass => $cachedMounts) {
+                    $providerArgs = array_filter(array_map(
+                        static function (ICachedMountInfo $info) use ($rootsMetadata) {
+                            $rootMetadata = $rootsMetadata[$info->getRootId()] ?? null;
+
+                            return $rootMetadata
+                                ? new IMountProviderArgs($info, $rootMetadata)
+                                : null;
+                        },
+                        $cachedMounts
+                    ));
+                    $authoritativeMounts[]
+                        = $this->mountProviderCollection->getUserMountsFromProviderByPath(
+                            $providerClass,
+                            $path,
+                            true,
+                            $providerArgs,
+                        );
+                }
+            }
+        } else {
+            $this->eventLogger->end('fs:setup:user:path:find');
+        }
+
+        $fullProviderMounts = array_merge(...$fullProviderMounts);
+        $authoritativeMounts = array_merge(...$authoritativeMounts);
+
+        if (count($fullProviderMounts) || count($authoritativeMounts)) {
+            if (count($fullProviderMounts)) {
+                $this->registerMounts($user, $fullProviderMounts, $currentProviders);
+            }
+
+            $this->setupForUserWith($user, function () use ($fullProviderMounts, $authoritativeMounts) {
+                $allMounts = [...$fullProviderMounts, ...$authoritativeMounts];
+                array_walk($allMounts, $this->mountManager->addMount(...));
+            });
+        } elseif (!$this->isSetupStarted($user)) {
+            $this->oneTimeUserSetup($user);
+        }
+        $this->eventLogger->end('fs:setup:user:path');
+    }
+
+    private function fullSetupRequired(IUser $user): bool {
+        if ($this->forceFullSetup) {
+            return true;
+        }
+
+        // we perform a "cached" setup only after having done the full setup recently
+        // this is also used to trigger a full setup after handling events that are likely
+        // to change the available mounts
+        if (!isset($this->fullSetupRequired[$user->getUID()])) {
+            $this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
+        }
+        return $this->fullSetupRequired[$user->getUID()];
+    }
+
+    /**
+     * @param string $path
+     * @param string[] $providers
+     */
+    public function setupForProvider(string $path, array $providers): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for ' . implode(', ', $providers));
+
+        $this->oneTimeUserSetup($user);
+
+        // home providers are always used
+        $providers = array_filter($providers, function (string $provider) {
+            return !is_subclass_of($provider, IHomeMountProvider::class);
+        });
+
+        if (in_array('', $providers)) {
+            $this->setupForUser($user);
+            return;
+        }
+        $setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
+
+        $providers = array_diff($providers, $setupProviders);
+        if (count($providers) === 0) {
+            if (!$this->isSetupStarted($user)) {
+                $this->oneTimeUserSetup($user);
+            }
+            $this->eventLogger->end('fs:setup:user:providers');
+            return;
+        } else {
+            $this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
+            $mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
+        }
+
+        $this->registerMounts($user, $mounts, $providers);
+        $this->setupForUserWith($user, function () use ($mounts) {
+            array_walk($mounts, [$this->mountManager, 'addMount']);
+        });
+        $this->eventLogger->end('fs:setup:user:providers');
+    }
+
+    public function tearDown() {
+        $this->setupUsers = [];
+        $this->setupUsersComplete = [];
+        $this->setupUserMountProviders = [];
+        $this->setupMountProviderPaths = [];
+        $this->fullSetupRequired = [];
+        $this->rootSetup = false;
+        $this->mountManager->clear();
+        $this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
+    }
+
+    /**
+     * Get mounts from mount providers that are registered after setup
+     */
+    private function listenForNewMountProviders() {
+        if (!$this->listeningForProviders) {
+            $this->listeningForProviders = true;
+            $this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
+                IMountProvider $provider,
+            ) {
+                foreach ($this->setupUsers as $userId) {
+                    $user = $this->userManager->get($userId);
+                    if ($user) {
+                        $mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
+                        array_walk($mounts, [$this->mountManager, 'addMount']);
+                    }
+                }
+            });
+        }
+    }
+
+    private function setupListeners() {
+        // note that this event handling is intentionally pessimistic
+        // clearing the cache to often is better than not enough
+
+        $this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
+            $this->cache->remove($event->getShare()->getSharedWith());
+        });
+        $this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event,
+        ) {
+            if ($user = $event->getUser()) {
+                $this->cache->remove($user->getUID());
+            } else {
+                $this->cache->clear();
+            }
+        });
+
+        $genericEvents = [
+            'OCA\Circles\Events\CreatingCircleEvent',
+            'OCA\Circles\Events\DestroyingCircleEvent',
+            'OCA\Circles\Events\AddingCircleMemberEvent',
+            'OCA\Circles\Events\RemovingCircleMemberEvent',
+        ];
+
+        foreach ($genericEvents as $genericEvent) {
+            $this->eventDispatcher->addListener($genericEvent, function ($event) {
+                $this->cache->clear();
+            });
+        }
+    }
+
+    private function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null): void {
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $this->userMountCache->registerMounts($user, $mounts, $mountProviderClasses);
+        }
+    }
 }

tests/lib/Files/SetupManagerTest.php

Indentation +482 added lines, -482 removed lines

@@ -37,493 +37,493 @@
 
 class SetupManagerTest extends TestCase {
 
-	/**
-	 * @var (object&\PHPUnit\Framework\MockObject\MockObject)|IUserManager|(IUserManager&object&\PHPUnit\Framework\MockObject\MockObject)|(IUserManager&\PHPUnit\Framework\MockObject\MockObject)|\PHPUnit\Framework\MockObject\MockObject
-	 */
-	private IUserManager&MockObject $userManager;
-	private IUserMountCache&MockObject $userMountCache;
-	private ICache&MockObject $cache;
-	private FileAccess&MockObject $fileAccess;
-	private MountProviderCollection&MockObject $mountProviderCollection;
-	private IMountManager&MockObject $mountManager;
-	private SetupManager $setupManager;
-	private IUser&MockObject $user;
-	private string $userId;
-	private string $path;
-	private string $mountPoint;
-
-	protected function setUp(): void {
-		$eventLogger = $this->createMock(IEventLogger::class);
-		$eventLogger->method('start');
-		$eventLogger->method('end');
-
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->cache = $this->createMock(ICache::class);
-
-		$this->userId = 'alice';
-		$this->path = "/{$this->userId}/files/folder";
-		$this->mountPoint = "{$this->path}/";
-
-		$this->user = $this->createMock(IUser::class);
-		$this->user->method('getUID')->willReturn($this->userId);
-		$this->userManager->method('get')
-			->with($this->userId)
-			->willReturn($this->user);
-
-		// avoid triggering full setup required check
-		$this->cache->method('get')
-			->with($this->userId)
-			->willReturn(true);
-
-		$this->mountProviderCollection = $this->createMock(MountProviderCollection::class);
-		$this->mountManager = $this->createMock(IMountManager::class);
-		$eventDispatcher = $this->createMock(IEventDispatcher::class);
-		$eventDispatcher->method('addListener');
-		$this->userMountCache = $this->createMock(IUserMountCache::class);
-		$lockdownManager = $this->createMock(ILockdownManager::class);
-		$userSession = $this->createMock(IUserSession::class);
-		$cacheFactory = $this->createMock(ICacheFactory::class);
-		$cacheFactory->expects($this->once())
-			->method('createDistributed')
-			->with('setupmanager::')
-			->willReturn($this->cache);
-		$logger = $this->createMock(LoggerInterface::class);
-		$config = $this->createMock(IConfig::class);
-		$config->method('getSystemValueBool')->willReturn(false);
-		$shareDisableChecker = $this->createMock(ShareDisableChecker::class);
-		$appManager = $this->createMock(IAppManager::class);
-		$this->fileAccess = $this->createMock(FileAccess::class);
-
-		$lockdownManager->method('canAccessFilesystem')->willReturn(true);
-
-		$this->setupManager = new SetupManager(
-			$eventLogger,
-			$this->mountProviderCollection,
-			$this->mountManager,
-			$this->userManager,
-			$eventDispatcher,
-			$this->userMountCache,
-			$lockdownManager,
-			$userSession,
-			$cacheFactory,
-			$logger,
-			$config,
-			$shareDisableChecker,
-			$appManager,
-			$this->fileAccess,
-		);
-	}
-
-	public function testTearDown(): void {
-		$this->setupManager->tearDown();
-	}
-
-	/**
-	 * Tests that a path is not set up twice for providers implementing
-	 * IPartialMountProvider in setupForPath.
-	 */
-	public function testSetupForPathWithPartialProviderSkipsAlreadySetupPath(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-		$this->userMountCache->expects($this->never())->method('registerMounts');
-		$this->userMountCache->expects($this->never())->method('getMountsInPath');
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-
-		$partialMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsFromProviderByPath')
-			->with(
-				SetupManagerTestPartialMountProvider::class,
-				$this->path,
-				false,
-				$this->callback(function (array $args) use ($cachedMount) {
-					$this->assertCount(1, $args);
-					$this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
-					$this->assertSame($cachedMount, $args[0]->mountInfo);
-					return true;
-				})
-			)
-			->willReturn([$partialMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->mountProviderCollection->expects($this->never())
-			->method('getUserMountsForProviderClasses');
-
-		$invokedCount = $this->exactly(2);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $partialMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, false);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	/**
-	 * Tests that providers that are not implementing IPartialMountProvider are
-	 * not set up more than once by setupForPath.
-	 */
-	public function testSetupForPathWithNonPartialProviderSkipsAlreadySetupProvider(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42,
-			IMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-
-		$this->userMountCache->expects($this->once())->method('registerMounts');
-		$this->userMountCache->expects($this->never())->method('getMountsInPath');
-
-		$providerMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsForProviderClasses')
-			->with($this->user, [IMountProvider::class])
-			->willReturn([$providerMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$invokedCount = $this->exactly(2);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $providerMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, false);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	/**
-	 * Tests that setupForPath does not instantiate already set up providers
-	 * when called for the same path first with $withChildren set to true
-	 * and then set to false.
-	 */
-	public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
-		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-
-		$this->userMountCache->expects($this->once())->method('registerMounts');
-		$this->userMountCache->expects($this->once())->method('getMountsInPath')
-			->willReturn([$additionalCachedMount]);
-
-		$mount = $this->createMock(IMountPoint::class);
-		$additionalMount = $this->createMock(IMountPoint::class);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsForProviderClasses')
-			->willReturnCallback(function (IUser $userArg, array $providersArg) use (
-				$additionalMount,
-				$mount,
-				$invokedCount) {
-				if ($invokedCount->numberOfInvocations() === 1) {
-					$providers = [IMountProvider::class];
-					$returnMounts = [$mount];
-				} else {
-					$providers = [SetupManagerTestFullMountProvider::class];
-					$returnMounts = [$additionalMount];
-				}
-
-				$this->assertSame($this->user, $userArg);
-				$this->assertSame($providersArg, $providers);
-
-				return $returnMounts;
-			});
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$invokedCount = $this->exactly(3);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $mount,
-			3 => $additionalMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	/**
-	 * Tests that setupForPath does not set up child mounts again if a parent
-	 * was set up with $withChildren set to true.
-	 */
-	public function testSetupForPathWithChildrenAndPartialProviderSkipsIfParentAlreadySetup():	void {
-		$childPath = "{$this->path}/child";
-		$childMountPoint = "{$childPath}/";
-
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-		$cachedChildMount = $this->getCachedMountInfo($childMountPoint, 43);
-
-		$invokedCount = $this->exactly(3);
-		$this->userMountCache->expects($invokedCount)
-			->method('getMountForPath')
-			->willReturnCallback(function (IUser $userArg, string $pathArg) use (
-				$cachedChildMount,
-				$cachedMount,
-				$childPath,
-				$invokedCount) {
-				if ($invokedCount->numberOfInvocations() === 1) {
-					$expectedPath = $this->path;
-					$returnMount = $cachedMount;
-				} else {
-					$expectedPath = $childPath;
-					$returnMount = $cachedChildMount;
-				}
-
-				$this->assertSame($this->user, $userArg);
-				$this->assertSame($expectedPath, $pathArg);
-
-				return $returnMount;
-			});
-
-		$this->userMountCache->expects($this->never())->method('registerMounts');
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountsInPath')
-			->willReturn([$cachedChildMount]);
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileIds')
-			->with([43])
-			->willReturn([43 => $this->createMock(CacheEntry::class)]);
-
-		$partialMount = $this->createMock(IMountPoint::class);
-		$partialChildMount = $this->createMock(IMountPoint::class);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (
-				string $providerClass,
-				string $pathArg,
-				bool $forChildren,
-				array $mountProviderArgs,
-			) use (
-				$cachedChildMount,
-				$partialMount,
-				$partialChildMount,
-				$cachedMount,
-				$invokedCount
-			) {
-				$expectedPath = $this->path;
-				if ($invokedCount->numberOfInvocations() === 1) {
-					// call for the parent
-					$expectedCachedMount = $cachedMount;
-					$mountPoints = [$partialMount];
-					$expectedForChildren = false;
-				} else {
-					// call for the children
-					$expectedCachedMount = $cachedChildMount;
-					$mountPoints = [$partialChildMount];
-					$expectedForChildren = true;
-				}
-
-				$this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
-				$this->assertSame($expectedPath, $pathArg);
-				$this->assertSame($expectedForChildren, $forChildren);
-				$this->assertCount(1, $mountProviderArgs);
-				$this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
-				$this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
-
-				return $mountPoints;
-			});
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->mountProviderCollection->expects($this->never())
-			->method('getUserMountsForProviderClasses');
-
-		$invokedCount = $this->exactly(3);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $partialMount,
-			3 => $partialChildMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// once the setup for a path has been done with children, setup for sub
-		// paths should not create the same new mounts again
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($childPath, false);
-		$this->setupManager->setupForPath($childPath, true);
-	}
-
-	/**
-	 * Tests that when called twice setupForPath does not set up mounts from
-	 * providers implementing IPartialMountProviders or IMountProvider.
-	 */
-	public function testSetupForPathHandlesPartialAndFullProvidersWithChildren(): void {
-		$parentPartialCachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-		$childCachedPartialMount = $this->getCachedMountInfo("{$this->mountPoint}partial/", 43);
-		$childCachedFullMount = $this->getCachedMountInfo("{$this->mountPoint}full/", 44, SetupManagerTestFullMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($parentPartialCachedMount);
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountsInPath')
-			->with($this->user, $this->path)
-			->willReturn([$childCachedPartialMount, $childCachedFullMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-		$parentPartialMount = $this->createMock(IMountPoint::class);
-		$childPartialMount = $this->createMock(IMountPoint::class);
-		$childFullProviderMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->userMountCache->expects($this->once())
-			->method('registerMounts')
-			->with(
-				$this->user, [$childFullProviderMount],
-				[SetupManagerTestFullMountProvider::class],
-			);
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-		$childMetadata = $this->createMock(CacheEntry::class);
-		$this->fileAccess->expects($this->once())
-			->method('getByFileIds')
-			->with([43])
-			->willReturn([43 => $childMetadata]);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (string $providerClass, string $pathArg, bool $forChildren, array $mountProviderArgs) use (
-				$childCachedPartialMount,
-				$childPartialMount,
-				$parentPartialMount,
-				$parentPartialCachedMount,
-				$invokedCount) {
-				$expectedPath = $this->path;
-				if ($invokedCount->numberOfInvocations() === 1) {
-					// call for the parent
-					$expectedCachedMount = $parentPartialCachedMount;
-					$mountPoints = [$parentPartialMount];
-					$expectedForChildren = false;
-				} else {
-					// call for the children
-					$expectedCachedMount = $childCachedPartialMount;
-					$mountPoints = [$childPartialMount];
-					$expectedForChildren = true;
-				}
-
-				$this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
-				$this->assertSame($expectedPath, $pathArg);
-				$this->assertSame($expectedForChildren, $forChildren);
-				$this->assertCount(1, $mountProviderArgs);
-				$this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
-				$this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
-
-				return $mountPoints;
-			});
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsForProviderClasses')
-			->with($this->user, [SetupManagerTestFullMountProvider::class])
-			->willReturn([$childFullProviderMount]);
-
-		$invokedCount = $this->exactly(4);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $childFullProviderMount,
-			3 => $parentPartialMount,
-			4 => $childPartialMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// call twice to test that providers and mounts are only called once
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($this->path, true);
-	}
-
-	private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
-		return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
-			$expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
-			$this->assertSame($expectedMount, $actualMount);
-		};
-	}
-
-	public function getCachedMountInfo(string $mountPoint, int $rootId, string $providerClass = SetupManagerTestPartialMountProvider::class): ICachedMountInfo&MockObject {
-		$cachedMount = $this->createMock(ICachedMountInfo::class);
-		$cachedMount->method('getMountProvider')->willReturn($providerClass);
-		$cachedMount->method('getMountPoint')->willReturn($mountPoint);
-		$cachedMount->method('getRootId')->willReturn($rootId);
-
-		return $cachedMount;
-	}
+    /**
+     * @var (object&\PHPUnit\Framework\MockObject\MockObject)|IUserManager|(IUserManager&object&\PHPUnit\Framework\MockObject\MockObject)|(IUserManager&\PHPUnit\Framework\MockObject\MockObject)|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private IUserManager&MockObject $userManager;
+    private IUserMountCache&MockObject $userMountCache;
+    private ICache&MockObject $cache;
+    private FileAccess&MockObject $fileAccess;
+    private MountProviderCollection&MockObject $mountProviderCollection;
+    private IMountManager&MockObject $mountManager;
+    private SetupManager $setupManager;
+    private IUser&MockObject $user;
+    private string $userId;
+    private string $path;
+    private string $mountPoint;
+
+    protected function setUp(): void {
+        $eventLogger = $this->createMock(IEventLogger::class);
+        $eventLogger->method('start');
+        $eventLogger->method('end');
+
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->cache = $this->createMock(ICache::class);
+
+        $this->userId = 'alice';
+        $this->path = "/{$this->userId}/files/folder";
+        $this->mountPoint = "{$this->path}/";
+
+        $this->user = $this->createMock(IUser::class);
+        $this->user->method('getUID')->willReturn($this->userId);
+        $this->userManager->method('get')
+            ->with($this->userId)
+            ->willReturn($this->user);
+
+        // avoid triggering full setup required check
+        $this->cache->method('get')
+            ->with($this->userId)
+            ->willReturn(true);
+
+        $this->mountProviderCollection = $this->createMock(MountProviderCollection::class);
+        $this->mountManager = $this->createMock(IMountManager::class);
+        $eventDispatcher = $this->createMock(IEventDispatcher::class);
+        $eventDispatcher->method('addListener');
+        $this->userMountCache = $this->createMock(IUserMountCache::class);
+        $lockdownManager = $this->createMock(ILockdownManager::class);
+        $userSession = $this->createMock(IUserSession::class);
+        $cacheFactory = $this->createMock(ICacheFactory::class);
+        $cacheFactory->expects($this->once())
+            ->method('createDistributed')
+            ->with('setupmanager::')
+            ->willReturn($this->cache);
+        $logger = $this->createMock(LoggerInterface::class);
+        $config = $this->createMock(IConfig::class);
+        $config->method('getSystemValueBool')->willReturn(false);
+        $shareDisableChecker = $this->createMock(ShareDisableChecker::class);
+        $appManager = $this->createMock(IAppManager::class);
+        $this->fileAccess = $this->createMock(FileAccess::class);
+
+        $lockdownManager->method('canAccessFilesystem')->willReturn(true);
+
+        $this->setupManager = new SetupManager(
+            $eventLogger,
+            $this->mountProviderCollection,
+            $this->mountManager,
+            $this->userManager,
+            $eventDispatcher,
+            $this->userMountCache,
+            $lockdownManager,
+            $userSession,
+            $cacheFactory,
+            $logger,
+            $config,
+            $shareDisableChecker,
+            $appManager,
+            $this->fileAccess,
+        );
+    }
+
+    public function testTearDown(): void {
+        $this->setupManager->tearDown();
+    }
+
+    /**
+     * Tests that a path is not set up twice for providers implementing
+     * IPartialMountProvider in setupForPath.
+     */
+    public function testSetupForPathWithPartialProviderSkipsAlreadySetupPath(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+        $this->userMountCache->expects($this->never())->method('registerMounts');
+        $this->userMountCache->expects($this->never())->method('getMountsInPath');
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+
+        $partialMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsFromProviderByPath')
+            ->with(
+                SetupManagerTestPartialMountProvider::class,
+                $this->path,
+                false,
+                $this->callback(function (array $args) use ($cachedMount) {
+                    $this->assertCount(1, $args);
+                    $this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
+                    $this->assertSame($cachedMount, $args[0]->mountInfo);
+                    return true;
+                })
+            )
+            ->willReturn([$partialMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->mountProviderCollection->expects($this->never())
+            ->method('getUserMountsForProviderClasses');
+
+        $invokedCount = $this->exactly(2);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $partialMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, false);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    /**
+     * Tests that providers that are not implementing IPartialMountProvider are
+     * not set up more than once by setupForPath.
+     */
+    public function testSetupForPathWithNonPartialProviderSkipsAlreadySetupProvider(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42,
+            IMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+
+        $this->userMountCache->expects($this->once())->method('registerMounts');
+        $this->userMountCache->expects($this->never())->method('getMountsInPath');
+
+        $providerMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsForProviderClasses')
+            ->with($this->user, [IMountProvider::class])
+            ->willReturn([$providerMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $invokedCount = $this->exactly(2);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $providerMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, false);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    /**
+     * Tests that setupForPath does not instantiate already set up providers
+     * when called for the same path first with $withChildren set to true
+     * and then set to false.
+     */
+    public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
+        $additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+
+        $this->userMountCache->expects($this->once())->method('registerMounts');
+        $this->userMountCache->expects($this->once())->method('getMountsInPath')
+            ->willReturn([$additionalCachedMount]);
+
+        $mount = $this->createMock(IMountPoint::class);
+        $additionalMount = $this->createMock(IMountPoint::class);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsForProviderClasses')
+            ->willReturnCallback(function (IUser $userArg, array $providersArg) use (
+                $additionalMount,
+                $mount,
+                $invokedCount) {
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    $providers = [IMountProvider::class];
+                    $returnMounts = [$mount];
+                } else {
+                    $providers = [SetupManagerTestFullMountProvider::class];
+                    $returnMounts = [$additionalMount];
+                }
+
+                $this->assertSame($this->user, $userArg);
+                $this->assertSame($providersArg, $providers);
+
+                return $returnMounts;
+            });
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $invokedCount = $this->exactly(3);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $mount,
+            3 => $additionalMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    /**
+     * Tests that setupForPath does not set up child mounts again if a parent
+     * was set up with $withChildren set to true.
+     */
+    public function testSetupForPathWithChildrenAndPartialProviderSkipsIfParentAlreadySetup():	void {
+        $childPath = "{$this->path}/child";
+        $childMountPoint = "{$childPath}/";
+
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+        $cachedChildMount = $this->getCachedMountInfo($childMountPoint, 43);
+
+        $invokedCount = $this->exactly(3);
+        $this->userMountCache->expects($invokedCount)
+            ->method('getMountForPath')
+            ->willReturnCallback(function (IUser $userArg, string $pathArg) use (
+                $cachedChildMount,
+                $cachedMount,
+                $childPath,
+                $invokedCount) {
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    $expectedPath = $this->path;
+                    $returnMount = $cachedMount;
+                } else {
+                    $expectedPath = $childPath;
+                    $returnMount = $cachedChildMount;
+                }
+
+                $this->assertSame($this->user, $userArg);
+                $this->assertSame($expectedPath, $pathArg);
+
+                return $returnMount;
+            });
+
+        $this->userMountCache->expects($this->never())->method('registerMounts');
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountsInPath')
+            ->willReturn([$cachedChildMount]);
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileIds')
+            ->with([43])
+            ->willReturn([43 => $this->createMock(CacheEntry::class)]);
+
+        $partialMount = $this->createMock(IMountPoint::class);
+        $partialChildMount = $this->createMock(IMountPoint::class);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsFromProviderByPath')
+            ->willReturnCallback(function (
+                string $providerClass,
+                string $pathArg,
+                bool $forChildren,
+                array $mountProviderArgs,
+            ) use (
+                $cachedChildMount,
+                $partialMount,
+                $partialChildMount,
+                $cachedMount,
+                $invokedCount
+            ) {
+                $expectedPath = $this->path;
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    // call for the parent
+                    $expectedCachedMount = $cachedMount;
+                    $mountPoints = [$partialMount];
+                    $expectedForChildren = false;
+                } else {
+                    // call for the children
+                    $expectedCachedMount = $cachedChildMount;
+                    $mountPoints = [$partialChildMount];
+                    $expectedForChildren = true;
+                }
+
+                $this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
+                $this->assertSame($expectedPath, $pathArg);
+                $this->assertSame($expectedForChildren, $forChildren);
+                $this->assertCount(1, $mountProviderArgs);
+                $this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
+                $this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
+
+                return $mountPoints;
+            });
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->mountProviderCollection->expects($this->never())
+            ->method('getUserMountsForProviderClasses');
+
+        $invokedCount = $this->exactly(3);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $partialMount,
+            3 => $partialChildMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // once the setup for a path has been done with children, setup for sub
+        // paths should not create the same new mounts again
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($childPath, false);
+        $this->setupManager->setupForPath($childPath, true);
+    }
+
+    /**
+     * Tests that when called twice setupForPath does not set up mounts from
+     * providers implementing IPartialMountProviders or IMountProvider.
+     */
+    public function testSetupForPathHandlesPartialAndFullProvidersWithChildren(): void {
+        $parentPartialCachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+        $childCachedPartialMount = $this->getCachedMountInfo("{$this->mountPoint}partial/", 43);
+        $childCachedFullMount = $this->getCachedMountInfo("{$this->mountPoint}full/", 44, SetupManagerTestFullMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($parentPartialCachedMount);
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountsInPath')
+            ->with($this->user, $this->path)
+            ->willReturn([$childCachedPartialMount, $childCachedFullMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+        $parentPartialMount = $this->createMock(IMountPoint::class);
+        $childPartialMount = $this->createMock(IMountPoint::class);
+        $childFullProviderMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->userMountCache->expects($this->once())
+            ->method('registerMounts')
+            ->with(
+                $this->user, [$childFullProviderMount],
+                [SetupManagerTestFullMountProvider::class],
+            );
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+        $childMetadata = $this->createMock(CacheEntry::class);
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileIds')
+            ->with([43])
+            ->willReturn([43 => $childMetadata]);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsFromProviderByPath')
+            ->willReturnCallback(function (string $providerClass, string $pathArg, bool $forChildren, array $mountProviderArgs) use (
+                $childCachedPartialMount,
+                $childPartialMount,
+                $parentPartialMount,
+                $parentPartialCachedMount,
+                $invokedCount) {
+                $expectedPath = $this->path;
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    // call for the parent
+                    $expectedCachedMount = $parentPartialCachedMount;
+                    $mountPoints = [$parentPartialMount];
+                    $expectedForChildren = false;
+                } else {
+                    // call for the children
+                    $expectedCachedMount = $childCachedPartialMount;
+                    $mountPoints = [$childPartialMount];
+                    $expectedForChildren = true;
+                }
+
+                $this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
+                $this->assertSame($expectedPath, $pathArg);
+                $this->assertSame($expectedForChildren, $forChildren);
+                $this->assertCount(1, $mountProviderArgs);
+                $this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
+                $this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
+
+                return $mountPoints;
+            });
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsForProviderClasses')
+            ->with($this->user, [SetupManagerTestFullMountProvider::class])
+            ->willReturn([$childFullProviderMount]);
+
+        $invokedCount = $this->exactly(4);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $childFullProviderMount,
+            3 => $parentPartialMount,
+            4 => $childPartialMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // call twice to test that providers and mounts are only called once
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($this->path, true);
+    }
+
+    private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
+        return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
+            $expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
+            $this->assertSame($expectedMount, $actualMount);
+        };
+    }
+
+    public function getCachedMountInfo(string $mountPoint, int $rootId, string $providerClass = SetupManagerTestPartialMountProvider::class): ICachedMountInfo&MockObject {
+        $cachedMount = $this->createMock(ICachedMountInfo::class);
+        $cachedMount->method('getMountProvider')->willReturn($providerClass);
+        $cachedMount->method('getMountPoint')->willReturn($mountPoint);
+        $cachedMount->method('getRootId')->willReturn($rootId);
+
+        return $cachedMount;
+    }
 }
 
 class SetupManagerTestPartialMountProvider implements IPartialMountProvider {
-	public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
+        return [];
+    }
 
-	public function getMountsForPath(string $path, bool $forChildren, array $mountProviderArgs, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForPath(string $path, bool $forChildren, array $mountProviderArgs, IStorageFactory $loader): array {
+        return [];
+    }
 }
 
 class SetupManagerTestFullMountProvider implements IMountProvider {
-	public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
+        return [];
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -145,7 +145,7 @@ 
 				SetupManagerTestPartialMountProvider::class,
 				$this->path,
 				false,
-				$this->callback(function (array $args) use ($cachedMount) {
+				$this->callback(function(array $args) use ($cachedMount) {
 					$this->assertCount(1, $args);
 					$this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
 					$this->assertSame($cachedMount, $args[0]->mountInfo);
@@ -227,7 +227,7 @@ 
 	 */
 	public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
 		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
-		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
+		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint.'additional/', 43, SetupManagerTestFullMountProvider::class);
 
 		$this->userMountCache->expects($this->exactly(2))
 			->method('getMountForPath')
@@ -244,7 +244,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsForProviderClasses')
-			->willReturnCallback(function (IUser $userArg, array $providersArg) use (
+			->willReturnCallback(function(IUser $userArg, array $providersArg) use (
 				$additionalMount,
 				$mount,
 				$invokedCount) {
@@ -297,7 +297,7 @@ 
 		$invokedCount = $this->exactly(3);
 		$this->userMountCache->expects($invokedCount)
 			->method('getMountForPath')
-			->willReturnCallback(function (IUser $userArg, string $pathArg) use (
+			->willReturnCallback(function(IUser $userArg, string $pathArg) use (
 				$cachedChildMount,
 				$cachedMount,
 				$childPath,
@@ -337,7 +337,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (
+			->willReturnCallback(function(
 				string $providerClass,
 				string $pathArg,
 				bool $forChildren,
@@ -445,7 +445,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (string $providerClass, string $pathArg, bool $forChildren, array $mountProviderArgs) use (
+			->willReturnCallback(function(string $providerClass, string $pathArg, bool $forChildren, array $mountProviderArgs) use (
 				$childCachedPartialMount,
 				$childPartialMount,
 				$parentPartialMount,
@@ -496,7 +496,7 @@ 
 	}
 
 	private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
-		return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
+		return function(IMountPoint $actualMount) use ($invokedCount, $expectations) {
 			$expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
 			$this->assertSame($expectedMount, $actualMount);
 		};