nextcloud / server

lib/public/Lock/LockedException.php

Indentation +53 added lines, -53 removed lines

@@ -14,64 +14,64 @@
  * @since 8.1.0
  */
 class LockedException extends \Exception {
-	/**
-	 * Locked path
-	 *
-	 * @var string
-	 */
-	private $path;
+    /**
+     * Locked path
+     *
+     * @var string
+     */
+    private $path;
 
-	/** @var string|null */
-	private $existingLock;
+    /** @var string|null */
+    private $existingLock;
 
-	private ?string $readablePath;
+    private ?string $readablePath;
 
-	/**
-	 * LockedException constructor.
-	 *
-	 * @param string $path locked path
-	 * @param \Exception|null $previous previous exception for cascading
-	 * @param string $existingLock since 14.0.0
-	 * @param string $readablePath since 20.0.0
-	 * @since 8.1.0
-	 */
-	public function __construct(string $path, ?\Exception $previous = null, ?string $existingLock = null, ?string $readablePath = null) {
-		$this->readablePath = $readablePath;
-		if ($readablePath) {
-			$message = "\"$path\"(\"$readablePath\") is locked";
-		} else {
-			$message = '"' . $path . '" is locked';
-		}
-		$this->existingLock = $existingLock;
-		if ($existingLock) {
-			$message .= ', existing lock on file: ' . $existingLock;
-		}
-		parent::__construct($message, 0, $previous);
-		$this->path = $path;
-	}
+    /**
+     * LockedException constructor.
+     *
+     * @param string $path locked path
+     * @param \Exception|null $previous previous exception for cascading
+     * @param string $existingLock since 14.0.0
+     * @param string $readablePath since 20.0.0
+     * @since 8.1.0
+     */
+    public function __construct(string $path, ?\Exception $previous = null, ?string $existingLock = null, ?string $readablePath = null) {
+        $this->readablePath = $readablePath;
+        if ($readablePath) {
+            $message = "\"$path\"(\"$readablePath\") is locked";
+        } else {
+            $message = '"' . $path . '" is locked';
+        }
+        $this->existingLock = $existingLock;
+        if ($existingLock) {
+            $message .= ', existing lock on file: ' . $existingLock;
+        }
+        parent::__construct($message, 0, $previous);
+        $this->path = $path;
+    }
 
-	/**
-	 * @return string
-	 * @since 8.1.0
-	 */
-	public function getPath(): string {
-		return $this->path;
-	}
+    /**
+     * @return string
+     * @since 8.1.0
+     */
+    public function getPath(): string {
+        return $this->path;
+    }
 
-	/**
-	 * @return string
-	 * @since 19.0.0
-	 */
-	public function getExistingLock(): ?string {
-		return $this->existingLock;
-	}
+    /**
+     * @return string
+     * @since 19.0.0
+     */
+    public function getExistingLock(): ?string {
+        return $this->existingLock;
+    }
 
-	/**
-	 * @return ?string
-	 * @since 32.0.0
-	 */
-	public function getReadablePath(): ?string {
-		return $this->readablePath;
-	}
+    /**
+     * @return ?string
+     * @since 32.0.0
+     */
+    public function getReadablePath(): ?string {
+        return $this->readablePath;
+    }
 
 }

lib/private/Files/Cache/Scanner.php

Indentation +587 added lines, -587 removed lines

@@ -33,591 +33,591 @@
  * @package OC\Files\Cache
  */
 class Scanner extends BasicEmitter implements IScanner {
-	/**
-	 * @var \OC\Files\Storage\Storage $storage
-	 */
-	protected $storage;
-
-	/**
-	 * @var string $storageId
-	 */
-	protected $storageId;
-
-	/**
-	 * @var \OC\Files\Cache\Cache $cache
-	 */
-	protected $cache;
-
-	/**
-	 * @var boolean $cacheActive If true, perform cache operations, if false, do not affect cache
-	 */
-	protected $cacheActive;
-
-	/**
-	 * @var bool $useTransactions whether to use transactions
-	 */
-	protected $useTransactions = true;
-
-	/**
-	 * @var \OCP\Lock\ILockingProvider
-	 */
-	protected $lockingProvider;
-
-	protected IDBConnection $connection;
-
-	public function __construct(\OC\Files\Storage\Storage $storage) {
-		$this->storage = $storage;
-		$this->storageId = $this->storage->getId();
-		$this->cache = $storage->getCache();
-		/** @var SystemConfig $config */
-		$config = \OC::$server->get(SystemConfig::class);
-		$this->cacheActive = !$config->getValue('filesystem_cache_readonly', false);
-		$this->useTransactions = !$config->getValue('filescanner_no_transactions', false);
-		$this->lockingProvider = \OC::$server->get(ILockingProvider::class);
-		$this->connection = \OC::$server->get(IDBConnection::class);
-	}
-
-	/**
-	 * Whether to wrap the scanning of a folder in a database transaction
-	 * On default transactions are used
-	 *
-	 * @param bool $useTransactions
-	 */
-	public function setUseTransactions($useTransactions): void {
-		$this->useTransactions = $useTransactions;
-	}
-
-	/**
-	 * get all the metadata of a file or folder
-	 * *
-	 *
-	 * @param string $path
-	 * @return array|null an array of metadata of the file
-	 */
-	protected function getData($path) {
-		$data = $this->storage->getMetaData($path);
-		if (is_null($data)) {
-			\OC::$server->get(LoggerInterface::class)->debug("!!! Path '$path' is not accessible or present !!!", ['app' => 'core']);
-		}
-		return $data;
-	}
-
-	/**
-	 * scan a single file and store it in the cache
-	 *
-	 * @param string $file
-	 * @param int $reuseExisting
-	 * @param int $parentId
-	 * @param array|CacheEntry|null|false $cacheData existing data in the cache for the file to be scanned
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @param array|null $data the metadata for the file, as returned by the storage
-	 * @return array|null an array of metadata of the scanned file
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true, $data = null) {
-		if ($file !== '') {
-			try {
-				$this->storage->verifyPath(dirname($file), basename($file));
-			} catch (\Exception $e) {
-				return null;
-			}
-		}
-
-		// only proceed if $file is not a partial file, blacklist is handled by the storage
-		if (self::isPartialFile($file)) {
-			return null;
-		}
-
-		// acquire a lock
-		if ($lock) {
-			if ($this->storage->instanceOfStorage(ILockingStorage::class)) {
-				$this->storage->acquireLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-			}
-		}
-
-		try {
-			$data = $data ?? $this->getData($file);
-		} catch (ForbiddenException $e) {
-			if ($lock) {
-				if ($this->storage->instanceOfStorage(ILockingStorage::class)) {
-					$this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-				}
-			}
-
-			return null;
-		}
-
-		try {
-			if ($data === null) {
-				$this->removeFromCache($file);
-			} else {
-				// pre-emit only if it was a file. By that we avoid counting/treating folders as files
-				if ($data['mimetype'] !== 'httpd/unix-directory') {
-					$this->emit('\OC\Files\Cache\Scanner', 'scanFile', [$file, $this->storageId]);
-					\OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', ['path' => $file, 'storage' => $this->storageId]);
-				}
-
-				$parent = dirname($file);
-				if ($parent === '.' || $parent === '/') {
-					$parent = '';
-				}
-				if ($parentId === -1) {
-					$parentId = $this->cache->getParentId($file);
-				}
-
-				// scan the parent if it's not in the cache (id -1) and the current file is not the root folder
-				if ($file && $parentId === -1) {
-					$parentData = $this->scanFile($parent);
-					if ($parentData === null) {
-						return null;
-					}
-
-					$parentId = $parentData['fileid'];
-				}
-				if ($parent) {
-					$data['parent'] = $parentId;
-				}
-
-				$cacheData = $cacheData ?? $this->cache->get($file);
-				if ($reuseExisting && $cacheData !== false && isset($cacheData['fileid'])) {
-					// prevent empty etag
-					$etag = empty($cacheData['etag']) ? $data['etag'] : $cacheData['etag'];
-					$fileId = $cacheData['fileid'];
-					$data['fileid'] = $fileId;
-					// only reuse data if the file hasn't explicitly changed
-					$mtimeUnchanged = isset($data['storage_mtime']) && isset($cacheData['storage_mtime']) && $data['storage_mtime'] === $cacheData['storage_mtime'];
-					// if the folder is marked as unscanned, never reuse etags
-					if ($mtimeUnchanged && $cacheData['size'] !== -1) {
-						$data['mtime'] = $cacheData['mtime'];
-						if (($reuseExisting & self::REUSE_SIZE) && ($data['size'] === -1)) {
-							$data['size'] = $cacheData['size'];
-						}
-						if ($reuseExisting & self::REUSE_ETAG && !$this->storage->instanceOfStorage(IReliableEtagStorage::class)) {
-							$data['etag'] = $etag;
-						}
-					}
-
-					// we only updated unencrypted_size if it's already set
-					if (isset($cacheData['unencrypted_size']) && $cacheData['unencrypted_size'] === 0) {
-						unset($data['unencrypted_size']);
-					}
-
-					/**
-					 * Only update metadata that has changed.
-					 * i.e. get all the values in $data that are not present in the cache already
-					 *
-					 * We need the OC implementation for usage of "getData" method below.
-					 * @var \OC\Files\Cache\CacheEntry $cacheData
-					 */
-					$newData = $this->array_diff_assoc_multi($data, $cacheData->getData());
-
-					// make it known to the caller that etag has been changed and needs propagation
-					if (isset($newData['etag'])) {
-						$data['etag_changed'] = true;
-					}
-				} else {
-					unset($data['unencrypted_size']);
-					$newData = $data;
-					$fileId = -1;
-				}
-				if (!empty($newData)) {
-					// Reset the checksum if the data has changed
-					$newData['checksum'] = '';
-					$newData['parent'] = $parentId;
-					$data['fileid'] = $this->addToCache($file, $newData, $fileId);
-				}
-
-				if ($cacheData !== false) {
-					$data['oldSize'] = $cacheData['size'] ?? 0;
-					$data['encrypted'] = $cacheData['encrypted'] ?? false;
-				}
-
-				// post-emit only if it was a file. By that we avoid counting/treating folders as files
-				if ($data['mimetype'] !== 'httpd/unix-directory') {
-					$this->emit('\OC\Files\Cache\Scanner', 'postScanFile', [$file, $this->storageId]);
-					\OC_Hook::emit('\OC\Files\Cache\Scanner', 'post_scan_file', ['path' => $file, 'storage' => $this->storageId]);
-				}
-			}
-		} finally {
-			// release the acquired lock
-			if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
-				$this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-			}
-		}
-
-		return $data;
-	}
-
-	protected function removeFromCache($path) {
-		\OC_Hook::emit('Scanner', 'removeFromCache', ['file' => $path]);
-		$this->emit('\OC\Files\Cache\Scanner', 'removeFromCache', [$path]);
-		if ($this->cacheActive) {
-			$this->cache->remove($path);
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param array $data
-	 * @param int $fileId
-	 * @return int the id of the added file
-	 */
-	protected function addToCache($path, $data, $fileId = -1) {
-		if (isset($data['scan_permissions'])) {
-			$data['permissions'] = $data['scan_permissions'];
-		}
-		\OC_Hook::emit('Scanner', 'addToCache', ['file' => $path, 'data' => $data]);
-		$this->emit('\OC\Files\Cache\Scanner', 'addToCache', [$path, $this->storageId, $data, $fileId]);
-		if ($this->cacheActive) {
-			if ($fileId !== -1) {
-				$this->cache->update($fileId, $data);
-				return $fileId;
-			} else {
-				return $this->cache->insert($path, $data);
-			}
-		} else {
-			return -1;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param array $data
-	 * @param int $fileId
-	 */
-	protected function updateCache($path, $data, $fileId = -1) {
-		\OC_Hook::emit('Scanner', 'addToCache', ['file' => $path, 'data' => $data]);
-		$this->emit('\OC\Files\Cache\Scanner', 'updateCache', [$path, $this->storageId, $data]);
-		if ($this->cacheActive) {
-			if ($fileId !== -1) {
-				$this->cache->update($fileId, $data);
-			} else {
-				$this->cache->put($path, $data);
-			}
-		}
-	}
-
-	/**
-	 * scan a folder and all it's children
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @return array|null an array of the meta data of the scanned file or folder
-	 */
-	public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
-		if ($reuse === -1) {
-			$reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
-		}
-
-		if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
-			$this->storage->acquireLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
-			$this->storage->acquireLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-		}
-
-		try {
-			$data = $this->scanFile($path, $reuse, -1, lock: $lock);
-
-			if ($data !== null && $data['mimetype'] === 'httpd/unix-directory') {
-				$size = $this->scanChildren($path, $recursive, $reuse, $data['fileid'], $lock, $data['size']);
-				$data['size'] = $size;
-			}
-		} catch (NotFoundException $e) {
-			$this->removeFromCache($path);
-			return null;
-		} finally {
-			if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
-				$this->storage->releaseLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
-				$this->storage->releaseLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
-			}
-		}
-		return $data;
-	}
-
-	/**
-	 * Compares $array1 against $array2 and returns all the values in $array1 that are not in $array2
-	 * Note this is a one-way check - i.e. we don't care about things that are in $array2 that aren't in $array1
-	 *
-	 * Supports multi-dimensional arrays
-	 * Also checks keys/indexes
-	 * Comparisons are strict just like array_diff_assoc
-	 * Order of keys/values does not matter
-	 *
-	 * @param array $array1
-	 * @param array $array2
-	 * @return array with the differences between $array1 and $array1
-	 * @throws \InvalidArgumentException if $array1 isn't an actual array
-	 *
-	 */
-	protected function array_diff_assoc_multi(array $array1, array $array2) {
-
-		$result = [];
-
-		foreach ($array1 as $key => $value) {
-
-			// if $array2 doesn't have the same key, that's a result
-			if (!array_key_exists($key, $array2)) {
-				$result[$key] = $value;
-				continue;
-			}
-
-			// if $array2's value for the same key is different, that's a result
-			if ($array2[$key] !== $value && !is_array($value)) {
-				$result[$key] = $value;
-				continue;
-			}
-
-			if (is_array($value)) {
-				$nestedDiff = $this->array_diff_assoc_multi($value, $array2[$key]);
-				if (!empty($nestedDiff)) {
-					$result[$key] = $nestedDiff;
-					continue;
-				}
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Get the children currently in the cache
-	 *
-	 * @param int $folderId
-	 * @return array<string, \OCP\Files\Cache\ICacheEntry>
-	 */
-	protected function getExistingChildren($folderId): array {
-		$existingChildren = [];
-		$children = $this->cache->getFolderContentsById($folderId);
-		foreach ($children as $child) {
-			$existingChildren[$child['name']] = $child;
-		}
-		return $existingChildren;
-	}
-
-	/**
-	 * scan all the files and folders in a folder
-	 *
-	 * @param string $path
-	 * @param bool|IScanner::SCAN_RECURSIVE_INCOMPLETE $recursive
-	 * @param int $reuse a combination of self::REUSE_*
-	 * @param int $folderId id for the folder to be scanned
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @param int|float $oldSize the size of the folder before (re)scanning the children
-	 * @return int|float the size of the scanned folder or -1 if the size is unknown at this stage
-	 */
-	protected function scanChildren(string $path, $recursive, int $reuse, int $folderId, bool $lock, int|float $oldSize, &$etagChanged = false) {
-		if ($reuse === -1) {
-			$reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
-		}
-		$this->emit('\OC\Files\Cache\Scanner', 'scanFolder', [$path, $this->storageId]);
-		$size = 0;
-		$childQueue = $this->handleChildren($path, $recursive, $reuse, $folderId, $lock, $size, $etagChanged);
-
-		foreach ($childQueue as $child => [$childId, $childSize]) {
-			// "etag changed" propagates up, but not down, so we pass `false` to the children even if we already know that the etag of the current folder changed
-			$childEtagChanged = false;
-			$childSize = $this->scanChildren($child, $recursive, $reuse, $childId, $lock, $childSize, $childEtagChanged);
-			$etagChanged |= $childEtagChanged;
-
-			if ($childSize === -1) {
-				$size = -1;
-			} elseif ($size !== -1) {
-				$size += $childSize;
-			}
-		}
-
-		// for encrypted storages, we trigger a regular folder size calculation instead of using the calculated size
-		// to make sure we also updated the unencrypted-size where applicable
-		if ($this->storage->instanceOfStorage(Encryption::class)) {
-			$this->cache->calculateFolderSize($path);
-		} else {
-			if ($this->cacheActive) {
-				$updatedData = [];
-				if ($oldSize !== $size) {
-					$updatedData['size'] = $size;
-				}
-				if ($etagChanged) {
-					$updatedData['etag'] = uniqid();
-				}
-				if ($updatedData) {
-					$this->cache->update($folderId, $updatedData);
-				}
-			}
-		}
-		$this->emit('\OC\Files\Cache\Scanner', 'postScanFolder', [$path, $this->storageId]);
-		return $size;
-	}
-
-	/**
-	 * @param bool|IScanner::SCAN_RECURSIVE_INCOMPLETE $recursive
-	 */
-	private function handleChildren(string $path, $recursive, int $reuse, int $folderId, bool $lock, int|float &$size, bool &$etagChanged): array {
-		// we put this in it's own function so it cleans up the memory before we start recursing
-		$existingChildren = $this->getExistingChildren($folderId);
-		$newChildren = iterator_to_array($this->storage->getDirectoryContent($path));
-
-		if (count($existingChildren) === 0 && count($newChildren) === 0) {
-			// no need to do a transaction
-			return [];
-		}
-
-		if ($this->useTransactions) {
-			$this->connection->beginTransaction();
-		}
-
-		$exceptionOccurred = false;
-		$childQueue = [];
-		$newChildNames = [];
-		foreach ($newChildren as $fileMeta) {
-			$permissions = $fileMeta['scan_permissions'] ?? $fileMeta['permissions'];
-			if ($permissions === 0) {
-				continue;
-			}
-			$originalFile = $fileMeta['name'];
-			$file = trim(\OC\Files\Filesystem::normalizePath($originalFile), '/');
-			if (trim($originalFile, '/') !== $file) {
-				// encoding mismatch, might require compatibility wrapper
-				\OC::$server->get(LoggerInterface::class)->debug('Scanner: Skipping non-normalized file name "' . $originalFile . '" in path "' . $path . '".', ['app' => 'core']);
-				$this->emit('\OC\Files\Cache\Scanner', 'normalizedNameMismatch', [$path ? $path . '/' . $originalFile : $originalFile]);
-				// skip this entry
-				continue;
-			}
-
-			$newChildNames[] = $file;
-			$child = $path ? $path . '/' . $file : $file;
-			try {
-				$existingData = $existingChildren[$file] ?? false;
-				$data = $this->scanFile($child, $reuse, $folderId, $existingData, $lock, $fileMeta);
-				if ($data) {
-					if ($data['mimetype'] === 'httpd/unix-directory' && $recursive === self::SCAN_RECURSIVE) {
-						$childQueue[$child] = [$data['fileid'], $data['size']];
-					} elseif ($data['mimetype'] === 'httpd/unix-directory' && $recursive === self::SCAN_RECURSIVE_INCOMPLETE && $data['size'] === -1) {
-						// only recurse into folders which aren't fully scanned
-						$childQueue[$child] = [$data['fileid'], $data['size']];
-					} elseif ($data['size'] === -1) {
-						$size = -1;
-					} elseif ($size !== -1) {
-						$size += $data['size'];
-					}
-
-					if (isset($data['etag_changed']) && $data['etag_changed']) {
-						$etagChanged = true;
-					}
-				}
-			} catch (Exception $ex) {
-				// might happen if inserting duplicate while a scanning
-				// process is running in parallel
-				// log and ignore
-				if ($this->useTransactions) {
-					$this->connection->rollback();
-					$this->connection->beginTransaction();
-				}
-				\OC::$server->get(LoggerInterface::class)->debug('Exception while scanning file "' . $child . '"', [
-					'app' => 'core',
-					'exception' => $ex,
-				]);
-				$exceptionOccurred = true;
-			} catch (\OCP\Lock\LockedException $e) {
-				if ($this->useTransactions) {
-					$this->connection->rollback();
-				}
-				throw $e;
-			}
-		}
-		$removedChildren = \array_diff(array_keys($existingChildren), $newChildNames);
-		foreach ($removedChildren as $childName) {
-			$child = $path ? $path . '/' . $childName : $childName;
-			$this->removeFromCache($child);
-		}
-		if ($this->useTransactions) {
-			$this->connection->commit();
-		}
-		if ($exceptionOccurred) {
-			// It might happen that the parallel scan process has already
-			// inserted mimetypes but those weren't available yet inside the transaction
-			// To make sure to have the updated mime types in such cases,
-			// we reload them here
-			\OC::$server->getMimeTypeLoader()->reset();
-		}
-		return $childQueue;
-	}
-
-	/**
-	 * check if the file should be ignored when scanning
-	 * NOTE: files with a '.part' extension are ignored as well!
-	 *       prevents unfinished put requests to be scanned
-	 *
-	 * @param string $file
-	 * @return boolean
-	 */
-	public static function isPartialFile($file) {
-		if (pathinfo($file, PATHINFO_EXTENSION) === 'part') {
-			return true;
-		}
-		if (str_contains($file, '.part/')) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * walk over any folders that are not fully scanned yet and scan them
-	 */
-	public function backgroundScan() {
-		if ($this->storage->instanceOfStorage(Jail::class)) {
-			// for jail storage wrappers (shares, groupfolders) we run the background scan on the source storage
-			// this is mainly done because the jail wrapper doesn't implement `getIncomplete` (because it would be inefficient).
-			//
-			// Running the scan on the source storage might scan more than "needed", but the unscanned files outside the jail will
-			// have to be scanned at some point anyway.
-			$unJailedScanner = $this->storage->getUnjailedStorage()->getScanner();
-			$unJailedScanner->backgroundScan();
-		} else {
-			if (!$this->cache->inCache('')) {
-				// if the storage isn't in the cache yet, just scan the root completely
-				$this->runBackgroundScanJob(function () {
-					$this->scan('', self::SCAN_RECURSIVE, self::REUSE_ETAG);
-				}, '');
-			} else {
-				$lastPath = null;
-				// find any path marked as unscanned and run the scanner until no more paths are unscanned (or we get stuck)
-				while (($path = $this->cache->getIncomplete()) !== false && $path !== $lastPath) {
-					$this->runBackgroundScanJob(function () use ($path) {
-						$this->scan($path, self::SCAN_RECURSIVE_INCOMPLETE, self::REUSE_ETAG | self::REUSE_SIZE);
-					}, $path);
-					// FIXME: this won't proceed with the next item, needs revamping of getIncomplete()
-					// to make this possible
-					$lastPath = $path;
-				}
-			}
-		}
-	}
-
-	protected function runBackgroundScanJob(callable $callback, $path) {
-		try {
-			$callback();
-			\OC_Hook::emit('Scanner', 'correctFolderSize', ['path' => $path]);
-			if ($this->cacheActive && $this->cache instanceof Cache) {
-				$this->cache->correctFolderSize($path, null, true);
-			}
-		} catch (\OCP\Files\StorageInvalidException $e) {
-			// skip unavailable storages
-		} catch (\OCP\Files\StorageNotAvailableException $e) {
-			// skip unavailable storages
-		} catch (\OCP\Files\ForbiddenException $e) {
-			// skip forbidden storages
-		} catch (\OCP\Lock\LockedException $e) {
-			// skip unavailable storages
-		}
-	}
-
-	/**
-	 * Set whether the cache is affected by scan operations
-	 *
-	 * @param boolean $active The active state of the cache
-	 */
-	public function setCacheActive($active) {
-		$this->cacheActive = $active;
-	}
+    /**
+     * @var \OC\Files\Storage\Storage $storage
+     */
+    protected $storage;
+
+    /**
+     * @var string $storageId
+     */
+    protected $storageId;
+
+    /**
+     * @var \OC\Files\Cache\Cache $cache
+     */
+    protected $cache;
+
+    /**
+     * @var boolean $cacheActive If true, perform cache operations, if false, do not affect cache
+     */
+    protected $cacheActive;
+
+    /**
+     * @var bool $useTransactions whether to use transactions
+     */
+    protected $useTransactions = true;
+
+    /**
+     * @var \OCP\Lock\ILockingProvider
+     */
+    protected $lockingProvider;
+
+    protected IDBConnection $connection;
+
+    public function __construct(\OC\Files\Storage\Storage $storage) {
+        $this->storage = $storage;
+        $this->storageId = $this->storage->getId();
+        $this->cache = $storage->getCache();
+        /** @var SystemConfig $config */
+        $config = \OC::$server->get(SystemConfig::class);
+        $this->cacheActive = !$config->getValue('filesystem_cache_readonly', false);
+        $this->useTransactions = !$config->getValue('filescanner_no_transactions', false);
+        $this->lockingProvider = \OC::$server->get(ILockingProvider::class);
+        $this->connection = \OC::$server->get(IDBConnection::class);
+    }
+
+    /**
+     * Whether to wrap the scanning of a folder in a database transaction
+     * On default transactions are used
+     *
+     * @param bool $useTransactions
+     */
+    public function setUseTransactions($useTransactions): void {
+        $this->useTransactions = $useTransactions;
+    }
+
+    /**
+     * get all the metadata of a file or folder
+     * *
+     *
+     * @param string $path
+     * @return array|null an array of metadata of the file
+     */
+    protected function getData($path) {
+        $data = $this->storage->getMetaData($path);
+        if (is_null($data)) {
+            \OC::$server->get(LoggerInterface::class)->debug("!!! Path '$path' is not accessible or present !!!", ['app' => 'core']);
+        }
+        return $data;
+    }
+
+    /**
+     * scan a single file and store it in the cache
+     *
+     * @param string $file
+     * @param int $reuseExisting
+     * @param int $parentId
+     * @param array|CacheEntry|null|false $cacheData existing data in the cache for the file to be scanned
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @param array|null $data the metadata for the file, as returned by the storage
+     * @return array|null an array of metadata of the scanned file
+     * @throws \OCP\Lock\LockedException
+     */
+    public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true, $data = null) {
+        if ($file !== '') {
+            try {
+                $this->storage->verifyPath(dirname($file), basename($file));
+            } catch (\Exception $e) {
+                return null;
+            }
+        }
+
+        // only proceed if $file is not a partial file, blacklist is handled by the storage
+        if (self::isPartialFile($file)) {
+            return null;
+        }
+
+        // acquire a lock
+        if ($lock) {
+            if ($this->storage->instanceOfStorage(ILockingStorage::class)) {
+                $this->storage->acquireLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+            }
+        }
+
+        try {
+            $data = $data ?? $this->getData($file);
+        } catch (ForbiddenException $e) {
+            if ($lock) {
+                if ($this->storage->instanceOfStorage(ILockingStorage::class)) {
+                    $this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                }
+            }
+
+            return null;
+        }
+
+        try {
+            if ($data === null) {
+                $this->removeFromCache($file);
+            } else {
+                // pre-emit only if it was a file. By that we avoid counting/treating folders as files
+                if ($data['mimetype'] !== 'httpd/unix-directory') {
+                    $this->emit('\OC\Files\Cache\Scanner', 'scanFile', [$file, $this->storageId]);
+                    \OC_Hook::emit('\OC\Files\Cache\Scanner', 'scan_file', ['path' => $file, 'storage' => $this->storageId]);
+                }
+
+                $parent = dirname($file);
+                if ($parent === '.' || $parent === '/') {
+                    $parent = '';
+                }
+                if ($parentId === -1) {
+                    $parentId = $this->cache->getParentId($file);
+                }
+
+                // scan the parent if it's not in the cache (id -1) and the current file is not the root folder
+                if ($file && $parentId === -1) {
+                    $parentData = $this->scanFile($parent);
+                    if ($parentData === null) {
+                        return null;
+                    }
+
+                    $parentId = $parentData['fileid'];
+                }
+                if ($parent) {
+                    $data['parent'] = $parentId;
+                }
+
+                $cacheData = $cacheData ?? $this->cache->get($file);
+                if ($reuseExisting && $cacheData !== false && isset($cacheData['fileid'])) {
+                    // prevent empty etag
+                    $etag = empty($cacheData['etag']) ? $data['etag'] : $cacheData['etag'];
+                    $fileId = $cacheData['fileid'];
+                    $data['fileid'] = $fileId;
+                    // only reuse data if the file hasn't explicitly changed
+                    $mtimeUnchanged = isset($data['storage_mtime']) && isset($cacheData['storage_mtime']) && $data['storage_mtime'] === $cacheData['storage_mtime'];
+                    // if the folder is marked as unscanned, never reuse etags
+                    if ($mtimeUnchanged && $cacheData['size'] !== -1) {
+                        $data['mtime'] = $cacheData['mtime'];
+                        if (($reuseExisting & self::REUSE_SIZE) && ($data['size'] === -1)) {
+                            $data['size'] = $cacheData['size'];
+                        }
+                        if ($reuseExisting & self::REUSE_ETAG && !$this->storage->instanceOfStorage(IReliableEtagStorage::class)) {
+                            $data['etag'] = $etag;
+                        }
+                    }
+
+                    // we only updated unencrypted_size if it's already set
+                    if (isset($cacheData['unencrypted_size']) && $cacheData['unencrypted_size'] === 0) {
+                        unset($data['unencrypted_size']);
+                    }
+
+                    /**
+                     * Only update metadata that has changed.
+                     * i.e. get all the values in $data that are not present in the cache already
+                     *
+                     * We need the OC implementation for usage of "getData" method below.
+                     * @var \OC\Files\Cache\CacheEntry $cacheData
+                     */
+                    $newData = $this->array_diff_assoc_multi($data, $cacheData->getData());
+
+                    // make it known to the caller that etag has been changed and needs propagation
+                    if (isset($newData['etag'])) {
+                        $data['etag_changed'] = true;
+                    }
+                } else {
+                    unset($data['unencrypted_size']);
+                    $newData = $data;
+                    $fileId = -1;
+                }
+                if (!empty($newData)) {
+                    // Reset the checksum if the data has changed
+                    $newData['checksum'] = '';
+                    $newData['parent'] = $parentId;
+                    $data['fileid'] = $this->addToCache($file, $newData, $fileId);
+                }
+
+                if ($cacheData !== false) {
+                    $data['oldSize'] = $cacheData['size'] ?? 0;
+                    $data['encrypted'] = $cacheData['encrypted'] ?? false;
+                }
+
+                // post-emit only if it was a file. By that we avoid counting/treating folders as files
+                if ($data['mimetype'] !== 'httpd/unix-directory') {
+                    $this->emit('\OC\Files\Cache\Scanner', 'postScanFile', [$file, $this->storageId]);
+                    \OC_Hook::emit('\OC\Files\Cache\Scanner', 'post_scan_file', ['path' => $file, 'storage' => $this->storageId]);
+                }
+            }
+        } finally {
+            // release the acquired lock
+            if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
+                $this->storage->releaseLock($file, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+            }
+        }
+
+        return $data;
+    }
+
+    protected function removeFromCache($path) {
+        \OC_Hook::emit('Scanner', 'removeFromCache', ['file' => $path]);
+        $this->emit('\OC\Files\Cache\Scanner', 'removeFromCache', [$path]);
+        if ($this->cacheActive) {
+            $this->cache->remove($path);
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param array $data
+     * @param int $fileId
+     * @return int the id of the added file
+     */
+    protected function addToCache($path, $data, $fileId = -1) {
+        if (isset($data['scan_permissions'])) {
+            $data['permissions'] = $data['scan_permissions'];
+        }
+        \OC_Hook::emit('Scanner', 'addToCache', ['file' => $path, 'data' => $data]);
+        $this->emit('\OC\Files\Cache\Scanner', 'addToCache', [$path, $this->storageId, $data, $fileId]);
+        if ($this->cacheActive) {
+            if ($fileId !== -1) {
+                $this->cache->update($fileId, $data);
+                return $fileId;
+            } else {
+                return $this->cache->insert($path, $data);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param array $data
+     * @param int $fileId
+     */
+    protected function updateCache($path, $data, $fileId = -1) {
+        \OC_Hook::emit('Scanner', 'addToCache', ['file' => $path, 'data' => $data]);
+        $this->emit('\OC\Files\Cache\Scanner', 'updateCache', [$path, $this->storageId, $data]);
+        if ($this->cacheActive) {
+            if ($fileId !== -1) {
+                $this->cache->update($fileId, $data);
+            } else {
+                $this->cache->put($path, $data);
+            }
+        }
+    }
+
+    /**
+     * scan a folder and all it's children
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @return array|null an array of the meta data of the scanned file or folder
+     */
+    public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
+        if ($reuse === -1) {
+            $reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
+        }
+
+        if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
+            $this->storage->acquireLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
+            $this->storage->acquireLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+        }
+
+        try {
+            $data = $this->scanFile($path, $reuse, -1, lock: $lock);
+
+            if ($data !== null && $data['mimetype'] === 'httpd/unix-directory') {
+                $size = $this->scanChildren($path, $recursive, $reuse, $data['fileid'], $lock, $data['size']);
+                $data['size'] = $size;
+            }
+        } catch (NotFoundException $e) {
+            $this->removeFromCache($path);
+            return null;
+        } finally {
+            if ($lock && $this->storage->instanceOfStorage(ILockingStorage::class)) {
+                $this->storage->releaseLock($path, ILockingProvider::LOCK_SHARED, $this->lockingProvider);
+                $this->storage->releaseLock('scanner::' . $path, ILockingProvider::LOCK_EXCLUSIVE, $this->lockingProvider);
+            }
+        }
+        return $data;
+    }
+
+    /**
+     * Compares $array1 against $array2 and returns all the values in $array1 that are not in $array2
+     * Note this is a one-way check - i.e. we don't care about things that are in $array2 that aren't in $array1
+     *
+     * Supports multi-dimensional arrays
+     * Also checks keys/indexes
+     * Comparisons are strict just like array_diff_assoc
+     * Order of keys/values does not matter
+     *
+     * @param array $array1
+     * @param array $array2
+     * @return array with the differences between $array1 and $array1
+     * @throws \InvalidArgumentException if $array1 isn't an actual array
+     *
+     */
+    protected function array_diff_assoc_multi(array $array1, array $array2) {
+
+        $result = [];
+
+        foreach ($array1 as $key => $value) {
+
+            // if $array2 doesn't have the same key, that's a result
+            if (!array_key_exists($key, $array2)) {
+                $result[$key] = $value;
+                continue;
+            }
+
+            // if $array2's value for the same key is different, that's a result
+            if ($array2[$key] !== $value && !is_array($value)) {
+                $result[$key] = $value;
+                continue;
+            }
+
+            if (is_array($value)) {
+                $nestedDiff = $this->array_diff_assoc_multi($value, $array2[$key]);
+                if (!empty($nestedDiff)) {
+                    $result[$key] = $nestedDiff;
+                    continue;
+                }
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Get the children currently in the cache
+     *
+     * @param int $folderId
+     * @return array<string, \OCP\Files\Cache\ICacheEntry>
+     */
+    protected function getExistingChildren($folderId): array {
+        $existingChildren = [];
+        $children = $this->cache->getFolderContentsById($folderId);
+        foreach ($children as $child) {
+            $existingChildren[$child['name']] = $child;
+        }
+        return $existingChildren;
+    }
+
+    /**
+     * scan all the files and folders in a folder
+     *
+     * @param string $path
+     * @param bool|IScanner::SCAN_RECURSIVE_INCOMPLETE $recursive
+     * @param int $reuse a combination of self::REUSE_*
+     * @param int $folderId id for the folder to be scanned
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @param int|float $oldSize the size of the folder before (re)scanning the children
+     * @return int|float the size of the scanned folder or -1 if the size is unknown at this stage
+     */
+    protected function scanChildren(string $path, $recursive, int $reuse, int $folderId, bool $lock, int|float $oldSize, &$etagChanged = false) {
+        if ($reuse === -1) {
+            $reuse = ($recursive === self::SCAN_SHALLOW) ? self::REUSE_ETAG | self::REUSE_SIZE : self::REUSE_ETAG;
+        }
+        $this->emit('\OC\Files\Cache\Scanner', 'scanFolder', [$path, $this->storageId]);
+        $size = 0;
+        $childQueue = $this->handleChildren($path, $recursive, $reuse, $folderId, $lock, $size, $etagChanged);
+
+        foreach ($childQueue as $child => [$childId, $childSize]) {
+            // "etag changed" propagates up, but not down, so we pass `false` to the children even if we already know that the etag of the current folder changed
+            $childEtagChanged = false;
+            $childSize = $this->scanChildren($child, $recursive, $reuse, $childId, $lock, $childSize, $childEtagChanged);
+            $etagChanged |= $childEtagChanged;
+
+            if ($childSize === -1) {
+                $size = -1;
+            } elseif ($size !== -1) {
+                $size += $childSize;
+            }
+        }
+
+        // for encrypted storages, we trigger a regular folder size calculation instead of using the calculated size
+        // to make sure we also updated the unencrypted-size where applicable
+        if ($this->storage->instanceOfStorage(Encryption::class)) {
+            $this->cache->calculateFolderSize($path);
+        } else {
+            if ($this->cacheActive) {
+                $updatedData = [];
+                if ($oldSize !== $size) {
+                    $updatedData['size'] = $size;
+                }
+                if ($etagChanged) {
+                    $updatedData['etag'] = uniqid();
+                }
+                if ($updatedData) {
+                    $this->cache->update($folderId, $updatedData);
+                }
+            }
+        }
+        $this->emit('\OC\Files\Cache\Scanner', 'postScanFolder', [$path, $this->storageId]);
+        return $size;
+    }
+
+    /**
+     * @param bool|IScanner::SCAN_RECURSIVE_INCOMPLETE $recursive
+     */
+    private function handleChildren(string $path, $recursive, int $reuse, int $folderId, bool $lock, int|float &$size, bool &$etagChanged): array {
+        // we put this in it's own function so it cleans up the memory before we start recursing
+        $existingChildren = $this->getExistingChildren($folderId);
+        $newChildren = iterator_to_array($this->storage->getDirectoryContent($path));
+
+        if (count($existingChildren) === 0 && count($newChildren) === 0) {
+            // no need to do a transaction
+            return [];
+        }
+
+        if ($this->useTransactions) {
+            $this->connection->beginTransaction();
+        }
+
+        $exceptionOccurred = false;
+        $childQueue = [];
+        $newChildNames = [];
+        foreach ($newChildren as $fileMeta) {
+            $permissions = $fileMeta['scan_permissions'] ?? $fileMeta['permissions'];
+            if ($permissions === 0) {
+                continue;
+            }
+            $originalFile = $fileMeta['name'];
+            $file = trim(\OC\Files\Filesystem::normalizePath($originalFile), '/');
+            if (trim($originalFile, '/') !== $file) {
+                // encoding mismatch, might require compatibility wrapper
+                \OC::$server->get(LoggerInterface::class)->debug('Scanner: Skipping non-normalized file name "' . $originalFile . '" in path "' . $path . '".', ['app' => 'core']);
+                $this->emit('\OC\Files\Cache\Scanner', 'normalizedNameMismatch', [$path ? $path . '/' . $originalFile : $originalFile]);
+                // skip this entry
+                continue;
+            }
+
+            $newChildNames[] = $file;
+            $child = $path ? $path . '/' . $file : $file;
+            try {
+                $existingData = $existingChildren[$file] ?? false;
+                $data = $this->scanFile($child, $reuse, $folderId, $existingData, $lock, $fileMeta);
+                if ($data) {
+                    if ($data['mimetype'] === 'httpd/unix-directory' && $recursive === self::SCAN_RECURSIVE) {
+                        $childQueue[$child] = [$data['fileid'], $data['size']];
+                    } elseif ($data['mimetype'] === 'httpd/unix-directory' && $recursive === self::SCAN_RECURSIVE_INCOMPLETE && $data['size'] === -1) {
+                        // only recurse into folders which aren't fully scanned
+                        $childQueue[$child] = [$data['fileid'], $data['size']];
+                    } elseif ($data['size'] === -1) {
+                        $size = -1;
+                    } elseif ($size !== -1) {
+                        $size += $data['size'];
+                    }
+
+                    if (isset($data['etag_changed']) && $data['etag_changed']) {
+                        $etagChanged = true;
+                    }
+                }
+            } catch (Exception $ex) {
+                // might happen if inserting duplicate while a scanning
+                // process is running in parallel
+                // log and ignore
+                if ($this->useTransactions) {
+                    $this->connection->rollback();
+                    $this->connection->beginTransaction();
+                }
+                \OC::$server->get(LoggerInterface::class)->debug('Exception while scanning file "' . $child . '"', [
+                    'app' => 'core',
+                    'exception' => $ex,
+                ]);
+                $exceptionOccurred = true;
+            } catch (\OCP\Lock\LockedException $e) {
+                if ($this->useTransactions) {
+                    $this->connection->rollback();
+                }
+                throw $e;
+            }
+        }
+        $removedChildren = \array_diff(array_keys($existingChildren), $newChildNames);
+        foreach ($removedChildren as $childName) {
+            $child = $path ? $path . '/' . $childName : $childName;
+            $this->removeFromCache($child);
+        }
+        if ($this->useTransactions) {
+            $this->connection->commit();
+        }
+        if ($exceptionOccurred) {
+            // It might happen that the parallel scan process has already
+            // inserted mimetypes but those weren't available yet inside the transaction
+            // To make sure to have the updated mime types in such cases,
+            // we reload them here
+            \OC::$server->getMimeTypeLoader()->reset();
+        }
+        return $childQueue;
+    }
+
+    /**
+     * check if the file should be ignored when scanning
+     * NOTE: files with a '.part' extension are ignored as well!
+     *       prevents unfinished put requests to be scanned
+     *
+     * @param string $file
+     * @return boolean
+     */
+    public static function isPartialFile($file) {
+        if (pathinfo($file, PATHINFO_EXTENSION) === 'part') {
+            return true;
+        }
+        if (str_contains($file, '.part/')) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * walk over any folders that are not fully scanned yet and scan them
+     */
+    public function backgroundScan() {
+        if ($this->storage->instanceOfStorage(Jail::class)) {
+            // for jail storage wrappers (shares, groupfolders) we run the background scan on the source storage
+            // this is mainly done because the jail wrapper doesn't implement `getIncomplete` (because it would be inefficient).
+            //
+            // Running the scan on the source storage might scan more than "needed", but the unscanned files outside the jail will
+            // have to be scanned at some point anyway.
+            $unJailedScanner = $this->storage->getUnjailedStorage()->getScanner();
+            $unJailedScanner->backgroundScan();
+        } else {
+            if (!$this->cache->inCache('')) {
+                // if the storage isn't in the cache yet, just scan the root completely
+                $this->runBackgroundScanJob(function () {
+                    $this->scan('', self::SCAN_RECURSIVE, self::REUSE_ETAG);
+                }, '');
+            } else {
+                $lastPath = null;
+                // find any path marked as unscanned and run the scanner until no more paths are unscanned (or we get stuck)
+                while (($path = $this->cache->getIncomplete()) !== false && $path !== $lastPath) {
+                    $this->runBackgroundScanJob(function () use ($path) {
+                        $this->scan($path, self::SCAN_RECURSIVE_INCOMPLETE, self::REUSE_ETAG | self::REUSE_SIZE);
+                    }, $path);
+                    // FIXME: this won't proceed with the next item, needs revamping of getIncomplete()
+                    // to make this possible
+                    $lastPath = $path;
+                }
+            }
+        }
+    }
+
+    protected function runBackgroundScanJob(callable $callback, $path) {
+        try {
+            $callback();
+            \OC_Hook::emit('Scanner', 'correctFolderSize', ['path' => $path]);
+            if ($this->cacheActive && $this->cache instanceof Cache) {
+                $this->cache->correctFolderSize($path, null, true);
+            }
+        } catch (\OCP\Files\StorageInvalidException $e) {
+            // skip unavailable storages
+        } catch (\OCP\Files\StorageNotAvailableException $e) {
+            // skip unavailable storages
+        } catch (\OCP\Files\ForbiddenException $e) {
+            // skip forbidden storages
+        } catch (\OCP\Lock\LockedException $e) {
+            // skip unavailable storages
+        }
+    }
+
+    /**
+     * Set whether the cache is affected by scan operations
+     *
+     * @param boolean $active The active state of the cache
+     */
+    public function setCacheActive($active) {
+        $this->cacheActive = $active;
+    }
 }

lib/private/Files/Utils/Scanner.php

Indentation +237 added lines, -237 removed lines

@@ -42,266 +42,266 @@
  * @package OC\Files\Utils
  */
 class Scanner extends PublicEmitter {
-	public const MAX_ENTRIES_TO_COMMIT = 10000;
+    public const MAX_ENTRIES_TO_COMMIT = 10000;
 
-	/** @var string $user */
-	private $user;
+    /** @var string $user */
+    private $user;
 
-	/** @var IDBConnection */
-	protected $db;
+    /** @var IDBConnection */
+    protected $db;
 
-	/** @var IEventDispatcher */
-	private $dispatcher;
+    /** @var IEventDispatcher */
+    private $dispatcher;
 
-	protected LoggerInterface $logger;
+    protected LoggerInterface $logger;
 
-	/**
-	 * Whether to use a DB transaction
-	 *
-	 * @var bool
-	 */
-	protected $useTransaction;
+    /**
+     * Whether to use a DB transaction
+     *
+     * @var bool
+     */
+    protected $useTransaction;
 
-	/**
-	 * Number of entries scanned to commit
-	 *
-	 * @var int
-	 */
-	protected $entriesToCommit;
+    /**
+     * Number of entries scanned to commit
+     *
+     * @var int
+     */
+    protected $entriesToCommit;
 
-	/**
-	 * @param string $user
-	 * @param IDBConnection|null $db
-	 * @param IEventDispatcher $dispatcher
-	 */
-	public function __construct($user, $db, IEventDispatcher $dispatcher, LoggerInterface $logger) {
-		$this->user = $user;
-		$this->db = $db;
-		$this->dispatcher = $dispatcher;
-		$this->logger = $logger;
-		// when DB locking is used, no DB transactions will be used
-		$this->useTransaction = !(\OC::$server->get(ILockingProvider::class) instanceof DBLockingProvider);
-	}
+    /**
+     * @param string $user
+     * @param IDBConnection|null $db
+     * @param IEventDispatcher $dispatcher
+     */
+    public function __construct($user, $db, IEventDispatcher $dispatcher, LoggerInterface $logger) {
+        $this->user = $user;
+        $this->db = $db;
+        $this->dispatcher = $dispatcher;
+        $this->logger = $logger;
+        // when DB locking is used, no DB transactions will be used
+        $this->useTransaction = !(\OC::$server->get(ILockingProvider::class) instanceof DBLockingProvider);
+    }
 
-	/**
-	 * get all storages for $dir
-	 *
-	 * @param string $dir
-	 * @return array<string, IMountPoint>
-	 */
-	protected function getMounts($dir) {
-		//TODO: move to the node based fileapi once that's done
-		\OC_Util::tearDownFS();
-		\OC_Util::setupFS($this->user);
+    /**
+     * get all storages for $dir
+     *
+     * @param string $dir
+     * @return array<string, IMountPoint>
+     */
+    protected function getMounts($dir) {
+        //TODO: move to the node based fileapi once that's done
+        \OC_Util::tearDownFS();
+        \OC_Util::setupFS($this->user);
 
-		$mountManager = Filesystem::getMountManager();
-		$mounts = $mountManager->findIn($dir);
-		$mounts[] = $mountManager->find($dir);
-		$mounts = array_reverse($mounts); //start with the mount of $dir
-		$mountPoints = array_map(fn ($mount) => $mount->getMountPoint(), $mounts);
+        $mountManager = Filesystem::getMountManager();
+        $mounts = $mountManager->findIn($dir);
+        $mounts[] = $mountManager->find($dir);
+        $mounts = array_reverse($mounts); //start with the mount of $dir
+        $mountPoints = array_map(fn ($mount) => $mount->getMountPoint(), $mounts);
 
-		return array_combine($mountPoints, $mounts);
-	}
+        return array_combine($mountPoints, $mounts);
+    }
 
-	/**
-	 * attach listeners to the scanner
-	 *
-	 * @param \OC\Files\Mount\MountPoint $mount
-	 */
-	protected function attachListener($mount) {
-		/** @var \OC\Files\Cache\Scanner $scanner */
-		$scanner = $mount->getStorage()->getScanner();
-		$scanner->listen('\OC\Files\Cache\Scanner', 'scanFile', function ($path) use ($mount) {
-			$this->emit('\OC\Files\Utils\Scanner', 'scanFile', [$mount->getMountPoint() . $path]);
-			$this->dispatcher->dispatchTyped(new BeforeFileScannedEvent($mount->getMountPoint() . $path));
-		});
-		$scanner->listen('\OC\Files\Cache\Scanner', 'scanFolder', function ($path) use ($mount) {
-			$this->emit('\OC\Files\Utils\Scanner', 'scanFolder', [$mount->getMountPoint() . $path]);
-			$this->dispatcher->dispatchTyped(new BeforeFolderScannedEvent($mount->getMountPoint() . $path));
-		});
-		$scanner->listen('\OC\Files\Cache\Scanner', 'postScanFile', function ($path) use ($mount) {
-			$this->emit('\OC\Files\Utils\Scanner', 'postScanFile', [$mount->getMountPoint() . $path]);
-			$this->dispatcher->dispatchTyped(new FileScannedEvent($mount->getMountPoint() . $path));
-		});
-		$scanner->listen('\OC\Files\Cache\Scanner', 'postScanFolder', function ($path) use ($mount) {
-			$this->emit('\OC\Files\Utils\Scanner', 'postScanFolder', [$mount->getMountPoint() . $path]);
-			$this->dispatcher->dispatchTyped(new FolderScannedEvent($mount->getMountPoint() . $path));
-		});
-		$scanner->listen('\OC\Files\Cache\Scanner', 'normalizedNameMismatch', function ($path) use ($mount) {
-			$this->emit('\OC\Files\Utils\Scanner', 'normalizedNameMismatch', [$path]);
-		});
-	}
+    /**
+     * attach listeners to the scanner
+     *
+     * @param \OC\Files\Mount\MountPoint $mount
+     */
+    protected function attachListener($mount) {
+        /** @var \OC\Files\Cache\Scanner $scanner */
+        $scanner = $mount->getStorage()->getScanner();
+        $scanner->listen('\OC\Files\Cache\Scanner', 'scanFile', function ($path) use ($mount) {
+            $this->emit('\OC\Files\Utils\Scanner', 'scanFile', [$mount->getMountPoint() . $path]);
+            $this->dispatcher->dispatchTyped(new BeforeFileScannedEvent($mount->getMountPoint() . $path));
+        });
+        $scanner->listen('\OC\Files\Cache\Scanner', 'scanFolder', function ($path) use ($mount) {
+            $this->emit('\OC\Files\Utils\Scanner', 'scanFolder', [$mount->getMountPoint() . $path]);
+            $this->dispatcher->dispatchTyped(new BeforeFolderScannedEvent($mount->getMountPoint() . $path));
+        });
+        $scanner->listen('\OC\Files\Cache\Scanner', 'postScanFile', function ($path) use ($mount) {
+            $this->emit('\OC\Files\Utils\Scanner', 'postScanFile', [$mount->getMountPoint() . $path]);
+            $this->dispatcher->dispatchTyped(new FileScannedEvent($mount->getMountPoint() . $path));
+        });
+        $scanner->listen('\OC\Files\Cache\Scanner', 'postScanFolder', function ($path) use ($mount) {
+            $this->emit('\OC\Files\Utils\Scanner', 'postScanFolder', [$mount->getMountPoint() . $path]);
+            $this->dispatcher->dispatchTyped(new FolderScannedEvent($mount->getMountPoint() . $path));
+        });
+        $scanner->listen('\OC\Files\Cache\Scanner', 'normalizedNameMismatch', function ($path) use ($mount) {
+            $this->emit('\OC\Files\Utils\Scanner', 'normalizedNameMismatch', [$path]);
+        });
+    }
 
-	/**
-	 * @param string $dir
-	 */
-	public function backgroundScan($dir) {
-		$mounts = $this->getMounts($dir);
-		foreach ($mounts as $mount) {
-			try {
-				$storage = $mount->getStorage();
-				if (is_null($storage)) {
-					continue;
-				}
+    /**
+     * @param string $dir
+     */
+    public function backgroundScan($dir) {
+        $mounts = $this->getMounts($dir);
+        foreach ($mounts as $mount) {
+            try {
+                $storage = $mount->getStorage();
+                if (is_null($storage)) {
+                    continue;
+                }
 
-				// don't bother scanning failed storages (shortcut for same result)
-				if ($storage->instanceOfStorage(FailedStorage::class)) {
-					continue;
-				}
+                // don't bother scanning failed storages (shortcut for same result)
+                if ($storage->instanceOfStorage(FailedStorage::class)) {
+                    continue;
+                }
 
-				/** @var \OC\Files\Cache\Scanner $scanner */
-				$scanner = $storage->getScanner();
-				$this->attachListener($mount);
+                /** @var \OC\Files\Cache\Scanner $scanner */
+                $scanner = $storage->getScanner();
+                $this->attachListener($mount);
 
-				$scanner->listen('\OC\Files\Cache\Scanner', 'removeFromCache', function ($path) use ($storage) {
-					$this->triggerPropagator($storage, $path);
-				});
-				$scanner->listen('\OC\Files\Cache\Scanner', 'updateCache', function ($path) use ($storage) {
-					$this->triggerPropagator($storage, $path);
-				});
-				$scanner->listen('\OC\Files\Cache\Scanner', 'addToCache', function ($path) use ($storage) {
-					$this->triggerPropagator($storage, $path);
-				});
+                $scanner->listen('\OC\Files\Cache\Scanner', 'removeFromCache', function ($path) use ($storage) {
+                    $this->triggerPropagator($storage, $path);
+                });
+                $scanner->listen('\OC\Files\Cache\Scanner', 'updateCache', function ($path) use ($storage) {
+                    $this->triggerPropagator($storage, $path);
+                });
+                $scanner->listen('\OC\Files\Cache\Scanner', 'addToCache', function ($path) use ($storage) {
+                    $this->triggerPropagator($storage, $path);
+                });
 
-				$propagator = $storage->getPropagator();
-				$propagator->beginBatch();
-				$scanner->backgroundScan();
-				$propagator->commitBatch();
-			} catch (\Exception $e) {
-				$this->logger->error("Error while trying to scan mount as {$mount->getMountPoint()}:" . $e->getMessage(), ['exception' => $e, 'app' => 'files']);
-			}
-		}
-	}
+                $propagator = $storage->getPropagator();
+                $propagator->beginBatch();
+                $scanner->backgroundScan();
+                $propagator->commitBatch();
+            } catch (\Exception $e) {
+                $this->logger->error("Error while trying to scan mount as {$mount->getMountPoint()}:" . $e->getMessage(), ['exception' => $e, 'app' => 'files']);
+            }
+        }
+    }
 
-	/**
-	 * @param string $dir
-	 * @param $recursive
-	 * @param callable|null $mountFilter
-	 * @throws ForbiddenException
-	 * @throws NotFoundException
-	 */
-	public function scan($dir = '', $recursive = \OC\Files\Cache\Scanner::SCAN_RECURSIVE, ?callable $mountFilter = null) {
-		if (!Filesystem::isValidPath($dir)) {
-			throw new \InvalidArgumentException('Invalid path to scan');
-		}
-		$mounts = $this->getMounts($dir);
-		foreach ($mounts as $mount) {
-			if ($mountFilter && !$mountFilter($mount)) {
-				continue;
-			}
-			$storage = $mount->getStorage();
-			if (is_null($storage)) {
-				continue;
-			}
+    /**
+     * @param string $dir
+     * @param $recursive
+     * @param callable|null $mountFilter
+     * @throws ForbiddenException
+     * @throws NotFoundException
+     */
+    public function scan($dir = '', $recursive = \OC\Files\Cache\Scanner::SCAN_RECURSIVE, ?callable $mountFilter = null) {
+        if (!Filesystem::isValidPath($dir)) {
+            throw new \InvalidArgumentException('Invalid path to scan');
+        }
+        $mounts = $this->getMounts($dir);
+        foreach ($mounts as $mount) {
+            if ($mountFilter && !$mountFilter($mount)) {
+                continue;
+            }
+            $storage = $mount->getStorage();
+            if (is_null($storage)) {
+                continue;
+            }
 
-			// don't bother scanning failed storages (shortcut for same result)
-			if ($storage->instanceOfStorage(FailedStorage::class)) {
-				continue;
-			}
+            // don't bother scanning failed storages (shortcut for same result)
+            if ($storage->instanceOfStorage(FailedStorage::class)) {
+                continue;
+            }
 
-			// if the home storage isn't writable then the scanner is run as the wrong user
-			if ($storage->instanceOfStorage(Home::class)) {
-				/** @var Home $storage */
-				foreach (['', 'files'] as $path) {
-					if (!$storage->isCreatable($path)) {
-						$fullPath = $storage->getSourcePath($path);
-						if (!$storage->is_dir($path) && $storage->getCache()->inCache($path)) {
-							throw new NotFoundException("User folder $fullPath exists in cache but not on disk");
-						} elseif ($storage->is_dir($path)) {
-							$ownerUid = fileowner($fullPath);
-							$owner = posix_getpwuid($ownerUid);
-							$owner = $owner['name'] ?? $ownerUid;
-							$permissions = decoct(fileperms($fullPath));
-							throw new ForbiddenException("User folder $fullPath is not writable, folders is owned by $owner and has mode $permissions");
-						} elseif (isset($mounts[$mount->getMountPoint() . $path . '/'])) {
-							// /<user>/files is overwritten by a mountpoint, so this check is irrelevant
-							break;
-						} else {
-							// if the root exists in neither the cache nor the storage the user isn't setup yet
-							break 2;
-						}
-					}
-				}
-			}
+            // if the home storage isn't writable then the scanner is run as the wrong user
+            if ($storage->instanceOfStorage(Home::class)) {
+                /** @var Home $storage */
+                foreach (['', 'files'] as $path) {
+                    if (!$storage->isCreatable($path)) {
+                        $fullPath = $storage->getSourcePath($path);
+                        if (!$storage->is_dir($path) && $storage->getCache()->inCache($path)) {
+                            throw new NotFoundException("User folder $fullPath exists in cache but not on disk");
+                        } elseif ($storage->is_dir($path)) {
+                            $ownerUid = fileowner($fullPath);
+                            $owner = posix_getpwuid($ownerUid);
+                            $owner = $owner['name'] ?? $ownerUid;
+                            $permissions = decoct(fileperms($fullPath));
+                            throw new ForbiddenException("User folder $fullPath is not writable, folders is owned by $owner and has mode $permissions");
+                        } elseif (isset($mounts[$mount->getMountPoint() . $path . '/'])) {
+                            // /<user>/files is overwritten by a mountpoint, so this check is irrelevant
+                            break;
+                        } else {
+                            // if the root exists in neither the cache nor the storage the user isn't setup yet
+                            break 2;
+                        }
+                    }
+                }
+            }
 
-			// don't scan received local shares, these can be scanned when scanning the owner's storage
-			if ($storage->instanceOfStorage(SharedStorage::class)) {
-				continue;
-			}
-			$relativePath = $mount->getInternalPath($dir);
-			/** @var \OC\Files\Cache\Scanner $scanner */
-			$scanner = $storage->getScanner();
-			$scanner->setUseTransactions(false);
-			$this->attachListener($mount);
+            // don't scan received local shares, these can be scanned when scanning the owner's storage
+            if ($storage->instanceOfStorage(SharedStorage::class)) {
+                continue;
+            }
+            $relativePath = $mount->getInternalPath($dir);
+            /** @var \OC\Files\Cache\Scanner $scanner */
+            $scanner = $storage->getScanner();
+            $scanner->setUseTransactions(false);
+            $this->attachListener($mount);
 
-			$scanner->listen('\OC\Files\Cache\Scanner', 'removeFromCache', function ($path) use ($storage) {
-				$this->postProcessEntry($storage, $path);
-				$this->dispatcher->dispatchTyped(new NodeRemovedFromCache($storage, $path));
-			});
-			$scanner->listen('\OC\Files\Cache\Scanner', 'updateCache', function ($path) use ($storage) {
-				$this->postProcessEntry($storage, $path);
-				$this->dispatcher->dispatchTyped(new FileCacheUpdated($storage, $path));
-			});
-			$scanner->listen('\OC\Files\Cache\Scanner', 'addToCache', function ($path, $storageId, $data, $fileId) use ($storage) {
-				$this->postProcessEntry($storage, $path);
-				if ($fileId) {
-					$this->dispatcher->dispatchTyped(new FileCacheUpdated($storage, $path));
-				} else {
-					$this->dispatcher->dispatchTyped(new NodeAddedToCache($storage, $path));
-				}
-			});
+            $scanner->listen('\OC\Files\Cache\Scanner', 'removeFromCache', function ($path) use ($storage) {
+                $this->postProcessEntry($storage, $path);
+                $this->dispatcher->dispatchTyped(new NodeRemovedFromCache($storage, $path));
+            });
+            $scanner->listen('\OC\Files\Cache\Scanner', 'updateCache', function ($path) use ($storage) {
+                $this->postProcessEntry($storage, $path);
+                $this->dispatcher->dispatchTyped(new FileCacheUpdated($storage, $path));
+            });
+            $scanner->listen('\OC\Files\Cache\Scanner', 'addToCache', function ($path, $storageId, $data, $fileId) use ($storage) {
+                $this->postProcessEntry($storage, $path);
+                if ($fileId) {
+                    $this->dispatcher->dispatchTyped(new FileCacheUpdated($storage, $path));
+                } else {
+                    $this->dispatcher->dispatchTyped(new NodeAddedToCache($storage, $path));
+                }
+            });
 
-			if (!$storage->file_exists($relativePath)) {
-				throw new NotFoundException($dir);
-			}
+            if (!$storage->file_exists($relativePath)) {
+                throw new NotFoundException($dir);
+            }
 
-			if ($this->useTransaction) {
-				$this->db->beginTransaction();
-			}
-			try {
-				$propagator = $storage->getPropagator();
-				$propagator->beginBatch();
-				try {
-					$scanner->scan($relativePath, $recursive, \OC\Files\Cache\Scanner::REUSE_ETAG | \OC\Files\Cache\Scanner::REUSE_SIZE);
-				} catch (LockedException $e) {
-					if (is_string($e->getReadablePath()) && str_starts_with($e->getReadablePath(), 'scanner::')) {
-						throw new LockedException("scanner::$dir", $e, $e->getExistingLock());
-					} else {
-						throw $e;
-					}
-				}
-				$cache = $storage->getCache();
-				if ($cache instanceof Cache) {
-					// only re-calculate for the root folder we scanned, anything below that is taken care of by the scanner
-					$cache->correctFolderSize($relativePath);
-				}
-				$propagator->commitBatch();
-			} catch (StorageNotAvailableException $e) {
-				$this->logger->error('Storage ' . $storage->getId() . ' not available', ['exception' => $e]);
-				$this->emit('\OC\Files\Utils\Scanner', 'StorageNotAvailable', [$e]);
-			}
-			if ($this->useTransaction) {
-				$this->db->commit();
-			}
-		}
-	}
+            if ($this->useTransaction) {
+                $this->db->beginTransaction();
+            }
+            try {
+                $propagator = $storage->getPropagator();
+                $propagator->beginBatch();
+                try {
+                    $scanner->scan($relativePath, $recursive, \OC\Files\Cache\Scanner::REUSE_ETAG | \OC\Files\Cache\Scanner::REUSE_SIZE);
+                } catch (LockedException $e) {
+                    if (is_string($e->getReadablePath()) && str_starts_with($e->getReadablePath(), 'scanner::')) {
+                        throw new LockedException("scanner::$dir", $e, $e->getExistingLock());
+                    } else {
+                        throw $e;
+                    }
+                }
+                $cache = $storage->getCache();
+                if ($cache instanceof Cache) {
+                    // only re-calculate for the root folder we scanned, anything below that is taken care of by the scanner
+                    $cache->correctFolderSize($relativePath);
+                }
+                $propagator->commitBatch();
+            } catch (StorageNotAvailableException $e) {
+                $this->logger->error('Storage ' . $storage->getId() . ' not available', ['exception' => $e]);
+                $this->emit('\OC\Files\Utils\Scanner', 'StorageNotAvailable', [$e]);
+            }
+            if ($this->useTransaction) {
+                $this->db->commit();
+            }
+        }
+    }
 
-	private function triggerPropagator(IStorage $storage, $internalPath) {
-		$storage->getPropagator()->propagateChange($internalPath, time());
-	}
+    private function triggerPropagator(IStorage $storage, $internalPath) {
+        $storage->getPropagator()->propagateChange($internalPath, time());
+    }
 
-	private function postProcessEntry(IStorage $storage, $internalPath) {
-		$this->triggerPropagator($storage, $internalPath);
-		if ($this->useTransaction) {
-			$this->entriesToCommit++;
-			if ($this->entriesToCommit >= self::MAX_ENTRIES_TO_COMMIT) {
-				$propagator = $storage->getPropagator();
-				$this->entriesToCommit = 0;
-				$this->db->commit();
-				$propagator->commitBatch();
-				$this->db->beginTransaction();
-				$propagator->beginBatch();
-			}
-		}
-	}
+    private function postProcessEntry(IStorage $storage, $internalPath) {
+        $this->triggerPropagator($storage, $internalPath);
+        if ($this->useTransaction) {
+            $this->entriesToCommit++;
+            if ($this->entriesToCommit >= self::MAX_ENTRIES_TO_COMMIT) {
+                $propagator = $storage->getPropagator();
+                $this->entriesToCommit = 0;
+                $this->db->commit();
+                $propagator->commitBatch();
+                $this->db->beginTransaction();
+                $propagator->beginBatch();
+            }
+        }
+    }
 }

apps/files/lib/Command/Scan.php

Indentation +274 added lines, -274 removed lines

@@ -34,304 +34,304 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Scan extends Base {
-	protected float $execTime = 0;
-	protected int $foldersCounter = 0;
-	protected int $filesCounter = 0;
-	protected int $errorsCounter = 0;
-	protected int $newCounter = 0;
-	protected int $updatedCounter = 0;
-	protected int $removedCounter = 0;
+    protected float $execTime = 0;
+    protected int $foldersCounter = 0;
+    protected int $filesCounter = 0;
+    protected int $errorsCounter = 0;
+    protected int $newCounter = 0;
+    protected int $updatedCounter = 0;
+    protected int $removedCounter = 0;
 
-	public function __construct(
-		private IUserManager $userManager,
-		private IRootFolder $rootFolder,
-		private FilesMetadataManager $filesMetadataManager,
-		private IEventDispatcher $eventDispatcher,
-		private LoggerInterface $logger,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        private IUserManager $userManager,
+        private IRootFolder $rootFolder,
+        private FilesMetadataManager $filesMetadataManager,
+        private IEventDispatcher $eventDispatcher,
+        private LoggerInterface $logger,
+    ) {
+        parent::__construct();
+    }
 
-	protected function configure(): void {
-		parent::configure();
+    protected function configure(): void {
+        parent::configure();
 
-		$this
-			->setName('files:scan')
-			->setDescription('rescan filesystem')
-			->addArgument(
-				'user_id',
-				InputArgument::OPTIONAL | InputArgument::IS_ARRAY,
-				'will rescan all files of the given user(s)'
-			)
-			->addOption(
-				'path',
-				'p',
-				InputOption::VALUE_REQUIRED,
-				'limit rescan to this path, eg. --path="/alice/files/Music", the user_id is determined by the path and the user_id parameter and --all are ignored'
-			)
-			->addOption(
-				'generate-metadata',
-				null,
-				InputOption::VALUE_OPTIONAL,
-				'Generate metadata for all scanned files; if specified only generate for named value',
-				''
-			)
-			->addOption(
-				'all',
-				null,
-				InputOption::VALUE_NONE,
-				'will rescan all files of all known users'
-			)->addOption(
-				'unscanned',
-				null,
-				InputOption::VALUE_NONE,
-				'only scan files which are marked as not fully scanned'
-			)->addOption(
-				'shallow',
-				null,
-				InputOption::VALUE_NONE,
-				'do not scan folders recursively'
-			)->addOption(
-				'home-only',
-				null,
-				InputOption::VALUE_NONE,
-				'only scan the home storage, ignoring any mounted external storage or share'
-			);
-	}
+        $this
+            ->setName('files:scan')
+            ->setDescription('rescan filesystem')
+            ->addArgument(
+                'user_id',
+                InputArgument::OPTIONAL | InputArgument::IS_ARRAY,
+                'will rescan all files of the given user(s)'
+            )
+            ->addOption(
+                'path',
+                'p',
+                InputOption::VALUE_REQUIRED,
+                'limit rescan to this path, eg. --path="/alice/files/Music", the user_id is determined by the path and the user_id parameter and --all are ignored'
+            )
+            ->addOption(
+                'generate-metadata',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'Generate metadata for all scanned files; if specified only generate for named value',
+                ''
+            )
+            ->addOption(
+                'all',
+                null,
+                InputOption::VALUE_NONE,
+                'will rescan all files of all known users'
+            )->addOption(
+                'unscanned',
+                null,
+                InputOption::VALUE_NONE,
+                'only scan files which are marked as not fully scanned'
+            )->addOption(
+                'shallow',
+                null,
+                InputOption::VALUE_NONE,
+                'do not scan folders recursively'
+            )->addOption(
+                'home-only',
+                null,
+                InputOption::VALUE_NONE,
+                'only scan the home storage, ignoring any mounted external storage or share'
+            );
+    }
 
-	protected function scanFiles(string $user, string $path, ?string $scanMetadata, OutputInterface $output, bool $backgroundScan = false, bool $recursive = true, bool $homeOnly = false): void {
-		$connection = $this->reconnectToDatabase($output);
-		$scanner = new Scanner(
-			$user,
-			new ConnectionAdapter($connection),
-			Server::get(IEventDispatcher::class),
-			Server::get(LoggerInterface::class)
-		);
+    protected function scanFiles(string $user, string $path, ?string $scanMetadata, OutputInterface $output, bool $backgroundScan = false, bool $recursive = true, bool $homeOnly = false): void {
+        $connection = $this->reconnectToDatabase($output);
+        $scanner = new Scanner(
+            $user,
+            new ConnectionAdapter($connection),
+            Server::get(IEventDispatcher::class),
+            Server::get(LoggerInterface::class)
+        );
 
-		# check on each file/folder if there was a user interrupt (ctrl-c) and throw an exception
-		$scanner->listen('\OC\Files\Utils\Scanner', 'scanFile', function (string $path) use ($output, $scanMetadata): void {
-			$output->writeln("\tFile\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
-			++$this->filesCounter;
-			$this->abortIfInterrupted();
-			if ($scanMetadata !== null) {
-				$node = $this->rootFolder->get($path);
-				$this->filesMetadataManager->refreshMetadata(
-					$node,
-					($scanMetadata !== '') ? IFilesMetadataManager::PROCESS_NAMED : IFilesMetadataManager::PROCESS_LIVE | IFilesMetadataManager::PROCESS_BACKGROUND,
-					$scanMetadata
-				);
-			}
-		});
+        # check on each file/folder if there was a user interrupt (ctrl-c) and throw an exception
+        $scanner->listen('\OC\Files\Utils\Scanner', 'scanFile', function (string $path) use ($output, $scanMetadata): void {
+            $output->writeln("\tFile\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
+            ++$this->filesCounter;
+            $this->abortIfInterrupted();
+            if ($scanMetadata !== null) {
+                $node = $this->rootFolder->get($path);
+                $this->filesMetadataManager->refreshMetadata(
+                    $node,
+                    ($scanMetadata !== '') ? IFilesMetadataManager::PROCESS_NAMED : IFilesMetadataManager::PROCESS_LIVE | IFilesMetadataManager::PROCESS_BACKGROUND,
+                    $scanMetadata
+                );
+            }
+        });
 
-		$scanner->listen('\OC\Files\Utils\Scanner', 'scanFolder', function ($path) use ($output): void {
-			$output->writeln("\tFolder\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
-			++$this->foldersCounter;
-			$this->abortIfInterrupted();
-		});
+        $scanner->listen('\OC\Files\Utils\Scanner', 'scanFolder', function ($path) use ($output): void {
+            $output->writeln("\tFolder\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
+            ++$this->foldersCounter;
+            $this->abortIfInterrupted();
+        });
 
-		$scanner->listen('\OC\Files\Utils\Scanner', 'StorageNotAvailable', function (StorageNotAvailableException $e) use ($output): void {
-			$output->writeln('Error while scanning, storage not available (' . $e->getMessage() . ')', OutputInterface::VERBOSITY_VERBOSE);
-			++$this->errorsCounter;
-		});
+        $scanner->listen('\OC\Files\Utils\Scanner', 'StorageNotAvailable', function (StorageNotAvailableException $e) use ($output): void {
+            $output->writeln('Error while scanning, storage not available (' . $e->getMessage() . ')', OutputInterface::VERBOSITY_VERBOSE);
+            ++$this->errorsCounter;
+        });
 
-		$scanner->listen('\OC\Files\Utils\Scanner', 'normalizedNameMismatch', function ($fullPath) use ($output): void {
-			$output->writeln("\t<error>Entry \"" . $fullPath . '" will not be accessible due to incompatible encoding</error>');
-			++$this->errorsCounter;
-		});
+        $scanner->listen('\OC\Files\Utils\Scanner', 'normalizedNameMismatch', function ($fullPath) use ($output): void {
+            $output->writeln("\t<error>Entry \"" . $fullPath . '" will not be accessible due to incompatible encoding</error>');
+            ++$this->errorsCounter;
+        });
 
-		$this->eventDispatcher->addListener(NodeAddedToCache::class, function (): void {
-			++$this->newCounter;
-		});
-		$this->eventDispatcher->addListener(FileCacheUpdated::class, function (): void {
-			++$this->updatedCounter;
-		});
-		$this->eventDispatcher->addListener(NodeRemovedFromCache::class, function (): void {
-			++$this->removedCounter;
-		});
+        $this->eventDispatcher->addListener(NodeAddedToCache::class, function (): void {
+            ++$this->newCounter;
+        });
+        $this->eventDispatcher->addListener(FileCacheUpdated::class, function (): void {
+            ++$this->updatedCounter;
+        });
+        $this->eventDispatcher->addListener(NodeRemovedFromCache::class, function (): void {
+            ++$this->removedCounter;
+        });
 
-		try {
-			if ($backgroundScan) {
-				$scanner->backgroundScan($path);
-			} else {
-				$scanner->scan($path, $recursive, $homeOnly ? [$this, 'filterHomeMount'] : null);
-			}
-		} catch (ForbiddenException $e) {
-			$output->writeln("<error>Home storage for user $user not writable or 'files' subdirectory missing</error>");
-			$output->writeln('  ' . $e->getMessage());
-			$output->writeln('Make sure you\'re running the scan command only as the user the web server runs as');
-			++$this->errorsCounter;
-		} catch (InterruptedException $e) {
-			# exit the function if ctrl-c has been pressed
-			$output->writeln('Interrupted by user');
-		} catch (NotFoundException $e) {
-			$output->writeln('<error>Path not found: ' . $e->getMessage() . '</error>');
-			++$this->errorsCounter;
-		} catch (LockedException $e) {
-			if (str_starts_with($e->getPath(), 'scanner::')) {
-				$output->writeln('<error>Another process is already scanning \'' . substr($e->getPath(), strlen('scanner::')) . '\'</error>');
-			} else {
-				throw $e;
-			}
-		} catch (\Exception $e) {
-			$output->writeln('<error>Exception during scan: ' . $e->getMessage() . '</error>');
-			$output->writeln('<error>' . $e->getTraceAsString() . '</error>');
-			++$this->errorsCounter;
-		}
-	}
+        try {
+            if ($backgroundScan) {
+                $scanner->backgroundScan($path);
+            } else {
+                $scanner->scan($path, $recursive, $homeOnly ? [$this, 'filterHomeMount'] : null);
+            }
+        } catch (ForbiddenException $e) {
+            $output->writeln("<error>Home storage for user $user not writable or 'files' subdirectory missing</error>");
+            $output->writeln('  ' . $e->getMessage());
+            $output->writeln('Make sure you\'re running the scan command only as the user the web server runs as');
+            ++$this->errorsCounter;
+        } catch (InterruptedException $e) {
+            # exit the function if ctrl-c has been pressed
+            $output->writeln('Interrupted by user');
+        } catch (NotFoundException $e) {
+            $output->writeln('<error>Path not found: ' . $e->getMessage() . '</error>');
+            ++$this->errorsCounter;
+        } catch (LockedException $e) {
+            if (str_starts_with($e->getPath(), 'scanner::')) {
+                $output->writeln('<error>Another process is already scanning \'' . substr($e->getPath(), strlen('scanner::')) . '\'</error>');
+            } else {
+                throw $e;
+            }
+        } catch (\Exception $e) {
+            $output->writeln('<error>Exception during scan: ' . $e->getMessage() . '</error>');
+            $output->writeln('<error>' . $e->getTraceAsString() . '</error>');
+            ++$this->errorsCounter;
+        }
+    }
 
-	public function filterHomeMount(IMountPoint $mountPoint): bool {
-		// any mountpoint inside '/$user/files/'
-		return substr_count($mountPoint->getMountPoint(), '/') <= 3;
-	}
+    public function filterHomeMount(IMountPoint $mountPoint): bool {
+        // any mountpoint inside '/$user/files/'
+        return substr_count($mountPoint->getMountPoint(), '/') <= 3;
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$inputPath = $input->getOption('path');
-		if ($inputPath) {
-			$inputPath = '/' . trim($inputPath, '/');
-			[, $user,] = explode('/', $inputPath, 3);
-			$users = [$user];
-		} elseif ($input->getOption('all')) {
-			$users = $this->userManager->search('');
-		} else {
-			$users = $input->getArgument('user_id');
-		}
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $inputPath = $input->getOption('path');
+        if ($inputPath) {
+            $inputPath = '/' . trim($inputPath, '/');
+            [, $user,] = explode('/', $inputPath, 3);
+            $users = [$user];
+        } elseif ($input->getOption('all')) {
+            $users = $this->userManager->search('');
+        } else {
+            $users = $input->getArgument('user_id');
+        }
 
-		# check quantity of users to be process and show it on the command line
-		$users_total = count($users);
-		if ($users_total === 0) {
-			$output->writeln('<error>Please specify the user id to scan, --all to scan for all users or --path=...</error>');
-			return self::FAILURE;
-		}
+        # check quantity of users to be process and show it on the command line
+        $users_total = count($users);
+        if ($users_total === 0) {
+            $output->writeln('<error>Please specify the user id to scan, --all to scan for all users or --path=...</error>');
+            return self::FAILURE;
+        }
 
-		$this->initTools($output);
+        $this->initTools($output);
 
-		// getOption() logic on VALUE_OPTIONAL
-		$metadata = null; // null if --generate-metadata is not set, empty if option have no value, value if set
-		if ($input->getOption('generate-metadata') !== '') {
-			$metadata = $input->getOption('generate-metadata') ?? '';
-		}
+        // getOption() logic on VALUE_OPTIONAL
+        $metadata = null; // null if --generate-metadata is not set, empty if option have no value, value if set
+        if ($input->getOption('generate-metadata') !== '') {
+            $metadata = $input->getOption('generate-metadata') ?? '';
+        }
 
-		$user_count = 0;
-		foreach ($users as $user) {
-			if (is_object($user)) {
-				$user = $user->getUID();
-			}
-			$path = $inputPath ?: '/' . $user;
-			++$user_count;
-			if ($this->userManager->userExists($user)) {
-				$output->writeln("Starting scan for user $user_count out of $users_total ($user)");
-				$this->scanFiles($user, $path, $metadata, $output, $input->getOption('unscanned'), !$input->getOption('shallow'), $input->getOption('home-only'));
-				$output->writeln('', OutputInterface::VERBOSITY_VERBOSE);
-			} else {
-				$output->writeln("<error>Unknown user $user_count $user</error>");
-				$output->writeln('', OutputInterface::VERBOSITY_VERBOSE);
-			}
+        $user_count = 0;
+        foreach ($users as $user) {
+            if (is_object($user)) {
+                $user = $user->getUID();
+            }
+            $path = $inputPath ?: '/' . $user;
+            ++$user_count;
+            if ($this->userManager->userExists($user)) {
+                $output->writeln("Starting scan for user $user_count out of $users_total ($user)");
+                $this->scanFiles($user, $path, $metadata, $output, $input->getOption('unscanned'), !$input->getOption('shallow'), $input->getOption('home-only'));
+                $output->writeln('', OutputInterface::VERBOSITY_VERBOSE);
+            } else {
+                $output->writeln("<error>Unknown user $user_count $user</error>");
+                $output->writeln('', OutputInterface::VERBOSITY_VERBOSE);
+            }
 
-			try {
-				$this->abortIfInterrupted();
-			} catch (InterruptedException $e) {
-				break;
-			}
-		}
+            try {
+                $this->abortIfInterrupted();
+            } catch (InterruptedException $e) {
+                break;
+            }
+        }
 
-		$this->presentStats($output);
-		return self::SUCCESS;
-	}
+        $this->presentStats($output);
+        return self::SUCCESS;
+    }
 
-	/**
-	 * Initialises some useful tools for the Command
-	 */
-	protected function initTools(OutputInterface $output): void {
-		// Start the timer
-		$this->execTime = -microtime(true);
-		// Convert PHP errors to exceptions
-		set_error_handler(
-			fn (int $severity, string $message, string $file, int $line): bool =>
-				$this->exceptionErrorHandler($output, $severity, $message, $file, $line),
-			E_ALL
-		);
-	}
+    /**
+     * Initialises some useful tools for the Command
+     */
+    protected function initTools(OutputInterface $output): void {
+        // Start the timer
+        $this->execTime = -microtime(true);
+        // Convert PHP errors to exceptions
+        set_error_handler(
+            fn (int $severity, string $message, string $file, int $line): bool =>
+                $this->exceptionErrorHandler($output, $severity, $message, $file, $line),
+            E_ALL
+        );
+    }
 
-	/**
-	 * Processes PHP errors in order to be able to show them in the output
-	 *
-	 * @see https://www.php.net/manual/en/function.set-error-handler.php
-	 *
-	 * @param int $severity the level of the error raised
-	 * @param string $message
-	 * @param string $file the filename that the error was raised in
-	 * @param int $line the line number the error was raised
-	 */
-	public function exceptionErrorHandler(OutputInterface $output, int $severity, string $message, string $file, int $line): bool {
-		if (($severity === E_DEPRECATED) || ($severity === E_USER_DEPRECATED)) {
-			// Do not show deprecation warnings
-			return false;
-		}
-		$e = new \ErrorException($message, 0, $severity, $file, $line);
-		$output->writeln('<error>Error during scan: ' . $e->getMessage() . '</error>');
-		$output->writeln('<error>' . $e->getTraceAsString() . '</error>', OutputInterface::VERBOSITY_VERY_VERBOSE);
-		++$this->errorsCounter;
-		return true;
-	}
+    /**
+     * Processes PHP errors in order to be able to show them in the output
+     *
+     * @see https://www.php.net/manual/en/function.set-error-handler.php
+     *
+     * @param int $severity the level of the error raised
+     * @param string $message
+     * @param string $file the filename that the error was raised in
+     * @param int $line the line number the error was raised
+     */
+    public function exceptionErrorHandler(OutputInterface $output, int $severity, string $message, string $file, int $line): bool {
+        if (($severity === E_DEPRECATED) || ($severity === E_USER_DEPRECATED)) {
+            // Do not show deprecation warnings
+            return false;
+        }
+        $e = new \ErrorException($message, 0, $severity, $file, $line);
+        $output->writeln('<error>Error during scan: ' . $e->getMessage() . '</error>');
+        $output->writeln('<error>' . $e->getTraceAsString() . '</error>', OutputInterface::VERBOSITY_VERY_VERBOSE);
+        ++$this->errorsCounter;
+        return true;
+    }
 
-	protected function presentStats(OutputInterface $output): void {
-		// Stop the timer
-		$this->execTime += microtime(true);
+    protected function presentStats(OutputInterface $output): void {
+        // Stop the timer
+        $this->execTime += microtime(true);
 
-		$this->logger->info("Completed scan of {$this->filesCounter} files in {$this->foldersCounter} folder. Found {$this->newCounter} new, {$this->updatedCounter} updated and {$this->removedCounter} removed items");
+        $this->logger->info("Completed scan of {$this->filesCounter} files in {$this->foldersCounter} folder. Found {$this->newCounter} new, {$this->updatedCounter} updated and {$this->removedCounter} removed items");
 
-		$headers = [
-			'Folders',
-			'Files',
-			'New',
-			'Updated',
-			'Removed',
-			'Errors',
-			'Elapsed time',
-		];
-		$niceDate = $this->formatExecTime();
-		$rows = [
-			$this->foldersCounter,
-			$this->filesCounter,
-			$this->newCounter,
-			$this->updatedCounter,
-			$this->removedCounter,
-			$this->errorsCounter,
-			$niceDate,
-		];
-		$table = new Table($output);
-		$table
-			->setHeaders($headers)
-			->setRows([$rows]);
-		$table->render();
-	}
+        $headers = [
+            'Folders',
+            'Files',
+            'New',
+            'Updated',
+            'Removed',
+            'Errors',
+            'Elapsed time',
+        ];
+        $niceDate = $this->formatExecTime();
+        $rows = [
+            $this->foldersCounter,
+            $this->filesCounter,
+            $this->newCounter,
+            $this->updatedCounter,
+            $this->removedCounter,
+            $this->errorsCounter,
+            $niceDate,
+        ];
+        $table = new Table($output);
+        $table
+            ->setHeaders($headers)
+            ->setRows([$rows]);
+        $table->render();
+    }
 
 
-	/**
-	 * Formats microtime into a human-readable format
-	 */
-	protected function formatExecTime(): string {
-		$secs = (int)round($this->execTime);
-		# convert seconds into HH:MM:SS form
-		return sprintf('%02d:%02d:%02d', (int)($secs / 3600), ((int)($secs / 60) % 60), $secs % 60);
-	}
+    /**
+     * Formats microtime into a human-readable format
+     */
+    protected function formatExecTime(): string {
+        $secs = (int)round($this->execTime);
+        # convert seconds into HH:MM:SS form
+        return sprintf('%02d:%02d:%02d', (int)($secs / 3600), ((int)($secs / 60) % 60), $secs % 60);
+    }
 
-	protected function reconnectToDatabase(OutputInterface $output): Connection {
-		/** @var Connection $connection */
-		$connection = Server::get(Connection::class);
-		try {
-			$connection->close();
-		} catch (\Exception $ex) {
-			$output->writeln("<info>Error while disconnecting from database: {$ex->getMessage()}</info>");
-		}
-		while (!$connection->isConnected()) {
-			try {
-				$connection->connect();
-			} catch (\Exception $ex) {
-				$output->writeln("<info>Error while re-connecting to database: {$ex->getMessage()}</info>");
-				sleep(60);
-			}
-		}
-		return $connection;
-	}
+    protected function reconnectToDatabase(OutputInterface $output): Connection {
+        /** @var Connection $connection */
+        $connection = Server::get(Connection::class);
+        try {
+            $connection->close();
+        } catch (\Exception $ex) {
+            $output->writeln("<info>Error while disconnecting from database: {$ex->getMessage()}</info>");
+        }
+        while (!$connection->isConnected()) {
+            try {
+                $connection->connect();
+            } catch (\Exception $ex) {
+                $output->writeln("<info>Error while re-connecting to database: {$ex->getMessage()}</info>");
+                sleep(60);
+            }
+        }
+        return $connection;
+    }
 }

apps/files_external/lib/Command/Scan.php

Indentation +131 added lines, -131 removed lines

@@ -19,135 +19,135 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Scan extends StorageAuthBase {
-	protected float $execTime = 0;
-	protected int $foldersCounter = 0;
-	protected int $filesCounter = 0;
-
-	public function __construct(
-		GlobalStoragesService $globalService,
-		IUserManager $userManager,
-	) {
-		parent::__construct($globalService, $userManager);
-	}
-
-	protected function configure(): void {
-		$this
-			->setName('files_external:scan')
-			->setDescription('Scan an external storage for changed files')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'the mount id of the mount to scan'
-			)->addOption(
-				'user',
-				'u',
-				InputOption::VALUE_REQUIRED,
-				'The username for the remote mount (required only for some mount configuration that don\'t store credentials)'
-			)->addOption(
-				'password',
-				'p',
-				InputOption::VALUE_REQUIRED,
-				'The password for the remote mount (required only for some mount configuration that don\'t store credentials)'
-			)->addOption(
-				'path',
-				'',
-				InputOption::VALUE_OPTIONAL,
-				'The path in the storage to scan',
-				''
-			);
-		parent::configure();
-	}
-
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		[, $storage] = $this->createStorage($input, $output);
-		if ($storage === null) {
-			return 1;
-		}
-
-		$path = $input->getOption('path');
-
-		$this->execTime = -microtime(true);
-
-		/** @var Scanner $scanner */
-		$scanner = $storage->getScanner();
-
-		$scanner->listen('\OC\Files\Cache\Scanner', 'scanFile', function (string $path) use ($output): void {
-			$output->writeln("\tFile\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
-			++$this->filesCounter;
-			$this->abortIfInterrupted();
-		});
-
-		$scanner->listen('\OC\Files\Cache\Scanner', 'scanFolder', function (string $path) use ($output): void {
-			$output->writeln("\tFolder\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
-			++$this->foldersCounter;
-			$this->abortIfInterrupted();
-		});
-
-		try {
-			$scanner->scan($path);
-		} catch (LockedException $e) {
-			if (is_string($e->getReadablePath()) && str_starts_with($e->getReadablePath(), 'scanner::')) {
-				if ($e->getReadablePath() === 'scanner::') {
-					$output->writeln('<error>Another process is already scanning this storage</error>');
-				} else {
-					$output->writeln('<error>Another process is already scanning \'' . substr($e->getReadablePath(), strlen('scanner::')) . '\' in this storage</error>');
-				}
-			} else {
-				throw $e;
-			}
-		}
-
-		$this->presentStats($output);
-
-		return 0;
-	}
-
-	/**
-	 * @param OutputInterface $output
-	 */
-	protected function presentStats(OutputInterface $output): void {
-		// Stop the timer
-		$this->execTime += microtime(true);
-
-		$headers = [
-			'Folders', 'Files', 'Elapsed time'
-		];
-
-		$this->showSummary($headers, [], $output);
-	}
-
-	/**
-	 * Shows a summary of operations
-	 *
-	 * @param string[] $headers
-	 * @param string[] $rows
-	 * @param OutputInterface $output
-	 */
-	protected function showSummary(array $headers, array $rows, OutputInterface $output): void {
-		$niceDate = $this->formatExecTime();
-		if (!$rows) {
-			$rows = [
-				$this->foldersCounter,
-				$this->filesCounter,
-				$niceDate,
-			];
-		}
-		$table = new Table($output);
-		$table
-			->setHeaders($headers)
-			->setRows([$rows]);
-		$table->render();
-	}
-
-
-	/**
-	 * Formats microtime into a human readable format
-	 *
-	 * @return string
-	 */
-	protected function formatExecTime(): string {
-		$secs = round($this->execTime);
-		# convert seconds into HH:MM:SS form
-		return sprintf('%02d:%02d:%02d', ($secs / 3600), ($secs / 60 % 60), $secs % 60);
-	}
+    protected float $execTime = 0;
+    protected int $foldersCounter = 0;
+    protected int $filesCounter = 0;
+
+    public function __construct(
+        GlobalStoragesService $globalService,
+        IUserManager $userManager,
+    ) {
+        parent::__construct($globalService, $userManager);
+    }
+
+    protected function configure(): void {
+        $this
+            ->setName('files_external:scan')
+            ->setDescription('Scan an external storage for changed files')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'the mount id of the mount to scan'
+            )->addOption(
+                'user',
+                'u',
+                InputOption::VALUE_REQUIRED,
+                'The username for the remote mount (required only for some mount configuration that don\'t store credentials)'
+            )->addOption(
+                'password',
+                'p',
+                InputOption::VALUE_REQUIRED,
+                'The password for the remote mount (required only for some mount configuration that don\'t store credentials)'
+            )->addOption(
+                'path',
+                '',
+                InputOption::VALUE_OPTIONAL,
+                'The path in the storage to scan',
+                ''
+            );
+        parent::configure();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        [, $storage] = $this->createStorage($input, $output);
+        if ($storage === null) {
+            return 1;
+        }
+
+        $path = $input->getOption('path');
+
+        $this->execTime = -microtime(true);
+
+        /** @var Scanner $scanner */
+        $scanner = $storage->getScanner();
+
+        $scanner->listen('\OC\Files\Cache\Scanner', 'scanFile', function (string $path) use ($output): void {
+            $output->writeln("\tFile\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
+            ++$this->filesCounter;
+            $this->abortIfInterrupted();
+        });
+
+        $scanner->listen('\OC\Files\Cache\Scanner', 'scanFolder', function (string $path) use ($output): void {
+            $output->writeln("\tFolder\t<info>$path</info>", OutputInterface::VERBOSITY_VERBOSE);
+            ++$this->foldersCounter;
+            $this->abortIfInterrupted();
+        });
+
+        try {
+            $scanner->scan($path);
+        } catch (LockedException $e) {
+            if (is_string($e->getReadablePath()) && str_starts_with($e->getReadablePath(), 'scanner::')) {
+                if ($e->getReadablePath() === 'scanner::') {
+                    $output->writeln('<error>Another process is already scanning this storage</error>');
+                } else {
+                    $output->writeln('<error>Another process is already scanning \'' . substr($e->getReadablePath(), strlen('scanner::')) . '\' in this storage</error>');
+                }
+            } else {
+                throw $e;
+            }
+        }
+
+        $this->presentStats($output);
+
+        return 0;
+    }
+
+    /**
+     * @param OutputInterface $output
+     */
+    protected function presentStats(OutputInterface $output): void {
+        // Stop the timer
+        $this->execTime += microtime(true);
+
+        $headers = [
+            'Folders', 'Files', 'Elapsed time'
+        ];
+
+        $this->showSummary($headers, [], $output);
+    }
+
+    /**
+     * Shows a summary of operations
+     *
+     * @param string[] $headers
+     * @param string[] $rows
+     * @param OutputInterface $output
+     */
+    protected function showSummary(array $headers, array $rows, OutputInterface $output): void {
+        $niceDate = $this->formatExecTime();
+        if (!$rows) {
+            $rows = [
+                $this->foldersCounter,
+                $this->filesCounter,
+                $niceDate,
+            ];
+        }
+        $table = new Table($output);
+        $table
+            ->setHeaders($headers)
+            ->setRows([$rows]);
+        $table->render();
+    }
+
+
+    /**
+     * Formats microtime into a human readable format
+     *
+     * @return string
+     */
+    protected function formatExecTime(): string {
+        $secs = round($this->execTime);
+        # convert seconds into HH:MM:SS form
+        return sprintf('%02d:%02d:%02d', ($secs / 3600), ($secs / 60 % 60), $secs % 60);
+    }
 }