nextcloud / server

apps/dav/lib/Upload/ChunkingV2Plugin.php

Indentation +333 added lines, -333 removed lines

@@ -54,337 +54,337 @@
 use Sabre\Uri;
 
 class ChunkingV2Plugin extends ServerPlugin {
-	/** @var Server */
-	private $server;
-	/** @var UploadFolder */
-	private $uploadFolder;
-	/** @var ICache */
-	private $cache;
-
-	private ?string $uploadId = null;
-	private ?string $uploadPath = null;
-
-	private const TEMP_TARGET = '.target';
-
-	public const CACHE_KEY = 'chunking-v2';
-	public const UPLOAD_TARGET_PATH = 'upload-target-path';
-	public const UPLOAD_TARGET_ID = 'upload-target-id';
-	public const UPLOAD_ID = 'upload-id';
-
-	private const DESTINATION_HEADER = 'Destination';
-
-	public function __construct(ICacheFactory $cacheFactory) {
-		$this->cache = $cacheFactory->createDistributed(self::CACHE_KEY);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function initialize(Server $server) {
-		$server->on('afterMethod:MKCOL', [$this, 'afterMkcol']);
-		$server->on('beforeMethod:PUT', [$this, 'beforePut']);
-		$server->on('beforeMethod:DELETE', [$this, 'beforeDelete']);
-		$server->on('beforeMove', [$this, 'beforeMove'], 90);
-
-		$this->server = $server;
-	}
-
-	/**
-	 * @param string $path
-	 * @param bool $createIfNotExists
-	 * @return FutureFile|UploadFile|ICollection|INode
-	 */
-	private function getUploadFile(string $path, bool $createIfNotExists = false) {
-		try {
-			$actualFile = $this->server->tree->getNodeForPath($path);
-			// Only directly upload to the target file if it is on the same storage
-			// There may be further potential to optimize here by also uploading
-			// to other storages directly. This would require to also carefully pick
-			// the storage/path used in getStorage()
-			if ($actualFile instanceof File && $this->uploadFolder->getStorage()->getId() === $actualFile->getNode()->getStorage()->getId()) {
-				return $actualFile;
-			}
-		} catch (NotFound $e) {
-			// If there is no target file we upload to the upload folder first
-		}
-
-		// Use file in the upload directory that will be copied or moved afterwards
-		if ($createIfNotExists) {
-			$this->uploadFolder->createFile(self::TEMP_TARGET);
-		}
-
-		/** @var UploadFile $uploadFile */
-		$uploadFile = $this->uploadFolder->getChild(self::TEMP_TARGET);
-		return $uploadFile->getFile();
-	}
-
-	public function afterMkcol(RequestInterface $request, ResponseInterface $response): bool {
-		try {
-			$this->prepareUpload($request->getPath());
-			$this->checkPrerequisites(false);
-		} catch (BadRequest|StorageInvalidException|NotFound $e) {
-			return true;
-		}
-
-		$this->uploadPath = $this->server->calculateUri($this->server->httpRequest->getHeader(self::DESTINATION_HEADER));
-		$targetFile = $this->getUploadFile($this->uploadPath, true);
-		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
-
-		$this->uploadId = $storage->startChunkedWrite($storagePath);
-
-		$this->cache->set($this->uploadFolder->getName(), [
-			self::UPLOAD_ID => $this->uploadId,
-			self::UPLOAD_TARGET_PATH => $this->uploadPath,
-			self::UPLOAD_TARGET_ID => $targetFile->getId(),
-		], 86400);
-
-		$response->setStatus(201);
-		return true;
-	}
-
-	public function beforePut(RequestInterface $request, ResponseInterface $response): bool {
-		try {
-			$this->prepareUpload(dirname($request->getPath()));
-			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound $e) {
-			return true;
-		}
-
-		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
-
-		$chunkName = basename($request->getPath());
-		$partId = is_numeric($chunkName) ? (int)$chunkName : -1;
-		if (!($partId >= 1 && $partId <= 10000)) {
-			throw new BadRequest('Invalid chunk name, must be numeric between 1 and 10000');
-		}
-
-		$uploadFile = $this->getUploadFile($this->uploadPath);
-		$tempTargetFile = null;
-
-		$additionalSize = (int)$request->getHeader('Content-Length');
-		if ($this->uploadFolder->childExists(self::TEMP_TARGET) && $this->uploadPath) {
-			/** @var UploadFile $tempTargetFile */
-			$tempTargetFile = $this->uploadFolder->getChild(self::TEMP_TARGET);
-			[$destinationDir, $destinationName] = Uri\split($this->uploadPath);
-			/** @var Directory $destinationParent */
-			$destinationParent = $this->server->tree->getNodeForPath($destinationDir);
-			$free = $storage->free_space($destinationParent->getInternalPath());
-			$newSize = $tempTargetFile->getSize() + $additionalSize;
-			if ($free >= 0 && ($tempTargetFile->getSize() > $free || $newSize > $free)) {
-				throw new InsufficientStorage("Insufficient space in $this->uploadPath");
-			}
-		}
-
-		$stream = $request->getBodyAsStream();
-		$storage->putChunkedWritePart($storagePath, $this->uploadId, (string)$partId, $stream, $additionalSize);
-
-		$storage->getCache()->update($uploadFile->getId(), ['size' => $uploadFile->getSize() + $additionalSize]);
-		if ($tempTargetFile) {
-			$storage->getPropagator()->propagateChange($tempTargetFile->getInternalPath(), time(), $additionalSize);
-		}
-
-		$response->setStatus(201);
-		return false;
-	}
-
-	public function beforeMove($sourcePath, $destination): bool {
-		try {
-			$this->prepareUpload(dirname($sourcePath));
-			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound|PreconditionFailed $e) {
-			return true;
-		}
-		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
-
-		$targetFile = $this->getUploadFile($this->uploadPath);
-
-		[$destinationDir, $destinationName] = Uri\split($destination);
-		/** @var Directory $destinationParent */
-		$destinationParent = $this->server->tree->getNodeForPath($destinationDir);
-		$destinationExists = $destinationParent->childExists($destinationName);
-
-
-		// allow sync clients to send the modification and creation time along in a header
-		$updateFileInfo = [];
-		if ($this->server->httpRequest->getHeader('X-OC-MTime') !== null) {
-			$updateFileInfo['mtime'] = $this->sanitizeMtime($this->server->httpRequest->getHeader('X-OC-MTime'));
-			$this->server->httpResponse->setHeader('X-OC-MTime', 'accepted');
-		}
-		if ($this->server->httpRequest->getHeader('X-OC-CTime') !== null) {
-			$updateFileInfo['creation_time'] = $this->sanitizeMtime($this->server->httpRequest->getHeader('X-OC-CTime'));
-			$this->server->httpResponse->setHeader('X-OC-CTime', 'accepted');
-		}
-		$updateFileInfo['mimetype'] = \OCP\Server::get(IMimeTypeDetector::class)->detectPath($destinationName);
-
-		if ($storage->instanceOfStorage(ObjectStoreStorage::class) && $storage->getObjectStore() instanceof IObjectStoreMultiPartUpload) {
-			/** @var ObjectStoreStorage $storage */
-			/** @var IObjectStoreMultiPartUpload $objectStore */
-			$objectStore = $storage->getObjectStore();
-			$parts = $objectStore->getMultipartUploads($storage->getURN($targetFile->getId()), $this->uploadId);
-			$size = 0;
-			foreach ($parts as $part) {
-				$size += $part['Size'];
-			}
-			$free = $storage->free_space($destinationParent->getInternalPath());
-			if ($free >= 0 && ($size > $free)) {
-				throw new InsufficientStorage("Insufficient space in $this->uploadPath");
-			}
-		}
-
-		$destinationInView = $destinationParent->getFileInfo()->getPath() . '/' . $destinationName;
-		$this->completeChunkedWrite($destinationInView);
-
-		$rootView = new View();
-		$rootView->putFileInfo($destinationInView, $updateFileInfo);
-
-		$sourceNode = $this->server->tree->getNodeForPath($sourcePath);
-		if ($sourceNode instanceof FutureFile) {
-			$this->uploadFolder->delete();
-		}
-
-		$this->server->emit('afterMove', [$sourcePath, $destination]);
-		$this->server->emit('afterUnbind', [$sourcePath]);
-		$this->server->emit('afterBind', [$destination]);
-
-		$response = $this->server->httpResponse;
-		$response->setHeader('Content-Type', 'application/xml; charset=utf-8');
-		$response->setHeader('Content-Length', '0');
-		$response->setStatus($destinationExists ? 204 : 201);
-		return false;
-	}
-
-	public function beforeDelete(RequestInterface $request, ResponseInterface $response) {
-		try {
-			$this->prepareUpload(dirname($request->getPath()));
-			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound $e) {
-			return true;
-		}
-
-		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
-		$storage->cancelChunkedWrite($storagePath, $this->uploadId);
-		return true;
-	}
-
-	/**
-	 * @throws BadRequest
-	 * @throws PreconditionFailed
-	 * @throws StorageInvalidException
-	 */
-	private function checkPrerequisites(bool $checkUploadMetadata = true): void {
-		if (!$this->uploadFolder instanceof UploadFolder || empty($this->server->httpRequest->getHeader(self::DESTINATION_HEADER))) {
-			throw new BadRequest('Skipping chunked file writing as the destination header was not passed');
-		}
-		if (!$this->uploadFolder->getStorage()->instanceOfStorage(IChunkedFileWrite::class)) {
-			throw new StorageInvalidException('Storage does not support chunked file writing');
-		}
-
-		if ($checkUploadMetadata) {
-			if ($this->uploadId === null || $this->uploadPath === null) {
-				throw new PreconditionFailed('Missing metadata for chunked upload');
-			}
-		}
-	}
-
-	/**
-	 * @return array [IStorage, string]
-	 */
-	private function getUploadStorage(string $targetPath): array {
-		$storage = $this->uploadFolder->getStorage();
-		$targetFile = $this->getUploadFile($targetPath);
-		return [$storage, $targetFile->getInternalPath()];
-	}
-
-	protected function sanitizeMtime(string $mtimeFromRequest): int {
-		if (!is_numeric($mtimeFromRequest)) {
-			throw new InvalidArgumentException('X-OC-MTime header must be an integer (unix timestamp).');
-		}
-
-		return (int)$mtimeFromRequest;
-	}
-
-	/**
-	 * @throws NotFound
-	 */
-	public function prepareUpload($path): void {
-		$this->uploadFolder = $this->server->tree->getNodeForPath($path);
-		$uploadMetadata = $this->cache->get($this->uploadFolder->getName());
-		$this->uploadId = $uploadMetadata[self::UPLOAD_ID] ?? null;
-		$this->uploadPath = $uploadMetadata[self::UPLOAD_TARGET_PATH] ?? null;
-	}
-
-	private function completeChunkedWrite(string $targetAbsolutePath): void {
-		$uploadFile = $this->getUploadFile($this->uploadPath)->getNode();
-		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
-
-		$rootFolder = \OCP\Server::get(IRootFolder::class);
-		$exists = $rootFolder->nodeExists($targetAbsolutePath);
-
-		$uploadFile->lock(ILockingProvider::LOCK_SHARED);
-		$this->emitPreHooks($targetAbsolutePath, $exists);
-		try {
-			$uploadFile->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
-			$storage->completeChunkedWrite($storagePath, $this->uploadId);
-			$uploadFile->changeLock(ILockingProvider::LOCK_SHARED);
-		} catch (Exception $e) {
-			$uploadFile->unlock(ILockingProvider::LOCK_EXCLUSIVE);
-			throw $e;
-		}
-
-		// If the file was not uploaded to the user storage directly we need to copy/move it
-		try {
-			$uploadFileAbsolutePath = Filesystem::getRoot() . $uploadFile->getPath();
-			if ($uploadFileAbsolutePath !== $targetAbsolutePath) {
-				$uploadFile = $rootFolder->get($uploadFile->getFileInfo()->getPath());
-				if ($exists) {
-					$uploadFile->copy($targetAbsolutePath);
-				} else {
-					$uploadFile->move($targetAbsolutePath);
-				}
-			}
-			$this->emitPostHooks($targetAbsolutePath, $exists);
-		} catch (Exception $e) {
-			$uploadFile->unlock(ILockingProvider::LOCK_SHARED);
-			throw $e;
-		}
-	}
-
-	private function emitPreHooks(string $target, bool $exists): void {
-		$hookPath = $this->getHookPath($target);
-		if (!$exists) {
-			OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
-				Filesystem::signal_param_path => $hookPath,
-			]);
-		} else {
-			OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
-				Filesystem::signal_param_path => $hookPath,
-			]);
-		}
-		OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
-			Filesystem::signal_param_path => $hookPath,
-		]);
-	}
-
-	private function emitPostHooks(string $target, bool $exists): void {
-		$hookPath = $this->getHookPath($target);
-		if (!$exists) {
-			OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
-				Filesystem::signal_param_path => $hookPath,
-			]);
-		} else {
-			OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
-				Filesystem::signal_param_path => $hookPath,
-			]);
-		}
-		OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
-			Filesystem::signal_param_path => $hookPath,
-		]);
-	}
-
-	private function getHookPath(string $path): ?string {
-		if (!Filesystem::getView()) {
-			return $path;
-		}
-		return Filesystem::getView()->getRelativePath($path);
-	}
+    /** @var Server */
+    private $server;
+    /** @var UploadFolder */
+    private $uploadFolder;
+    /** @var ICache */
+    private $cache;
+
+    private ?string $uploadId = null;
+    private ?string $uploadPath = null;
+
+    private const TEMP_TARGET = '.target';
+
+    public const CACHE_KEY = 'chunking-v2';
+    public const UPLOAD_TARGET_PATH = 'upload-target-path';
+    public const UPLOAD_TARGET_ID = 'upload-target-id';
+    public const UPLOAD_ID = 'upload-id';
+
+    private const DESTINATION_HEADER = 'Destination';
+
+    public function __construct(ICacheFactory $cacheFactory) {
+        $this->cache = $cacheFactory->createDistributed(self::CACHE_KEY);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function initialize(Server $server) {
+        $server->on('afterMethod:MKCOL', [$this, 'afterMkcol']);
+        $server->on('beforeMethod:PUT', [$this, 'beforePut']);
+        $server->on('beforeMethod:DELETE', [$this, 'beforeDelete']);
+        $server->on('beforeMove', [$this, 'beforeMove'], 90);
+
+        $this->server = $server;
+    }
+
+    /**
+     * @param string $path
+     * @param bool $createIfNotExists
+     * @return FutureFile|UploadFile|ICollection|INode
+     */
+    private function getUploadFile(string $path, bool $createIfNotExists = false) {
+        try {
+            $actualFile = $this->server->tree->getNodeForPath($path);
+            // Only directly upload to the target file if it is on the same storage
+            // There may be further potential to optimize here by also uploading
+            // to other storages directly. This would require to also carefully pick
+            // the storage/path used in getStorage()
+            if ($actualFile instanceof File && $this->uploadFolder->getStorage()->getId() === $actualFile->getNode()->getStorage()->getId()) {
+                return $actualFile;
+            }
+        } catch (NotFound $e) {
+            // If there is no target file we upload to the upload folder first
+        }
+
+        // Use file in the upload directory that will be copied or moved afterwards
+        if ($createIfNotExists) {
+            $this->uploadFolder->createFile(self::TEMP_TARGET);
+        }
+
+        /** @var UploadFile $uploadFile */
+        $uploadFile = $this->uploadFolder->getChild(self::TEMP_TARGET);
+        return $uploadFile->getFile();
+    }
+
+    public function afterMkcol(RequestInterface $request, ResponseInterface $response): bool {
+        try {
+            $this->prepareUpload($request->getPath());
+            $this->checkPrerequisites(false);
+        } catch (BadRequest|StorageInvalidException|NotFound $e) {
+            return true;
+        }
+
+        $this->uploadPath = $this->server->calculateUri($this->server->httpRequest->getHeader(self::DESTINATION_HEADER));
+        $targetFile = $this->getUploadFile($this->uploadPath, true);
+        [$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
+
+        $this->uploadId = $storage->startChunkedWrite($storagePath);
+
+        $this->cache->set($this->uploadFolder->getName(), [
+            self::UPLOAD_ID => $this->uploadId,
+            self::UPLOAD_TARGET_PATH => $this->uploadPath,
+            self::UPLOAD_TARGET_ID => $targetFile->getId(),
+        ], 86400);
+
+        $response->setStatus(201);
+        return true;
+    }
+
+    public function beforePut(RequestInterface $request, ResponseInterface $response): bool {
+        try {
+            $this->prepareUpload(dirname($request->getPath()));
+            $this->checkPrerequisites();
+        } catch (StorageInvalidException|BadRequest|NotFound $e) {
+            return true;
+        }
+
+        [$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
+
+        $chunkName = basename($request->getPath());
+        $partId = is_numeric($chunkName) ? (int)$chunkName : -1;
+        if (!($partId >= 1 && $partId <= 10000)) {
+            throw new BadRequest('Invalid chunk name, must be numeric between 1 and 10000');
+        }
+
+        $uploadFile = $this->getUploadFile($this->uploadPath);
+        $tempTargetFile = null;
+
+        $additionalSize = (int)$request->getHeader('Content-Length');
+        if ($this->uploadFolder->childExists(self::TEMP_TARGET) && $this->uploadPath) {
+            /** @var UploadFile $tempTargetFile */
+            $tempTargetFile = $this->uploadFolder->getChild(self::TEMP_TARGET);
+            [$destinationDir, $destinationName] = Uri\split($this->uploadPath);
+            /** @var Directory $destinationParent */
+            $destinationParent = $this->server->tree->getNodeForPath($destinationDir);
+            $free = $storage->free_space($destinationParent->getInternalPath());
+            $newSize = $tempTargetFile->getSize() + $additionalSize;
+            if ($free >= 0 && ($tempTargetFile->getSize() > $free || $newSize > $free)) {
+                throw new InsufficientStorage("Insufficient space in $this->uploadPath");
+            }
+        }
+
+        $stream = $request->getBodyAsStream();
+        $storage->putChunkedWritePart($storagePath, $this->uploadId, (string)$partId, $stream, $additionalSize);
+
+        $storage->getCache()->update($uploadFile->getId(), ['size' => $uploadFile->getSize() + $additionalSize]);
+        if ($tempTargetFile) {
+            $storage->getPropagator()->propagateChange($tempTargetFile->getInternalPath(), time(), $additionalSize);
+        }
+
+        $response->setStatus(201);
+        return false;
+    }
+
+    public function beforeMove($sourcePath, $destination): bool {
+        try {
+            $this->prepareUpload(dirname($sourcePath));
+            $this->checkPrerequisites();
+        } catch (StorageInvalidException|BadRequest|NotFound|PreconditionFailed $e) {
+            return true;
+        }
+        [$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
+
+        $targetFile = $this->getUploadFile($this->uploadPath);
+
+        [$destinationDir, $destinationName] = Uri\split($destination);
+        /** @var Directory $destinationParent */
+        $destinationParent = $this->server->tree->getNodeForPath($destinationDir);
+        $destinationExists = $destinationParent->childExists($destinationName);
+
+
+        // allow sync clients to send the modification and creation time along in a header
+        $updateFileInfo = [];
+        if ($this->server->httpRequest->getHeader('X-OC-MTime') !== null) {
+            $updateFileInfo['mtime'] = $this->sanitizeMtime($this->server->httpRequest->getHeader('X-OC-MTime'));
+            $this->server->httpResponse->setHeader('X-OC-MTime', 'accepted');
+        }
+        if ($this->server->httpRequest->getHeader('X-OC-CTime') !== null) {
+            $updateFileInfo['creation_time'] = $this->sanitizeMtime($this->server->httpRequest->getHeader('X-OC-CTime'));
+            $this->server->httpResponse->setHeader('X-OC-CTime', 'accepted');
+        }
+        $updateFileInfo['mimetype'] = \OCP\Server::get(IMimeTypeDetector::class)->detectPath($destinationName);
+
+        if ($storage->instanceOfStorage(ObjectStoreStorage::class) && $storage->getObjectStore() instanceof IObjectStoreMultiPartUpload) {
+            /** @var ObjectStoreStorage $storage */
+            /** @var IObjectStoreMultiPartUpload $objectStore */
+            $objectStore = $storage->getObjectStore();
+            $parts = $objectStore->getMultipartUploads($storage->getURN($targetFile->getId()), $this->uploadId);
+            $size = 0;
+            foreach ($parts as $part) {
+                $size += $part['Size'];
+            }
+            $free = $storage->free_space($destinationParent->getInternalPath());
+            if ($free >= 0 && ($size > $free)) {
+                throw new InsufficientStorage("Insufficient space in $this->uploadPath");
+            }
+        }
+
+        $destinationInView = $destinationParent->getFileInfo()->getPath() . '/' . $destinationName;
+        $this->completeChunkedWrite($destinationInView);
+
+        $rootView = new View();
+        $rootView->putFileInfo($destinationInView, $updateFileInfo);
+
+        $sourceNode = $this->server->tree->getNodeForPath($sourcePath);
+        if ($sourceNode instanceof FutureFile) {
+            $this->uploadFolder->delete();
+        }
+
+        $this->server->emit('afterMove', [$sourcePath, $destination]);
+        $this->server->emit('afterUnbind', [$sourcePath]);
+        $this->server->emit('afterBind', [$destination]);
+
+        $response = $this->server->httpResponse;
+        $response->setHeader('Content-Type', 'application/xml; charset=utf-8');
+        $response->setHeader('Content-Length', '0');
+        $response->setStatus($destinationExists ? 204 : 201);
+        return false;
+    }
+
+    public function beforeDelete(RequestInterface $request, ResponseInterface $response) {
+        try {
+            $this->prepareUpload(dirname($request->getPath()));
+            $this->checkPrerequisites();
+        } catch (StorageInvalidException|BadRequest|NotFound $e) {
+            return true;
+        }
+
+        [$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
+        $storage->cancelChunkedWrite($storagePath, $this->uploadId);
+        return true;
+    }
+
+    /**
+     * @throws BadRequest
+     * @throws PreconditionFailed
+     * @throws StorageInvalidException
+     */
+    private function checkPrerequisites(bool $checkUploadMetadata = true): void {
+        if (!$this->uploadFolder instanceof UploadFolder || empty($this->server->httpRequest->getHeader(self::DESTINATION_HEADER))) {
+            throw new BadRequest('Skipping chunked file writing as the destination header was not passed');
+        }
+        if (!$this->uploadFolder->getStorage()->instanceOfStorage(IChunkedFileWrite::class)) {
+            throw new StorageInvalidException('Storage does not support chunked file writing');
+        }
+
+        if ($checkUploadMetadata) {
+            if ($this->uploadId === null || $this->uploadPath === null) {
+                throw new PreconditionFailed('Missing metadata for chunked upload');
+            }
+        }
+    }
+
+    /**
+     * @return array [IStorage, string]
+     */
+    private function getUploadStorage(string $targetPath): array {
+        $storage = $this->uploadFolder->getStorage();
+        $targetFile = $this->getUploadFile($targetPath);
+        return [$storage, $targetFile->getInternalPath()];
+    }
+
+    protected function sanitizeMtime(string $mtimeFromRequest): int {
+        if (!is_numeric($mtimeFromRequest)) {
+            throw new InvalidArgumentException('X-OC-MTime header must be an integer (unix timestamp).');
+        }
+
+        return (int)$mtimeFromRequest;
+    }
+
+    /**
+     * @throws NotFound
+     */
+    public function prepareUpload($path): void {
+        $this->uploadFolder = $this->server->tree->getNodeForPath($path);
+        $uploadMetadata = $this->cache->get($this->uploadFolder->getName());
+        $this->uploadId = $uploadMetadata[self::UPLOAD_ID] ?? null;
+        $this->uploadPath = $uploadMetadata[self::UPLOAD_TARGET_PATH] ?? null;
+    }
+
+    private function completeChunkedWrite(string $targetAbsolutePath): void {
+        $uploadFile = $this->getUploadFile($this->uploadPath)->getNode();
+        [$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
+
+        $rootFolder = \OCP\Server::get(IRootFolder::class);
+        $exists = $rootFolder->nodeExists($targetAbsolutePath);
+
+        $uploadFile->lock(ILockingProvider::LOCK_SHARED);
+        $this->emitPreHooks($targetAbsolutePath, $exists);
+        try {
+            $uploadFile->changeLock(ILockingProvider::LOCK_EXCLUSIVE);
+            $storage->completeChunkedWrite($storagePath, $this->uploadId);
+            $uploadFile->changeLock(ILockingProvider::LOCK_SHARED);
+        } catch (Exception $e) {
+            $uploadFile->unlock(ILockingProvider::LOCK_EXCLUSIVE);
+            throw $e;
+        }
+
+        // If the file was not uploaded to the user storage directly we need to copy/move it
+        try {
+            $uploadFileAbsolutePath = Filesystem::getRoot() . $uploadFile->getPath();
+            if ($uploadFileAbsolutePath !== $targetAbsolutePath) {
+                $uploadFile = $rootFolder->get($uploadFile->getFileInfo()->getPath());
+                if ($exists) {
+                    $uploadFile->copy($targetAbsolutePath);
+                } else {
+                    $uploadFile->move($targetAbsolutePath);
+                }
+            }
+            $this->emitPostHooks($targetAbsolutePath, $exists);
+        } catch (Exception $e) {
+            $uploadFile->unlock(ILockingProvider::LOCK_SHARED);
+            throw $e;
+        }
+    }
+
+    private function emitPreHooks(string $target, bool $exists): void {
+        $hookPath = $this->getHookPath($target);
+        if (!$exists) {
+            OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
+                Filesystem::signal_param_path => $hookPath,
+            ]);
+        } else {
+            OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
+                Filesystem::signal_param_path => $hookPath,
+            ]);
+        }
+        OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
+            Filesystem::signal_param_path => $hookPath,
+        ]);
+    }
+
+    private function emitPostHooks(string $target, bool $exists): void {
+        $hookPath = $this->getHookPath($target);
+        if (!$exists) {
+            OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
+                Filesystem::signal_param_path => $hookPath,
+            ]);
+        } else {
+            OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
+                Filesystem::signal_param_path => $hookPath,
+            ]);
+        }
+        OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
+            Filesystem::signal_param_path => $hookPath,
+        ]);
+    }
+
+    private function getHookPath(string $path): ?string {
+        if (!Filesystem::getView()) {
+            return $path;
+        }
+        return Filesystem::getView()->getRelativePath($path);
+    }
 }

Spacing +10 added lines, -10 removed lines

@@ -122,7 +122,7 @@ 
 		try {
 			$this->prepareUpload($request->getPath());
 			$this->checkPrerequisites(false);
-		} catch (BadRequest|StorageInvalidException|NotFound $e) {
+		} catch (BadRequest | StorageInvalidException | NotFound $e) {
 			return true;
 		}
 
@@ -146,14 +146,14 @@ 
 		try {
 			$this->prepareUpload(dirname($request->getPath()));
 			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound $e) {
+		} catch (StorageInvalidException | BadRequest | NotFound $e) {
 			return true;
 		}
 
 		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
 
 		$chunkName = basename($request->getPath());
-		$partId = is_numeric($chunkName) ? (int)$chunkName : -1;
+		$partId = is_numeric($chunkName) ? (int) $chunkName : -1;
 		if (!($partId >= 1 && $partId <= 10000)) {
 			throw new BadRequest('Invalid chunk name, must be numeric between 1 and 10000');
 		}
@@ -161,7 +161,7 @@ 
 		$uploadFile = $this->getUploadFile($this->uploadPath);
 		$tempTargetFile = null;
 
-		$additionalSize = (int)$request->getHeader('Content-Length');
+		$additionalSize = (int) $request->getHeader('Content-Length');
 		if ($this->uploadFolder->childExists(self::TEMP_TARGET) && $this->uploadPath) {
 			/** @var UploadFile $tempTargetFile */
 			$tempTargetFile = $this->uploadFolder->getChild(self::TEMP_TARGET);
@@ -176,7 +176,7 @@ 
 		}
 
 		$stream = $request->getBodyAsStream();
-		$storage->putChunkedWritePart($storagePath, $this->uploadId, (string)$partId, $stream, $additionalSize);
+		$storage->putChunkedWritePart($storagePath, $this->uploadId, (string) $partId, $stream, $additionalSize);
 
 		$storage->getCache()->update($uploadFile->getId(), ['size' => $uploadFile->getSize() + $additionalSize]);
 		if ($tempTargetFile) {
@@ -191,7 +191,7 @@ 
 		try {
 			$this->prepareUpload(dirname($sourcePath));
 			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound|PreconditionFailed $e) {
+		} catch (StorageInvalidException | BadRequest | NotFound | PreconditionFailed $e) {
 			return true;
 		}
 		[$storage, $storagePath] = $this->getUploadStorage($this->uploadPath);
@@ -231,7 +231,7 @@ 
 			}
 		}
 
-		$destinationInView = $destinationParent->getFileInfo()->getPath() . '/' . $destinationName;
+		$destinationInView = $destinationParent->getFileInfo()->getPath().'/'.$destinationName;
 		$this->completeChunkedWrite($destinationInView);
 
 		$rootView = new View();
@@ -257,7 +257,7 @@ 
 		try {
 			$this->prepareUpload(dirname($request->getPath()));
 			$this->checkPrerequisites();
-		} catch (StorageInvalidException|BadRequest|NotFound $e) {
+		} catch (StorageInvalidException | BadRequest | NotFound $e) {
 			return true;
 		}
 
@@ -300,7 +300,7 @@ 
 			throw new InvalidArgumentException('X-OC-MTime header must be an integer (unix timestamp).');
 		}
 
-		return (int)$mtimeFromRequest;
+		return (int) $mtimeFromRequest;
 	}
 
 	/**
@@ -333,7 +333,7 @@ 
 
 		// If the file was not uploaded to the user storage directly we need to copy/move it
 		try {
-			$uploadFileAbsolutePath = Filesystem::getRoot() . $uploadFile->getPath();
+			$uploadFileAbsolutePath = Filesystem::getRoot().$uploadFile->getPath();
 			if ($uploadFileAbsolutePath !== $targetAbsolutePath) {
 				$uploadFile = $rootFolder->get($uploadFile->getFileInfo()->getPath());
 				if ($exists) {