nextcloud / server

lib/private/Files/Config/CachedMountFileInfo.php

Indentation +24 added lines, -24 removed lines

@@ -27,31 +27,31 @@
 use OCP\IUser;
 
 class CachedMountFileInfo extends CachedMountInfo implements ICachedMountFileInfo {
-	private string $internalPath;
+    private string $internalPath;
 
-	public function __construct(
-		IUser $user,
-		int $storageId,
-		int $rootId,
-		string $mountPoint,
-		?int $mountId,
-		string $mountProvider,
-		string $rootInternalPath,
-		string $internalPath
-	) {
-		parent::__construct($user, $storageId, $rootId, $mountPoint, $mountProvider, $mountId, $rootInternalPath);
-		$this->internalPath = $internalPath;
-	}
+    public function __construct(
+        IUser $user,
+        int $storageId,
+        int $rootId,
+        string $mountPoint,
+        ?int $mountId,
+        string $mountProvider,
+        string $rootInternalPath,
+        string $internalPath
+    ) {
+        parent::__construct($user, $storageId, $rootId, $mountPoint, $mountProvider, $mountId, $rootInternalPath);
+        $this->internalPath = $internalPath;
+    }
 
-	public function getInternalPath(): string {
-		if ($this->getRootInternalPath()) {
-			return substr($this->internalPath, strlen($this->getRootInternalPath()) + 1);
-		} else {
-			return $this->internalPath;
-		}
-	}
+    public function getInternalPath(): string {
+        if ($this->getRootInternalPath()) {
+            return substr($this->internalPath, strlen($this->getRootInternalPath()) + 1);
+        } else {
+            return $this->internalPath;
+        }
+    }
 
-	public function getPath(): string {
-		return $this->getMountPoint() . $this->getInternalPath();
-	}
+    public function getPath(): string {
+        return $this->getMountPoint() . $this->getInternalPath();
+    }
 }

lib/private/Files/Config/MountProviderCollection.php

Indentation +181 added lines, -181 removed lines

@@ -37,185 +37,185 @@
 use OCP\IUser;
 
 class MountProviderCollection implements IMountProviderCollection, Emitter {
-	use EmitterTrait;
-
-	/**
-	 * @var \OCP\Files\Config\IHomeMountProvider[]
-	 */
-	private $homeProviders = [];
-
-	/**
-	 * @var \OCP\Files\Config\IMountProvider[]
-	 */
-	private $providers = [];
-
-	/** @var \OCP\Files\Config\IRootMountProvider[] */
-	private $rootProviders = [];
-
-	/**
-	 * @var \OCP\Files\Storage\IStorageFactory
-	 */
-	private $loader;
-
-	/**
-	 * @var \OCP\Files\Config\IUserMountCache
-	 */
-	private $mountCache;
-
-	/** @var callable[] */
-	private $mountFilters = [];
-
-	/**
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
-	 * @param IUserMountCache $mountCache
-	 */
-	public function __construct(IStorageFactory $loader, IUserMountCache $mountCache) {
-		$this->loader = $loader;
-		$this->mountCache = $mountCache;
-	}
-
-	/**
-	 * Get all configured mount points for the user
-	 *
-	 * @param \OCP\IUser $user
-	 * @return \OCP\Files\Mount\IMountPoint[]
-	 */
-	public function getMountsForUser(IUser $user) {
-		$loader = $this->loader;
-		$mounts = array_map(function (IMountProvider $provider) use ($user, $loader) {
-			return $provider->getMountsForUser($user, $loader);
-		}, $this->providers);
-		$mounts = array_filter($mounts, function ($result) {
-			return is_array($result);
-		});
-		$mounts = array_reduce($mounts, function (array $mounts, array $providerMounts) {
-			return array_merge($mounts, $providerMounts);
-		}, []);
-		return $this->filterMounts($user, $mounts);
-	}
-
-	public function addMountForUser(IUser $user, IMountManager $mountManager) {
-		// shared mount provider gets to go last since it needs to know existing files
-		// to check for name collisions
-		$firstMounts = [];
-		$firstProviders = array_filter($this->providers, function (IMountProvider $provider) {
-			return (get_class($provider) !== 'OCA\Files_Sharing\MountProvider');
-		});
-		$lastProviders = array_filter($this->providers, function (IMountProvider $provider) {
-			return (get_class($provider) === 'OCA\Files_Sharing\MountProvider');
-		});
-		foreach ($firstProviders as $provider) {
-			$mounts = $provider->getMountsForUser($user, $this->loader);
-			if (is_array($mounts)) {
-				$firstMounts = array_merge($firstMounts, $mounts);
-			}
-		}
-		$firstMounts = $this->filterMounts($user, $firstMounts);
-		array_walk($firstMounts, [$mountManager, 'addMount']);
-
-		$lateMounts = [];
-		foreach ($lastProviders as $provider) {
-			$mounts = $provider->getMountsForUser($user, $this->loader);
-			if (is_array($mounts)) {
-				$lateMounts = array_merge($lateMounts, $mounts);
-			}
-		}
-
-		$lateMounts = $this->filterMounts($user, $lateMounts);
-		array_walk($lateMounts, [$mountManager, 'addMount']);
-
-		return array_merge($lateMounts, $firstMounts);
-	}
-
-	/**
-	 * Get the configured home mount for this user
-	 *
-	 * @param \OCP\IUser $user
-	 * @return \OCP\Files\Mount\IMountPoint
-	 * @since 9.1.0
-	 */
-	public function getHomeMountForUser(IUser $user) {
-		/** @var \OCP\Files\Config\IHomeMountProvider[] $providers */
-		$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
-	 *
-	 * @param \OCP\Files\Config\IMountProvider $provider
-	 */
-	public function registerProvider(IMountProvider $provider) {
-		$this->providers[] = $provider;
-
-		$this->emit('\OC\Files\Config', 'registerMountProvider', [$provider]);
-	}
-
-	public function registerMountFilter(callable $filter) {
-		$this->mountFilters[] = $filter;
-	}
-
-	private function filterMounts(IUser $user, array $mountPoints) {
-		return 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 \OCP\Files\Config\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
-	 *
-	 * @return IUserMountCache
-	 */
-	public function getMountCache() {
-		return $this->mountCache;
-	}
-
-	public function registerRootProvider(IRootMountProvider $provider) {
-		$this->rootProviders[] = $provider;
-	}
-
-	/**
-	 * Get all root mountpoints
-	 *
-	 * @return \OCP\Files\Mount\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);
-		}, []);
-		return $mounts;
-	}
-
-	public function clearProviders() {
-		$this->providers = [];
-		$this->homeProviders = [];
-		$this->rootProviders = [];
-	}
+    use EmitterTrait;
+
+    /**
+     * @var \OCP\Files\Config\IHomeMountProvider[]
+     */
+    private $homeProviders = [];
+
+    /**
+     * @var \OCP\Files\Config\IMountProvider[]
+     */
+    private $providers = [];
+
+    /** @var \OCP\Files\Config\IRootMountProvider[] */
+    private $rootProviders = [];
+
+    /**
+     * @var \OCP\Files\Storage\IStorageFactory
+     */
+    private $loader;
+
+    /**
+     * @var \OCP\Files\Config\IUserMountCache
+     */
+    private $mountCache;
+
+    /** @var callable[] */
+    private $mountFilters = [];
+
+    /**
+     * @param \OCP\Files\Storage\IStorageFactory $loader
+     * @param IUserMountCache $mountCache
+     */
+    public function __construct(IStorageFactory $loader, IUserMountCache $mountCache) {
+        $this->loader = $loader;
+        $this->mountCache = $mountCache;
+    }
+
+    /**
+     * Get all configured mount points for the user
+     *
+     * @param \OCP\IUser $user
+     * @return \OCP\Files\Mount\IMountPoint[]
+     */
+    public function getMountsForUser(IUser $user) {
+        $loader = $this->loader;
+        $mounts = array_map(function (IMountProvider $provider) use ($user, $loader) {
+            return $provider->getMountsForUser($user, $loader);
+        }, $this->providers);
+        $mounts = array_filter($mounts, function ($result) {
+            return is_array($result);
+        });
+        $mounts = array_reduce($mounts, function (array $mounts, array $providerMounts) {
+            return array_merge($mounts, $providerMounts);
+        }, []);
+        return $this->filterMounts($user, $mounts);
+    }
+
+    public function addMountForUser(IUser $user, IMountManager $mountManager) {
+        // shared mount provider gets to go last since it needs to know existing files
+        // to check for name collisions
+        $firstMounts = [];
+        $firstProviders = array_filter($this->providers, function (IMountProvider $provider) {
+            return (get_class($provider) !== 'OCA\Files_Sharing\MountProvider');
+        });
+        $lastProviders = array_filter($this->providers, function (IMountProvider $provider) {
+            return (get_class($provider) === 'OCA\Files_Sharing\MountProvider');
+        });
+        foreach ($firstProviders as $provider) {
+            $mounts = $provider->getMountsForUser($user, $this->loader);
+            if (is_array($mounts)) {
+                $firstMounts = array_merge($firstMounts, $mounts);
+            }
+        }
+        $firstMounts = $this->filterMounts($user, $firstMounts);
+        array_walk($firstMounts, [$mountManager, 'addMount']);
+
+        $lateMounts = [];
+        foreach ($lastProviders as $provider) {
+            $mounts = $provider->getMountsForUser($user, $this->loader);
+            if (is_array($mounts)) {
+                $lateMounts = array_merge($lateMounts, $mounts);
+            }
+        }
+
+        $lateMounts = $this->filterMounts($user, $lateMounts);
+        array_walk($lateMounts, [$mountManager, 'addMount']);
+
+        return array_merge($lateMounts, $firstMounts);
+    }
+
+    /**
+     * Get the configured home mount for this user
+     *
+     * @param \OCP\IUser $user
+     * @return \OCP\Files\Mount\IMountPoint
+     * @since 9.1.0
+     */
+    public function getHomeMountForUser(IUser $user) {
+        /** @var \OCP\Files\Config\IHomeMountProvider[] $providers */
+        $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
+     *
+     * @param \OCP\Files\Config\IMountProvider $provider
+     */
+    public function registerProvider(IMountProvider $provider) {
+        $this->providers[] = $provider;
+
+        $this->emit('\OC\Files\Config', 'registerMountProvider', [$provider]);
+    }
+
+    public function registerMountFilter(callable $filter) {
+        $this->mountFilters[] = $filter;
+    }
+
+    private function filterMounts(IUser $user, array $mountPoints) {
+        return 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 \OCP\Files\Config\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
+     *
+     * @return IUserMountCache
+     */
+    public function getMountCache() {
+        return $this->mountCache;
+    }
+
+    public function registerRootProvider(IRootMountProvider $provider) {
+        $this->rootProviders[] = $provider;
+    }
+
+    /**
+     * Get all root mountpoints
+     *
+     * @return \OCP\Files\Mount\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);
+        }, []);
+        return $mounts;
+    }
+
+    public function clearProviders() {
+        $this->providers = [];
+        $this->homeProviders = [];
+        $this->rootProviders = [];
+    }
 }

lib/private/Files/Config/CachedMountInfo.php

Indentation +95 added lines, -95 removed lines

@@ -28,108 +28,108 @@
 use OCP\IUser;
 
 class CachedMountInfo implements ICachedMountInfo {
-	protected IUser $user;
-	protected int $storageId;
-	protected int $rootId;
-	protected string $mountPoint;
-	protected ?int $mountId;
-	protected string $rootInternalPath;
-	protected string $mountProvider;
+    protected IUser $user;
+    protected int $storageId;
+    protected int $rootId;
+    protected string $mountPoint;
+    protected ?int $mountId;
+    protected string $rootInternalPath;
+    protected string $mountProvider;
 
-	/**
-	 * CachedMountInfo constructor.
-	 *
-	 * @param IUser $user
-	 * @param int $storageId
-	 * @param int $rootId
-	 * @param string $mountPoint
-	 * @param int|null $mountId
-	 * @param string $rootInternalPath
-	 */
-	public function __construct(
-		IUser $user,
-		int $storageId,
-		int $rootId,
-		string $mountPoint,
-		string $mountProvider,
-		int $mountId = null,
-		string $rootInternalPath = ''
-	) {
-		$this->user = $user;
-		$this->storageId = $storageId;
-		$this->rootId = $rootId;
-		$this->mountPoint = $mountPoint;
-		$this->mountId = $mountId;
-		$this->rootInternalPath = $rootInternalPath;
-		if (strlen($mountProvider) > 128) {
-			throw new \Exception("Mount provider $mountProvider name exceeds the limit of 128 characters");
-		}
-		$this->mountProvider = $mountProvider;
-	}
+    /**
+     * CachedMountInfo constructor.
+     *
+     * @param IUser $user
+     * @param int $storageId
+     * @param int $rootId
+     * @param string $mountPoint
+     * @param int|null $mountId
+     * @param string $rootInternalPath
+     */
+    public function __construct(
+        IUser $user,
+        int $storageId,
+        int $rootId,
+        string $mountPoint,
+        string $mountProvider,
+        int $mountId = null,
+        string $rootInternalPath = ''
+    ) {
+        $this->user = $user;
+        $this->storageId = $storageId;
+        $this->rootId = $rootId;
+        $this->mountPoint = $mountPoint;
+        $this->mountId = $mountId;
+        $this->rootInternalPath = $rootInternalPath;
+        if (strlen($mountProvider) > 128) {
+            throw new \Exception("Mount provider $mountProvider name exceeds the limit of 128 characters");
+        }
+        $this->mountProvider = $mountProvider;
+    }
 
-	/**
-	 * @return IUser
-	 */
-	public function getUser(): IUser {
-		return $this->user;
-	}
+    /**
+     * @return IUser
+     */
+    public function getUser(): IUser {
+        return $this->user;
+    }
 
-	/**
-	 * @return int the numeric storage id of the mount
-	 */
-	public function getStorageId(): int {
-		return $this->storageId;
-	}
+    /**
+     * @return int the numeric storage id of the mount
+     */
+    public function getStorageId(): int {
+        return $this->storageId;
+    }
 
-	/**
-	 * @return int the fileid of the root of the mount
-	 */
-	public function getRootId(): int {
-		return $this->rootId;
-	}
+    /**
+     * @return int the fileid of the root of the mount
+     */
+    public function getRootId(): int {
+        return $this->rootId;
+    }
 
-	/**
-	 * @return Node|null the root node of the mount
-	 */
-	public function getMountPointNode(): ?Node {
-		// TODO injection etc
-		Filesystem::initMountPoints($this->getUser()->getUID());
-		$userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
-		$nodes = $userNode->getParent()->getById($this->getRootId());
-		if (count($nodes) > 0) {
-			return $nodes[0];
-		} else {
-			return null;
-		}
-	}
+    /**
+     * @return Node|null the root node of the mount
+     */
+    public function getMountPointNode(): ?Node {
+        // TODO injection etc
+        Filesystem::initMountPoints($this->getUser()->getUID());
+        $userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
+        $nodes = $userNode->getParent()->getById($this->getRootId());
+        if (count($nodes) > 0) {
+            return $nodes[0];
+        } else {
+            return null;
+        }
+    }
 
-	/**
-	 * @return string the mount point of the mount for the user
-	 */
-	public function getMountPoint(): string {
-		return $this->mountPoint;
-	}
+    /**
+     * @return string the mount point of the mount for the user
+     */
+    public function getMountPoint(): string {
+        return $this->mountPoint;
+    }
 
-	/**
-	 * Get the id of the configured mount
-	 *
-	 * @return int|null mount id or null if not applicable
-	 * @since 9.1.0
-	 */
-	public function getMountId(): ?int {
-		return $this->mountId;
-	}
+    /**
+     * Get the id of the configured mount
+     *
+     * @return int|null mount id or null if not applicable
+     * @since 9.1.0
+     */
+    public function getMountId(): ?int {
+        return $this->mountId;
+    }
 
-	/**
-	 * Get the internal path (within the storage) of the root of the mount
-	 *
-	 * @return string
-	 */
-	public function getRootInternalPath(): string {
-		return $this->rootInternalPath;
-	}
+    /**
+     * Get the internal path (within the storage) of the root of the mount
+     *
+     * @return string
+     */
+    public function getRootInternalPath(): string {
+        return $this->rootInternalPath;
+    }
 
-	public function getMountProvider(): string {
-		return $this->mountProvider;
-	}
+    public function getMountProvider(): string {
+        return $this->mountProvider;
+    }
 }

lib/private/Files/Mount/Manager.php

Indentation +166 added lines, -166 removed lines

@@ -38,170 +38,170 @@
 use OCP\Files\NotFoundException;
 
 class Manager implements IMountManager {
-	/** @var MountPoint[] */
-	private array $mounts = [];
-	/** @var CappedMemoryCache<IMountPoint> */
-	private CappedMemoryCache $pathCache;
-	/** @var CappedMemoryCache<IMountPoint[]> */
-	private CappedMemoryCache $inPathCache;
-	private SetupManager $setupManager;
-
-	public function __construct(SetupManagerFactory $setupManagerFactory) {
-		$this->pathCache = new CappedMemoryCache();
-		$this->inPathCache = new CappedMemoryCache();
-		$this->setupManager = $setupManagerFactory->create($this);
-	}
-
-	/**
-	 * @param IMountPoint $mount
-	 */
-	public function addMount(IMountPoint $mount) {
-		$this->mounts[$mount->getMountPoint()] = $mount;
-		$this->pathCache->clear();
-		$this->inPathCache->clear();
-	}
-
-	/**
-	 * @param string $mountPoint
-	 */
-	public function removeMount(string $mountPoint) {
-		$mountPoint = Filesystem::normalizePath($mountPoint);
-		if (\strlen($mountPoint) > 1) {
-			$mountPoint .= '/';
-		}
-		unset($this->mounts[$mountPoint]);
-		$this->pathCache->clear();
-		$this->inPathCache->clear();
-	}
-
-	/**
-	 * @param string $mountPoint
-	 * @param string $target
-	 */
-	public function moveMount(string $mountPoint, string $target) {
-		$this->mounts[$target] = $this->mounts[$mountPoint];
-		unset($this->mounts[$mountPoint]);
-		$this->pathCache->clear();
-		$this->inPathCache->clear();
-	}
-
-	/**
-	 * Find the mount for $path
-	 *
-	 * @param string $path
-	 * @return IMountPoint
-	 */
-	public function find(string $path): IMountPoint {
-		$this->setupManager->setupForPath($path);
-		$path = Filesystem::normalizePath($path);
-
-		if (isset($this->pathCache[$path])) {
-			return $this->pathCache[$path];
-		}
-
-		$current = $path;
-		while (true) {
-			$mountPoint = $current . '/';
-			if (isset($this->mounts[$mountPoint])) {
-				$this->pathCache[$path] = $this->mounts[$mountPoint];
-				return $this->mounts[$mountPoint];
-			} elseif ($current === '') {
-				break;
-			}
-
-			$current = dirname($current);
-			if ($current === '.' || $current === '/') {
-				$current = '';
-			}
-		}
-
-		throw new NotFoundException("No mount for path " . $path . " existing mounts: " . implode(",", array_keys($this->mounts)));
-	}
-
-	/**
-	 * Find all mounts in $path
-	 *
-	 * @param string $path
-	 * @return IMountPoint[]
-	 */
-	public function findIn(string $path): array {
-		$this->setupManager->setupForPath($path);
-		$path = $this->formatPath($path);
-
-		if (isset($this->inPathCache[$path])) {
-			return $this->inPathCache[$path];
-		}
-
-		$result = [];
-		$pathLength = \strlen($path);
-		$mountPoints = array_keys($this->mounts);
-		foreach ($mountPoints as $mountPoint) {
-			if (substr($mountPoint, 0, $pathLength) === $path && \strlen($mountPoint) > $pathLength) {
-				$result[] = $this->mounts[$mountPoint];
-			}
-		}
-
-		$this->inPathCache[$path] = $result;
-		return $result;
-	}
-
-	public function clear() {
-		$this->mounts = [];
-		$this->pathCache->clear();
-		$this->inPathCache->clear();
-	}
-
-	/**
-	 * Find mounts by storage id
-	 *
-	 * @param string $id
-	 * @return IMountPoint[]
-	 */
-	public function findByStorageId(string $id): array {
-		\OC_Util::setupFS();
-		if (\strlen($id) > 64) {
-			$id = md5($id);
-		}
-		$result = [];
-		foreach ($this->mounts as $mount) {
-			if ($mount->getStorageId() === $id) {
-				$result[] = $mount;
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * @return IMountPoint[]
-	 */
-	public function getAll(): array {
-		return $this->mounts;
-	}
-
-	/**
-	 * Find mounts by numeric storage id
-	 *
-	 * @param int $id
-	 * @return IMountPoint[]
-	 */
-	public function findByNumericId(int $id): array {
-		$storageId = \OC\Files\Cache\Storage::getStorageId($id);
-		return $this->findByStorageId($storageId);
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	private function formatPath(string $path): string {
-		$path = Filesystem::normalizePath($path);
-		if (\strlen($path) > 1) {
-			$path .= '/';
-		}
-		return $path;
-	}
-
-	public function getSetupManager(): SetupManager {
-		return $this->setupManager;
-	}
+    /** @var MountPoint[] */
+    private array $mounts = [];
+    /** @var CappedMemoryCache<IMountPoint> */
+    private CappedMemoryCache $pathCache;
+    /** @var CappedMemoryCache<IMountPoint[]> */
+    private CappedMemoryCache $inPathCache;
+    private SetupManager $setupManager;
+
+    public function __construct(SetupManagerFactory $setupManagerFactory) {
+        $this->pathCache = new CappedMemoryCache();
+        $this->inPathCache = new CappedMemoryCache();
+        $this->setupManager = $setupManagerFactory->create($this);
+    }
+
+    /**
+     * @param IMountPoint $mount
+     */
+    public function addMount(IMountPoint $mount) {
+        $this->mounts[$mount->getMountPoint()] = $mount;
+        $this->pathCache->clear();
+        $this->inPathCache->clear();
+    }
+
+    /**
+     * @param string $mountPoint
+     */
+    public function removeMount(string $mountPoint) {
+        $mountPoint = Filesystem::normalizePath($mountPoint);
+        if (\strlen($mountPoint) > 1) {
+            $mountPoint .= '/';
+        }
+        unset($this->mounts[$mountPoint]);
+        $this->pathCache->clear();
+        $this->inPathCache->clear();
+    }
+
+    /**
+     * @param string $mountPoint
+     * @param string $target
+     */
+    public function moveMount(string $mountPoint, string $target) {
+        $this->mounts[$target] = $this->mounts[$mountPoint];
+        unset($this->mounts[$mountPoint]);
+        $this->pathCache->clear();
+        $this->inPathCache->clear();
+    }
+
+    /**
+     * Find the mount for $path
+     *
+     * @param string $path
+     * @return IMountPoint
+     */
+    public function find(string $path): IMountPoint {
+        $this->setupManager->setupForPath($path);
+        $path = Filesystem::normalizePath($path);
+
+        if (isset($this->pathCache[$path])) {
+            return $this->pathCache[$path];
+        }
+
+        $current = $path;
+        while (true) {
+            $mountPoint = $current . '/';
+            if (isset($this->mounts[$mountPoint])) {
+                $this->pathCache[$path] = $this->mounts[$mountPoint];
+                return $this->mounts[$mountPoint];
+            } elseif ($current === '') {
+                break;
+            }
+
+            $current = dirname($current);
+            if ($current === '.' || $current === '/') {
+                $current = '';
+            }
+        }
+
+        throw new NotFoundException("No mount for path " . $path . " existing mounts: " . implode(",", array_keys($this->mounts)));
+    }
+
+    /**
+     * Find all mounts in $path
+     *
+     * @param string $path
+     * @return IMountPoint[]
+     */
+    public function findIn(string $path): array {
+        $this->setupManager->setupForPath($path);
+        $path = $this->formatPath($path);
+
+        if (isset($this->inPathCache[$path])) {
+            return $this->inPathCache[$path];
+        }
+
+        $result = [];
+        $pathLength = \strlen($path);
+        $mountPoints = array_keys($this->mounts);
+        foreach ($mountPoints as $mountPoint) {
+            if (substr($mountPoint, 0, $pathLength) === $path && \strlen($mountPoint) > $pathLength) {
+                $result[] = $this->mounts[$mountPoint];
+            }
+        }
+
+        $this->inPathCache[$path] = $result;
+        return $result;
+    }
+
+    public function clear() {
+        $this->mounts = [];
+        $this->pathCache->clear();
+        $this->inPathCache->clear();
+    }
+
+    /**
+     * Find mounts by storage id
+     *
+     * @param string $id
+     * @return IMountPoint[]
+     */
+    public function findByStorageId(string $id): array {
+        \OC_Util::setupFS();
+        if (\strlen($id) > 64) {
+            $id = md5($id);
+        }
+        $result = [];
+        foreach ($this->mounts as $mount) {
+            if ($mount->getStorageId() === $id) {
+                $result[] = $mount;
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * @return IMountPoint[]
+     */
+    public function getAll(): array {
+        return $this->mounts;
+    }
+
+    /**
+     * Find mounts by numeric storage id
+     *
+     * @param int $id
+     * @return IMountPoint[]
+     */
+    public function findByNumericId(int $id): array {
+        $storageId = \OC\Files\Cache\Storage::getStorageId($id);
+        return $this->findByStorageId($storageId);
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    private function formatPath(string $path): string {
+        $path = Filesystem::normalizePath($path);
+        if (\strlen($path) > 1) {
+            $path .= '/';
+        }
+        return $path;
+    }
+
+    public function getSetupManager(): SetupManager {
+        return $this->setupManager;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -101,7 +101,7 @@ 
 
 		$current = $path;
 		while (true) {
-			$mountPoint = $current . '/';
+			$mountPoint = $current.'/';
 			if (isset($this->mounts[$mountPoint])) {
 				$this->pathCache[$path] = $this->mounts[$mountPoint];
 				return $this->mounts[$mountPoint];
@@ -115,7 +115,7 @@ 
 			}
 		}
 
-		throw new NotFoundException("No mount for path " . $path . " existing mounts: " . implode(",", array_keys($this->mounts)));
+		throw new NotFoundException("No mount for path ".$path." existing mounts: ".implode(",", array_keys($this->mounts)));
 	}
 
 	/**

lib/private/Files/SetupManager.php

Indentation +227 added lines, -227 removed lines

@@ -51,233 +51,233 @@
 use OCP\Lockdown\ILockdownManager;
 
 class SetupManager {
-	private bool $rootSetup = false;
-	private IEventLogger $eventLogger;
-	private MountProviderCollection $mountProviderCollection;
-	private IMountManager $mountManager;
-	private IUserManager $userManager;
-	private array $setupUsers = [];
-	private IEventDispatcher $eventDispatcher;
-	private IUserMountCache $userMountCache;
-	private ILockdownManager $lockdownManager;
-	private bool $listeningForProviders;
-
-	public function __construct(
-		IEventLogger $eventLogger,
-		MountProviderCollection $mountProviderCollection,
-		IMountManager $mountManager,
-		IUserManager $userManager,
-		IEventDispatcher $eventDispatcher,
-		IUserMountCache $userMountCache,
-		ILockdownManager $lockdownManager
-	) {
-		$this->eventLogger = $eventLogger;
-		$this->mountProviderCollection = $mountProviderCollection;
-		$this->mountManager = $mountManager;
-		$this->userManager = $userManager;
-		$this->eventDispatcher = $eventDispatcher;
-		$this->userMountCache = $userMountCache;
-		$this->lockdownManager = $lockdownManager;
-		$this->listeningForProviders = false;
-	}
-
-	private function setupBuiltinWrappers() {
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($storage->instanceOfStorage(Common::class)) {
-				$storage->setMountOptions($mount->getOptions());
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if (!$mount->getOption('enable_sharing', true)) {
-				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) {
-			if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$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) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
-				return new Encoding(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
-			// set up quota for home storages, even for other users
-			// which can happen when using sharing
-
-			/**
-			 * @var Storage $storage
-			 */
-			if ($storage->instanceOfStorage(HomeObjectStoreStorage::class) || $storage->instanceOfStorage(Home::class)) {
-				if (is_object($storage->getUser())) {
-					$quota = OC_Util::getUserQuota($storage->getUser());
-					if ($quota !== \OCP\Files\FileInfo::SPACE_UNLIMITED) {
-						return new Quota(['storage' => $storage, 'quota' => $quota, 'root' => 'files']);
-					}
-				}
-			}
-
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			/*
+    private bool $rootSetup = false;
+    private IEventLogger $eventLogger;
+    private MountProviderCollection $mountProviderCollection;
+    private IMountManager $mountManager;
+    private IUserManager $userManager;
+    private array $setupUsers = [];
+    private IEventDispatcher $eventDispatcher;
+    private IUserMountCache $userMountCache;
+    private ILockdownManager $lockdownManager;
+    private bool $listeningForProviders;
+
+    public function __construct(
+        IEventLogger $eventLogger,
+        MountProviderCollection $mountProviderCollection,
+        IMountManager $mountManager,
+        IUserManager $userManager,
+        IEventDispatcher $eventDispatcher,
+        IUserMountCache $userMountCache,
+        ILockdownManager $lockdownManager
+    ) {
+        $this->eventLogger = $eventLogger;
+        $this->mountProviderCollection = $mountProviderCollection;
+        $this->mountManager = $mountManager;
+        $this->userManager = $userManager;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->userMountCache = $userMountCache;
+        $this->lockdownManager = $lockdownManager;
+        $this->listeningForProviders = false;
+    }
+
+    private function setupBuiltinWrappers() {
+        Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($storage->instanceOfStorage(Common::class)) {
+                $storage->setMountOptions($mount->getOptions());
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if (!$mount->getOption('enable_sharing', true)) {
+                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) {
+            if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$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) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
+                return new Encoding(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
+            // set up quota for home storages, even for other users
+            // which can happen when using sharing
+
+            /**
+             * @var Storage $storage
+             */
+            if ($storage->instanceOfStorage(HomeObjectStoreStorage::class) || $storage->instanceOfStorage(Home::class)) {
+                if (is_object($storage->getUser())) {
+                    $quota = OC_Util::getUserQuota($storage->getUser());
+                    if ($quota !== \OCP\Files\FileInfo::SPACE_UNLIMITED) {
+                        return new Quota(['storage' => $storage, 'quota' => $quota, 'root' => 'files']);
+                    }
+                }
+            }
+
+            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;
-		});
-	}
-
-	/**
-	 * Setup the full filesystem for the specified user
-	 */
-	public function setupForUser(IUser $user): void {
-		$this->setupRoot();
-
-		if (in_array($user->getUID(), $this->setupUsers, true)) {
-			return;
-		}
-		$this->setupUsers[] = $user->getUID();
-
-		$this->eventLogger->start('setup_fs', 'Setup filesystem');
-
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-
-		$userDir = '/' . $user->getUID() . '/files';
-
-		Filesystem::init($user, $userDir);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			// 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) {
-				$homeMount->getStorage()->mkdir('');
-				$homeMount->getStorage()->getScanner()->scan('');
-			}
-
-			// Chance to mount for other storages
-			$mounts = $this->mountProviderCollection->addMountForUser($user, $this->mountManager);
-			$mounts[] = $homeMount;
-			$this->userMountCache->registerMounts($user, $mounts);
-
-			$this->listenForNewMountProviders();
-		} else {
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID()
-			));
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
-			));
-		}
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
-
-		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
-
-		$this->eventLogger->end('setup_fs');
-	}
-
-	/**
-	 * Set up the root filesystem
-	 */
-	public function setupRoot(): void {
-		//setting up the filesystem twice can only lead to trouble
-		if ($this->rootSetup) {
-			return;
-		}
-		$this->rootSetup = true;
-
-		$this->eventLogger->start('setup_root_fs', 'Setup root filesystem');
-
-		// load all filesystem apps before, so no setup-hook gets lost
-		OC_App::loadApps(['filesystem']);
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		$this->setupBuiltinWrappers();
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-
-		$rootMounts = $this->mountProviderCollection->getRootMounts();
-		foreach ($rootMounts as $rootMountProvider) {
-			$this->mountManager->addMount($rootMountProvider);
-		}
-
-		$this->eventLogger->end('setup_root_fs');
-	}
-
-	/**
-	 * Set up the filesystem for the specified path
-	 */
-	public function setupForPath(string $path): void {
-		if (substr_count($path, '/') < 2 || strpos($path, '/appdata_' . \OC_Util::getInstanceId()) === 0 || strpos($path, '/files_external/') === 0) {
-			$this->setupRoot();
-			return;
-		} else {
-			[, $userId] = explode('/', $path);
-		}
-
-		$user = $this->userManager->get($userId);
-
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		$this->setupForUser($user);
-	}
-
-	public function tearDown() {
-		$this->setupUsers = [];
-		$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']);
-					}
-				}
-			});
-		}
-	}
+            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;
+        });
+    }
+
+    /**
+     * Setup the full filesystem for the specified user
+     */
+    public function setupForUser(IUser $user): void {
+        $this->setupRoot();
+
+        if (in_array($user->getUID(), $this->setupUsers, true)) {
+            return;
+        }
+        $this->setupUsers[] = $user->getUID();
+
+        $this->eventLogger->start('setup_fs', 'Setup filesystem');
+
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+
+        $userDir = '/' . $user->getUID() . '/files';
+
+        Filesystem::init($user, $userDir);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            // 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) {
+                $homeMount->getStorage()->mkdir('');
+                $homeMount->getStorage()->getScanner()->scan('');
+            }
+
+            // Chance to mount for other storages
+            $mounts = $this->mountProviderCollection->addMountForUser($user, $this->mountManager);
+            $mounts[] = $homeMount;
+            $this->userMountCache->registerMounts($user, $mounts);
+
+            $this->listenForNewMountProviders();
+        } else {
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID()
+            ));
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID() . '/files'
+            ));
+        }
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
+
+        OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
+
+        $this->eventLogger->end('setup_fs');
+    }
+
+    /**
+     * Set up the root filesystem
+     */
+    public function setupRoot(): void {
+        //setting up the filesystem twice can only lead to trouble
+        if ($this->rootSetup) {
+            return;
+        }
+        $this->rootSetup = true;
+
+        $this->eventLogger->start('setup_root_fs', 'Setup root filesystem');
+
+        // load all filesystem apps before, so no setup-hook gets lost
+        OC_App::loadApps(['filesystem']);
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        $this->setupBuiltinWrappers();
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+
+        $rootMounts = $this->mountProviderCollection->getRootMounts();
+        foreach ($rootMounts as $rootMountProvider) {
+            $this->mountManager->addMount($rootMountProvider);
+        }
+
+        $this->eventLogger->end('setup_root_fs');
+    }
+
+    /**
+     * Set up the filesystem for the specified path
+     */
+    public function setupForPath(string $path): void {
+        if (substr_count($path, '/') < 2 || strpos($path, '/appdata_' . \OC_Util::getInstanceId()) === 0 || strpos($path, '/files_external/') === 0) {
+            $this->setupRoot();
+            return;
+        } else {
+            [, $userId] = explode('/', $path);
+        }
+
+        $user = $this->userManager->get($userId);
+
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        $this->setupForUser($user);
+    }
+
+    public function tearDown() {
+        $this->setupUsers = [];
+        $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']);
+                    }
+                }
+            });
+        }
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -82,14 +82,14 @@ 
 	}
 
 	private function setupBuiltinWrappers() {
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('mount_options', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($storage->instanceOfStorage(Common::class)) {
 				$storage->setMountOptions($mount->getOptions());
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('enable_sharing', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('enable_sharing', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if (!$mount->getOption('enable_sharing', true)) {
 				return new PermissionsMask([
 					'storage' => $storage,
@@ -100,21 +100,21 @@ 
 		});
 
 		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage) {
+		Filesystem::addStorageWrapper('oc_availability', function($mountPoint, IStorage $storage) {
 			if (!$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
 				return new Availability(['storage' => $storage]);
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('oc_encoding', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($mount->getOption('encoding_compatibility', false) && !$storage->instanceOfStorage('\OCA\Files_Sharing\SharedStorage') && !$storage->isLocal()) {
 				return new Encoding(['storage' => $storage]);
 			}
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage) {
+		Filesystem::addStorageWrapper('oc_quota', function($mountPoint, $storage) {
 			// set up quota for home storages, even for other users
 			// which can happen when using sharing
 
@@ -133,7 +133,7 @@ 
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('readonly', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			/*
 			 * Do not allow any operations that modify the storage
 			 */
@@ -170,7 +170,7 @@ 
 
 		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
 
-		$userDir = '/' . $user->getUID() . '/files';
+		$userDir = '/'.$user->getUID().'/files';
 
 		Filesystem::init($user, $userDir);
 
@@ -193,11 +193,11 @@ 
 		} else {
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID()
+				'/'.$user->getUID()
 			));
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
+				'/'.$user->getUID().'/files'
 			));
 		}
 		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
@@ -239,7 +239,7 @@ 
 	 * Set up the filesystem for the specified path
 	 */
 	public function setupForPath(string $path): void {
-		if (substr_count($path, '/') < 2 || strpos($path, '/appdata_' . \OC_Util::getInstanceId()) === 0 || strpos($path, '/files_external/') === 0) {
+		if (substr_count($path, '/') < 2 || strpos($path, '/appdata_'.\OC_Util::getInstanceId()) === 0 || strpos($path, '/files_external/') === 0) {
 			$this->setupRoot();
 			return;
 		} else {
@@ -269,7 +269,7 @@ 
 	private function listenForNewMountProviders() {
 		if (!$this->listeningForProviders) {
 			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (IMountProvider $provider) {
+			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function(IMountProvider $provider) {
 				foreach ($this->setupUsers as $userId) {
 					$user = $this->userManager->get($userId);
 					if ($user) {

lib/private/Files/Filesystem.php

Indentation +740 added lines, -740 removed lines

@@ -49,744 +49,744 @@
 
 class Filesystem {
 
-	/**
-	 * @var Mount\Manager $mounts
-	 */
-	private static $mounts;
-
-	public static $loaded = false;
-	/**
-	 * @var \OC\Files\View $defaultInstance
-	 */
-	private static $defaultInstance;
-
-	private static $usersSetup = [];
-
-	private static $normalizedPathCache = null;
-
-	private static $listeningForProviders = false;
-
-	/**
-	 * classname which used for hooks handling
-	 * used as signalclass in OC_Hooks::emit()
-	 */
-	public const CLASSNAME = 'OC_Filesystem';
-
-	/**
-	 * signalname emitted before file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_rename = 'rename';
-
-	/**
-	 * signal emitted after file renaming
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_post_rename = 'post_rename';
-
-	/**
-	 * signal emitted before file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_create = 'create';
-
-	/**
-	 * signal emitted after file/dir creation
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_post_create = 'post_create';
-
-	/**
-	 * signal emits before file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_copy = 'copy';
-
-	/**
-	 * signal emits after file/dir copy
-	 *
-	 * @param string $oldpath
-	 * @param string $newpath
-	 */
-	public const signal_post_copy = 'post_copy';
-
-	/**
-	 * signal emits before file/dir save
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_write = 'write';
-
-	/**
-	 * signal emits after file/dir save
-	 *
-	 * @param string $path
-	 */
-	public const signal_post_write = 'post_write';
-
-	/**
-	 * signal emitted before file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_update = 'update';
-
-	/**
-	 * signal emitted after file/dir update
-	 *
-	 * @param string $path
-	 * @param bool $run changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_post_update = 'post_update';
-
-	/**
-	 * signal emits when reading file/dir
-	 *
-	 * @param string $path
-	 */
-	public const signal_read = 'read';
-
-	/**
-	 * signal emits when removing file/dir
-	 *
-	 * @param string $path
-	 */
-	public const signal_delete = 'delete';
-
-	/**
-	 * parameters definitions for signals
-	 */
-	public const signal_param_path = 'path';
-	public const signal_param_oldpath = 'oldpath';
-	public const signal_param_newpath = 'newpath';
-
-	/**
-	 * run - changing this flag to false in hook handler will cancel event
-	 */
-	public const signal_param_run = 'run';
-
-	public const signal_create_mount = 'create_mount';
-	public const signal_delete_mount = 'delete_mount';
-	public const signal_param_mount_type = 'mounttype';
-	public const signal_param_users = 'users';
-
-	/**
-	 * @var \OC\Files\Storage\StorageFactory $loader
-	 */
-	private static $loader;
-
-	/** @var bool */
-	private static $logWarningWhenAddingStorageWrapper = true;
-
-	/**
-	 * @param bool $shouldLog
-	 * @return bool previous value
-	 * @internal
-	 */
-	public static function logWarningWhenAddingStorageWrapper($shouldLog) {
-		$previousValue = self::$logWarningWhenAddingStorageWrapper;
-		self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
-		return $previousValue;
-	}
-
-	/**
-	 * @param string $wrapperName
-	 * @param callable $wrapper
-	 * @param int $priority
-	 */
-	public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
-		if (self::$logWarningWhenAddingStorageWrapper) {
-			\OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
-				'wrapper' => $wrapperName,
-				'app' => 'filesystem',
-			]);
-		}
-
-		$mounts = self::getMountManager()->getAll();
-		if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
-			// do not re-wrap if storage with this name already existed
-			return;
-		}
-	}
-
-	/**
-	 * Returns the storage factory
-	 *
-	 * @return IStorageFactory
-	 */
-	public static function getLoader() {
-		if (!self::$loader) {
-			self::$loader = \OC::$server->query(IStorageFactory::class);
-		}
-		return self::$loader;
-	}
-
-	/**
-	 * Returns the mount manager
-	 *
-	 * @return \OC\Files\Mount\Manager
-	 */
-	public static function getMountManager($user = '') {
-		self::initMountManager();
-		return self::$mounts;
-	}
-
-	/**
-	 * get the mountpoint of the storage object for a path
-	 * ( note: because a storage is not always mounted inside the fakeroot, the
-	 * returned mountpoint is relative to the absolute root of the filesystem
-	 * and doesn't take the chroot into account )
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getMountPoint($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = self::$mounts->find($path);
-		return $mount->getMountPoint();
-	}
-
-	/**
-	 * get a list of all mount points in a directory
-	 *
-	 * @param string $path
-	 * @return string[]
-	 */
-	public static function getMountPoints($path) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$result = [];
-		$mounts = self::$mounts->findIn($path);
-		foreach ($mounts as $mount) {
-			$result[] = $mount->getMountPoint();
-		}
-		return $result;
-	}
-
-	/**
-	 * get the storage mounted at $mountPoint
-	 *
-	 * @param string $mountPoint
-	 * @return \OC\Files\Storage\Storage|null
-	 */
-	public static function getStorage($mountPoint) {
-		$mount = self::getMountManager()->find($mountPoint);
-		return $mount->getStorage();
-	}
-
-	/**
-	 * @param string $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByStorageId($id) {
-		return self::getMountManager()->findByStorageId($id);
-	}
-
-	/**
-	 * @param int $id
-	 * @return Mount\MountPoint[]
-	 */
-	public static function getMountByNumericId($id) {
-		return self::getMountManager()->findByNumericId($id);
-	}
-
-	/**
-	 * resolve a path to a storage and internal path
-	 *
-	 * @param string $path
-	 * @return array an array consisting of the storage and the internal path
-	 */
-	public static function resolvePath($path) {
-		$mount = self::getMountManager()->find($path);
-		return [$mount->getStorage(), rtrim($mount->getInternalPath($path), '/')];
-	}
-
-	public static function init($user, $root) {
-		if (self::$defaultInstance) {
-			return false;
-		}
-		self::getLoader();
-		self::$defaultInstance = new View($root);
-		/** @var IEventDispatcher $eventDispatcher */
-		$eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
-			self::$defaultInstance = null;
-			self::$usersSetup = [];
-			self::$loaded = false;
-		});
-
-		if (!self::$mounts) {
-			self::$mounts = \OC::$server->getMountManager();
-		}
-
-		//load custom mount config
-		self::initMountPoints($user);
-
-		self::$loaded = true;
-
-		return true;
-	}
-
-	public static function initMountManager() {
-		if (!self::$mounts) {
-			self::$mounts = \OC::$server->getMountManager();
-		}
-	}
-
-	/**
-	 * Initialize system and personal mount points for a user
-	 *
-	 * @param string|IUser|null $user
-	 * @throws \OC\User\NoUserException if the user is not available
-	 */
-	public static function initMountPoints($user = '') {
-		/** @var IUserManager $userManager */
-		$userManager = \OC::$server->get(IUserManager::class);
-
-		$userObject = ($user instanceof IUser) ? $user : $userManager->get($user);
-		if ($userObject) {
-			/** @var SetupManager $setupManager */
-			$setupManager = \OC::$server->get(SetupManager::class);
-			$setupManager->setupForUser($userObject);
-		} else {
-			throw new NoUserException();
-		}
-	}
-
-	/**
-	 * get the default filesystem view
-	 *
-	 * @return View
-	 */
-	public static function getView() {
-		return self::$defaultInstance;
-	}
-
-	/**
-	 * tear down the filesystem, removing all storage providers
-	 */
-	public static function tearDown() {
-		\OC_Util::tearDownFS();
-	}
-
-	/**
-	 * get the relative path of the root data directory for the current user
-	 *
-	 * @return string
-	 *
-	 * Returns path like /admin/files
-	 */
-	public static function getRoot() {
-		if (!self::$defaultInstance) {
-			return null;
-		}
-		return self::$defaultInstance->getRoot();
-	}
-
-	/**
-	 * mount an \OC\Files\Storage\Storage in our virtual filesystem
-	 *
-	 * @param \OC\Files\Storage\Storage|string $class
-	 * @param array $arguments
-	 * @param string $mountpoint
-	 */
-	public static function mount($class, $arguments, $mountpoint) {
-		if (!self::$mounts) {
-			\OC_Util::setupFS();
-		}
-		$mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
-		self::$mounts->addMount($mount);
-	}
-
-	/**
-	 * return the path to a local version of the file
-	 * we need this because we can't know if a file is stored local or not from
-	 * outside the filestorage and for some purposes a local file is needed
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getLocalFile($path) {
-		return self::$defaultInstance->getLocalFile($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getLocalFolder($path) {
-		return self::$defaultInstance->getLocalFolder($path);
-	}
-
-	/**
-	 * return path to file which reflects one visible in browser
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
-		$newpath = $path;
-		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
-			$newpath = substr($path, strlen($datadir));
-		}
-		return $newpath;
-	}
-
-	/**
-	 * check if the requested path is valid
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	public static function isValidPath($path) {
-		$path = self::normalizePath($path);
-		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
-		}
-		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * checks if a file is blacklisted for storage in the filesystem
-	 * Listens to write and rename hooks
-	 *
-	 * @param array $data from hook
-	 */
-	public static function isBlacklisted($data) {
-		if (isset($data['path'])) {
-			$path = $data['path'];
-		} elseif (isset($data['newpath'])) {
-			$path = $data['newpath'];
-		}
-		if (isset($path)) {
-			if (self::isFileBlacklisted($path)) {
-				$data['run'] = false;
-			}
-		}
-	}
-
-	/**
-	 * @param string $filename
-	 * @return bool
-	 */
-	public static function isFileBlacklisted($filename) {
-		$filename = self::normalizePath($filename);
-
-		$blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', ['.htaccess']);
-		$filename = strtolower(basename($filename));
-		return in_array($filename, $blacklist);
-	}
-
-	/**
-	 * check if the directory should be ignored when scanning
-	 * NOTE: the special directories . and .. would cause never ending recursion
-	 *
-	 * @param string $dir
-	 * @return boolean
-	 */
-	public static function isIgnoredDir($dir) {
-		if ($dir === '.' || $dir === '..') {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * following functions are equivalent to their php builtin equivalents for arguments/return values.
-	 */
-	public static function mkdir($path) {
-		return self::$defaultInstance->mkdir($path);
-	}
-
-	public static function rmdir($path) {
-		return self::$defaultInstance->rmdir($path);
-	}
-
-	public static function is_dir($path) {
-		return self::$defaultInstance->is_dir($path);
-	}
-
-	public static function is_file($path) {
-		return self::$defaultInstance->is_file($path);
-	}
-
-	public static function stat($path) {
-		return self::$defaultInstance->stat($path);
-	}
-
-	public static function filetype($path) {
-		return self::$defaultInstance->filetype($path);
-	}
-
-	public static function filesize($path) {
-		return self::$defaultInstance->filesize($path);
-	}
-
-	public static function readfile($path) {
-		return self::$defaultInstance->readfile($path);
-	}
-
-	public static function isCreatable($path) {
-		return self::$defaultInstance->isCreatable($path);
-	}
-
-	public static function isReadable($path) {
-		return self::$defaultInstance->isReadable($path);
-	}
-
-	public static function isUpdatable($path) {
-		return self::$defaultInstance->isUpdatable($path);
-	}
-
-	public static function isDeletable($path) {
-		return self::$defaultInstance->isDeletable($path);
-	}
-
-	public static function isSharable($path) {
-		return self::$defaultInstance->isSharable($path);
-	}
-
-	public static function file_exists($path) {
-		return self::$defaultInstance->file_exists($path);
-	}
-
-	public static function filemtime($path) {
-		return self::$defaultInstance->filemtime($path);
-	}
-
-	public static function touch($path, $mtime = null) {
-		return self::$defaultInstance->touch($path, $mtime);
-	}
-
-	/**
-	 * @return string
-	 */
-	public static function file_get_contents($path) {
-		return self::$defaultInstance->file_get_contents($path);
-	}
-
-	public static function file_put_contents($path, $data) {
-		return self::$defaultInstance->file_put_contents($path, $data);
-	}
-
-	public static function unlink($path) {
-		return self::$defaultInstance->unlink($path);
-	}
-
-	public static function rename($path1, $path2) {
-		return self::$defaultInstance->rename($path1, $path2);
-	}
-
-	public static function copy($path1, $path2) {
-		return self::$defaultInstance->copy($path1, $path2);
-	}
-
-	public static function fopen($path, $mode) {
-		return self::$defaultInstance->fopen($path, $mode);
-	}
-
-	/**
-	 * @return string
-	 */
-	public static function toTmpFile($path) {
-		return self::$defaultInstance->toTmpFile($path);
-	}
-
-	public static function fromTmpFile($tmpFile, $path) {
-		return self::$defaultInstance->fromTmpFile($tmpFile, $path);
-	}
-
-	public static function getMimeType($path) {
-		return self::$defaultInstance->getMimeType($path);
-	}
-
-	public static function hash($type, $path, $raw = false) {
-		return self::$defaultInstance->hash($type, $path, $raw);
-	}
-
-	public static function free_space($path = '/') {
-		return self::$defaultInstance->free_space($path);
-	}
-
-	public static function search($query) {
-		return self::$defaultInstance->search($query);
-	}
-
-	/**
-	 * @param string $query
-	 */
-	public static function searchByMime($query) {
-		return self::$defaultInstance->searchByMime($query);
-	}
-
-	/**
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return FileInfo[] array or file info
-	 */
-	public static function searchByTag($tag, $userId) {
-		return self::$defaultInstance->searchByTag($tag, $userId);
-	}
-
-	/**
-	 * check if a file or folder has been updated since $time
-	 *
-	 * @param string $path
-	 * @param int $time
-	 * @return bool
-	 */
-	public static function hasUpdated($path, $time) {
-		return self::$defaultInstance->hasUpdated($path, $time);
-	}
-
-	/**
-	 * Fix common problems with a file path
-	 *
-	 * @param string $path
-	 * @param bool $stripTrailingSlash whether to strip the trailing slash
-	 * @param bool $isAbsolutePath whether the given path is absolute
-	 * @param bool $keepUnicode true to disable unicode normalization
-	 * @return string
-	 */
-	public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
-		/**
-		 * FIXME: This is a workaround for existing classes and files which call
-		 *        this function with another type than a valid string. This
-		 *        conversion should get removed as soon as all existing
-		 *        function calls have been fixed.
-		 */
-		$path = (string)$path;
-
-		if ($path === '') {
-			return '/';
-		}
-
-		if (is_null(self::$normalizedPathCache)) {
-			self::$normalizedPathCache = new CappedMemoryCache(2048);
-		}
-
-		$cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
-
-		if ($cacheKey && isset(self::$normalizedPathCache[$cacheKey])) {
-			return self::$normalizedPathCache[$cacheKey];
-		}
-
-		//normalize unicode if possible
-		if (!$keepUnicode) {
-			$path = \OC_Util::normalizeUnicode($path);
-		}
-
-		//add leading slash, if it is already there we strip it anyway
-		$path = '/' . $path;
-
-		$patterns = [
-			'#\\\\#s',       // no windows style '\\' slashes
-			'#/\.(/\.)*/#s', // remove '/./'
-			'#\//+#s',       // remove sequence of slashes
-			'#/\.$#s',       // remove trailing '/.'
-		];
-
-		do {
-			$count = 0;
-			$path = preg_replace($patterns, '/', $path, -1, $count);
-		} while ($count > 0);
-
-		//remove trailing slash
-		if ($stripTrailingSlash && strlen($path) > 1) {
-			$path = rtrim($path, '/');
-		}
-
-		self::$normalizedPathCache[$cacheKey] = $path;
-
-		return $path;
-	}
-
-	/**
-	 * get the filesystem info
-	 *
-	 * @param string $path
-	 * @param boolean $includeMountPoints whether to add mountpoint sizes,
-	 * defaults to true
-	 * @return \OC\Files\FileInfo|false False if file does not exist
-	 */
-	public static function getFileInfo($path, $includeMountPoints = true) {
-		return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
-	}
-
-	/**
-	 * change file metadata
-	 *
-	 * @param string $path
-	 * @param array $data
-	 * @return int
-	 *
-	 * returns the fileid of the updated file
-	 */
-	public static function putFileInfo($path, $data) {
-		return self::$defaultInstance->putFileInfo($path, $data);
-	}
-
-	/**
-	 * get the content of a directory
-	 *
-	 * @param string $directory path under datadirectory
-	 * @param string $mimetype_filter limit returned content to this mimetype or mimepart
-	 * @return \OC\Files\FileInfo[]
-	 */
-	public static function getDirectoryContent($directory, $mimetype_filter = '') {
-		return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
-	}
-
-	/**
-	 * Get the path of a file by id
-	 *
-	 * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
-	 *
-	 * @param int $id
-	 * @throws NotFoundException
-	 * @return string
-	 */
-	public static function getPath($id) {
-		return self::$defaultInstance->getPath($id);
-	}
-
-	/**
-	 * Get the owner for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getOwner($path) {
-		return self::$defaultInstance->getOwner($path);
-	}
-
-	/**
-	 * get the ETag for a file or folder
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public static function getETag($path) {
-		return self::$defaultInstance->getETag($path);
-	}
+    /**
+     * @var Mount\Manager $mounts
+     */
+    private static $mounts;
+
+    public static $loaded = false;
+    /**
+     * @var \OC\Files\View $defaultInstance
+     */
+    private static $defaultInstance;
+
+    private static $usersSetup = [];
+
+    private static $normalizedPathCache = null;
+
+    private static $listeningForProviders = false;
+
+    /**
+     * classname which used for hooks handling
+     * used as signalclass in OC_Hooks::emit()
+     */
+    public const CLASSNAME = 'OC_Filesystem';
+
+    /**
+     * signalname emitted before file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_rename = 'rename';
+
+    /**
+     * signal emitted after file renaming
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_post_rename = 'post_rename';
+
+    /**
+     * signal emitted before file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_create = 'create';
+
+    /**
+     * signal emitted after file/dir creation
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_post_create = 'post_create';
+
+    /**
+     * signal emits before file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_copy = 'copy';
+
+    /**
+     * signal emits after file/dir copy
+     *
+     * @param string $oldpath
+     * @param string $newpath
+     */
+    public const signal_post_copy = 'post_copy';
+
+    /**
+     * signal emits before file/dir save
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_write = 'write';
+
+    /**
+     * signal emits after file/dir save
+     *
+     * @param string $path
+     */
+    public const signal_post_write = 'post_write';
+
+    /**
+     * signal emitted before file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_update = 'update';
+
+    /**
+     * signal emitted after file/dir update
+     *
+     * @param string $path
+     * @param bool $run changing this flag to false in hook handler will cancel event
+     */
+    public const signal_post_update = 'post_update';
+
+    /**
+     * signal emits when reading file/dir
+     *
+     * @param string $path
+     */
+    public const signal_read = 'read';
+
+    /**
+     * signal emits when removing file/dir
+     *
+     * @param string $path
+     */
+    public const signal_delete = 'delete';
+
+    /**
+     * parameters definitions for signals
+     */
+    public const signal_param_path = 'path';
+    public const signal_param_oldpath = 'oldpath';
+    public const signal_param_newpath = 'newpath';
+
+    /**
+     * run - changing this flag to false in hook handler will cancel event
+     */
+    public const signal_param_run = 'run';
+
+    public const signal_create_mount = 'create_mount';
+    public const signal_delete_mount = 'delete_mount';
+    public const signal_param_mount_type = 'mounttype';
+    public const signal_param_users = 'users';
+
+    /**
+     * @var \OC\Files\Storage\StorageFactory $loader
+     */
+    private static $loader;
+
+    /** @var bool */
+    private static $logWarningWhenAddingStorageWrapper = true;
+
+    /**
+     * @param bool $shouldLog
+     * @return bool previous value
+     * @internal
+     */
+    public static function logWarningWhenAddingStorageWrapper($shouldLog) {
+        $previousValue = self::$logWarningWhenAddingStorageWrapper;
+        self::$logWarningWhenAddingStorageWrapper = (bool) $shouldLog;
+        return $previousValue;
+    }
+
+    /**
+     * @param string $wrapperName
+     * @param callable $wrapper
+     * @param int $priority
+     */
+    public static function addStorageWrapper($wrapperName, $wrapper, $priority = 50) {
+        if (self::$logWarningWhenAddingStorageWrapper) {
+            \OC::$server->getLogger()->warning("Storage wrapper '{wrapper}' was not registered via the 'OC_Filesystem - preSetup' hook which could cause potential problems.", [
+                'wrapper' => $wrapperName,
+                'app' => 'filesystem',
+            ]);
+        }
+
+        $mounts = self::getMountManager()->getAll();
+        if (!self::getLoader()->addStorageWrapper($wrapperName, $wrapper, $priority, $mounts)) {
+            // do not re-wrap if storage with this name already existed
+            return;
+        }
+    }
+
+    /**
+     * Returns the storage factory
+     *
+     * @return IStorageFactory
+     */
+    public static function getLoader() {
+        if (!self::$loader) {
+            self::$loader = \OC::$server->query(IStorageFactory::class);
+        }
+        return self::$loader;
+    }
+
+    /**
+     * Returns the mount manager
+     *
+     * @return \OC\Files\Mount\Manager
+     */
+    public static function getMountManager($user = '') {
+        self::initMountManager();
+        return self::$mounts;
+    }
+
+    /**
+     * get the mountpoint of the storage object for a path
+     * ( note: because a storage is not always mounted inside the fakeroot, the
+     * returned mountpoint is relative to the absolute root of the filesystem
+     * and doesn't take the chroot into account )
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getMountPoint($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = self::$mounts->find($path);
+        return $mount->getMountPoint();
+    }
+
+    /**
+     * get a list of all mount points in a directory
+     *
+     * @param string $path
+     * @return string[]
+     */
+    public static function getMountPoints($path) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $result = [];
+        $mounts = self::$mounts->findIn($path);
+        foreach ($mounts as $mount) {
+            $result[] = $mount->getMountPoint();
+        }
+        return $result;
+    }
+
+    /**
+     * get the storage mounted at $mountPoint
+     *
+     * @param string $mountPoint
+     * @return \OC\Files\Storage\Storage|null
+     */
+    public static function getStorage($mountPoint) {
+        $mount = self::getMountManager()->find($mountPoint);
+        return $mount->getStorage();
+    }
+
+    /**
+     * @param string $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByStorageId($id) {
+        return self::getMountManager()->findByStorageId($id);
+    }
+
+    /**
+     * @param int $id
+     * @return Mount\MountPoint[]
+     */
+    public static function getMountByNumericId($id) {
+        return self::getMountManager()->findByNumericId($id);
+    }
+
+    /**
+     * resolve a path to a storage and internal path
+     *
+     * @param string $path
+     * @return array an array consisting of the storage and the internal path
+     */
+    public static function resolvePath($path) {
+        $mount = self::getMountManager()->find($path);
+        return [$mount->getStorage(), rtrim($mount->getInternalPath($path), '/')];
+    }
+
+    public static function init($user, $root) {
+        if (self::$defaultInstance) {
+            return false;
+        }
+        self::getLoader();
+        self::$defaultInstance = new View($root);
+        /** @var IEventDispatcher $eventDispatcher */
+        $eventDispatcher = \OC::$server->get(IEventDispatcher::class);
+        $eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+            self::$defaultInstance = null;
+            self::$usersSetup = [];
+            self::$loaded = false;
+        });
+
+        if (!self::$mounts) {
+            self::$mounts = \OC::$server->getMountManager();
+        }
+
+        //load custom mount config
+        self::initMountPoints($user);
+
+        self::$loaded = true;
+
+        return true;
+    }
+
+    public static function initMountManager() {
+        if (!self::$mounts) {
+            self::$mounts = \OC::$server->getMountManager();
+        }
+    }
+
+    /**
+     * Initialize system and personal mount points for a user
+     *
+     * @param string|IUser|null $user
+     * @throws \OC\User\NoUserException if the user is not available
+     */
+    public static function initMountPoints($user = '') {
+        /** @var IUserManager $userManager */
+        $userManager = \OC::$server->get(IUserManager::class);
+
+        $userObject = ($user instanceof IUser) ? $user : $userManager->get($user);
+        if ($userObject) {
+            /** @var SetupManager $setupManager */
+            $setupManager = \OC::$server->get(SetupManager::class);
+            $setupManager->setupForUser($userObject);
+        } else {
+            throw new NoUserException();
+        }
+    }
+
+    /**
+     * get the default filesystem view
+     *
+     * @return View
+     */
+    public static function getView() {
+        return self::$defaultInstance;
+    }
+
+    /**
+     * tear down the filesystem, removing all storage providers
+     */
+    public static function tearDown() {
+        \OC_Util::tearDownFS();
+    }
+
+    /**
+     * get the relative path of the root data directory for the current user
+     *
+     * @return string
+     *
+     * Returns path like /admin/files
+     */
+    public static function getRoot() {
+        if (!self::$defaultInstance) {
+            return null;
+        }
+        return self::$defaultInstance->getRoot();
+    }
+
+    /**
+     * mount an \OC\Files\Storage\Storage in our virtual filesystem
+     *
+     * @param \OC\Files\Storage\Storage|string $class
+     * @param array $arguments
+     * @param string $mountpoint
+     */
+    public static function mount($class, $arguments, $mountpoint) {
+        if (!self::$mounts) {
+            \OC_Util::setupFS();
+        }
+        $mount = new Mount\MountPoint($class, $mountpoint, $arguments, self::getLoader());
+        self::$mounts->addMount($mount);
+    }
+
+    /**
+     * return the path to a local version of the file
+     * we need this because we can't know if a file is stored local or not from
+     * outside the filestorage and for some purposes a local file is needed
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getLocalFile($path) {
+        return self::$defaultInstance->getLocalFile($path);
+    }
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    public static function getLocalFolder($path) {
+        return self::$defaultInstance->getLocalFolder($path);
+    }
+
+    /**
+     * return path to file which reflects one visible in browser
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getLocalPath($path) {
+        $datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+        $newpath = $path;
+        if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
+            $newpath = substr($path, strlen($datadir));
+        }
+        return $newpath;
+    }
+
+    /**
+     * check if the requested path is valid
+     *
+     * @param string $path
+     * @return bool
+     */
+    public static function isValidPath($path) {
+        $path = self::normalizePath($path);
+        if (!$path || $path[0] !== '/') {
+            $path = '/' . $path;
+        }
+        if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * checks if a file is blacklisted for storage in the filesystem
+     * Listens to write and rename hooks
+     *
+     * @param array $data from hook
+     */
+    public static function isBlacklisted($data) {
+        if (isset($data['path'])) {
+            $path = $data['path'];
+        } elseif (isset($data['newpath'])) {
+            $path = $data['newpath'];
+        }
+        if (isset($path)) {
+            if (self::isFileBlacklisted($path)) {
+                $data['run'] = false;
+            }
+        }
+    }
+
+    /**
+     * @param string $filename
+     * @return bool
+     */
+    public static function isFileBlacklisted($filename) {
+        $filename = self::normalizePath($filename);
+
+        $blacklist = \OC::$server->getConfig()->getSystemValue('blacklisted_files', ['.htaccess']);
+        $filename = strtolower(basename($filename));
+        return in_array($filename, $blacklist);
+    }
+
+    /**
+     * check if the directory should be ignored when scanning
+     * NOTE: the special directories . and .. would cause never ending recursion
+     *
+     * @param string $dir
+     * @return boolean
+     */
+    public static function isIgnoredDir($dir) {
+        if ($dir === '.' || $dir === '..') {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * following functions are equivalent to their php builtin equivalents for arguments/return values.
+     */
+    public static function mkdir($path) {
+        return self::$defaultInstance->mkdir($path);
+    }
+
+    public static function rmdir($path) {
+        return self::$defaultInstance->rmdir($path);
+    }
+
+    public static function is_dir($path) {
+        return self::$defaultInstance->is_dir($path);
+    }
+
+    public static function is_file($path) {
+        return self::$defaultInstance->is_file($path);
+    }
+
+    public static function stat($path) {
+        return self::$defaultInstance->stat($path);
+    }
+
+    public static function filetype($path) {
+        return self::$defaultInstance->filetype($path);
+    }
+
+    public static function filesize($path) {
+        return self::$defaultInstance->filesize($path);
+    }
+
+    public static function readfile($path) {
+        return self::$defaultInstance->readfile($path);
+    }
+
+    public static function isCreatable($path) {
+        return self::$defaultInstance->isCreatable($path);
+    }
+
+    public static function isReadable($path) {
+        return self::$defaultInstance->isReadable($path);
+    }
+
+    public static function isUpdatable($path) {
+        return self::$defaultInstance->isUpdatable($path);
+    }
+
+    public static function isDeletable($path) {
+        return self::$defaultInstance->isDeletable($path);
+    }
+
+    public static function isSharable($path) {
+        return self::$defaultInstance->isSharable($path);
+    }
+
+    public static function file_exists($path) {
+        return self::$defaultInstance->file_exists($path);
+    }
+
+    public static function filemtime($path) {
+        return self::$defaultInstance->filemtime($path);
+    }
+
+    public static function touch($path, $mtime = null) {
+        return self::$defaultInstance->touch($path, $mtime);
+    }
+
+    /**
+     * @return string
+     */
+    public static function file_get_contents($path) {
+        return self::$defaultInstance->file_get_contents($path);
+    }
+
+    public static function file_put_contents($path, $data) {
+        return self::$defaultInstance->file_put_contents($path, $data);
+    }
+
+    public static function unlink($path) {
+        return self::$defaultInstance->unlink($path);
+    }
+
+    public static function rename($path1, $path2) {
+        return self::$defaultInstance->rename($path1, $path2);
+    }
+
+    public static function copy($path1, $path2) {
+        return self::$defaultInstance->copy($path1, $path2);
+    }
+
+    public static function fopen($path, $mode) {
+        return self::$defaultInstance->fopen($path, $mode);
+    }
+
+    /**
+     * @return string
+     */
+    public static function toTmpFile($path) {
+        return self::$defaultInstance->toTmpFile($path);
+    }
+
+    public static function fromTmpFile($tmpFile, $path) {
+        return self::$defaultInstance->fromTmpFile($tmpFile, $path);
+    }
+
+    public static function getMimeType($path) {
+        return self::$defaultInstance->getMimeType($path);
+    }
+
+    public static function hash($type, $path, $raw = false) {
+        return self::$defaultInstance->hash($type, $path, $raw);
+    }
+
+    public static function free_space($path = '/') {
+        return self::$defaultInstance->free_space($path);
+    }
+
+    public static function search($query) {
+        return self::$defaultInstance->search($query);
+    }
+
+    /**
+     * @param string $query
+     */
+    public static function searchByMime($query) {
+        return self::$defaultInstance->searchByMime($query);
+    }
+
+    /**
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return FileInfo[] array or file info
+     */
+    public static function searchByTag($tag, $userId) {
+        return self::$defaultInstance->searchByTag($tag, $userId);
+    }
+
+    /**
+     * check if a file or folder has been updated since $time
+     *
+     * @param string $path
+     * @param int $time
+     * @return bool
+     */
+    public static function hasUpdated($path, $time) {
+        return self::$defaultInstance->hasUpdated($path, $time);
+    }
+
+    /**
+     * Fix common problems with a file path
+     *
+     * @param string $path
+     * @param bool $stripTrailingSlash whether to strip the trailing slash
+     * @param bool $isAbsolutePath whether the given path is absolute
+     * @param bool $keepUnicode true to disable unicode normalization
+     * @return string
+     */
+    public static function normalizePath($path, $stripTrailingSlash = true, $isAbsolutePath = false, $keepUnicode = false) {
+        /**
+         * FIXME: This is a workaround for existing classes and files which call
+         *        this function with another type than a valid string. This
+         *        conversion should get removed as soon as all existing
+         *        function calls have been fixed.
+         */
+        $path = (string)$path;
+
+        if ($path === '') {
+            return '/';
+        }
+
+        if (is_null(self::$normalizedPathCache)) {
+            self::$normalizedPathCache = new CappedMemoryCache(2048);
+        }
+
+        $cacheKey = json_encode([$path, $stripTrailingSlash, $isAbsolutePath, $keepUnicode]);
+
+        if ($cacheKey && isset(self::$normalizedPathCache[$cacheKey])) {
+            return self::$normalizedPathCache[$cacheKey];
+        }
+
+        //normalize unicode if possible
+        if (!$keepUnicode) {
+            $path = \OC_Util::normalizeUnicode($path);
+        }
+
+        //add leading slash, if it is already there we strip it anyway
+        $path = '/' . $path;
+
+        $patterns = [
+            '#\\\\#s',       // no windows style '\\' slashes
+            '#/\.(/\.)*/#s', // remove '/./'
+            '#\//+#s',       // remove sequence of slashes
+            '#/\.$#s',       // remove trailing '/.'
+        ];
+
+        do {
+            $count = 0;
+            $path = preg_replace($patterns, '/', $path, -1, $count);
+        } while ($count > 0);
+
+        //remove trailing slash
+        if ($stripTrailingSlash && strlen($path) > 1) {
+            $path = rtrim($path, '/');
+        }
+
+        self::$normalizedPathCache[$cacheKey] = $path;
+
+        return $path;
+    }
+
+    /**
+     * get the filesystem info
+     *
+     * @param string $path
+     * @param boolean $includeMountPoints whether to add mountpoint sizes,
+     * defaults to true
+     * @return \OC\Files\FileInfo|false False if file does not exist
+     */
+    public static function getFileInfo($path, $includeMountPoints = true) {
+        return self::$defaultInstance->getFileInfo($path, $includeMountPoints);
+    }
+
+    /**
+     * change file metadata
+     *
+     * @param string $path
+     * @param array $data
+     * @return int
+     *
+     * returns the fileid of the updated file
+     */
+    public static function putFileInfo($path, $data) {
+        return self::$defaultInstance->putFileInfo($path, $data);
+    }
+
+    /**
+     * get the content of a directory
+     *
+     * @param string $directory path under datadirectory
+     * @param string $mimetype_filter limit returned content to this mimetype or mimepart
+     * @return \OC\Files\FileInfo[]
+     */
+    public static function getDirectoryContent($directory, $mimetype_filter = '') {
+        return self::$defaultInstance->getDirectoryContent($directory, $mimetype_filter);
+    }
+
+    /**
+     * Get the path of a file by id
+     *
+     * Note that the resulting path is not guaranteed to be unique for the id, multiple paths can point to the same file
+     *
+     * @param int $id
+     * @throws NotFoundException
+     * @return string
+     */
+    public static function getPath($id) {
+        return self::$defaultInstance->getPath($id);
+    }
+
+    /**
+     * Get the owner for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getOwner($path) {
+        return self::$defaultInstance->getOwner($path);
+    }
+
+    /**
+     * get the ETag for a file or folder
+     *
+     * @param string $path
+     * @return string
+     */
+    public static function getETag($path) {
+        return self::$defaultInstance->getETag($path);
+    }
 }

Spacing +8 added lines, -8 removed lines

@@ -325,7 +325,7 @@ 
 		self::$defaultInstance = new View($root);
 		/** @var IEventDispatcher $eventDispatcher */
 		$eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function () {
+		$eventDispatcher->addListener(FilesystemTornDownEvent::class, function() {
 			self::$defaultInstance = null;
 			self::$usersSetup = [];
 			self::$loaded = false;
@@ -441,7 +441,7 @@ 
 	 * @return string
 	 */
 	public static function getLocalPath($path) {
-		$datadir = \OC_User::getHome(\OC_User::getUser()) . '/files';
+		$datadir = \OC_User::getHome(\OC_User::getUser()).'/files';
 		$newpath = $path;
 		if (strncmp($newpath, $datadir, strlen($datadir)) == 0) {
 			$newpath = substr($path, strlen($datadir));
@@ -458,7 +458,7 @@ 
 	public static function isValidPath($path) {
 		$path = self::normalizePath($path);
 		if (!$path || $path[0] !== '/') {
-			$path = '/' . $path;
+			$path = '/'.$path;
 		}
 		if (strpos($path, '/../') !== false || strrchr($path, '/') === '/..') {
 			return false;
@@ -675,7 +675,7 @@ 
 		 *        conversion should get removed as soon as all existing
 		 *        function calls have been fixed.
 		 */
-		$path = (string)$path;
+		$path = (string) $path;
 
 		if ($path === '') {
 			return '/';
@@ -697,13 +697,13 @@ 
 		}
 
 		//add leading slash, if it is already there we strip it anyway
-		$path = '/' . $path;
+		$path = '/'.$path;
 
 		$patterns = [
-			'#\\\\#s',       // no windows style '\\' slashes
+			'#\\\\#s', // no windows style '\\' slashes
 			'#/\.(/\.)*/#s', // remove '/./'
-			'#\//+#s',       // remove sequence of slashes
-			'#/\.$#s',       // remove trailing '/.'
+			'#\//+#s', // remove sequence of slashes
+			'#/\.$#s', // remove trailing '/.'
 		];
 
 		do {

apps/files_sharing/lib/External/Manager.php

Indentation +720 added lines, -720 removed lines

@@ -57,771 +57,771 @@
 use Psr\Log\LoggerInterface;
 
 class Manager {
-	public const STORAGE = '\OCA\Files_Sharing\External\Storage';
-
-	/** @var string|null */
-	private $uid;
-
-	/** @var IDBConnection */
-	private $connection;
-
-	/** @var \OC\Files\Mount\Manager */
-	private $mountManager;
-
-	/** @var IStorageFactory */
-	private $storageLoader;
-
-	/** @var IClientService */
-	private $clientService;
-
-	/** @var IManager */
-	private $notificationManager;
-
-	/** @var IDiscoveryService */
-	private $discoveryService;
-
-	/** @var ICloudFederationProviderManager */
-	private $cloudFederationProviderManager;
-
-	/** @var ICloudFederationFactory */
-	private $cloudFederationFactory;
-
-	/** @var IGroupManager */
-	private $groupManager;
-
-	/** @var IUserManager */
-	private $userManager;
-
-	/** @var IEventDispatcher */
-	private $eventDispatcher;
-
-	/** @var LoggerInterface */
-	private $logger;
-
-	public function __construct(
-		IDBConnection                   $connection,
-		\OC\Files\Mount\Manager         $mountManager,
-		IStorageFactory                 $storageLoader,
-		IClientService                  $clientService,
-		IManager                        $notificationManager,
-		IDiscoveryService               $discoveryService,
-		ICloudFederationProviderManager $cloudFederationProviderManager,
-		ICloudFederationFactory         $cloudFederationFactory,
-		IGroupManager                   $groupManager,
-		IUserManager                    $userManager,
-		IUserSession                    $userSession,
-		IEventDispatcher                $eventDispatcher,
-		LoggerInterface                 $logger
-	) {
-		$user = $userSession->getUser();
-		$this->connection = $connection;
-		$this->mountManager = $mountManager;
-		$this->storageLoader = $storageLoader;
-		$this->clientService = $clientService;
-		$this->uid = $user ? $user->getUID() : null;
-		$this->notificationManager = $notificationManager;
-		$this->discoveryService = $discoveryService;
-		$this->cloudFederationProviderManager = $cloudFederationProviderManager;
-		$this->cloudFederationFactory = $cloudFederationFactory;
-		$this->groupManager = $groupManager;
-		$this->userManager = $userManager;
-		$this->eventDispatcher = $eventDispatcher;
-		$this->logger = $logger;
-	}
-
-	/**
-	 * add new server-to-server share
-	 *
-	 * @param string $remote
-	 * @param string $token
-	 * @param string $password
-	 * @param string $name
-	 * @param string $owner
-	 * @param int $shareType
-	 * @param boolean $accepted
-	 * @param string $user
-	 * @param string $remoteId
-	 * @param int $parent
-	 * @return Mount|null
-	 * @throws \Doctrine\DBAL\Exception
-	 */
-	public function addShare($remote, $token, $password, $name, $owner, $shareType, $accepted = false, $user = null, $remoteId = '', $parent = -1) {
-		$user = $user ? $user : $this->uid;
-		$accepted = $accepted ? IShare::STATUS_ACCEPTED : IShare::STATUS_PENDING;
-		$name = Filesystem::normalizePath('/' . $name);
-
-		if ($accepted !== IShare::STATUS_ACCEPTED) {
-			// To avoid conflicts with the mount point generation later,
-			// we only use a temporary mount point name here. The real
-			// mount point name will be generated when accepting the share,
-			// using the original share item name.
-			$tmpMountPointName = '{{TemporaryMountPointName#' . $name . '}}';
-			$mountPoint = $tmpMountPointName;
-			$hash = md5($tmpMountPointName);
-			$data = [
-				'remote' => $remote,
-				'share_token' => $token,
-				'password' => $password,
-				'name' => $name,
-				'owner' => $owner,
-				'user' => $user,
-				'mountpoint' => $mountPoint,
-				'mountpoint_hash' => $hash,
-				'accepted' => $accepted,
-				'remote_id' => $remoteId,
-				'share_type' => $shareType,
-			];
-
-			$i = 1;
-			while (!$this->connection->insertIfNotExist('*PREFIX*share_external', $data, ['user', 'mountpoint_hash'])) {
-				// The external share already exists for the user
-				$data['mountpoint'] = $tmpMountPointName . '-' . $i;
-				$data['mountpoint_hash'] = md5($data['mountpoint']);
-				$i++;
-			}
-			return null;
-		}
-
-		$mountPoint = Files::buildNotExistingFileName('/', $name);
-		$mountPoint = Filesystem::normalizePath('/' . $mountPoint);
-		$hash = md5($mountPoint);
-
-		$this->writeShareToDb($remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType);
-
-		$options = [
-			'remote' => $remote,
-			'token' => $token,
-			'password' => $password,
-			'mountpoint' => $mountPoint,
-			'owner' => $owner
-		];
-		return $this->mountShare($options);
-	}
-
-	/**
-	 * write remote share to the database
-	 *
-	 * @param $remote
-	 * @param $token
-	 * @param $password
-	 * @param $name
-	 * @param $owner
-	 * @param $user
-	 * @param $mountPoint
-	 * @param $hash
-	 * @param $accepted
-	 * @param $remoteId
-	 * @param $parent
-	 * @param $shareType
-	 *
-	 * @return void
-	 * @throws \Doctrine\DBAL\Driver\Exception
-	 */
-	private function writeShareToDb($remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType): void {
-		$query = $this->connection->prepare('
+    public const STORAGE = '\OCA\Files_Sharing\External\Storage';
+
+    /** @var string|null */
+    private $uid;
+
+    /** @var IDBConnection */
+    private $connection;
+
+    /** @var \OC\Files\Mount\Manager */
+    private $mountManager;
+
+    /** @var IStorageFactory */
+    private $storageLoader;
+
+    /** @var IClientService */
+    private $clientService;
+
+    /** @var IManager */
+    private $notificationManager;
+
+    /** @var IDiscoveryService */
+    private $discoveryService;
+
+    /** @var ICloudFederationProviderManager */
+    private $cloudFederationProviderManager;
+
+    /** @var ICloudFederationFactory */
+    private $cloudFederationFactory;
+
+    /** @var IGroupManager */
+    private $groupManager;
+
+    /** @var IUserManager */
+    private $userManager;
+
+    /** @var IEventDispatcher */
+    private $eventDispatcher;
+
+    /** @var LoggerInterface */
+    private $logger;
+
+    public function __construct(
+        IDBConnection                   $connection,
+        \OC\Files\Mount\Manager         $mountManager,
+        IStorageFactory                 $storageLoader,
+        IClientService                  $clientService,
+        IManager                        $notificationManager,
+        IDiscoveryService               $discoveryService,
+        ICloudFederationProviderManager $cloudFederationProviderManager,
+        ICloudFederationFactory         $cloudFederationFactory,
+        IGroupManager                   $groupManager,
+        IUserManager                    $userManager,
+        IUserSession                    $userSession,
+        IEventDispatcher                $eventDispatcher,
+        LoggerInterface                 $logger
+    ) {
+        $user = $userSession->getUser();
+        $this->connection = $connection;
+        $this->mountManager = $mountManager;
+        $this->storageLoader = $storageLoader;
+        $this->clientService = $clientService;
+        $this->uid = $user ? $user->getUID() : null;
+        $this->notificationManager = $notificationManager;
+        $this->discoveryService = $discoveryService;
+        $this->cloudFederationProviderManager = $cloudFederationProviderManager;
+        $this->cloudFederationFactory = $cloudFederationFactory;
+        $this->groupManager = $groupManager;
+        $this->userManager = $userManager;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->logger = $logger;
+    }
+
+    /**
+     * add new server-to-server share
+     *
+     * @param string $remote
+     * @param string $token
+     * @param string $password
+     * @param string $name
+     * @param string $owner
+     * @param int $shareType
+     * @param boolean $accepted
+     * @param string $user
+     * @param string $remoteId
+     * @param int $parent
+     * @return Mount|null
+     * @throws \Doctrine\DBAL\Exception
+     */
+    public function addShare($remote, $token, $password, $name, $owner, $shareType, $accepted = false, $user = null, $remoteId = '', $parent = -1) {
+        $user = $user ? $user : $this->uid;
+        $accepted = $accepted ? IShare::STATUS_ACCEPTED : IShare::STATUS_PENDING;
+        $name = Filesystem::normalizePath('/' . $name);
+
+        if ($accepted !== IShare::STATUS_ACCEPTED) {
+            // To avoid conflicts with the mount point generation later,
+            // we only use a temporary mount point name here. The real
+            // mount point name will be generated when accepting the share,
+            // using the original share item name.
+            $tmpMountPointName = '{{TemporaryMountPointName#' . $name . '}}';
+            $mountPoint = $tmpMountPointName;
+            $hash = md5($tmpMountPointName);
+            $data = [
+                'remote' => $remote,
+                'share_token' => $token,
+                'password' => $password,
+                'name' => $name,
+                'owner' => $owner,
+                'user' => $user,
+                'mountpoint' => $mountPoint,
+                'mountpoint_hash' => $hash,
+                'accepted' => $accepted,
+                'remote_id' => $remoteId,
+                'share_type' => $shareType,
+            ];
+
+            $i = 1;
+            while (!$this->connection->insertIfNotExist('*PREFIX*share_external', $data, ['user', 'mountpoint_hash'])) {
+                // The external share already exists for the user
+                $data['mountpoint'] = $tmpMountPointName . '-' . $i;
+                $data['mountpoint_hash'] = md5($data['mountpoint']);
+                $i++;
+            }
+            return null;
+        }
+
+        $mountPoint = Files::buildNotExistingFileName('/', $name);
+        $mountPoint = Filesystem::normalizePath('/' . $mountPoint);
+        $hash = md5($mountPoint);
+
+        $this->writeShareToDb($remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType);
+
+        $options = [
+            'remote' => $remote,
+            'token' => $token,
+            'password' => $password,
+            'mountpoint' => $mountPoint,
+            'owner' => $owner
+        ];
+        return $this->mountShare($options);
+    }
+
+    /**
+     * write remote share to the database
+     *
+     * @param $remote
+     * @param $token
+     * @param $password
+     * @param $name
+     * @param $owner
+     * @param $user
+     * @param $mountPoint
+     * @param $hash
+     * @param $accepted
+     * @param $remoteId
+     * @param $parent
+     * @param $shareType
+     *
+     * @return void
+     * @throws \Doctrine\DBAL\Driver\Exception
+     */
+    private function writeShareToDb($remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType): void {
+        $query = $this->connection->prepare('
 				INSERT INTO `*PREFIX*share_external`
 					(`remote`, `share_token`, `password`, `name`, `owner`, `user`, `mountpoint`, `mountpoint_hash`, `accepted`, `remote_id`, `parent`, `share_type`)
 				VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 			');
-		$query->execute([$remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType]);
-	}
-
-	/**
-	 * get share
-	 *
-	 * @param int $id share id
-	 * @return mixed share of false
-	 */
-	private function fetchShare($id) {
-		$getShare = $this->connection->prepare('
+        $query->execute([$remote, $token, $password, $name, $owner, $user, $mountPoint, $hash, $accepted, $remoteId, $parent, $shareType]);
+    }
+
+    /**
+     * get share
+     *
+     * @param int $id share id
+     * @return mixed share of false
+     */
+    private function fetchShare($id) {
+        $getShare = $this->connection->prepare('
 			SELECT `id`, `remote`, `remote_id`, `share_token`, `name`, `owner`, `user`, `mountpoint`, `accepted`, `parent`, `share_type`, `password`, `mountpoint_hash`
 			FROM  `*PREFIX*share_external`
 			WHERE `id` = ?');
-		$result = $getShare->execute([$id]);
-		$share = $result->fetch();
-		$result->closeCursor();
-		return $share;
-	}
-
-	private function fetchUserShare($parentId, $uid) {
-		$getShare = $this->connection->prepare('
+        $result = $getShare->execute([$id]);
+        $share = $result->fetch();
+        $result->closeCursor();
+        return $share;
+    }
+
+    private function fetchUserShare($parentId, $uid) {
+        $getShare = $this->connection->prepare('
 			SELECT `id`, `remote`, `remote_id`, `share_token`, `name`, `owner`, `user`, `mountpoint`, `accepted`, `parent`, `share_type`, `password`, `mountpoint_hash`
 			FROM  `*PREFIX*share_external`
 			WHERE `parent` = ? AND `user` = ?');
-		$result = $getShare->execute([$parentId, $uid]);
-		$share = $result->fetch();
-		$result->closeCursor();
-		if ($share !== false) {
-			return $share;
-		}
-		return null;
-	}
-
-	/**
-	 * get share
-	 *
-	 * @param int $id share id
-	 * @return mixed share of false
-	 */
-	public function getShare($id) {
-		$share = $this->fetchShare($id);
-		$validShare = is_array($share) && isset($share['share_type']) && isset($share['user']);
-
-		// check if the user is allowed to access it
-		if ($validShare && (int)$share['share_type'] === IShare::TYPE_USER && $share['user'] === $this->uid) {
-			return $share;
-		} elseif ($validShare && (int)$share['share_type'] === IShare::TYPE_GROUP) {
-			$parentId = (int)$share['parent'];
-			if ($parentId !== -1) {
-				// we just retrieved a sub-share, switch to the parent entry for verification
-				$groupShare = $this->fetchShare($parentId);
-			} else {
-				$groupShare = $share;
-			}
-			$user = $this->userManager->get($this->uid);
-			if ($this->groupManager->get($groupShare['user'])->inGroup($user)) {
-				return $share;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Updates accepted flag in the database
-	 *
-	 * @param int $id
-	 */
-	private function updateAccepted(int $shareId, bool $accepted) : void {
-		$query = $this->connection->prepare('
+        $result = $getShare->execute([$parentId, $uid]);
+        $share = $result->fetch();
+        $result->closeCursor();
+        if ($share !== false) {
+            return $share;
+        }
+        return null;
+    }
+
+    /**
+     * get share
+     *
+     * @param int $id share id
+     * @return mixed share of false
+     */
+    public function getShare($id) {
+        $share = $this->fetchShare($id);
+        $validShare = is_array($share) && isset($share['share_type']) && isset($share['user']);
+
+        // check if the user is allowed to access it
+        if ($validShare && (int)$share['share_type'] === IShare::TYPE_USER && $share['user'] === $this->uid) {
+            return $share;
+        } elseif ($validShare && (int)$share['share_type'] === IShare::TYPE_GROUP) {
+            $parentId = (int)$share['parent'];
+            if ($parentId !== -1) {
+                // we just retrieved a sub-share, switch to the parent entry for verification
+                $groupShare = $this->fetchShare($parentId);
+            } else {
+                $groupShare = $share;
+            }
+            $user = $this->userManager->get($this->uid);
+            if ($this->groupManager->get($groupShare['user'])->inGroup($user)) {
+                return $share;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Updates accepted flag in the database
+     *
+     * @param int $id
+     */
+    private function updateAccepted(int $shareId, bool $accepted) : void {
+        $query = $this->connection->prepare('
 			UPDATE `*PREFIX*share_external`
 			SET `accepted` = ?
 			WHERE `id` = ?');
-		$updateResult = $query->execute([$accepted ? 1 : 0, $shareId]);
-		$updateResult->closeCursor();
-	}
-
-	/**
-	 * accept server-to-server share
-	 *
-	 * @param int $id
-	 * @return bool True if the share could be accepted, false otherwise
-	 */
-	public function acceptShare($id) {
-		$share = $this->getShare($id);
-		$result = false;
-
-		if ($share) {
-			\OC_Util::setupFS($this->uid);
-			$shareFolder = Helper::getShareFolder(null, $this->uid);
-			$mountPoint = Files::buildNotExistingFileName($shareFolder, $share['name']);
-			$mountPoint = Filesystem::normalizePath($mountPoint);
-			$hash = md5($mountPoint);
-			$userShareAccepted = false;
-
-			if ((int)$share['share_type'] === IShare::TYPE_USER) {
-				$acceptShare = $this->connection->prepare('
+        $updateResult = $query->execute([$accepted ? 1 : 0, $shareId]);
+        $updateResult->closeCursor();
+    }
+
+    /**
+     * accept server-to-server share
+     *
+     * @param int $id
+     * @return bool True if the share could be accepted, false otherwise
+     */
+    public function acceptShare($id) {
+        $share = $this->getShare($id);
+        $result = false;
+
+        if ($share) {
+            \OC_Util::setupFS($this->uid);
+            $shareFolder = Helper::getShareFolder(null, $this->uid);
+            $mountPoint = Files::buildNotExistingFileName($shareFolder, $share['name']);
+            $mountPoint = Filesystem::normalizePath($mountPoint);
+            $hash = md5($mountPoint);
+            $userShareAccepted = false;
+
+            if ((int)$share['share_type'] === IShare::TYPE_USER) {
+                $acceptShare = $this->connection->prepare('
 				UPDATE `*PREFIX*share_external`
 				SET `accepted` = ?,
 					`mountpoint` = ?,
 					`mountpoint_hash` = ?
 				WHERE `id` = ? AND `user` = ?');
-				$userShareAccepted = $acceptShare->execute([1, $mountPoint, $hash, $id, $this->uid]);
-			} else {
-				$parentId = (int)$share['parent'];
-				if ($parentId !== -1) {
-					// this is the sub-share
-					$subshare = $share;
-				} else {
-					$subshare = $this->fetchUserShare($id, $this->uid);
-				}
-
-				if ($subshare !== null) {
-					try {
-						$acceptShare = $this->connection->prepare('
+                $userShareAccepted = $acceptShare->execute([1, $mountPoint, $hash, $id, $this->uid]);
+            } else {
+                $parentId = (int)$share['parent'];
+                if ($parentId !== -1) {
+                    // this is the sub-share
+                    $subshare = $share;
+                } else {
+                    $subshare = $this->fetchUserShare($id, $this->uid);
+                }
+
+                if ($subshare !== null) {
+                    try {
+                        $acceptShare = $this->connection->prepare('
 						UPDATE `*PREFIX*share_external`
 						SET `accepted` = ?,
 							`mountpoint` = ?,
 							`mountpoint_hash` = ?
 						WHERE `id` = ? AND `user` = ?');
-						$acceptShare->execute([1, $mountPoint, $hash, $subshare['id'], $this->uid]);
-						$result = true;
-					} catch (Exception $e) {
-						$this->logger->emergency('Could not update share', ['exception' => $e]);
-						$result = false;
-					}
-				} else {
-					try {
-						$this->writeShareToDb(
-							$share['remote'],
-							$share['share_token'],
-							$share['password'],
-							$share['name'],
-							$share['owner'],
-							$this->uid,
-							$mountPoint, $hash, 1,
-							$share['remote_id'],
-							$id,
-							$share['share_type']);
-						$result = true;
-					} catch (Exception $e) {
-						$this->logger->emergency('Could not create share', ['exception' => $e]);
-						$result = false;
-					}
-				}
-			}
-			if ($userShareAccepted !== false) {
-				$this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'accept');
-				$event = new FederatedShareAddedEvent($share['remote']);
-				$this->eventDispatcher->dispatchTyped($event);
-				$result = true;
-			}
-		}
-
-		// Make sure the user has no notification for something that does not exist anymore.
-		$this->processNotification($id);
-
-		return $result;
-	}
-
-	/**
-	 * decline server-to-server share
-	 *
-	 * @param int $id
-	 * @return bool True if the share could be declined, false otherwise
-	 */
-	public function declineShare($id) {
-		$share = $this->getShare($id);
-		$result = false;
-
-		if ($share && (int)$share['share_type'] === IShare::TYPE_USER) {
-			$removeShare = $this->connection->prepare('
+                        $acceptShare->execute([1, $mountPoint, $hash, $subshare['id'], $this->uid]);
+                        $result = true;
+                    } catch (Exception $e) {
+                        $this->logger->emergency('Could not update share', ['exception' => $e]);
+                        $result = false;
+                    }
+                } else {
+                    try {
+                        $this->writeShareToDb(
+                            $share['remote'],
+                            $share['share_token'],
+                            $share['password'],
+                            $share['name'],
+                            $share['owner'],
+                            $this->uid,
+                            $mountPoint, $hash, 1,
+                            $share['remote_id'],
+                            $id,
+                            $share['share_type']);
+                        $result = true;
+                    } catch (Exception $e) {
+                        $this->logger->emergency('Could not create share', ['exception' => $e]);
+                        $result = false;
+                    }
+                }
+            }
+            if ($userShareAccepted !== false) {
+                $this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'accept');
+                $event = new FederatedShareAddedEvent($share['remote']);
+                $this->eventDispatcher->dispatchTyped($event);
+                $result = true;
+            }
+        }
+
+        // Make sure the user has no notification for something that does not exist anymore.
+        $this->processNotification($id);
+
+        return $result;
+    }
+
+    /**
+     * decline server-to-server share
+     *
+     * @param int $id
+     * @return bool True if the share could be declined, false otherwise
+     */
+    public function declineShare($id) {
+        $share = $this->getShare($id);
+        $result = false;
+
+        if ($share && (int)$share['share_type'] === IShare::TYPE_USER) {
+            $removeShare = $this->connection->prepare('
 				DELETE FROM `*PREFIX*share_external` WHERE `id` = ? AND `user` = ?');
-			$removeShare->execute([$id, $this->uid]);
-			$this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
-
-			$this->processNotification($id);
-			$result = true;
-		} elseif ($share && (int)$share['share_type'] === IShare::TYPE_GROUP) {
-			$parentId = (int)$share['parent'];
-			if ($parentId !== -1) {
-				// this is the sub-share
-				$subshare = $share;
-			} else {
-				$subshare = $this->fetchUserShare($id, $this->uid);
-			}
-
-			if ($subshare !== null) {
-				try {
-					$this->updateAccepted((int)$subshare['id'], false);
-					$result = true;
-				} catch (Exception $e) {
-					$this->logger->emergency('Could not update share', ['exception' => $e]);
-					$result = false;
-				}
-			} else {
-				try {
-					$this->writeShareToDb(
-						$share['remote'],
-						$share['share_token'],
-						$share['password'],
-						$share['name'],
-						$share['owner'],
-						$this->uid,
-						$share['mountpoint'],
-						$share['mountpoint_hash'],
-						0,
-						$share['remote_id'],
-						$id,
-						$share['share_type']);
-					$result = true;
-				} catch (Exception $e) {
-					$this->logger->emergency('Could not create share', ['exception' => $e]);
-					$result = false;
-				}
-			}
-			$this->processNotification($id);
-		}
-
-		return $result;
-	}
-
-	/**
-	 * @param int $remoteShare
-	 */
-	public function processNotification($remoteShare) {
-		$filter = $this->notificationManager->createNotification();
-		$filter->setApp('files_sharing')
-			->setUser($this->uid)
-			->setObject('remote_share', (int) $remoteShare);
-		$this->notificationManager->markProcessed($filter);
-	}
-
-	/**
-	 * inform remote server whether server-to-server share was accepted/declined
-	 *
-	 * @param string $remote
-	 * @param string $token
-	 * @param string $remoteId Share id on the remote host
-	 * @param string $feedback
-	 * @return boolean
-	 */
-	private function sendFeedbackToRemote($remote, $token, $remoteId, $feedback) {
-		$result = $this->tryOCMEndPoint($remote, $token, $remoteId, $feedback);
-
-		if (is_array($result)) {
-			return true;
-		}
-
-		$federationEndpoints = $this->discoveryService->discover($remote, 'FEDERATED_SHARING');
-		$endpoint = isset($federationEndpoints['share']) ? $federationEndpoints['share'] : '/ocs/v2.php/cloud/shares';
-
-		$url = rtrim($remote, '/') . $endpoint . '/' . $remoteId . '/' . $feedback . '?format=' . Share::RESPONSE_FORMAT;
-		$fields = ['token' => $token];
-
-		$client = $this->clientService->newClient();
-
-		try {
-			$response = $client->post(
-				$url,
-				[
-					'body' => $fields,
-					'connect_timeout' => 10,
-				]
-			);
-		} catch (\Exception $e) {
-			return false;
-		}
-
-		$status = json_decode($response->getBody(), true);
-
-		return ($status['ocs']['meta']['statuscode'] === 100 || $status['ocs']['meta']['statuscode'] === 200);
-	}
-
-	/**
-	 * try send accept message to ocm end-point
-	 *
-	 * @param string $remoteDomain
-	 * @param string $token
-	 * @param string $remoteId id of the share
-	 * @param string $feedback
-	 * @return array|false
-	 */
-	protected function tryOCMEndPoint($remoteDomain, $token, $remoteId, $feedback) {
-		switch ($feedback) {
-			case 'accept':
-				$notification = $this->cloudFederationFactory->getCloudFederationNotification();
-				$notification->setMessage(
-					'SHARE_ACCEPTED',
-					'file',
-					$remoteId,
-					[
-						'sharedSecret' => $token,
-						'message' => 'Recipient accept the share'
-					]
-
-				);
-				return $this->cloudFederationProviderManager->sendNotification($remoteDomain, $notification);
-			case 'decline':
-				$notification = $this->cloudFederationFactory->getCloudFederationNotification();
-				$notification->setMessage(
-					'SHARE_DECLINED',
-					'file',
-					$remoteId,
-					[
-						'sharedSecret' => $token,
-						'message' => 'Recipient declined the share'
-					]
-
-				);
-				return $this->cloudFederationProviderManager->sendNotification($remoteDomain, $notification);
-		}
-
-		return false;
-	}
-
-
-	/**
-	 * remove '/user/files' from the path and trailing slashes
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	protected function stripPath($path) {
-		$prefix = '/' . $this->uid . '/files';
-		return rtrim(substr($path, strlen($prefix)), '/');
-	}
-
-	public function getMount($data) {
-		$data['manager'] = $this;
-		$mountPoint = '/' . $this->uid . '/files' . $data['mountpoint'];
-		$data['mountpoint'] = $mountPoint;
-		$data['certificateManager'] = \OC::$server->getCertificateManager();
-		return new Mount(self::STORAGE, $mountPoint, $data, $this, $this->storageLoader);
-	}
-
-	/**
-	 * @param array $data
-	 * @return Mount
-	 */
-	protected function mountShare($data) {
-		$mount = $this->getMount($data);
-		$this->mountManager->addMount($mount);
-		return $mount;
-	}
-
-	/**
-	 * @return \OC\Files\Mount\Manager
-	 */
-	public function getMountManager() {
-		return $this->mountManager;
-	}
-
-	/**
-	 * @param string $source
-	 * @param string $target
-	 * @return bool
-	 */
-	public function setMountPoint($source, $target) {
-		$source = $this->stripPath($source);
-		$target = $this->stripPath($target);
-		$sourceHash = md5($source);
-		$targetHash = md5($target);
-
-		$query = $this->connection->prepare('
+            $removeShare->execute([$id, $this->uid]);
+            $this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
+
+            $this->processNotification($id);
+            $result = true;
+        } elseif ($share && (int)$share['share_type'] === IShare::TYPE_GROUP) {
+            $parentId = (int)$share['parent'];
+            if ($parentId !== -1) {
+                // this is the sub-share
+                $subshare = $share;
+            } else {
+                $subshare = $this->fetchUserShare($id, $this->uid);
+            }
+
+            if ($subshare !== null) {
+                try {
+                    $this->updateAccepted((int)$subshare['id'], false);
+                    $result = true;
+                } catch (Exception $e) {
+                    $this->logger->emergency('Could not update share', ['exception' => $e]);
+                    $result = false;
+                }
+            } else {
+                try {
+                    $this->writeShareToDb(
+                        $share['remote'],
+                        $share['share_token'],
+                        $share['password'],
+                        $share['name'],
+                        $share['owner'],
+                        $this->uid,
+                        $share['mountpoint'],
+                        $share['mountpoint_hash'],
+                        0,
+                        $share['remote_id'],
+                        $id,
+                        $share['share_type']);
+                    $result = true;
+                } catch (Exception $e) {
+                    $this->logger->emergency('Could not create share', ['exception' => $e]);
+                    $result = false;
+                }
+            }
+            $this->processNotification($id);
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param int $remoteShare
+     */
+    public function processNotification($remoteShare) {
+        $filter = $this->notificationManager->createNotification();
+        $filter->setApp('files_sharing')
+            ->setUser($this->uid)
+            ->setObject('remote_share', (int) $remoteShare);
+        $this->notificationManager->markProcessed($filter);
+    }
+
+    /**
+     * inform remote server whether server-to-server share was accepted/declined
+     *
+     * @param string $remote
+     * @param string $token
+     * @param string $remoteId Share id on the remote host
+     * @param string $feedback
+     * @return boolean
+     */
+    private function sendFeedbackToRemote($remote, $token, $remoteId, $feedback) {
+        $result = $this->tryOCMEndPoint($remote, $token, $remoteId, $feedback);
+
+        if (is_array($result)) {
+            return true;
+        }
+
+        $federationEndpoints = $this->discoveryService->discover($remote, 'FEDERATED_SHARING');
+        $endpoint = isset($federationEndpoints['share']) ? $federationEndpoints['share'] : '/ocs/v2.php/cloud/shares';
+
+        $url = rtrim($remote, '/') . $endpoint . '/' . $remoteId . '/' . $feedback . '?format=' . Share::RESPONSE_FORMAT;
+        $fields = ['token' => $token];
+
+        $client = $this->clientService->newClient();
+
+        try {
+            $response = $client->post(
+                $url,
+                [
+                    'body' => $fields,
+                    'connect_timeout' => 10,
+                ]
+            );
+        } catch (\Exception $e) {
+            return false;
+        }
+
+        $status = json_decode($response->getBody(), true);
+
+        return ($status['ocs']['meta']['statuscode'] === 100 || $status['ocs']['meta']['statuscode'] === 200);
+    }
+
+    /**
+     * try send accept message to ocm end-point
+     *
+     * @param string $remoteDomain
+     * @param string $token
+     * @param string $remoteId id of the share
+     * @param string $feedback
+     * @return array|false
+     */
+    protected function tryOCMEndPoint($remoteDomain, $token, $remoteId, $feedback) {
+        switch ($feedback) {
+            case 'accept':
+                $notification = $this->cloudFederationFactory->getCloudFederationNotification();
+                $notification->setMessage(
+                    'SHARE_ACCEPTED',
+                    'file',
+                    $remoteId,
+                    [
+                        'sharedSecret' => $token,
+                        'message' => 'Recipient accept the share'
+                    ]
+
+                );
+                return $this->cloudFederationProviderManager->sendNotification($remoteDomain, $notification);
+            case 'decline':
+                $notification = $this->cloudFederationFactory->getCloudFederationNotification();
+                $notification->setMessage(
+                    'SHARE_DECLINED',
+                    'file',
+                    $remoteId,
+                    [
+                        'sharedSecret' => $token,
+                        'message' => 'Recipient declined the share'
+                    ]
+
+                );
+                return $this->cloudFederationProviderManager->sendNotification($remoteDomain, $notification);
+        }
+
+        return false;
+    }
+
+
+    /**
+     * remove '/user/files' from the path and trailing slashes
+     *
+     * @param string $path
+     * @return string
+     */
+    protected function stripPath($path) {
+        $prefix = '/' . $this->uid . '/files';
+        return rtrim(substr($path, strlen($prefix)), '/');
+    }
+
+    public function getMount($data) {
+        $data['manager'] = $this;
+        $mountPoint = '/' . $this->uid . '/files' . $data['mountpoint'];
+        $data['mountpoint'] = $mountPoint;
+        $data['certificateManager'] = \OC::$server->getCertificateManager();
+        return new Mount(self::STORAGE, $mountPoint, $data, $this, $this->storageLoader);
+    }
+
+    /**
+     * @param array $data
+     * @return Mount
+     */
+    protected function mountShare($data) {
+        $mount = $this->getMount($data);
+        $this->mountManager->addMount($mount);
+        return $mount;
+    }
+
+    /**
+     * @return \OC\Files\Mount\Manager
+     */
+    public function getMountManager() {
+        return $this->mountManager;
+    }
+
+    /**
+     * @param string $source
+     * @param string $target
+     * @return bool
+     */
+    public function setMountPoint($source, $target) {
+        $source = $this->stripPath($source);
+        $target = $this->stripPath($target);
+        $sourceHash = md5($source);
+        $targetHash = md5($target);
+
+        $query = $this->connection->prepare('
 			UPDATE `*PREFIX*share_external`
 			SET `mountpoint` = ?, `mountpoint_hash` = ?
 			WHERE `mountpoint_hash` = ?
 			AND `user` = ?
 		');
-		$result = (bool)$query->execute([$target, $targetHash, $sourceHash, $this->uid]);
+        $result = (bool)$query->execute([$target, $targetHash, $sourceHash, $this->uid]);
 
-		return $result;
-	}
+        return $result;
+    }
 
-	public function removeShare($mountPoint): bool {
-		try {
-			$mountPointObj = $this->mountManager->find($mountPoint);
-		} catch (NotFoundException $e) {
-			$this->logger->error('Mount point to remove share not found', ['mountPoint' => $mountPoint]);
-			return false;
-		}
-		$id = $mountPointObj->getStorage()->getCache()->getId('');
+    public function removeShare($mountPoint): bool {
+        try {
+            $mountPointObj = $this->mountManager->find($mountPoint);
+        } catch (NotFoundException $e) {
+            $this->logger->error('Mount point to remove share not found', ['mountPoint' => $mountPoint]);
+            return false;
+        }
+        $id = $mountPointObj->getStorage()->getCache()->getId('');
 
-		$mountPoint = $this->stripPath($mountPoint);
-		$hash = md5($mountPoint);
+        $mountPoint = $this->stripPath($mountPoint);
+        $hash = md5($mountPoint);
 
-		try {
-			$getShare = $this->connection->prepare('
+        try {
+            $getShare = $this->connection->prepare('
 				SELECT `remote`, `share_token`, `remote_id`, `share_type`, `id`
 				FROM  `*PREFIX*share_external`
 				WHERE `mountpoint_hash` = ? AND `user` = ?');
-			$result = $getShare->execute([$hash, $this->uid]);
-			$share = $result->fetch();
-			$result->closeCursor();
-			if ($share !== false && (int)$share['share_type'] === IShare::TYPE_USER) {
-				try {
-					$this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
-				} catch (\Throwable $e) {
-					// if we fail to notify the remote (probably cause the remote is down)
-					// we still want the share to be gone to prevent undeletable remotes
-				}
-
-				$query = $this->connection->prepare('
+            $result = $getShare->execute([$hash, $this->uid]);
+            $share = $result->fetch();
+            $result->closeCursor();
+            if ($share !== false && (int)$share['share_type'] === IShare::TYPE_USER) {
+                try {
+                    $this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
+                } catch (\Throwable $e) {
+                    // if we fail to notify the remote (probably cause the remote is down)
+                    // we still want the share to be gone to prevent undeletable remotes
+                }
+
+                $query = $this->connection->prepare('
 					DELETE FROM `*PREFIX*share_external`
 					WHERE `id` = ?
 				');
-				$deleteResult = $query->execute([(int)$share['id']]);
-				$deleteResult->closeCursor();
-			} elseif ($share !== false && (int)$share['share_type'] === IShare::TYPE_GROUP) {
-				$this->updateAccepted((int)$share['id'], false);
-			}
-
-			$this->removeReShares($id);
-		} catch (\Doctrine\DBAL\Exception $ex) {
-			$this->logger->emergency('Could not update share', ['exception' => $ex]);
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * remove re-shares from share table and mapping in the federated_reshares table
-	 *
-	 * @param $mountPointId
-	 */
-	protected function removeReShares($mountPointId) {
-		$selectQuery = $this->connection->getQueryBuilder();
-		$query = $this->connection->getQueryBuilder();
-		$selectQuery->select('id')->from('share')
-			->where($selectQuery->expr()->eq('file_source', $query->createNamedParameter($mountPointId)));
-		$select = $selectQuery->getSQL();
-
-
-		$query->delete('federated_reshares')
-			->where($query->expr()->in('share_id', $query->createFunction('(' . $select . ')')));
-		$query->execute();
-
-		$deleteReShares = $this->connection->getQueryBuilder();
-		$deleteReShares->delete('share')
-			->where($deleteReShares->expr()->eq('file_source', $deleteReShares->createNamedParameter($mountPointId)));
-		$deleteReShares->execute();
-	}
-
-	/**
-	 * remove all shares for user $uid if the user was deleted
-	 *
-	 * @param string $uid
-	 */
-	public function removeUserShares($uid): bool {
-		try {
-			// TODO: use query builder
-			$getShare = $this->connection->prepare('
+                $deleteResult = $query->execute([(int)$share['id']]);
+                $deleteResult->closeCursor();
+            } elseif ($share !== false && (int)$share['share_type'] === IShare::TYPE_GROUP) {
+                $this->updateAccepted((int)$share['id'], false);
+            }
+
+            $this->removeReShares($id);
+        } catch (\Doctrine\DBAL\Exception $ex) {
+            $this->logger->emergency('Could not update share', ['exception' => $ex]);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * remove re-shares from share table and mapping in the federated_reshares table
+     *
+     * @param $mountPointId
+     */
+    protected function removeReShares($mountPointId) {
+        $selectQuery = $this->connection->getQueryBuilder();
+        $query = $this->connection->getQueryBuilder();
+        $selectQuery->select('id')->from('share')
+            ->where($selectQuery->expr()->eq('file_source', $query->createNamedParameter($mountPointId)));
+        $select = $selectQuery->getSQL();
+
+
+        $query->delete('federated_reshares')
+            ->where($query->expr()->in('share_id', $query->createFunction('(' . $select . ')')));
+        $query->execute();
+
+        $deleteReShares = $this->connection->getQueryBuilder();
+        $deleteReShares->delete('share')
+            ->where($deleteReShares->expr()->eq('file_source', $deleteReShares->createNamedParameter($mountPointId)));
+        $deleteReShares->execute();
+    }
+
+    /**
+     * remove all shares for user $uid if the user was deleted
+     *
+     * @param string $uid
+     */
+    public function removeUserShares($uid): bool {
+        try {
+            // TODO: use query builder
+            $getShare = $this->connection->prepare('
 				SELECT `id`, `remote`, `share_type`, `share_token`, `remote_id`
 				FROM  `*PREFIX*share_external`
 				WHERE `user` = ?
 				AND `share_type` = ?');
-			$result = $getShare->execute([$uid, IShare::TYPE_USER]);
-			$shares = $result->fetchAll();
-			$result->closeCursor();
-
-			foreach ($shares as $share) {
-				$this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
-			}
-
-			$qb = $this->connection->getQueryBuilder();
-			$qb->delete('share_external')
-				// user field can specify a user or a group
-				->where($qb->expr()->eq('user', $qb->createNamedParameter($uid)))
-				->andWhere(
-					$qb->expr()->orX(
-						// delete direct shares
-						$qb->expr()->eq('share_type', $qb->expr()->literal(IShare::TYPE_USER)),
-						// delete sub-shares of group shares for that user
-						$qb->expr()->andX(
-							$qb->expr()->eq('share_type', $qb->expr()->literal(IShare::TYPE_GROUP)),
-							$qb->expr()->neq('parent', $qb->expr()->literal(-1)),
-						)
-					)
-				);
-			$qb->execute();
-		} catch (\Doctrine\DBAL\Exception $ex) {
-			$this->logger->emergency('Could not delete user shares', ['exception' => $ex]);
-			return false;
-		}
-
-		return true;
-	}
-
-	public function removeGroupShares($gid): bool {
-		try {
-			$getShare = $this->connection->prepare('
+            $result = $getShare->execute([$uid, IShare::TYPE_USER]);
+            $shares = $result->fetchAll();
+            $result->closeCursor();
+
+            foreach ($shares as $share) {
+                $this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'decline');
+            }
+
+            $qb = $this->connection->getQueryBuilder();
+            $qb->delete('share_external')
+                // user field can specify a user or a group
+                ->where($qb->expr()->eq('user', $qb->createNamedParameter($uid)))
+                ->andWhere(
+                    $qb->expr()->orX(
+                        // delete direct shares
+                        $qb->expr()->eq('share_type', $qb->expr()->literal(IShare::TYPE_USER)),
+                        // delete sub-shares of group shares for that user
+                        $qb->expr()->andX(
+                            $qb->expr()->eq('share_type', $qb->expr()->literal(IShare::TYPE_GROUP)),
+                            $qb->expr()->neq('parent', $qb->expr()->literal(-1)),
+                        )
+                    )
+                );
+            $qb->execute();
+        } catch (\Doctrine\DBAL\Exception $ex) {
+            $this->logger->emergency('Could not delete user shares', ['exception' => $ex]);
+            return false;
+        }
+
+        return true;
+    }
+
+    public function removeGroupShares($gid): bool {
+        try {
+            $getShare = $this->connection->prepare('
 				SELECT `id`, `remote`, `share_type`, `share_token`, `remote_id`
 				FROM  `*PREFIX*share_external`
 				WHERE `user` = ?
 				AND `share_type` = ?');
-			$result = $getShare->execute([$gid, IShare::TYPE_GROUP]);
-			$shares = $result->fetchAll();
-			$result->closeCursor();
-
-			$deletedGroupShares = [];
-			$qb = $this->connection->getQueryBuilder();
-			// delete group share entry and matching sub-entries
-			$qb->delete('share_external')
-			   ->where(
-				   $qb->expr()->orX(
-					   $qb->expr()->eq('id', $qb->createParameter('share_id')),
-					   $qb->expr()->eq('parent', $qb->createParameter('share_parent_id'))
-				   )
-			   );
-
-			foreach ($shares as $share) {
-				$qb->setParameter('share_id', $share['id']);
-				$qb->setParameter('share_parent_id', $share['id']);
-				$qb->execute();
-			}
-		} catch (\Doctrine\DBAL\Exception $ex) {
-			$this->logger->emergency('Could not delete user shares', ['exception' => $ex]);
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * return a list of shares which are not yet accepted by the user
-	 *
-	 * @return array list of open server-to-server shares
-	 */
-	public function getOpenShares() {
-		return $this->getShares(false);
-	}
-
-	/**
-	 * return a list of shares which are accepted by the user
-	 *
-	 * @return array list of accepted server-to-server shares
-	 */
-	public function getAcceptedShares() {
-		return $this->getShares(true);
-	}
-
-	/**
-	 * return a list of shares for the user
-	 *
-	 * @param bool|null $accepted True for accepted only,
-	 *                            false for not accepted,
-	 *                            null for all shares of the user
-	 * @return array list of open server-to-server shares
-	 */
-	private function getShares($accepted) {
-		$user = $this->userManager->get($this->uid);
-		$groups = $this->groupManager->getUserGroups($user);
-		$userGroups = [];
-		foreach ($groups as $group) {
-			$userGroups[] = $group->getGID();
-		}
-
-		$qb = $this->connection->getQueryBuilder();
-		$qb->select('id', 'share_type', 'parent', 'remote', 'remote_id', 'share_token', 'name', 'owner', 'user', 'mountpoint', 'accepted')
-			->from('share_external')
-			->where(
-				$qb->expr()->orX(
-					$qb->expr()->eq('user', $qb->createNamedParameter($this->uid)),
-					$qb->expr()->in(
-						'user',
-						$qb->createNamedParameter($userGroups, IQueryBuilder::PARAM_STR_ARRAY)
-					)
-				)
-			)
-			->orderBy('id', 'ASC');
-
-		try {
-			$result = $qb->execute();
-			$shares = $result->fetchAll();
-			$result->closeCursor();
-
-			// remove parent group share entry if we have a specific user share entry for the user
-			$toRemove = [];
-			foreach ($shares as $share) {
-				if ((int)$share['share_type'] === IShare::TYPE_GROUP && (int)$share['parent'] > 0) {
-					$toRemove[] = $share['parent'];
-				}
-			}
-			$shares = array_filter($shares, function ($share) use ($toRemove) {
-				return !in_array($share['id'], $toRemove, true);
-			});
-
-			if (!is_null($accepted)) {
-				$shares = array_filter($shares, function ($share) use ($accepted) {
-					return (bool)$share['accepted'] === $accepted;
-				});
-			}
-			return array_values($shares);
-		} catch (\Doctrine\DBAL\Exception $e) {
-			$this->logger->emergency('Error when retrieving shares', ['exception' => $e]);
-			return [];
-		}
-	}
+            $result = $getShare->execute([$gid, IShare::TYPE_GROUP]);
+            $shares = $result->fetchAll();
+            $result->closeCursor();
+
+            $deletedGroupShares = [];
+            $qb = $this->connection->getQueryBuilder();
+            // delete group share entry and matching sub-entries
+            $qb->delete('share_external')
+                ->where(
+                    $qb->expr()->orX(
+                        $qb->expr()->eq('id', $qb->createParameter('share_id')),
+                        $qb->expr()->eq('parent', $qb->createParameter('share_parent_id'))
+                    )
+                );
+
+            foreach ($shares as $share) {
+                $qb->setParameter('share_id', $share['id']);
+                $qb->setParameter('share_parent_id', $share['id']);
+                $qb->execute();
+            }
+        } catch (\Doctrine\DBAL\Exception $ex) {
+            $this->logger->emergency('Could not delete user shares', ['exception' => $ex]);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * return a list of shares which are not yet accepted by the user
+     *
+     * @return array list of open server-to-server shares
+     */
+    public function getOpenShares() {
+        return $this->getShares(false);
+    }
+
+    /**
+     * return a list of shares which are accepted by the user
+     *
+     * @return array list of accepted server-to-server shares
+     */
+    public function getAcceptedShares() {
+        return $this->getShares(true);
+    }
+
+    /**
+     * return a list of shares for the user
+     *
+     * @param bool|null $accepted True for accepted only,
+     *                            false for not accepted,
+     *                            null for all shares of the user
+     * @return array list of open server-to-server shares
+     */
+    private function getShares($accepted) {
+        $user = $this->userManager->get($this->uid);
+        $groups = $this->groupManager->getUserGroups($user);
+        $userGroups = [];
+        foreach ($groups as $group) {
+            $userGroups[] = $group->getGID();
+        }
+
+        $qb = $this->connection->getQueryBuilder();
+        $qb->select('id', 'share_type', 'parent', 'remote', 'remote_id', 'share_token', 'name', 'owner', 'user', 'mountpoint', 'accepted')
+            ->from('share_external')
+            ->where(
+                $qb->expr()->orX(
+                    $qb->expr()->eq('user', $qb->createNamedParameter($this->uid)),
+                    $qb->expr()->in(
+                        'user',
+                        $qb->createNamedParameter($userGroups, IQueryBuilder::PARAM_STR_ARRAY)
+                    )
+                )
+            )
+            ->orderBy('id', 'ASC');
+
+        try {
+            $result = $qb->execute();
+            $shares = $result->fetchAll();
+            $result->closeCursor();
+
+            // remove parent group share entry if we have a specific user share entry for the user
+            $toRemove = [];
+            foreach ($shares as $share) {
+                if ((int)$share['share_type'] === IShare::TYPE_GROUP && (int)$share['parent'] > 0) {
+                    $toRemove[] = $share['parent'];
+                }
+            }
+            $shares = array_filter($shares, function ($share) use ($toRemove) {
+                return !in_array($share['id'], $toRemove, true);
+            });
+
+            if (!is_null($accepted)) {
+                $shares = array_filter($shares, function ($share) use ($accepted) {
+                    return (bool)$share['accepted'] === $accepted;
+                });
+            }
+            return array_values($shares);
+        } catch (\Doctrine\DBAL\Exception $e) {
+            $this->logger->emergency('Error when retrieving shares', ['exception' => $e]);
+            return [];
+        }
+    }
 }

apps/files_sharing/lib/Updater.php

Indentation +71 added lines, -71 removed lines

@@ -32,86 +32,86 @@
 
 class Updater {
 
-	/**
-	 * @param array $params
-	 */
-	public static function renameHook($params) {
-		self::renameChildren($params['oldpath'], $params['newpath']);
-		self::moveShareToShare($params['newpath']);
-	}
+    /**
+     * @param array $params
+     */
+    public static function renameHook($params) {
+        self::renameChildren($params['oldpath'], $params['newpath']);
+        self::moveShareToShare($params['newpath']);
+    }
 
-	/**
-	 * Fix for https://github.com/owncloud/core/issues/20769
-	 *
-	 * The owner is allowed to move their files (if they are shared) into a receiving folder
-	 * In this case we need to update the parent of the moved share. Since they are
-	 * effectively handing over ownership of the file the rest of the code needs to know
-	 * they need to build up the reshare tree.
-	 *
-	 * @param string $path
-	 */
-	private static function moveShareToShare($path) {
-		$userFolder = \OC::$server->getUserFolder();
+    /**
+     * Fix for https://github.com/owncloud/core/issues/20769
+     *
+     * The owner is allowed to move their files (if they are shared) into a receiving folder
+     * In this case we need to update the parent of the moved share. Since they are
+     * effectively handing over ownership of the file the rest of the code needs to know
+     * they need to build up the reshare tree.
+     *
+     * @param string $path
+     */
+    private static function moveShareToShare($path) {
+        $userFolder = \OC::$server->getUserFolder();
 
-		// If the user folder can't be constructed (e.g. link share) just return.
-		if ($userFolder === null) {
-			return;
-		}
+        // If the user folder can't be constructed (e.g. link share) just return.
+        if ($userFolder === null) {
+            return;
+        }
 
-		$src = $userFolder->get($path);
+        $src = $userFolder->get($path);
 
-		$shareManager = \OC::$server->getShareManager();
+        $shareManager = \OC::$server->getShareManager();
 
-		$shares = $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_USER, $src, false, -1);
-		$shares = array_merge($shares, $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_GROUP, $src, false, -1));
-		$shares = array_merge($shares, $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_ROOM, $src, false, -1));
+        $shares = $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_USER, $src, false, -1);
+        $shares = array_merge($shares, $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_GROUP, $src, false, -1));
+        $shares = array_merge($shares, $shareManager->getSharesBy($userFolder->getOwner()->getUID(), IShare::TYPE_ROOM, $src, false, -1));
 
-		// If the path we move is not a share we don't care
-		if (empty($shares)) {
-			return;
-		}
+        // If the path we move is not a share we don't care
+        if (empty($shares)) {
+            return;
+        }
 
-		// Check if the destination is inside a share
-		$mountManager = \OC::$server->getMountManager();
-		$dstMount = $mountManager->find($src->getPath());
-		if (!($dstMount instanceof \OCA\Files_Sharing\SharedMount)) {
-			return;
-		}
+        // Check if the destination is inside a share
+        $mountManager = \OC::$server->getMountManager();
+        $dstMount = $mountManager->find($src->getPath());
+        if (!($dstMount instanceof \OCA\Files_Sharing\SharedMount)) {
+            return;
+        }
 
-		$newOwner = $dstMount->getShare()->getShareOwner();
+        $newOwner = $dstMount->getShare()->getShareOwner();
 
-		//Ownership is moved over
-		foreach ($shares as $share) {
-			/** @var IShare $share */
-			if (!($dstMount->getShare()->getPermissions() & Constants::PERMISSION_SHARE)) {
-				$shareManager->deleteShare($share);
-				continue;
-			}
-			$share->setShareOwner($newOwner);
-			$share->setPermissions($share->getPermissions() & $dstMount->getShare()->getPermissions());
-			$shareManager->updateShare($share);
-		}
-	}
+        //Ownership is moved over
+        foreach ($shares as $share) {
+            /** @var IShare $share */
+            if (!($dstMount->getShare()->getPermissions() & Constants::PERMISSION_SHARE)) {
+                $shareManager->deleteShare($share);
+                continue;
+            }
+            $share->setShareOwner($newOwner);
+            $share->setPermissions($share->getPermissions() & $dstMount->getShare()->getPermissions());
+            $shareManager->updateShare($share);
+        }
+    }
 
-	/**
-	 * rename mount point from the children if the parent was renamed
-	 *
-	 * @param string $oldPath old path relative to data/user/files
-	 * @param string $newPath new path relative to data/user/files
-	 */
-	private static function renameChildren($oldPath, $newPath) {
-		$absNewPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $newPath);
-		$absOldPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $oldPath);
+    /**
+     * rename mount point from the children if the parent was renamed
+     *
+     * @param string $oldPath old path relative to data/user/files
+     * @param string $newPath new path relative to data/user/files
+     */
+    private static function renameChildren($oldPath, $newPath) {
+        $absNewPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $newPath);
+        $absOldPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $oldPath);
 
-		$mountManager = \OC\Files\Filesystem::getMountManager();
-		$mountedShares = $mountManager->findIn('/' . \OC_User::getUser() . '/files/' . $oldPath);
-		foreach ($mountedShares as $mount) {
-			/** @var MountPoint $mount */
-			if ($mount->getStorage()->instanceOfStorage(ISharedStorage::class)) {
-				$mountPoint = $mount->getMountPoint();
-				$target = str_replace($absOldPath, $absNewPath, $mountPoint);
-				$mount->moveMount($target);
-			}
-		}
-	}
+        $mountManager = \OC\Files\Filesystem::getMountManager();
+        $mountedShares = $mountManager->findIn('/' . \OC_User::getUser() . '/files/' . $oldPath);
+        foreach ($mountedShares as $mount) {
+            /** @var MountPoint $mount */
+            if ($mount->getStorage()->instanceOfStorage(ISharedStorage::class)) {
+                $mountPoint = $mount->getMountPoint();
+                $target = str_replace($absOldPath, $absNewPath, $mountPoint);
+                $mount->moveMount($target);
+            }
+        }
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -100,11 +100,11 @@
 	 * @param string $newPath new path relative to data/user/files
 	 */
 	private static function renameChildren($oldPath, $newPath) {
-		$absNewPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $newPath);
-		$absOldPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $oldPath);
+		$absNewPath = \OC\Files\Filesystem::normalizePath('/'.\OC_User::getUser().'/files/'.$newPath);
+		$absOldPath = \OC\Files\Filesystem::normalizePath('/'.\OC_User::getUser().'/files/'.$oldPath);
 
 		$mountManager = \OC\Files\Filesystem::getMountManager();
-		$mountedShares = $mountManager->findIn('/' . \OC_User::getUser() . '/files/' . $oldPath);
+		$mountedShares = $mountManager->findIn('/'.\OC_User::getUser().'/files/'.$oldPath);
 		foreach ($mountedShares as $mount) {
 			/** @var MountPoint $mount */
 			if ($mount->getStorage()->instanceOfStorage(ISharedStorage::class)) {