migrate therinaldos.com data

wedding-pics/apps/dav/lib/Upload/AssemblyStream.php

@@ -0,0 +1,304 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author J0WI <J0WI@users.noreply.github.com>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Markus Goetz <markus@woboq.com>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Vincent Petry <vincent@nextcloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use Sabre\DAV\IFile;
+
+/**
+ * Class AssemblyStream
+ *
+ * The assembly stream is a virtual stream that wraps multiple chunks.
+ * Reading from the stream transparently accessed the underlying chunks and
+ * give a representation as if they were already merged together.
+ *
+ * @package OCA\DAV\Upload
+ */
+class AssemblyStream implements \Icewind\Streams\File {
+
+	/** @var resource */
+	private $context;
+
+	/** @var IFile[] */
+	private $nodes;
+
+	/** @var int */
+	private $pos = 0;
+
+	/** @var int */
+	private $size = 0;
+
+	/** @var resource */
+	private $currentStream = null;
+
+	/** @var int */
+	private $currentNode = 0;
+
+	/** @var int */
+	private $currentNodeRead = 0;
+
+	/**
+	 * @param string $path
+	 * @param string $mode
+	 * @param int $options
+	 * @param string &$opened_path
+	 * @return bool
+	 */
+	public function stream_open($path, $mode, $options, &$opened_path) {
+		$this->loadContext('assembly');
+
+		$nodes = $this->nodes;
+		usort($nodes, function (IFile $a, IFile $b) {
+			return strnatcmp($a->getName(), $b->getName());
+		});
+		$this->nodes = array_values($nodes);
+		$this->size = array_reduce($this->nodes, function ($size, IFile $file) {
+			return $size + $file->getSize();
+		}, 0);
+
+		return true;
+	}
+
+	/**
+	 * @param int $offset
+	 * @param int $whence
+	 * @return bool
+	 */
+	public function stream_seek($offset, $whence = SEEK_SET) {
+		if ($whence === SEEK_CUR) {
+			$offset = $this->stream_tell() + $offset;
+		} elseif ($whence === SEEK_END) {
+			$offset = $this->size + $offset;
+		}
+
+		if ($offset > $this->size) {
+			return false;
+		}
+
+		$nodeIndex = 0;
+		$nodeStart = 0;
+		while (true) {
+			if (!isset($this->nodes[$nodeIndex + 1])) {
+				break;
+			}
+			$node = $this->nodes[$nodeIndex];
+			if ($nodeStart + $node->getSize() > $offset) {
+				break;
+			}
+			$nodeIndex++;
+			$nodeStart += $node->getSize();
+		}
+
+		$stream = $this->getStream($this->nodes[$nodeIndex]);
+		$nodeOffset = $offset - $nodeStart;
+		if (fseek($stream, $nodeOffset) === -1) {
+			return false;
+		}
+		$this->currentNode = $nodeIndex;
+		$this->currentNodeRead = $nodeOffset;
+		$this->currentStream = $stream;
+		$this->pos = $offset;
+
+		return true;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function stream_tell() {
+		return $this->pos;
+	}
+
+	/**
+	 * @param int $count
+	 * @return string
+	 */
+	public function stream_read($count) {
+		if (is_null($this->currentStream)) {
+			if ($this->currentNode < count($this->nodes)) {
+				$this->currentStream = $this->getStream($this->nodes[$this->currentNode]);
+			} else {
+				return '';
+			}
+		}
+
+		do {
+			$data = fread($this->currentStream, $count);
+			$read = strlen($data);
+			$this->currentNodeRead += $read;
+
+			if (feof($this->currentStream)) {
+				fclose($this->currentStream);
+				$currentNodeSize = $this->nodes[$this->currentNode]->getSize();
+				if ($this->currentNodeRead < $currentNodeSize) {
+					throw new \Exception('Stream from assembly node shorter than expected, got ' . $this->currentNodeRead . ' bytes, expected ' . $currentNodeSize);
+				}
+				$this->currentNode++;
+				$this->currentNodeRead = 0;
+				if ($this->currentNode < count($this->nodes)) {
+					$this->currentStream = $this->getStream($this->nodes[$this->currentNode]);
+				} else {
+					$this->currentStream = null;
+				}
+			}
+			// if no data read, try again with the next node because
+			// returning empty data can make the caller think there is no more
+			// data left to read
+		} while ($read === 0 && !is_null($this->currentStream));
+
+		// update position
+		$this->pos += $read;
+		return $data;
+	}
+
+	/**
+	 * @param string $data
+	 * @return int
+	 */
+	public function stream_write($data) {
+		return false;
+	}
+
+	/**
+	 * @param int $option
+	 * @param int $arg1
+	 * @param int $arg2
+	 * @return bool
+	 */
+	public function stream_set_option($option, $arg1, $arg2) {
+		return false;
+	}
+
+	/**
+	 * @param int $size
+	 * @return bool
+	 */
+	public function stream_truncate($size) {
+		return false;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function stream_stat() {
+		return [
+			'size' => $this->size,
+		];
+	}
+
+	/**
+	 * @param int $operation
+	 * @return bool
+	 */
+	public function stream_lock($operation) {
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function stream_flush() {
+		return false;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function stream_eof() {
+		return $this->pos >= $this->size || ($this->currentNode >= count($this->nodes) && $this->currentNode === null);
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function stream_close() {
+		return true;
+	}
+
+
+	/**
+	 * Load the source from the stream context and return the context options
+	 *
+	 * @param string $name
+	 * @return array
+	 * @throws \BadMethodCallException
+	 */
+	protected function loadContext($name) {
+		$context = stream_context_get_options($this->context);
+		if (isset($context[$name])) {
+			$context = $context[$name];
+		} else {
+			throw new \BadMethodCallException('Invalid context, "' . $name . '" options not set');
+		}
+		if (isset($context['nodes']) and is_array($context['nodes'])) {
+			$this->nodes = $context['nodes'];
+		} else {
+			throw new \BadMethodCallException('Invalid context, nodes not set');
+		}
+		return $context;
+	}
+
+	/**
+	 * @param IFile[] $nodes
+	 * @return resource
+	 *
+	 * @throws \BadMethodCallException
+	 */
+	public static function wrap(array $nodes) {
+		$context = stream_context_create([
+			'assembly' => [
+				'nodes' => $nodes
+			]
+		]);
+		stream_wrapper_register('assembly', self::class);
+		try {
+			$wrapped = fopen('assembly://', 'r', false, $context);
+		} catch (\BadMethodCallException $e) {
+			stream_wrapper_unregister('assembly');
+			throw $e;
+		}
+		stream_wrapper_unregister('assembly');
+		return $wrapped;
+	}
+
+	/**
+	 * @param IFile $node
+	 * @return resource
+	 */
+	private function getStream(IFile $node) {
+		$data = $node->get();
+		if (is_resource($data)) {
+			return $data;
+		} else {
+			$tmp = fopen('php://temp', 'w+');
+			fwrite($tmp, $data);
+			rewind($tmp);
+			return $tmp;
+		}
+	}
+}

wedding-pics/apps/dav/lib/Upload/ChunkingPlugin.php

@@ -0,0 +1,131 @@
+<?php
+/**
+ * @copyright Copyright (c) 2017, ownCloud GmbH
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Daniel Kesselberg <mail@danielkesselberg.de>
+ * @author Julius Härtl <jus@bitgrid.net>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\Exception\Forbidden;
+use Sabre\DAV\Exception\BadRequest;
+use Sabre\DAV\Exception\NotFound;
+use Sabre\DAV\INode;
+use Sabre\DAV\Server;
+use Sabre\DAV\ServerPlugin;
+
+class ChunkingPlugin extends ServerPlugin {
+
+	/** @var Server */
+	private $server;
+	/** @var FutureFile */
+	private $sourceNode;
+
+	/**
+	 * @inheritdoc
+	 */
+	public function initialize(Server $server) {
+		$server->on('beforeMove', [$this, 'beforeMove']);
+		$this->server = $server;
+	}
+
+	/**
+	 * @param string $sourcePath source path
+	 * @param string $destination destination path
+	 * @return bool|void
+	 * @throws BadRequest
+	 * @throws NotFound
+	 */
+	public function beforeMove($sourcePath, $destination) {
+		$this->sourceNode = $this->server->tree->getNodeForPath($sourcePath);
+		if (!$this->sourceNode instanceof FutureFile) {
+			// skip handling as the source is not a chunked FutureFile
+			return;
+		}
+
+		try {
+			/** @var INode $destinationNode */
+			$destinationNode = $this->server->tree->getNodeForPath($destination);
+			if ($destinationNode instanceof Directory) {
+				throw new BadRequest("The given destination $destination is a directory.");
+			}
+		} catch (NotFound $e) {
+			// If the destination does not exist yet it's not a directory either ;)
+		}
+
+		$this->verifySize();
+		return $this->performMove($sourcePath, $destination);
+	}
+
+	/**
+	 * Move handler for future file.
+	 *
+	 * This overrides the default move behavior to prevent Sabre
+	 * to delete the target file before moving. Because deleting would
+	 * lose the file id and metadata.
+	 *
+	 * @param string $path source path
+	 * @param string $destination destination path
+	 * @return bool|void false to stop handling, void to skip this handler
+	 */
+	public function performMove($path, $destination) {
+		$fileExists = $this->server->tree->nodeExists($destination);
+		// do a move manually, skipping Sabre's default "delete" for existing nodes
+		try {
+			$this->server->tree->move($path, $destination);
+		} catch (Forbidden $e) {
+			$sourceNode = $this->server->tree->getNodeForPath($path);
+			if ($sourceNode instanceof FutureFile) {
+				$sourceNode->delete();
+			}
+			throw $e;
+		}
+
+		// trigger all default events (copied from CorePlugin::move)
+		$this->server->emit('afterMove', [$path, $destination]);
+		$this->server->emit('afterUnbind', [$path]);
+		$this->server->emit('afterBind', [$destination]);
+
+		$response = $this->server->httpResponse;
+		$response->setHeader('Content-Length', '0');
+		$response->setStatus($fileExists ? 204 : 201);
+
+		return false;
+	}
+
+	/**
+	 * @throws BadRequest
+	 */
+	private function verifySize() {
+		$expectedSize = $this->server->httpRequest->getHeader('OC-Total-Length');
+		if ($expectedSize === null) {
+			return;
+		}
+		$actualSize = $this->sourceNode->getSize();
+
+		// casted to string because cast to float cause equality for non equal numbers
+		// and integer has the problem of limited size on 32 bit systems
+		if ((string)$expectedSize !== (string)$actualSize) {
+			throw new BadRequest("Chunks on server do not sum up to $expectedSize but to $actualSize bytes");
+		}
+	}
+}

wedding-pics/apps/dav/lib/Upload/ChunkingV2Plugin.php

@@ -0,0 +1,401 @@
+<?php
+
+declare(strict_types=1);
+/*
+ * @copyright Copyright (c) 2021 Julius Härtl <jus@bitgrid.net>
+ *
+ * @author Julius Härtl <jus@bitgrid.net>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OCA\DAV\Upload;
+
+use Exception;
+use InvalidArgumentException;
+use OC\Files\Filesystem;
+use OC\Files\ObjectStore\ObjectStoreStorage;
+use OC\Files\View;
+use OC\Memcache\Memcached;
+use OC\Memcache\Redis;
+use OC_Hook;
+use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\File;
+use OCP\Files\IMimeTypeDetector;
+use OCP\Files\IRootFolder;
+use OCP\Files\ObjectStore\IObjectStoreMultiPartUpload;
+use OCP\Files\Storage\IChunkedFileWrite;
+use OCP\Files\StorageInvalidException;
+use OCP\ICache;
+use OCP\ICacheFactory;
+use OCP\IConfig;
+use OCP\Lock\ILockingProvider;
+use Sabre\DAV\Exception\BadRequest;
+use Sabre\DAV\Exception\InsufficientStorage;
+use Sabre\DAV\Exception\NotFound;
+use Sabre\DAV\Exception\PreconditionFailed;
+use Sabre\DAV\ICollection;
+use Sabre\DAV\INode;
+use Sabre\DAV\Server;
+use Sabre\DAV\ServerPlugin;
+use Sabre\HTTP\RequestInterface;
+use Sabre\HTTP\ResponseInterface;
+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 = $destinationParent->getNode()->getFreeSpace();
+			$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 = $destinationParent->getNode()->getFreeSpace();
+			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 {
+		$distributedCacheConfig = \OCP\Server::get(IConfig::class)->getSystemValue('memcache.distributed', null);
+
+		if ($distributedCacheConfig === null || (!$this->cache instanceof Redis && !$this->cache instanceof Memcached)) {
+			throw new BadRequest('Skipping chunking v2 since no proper distributed cache is available');
+		}
+		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 ($this->uploadFolder->getStorage()->instanceOfStorage(ObjectStoreStorage::class) && !$this->uploadFolder->getStorage()->getObjectStore() instanceof IObjectStoreMultiPartUpload) {
+			throw new StorageInvalidException('Storage does not support multi part uploads');
+		}
+
+		if ($checkUploadMetadata) {
+			if ($this->uploadId === null || $this->uploadPath === null) {
+				throw new PreconditionFailed('Missing metadata for chunked upload. The distributed cache does not hold the information of previous requests.');
+			}
+		}
+	}
+
+	/**
+	 * @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);
+	}
+}

wedding-pics/apps/dav/lib/Upload/CleanupService.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2018, Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OCA\DAV\BackgroundJob\UploadCleanup;
+use OCP\BackgroundJob\IJobList;
+use OCP\IUserSession;
+
+class CleanupService {
+	/** @var IUserSession */
+	private $userSession;
+	/** @var IJobList */
+	private $jobList;
+
+	public function __construct(IUserSession $userSession, IJobList $jobList) {
+		$this->userSession = $userSession;
+		$this->jobList = $jobList;
+	}
+
+	public function addJob(string $folder) {
+		$this->jobList->add(UploadCleanup::class, ['uid' => $this->userSession->getUser()->getUID(), 'folder' => $folder]);
+	}
+
+	public function removeJob(string $folder) {
+		$this->jobList->remove(UploadCleanup::class, ['uid' => $this->userSession->getUser()->getUID(), 'folder' => $folder]);
+	}
+}

wedding-pics/apps/dav/lib/Upload/FutureFile.php

@@ -0,0 +1,126 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OCA\DAV\Connector\Sabre\Directory;
+use Sabre\DAV\Exception\Forbidden;
+use Sabre\DAV\IFile;
+
+/**
+ * Class FutureFile
+ *
+ * The FutureFile is a SabreDav IFile which connects the chunked upload directory
+ * with the AssemblyStream, who does the final assembly job
+ *
+ * @package OCA\DAV\Upload
+ */
+class FutureFile implements \Sabre\DAV\IFile {
+	/** @var Directory */
+	private $root;
+	/** @var string */
+	private $name;
+
+	/**
+	 * @param Directory $root
+	 * @param string $name
+	 */
+	public function __construct(Directory $root, $name) {
+		$this->root = $root;
+		$this->name = $name;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function put($data) {
+		throw new Forbidden('Permission denied to put into this file');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function get() {
+		$nodes = $this->root->getChildren();
+		return AssemblyStream::wrap($nodes);
+	}
+
+	public function getPath() {
+		return $this->root->getFileInfo()->getInternalPath() . '/.file';
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getContentType() {
+		return 'application/octet-stream';
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getETag() {
+		return $this->root->getETag();
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getSize() {
+		$children = $this->root->getChildren();
+		$sizes = array_map(function ($node) {
+			/** @var IFile $node */
+			return $node->getSize();
+		}, $children);
+
+		return array_sum($sizes);
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function delete() {
+		$this->root->delete();
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getName() {
+		return $this->name;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function setName($name) {
+		throw new Forbidden('Permission denied to rename this file');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getLastModified() {
+		return $this->root->getLastModified();
+	}
+}

wedding-pics/apps/dav/lib/Upload/PartFile.php

@@ -0,0 +1,111 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OCA\DAV\Connector\Sabre\Directory;
+use Sabre\DAV\Exception\Forbidden;
+use Sabre\DAV\IFile;
+
+/**
+ * This class represents an Upload part which is not present on the storage itself
+ * but handled directly by external storage services like S3 with Multipart Upload
+ */
+class PartFile implements IFile {
+	/** @var Directory */
+	private $root;
+	/** @var array */
+	private $partInfo;
+
+	public function __construct(Directory $root, array $partInfo) {
+		$this->root = $root;
+		$this->partInfo = $partInfo;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function put($data) {
+		throw new Forbidden('Permission denied to put into this file');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function get() {
+		throw new Forbidden('Permission denied to get this file');
+	}
+
+	public function getPath() {
+		return $this->root->getFileInfo()->getInternalPath() . '/' . $this->partInfo['PartNumber'];
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getContentType() {
+		return 'application/octet-stream';
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getETag() {
+		return $this->partInfo['ETag'];
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getSize() {
+		return $this->partInfo['Size'];
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function delete() {
+		$this->root->delete();
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getName() {
+		return $this->partInfo['PartNumber'];
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function setName($name) {
+		throw new Forbidden('Permission denied to rename this file');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getLastModified() {
+		return $this->partInfo['LastModified'];
+	}
+}

wedding-pics/apps/dav/lib/Upload/RootCollection.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use Sabre\DAVACL\AbstractPrincipalCollection;
+use Sabre\DAVACL\PrincipalBackend;
+
+class RootCollection extends AbstractPrincipalCollection {
+
+	/** @var CleanupService */
+	private $cleanupService;
+
+	public function __construct(PrincipalBackend\BackendInterface $principalBackend,
+		string $principalPrefix,
+		CleanupService $cleanupService) {
+		parent::__construct($principalBackend, $principalPrefix);
+		$this->cleanupService = $cleanupService;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getChildForPrincipal(array $principalInfo): UploadHome {
+		return new UploadHome($principalInfo, $this->cleanupService);
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getName(): string {
+		return 'uploads';
+	}
+}

wedding-pics/apps/dav/lib/Upload/UploadFile.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2020, Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OCA\DAV\Connector\Sabre\File;
+use Sabre\DAV\IFile;
+
+class UploadFile implements IFile {
+	/**  @var File */
+	private $file;
+
+	public function __construct(File $file) {
+		$this->file = $file;
+	}
+
+	public function put($data) {
+		return $this->file->put($data);
+	}
+
+	public function get() {
+		return $this->file->get();
+	}
+
+	public function getId() {
+		return $this->file->getId();
+	}
+
+	public function getContentType() {
+		return $this->file->getContentType();
+	}
+
+	public function getETag() {
+		return $this->file->getETag();
+	}
+
+	/**
+	 * @psalm-suppress ImplementedReturnTypeMismatch \Sabre\DAV\IFile::getSize signature does not support 32bit
+	 * @return int|float
+	 */
+	public function getSize() {
+		return $this->file->getSize();
+	}
+
+	public function delete() {
+		$this->file->delete();
+	}
+
+	public function getName() {
+		return $this->file->getName();
+	}
+
+	public function setName($name) {
+		$this->file->setName($name);
+	}
+
+	public function getLastModified() {
+		return $this->file->getLastModified();
+	}
+
+	public function getInternalPath(): string {
+		return $this->file->getInternalPath();
+	}
+
+	public function getFile(): File {
+		return $this->file;
+	}
+
+	public function getNode() {
+		return $this->file->getNode();
+	}
+}

wedding-pics/apps/dav/lib/Upload/UploadFolder.php

@@ -0,0 +1,131 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OC\Files\ObjectStore\ObjectStoreStorage;
+use OCA\DAV\Connector\Sabre\Directory;
+use OCP\Files\ObjectStore\IObjectStoreMultiPartUpload;
+use OCP\Files\Storage\IStorage;
+use Sabre\DAV\Exception\Forbidden;
+use Sabre\DAV\ICollection;
+
+class UploadFolder implements ICollection {
+	/** @var Directory */
+	private $node;
+	/** @var CleanupService */
+	private $cleanupService;
+	/** @var IStorage */
+	private $storage;
+
+	public function __construct(Directory $node, CleanupService $cleanupService, IStorage $storage) {
+		$this->node = $node;
+		$this->cleanupService = $cleanupService;
+		$this->storage = $storage;
+	}
+
+	public function createFile($name, $data = null) {
+		// TODO: verify name - should be a simple number
+		try {
+			$this->node->createFile($name, $data);
+		} catch (\Exception $e) {
+			if ($this->node->childExists($name)) {
+				$child = $this->node->getChild($name);
+				$child->delete();
+			}
+			throw $e;
+		}
+	}
+
+	public function createDirectory($name) {
+		throw new Forbidden('Permission denied to create file (filename ' . $name . ')');
+	}
+
+	public function getChild($name) {
+		if ($name === '.file') {
+			return new FutureFile($this->node, '.file');
+		}
+		return new UploadFile($this->node->getChild($name));
+	}
+
+	public function getChildren() {
+		$tmpChildren = $this->node->getChildren();
+
+		$children = [];
+		$children[] = new FutureFile($this->node, '.file');
+
+		foreach ($tmpChildren as $child) {
+			$children[] = new UploadFile($child);
+		}
+
+		if ($this->storage->instanceOfStorage(ObjectStoreStorage::class)) {
+			/** @var ObjectStoreStorage $storage */
+			$objectStore = $this->storage->getObjectStore();
+			if ($objectStore instanceof IObjectStoreMultiPartUpload) {
+				$cache = \OC::$server->getMemCacheFactory()->createDistributed(ChunkingV2Plugin::CACHE_KEY);
+				$uploadSession = $cache->get($this->getName());
+				if ($uploadSession) {
+					$uploadId = $uploadSession[ChunkingV2Plugin::UPLOAD_ID];
+					$id = $uploadSession[ChunkingV2Plugin::UPLOAD_TARGET_ID];
+					$parts = $objectStore->getMultipartUploads($this->storage->getURN($id), $uploadId);
+					foreach ($parts as $part) {
+						$children[] = new PartFile($this->node, $part);
+					}
+				}
+			}
+		}
+
+		return $children;
+	}
+
+	public function childExists($name) {
+		if ($name === '.file') {
+			return true;
+		}
+		return $this->node->childExists($name);
+	}
+
+	public function delete() {
+		$this->node->delete();
+
+		// Background cleanup job is not needed anymore
+		$this->cleanupService->removeJob($this->getName());
+	}
+
+	public function getName() {
+		return $this->node->getName();
+	}
+
+	public function setName($name) {
+		throw new Forbidden('Permission denied to rename this folder');
+	}
+
+	public function getLastModified() {
+		return $this->node->getLastModified();
+	}
+
+	public function getStorage() {
+		return $this->storage;
+	}
+}

wedding-pics/apps/dav/lib/Upload/UploadHome.php

@@ -0,0 +1,111 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OCA\DAV\Upload;
+
+use OC\Files\Filesystem;
+use OC\Files\View;
+use OCA\DAV\Connector\Sabre\Directory;
+use Sabre\DAV\Exception\Forbidden;
+use Sabre\DAV\ICollection;
+
+class UploadHome implements ICollection {
+	/** @var array */
+	private $principalInfo;
+	/** @var CleanupService */
+	private $cleanupService;
+
+	public function __construct(array $principalInfo, CleanupService $cleanupService) {
+		$this->principalInfo = $principalInfo;
+		$this->cleanupService = $cleanupService;
+	}
+
+	public function createFile($name, $data = null) {
+		throw new Forbidden('Permission denied to create file (filename ' . $name . ')');
+	}
+
+	public function createDirectory($name) {
+		$this->impl()->createDirectory($name);
+
+		// Add a cleanup job
+		$this->cleanupService->addJob($name);
+	}
+
+	public function getChild($name): UploadFolder {
+		return new UploadFolder($this->impl()->getChild($name), $this->cleanupService, $this->getStorage());
+	}
+
+	public function getChildren(): array {
+		return array_map(function ($node) {
+			return new UploadFolder($node, $this->cleanupService, $this->getStorage());
+		}, $this->impl()->getChildren());
+	}
+
+	public function childExists($name): bool {
+		return !is_null($this->getChild($name));
+	}
+
+	public function delete() {
+		$this->impl()->delete();
+	}
+
+	public function getName() {
+		[,$name] = \Sabre\Uri\split($this->principalInfo['uri']);
+		return $name;
+	}
+
+	public function setName($name) {
+		throw new Forbidden('Permission denied to rename this folder');
+	}
+
+	public function getLastModified() {
+		return $this->impl()->getLastModified();
+	}
+
+	/**
+	 * @return Directory
+	 */
+	private function impl() {
+		$view = $this->getView();
+		$rootInfo = $view->getFileInfo('');
+		return new Directory($view, $rootInfo);
+	}
+
+	private function getView() {
+		$rootView = new View();
+		$user = \OC::$server->getUserSession()->getUser();
+		Filesystem::initMountPoints($user->getUID());
+		if (!$rootView->file_exists('/' . $user->getUID() . '/uploads')) {
+			$rootView->mkdir('/' . $user->getUID() . '/uploads');
+		}
+		return new View('/' . $user->getUID() . '/uploads');
+	}
+
+	private function getStorage() {
+		$view = $this->getView();
+		$storage = $view->getFileInfo('')->getStorage();
+		return $storage;
+	}
+}