nextcloud / server

lib/private/Files/Cache/Wrapper/CacheJail.php

Indentation +304 added lines, -304 removed lines

@@ -22,308 +22,308 @@
  */
 class CacheJail extends CacheWrapper {
 
-	protected string $unjailedRoot;
-
-	public function __construct(
-		?ICache $cache,
-		protected string $root,
-		?CacheDependencies $dependencies = null,
-	) {
-		parent::__construct($cache, $dependencies);
-
-		$this->unjailedRoot = $root;
-		$parent = $cache;
-		while ($parent instanceof CacheWrapper) {
-			if ($parent instanceof CacheJail) {
-				$this->unjailedRoot = $parent->getSourcePath($this->unjailedRoot);
-			}
-			$parent = $parent->getCache();
-		}
-	}
-
-	/**
-	 * @return string
-	 */
-	protected function getRoot() {
-		return $this->root;
-	}
-
-	/**
-	 * Get the root path with any nested jails resolved
-	 *
-	 * @return string
-	 */
-	public function getGetUnjailedRoot() {
-		return $this->unjailedRoot;
-	}
-
-	/**
-	 * @return string
-	 */
-	protected function getSourcePath(string $path) {
-		if ($path === '') {
-			return $this->getRoot();
-		} else {
-			return $this->getRoot() . '/' . ltrim($path, '/');
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param null|string $root
-	 * @return null|string the jailed path or null if the path is outside the jail
-	 */
-	protected function getJailedPath(string $path, ?string $root = null) {
-		if ($root === null) {
-			$root = $this->getRoot();
-		}
-		if ($root === '') {
-			return $path;
-		}
-		$rootLength = strlen($root) + 1;
-		if ($path === $root) {
-			return '';
-		} elseif (substr($path, 0, $rootLength) === $root . '/') {
-			return substr($path, $rootLength);
-		} else {
-			return null;
-		}
-	}
-
-	protected function formatCacheEntry($entry) {
-		if (isset($entry['path'])) {
-			$entry['path'] = $this->getJailedPath($entry['path']);
-		}
-		return $entry;
-	}
-
-	/**
-	 * get the stored metadata of a file or folder
-	 *
-	 * @param string|int $file
-	 * @return ICacheEntry|false
-	 */
-	public function get($file) {
-		if (is_string($file) or $file == '') {
-			$file = $this->getSourcePath($file);
-		}
-		return parent::get($file);
-	}
-
-	/**
-	 * insert meta data for a new file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function insert($file, array $data) {
-		return $this->getCache()->insert($this->getSourcePath($file), $data);
-	}
-
-	/**
-	 * update the metadata in the cache
-	 *
-	 * @param int $id
-	 * @param array $data
-	 */
-	public function update($id, array $data) {
-		$this->getCache()->update($id, $data);
-	}
-
-	/**
-	 * get the file id for a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getId($file) {
-		return $this->getCache()->getId($this->getSourcePath($file));
-	}
-
-	/**
-	 * get the id of the parent folder of a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getParentId($file) {
-		return $this->getCache()->getParentId($this->getSourcePath($file));
-	}
-
-	/**
-	 * check if a file is available in the cache
-	 *
-	 * @param string $file
-	 * @return bool
-	 */
-	public function inCache($file) {
-		return $this->getCache()->inCache($this->getSourcePath($file));
-	}
-
-	/**
-	 * remove a file or folder from the cache
-	 *
-	 * @param string $file
-	 */
-	public function remove($file) {
-		$this->getCache()->remove($this->getSourcePath($file));
-	}
-
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function move($source, $target) {
-		$this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
-	}
-
-	/**
-	 * Get the storage id and path needed for a move
-	 *
-	 * @param string $path
-	 * @return array [$storageId, $internalPath]
-	 */
-	protected function getMoveInfo($path) {
-		return [$this->getNumericStorageId(), $this->getSourcePath($path)];
-	}
-
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		$this->getCache()->remove($this->getRoot());
-	}
-
-	/**
-	 * @param string $file
-	 *
-	 * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
-	 */
-	public function getStatus($file) {
-		return $this->getCache()->getStatus($this->getSourcePath($file));
-	}
-
-	/**
-	 * update the folder size and the size of all parent folders
-	 *
-	 * @param array|ICacheEntry|null $data (optional) meta data of the folder
-	 */
-	public function correctFolderSize(string $path, $data = null, bool $isBackgroundScan = false): void {
-		$cache = $this->getCache();
-		if ($cache instanceof Cache) {
-			$cache->correctFolderSize($this->getSourcePath($path), $data, $isBackgroundScan);
-		}
-	}
-
-	/**
-	 * get the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array|null|ICacheEntry $entry (optional) meta data of the folder
-	 * @return int|float
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		$cache = $this->getCache();
-		if ($cache instanceof Cache) {
-			return $cache->calculateFolderSize($this->getSourcePath($path), $entry);
-		} else {
-			return 0;
-		}
-	}
-
-	/**
-	 * get all file ids on the files on the storage
-	 *
-	 * @return int[]
-	 */
-	public function getAll() {
-		// not supported
-		return [];
-	}
-
-	/**
-	 * find a folder in the cache which has not been fully scanned
-	 *
-	 * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
-	 * use the one with the highest id gives the best result with the background scanner, since that is most
-	 * likely the folder where we stopped scanning previously
-	 *
-	 * @return string|false the path of the folder or false when no folder matched
-	 */
-	public function getIncomplete() {
-		// not supported
-		return false;
-	}
-
-	/**
-	 * get the path of a file on this storage by it's id
-	 *
-	 * @param int $id
-	 * @return string|null
-	 */
-	public function getPathById($id) {
-		$path = $this->getCache()->getPathById($id);
-		if ($path === null) {
-			return null;
-		}
-
-		return $this->getJailedPath($path);
-	}
-
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * Note that this should make sure the entries are removed from the source cache
-	 *
-	 * @param \OCP\Files\Cache\ICache $sourceCache
-	 * @param string $sourcePath
-	 * @param string $targetPath
-	 */
-	public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
-		if ($sourceCache === $this) {
-			return $this->move($sourcePath, $targetPath);
-		}
-		return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
-	}
-
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return $this->addJailFilterQuery($this->getCache()->getQueryFilterForStorage());
-	}
-
-	protected function addJailFilterQuery(ISearchOperator $filter): ISearchOperator {
-		if ($this->getGetUnjailedRoot() !== '' && $this->getGetUnjailedRoot() !== '/') {
-			return new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND,
-				[
-					$filter,
-					new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR,
-						[
-							new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
-							new SearchComparison(ISearchComparison::COMPARE_LIKE_CASE_SENSITIVE, 'path', SearchComparison::escapeLikeParameter($this->getGetUnjailedRoot()) . '/%'),
-						],
-					)
-				]
-			);
-		} else {
-			return $filter;
-		}
-	}
-
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		if ($this->getGetUnjailedRoot() === '' || str_starts_with($rawEntry->getPath(), $this->getGetUnjailedRoot())) {
-			$rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
-			if ($rawEntry) {
-				$jailedPath = $this->getJailedPath($rawEntry->getPath());
-				if ($jailedPath !== null) {
-					return $this->formatCacheEntry(clone $rawEntry) ?: null;
-				}
-			}
-		}
-
-		return null;
-	}
+    protected string $unjailedRoot;
+
+    public function __construct(
+        ?ICache $cache,
+        protected string $root,
+        ?CacheDependencies $dependencies = null,
+    ) {
+        parent::__construct($cache, $dependencies);
+
+        $this->unjailedRoot = $root;
+        $parent = $cache;
+        while ($parent instanceof CacheWrapper) {
+            if ($parent instanceof CacheJail) {
+                $this->unjailedRoot = $parent->getSourcePath($this->unjailedRoot);
+            }
+            $parent = $parent->getCache();
+        }
+    }
+
+    /**
+     * @return string
+     */
+    protected function getRoot() {
+        return $this->root;
+    }
+
+    /**
+     * Get the root path with any nested jails resolved
+     *
+     * @return string
+     */
+    public function getGetUnjailedRoot() {
+        return $this->unjailedRoot;
+    }
+
+    /**
+     * @return string
+     */
+    protected function getSourcePath(string $path) {
+        if ($path === '') {
+            return $this->getRoot();
+        } else {
+            return $this->getRoot() . '/' . ltrim($path, '/');
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param null|string $root
+     * @return null|string the jailed path or null if the path is outside the jail
+     */
+    protected function getJailedPath(string $path, ?string $root = null) {
+        if ($root === null) {
+            $root = $this->getRoot();
+        }
+        if ($root === '') {
+            return $path;
+        }
+        $rootLength = strlen($root) + 1;
+        if ($path === $root) {
+            return '';
+        } elseif (substr($path, 0, $rootLength) === $root . '/') {
+            return substr($path, $rootLength);
+        } else {
+            return null;
+        }
+    }
+
+    protected function formatCacheEntry($entry) {
+        if (isset($entry['path'])) {
+            $entry['path'] = $this->getJailedPath($entry['path']);
+        }
+        return $entry;
+    }
+
+    /**
+     * get the stored metadata of a file or folder
+     *
+     * @param string|int $file
+     * @return ICacheEntry|false
+     */
+    public function get($file) {
+        if (is_string($file) or $file == '') {
+            $file = $this->getSourcePath($file);
+        }
+        return parent::get($file);
+    }
+
+    /**
+     * insert meta data for a new file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function insert($file, array $data) {
+        return $this->getCache()->insert($this->getSourcePath($file), $data);
+    }
+
+    /**
+     * update the metadata in the cache
+     *
+     * @param int $id
+     * @param array $data
+     */
+    public function update($id, array $data) {
+        $this->getCache()->update($id, $data);
+    }
+
+    /**
+     * get the file id for a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getId($file) {
+        return $this->getCache()->getId($this->getSourcePath($file));
+    }
+
+    /**
+     * get the id of the parent folder of a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getParentId($file) {
+        return $this->getCache()->getParentId($this->getSourcePath($file));
+    }
+
+    /**
+     * check if a file is available in the cache
+     *
+     * @param string $file
+     * @return bool
+     */
+    public function inCache($file) {
+        return $this->getCache()->inCache($this->getSourcePath($file));
+    }
+
+    /**
+     * remove a file or folder from the cache
+     *
+     * @param string $file
+     */
+    public function remove($file) {
+        $this->getCache()->remove($this->getSourcePath($file));
+    }
+
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function move($source, $target) {
+        $this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
+    }
+
+    /**
+     * Get the storage id and path needed for a move
+     *
+     * @param string $path
+     * @return array [$storageId, $internalPath]
+     */
+    protected function getMoveInfo($path) {
+        return [$this->getNumericStorageId(), $this->getSourcePath($path)];
+    }
+
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        $this->getCache()->remove($this->getRoot());
+    }
+
+    /**
+     * @param string $file
+     *
+     * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+     */
+    public function getStatus($file) {
+        return $this->getCache()->getStatus($this->getSourcePath($file));
+    }
+
+    /**
+     * update the folder size and the size of all parent folders
+     *
+     * @param array|ICacheEntry|null $data (optional) meta data of the folder
+     */
+    public function correctFolderSize(string $path, $data = null, bool $isBackgroundScan = false): void {
+        $cache = $this->getCache();
+        if ($cache instanceof Cache) {
+            $cache->correctFolderSize($this->getSourcePath($path), $data, $isBackgroundScan);
+        }
+    }
+
+    /**
+     * get the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array|null|ICacheEntry $entry (optional) meta data of the folder
+     * @return int|float
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        $cache = $this->getCache();
+        if ($cache instanceof Cache) {
+            return $cache->calculateFolderSize($this->getSourcePath($path), $entry);
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * get all file ids on the files on the storage
+     *
+     * @return int[]
+     */
+    public function getAll() {
+        // not supported
+        return [];
+    }
+
+    /**
+     * find a folder in the cache which has not been fully scanned
+     *
+     * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
+     * use the one with the highest id gives the best result with the background scanner, since that is most
+     * likely the folder where we stopped scanning previously
+     *
+     * @return string|false the path of the folder or false when no folder matched
+     */
+    public function getIncomplete() {
+        // not supported
+        return false;
+    }
+
+    /**
+     * get the path of a file on this storage by it's id
+     *
+     * @param int $id
+     * @return string|null
+     */
+    public function getPathById($id) {
+        $path = $this->getCache()->getPathById($id);
+        if ($path === null) {
+            return null;
+        }
+
+        return $this->getJailedPath($path);
+    }
+
+    /**
+     * Move a file or folder in the cache
+     *
+     * Note that this should make sure the entries are removed from the source cache
+     *
+     * @param \OCP\Files\Cache\ICache $sourceCache
+     * @param string $sourcePath
+     * @param string $targetPath
+     */
+    public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
+        if ($sourceCache === $this) {
+            return $this->move($sourcePath, $targetPath);
+        }
+        return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
+    }
+
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return $this->addJailFilterQuery($this->getCache()->getQueryFilterForStorage());
+    }
+
+    protected function addJailFilterQuery(ISearchOperator $filter): ISearchOperator {
+        if ($this->getGetUnjailedRoot() !== '' && $this->getGetUnjailedRoot() !== '/') {
+            return new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND,
+                [
+                    $filter,
+                    new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR,
+                        [
+                            new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
+                            new SearchComparison(ISearchComparison::COMPARE_LIKE_CASE_SENSITIVE, 'path', SearchComparison::escapeLikeParameter($this->getGetUnjailedRoot()) . '/%'),
+                        ],
+                    )
+                ]
+            );
+        } else {
+            return $filter;
+        }
+    }
+
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        if ($this->getGetUnjailedRoot() === '' || str_starts_with($rawEntry->getPath(), $this->getGetUnjailedRoot())) {
+            $rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
+            if ($rawEntry) {
+                $jailedPath = $this->getJailedPath($rawEntry->getPath());
+                if ($jailedPath !== null) {
+                    return $this->formatCacheEntry(clone $rawEntry) ?: null;
+                }
+            }
+        }
+
+        return null;
+    }
 }

apps/files_sharing/lib/Cache.php

Indentation +168 added lines, -168 removed lines

@@ -27,172 +27,172 @@
  * don't use this class directly if you need to get metadata, use \OC\Files\Filesystem::getFileInfo instead
  */
 class Cache extends CacheJail {
-	private bool $rootUnchanged = true;
-	private ?string $ownerDisplayName = null;
-	private $numericId;
-	private DisplayNameCache $displayNameCache;
-
-	/**
-	 * @param SharedStorage $storage
-	 */
-	public function __construct(
-		private $storage,
-		private ICacheEntry $sourceRootInfo,
-		CacheDependencies $dependencies,
-		private IShare $share,
-	) {
-		$this->numericId = $this->sourceRootInfo->getStorageId();
-		$this->displayNameCache = $dependencies->getDisplayNameCache();
-
-		parent::__construct(
-			null,
-			'',
-			$dependencies,
-		);
-	}
-
-	protected function getRoot() {
-		if ($this->root === '') {
-			$absoluteRoot = $this->sourceRootInfo->getPath();
-
-			// the sourceRootInfo path is the absolute path of the folder in the "real" storage
-			// in the case where a folder is shared from a Jail we need to ensure that the share Jail
-			// has its root set relative to the source Jail
-			$currentStorage = $this->storage->getSourceStorage();
-			if ($currentStorage->instanceOfStorage(Jail::class)) {
-				/** @var Jail $currentStorage */
-				$absoluteRoot = $currentStorage->getJailedPath($absoluteRoot);
-			}
-			$this->root = $absoluteRoot ?? '';
-		}
-		return $this->root;
-	}
-
-	public function getGetUnjailedRoot(): string {
-		return $this->sourceRootInfo->getPath();
-	}
-
-	public function getCache(): ICache {
-		if (is_null($this->cache)) {
-			$sourceStorage = $this->storage->getSourceStorage();
-			if ($sourceStorage) {
-				$this->cache = $sourceStorage->getCache();
-			} else {
-				// don't set $this->cache here since sourceStorage will be set later
-				return new FailedCache();
-			}
-		}
-		return $this->cache;
-	}
-
-	public function getNumericStorageId() {
-		if (isset($this->numericId)) {
-			return $this->numericId;
-		} else {
-			return -1;
-		}
-	}
-
-	public function get($file) {
-		if ($this->rootUnchanged && ($file === '' || $file === $this->sourceRootInfo->getId())) {
-			return $this->formatCacheEntry(clone $this->sourceRootInfo, '');
-		}
-		return parent::get($file);
-	}
-
-	public function update($id, array $data) {
-		$this->rootUnchanged = false;
-		parent::update($id, $data);
-	}
-
-	public function insert($file, array $data) {
-		$this->rootUnchanged = false;
-		return parent::insert($file, $data);
-	}
-
-	public function remove($file) {
-		$this->rootUnchanged = false;
-		parent::remove($file);
-	}
-
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		$this->rootUnchanged = false;
-		return parent::moveFromCache($sourceCache, $sourcePath, $targetPath);
-	}
-
-	protected function formatCacheEntry($entry, $path = null) {
-		if (is_null($path)) {
-			$path = $entry['path'] ?? '';
-			$entry['path'] = $this->getJailedPath($path);
-		} else {
-			$entry['path'] = $path;
-		}
-
-		try {
-			if (isset($entry['permissions'])) {
-				$entry['permissions'] &= $this->share->getPermissions();
-			} else {
-				$entry['permissions'] = $this->storage->getPermissions($entry['path']);
-			}
-
-			if ($this->share->getNodeId() === $entry['fileid']) {
-				$entry['name'] = basename($this->share->getTarget());
-			}
-		} catch (StorageNotAvailableException $e) {
-			// thrown by FailedStorage e.g. when the sharer does not exist anymore
-			// (IDE may say the exception is never thrown – false negative)
-			$sharePermissions = 0;
-		}
-		$entry['uid_owner'] = $this->share->getShareOwner();
-		$entry['displayname_owner'] = $this->getOwnerDisplayName();
-		if ($path === '') {
-			$entry['is_share_mount_point'] = true;
-		}
-		return $entry;
-	}
-
-	private function getOwnerDisplayName() {
-		if (!$this->ownerDisplayName) {
-			$uid = $this->share->getShareOwner();
-			$this->ownerDisplayName = $this->displayNameCache->getDisplayName($uid) ?? $uid;
-		}
-		return $this->ownerDisplayName;
-	}
-
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		// Not a valid action for Shared Cache
-	}
-
-	public function getQueryFilterForStorage(): ISearchOperator {
-		$storageFilter = \OC\Files\Cache\Cache::getQueryFilterForStorage();
-
-		// Do the normal jail behavior for non files
-		if ($this->storage->getItemType() !== 'file') {
-			return $this->addJailFilterQuery($storageFilter);
-		}
-
-		// for single file shares we don't need to do the LIKE
-		return new SearchBinaryOperator(
-			ISearchBinaryOperator::OPERATOR_AND,
-			[
-				$storageFilter,
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
-			]
-		);
-	}
-
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		if ($rawEntry->getStorageId() === $this->getNumericStorageId()) {
-			return parent::getCacheEntryFromSearchResult($rawEntry);
-		} else {
-			return null;
-		}
-	}
-
-	public function markRootChanged(): void {
-		$this->rootUnchanged = false;
-	}
+    private bool $rootUnchanged = true;
+    private ?string $ownerDisplayName = null;
+    private $numericId;
+    private DisplayNameCache $displayNameCache;
+
+    /**
+     * @param SharedStorage $storage
+     */
+    public function __construct(
+        private $storage,
+        private ICacheEntry $sourceRootInfo,
+        CacheDependencies $dependencies,
+        private IShare $share,
+    ) {
+        $this->numericId = $this->sourceRootInfo->getStorageId();
+        $this->displayNameCache = $dependencies->getDisplayNameCache();
+
+        parent::__construct(
+            null,
+            '',
+            $dependencies,
+        );
+    }
+
+    protected function getRoot() {
+        if ($this->root === '') {
+            $absoluteRoot = $this->sourceRootInfo->getPath();
+
+            // the sourceRootInfo path is the absolute path of the folder in the "real" storage
+            // in the case where a folder is shared from a Jail we need to ensure that the share Jail
+            // has its root set relative to the source Jail
+            $currentStorage = $this->storage->getSourceStorage();
+            if ($currentStorage->instanceOfStorage(Jail::class)) {
+                /** @var Jail $currentStorage */
+                $absoluteRoot = $currentStorage->getJailedPath($absoluteRoot);
+            }
+            $this->root = $absoluteRoot ?? '';
+        }
+        return $this->root;
+    }
+
+    public function getGetUnjailedRoot(): string {
+        return $this->sourceRootInfo->getPath();
+    }
+
+    public function getCache(): ICache {
+        if (is_null($this->cache)) {
+            $sourceStorage = $this->storage->getSourceStorage();
+            if ($sourceStorage) {
+                $this->cache = $sourceStorage->getCache();
+            } else {
+                // don't set $this->cache here since sourceStorage will be set later
+                return new FailedCache();
+            }
+        }
+        return $this->cache;
+    }
+
+    public function getNumericStorageId() {
+        if (isset($this->numericId)) {
+            return $this->numericId;
+        } else {
+            return -1;
+        }
+    }
+
+    public function get($file) {
+        if ($this->rootUnchanged && ($file === '' || $file === $this->sourceRootInfo->getId())) {
+            return $this->formatCacheEntry(clone $this->sourceRootInfo, '');
+        }
+        return parent::get($file);
+    }
+
+    public function update($id, array $data) {
+        $this->rootUnchanged = false;
+        parent::update($id, $data);
+    }
+
+    public function insert($file, array $data) {
+        $this->rootUnchanged = false;
+        return parent::insert($file, $data);
+    }
+
+    public function remove($file) {
+        $this->rootUnchanged = false;
+        parent::remove($file);
+    }
+
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        $this->rootUnchanged = false;
+        return parent::moveFromCache($sourceCache, $sourcePath, $targetPath);
+    }
+
+    protected function formatCacheEntry($entry, $path = null) {
+        if (is_null($path)) {
+            $path = $entry['path'] ?? '';
+            $entry['path'] = $this->getJailedPath($path);
+        } else {
+            $entry['path'] = $path;
+        }
+
+        try {
+            if (isset($entry['permissions'])) {
+                $entry['permissions'] &= $this->share->getPermissions();
+            } else {
+                $entry['permissions'] = $this->storage->getPermissions($entry['path']);
+            }
+
+            if ($this->share->getNodeId() === $entry['fileid']) {
+                $entry['name'] = basename($this->share->getTarget());
+            }
+        } catch (StorageNotAvailableException $e) {
+            // thrown by FailedStorage e.g. when the sharer does not exist anymore
+            // (IDE may say the exception is never thrown – false negative)
+            $sharePermissions = 0;
+        }
+        $entry['uid_owner'] = $this->share->getShareOwner();
+        $entry['displayname_owner'] = $this->getOwnerDisplayName();
+        if ($path === '') {
+            $entry['is_share_mount_point'] = true;
+        }
+        return $entry;
+    }
+
+    private function getOwnerDisplayName() {
+        if (!$this->ownerDisplayName) {
+            $uid = $this->share->getShareOwner();
+            $this->ownerDisplayName = $this->displayNameCache->getDisplayName($uid) ?? $uid;
+        }
+        return $this->ownerDisplayName;
+    }
+
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        // Not a valid action for Shared Cache
+    }
+
+    public function getQueryFilterForStorage(): ISearchOperator {
+        $storageFilter = \OC\Files\Cache\Cache::getQueryFilterForStorage();
+
+        // Do the normal jail behavior for non files
+        if ($this->storage->getItemType() !== 'file') {
+            return $this->addJailFilterQuery($storageFilter);
+        }
+
+        // for single file shares we don't need to do the LIKE
+        return new SearchBinaryOperator(
+            ISearchBinaryOperator::OPERATOR_AND,
+            [
+                $storageFilter,
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
+            ]
+        );
+    }
+
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        if ($rawEntry->getStorageId() === $this->getNumericStorageId()) {
+            return parent::getCacheEntryFromSearchResult($rawEntry);
+        } else {
+            return null;
+        }
+    }
+
+    public function markRootChanged(): void {
+        $this->rootUnchanged = false;
+    }
 }

tests/lib/Files/Cache/Wrapper/CacheJailTest.php

Indentation +237 added lines, -237 removed lines

@@ -26,241 +26,241 @@
  * @package Test\Files\Cache\Wrapper
  */
 class CacheJailTest extends CacheTest {
-	/**
-	 * @var \OC\Files\Cache\Cache $sourceCache
-	 */
-	protected $sourceCache;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->storage->mkdir('jail');
-		$this->sourceCache = $this->cache;
-		$this->cache = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, 'jail');
-		$this->cache->insert('', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
-	}
-
-	public function testSearchOutsideJail(): void {
-		$this->storage->getScanner()->scan('');
-		$file1 = 'jail/foobar';
-		$file2 = 'folder/foobar';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
-
-		$this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-
-		$this->assertCount(2, $this->sourceCache->search('%foobar'));
-
-		$result = $this->cache->search('%foobar%');
-		$this->assertCount(1, $result);
-		$this->assertEquals('foobar', $result[0]['path']);
-
-		$result = $this->cache->search('%foo%');
-		$this->assertCount(1, $result);
-		usort($result, function ($a, $b) {
-			return $a['path'] <=> $b['path'];
-		});
-		$this->assertEquals('foobar', $result[0]['path']);
-	}
-
-	public function testSearchMimeOutsideJail(): void {
-		$this->storage->getScanner()->scan('');
-		$file1 = 'jail/foobar';
-		$file2 = 'folder/foobar';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
-
-		$this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-
-		$this->assertCount(2, $this->sourceCache->searchByMime('foo/folder'));
-
-		$result = $this->cache->search('%foobar%');
-		$this->assertCount(1, $result);
-		$this->assertEquals('foobar', $result[0]['path']);
-	}
-
-	public function testSearchQueryOutsideJail(): void {
-		$this->storage->getScanner()->scan('');
-		$file1 = 'jail/foobar';
-		$file2 = 'folder/foobar';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
-
-
-		$this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-
-		$user = new User('foo', null, $this->createMock(IEventDispatcher::class));
-		$query = new SearchQuery(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'foobar'), 10, 0, [], $user);
-		$result = $this->cache->searchQuery($query);
-
-		$this->assertCount(1, $result);
-		$this->assertEquals('foobar', $result[0]['path']);
-
-		$query = new SearchQuery(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'jail'), 10, 0, [], $user);
-		$result = $this->cache->searchQuery($query);
-		$this->assertCount(1, $result);
-		$this->assertEquals('', $result[0]['path']);
-	}
-
-	public function testClearKeepEntriesOutsideJail(): void {
-		$file1 = 'jail/foobar';
-		$file2 = 'jail/foobar/asd';
-		$file3 = 'folder/foobar';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
-
-		$this->sourceCache->put('folder', $data1);
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-		$this->sourceCache->put($file3, $data1);
-
-		$this->cache->clear();
-
-		$this->assertFalse($this->cache->inCache('foobar'));
-		$this->assertTrue($this->sourceCache->inCache('folder/foobar'));
-	}
-
-	public function testGetById(): void {
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
-		$id = $this->sourceCache->put('jail/bar', $data1);
-
-		// path from jailed foo of foo/bar is bar
-		$path = $this->cache->getPathById($id);
-		$this->assertEquals('bar', $path);
-
-		// path from jailed '' of foo/bar is foo/bar
-		$this->cache = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, '');
-		$path = $this->cache->getPathById($id);
-		$this->assertEquals('jail/bar', $path);
-	}
-
-	public function testGetIncomplete(): void {
-		//not supported
-		$this->addToAssertionCount(1);
-	}
-
-	public function testMoveFromJail(): void {
-		$folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
-
-		$this->sourceCache->put('source', $folderData);
-		$this->sourceCache->put('source/foo', $folderData);
-		$this->sourceCache->put('source/foo/bar', $folderData);
-		$this->sourceCache->put('target', $folderData);
-
-		$jail = new CacheJail($this->sourceCache, 'source');
-
-		$this->sourceCache->moveFromCache($jail, 'foo', 'target/foo');
-
-		$this->assertTrue($this->sourceCache->inCache('target/foo'));
-		$this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
-	}
-
-	public function testMoveToJail(): void {
-		$folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
-
-		$this->sourceCache->put('source', $folderData);
-		$this->sourceCache->put('source/foo', $folderData);
-		$this->sourceCache->put('source/foo/bar', $folderData);
-		$this->sourceCache->put('target', $folderData);
-
-		$jail = new CacheJail($this->sourceCache, 'target');
-
-		$jail->moveFromCache($this->sourceCache, 'source/foo', 'foo');
-
-		$this->assertTrue($this->sourceCache->inCache('target/foo'));
-		$this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
-	}
-
-	public function testMoveBetweenJail(): void {
-		$folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
-
-		$this->sourceCache->put('source', $folderData);
-		$this->sourceCache->put('source/foo', $folderData);
-		$this->sourceCache->put('source/foo/bar', $folderData);
-		$this->sourceCache->put('target', $folderData);
-
-		$jail = new CacheJail($this->sourceCache, 'target');
-		$sourceJail = new CacheJail($this->sourceCache, 'source');
-
-		$jail->moveFromCache($sourceJail, 'foo', 'foo');
-
-		$this->assertTrue($this->sourceCache->inCache('target/foo'));
-		$this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
-	}
-
-	public function testSearchNested(): void {
-		$this->storage->getScanner()->scan('');
-		$file1 = 'jail';
-		$file2 = 'jail/bar';
-		$file3 = 'jail/bar/asd';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
-
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-		$this->sourceCache->put($file3, $data1);
-
-		$nested = new \OC\Files\Cache\Wrapper\CacheJail($this->cache, 'bar');
-
-		$result = $nested->search('%asd%');
-		$this->assertCount(1, $result);
-		$this->assertEquals('asd', $result[0]['path']);
-	}
-
-	public function testRootJail(): void {
-		$this->storage->getScanner()->scan('');
-		$file1 = 'jail';
-		$file2 = 'jail/bar';
-		$file3 = 'jail/bar/asd';
-		$data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
-
-		$this->sourceCache->put($file1, $data1);
-		$this->sourceCache->put($file2, $data1);
-		$this->sourceCache->put($file3, $data1);
-
-		$nested = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, '');
-
-		$result = $nested->search('%asd%');
-		$this->assertCount(1, $result);
-		$this->assertEquals('jail/bar/asd', $result[0]['path']);
-	}
-
-	public function testWatcher(): void {
-		$storage = new Jail([
-			'storage' => $this->storage,
-			'root' => 'jail'
-		]);
-		$storage->getScanner()->scan('');
-		$storage->file_put_contents('bar', 'asd');
-
-		$this->assertFalse($this->cache->inCache('bar'));
-		$storage->getWatcher()->update('bar', ['mimetype' => 'text/plain']);
-		$this->assertTrue($this->cache->inCache('bar'));
-	}
-
-	public function testWatcherAfterInnerWatcher(): void {
-		$storage = new Jail([
-			'storage' => $this->storage,
-			'root' => 'jail'
-		]);
-		$storage->getScanner()->scan('');
-		$storage->file_put_contents('bar', 'asd');
-
-		// let the underlying storage create it's watcher first
-		$this->storage->getWatcher();
-
-		$this->assertFalse($this->cache->inCache('bar'));
-		$storage->getWatcher()->update('bar', ['mimetype' => 'text/plain']);
-		$this->assertTrue($this->cache->inCache('bar'));
-	}
-
-	public function testUnJailedRoot(): void {
-		$jail1 = new CacheJail($this->sourceCache, 'foo');
-		$jail2 = new CacheJail($jail1, 'bar');
-		$this->assertEquals('foo/bar', $jail2->getGetUnjailedRoot());
-
-		$middleWrapper = new CacheWrapper($jail1);
-		$jail3 = new CacheJail($middleWrapper, 'bar');
-		$this->assertEquals('foo/bar', $jail3->getGetUnjailedRoot());
-	}
+    /**
+     * @var \OC\Files\Cache\Cache $sourceCache
+     */
+    protected $sourceCache;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->storage->mkdir('jail');
+        $this->sourceCache = $this->cache;
+        $this->cache = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, 'jail');
+        $this->cache->insert('', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
+    }
+
+    public function testSearchOutsideJail(): void {
+        $this->storage->getScanner()->scan('');
+        $file1 = 'jail/foobar';
+        $file2 = 'folder/foobar';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
+
+        $this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+
+        $this->assertCount(2, $this->sourceCache->search('%foobar'));
+
+        $result = $this->cache->search('%foobar%');
+        $this->assertCount(1, $result);
+        $this->assertEquals('foobar', $result[0]['path']);
+
+        $result = $this->cache->search('%foo%');
+        $this->assertCount(1, $result);
+        usort($result, function ($a, $b) {
+            return $a['path'] <=> $b['path'];
+        });
+        $this->assertEquals('foobar', $result[0]['path']);
+    }
+
+    public function testSearchMimeOutsideJail(): void {
+        $this->storage->getScanner()->scan('');
+        $file1 = 'jail/foobar';
+        $file2 = 'folder/foobar';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
+
+        $this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+
+        $this->assertCount(2, $this->sourceCache->searchByMime('foo/folder'));
+
+        $result = $this->cache->search('%foobar%');
+        $this->assertCount(1, $result);
+        $this->assertEquals('foobar', $result[0]['path']);
+    }
+
+    public function testSearchQueryOutsideJail(): void {
+        $this->storage->getScanner()->scan('');
+        $file1 = 'jail/foobar';
+        $file2 = 'folder/foobar';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
+
+
+        $this->sourceCache->insert('folder', ['size' => 0, 'mtime' => 0, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+
+        $user = new User('foo', null, $this->createMock(IEventDispatcher::class));
+        $query = new SearchQuery(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'foobar'), 10, 0, [], $user);
+        $result = $this->cache->searchQuery($query);
+
+        $this->assertCount(1, $result);
+        $this->assertEquals('foobar', $result[0]['path']);
+
+        $query = new SearchQuery(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'jail'), 10, 0, [], $user);
+        $result = $this->cache->searchQuery($query);
+        $this->assertCount(1, $result);
+        $this->assertEquals('', $result[0]['path']);
+    }
+
+    public function testClearKeepEntriesOutsideJail(): void {
+        $file1 = 'jail/foobar';
+        $file2 = 'jail/foobar/asd';
+        $file3 = 'folder/foobar';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
+
+        $this->sourceCache->put('folder', $data1);
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+        $this->sourceCache->put($file3, $data1);
+
+        $this->cache->clear();
+
+        $this->assertFalse($this->cache->inCache('foobar'));
+        $this->assertTrue($this->sourceCache->inCache('folder/foobar'));
+    }
+
+    public function testGetById(): void {
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
+        $id = $this->sourceCache->put('jail/bar', $data1);
+
+        // path from jailed foo of foo/bar is bar
+        $path = $this->cache->getPathById($id);
+        $this->assertEquals('bar', $path);
+
+        // path from jailed '' of foo/bar is foo/bar
+        $this->cache = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, '');
+        $path = $this->cache->getPathById($id);
+        $this->assertEquals('jail/bar', $path);
+    }
+
+    public function testGetIncomplete(): void {
+        //not supported
+        $this->addToAssertionCount(1);
+    }
+
+    public function testMoveFromJail(): void {
+        $folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
+
+        $this->sourceCache->put('source', $folderData);
+        $this->sourceCache->put('source/foo', $folderData);
+        $this->sourceCache->put('source/foo/bar', $folderData);
+        $this->sourceCache->put('target', $folderData);
+
+        $jail = new CacheJail($this->sourceCache, 'source');
+
+        $this->sourceCache->moveFromCache($jail, 'foo', 'target/foo');
+
+        $this->assertTrue($this->sourceCache->inCache('target/foo'));
+        $this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
+    }
+
+    public function testMoveToJail(): void {
+        $folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
+
+        $this->sourceCache->put('source', $folderData);
+        $this->sourceCache->put('source/foo', $folderData);
+        $this->sourceCache->put('source/foo/bar', $folderData);
+        $this->sourceCache->put('target', $folderData);
+
+        $jail = new CacheJail($this->sourceCache, 'target');
+
+        $jail->moveFromCache($this->sourceCache, 'source/foo', 'foo');
+
+        $this->assertTrue($this->sourceCache->inCache('target/foo'));
+        $this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
+    }
+
+    public function testMoveBetweenJail(): void {
+        $folderData = ['size' => 100, 'mtime' => 50, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE];
+
+        $this->sourceCache->put('source', $folderData);
+        $this->sourceCache->put('source/foo', $folderData);
+        $this->sourceCache->put('source/foo/bar', $folderData);
+        $this->sourceCache->put('target', $folderData);
+
+        $jail = new CacheJail($this->sourceCache, 'target');
+        $sourceJail = new CacheJail($this->sourceCache, 'source');
+
+        $jail->moveFromCache($sourceJail, 'foo', 'foo');
+
+        $this->assertTrue($this->sourceCache->inCache('target/foo'));
+        $this->assertTrue($this->sourceCache->inCache('target/foo/bar'));
+    }
+
+    public function testSearchNested(): void {
+        $this->storage->getScanner()->scan('');
+        $file1 = 'jail';
+        $file2 = 'jail/bar';
+        $file3 = 'jail/bar/asd';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
+
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+        $this->sourceCache->put($file3, $data1);
+
+        $nested = new \OC\Files\Cache\Wrapper\CacheJail($this->cache, 'bar');
+
+        $result = $nested->search('%asd%');
+        $this->assertCount(1, $result);
+        $this->assertEquals('asd', $result[0]['path']);
+    }
+
+    public function testRootJail(): void {
+        $this->storage->getScanner()->scan('');
+        $file1 = 'jail';
+        $file2 = 'jail/bar';
+        $file3 = 'jail/bar/asd';
+        $data1 = ['size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder'];
+
+        $this->sourceCache->put($file1, $data1);
+        $this->sourceCache->put($file2, $data1);
+        $this->sourceCache->put($file3, $data1);
+
+        $nested = new \OC\Files\Cache\Wrapper\CacheJail($this->sourceCache, '');
+
+        $result = $nested->search('%asd%');
+        $this->assertCount(1, $result);
+        $this->assertEquals('jail/bar/asd', $result[0]['path']);
+    }
+
+    public function testWatcher(): void {
+        $storage = new Jail([
+            'storage' => $this->storage,
+            'root' => 'jail'
+        ]);
+        $storage->getScanner()->scan('');
+        $storage->file_put_contents('bar', 'asd');
+
+        $this->assertFalse($this->cache->inCache('bar'));
+        $storage->getWatcher()->update('bar', ['mimetype' => 'text/plain']);
+        $this->assertTrue($this->cache->inCache('bar'));
+    }
+
+    public function testWatcherAfterInnerWatcher(): void {
+        $storage = new Jail([
+            'storage' => $this->storage,
+            'root' => 'jail'
+        ]);
+        $storage->getScanner()->scan('');
+        $storage->file_put_contents('bar', 'asd');
+
+        // let the underlying storage create it's watcher first
+        $this->storage->getWatcher();
+
+        $this->assertFalse($this->cache->inCache('bar'));
+        $storage->getWatcher()->update('bar', ['mimetype' => 'text/plain']);
+        $this->assertTrue($this->cache->inCache('bar'));
+    }
+
+    public function testUnJailedRoot(): void {
+        $jail1 = new CacheJail($this->sourceCache, 'foo');
+        $jail2 = new CacheJail($jail1, 'bar');
+        $this->assertEquals('foo/bar', $jail2->getGetUnjailedRoot());
+
+        $middleWrapper = new CacheWrapper($jail1);
+        $jail3 = new CacheJail($middleWrapper, 'bar');
+        $this->assertEquals('foo/bar', $jail3->getGetUnjailedRoot());
+    }
 }