nextcloud / server

lib/public/Files/Cache/IPropagator.php

Indentation +24 added lines, -24 removed lines

@@ -19,30 +19,30 @@
  */
 #[Consumable(since: '9.0.0')]
 interface IPropagator {
-	/**
-	 * Mark the beginning of a propagation batch.
-	 *
-	 * Note that not all cache setups support propagation in which case this will be a noop
-	 *
-	 * Batching for cache setups that do support it has to be explicit since the cache state is not fully consistent
-	 * before the batch is committed.
-	 *
-	 * @since 9.1.0
-	 */
-	public function beginBatch(): void;
+    /**
+     * Mark the beginning of a propagation batch.
+     *
+     * Note that not all cache setups support propagation in which case this will be a noop
+     *
+     * Batching for cache setups that do support it has to be explicit since the cache state is not fully consistent
+     * before the batch is committed.
+     *
+     * @since 9.1.0
+     */
+    public function beginBatch(): void;
 
-	/**
-	 * Commit the active propagation batch.
-	 *
-	 * @since 9.1.0
-	 */
-	public function commitBatch(): void;
+    /**
+     * Commit the active propagation batch.
+     *
+     * @since 9.1.0
+     */
+    public function commitBatch(): void;
 
-	/**
-	 * @param string $internalPath
-	 * @param int $time
-	 * @param int $sizeDifference The number of bytes the file has grown.
-	 * @since 9.0.0
-	 */
-	public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void;
+    /**
+     * @param string $internalPath
+     * @param int $time
+     * @param int $sizeDifference The number of bytes the file has grown.
+     * @since 9.0.0
+     */
+    public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void;
 }

lib/private/Files/Cache/HomePropagator.php

Indentation +3 added lines, -3 removed lines

@@ -13,7 +13,7 @@
 use OCP\IDBConnection;
 
 class HomePropagator extends Propagator {
-	public function __construct(IStorage $storage, IDBConnection $connection) {
-		parent::__construct($storage, $connection, ignore: ['files_encryption']);
-	}
+    public function __construct(IStorage $storage, IDBConnection $connection) {
+        parent::__construct($storage, $connection, ignore: ['files_encryption']);
+    }
 }

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

Indentation +7 added lines, -7 removed lines

@@ -13,11 +13,11 @@
 use Override;
 
 class JailPropagator extends Propagator {
-	#[Override]
-	public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void {
-		/** @var Jail $jail */
-		$jail = $this->storage;
-		[$storage, $sourceInternalPath] = $jail->resolvePath($internalPath);
-		$storage->getPropagator()->propagateChange($sourceInternalPath, $time, $sizeDifference);
-	}
+    #[Override]
+    public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void {
+        /** @var Jail $jail */
+        $jail = $this->storage;
+        [$storage, $sourceInternalPath] = $jail->resolvePath($internalPath);
+        $storage->getPropagator()->propagateChange($sourceInternalPath, $time, $sizeDifference);
+    }
 }

lib/private/Files/Cache/Propagator.php

Indentation +174 added lines, -174 removed lines

@@ -22,178 +22,178 @@
 use Psr\Log\LoggerInterface;
 
 class Propagator implements IPropagator {
-	public const MAX_RETRIES = 3;
-
-	private bool $inBatch = false;
-	private array $batch = [];
-	private ClockInterface $clock;
-
-	public function __construct(
-		protected readonly IStorage $storage,
-		private readonly IDBConnection $connection,
-		private readonly array $ignore = [],
-	) {
-		$this->clock = Server::get(ClockInterface::class);
-	}
-
-	#[Override]
-	public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void {
-		// Do not propagate changes in ignored paths
-		foreach ($this->ignore as $ignore) {
-			if (str_starts_with($internalPath, $ignore)) {
-				return;
-			}
-		}
-
-		$time = min($time, $this->clock->now()->getTimestamp());
-
-		$storageId = $this->storage->getCache()->getNumericStorageId();
-
-		$parents = $this->getParents($internalPath);
-
-		if ($this->inBatch) {
-			foreach ($parents as $parent) {
-				$this->addToBatch($parent, $time, $sizeDifference);
-			}
-			return;
-		}
-
-		$parentHashes = array_map('md5', $parents);
-		$etag = uniqid(); // since we give all folders the same etag we don't ask the storage for the etag
-
-		$builder = $this->connection->getQueryBuilder();
-		$hashParams = array_map(function ($hash) use ($builder) {
-			return $builder->expr()->literal($hash);
-		}, $parentHashes);
-
-		$builder->update('filecache')
-			->set('mtime', $builder->func()->greatest('mtime', $builder->createNamedParameter($time, IQueryBuilder::PARAM_INT)))
-			->where($builder->expr()->eq('storage', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
-			->andWhere($builder->expr()->in('path_hash', $hashParams));
-		if (!$this->storage->instanceOfStorage(IReliableEtagStorage::class)) {
-			$builder->set('etag', $builder->createNamedParameter($etag, IQueryBuilder::PARAM_STR));
-		}
-
-		if ($sizeDifference !== 0) {
-			$hasCalculatedSize = $builder->expr()->gt('size', $builder->expr()->literal(-1, IQUeryBuilder::PARAM_INT));
-			$sizeColumn = $builder->getColumnName('size');
-			$newSize = $builder->func()->greatest(
-				$builder->func()->add('size', $builder->createNamedParameter($sizeDifference)),
-				$builder->createNamedParameter(-1, IQueryBuilder::PARAM_INT)
-			);
-
-			// Only update if row had a previously calculated size
-			$builder->set('size', $builder->createFunction("CASE WHEN $hasCalculatedSize THEN $newSize ELSE $sizeColumn END"));
-
-			if ($this->storage->instanceOfStorage(Encryption::class)) {
-				// in case of encryption being enabled after some files are already uploaded, some entries will have an unencrypted_size of 0 and a non-zero size
-				$hasUnencryptedSize = $builder->expr()->neq('unencrypted_size', $builder->expr()->literal(0, IQueryBuilder::PARAM_INT));
-				$sizeColumn = $builder->getColumnName('size');
-				$unencryptedSizeColumn = $builder->getColumnName('unencrypted_size');
-				$newUnencryptedSize = $builder->func()->greatest(
-					$builder->func()->add(
-						$builder->createFunction("CASE WHEN $hasUnencryptedSize THEN $unencryptedSizeColumn ELSE $sizeColumn END"),
-						$builder->createNamedParameter($sizeDifference)
-					),
-					$builder->createNamedParameter(-1, IQueryBuilder::PARAM_INT)
-				);
-
-				// Only update if row had a previously calculated size
-				$builder->set('unencrypted_size', $builder->createFunction("CASE WHEN $hasCalculatedSize THEN $newUnencryptedSize ELSE $unencryptedSizeColumn END"));
-			}
-		}
-
-		for ($i = 0; $i < self::MAX_RETRIES; $i++) {
-			try {
-				$builder->executeStatement();
-				break;
-			} catch (DbalException $e) {
-				if (!$e->isRetryable()) {
-					throw $e;
-				}
-
-				/** @var LoggerInterface $loggerInterface */
-				$loggerInterface = \OCP\Server::get(LoggerInterface::class);
-				$loggerInterface->warning('Retrying propagation query after retryable exception.', [ 'exception' => $e ]);
-			}
-		}
-	}
-
-	/**
-	 * @return string[]
-	 */
-	protected function getParents(string $path): array {
-		$parts = explode('/', $path);
-		$parent = '';
-		$parents = [];
-		foreach ($parts as $part) {
-			$parents[] = $parent;
-			$parent = trim($parent . '/' . $part, '/');
-		}
-		return $parents;
-	}
-
-	#[Override]
-	public function beginBatch(): void {
-		$this->inBatch = true;
-	}
-
-	private function addToBatch(string $internalPath, int $time, int $sizeDifference): void {
-		if (!isset($this->batch[$internalPath])) {
-			$this->batch[$internalPath] = [
-				'hash' => md5($internalPath),
-				'time' => $time,
-				'size' => $sizeDifference,
-			];
-		} else {
-			$this->batch[$internalPath]['size'] += $sizeDifference;
-			if ($time > $this->batch[$internalPath]['time']) {
-				$this->batch[$internalPath]['time'] = $time;
-			}
-		}
-	}
-
-	#[Override]
-	public function commitBatch(): void {
-		if (!$this->inBatch) {
-			throw new \BadMethodCallException('Not in batch');
-		}
-		$this->inBatch = false;
-
-		$this->connection->beginTransaction();
-
-		$query = $this->connection->getQueryBuilder();
-		$storageId = $this->storage->getCache()->getNumericStorageId();
-
-		$query->update('filecache')
-			->set('mtime', $query->func()->greatest('mtime', $query->createParameter('time')))
-			->set('etag', $query->expr()->literal(uniqid()))
-			->where($query->expr()->eq('storage', $query->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
-			->andWhere($query->expr()->eq('path_hash', $query->createParameter('hash')));
-
-		$sizeQuery = $this->connection->getQueryBuilder();
-		$sizeQuery->update('filecache')
-			->set('size', $sizeQuery->func()->add('size', $sizeQuery->createParameter('size')))
-			->where($query->expr()->eq('storage', $sizeQuery->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
-			->andWhere($query->expr()->eq('path_hash', $sizeQuery->createParameter('hash')))
-			->andWhere($sizeQuery->expr()->gt('size', $sizeQuery->createNamedParameter(-1, IQueryBuilder::PARAM_INT)));
-
-		foreach ($this->batch as $item) {
-			$query->setParameter('time', $item['time'], IQueryBuilder::PARAM_INT);
-			$query->setParameter('hash', $item['hash']);
-
-			$query->executeStatement();
-
-			if ($item['size']) {
-				$sizeQuery->setParameter('size', $item['size'], IQueryBuilder::PARAM_INT);
-				$sizeQuery->setParameter('hash', $item['hash']);
-
-				$sizeQuery->executeStatement();
-			}
-		}
-
-		$this->batch = [];
-
-		$this->connection->commit();
-	}
+    public const MAX_RETRIES = 3;
+
+    private bool $inBatch = false;
+    private array $batch = [];
+    private ClockInterface $clock;
+
+    public function __construct(
+        protected readonly IStorage $storage,
+        private readonly IDBConnection $connection,
+        private readonly array $ignore = [],
+    ) {
+        $this->clock = Server::get(ClockInterface::class);
+    }
+
+    #[Override]
+    public function propagateChange(string $internalPath, int $time, int $sizeDifference = 0): void {
+        // Do not propagate changes in ignored paths
+        foreach ($this->ignore as $ignore) {
+            if (str_starts_with($internalPath, $ignore)) {
+                return;
+            }
+        }
+
+        $time = min($time, $this->clock->now()->getTimestamp());
+
+        $storageId = $this->storage->getCache()->getNumericStorageId();
+
+        $parents = $this->getParents($internalPath);
+
+        if ($this->inBatch) {
+            foreach ($parents as $parent) {
+                $this->addToBatch($parent, $time, $sizeDifference);
+            }
+            return;
+        }
+
+        $parentHashes = array_map('md5', $parents);
+        $etag = uniqid(); // since we give all folders the same etag we don't ask the storage for the etag
+
+        $builder = $this->connection->getQueryBuilder();
+        $hashParams = array_map(function ($hash) use ($builder) {
+            return $builder->expr()->literal($hash);
+        }, $parentHashes);
+
+        $builder->update('filecache')
+            ->set('mtime', $builder->func()->greatest('mtime', $builder->createNamedParameter($time, IQueryBuilder::PARAM_INT)))
+            ->where($builder->expr()->eq('storage', $builder->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
+            ->andWhere($builder->expr()->in('path_hash', $hashParams));
+        if (!$this->storage->instanceOfStorage(IReliableEtagStorage::class)) {
+            $builder->set('etag', $builder->createNamedParameter($etag, IQueryBuilder::PARAM_STR));
+        }
+
+        if ($sizeDifference !== 0) {
+            $hasCalculatedSize = $builder->expr()->gt('size', $builder->expr()->literal(-1, IQUeryBuilder::PARAM_INT));
+            $sizeColumn = $builder->getColumnName('size');
+            $newSize = $builder->func()->greatest(
+                $builder->func()->add('size', $builder->createNamedParameter($sizeDifference)),
+                $builder->createNamedParameter(-1, IQueryBuilder::PARAM_INT)
+            );
+
+            // Only update if row had a previously calculated size
+            $builder->set('size', $builder->createFunction("CASE WHEN $hasCalculatedSize THEN $newSize ELSE $sizeColumn END"));
+
+            if ($this->storage->instanceOfStorage(Encryption::class)) {
+                // in case of encryption being enabled after some files are already uploaded, some entries will have an unencrypted_size of 0 and a non-zero size
+                $hasUnencryptedSize = $builder->expr()->neq('unencrypted_size', $builder->expr()->literal(0, IQueryBuilder::PARAM_INT));
+                $sizeColumn = $builder->getColumnName('size');
+                $unencryptedSizeColumn = $builder->getColumnName('unencrypted_size');
+                $newUnencryptedSize = $builder->func()->greatest(
+                    $builder->func()->add(
+                        $builder->createFunction("CASE WHEN $hasUnencryptedSize THEN $unencryptedSizeColumn ELSE $sizeColumn END"),
+                        $builder->createNamedParameter($sizeDifference)
+                    ),
+                    $builder->createNamedParameter(-1, IQueryBuilder::PARAM_INT)
+                );
+
+                // Only update if row had a previously calculated size
+                $builder->set('unencrypted_size', $builder->createFunction("CASE WHEN $hasCalculatedSize THEN $newUnencryptedSize ELSE $unencryptedSizeColumn END"));
+            }
+        }
+
+        for ($i = 0; $i < self::MAX_RETRIES; $i++) {
+            try {
+                $builder->executeStatement();
+                break;
+            } catch (DbalException $e) {
+                if (!$e->isRetryable()) {
+                    throw $e;
+                }
+
+                /** @var LoggerInterface $loggerInterface */
+                $loggerInterface = \OCP\Server::get(LoggerInterface::class);
+                $loggerInterface->warning('Retrying propagation query after retryable exception.', [ 'exception' => $e ]);
+            }
+        }
+    }
+
+    /**
+     * @return string[]
+     */
+    protected function getParents(string $path): array {
+        $parts = explode('/', $path);
+        $parent = '';
+        $parents = [];
+        foreach ($parts as $part) {
+            $parents[] = $parent;
+            $parent = trim($parent . '/' . $part, '/');
+        }
+        return $parents;
+    }
+
+    #[Override]
+    public function beginBatch(): void {
+        $this->inBatch = true;
+    }
+
+    private function addToBatch(string $internalPath, int $time, int $sizeDifference): void {
+        if (!isset($this->batch[$internalPath])) {
+            $this->batch[$internalPath] = [
+                'hash' => md5($internalPath),
+                'time' => $time,
+                'size' => $sizeDifference,
+            ];
+        } else {
+            $this->batch[$internalPath]['size'] += $sizeDifference;
+            if ($time > $this->batch[$internalPath]['time']) {
+                $this->batch[$internalPath]['time'] = $time;
+            }
+        }
+    }
+
+    #[Override]
+    public function commitBatch(): void {
+        if (!$this->inBatch) {
+            throw new \BadMethodCallException('Not in batch');
+        }
+        $this->inBatch = false;
+
+        $this->connection->beginTransaction();
+
+        $query = $this->connection->getQueryBuilder();
+        $storageId = $this->storage->getCache()->getNumericStorageId();
+
+        $query->update('filecache')
+            ->set('mtime', $query->func()->greatest('mtime', $query->createParameter('time')))
+            ->set('etag', $query->expr()->literal(uniqid()))
+            ->where($query->expr()->eq('storage', $query->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
+            ->andWhere($query->expr()->eq('path_hash', $query->createParameter('hash')));
+
+        $sizeQuery = $this->connection->getQueryBuilder();
+        $sizeQuery->update('filecache')
+            ->set('size', $sizeQuery->func()->add('size', $sizeQuery->createParameter('size')))
+            ->where($query->expr()->eq('storage', $sizeQuery->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)))
+            ->andWhere($query->expr()->eq('path_hash', $sizeQuery->createParameter('hash')))
+            ->andWhere($sizeQuery->expr()->gt('size', $sizeQuery->createNamedParameter(-1, IQueryBuilder::PARAM_INT)));
+
+        foreach ($this->batch as $item) {
+            $query->setParameter('time', $item['time'], IQueryBuilder::PARAM_INT);
+            $query->setParameter('hash', $item['hash']);
+
+            $query->executeStatement();
+
+            if ($item['size']) {
+                $sizeQuery->setParameter('size', $item['size'], IQueryBuilder::PARAM_INT);
+                $sizeQuery->setParameter('hash', $item['hash']);
+
+                $sizeQuery->executeStatement();
+            }
+        }
+
+        $this->batch = [];
+
+        $this->connection->commit();
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -62,7 +62,7 @@ 
 		$etag = uniqid(); // since we give all folders the same etag we don't ask the storage for the etag
 
 		$builder = $this->connection->getQueryBuilder();
-		$hashParams = array_map(function ($hash) use ($builder) {
+		$hashParams = array_map(function($hash) use ($builder) {
 			return $builder->expr()->literal($hash);
 		}, $parentHashes);
 
@@ -114,7 +114,7 @@ 
 
 				/** @var LoggerInterface $loggerInterface */
 				$loggerInterface = \OCP\Server::get(LoggerInterface::class);
-				$loggerInterface->warning('Retrying propagation query after retryable exception.', [ 'exception' => $e ]);
+				$loggerInterface->warning('Retrying propagation query after retryable exception.', ['exception' => $e]);
 			}
 		}
 	}
@@ -128,7 +128,7 @@ 
 		$parents = [];
 		foreach ($parts as $part) {
 			$parents[] = $parent;
-			$parent = trim($parent . '/' . $part, '/');
+			$parent = trim($parent.'/'.$part, '/');
 		}
 		return $parents;
 	}

lib/private/Files/Storage/Wrapper/Jail.php

Indentation +241 added lines, -241 removed lines

@@ -25,245 +25,245 @@
  * This restricts access to a subfolder of the wrapped storage with the subfolder becoming the root folder new storage
  */
 class Jail extends Wrapper {
-	/**
-	 * @var string
-	 */
-	protected $rootPath;
-
-	/**
-	 * @param array $parameters ['storage' => $storage, 'root' => $root]
-	 *
-	 * $storage: The storage that will be wrapper
-	 * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
-	 */
-	public function __construct(array $parameters) {
-		parent::__construct($parameters);
-		$this->rootPath = $parameters['root'];
-	}
-
-	public function getUnjailedPath(string $path): string {
-		return trim(Filesystem::normalizePath($this->rootPath . '/' . $path), '/');
-	}
-
-	/**
-	 * This is separate from Wrapper::getWrapperStorage so we can get the jailed storage consistently even if the jail is inside another wrapper
-	 */
-	public function getUnjailedStorage(): IStorage {
-		return $this->storage;
-	}
-
-
-	public function getJailedPath(string $path): ?string {
-		$root = rtrim($this->rootPath, '/') . '/';
-
-		if ($path !== $this->rootPath && !str_starts_with($path, $root)) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->rootPath));
-			return trim($path, '/');
-		}
-	}
-
-	public function getId(): string {
-		return parent::getId();
-	}
-
-	public function mkdir(string $path): bool {
-		return $this->getWrapperStorage()->mkdir($this->getUnjailedPath($path));
-	}
-
-	public function rmdir(string $path): bool {
-		return $this->getWrapperStorage()->rmdir($this->getUnjailedPath($path));
-	}
-
-	public function opendir(string $path) {
-		return $this->getWrapperStorage()->opendir($this->getUnjailedPath($path));
-	}
-
-	public function is_dir(string $path): bool {
-		return $this->getWrapperStorage()->is_dir($this->getUnjailedPath($path));
-	}
-
-	public function is_file(string $path): bool {
-		return $this->getWrapperStorage()->is_file($this->getUnjailedPath($path));
-	}
-
-	public function stat(string $path): array|false {
-		return $this->getWrapperStorage()->stat($this->getUnjailedPath($path));
-	}
-
-	public function filetype(string $path): string|false {
-		return $this->getWrapperStorage()->filetype($this->getUnjailedPath($path));
-	}
-
-	public function filesize(string $path): int|float|false {
-		return $this->getWrapperStorage()->filesize($this->getUnjailedPath($path));
-	}
-
-	public function isCreatable(string $path): bool {
-		return $this->getWrapperStorage()->isCreatable($this->getUnjailedPath($path));
-	}
-
-	public function isReadable(string $path): bool {
-		return $this->getWrapperStorage()->isReadable($this->getUnjailedPath($path));
-	}
-
-	public function isUpdatable(string $path): bool {
-		return $this->getWrapperStorage()->isUpdatable($this->getUnjailedPath($path));
-	}
-
-	public function isDeletable(string $path): bool {
-		return $this->getWrapperStorage()->isDeletable($this->getUnjailedPath($path));
-	}
-
-	public function isSharable(string $path): bool {
-		return $this->getWrapperStorage()->isSharable($this->getUnjailedPath($path));
-	}
-
-	public function getPermissions(string $path): int {
-		return $this->getWrapperStorage()->getPermissions($this->getUnjailedPath($path));
-	}
-
-	public function file_exists(string $path): bool {
-		return $this->getWrapperStorage()->file_exists($this->getUnjailedPath($path));
-	}
-
-	public function filemtime(string $path): int|false {
-		return $this->getWrapperStorage()->filemtime($this->getUnjailedPath($path));
-	}
-
-	public function file_get_contents(string $path): string|false {
-		return $this->getWrapperStorage()->file_get_contents($this->getUnjailedPath($path));
-	}
-
-	public function file_put_contents(string $path, mixed $data): int|float|false {
-		return $this->getWrapperStorage()->file_put_contents($this->getUnjailedPath($path), $data);
-	}
-
-	public function unlink(string $path): bool {
-		return $this->getWrapperStorage()->unlink($this->getUnjailedPath($path));
-	}
-
-	public function rename(string $source, string $target): bool {
-		return $this->getWrapperStorage()->rename($this->getUnjailedPath($source), $this->getUnjailedPath($target));
-	}
-
-	public function copy(string $source, string $target): bool {
-		return $this->getWrapperStorage()->copy($this->getUnjailedPath($source), $this->getUnjailedPath($target));
-	}
-
-	public function fopen(string $path, string $mode) {
-		return $this->getWrapperStorage()->fopen($this->getUnjailedPath($path), $mode);
-	}
-
-	public function getMimeType(string $path): string|false {
-		return $this->getWrapperStorage()->getMimeType($this->getUnjailedPath($path));
-	}
-
-	public function hash(string $type, string $path, bool $raw = false): string|false {
-		return $this->getWrapperStorage()->hash($type, $this->getUnjailedPath($path), $raw);
-	}
-
-	public function free_space(string $path): int|float|false {
-		return $this->getWrapperStorage()->free_space($this->getUnjailedPath($path));
-	}
-
-	public function touch(string $path, ?int $mtime = null): bool {
-		return $this->getWrapperStorage()->touch($this->getUnjailedPath($path), $mtime);
-	}
-
-	public function getLocalFile(string $path): string|false {
-		return $this->getWrapperStorage()->getLocalFile($this->getUnjailedPath($path));
-	}
-
-	public function hasUpdated(string $path, int $time): bool {
-		return $this->getWrapperStorage()->hasUpdated($this->getUnjailedPath($path), $time);
-	}
-
-	public function getCache(string $path = '', ?IStorage $storage = null): ICache {
-		$sourceCache = $this->getWrapperStorage()->getCache($this->getUnjailedPath($path));
-		return new CacheJail($sourceCache, $this->rootPath);
-	}
-
-	public function getOwner(string $path): string|false {
-		return $this->getWrapperStorage()->getOwner($this->getUnjailedPath($path));
-	}
-
-	public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
-		$sourceWatcher = $this->getWrapperStorage()->getWatcher($this->getUnjailedPath($path), $this->getWrapperStorage());
-		return new JailWatcher($sourceWatcher, $this->rootPath);
-	}
-
-	public function getETag(string $path): string|false {
-		return $this->getWrapperStorage()->getETag($this->getUnjailedPath($path));
-	}
-
-	public function getMetaData(string $path): ?array {
-		return $this->getWrapperStorage()->getMetaData($this->getUnjailedPath($path));
-	}
-
-	public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
-		$this->getWrapperStorage()->acquireLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
-		$this->getWrapperStorage()->releaseLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	public function changeLock(string $path, int $type, ILockingProvider $provider): void {
-		$this->getWrapperStorage()->changeLock($this->getUnjailedPath($path), $type, $provider);
-	}
-
-	/**
-	 * Resolve the path for the source of the share.
-	 *
-	 * @return array{0: IStorage, 1: string}
-	 */
-	public function resolvePath(string $path): array {
-		return [$this->getWrapperStorage(), $this->getUnjailedPath($path)];
-	}
-
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		if ($sourceStorage === $this) {
-			return $this->copy($sourceInternalPath, $targetInternalPath);
-		}
-		return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
-	}
-
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		if ($sourceStorage === $this) {
-			return $this->rename($sourceInternalPath, $targetInternalPath);
-		}
-		return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
-	}
-
-	public function getPropagator(?IStorage $storage = null): IPropagator {
-		if (isset($this->propagator)) {
-			return $this->propagator;
-		}
-
-		if (!$storage) {
-			$storage = $this;
-		}
-		$this->propagator = new JailPropagator($storage, \OC::$server->getDatabaseConnection());
-		return $this->propagator;
-	}
-
-	public function writeStream(string $path, $stream, ?int $size = null): int {
-		$storage = $this->getWrapperStorage();
-		if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
-			/** @var IWriteStreamStorage $storage */
-			return $storage->writeStream($this->getUnjailedPath($path), $stream, $size);
-		} else {
-			$target = $this->fopen($path, 'w');
-			$count = Files::streamCopy($stream, $target);
-			fclose($stream);
-			fclose($target);
-			return $count;
-		}
-	}
-
-	public function getDirectoryContent(string $directory): \Traversable {
-		return $this->getWrapperStorage()->getDirectoryContent($this->getUnjailedPath($directory));
-	}
+    /**
+     * @var string
+     */
+    protected $rootPath;
+
+    /**
+     * @param array $parameters ['storage' => $storage, 'root' => $root]
+     *
+     * $storage: The storage that will be wrapper
+     * $root: The folder in the wrapped storage that will become the root folder of the wrapped storage
+     */
+    public function __construct(array $parameters) {
+        parent::__construct($parameters);
+        $this->rootPath = $parameters['root'];
+    }
+
+    public function getUnjailedPath(string $path): string {
+        return trim(Filesystem::normalizePath($this->rootPath . '/' . $path), '/');
+    }
+
+    /**
+     * This is separate from Wrapper::getWrapperStorage so we can get the jailed storage consistently even if the jail is inside another wrapper
+     */
+    public function getUnjailedStorage(): IStorage {
+        return $this->storage;
+    }
+
+
+    public function getJailedPath(string $path): ?string {
+        $root = rtrim($this->rootPath, '/') . '/';
+
+        if ($path !== $this->rootPath && !str_starts_with($path, $root)) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->rootPath));
+            return trim($path, '/');
+        }
+    }
+
+    public function getId(): string {
+        return parent::getId();
+    }
+
+    public function mkdir(string $path): bool {
+        return $this->getWrapperStorage()->mkdir($this->getUnjailedPath($path));
+    }
+
+    public function rmdir(string $path): bool {
+        return $this->getWrapperStorage()->rmdir($this->getUnjailedPath($path));
+    }
+
+    public function opendir(string $path) {
+        return $this->getWrapperStorage()->opendir($this->getUnjailedPath($path));
+    }
+
+    public function is_dir(string $path): bool {
+        return $this->getWrapperStorage()->is_dir($this->getUnjailedPath($path));
+    }
+
+    public function is_file(string $path): bool {
+        return $this->getWrapperStorage()->is_file($this->getUnjailedPath($path));
+    }
+
+    public function stat(string $path): array|false {
+        return $this->getWrapperStorage()->stat($this->getUnjailedPath($path));
+    }
+
+    public function filetype(string $path): string|false {
+        return $this->getWrapperStorage()->filetype($this->getUnjailedPath($path));
+    }
+
+    public function filesize(string $path): int|float|false {
+        return $this->getWrapperStorage()->filesize($this->getUnjailedPath($path));
+    }
+
+    public function isCreatable(string $path): bool {
+        return $this->getWrapperStorage()->isCreatable($this->getUnjailedPath($path));
+    }
+
+    public function isReadable(string $path): bool {
+        return $this->getWrapperStorage()->isReadable($this->getUnjailedPath($path));
+    }
+
+    public function isUpdatable(string $path): bool {
+        return $this->getWrapperStorage()->isUpdatable($this->getUnjailedPath($path));
+    }
+
+    public function isDeletable(string $path): bool {
+        return $this->getWrapperStorage()->isDeletable($this->getUnjailedPath($path));
+    }
+
+    public function isSharable(string $path): bool {
+        return $this->getWrapperStorage()->isSharable($this->getUnjailedPath($path));
+    }
+
+    public function getPermissions(string $path): int {
+        return $this->getWrapperStorage()->getPermissions($this->getUnjailedPath($path));
+    }
+
+    public function file_exists(string $path): bool {
+        return $this->getWrapperStorage()->file_exists($this->getUnjailedPath($path));
+    }
+
+    public function filemtime(string $path): int|false {
+        return $this->getWrapperStorage()->filemtime($this->getUnjailedPath($path));
+    }
+
+    public function file_get_contents(string $path): string|false {
+        return $this->getWrapperStorage()->file_get_contents($this->getUnjailedPath($path));
+    }
+
+    public function file_put_contents(string $path, mixed $data): int|float|false {
+        return $this->getWrapperStorage()->file_put_contents($this->getUnjailedPath($path), $data);
+    }
+
+    public function unlink(string $path): bool {
+        return $this->getWrapperStorage()->unlink($this->getUnjailedPath($path));
+    }
+
+    public function rename(string $source, string $target): bool {
+        return $this->getWrapperStorage()->rename($this->getUnjailedPath($source), $this->getUnjailedPath($target));
+    }
+
+    public function copy(string $source, string $target): bool {
+        return $this->getWrapperStorage()->copy($this->getUnjailedPath($source), $this->getUnjailedPath($target));
+    }
+
+    public function fopen(string $path, string $mode) {
+        return $this->getWrapperStorage()->fopen($this->getUnjailedPath($path), $mode);
+    }
+
+    public function getMimeType(string $path): string|false {
+        return $this->getWrapperStorage()->getMimeType($this->getUnjailedPath($path));
+    }
+
+    public function hash(string $type, string $path, bool $raw = false): string|false {
+        return $this->getWrapperStorage()->hash($type, $this->getUnjailedPath($path), $raw);
+    }
+
+    public function free_space(string $path): int|float|false {
+        return $this->getWrapperStorage()->free_space($this->getUnjailedPath($path));
+    }
+
+    public function touch(string $path, ?int $mtime = null): bool {
+        return $this->getWrapperStorage()->touch($this->getUnjailedPath($path), $mtime);
+    }
+
+    public function getLocalFile(string $path): string|false {
+        return $this->getWrapperStorage()->getLocalFile($this->getUnjailedPath($path));
+    }
+
+    public function hasUpdated(string $path, int $time): bool {
+        return $this->getWrapperStorage()->hasUpdated($this->getUnjailedPath($path), $time);
+    }
+
+    public function getCache(string $path = '', ?IStorage $storage = null): ICache {
+        $sourceCache = $this->getWrapperStorage()->getCache($this->getUnjailedPath($path));
+        return new CacheJail($sourceCache, $this->rootPath);
+    }
+
+    public function getOwner(string $path): string|false {
+        return $this->getWrapperStorage()->getOwner($this->getUnjailedPath($path));
+    }
+
+    public function getWatcher(string $path = '', ?IStorage $storage = null): IWatcher {
+        $sourceWatcher = $this->getWrapperStorage()->getWatcher($this->getUnjailedPath($path), $this->getWrapperStorage());
+        return new JailWatcher($sourceWatcher, $this->rootPath);
+    }
+
+    public function getETag(string $path): string|false {
+        return $this->getWrapperStorage()->getETag($this->getUnjailedPath($path));
+    }
+
+    public function getMetaData(string $path): ?array {
+        return $this->getWrapperStorage()->getMetaData($this->getUnjailedPath($path));
+    }
+
+    public function acquireLock(string $path, int $type, ILockingProvider $provider): void {
+        $this->getWrapperStorage()->acquireLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    public function releaseLock(string $path, int $type, ILockingProvider $provider): void {
+        $this->getWrapperStorage()->releaseLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    public function changeLock(string $path, int $type, ILockingProvider $provider): void {
+        $this->getWrapperStorage()->changeLock($this->getUnjailedPath($path), $type, $provider);
+    }
+
+    /**
+     * Resolve the path for the source of the share.
+     *
+     * @return array{0: IStorage, 1: string}
+     */
+    public function resolvePath(string $path): array {
+        return [$this->getWrapperStorage(), $this->getUnjailedPath($path)];
+    }
+
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        if ($sourceStorage === $this) {
+            return $this->copy($sourceInternalPath, $targetInternalPath);
+        }
+        return $this->getWrapperStorage()->copyFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+    }
+
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        if ($sourceStorage === $this) {
+            return $this->rename($sourceInternalPath, $targetInternalPath);
+        }
+        return $this->getWrapperStorage()->moveFromStorage($sourceStorage, $sourceInternalPath, $this->getUnjailedPath($targetInternalPath));
+    }
+
+    public function getPropagator(?IStorage $storage = null): IPropagator {
+        if (isset($this->propagator)) {
+            return $this->propagator;
+        }
+
+        if (!$storage) {
+            $storage = $this;
+        }
+        $this->propagator = new JailPropagator($storage, \OC::$server->getDatabaseConnection());
+        return $this->propagator;
+    }
+
+    public function writeStream(string $path, $stream, ?int $size = null): int {
+        $storage = $this->getWrapperStorage();
+        if ($storage->instanceOfStorage(IWriteStreamStorage::class)) {
+            /** @var IWriteStreamStorage $storage */
+            return $storage->writeStream($this->getUnjailedPath($path), $stream, $size);
+        } else {
+            $target = $this->fopen($path, 'w');
+            $count = Files::streamCopy($stream, $target);
+            fclose($stream);
+            fclose($target);
+            return $count;
+        }
+    }
+
+    public function getDirectoryContent(string $directory): \Traversable {
+        return $this->getWrapperStorage()->getDirectoryContent($this->getUnjailedPath($directory));
+    }
 }