nextcloud / server

lib/private/Files/Cache/HomePropagator.php

Indentation +21 added lines, -21 removed lines

@@ -25,28 +25,28 @@
 use OCP\IDBConnection;
 
 class HomePropagator extends Propagator {
-	private $ignoredBaseFolders;
+    private $ignoredBaseFolders;
 
-	/**
-	 * @param \OC\Files\Storage\Storage $storage
-	 */
-	public function __construct(\OC\Files\Storage\Storage $storage, IDBConnection $connection) {
-		parent::__construct($storage, $connection);
-		$this->ignoredBaseFolders = ['files_encryption'];
-	}
+    /**
+     * @param \OC\Files\Storage\Storage $storage
+     */
+    public function __construct(\OC\Files\Storage\Storage $storage, IDBConnection $connection) {
+        parent::__construct($storage, $connection);
+        $this->ignoredBaseFolders = ['files_encryption'];
+    }
 
 
-	/**
-	 * @param string $internalPath
-	 * @param int $time
-	 * @param int $sizeDifference number of bytes the file has grown
-	 */
-	public function propagateChange($internalPath, $time, $sizeDifference = 0) {
-		list($baseFolder) = explode('/', $internalPath, 2);
-		if (in_array($baseFolder, $this->ignoredBaseFolders)) {
-			return [];
-		} else {
-			parent::propagateChange($internalPath, $time, $sizeDifference);
-		}
-	}
+    /**
+     * @param string $internalPath
+     * @param int $time
+     * @param int $sizeDifference number of bytes the file has grown
+     */
+    public function propagateChange($internalPath, $time, $sizeDifference = 0) {
+        list($baseFolder) = explode('/', $internalPath, 2);
+        if (in_array($baseFolder, $this->ignoredBaseFolders)) {
+            return [];
+        } else {
+            parent::propagateChange($internalPath, $time, $sizeDifference);
+        }
+    }
 }

lib/private/Files/Cache/Updater.php

Indentation +212 added lines, -212 removed lines

@@ -36,216 +36,216 @@
  *
  */
 class Updater implements IUpdater {
-	/**
-	 * @var bool
-	 */
-	protected $enabled = true;
-
-	/**
-	 * @var \OC\Files\Storage\Storage
-	 */
-	protected $storage;
-
-	/**
-	 * @var \OC\Files\Cache\Propagator
-	 */
-	protected $propagator;
-
-	/**
-	 * @var Scanner
-	 */
-	protected $scanner;
-
-	/**
-	 * @var Cache
-	 */
-	protected $cache;
-
-	/**
-	 * @param \OC\Files\Storage\Storage $storage
-	 */
-	public function __construct(\OC\Files\Storage\Storage $storage) {
-		$this->storage = $storage;
-		$this->propagator = $storage->getPropagator();
-		$this->scanner = $storage->getScanner();
-		$this->cache = $storage->getCache();
-	}
-
-	/**
-	 * Disable updating the cache trough this updater
-	 */
-	public function disable() {
-		$this->enabled = false;
-	}
-
-	/**
-	 * Re-enable the updating of the cache trough this updater
-	 */
-	public function enable() {
-		$this->enabled = true;
-	}
-
-	/**
-	 * Get the propagator for etags and mtime for the view the updater works on
-	 *
-	 * @return Propagator
-	 */
-	public function getPropagator() {
-		return $this->propagator;
-	}
-
-	/**
-	 * Propagate etag and mtime changes for the parent folders of $path up to the root of the filesystem
-	 *
-	 * @param string $path the path of the file to propagate the changes for
-	 * @param int|null $time the timestamp to set as mtime for the parent folders, if left out the current time is used
-	 */
-	public function propagate($path, $time = null) {
-		if (Scanner::isPartialFile($path)) {
-			return;
-		}
-		$this->propagator->propagateChange($path, $time);
-	}
-
-	/**
-	 * Update the cache for $path and update the size, etag and mtime of the parent folders
-	 *
-	 * @param string $path
-	 * @param int $time
-	 */
-	public function update($path, $time = null) {
-		if (!$this->enabled or Scanner::isPartialFile($path)) {
-			return;
-		}
-		if (is_null($time)) {
-			$time = time();
-		}
-
-		$data = $this->scanner->scan($path, Scanner::SCAN_SHALLOW, -1, false);
-		if (
-			isset($data['oldSize']) && isset($data['size']) &&
-			!$data['encrypted'] // encryption is a pita and touches the cache itself
-		) {
-			$sizeDifference = $data['size'] - $data['oldSize'];
-		} else {
-			// scanner didn't provide size info, fallback to full size calculation
-			$sizeDifference = 0;
-			if ($this->cache instanceof Cache) {
-				$this->cache->correctFolderSize($path, $data);
-			}
-		}
-		$this->correctParentStorageMtime($path);
-		$this->propagator->propagateChange($path, $time, $sizeDifference);
-	}
-
-	/**
-	 * Remove $path from the cache and update the size, etag and mtime of the parent folders
-	 *
-	 * @param string $path
-	 */
-	public function remove($path) {
-		if (!$this->enabled or Scanner::isPartialFile($path)) {
-			return;
-		}
-
-		$parent = dirname($path);
-		if ($parent === '.') {
-			$parent = '';
-		}
-
-		$entry = $this->cache->get($path);
-
-		$this->cache->remove($path);
-
-		$this->correctParentStorageMtime($path);
-		if ($entry instanceof ICacheEntry) {
-			$this->propagator->propagateChange($path, time(), -$entry->getSize());
-		} else {
-			$this->propagator->propagateChange($path, time());
-			if ($this->cache instanceof Cache) {
-				$this->cache->correctFolderSize($parent);
-			}
-		}
-
-	}
-
-	/**
-	 * Rename a file or folder in the cache and update the size, etag and mtime of the parent folders
-	 *
-	 * @param IStorage $sourceStorage
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function renameFromStorage(IStorage $sourceStorage, $source, $target) {
-		if (!$this->enabled or Scanner::isPartialFile($source) or Scanner::isPartialFile($target)) {
-			return;
-		}
-
-		$time = time();
-
-		$sourceCache = $sourceStorage->getCache();
-		$sourceUpdater = $sourceStorage->getUpdater();
-		$sourcePropagator = $sourceStorage->getPropagator();
-
-		if ($sourceCache->inCache($source)) {
-			if ($this->cache->inCache($target)) {
-				$this->cache->remove($target);
-			}
-
-			if ($sourceStorage === $this->storage) {
-				$this->cache->move($source, $target);
-			} else {
-				$this->cache->moveFromCache($sourceCache, $source, $target);
-			}
-		}
-
-		if (pathinfo($source, PATHINFO_EXTENSION) !== pathinfo($target, PATHINFO_EXTENSION)) {
-			// handle mime type change
-			$mimeType = $this->storage->getMimeType($target);
-			$fileId = $this->cache->getId($target);
-			$this->cache->update($fileId, ['mimetype' => $mimeType]);
-		}
-
-		if ($sourceCache instanceof Cache) {
-			$sourceCache->correctFolderSize($source);
-		}
-		if ($this->cache instanceof Cache) {
-			$this->cache->correctFolderSize($target);
-		}
-		if ($sourceUpdater instanceof Updater) {
-			$sourceUpdater->correctParentStorageMtime($source);
-		}
-		$this->correctParentStorageMtime($target);
-		$this->updateStorageMTimeOnly($target);
-		$sourcePropagator->propagateChange($source, $time);
-		$this->propagator->propagateChange($target, $time);
-	}
-
-	private function updateStorageMTimeOnly($internalPath) {
-		$fileId = $this->cache->getId($internalPath);
-		if ($fileId !== -1) {
-			$this->cache->update(
-				$fileId, [
-					'mtime' => null, // this magic tells it to not overwrite mtime
-					'storage_mtime' => $this->storage->filemtime($internalPath)
-				]
-			);
-		}
-	}
-
-	/**
-	 * update the storage_mtime of the direct parent in the cache to the mtime from the storage
-	 *
-	 * @param string $internalPath
-	 */
-	private function correctParentStorageMtime($internalPath) {
-		$parentId = $this->cache->getParentId($internalPath);
-		$parent = dirname($internalPath);
-		if ($parentId != -1) {
-			$mtime = $this->storage->filemtime($parent);
-			if ($mtime !== false) {
-				$this->cache->update($parentId, array('storage_mtime' => $mtime));
-			}
-		}
-	}
+    /**
+     * @var bool
+     */
+    protected $enabled = true;
+
+    /**
+     * @var \OC\Files\Storage\Storage
+     */
+    protected $storage;
+
+    /**
+     * @var \OC\Files\Cache\Propagator
+     */
+    protected $propagator;
+
+    /**
+     * @var Scanner
+     */
+    protected $scanner;
+
+    /**
+     * @var Cache
+     */
+    protected $cache;
+
+    /**
+     * @param \OC\Files\Storage\Storage $storage
+     */
+    public function __construct(\OC\Files\Storage\Storage $storage) {
+        $this->storage = $storage;
+        $this->propagator = $storage->getPropagator();
+        $this->scanner = $storage->getScanner();
+        $this->cache = $storage->getCache();
+    }
+
+    /**
+     * Disable updating the cache trough this updater
+     */
+    public function disable() {
+        $this->enabled = false;
+    }
+
+    /**
+     * Re-enable the updating of the cache trough this updater
+     */
+    public function enable() {
+        $this->enabled = true;
+    }
+
+    /**
+     * Get the propagator for etags and mtime for the view the updater works on
+     *
+     * @return Propagator
+     */
+    public function getPropagator() {
+        return $this->propagator;
+    }
+
+    /**
+     * Propagate etag and mtime changes for the parent folders of $path up to the root of the filesystem
+     *
+     * @param string $path the path of the file to propagate the changes for
+     * @param int|null $time the timestamp to set as mtime for the parent folders, if left out the current time is used
+     */
+    public function propagate($path, $time = null) {
+        if (Scanner::isPartialFile($path)) {
+            return;
+        }
+        $this->propagator->propagateChange($path, $time);
+    }
+
+    /**
+     * Update the cache for $path and update the size, etag and mtime of the parent folders
+     *
+     * @param string $path
+     * @param int $time
+     */
+    public function update($path, $time = null) {
+        if (!$this->enabled or Scanner::isPartialFile($path)) {
+            return;
+        }
+        if (is_null($time)) {
+            $time = time();
+        }
+
+        $data = $this->scanner->scan($path, Scanner::SCAN_SHALLOW, -1, false);
+        if (
+            isset($data['oldSize']) && isset($data['size']) &&
+            !$data['encrypted'] // encryption is a pita and touches the cache itself
+        ) {
+            $sizeDifference = $data['size'] - $data['oldSize'];
+        } else {
+            // scanner didn't provide size info, fallback to full size calculation
+            $sizeDifference = 0;
+            if ($this->cache instanceof Cache) {
+                $this->cache->correctFolderSize($path, $data);
+            }
+        }
+        $this->correctParentStorageMtime($path);
+        $this->propagator->propagateChange($path, $time, $sizeDifference);
+    }
+
+    /**
+     * Remove $path from the cache and update the size, etag and mtime of the parent folders
+     *
+     * @param string $path
+     */
+    public function remove($path) {
+        if (!$this->enabled or Scanner::isPartialFile($path)) {
+            return;
+        }
+
+        $parent = dirname($path);
+        if ($parent === '.') {
+            $parent = '';
+        }
+
+        $entry = $this->cache->get($path);
+
+        $this->cache->remove($path);
+
+        $this->correctParentStorageMtime($path);
+        if ($entry instanceof ICacheEntry) {
+            $this->propagator->propagateChange($path, time(), -$entry->getSize());
+        } else {
+            $this->propagator->propagateChange($path, time());
+            if ($this->cache instanceof Cache) {
+                $this->cache->correctFolderSize($parent);
+            }
+        }
+
+    }
+
+    /**
+     * Rename a file or folder in the cache and update the size, etag and mtime of the parent folders
+     *
+     * @param IStorage $sourceStorage
+     * @param string $source
+     * @param string $target
+     */
+    public function renameFromStorage(IStorage $sourceStorage, $source, $target) {
+        if (!$this->enabled or Scanner::isPartialFile($source) or Scanner::isPartialFile($target)) {
+            return;
+        }
+
+        $time = time();
+
+        $sourceCache = $sourceStorage->getCache();
+        $sourceUpdater = $sourceStorage->getUpdater();
+        $sourcePropagator = $sourceStorage->getPropagator();
+
+        if ($sourceCache->inCache($source)) {
+            if ($this->cache->inCache($target)) {
+                $this->cache->remove($target);
+            }
+
+            if ($sourceStorage === $this->storage) {
+                $this->cache->move($source, $target);
+            } else {
+                $this->cache->moveFromCache($sourceCache, $source, $target);
+            }
+        }
+
+        if (pathinfo($source, PATHINFO_EXTENSION) !== pathinfo($target, PATHINFO_EXTENSION)) {
+            // handle mime type change
+            $mimeType = $this->storage->getMimeType($target);
+            $fileId = $this->cache->getId($target);
+            $this->cache->update($fileId, ['mimetype' => $mimeType]);
+        }
+
+        if ($sourceCache instanceof Cache) {
+            $sourceCache->correctFolderSize($source);
+        }
+        if ($this->cache instanceof Cache) {
+            $this->cache->correctFolderSize($target);
+        }
+        if ($sourceUpdater instanceof Updater) {
+            $sourceUpdater->correctParentStorageMtime($source);
+        }
+        $this->correctParentStorageMtime($target);
+        $this->updateStorageMTimeOnly($target);
+        $sourcePropagator->propagateChange($source, $time);
+        $this->propagator->propagateChange($target, $time);
+    }
+
+    private function updateStorageMTimeOnly($internalPath) {
+        $fileId = $this->cache->getId($internalPath);
+        if ($fileId !== -1) {
+            $this->cache->update(
+                $fileId, [
+                    'mtime' => null, // this magic tells it to not overwrite mtime
+                    'storage_mtime' => $this->storage->filemtime($internalPath)
+                ]
+            );
+        }
+    }
+
+    /**
+     * update the storage_mtime of the direct parent in the cache to the mtime from the storage
+     *
+     * @param string $internalPath
+     */
+    private function correctParentStorageMtime($internalPath) {
+        $parentId = $this->cache->getParentId($internalPath);
+        $parent = dirname($internalPath);
+        if ($parentId != -1) {
+            $mtime = $this->storage->filemtime($parent);
+            if ($mtime !== false) {
+                $this->cache->update($parentId, array('storage_mtime' => $mtime));
+            }
+        }
+    }
 }

lib/private/Files/Cache/CacheEntry.php

Indentation +62 added lines, -62 removed lines

@@ -28,88 +28,88 @@
  * meta data for a file or folder
  */
 class CacheEntry implements ICacheEntry, \ArrayAccess {
-	/**
-	 * @var array
-	 */
-	private $data;
+    /**
+     * @var array
+     */
+    private $data;
 
-	public function __construct(array $data) {
-		$this->data = $data;
-	}
+    public function __construct(array $data) {
+        $this->data = $data;
+    }
 
-	public function offsetSet($offset, $value) {
-		$this->data[$offset] = $value;
-	}
+    public function offsetSet($offset, $value) {
+        $this->data[$offset] = $value;
+    }
 
-	public function offsetExists($offset) {
-		return isset($this->data[$offset]);
-	}
+    public function offsetExists($offset) {
+        return isset($this->data[$offset]);
+    }
 
-	public function offsetUnset($offset) {
-		unset($this->data[$offset]);
-	}
+    public function offsetUnset($offset) {
+        unset($this->data[$offset]);
+    }
 
-	public function offsetGet($offset) {
-		if (isset($this->data[$offset])) {
-			return $this->data[$offset];
-		} else {
-			return null;
-		}
-	}
+    public function offsetGet($offset) {
+        if (isset($this->data[$offset])) {
+            return $this->data[$offset];
+        } else {
+            return null;
+        }
+    }
 
-	public function getId() {
-		return (int)$this->data['fileid'];
-	}
+    public function getId() {
+        return (int)$this->data['fileid'];
+    }
 
-	public function getStorageId() {
-		return $this->data['storage'];
-	}
+    public function getStorageId() {
+        return $this->data['storage'];
+    }
 
 
-	public function getPath() {
-		return $this->data['path'];
-	}
+    public function getPath() {
+        return $this->data['path'];
+    }
 
 
-	public function getName() {
-		return $this->data['name'];
-	}
+    public function getName() {
+        return $this->data['name'];
+    }
 
 
-	public function getMimeType() {
-		return $this->data['mimetype'];
-	}
+    public function getMimeType() {
+        return $this->data['mimetype'];
+    }
 
 
-	public function getMimePart() {
-		return $this->data['mimepart'];
-	}
+    public function getMimePart() {
+        return $this->data['mimepart'];
+    }
 
-	public function getSize() {
-		return $this->data['size'];
-	}
+    public function getSize() {
+        return $this->data['size'];
+    }
 
-	public function getMTime() {
-		return $this->data['mtime'];
-	}
+    public function getMTime() {
+        return $this->data['mtime'];
+    }
 
-	public function getStorageMTime() {
-		return $this->data['storage_mtime'];
-	}
+    public function getStorageMTime() {
+        return $this->data['storage_mtime'];
+    }
 
-	public function getEtag() {
-		return $this->data['etag'];
-	}
+    public function getEtag() {
+        return $this->data['etag'];
+    }
 
-	public function getPermissions() {
-		return $this->data['permissions'];
-	}
+    public function getPermissions() {
+        return $this->data['permissions'];
+    }
 
-	public function isEncrypted() {
-		return isset($this->data['encrypted']) && $this->data['encrypted'];
-	}
+    public function isEncrypted() {
+        return isset($this->data['encrypted']) && $this->data['encrypted'];
+    }
 
-	public function getData() {
-		return $this->data;
-	}
+    public function getData() {
+        return $this->data;
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
 	}
 
 	public function getId() {
-		return (int)$this->data['fileid'];
+		return (int) $this->data['fileid'];
 	}
 
 	public function getStorageId() {

lib/private/Files/Cache/HomeCache.php

Indentation +51 added lines, -51 removed lines

@@ -30,58 +30,58 @@
 use OCP\Files\Cache\ICacheEntry;
 
 class HomeCache extends Cache {
-	/**
-	 * get the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array $entry (optional) meta data of the folder
-	 * @return int
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		if ($path !== '/' and $path !== '' and $path !== 'files' and $path !== 'files_trashbin' and $path !== 'files_versions') {
-			return parent::calculateFolderSize($path, $entry);
-		} elseif ($path === '' or $path === '/') {
-			// since the size of / isn't used (the size of /files is used instead) there is no use in calculating it
-			return 0;
-		}
+    /**
+     * get the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array $entry (optional) meta data of the folder
+     * @return int
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        if ($path !== '/' and $path !== '' and $path !== 'files' and $path !== 'files_trashbin' and $path !== 'files_versions') {
+            return parent::calculateFolderSize($path, $entry);
+        } elseif ($path === '' or $path === '/') {
+            // since the size of / isn't used (the size of /files is used instead) there is no use in calculating it
+            return 0;
+        }
 
-		$totalSize = 0;
-		if (is_null($entry)) {
-			$entry = $this->get($path);
-		}
-		if ($entry && $entry['mimetype'] === 'httpd/unix-directory') {
-			$id = $entry['fileid'];
-			$sql = 'SELECT SUM(`size`) AS f1 ' .
-			   'FROM `*PREFIX*filecache` ' .
-				'WHERE `parent` = ? AND `storage` = ? AND `size` >= 0';
-			$result = \OC_DB::executeAudited($sql, array($id, $this->getNumericStorageId()));
-			if ($row = $result->fetchRow()) {
-				$result->closeCursor();
-				list($sum) = array_values($row);
-				$totalSize = 0 + $sum;
-				$entry['size'] += 0;
-				if ($entry['size'] !== $totalSize) {
-					$this->update($id, array('size' => $totalSize));
-				}
-			}
-		}
-		return $totalSize;
-	}
+        $totalSize = 0;
+        if (is_null($entry)) {
+            $entry = $this->get($path);
+        }
+        if ($entry && $entry['mimetype'] === 'httpd/unix-directory') {
+            $id = $entry['fileid'];
+            $sql = 'SELECT SUM(`size`) AS f1 ' .
+                'FROM `*PREFIX*filecache` ' .
+                'WHERE `parent` = ? AND `storage` = ? AND `size` >= 0';
+            $result = \OC_DB::executeAudited($sql, array($id, $this->getNumericStorageId()));
+            if ($row = $result->fetchRow()) {
+                $result->closeCursor();
+                list($sum) = array_values($row);
+                $totalSize = 0 + $sum;
+                $entry['size'] += 0;
+                if ($entry['size'] !== $totalSize) {
+                    $this->update($id, array('size' => $totalSize));
+                }
+            }
+        }
+        return $totalSize;
+    }
 
-	/**
-	 * @param string $path
-	 * @return ICacheEntry
-	 */
-	public function get($path) {
-		$data = parent::get($path);
-		if ($path === '' or $path === '/') {
-			// only the size of the "files" dir counts
-			$filesData = parent::get('files');
+    /**
+     * @param string $path
+     * @return ICacheEntry
+     */
+    public function get($path) {
+        $data = parent::get($path);
+        if ($path === '' or $path === '/') {
+            // only the size of the "files" dir counts
+            $filesData = parent::get('files');
 
-			if (isset($filesData['size'])) {
-				$data['size'] = $filesData['size'];
-			}
-		}
-		return $data;
-	}
+            if (isset($filesData['size'])) {
+                $data['size'] = $filesData['size'];
+            }
+        }
+        return $data;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -51,8 +51,8 @@
 		}
 		if ($entry && $entry['mimetype'] === 'httpd/unix-directory') {
 			$id = $entry['fileid'];
-			$sql = 'SELECT SUM(`size`) AS f1 ' .
-			   'FROM `*PREFIX*filecache` ' .
+			$sql = 'SELECT SUM(`size`) AS f1 '.
+			   'FROM `*PREFIX*filecache` '.
 				'WHERE `parent` = ? AND `storage` = ? AND `size` >= 0';
 			$result = \OC_DB::executeAudited($sql, array($id, $this->getNumericStorageId()));
 			if ($row = $result->fetchRow()) {

lib/private/Files/Cache/MoveFromCacheTrait.php

Indentation +51 added lines, -51 removed lines

@@ -29,60 +29,60 @@
  * Fallback implementation for moveFromCache
  */
 trait MoveFromCacheTrait {
-	/**
-	 * store meta data for a file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	abstract public function put($file, array $data);
+    /**
+     * store meta data for a file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    abstract public function put($file, array $data);
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param \OCP\Files\Cache\ICache $sourceCache
-	 * @param string $sourcePath
-	 * @param string $targetPath
-	 */
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		$sourceEntry = $sourceCache->get($sourcePath);
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param \OCP\Files\Cache\ICache $sourceCache
+     * @param string $sourcePath
+     * @param string $targetPath
+     */
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        $sourceEntry = $sourceCache->get($sourcePath);
 
-		$this->copyFromCache($sourceCache, $sourceEntry, $targetPath);
+        $this->copyFromCache($sourceCache, $sourceEntry, $targetPath);
 
-		$sourceCache->remove($sourcePath);
-	}
+        $sourceCache->remove($sourcePath);
+    }
 
-	/**
-	 * Copy a file or folder in the cache
-	 *
-	 * @param \OCP\Files\Cache\ICache $sourceCache
-	 * @param ICacheEntry $sourceEntry
-	 * @param string $targetPath
-	 */
-	public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, $targetPath) {
-		$this->put($targetPath, $this->cacheEntryToArray($sourceEntry));
-		if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
-			$folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
-			foreach ($folderContent as $subEntry) {
-				$subTargetPath = $targetPath . '/' . $subEntry->getName();
-				$this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
-			}
-		}
-	}
+    /**
+     * Copy a file or folder in the cache
+     *
+     * @param \OCP\Files\Cache\ICache $sourceCache
+     * @param ICacheEntry $sourceEntry
+     * @param string $targetPath
+     */
+    public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, $targetPath) {
+        $this->put($targetPath, $this->cacheEntryToArray($sourceEntry));
+        if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
+            $folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
+            foreach ($folderContent as $subEntry) {
+                $subTargetPath = $targetPath . '/' . $subEntry->getName();
+                $this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
+            }
+        }
+    }
 
-	private function cacheEntryToArray(ICacheEntry $entry) {
-		return [
-			'size' => $entry->getSize(),
-			'mtime' => $entry->getMTime(),
-			'storage_mtime' => $entry->getStorageMTime(),
-			'mimetype' => $entry->getMimeType(),
-			'mimepart' => $entry->getMimePart(),
-			'etag' => $entry->getEtag(),
-			'permissions' => $entry->getPermissions(),
-			'encrypted' => $entry->isEncrypted()
-		];
-	}
+    private function cacheEntryToArray(ICacheEntry $entry) {
+        return [
+            'size' => $entry->getSize(),
+            'mtime' => $entry->getMTime(),
+            'storage_mtime' => $entry->getStorageMTime(),
+            'mimetype' => $entry->getMimeType(),
+            'mimepart' => $entry->getMimePart(),
+            'etag' => $entry->getEtag(),
+            'permissions' => $entry->getPermissions(),
+            'encrypted' => $entry->isEncrypted()
+        ];
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -67,7 +67,7 @@
 		if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
 			$folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
 			foreach ($folderContent as $subEntry) {
-				$subTargetPath = $targetPath . '/' . $subEntry->getName();
+				$subTargetPath = $targetPath.'/'.$subEntry->getName();
 				$this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
 			}
 		}

lib/private/Files/Cache/Watcher.php

Indentation +98 added lines, -98 removed lines

@@ -32,113 +32,113 @@
  */
 class Watcher implements IWatcher {
 
-	protected $watchPolicy = self::CHECK_ONCE;
+    protected $watchPolicy = self::CHECK_ONCE;
 
-	protected $checkedPaths = array();
+    protected $checkedPaths = array();
 
-	/**
-	 * @var \OC\Files\Storage\Storage $storage
-	 */
-	protected $storage;
+    /**
+     * @var \OC\Files\Storage\Storage $storage
+     */
+    protected $storage;
 
-	/**
-	 * @var Cache $cache
-	 */
-	protected $cache;
+    /**
+     * @var Cache $cache
+     */
+    protected $cache;
 
-	/**
-	 * @var Scanner $scanner ;
-	 */
-	protected $scanner;
+    /**
+     * @var Scanner $scanner ;
+     */
+    protected $scanner;
 
-	/**
-	 * @param \OC\Files\Storage\Storage $storage
-	 */
-	public function __construct(\OC\Files\Storage\Storage $storage) {
-		$this->storage = $storage;
-		$this->cache = $storage->getCache();
-		$this->scanner = $storage->getScanner();
-	}
+    /**
+     * @param \OC\Files\Storage\Storage $storage
+     */
+    public function __construct(\OC\Files\Storage\Storage $storage) {
+        $this->storage = $storage;
+        $this->cache = $storage->getCache();
+        $this->scanner = $storage->getScanner();
+    }
 
-	/**
-	 * @param int $policy either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
-	 */
-	public function setPolicy($policy) {
-		$this->watchPolicy = $policy;
-	}
+    /**
+     * @param int $policy either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
+     */
+    public function setPolicy($policy) {
+        $this->watchPolicy = $policy;
+    }
 
-	/**
-	 * @return int either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
-	 */
-	public function getPolicy() {
-		return $this->watchPolicy;
-	}
+    /**
+     * @return int either \OC\Files\Cache\Watcher::CHECK_NEVER, \OC\Files\Cache\Watcher::CHECK_ONCE, \OC\Files\Cache\Watcher::CHECK_ALWAYS
+     */
+    public function getPolicy() {
+        return $this->watchPolicy;
+    }
 
-	/**
-	 * check $path for updates and update if needed
-	 *
-	 * @param string $path
-	 * @param ICacheEntry|null $cachedEntry
-	 * @return boolean true if path was updated
-	 */
-	public function checkUpdate($path, $cachedEntry = null) {
-		if (is_null($cachedEntry)) {
-			$cachedEntry = $this->cache->get($path);
-		}
-		if ($this->needsUpdate($path, $cachedEntry)) {
-			$this->update($path, $cachedEntry);
-			return true;
-		} else {
-			return false;
-		}
-	}
+    /**
+     * check $path for updates and update if needed
+     *
+     * @param string $path
+     * @param ICacheEntry|null $cachedEntry
+     * @return boolean true if path was updated
+     */
+    public function checkUpdate($path, $cachedEntry = null) {
+        if (is_null($cachedEntry)) {
+            $cachedEntry = $this->cache->get($path);
+        }
+        if ($this->needsUpdate($path, $cachedEntry)) {
+            $this->update($path, $cachedEntry);
+            return true;
+        } else {
+            return false;
+        }
+    }
 
-	/**
-	 * Update the cache for changes to $path
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 */
-	public function update($path, $cachedData) {
-		if ($this->storage->is_dir($path)) {
-			$this->scanner->scan($path, Scanner::SCAN_SHALLOW);
-		} else {
-			$this->scanner->scanFile($path);
-		}
-		if ($cachedData['mimetype'] === 'httpd/unix-directory') {
-			$this->cleanFolder($path);
-		}
-		if ($this->cache instanceof Cache) {
-			$this->cache->correctFolderSize($path);
-		}
-	}
+    /**
+     * Update the cache for changes to $path
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     */
+    public function update($path, $cachedData) {
+        if ($this->storage->is_dir($path)) {
+            $this->scanner->scan($path, Scanner::SCAN_SHALLOW);
+        } else {
+            $this->scanner->scanFile($path);
+        }
+        if ($cachedData['mimetype'] === 'httpd/unix-directory') {
+            $this->cleanFolder($path);
+        }
+        if ($this->cache instanceof Cache) {
+            $this->cache->correctFolderSize($path);
+        }
+    }
 
-	/**
-	 * Check if the cache for $path needs to be updated
-	 *
-	 * @param string $path
-	 * @param ICacheEntry $cachedData
-	 * @return bool
-	 */
-	public function needsUpdate($path, $cachedData) {
-		if ($this->watchPolicy === self::CHECK_ALWAYS or ($this->watchPolicy === self::CHECK_ONCE and array_search($path, $this->checkedPaths) === false)) {
-			$this->checkedPaths[] = $path;
-			return $this->storage->hasUpdated($path, $cachedData['storage_mtime']);
-		}
-		return false;
-	}
+    /**
+     * Check if the cache for $path needs to be updated
+     *
+     * @param string $path
+     * @param ICacheEntry $cachedData
+     * @return bool
+     */
+    public function needsUpdate($path, $cachedData) {
+        if ($this->watchPolicy === self::CHECK_ALWAYS or ($this->watchPolicy === self::CHECK_ONCE and array_search($path, $this->checkedPaths) === false)) {
+            $this->checkedPaths[] = $path;
+            return $this->storage->hasUpdated($path, $cachedData['storage_mtime']);
+        }
+        return false;
+    }
 
-	/**
-	 * remove deleted files in $path from the cache
-	 *
-	 * @param string $path
-	 */
-	public function cleanFolder($path) {
-		$cachedContent = $this->cache->getFolderContents($path);
-		foreach ($cachedContent as $entry) {
-			if (!$this->storage->file_exists($entry['path'])) {
-				$this->cache->remove($entry['path']);
-			}
-		}
-	}
+    /**
+     * remove deleted files in $path from the cache
+     *
+     * @param string $path
+     */
+    public function cleanFolder($path) {
+        $cachedContent = $this->cache->getFolderContents($path);
+        foreach ($cachedContent as $entry) {
+            if (!$this->storage->file_exists($entry['path'])) {
+                $this->cache->remove($entry['path']);
+            }
+        }
+    }
 }

lib/private/Files/Cache/FailedCache.php

Indentation +111 added lines, -111 removed lines

@@ -29,115 +29,115 @@
  * Storage placeholder to represent a missing precondition, storage unavailable
  */
 class FailedCache implements ICache {
-	/** @var bool whether to show the failed storage in the ui */
-	private $visible;
-
-	/**
-	 * FailedCache constructor.
-	 *
-	 * @param bool $visible
-	 */
-	public function __construct($visible = true) {
-		$this->visible = $visible;
-	}
-
-
-	public function getNumericStorageId() {
-		return -1;
-	}
-
-	public function get($file) {
-		if ($file === '') {
-			return new CacheEntry([
-				'fileid' => -1,
-				'size' => 0,
-				'mimetype' => 'httpd/unix-directory',
-				'mimepart' => 'httpd',
-				'permissions' => $this->visible ? Constants::PERMISSION_READ : 0,
-				'mtime' => time()
-			]);
-		} else {
-			return false;
-		}
-	}
-
-	public function getFolderContents($folder) {
-		return [];
-	}
-
-	public function getFolderContentsById($fileId) {
-		return [];
-	}
-
-	public function put($file, array $data) {
-		return;
-	}
-
-	public function insert($file, array $data) {
-		return;
-	}
-
-	public function update($id, array $data) {
-		return;
-	}
-
-	public function getId($file) {
-		return -1;
-	}
-
-	public function getParentId($file) {
-		return -1;
-	}
-
-	public function inCache($file) {
-		return false;
-	}
-
-	public function remove($file) {
-		return;
-	}
-
-	public function move($source, $target) {
-		return;
-	}
-
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		return;
-	}
-
-	public function clear() {
-		return;
-	}
-
-	public function getStatus($file) {
-		return ICache::NOT_FOUND;
-	}
-
-	public function search($pattern) {
-		return [];
-	}
-
-	public function searchByMime($mimetype) {
-		return [];
-	}
-
-	public function searchByTag($tag, $userId) {
-		return [];
-	}
-
-	public function getAll() {
-		return [];
-	}
-
-	public function getIncomplete() {
-		return [];
-	}
-
-	public function getPathById($id) {
-		return null;
-	}
-
-	public function normalize($path) {
-		return $path;
-	}
+    /** @var bool whether to show the failed storage in the ui */
+    private $visible;
+
+    /**
+     * FailedCache constructor.
+     *
+     * @param bool $visible
+     */
+    public function __construct($visible = true) {
+        $this->visible = $visible;
+    }
+
+
+    public function getNumericStorageId() {
+        return -1;
+    }
+
+    public function get($file) {
+        if ($file === '') {
+            return new CacheEntry([
+                'fileid' => -1,
+                'size' => 0,
+                'mimetype' => 'httpd/unix-directory',
+                'mimepart' => 'httpd',
+                'permissions' => $this->visible ? Constants::PERMISSION_READ : 0,
+                'mtime' => time()
+            ]);
+        } else {
+            return false;
+        }
+    }
+
+    public function getFolderContents($folder) {
+        return [];
+    }
+
+    public function getFolderContentsById($fileId) {
+        return [];
+    }
+
+    public function put($file, array $data) {
+        return;
+    }
+
+    public function insert($file, array $data) {
+        return;
+    }
+
+    public function update($id, array $data) {
+        return;
+    }
+
+    public function getId($file) {
+        return -1;
+    }
+
+    public function getParentId($file) {
+        return -1;
+    }
+
+    public function inCache($file) {
+        return false;
+    }
+
+    public function remove($file) {
+        return;
+    }
+
+    public function move($source, $target) {
+        return;
+    }
+
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        return;
+    }
+
+    public function clear() {
+        return;
+    }
+
+    public function getStatus($file) {
+        return ICache::NOT_FOUND;
+    }
+
+    public function search($pattern) {
+        return [];
+    }
+
+    public function searchByMime($mimetype) {
+        return [];
+    }
+
+    public function searchByTag($tag, $userId) {
+        return [];
+    }
+
+    public function getAll() {
+        return [];
+    }
+
+    public function getIncomplete() {
+        return [];
+    }
+
+    public function getPathById($id) {
+        return null;
+    }
+
+    public function normalize($path) {
+        return $path;
+    }
 }

lib/private/Lock/DBLockingProvider.php

Indentation +219 added lines, -219 removed lines

@@ -37,245 +37,245 @@
  * Locking provider that stores the locks in the database
  */
 class DBLockingProvider extends AbstractLockingProvider {
-	/**
-	 * @var \OCP\IDBConnection
-	 */
-	private $connection;
+    /**
+     * @var \OCP\IDBConnection
+     */
+    private $connection;
 
-	/**
-	 * @var \OCP\ILogger
-	 */
-	private $logger;
+    /**
+     * @var \OCP\ILogger
+     */
+    private $logger;
 
-	/**
-	 * @var \OCP\AppFramework\Utility\ITimeFactory
-	 */
-	private $timeFactory;
+    /**
+     * @var \OCP\AppFramework\Utility\ITimeFactory
+     */
+    private $timeFactory;
 
-	private $sharedLocks = [];
+    private $sharedLocks = [];
 
-	/**
-	 * Check if we have an open shared lock for a path
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	protected function isLocallyLocked($path) {
-		return isset($this->sharedLocks[$path]) && $this->sharedLocks[$path];
-	}
+    /**
+     * Check if we have an open shared lock for a path
+     *
+     * @param string $path
+     * @return bool
+     */
+    protected function isLocallyLocked($path) {
+        return isset($this->sharedLocks[$path]) && $this->sharedLocks[$path];
+    }
 
-	/**
-	 * Mark a locally acquired lock
-	 *
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markAcquire($path, $type) {
-		parent::markAcquire($path, $type);
-		if ($type === self::LOCK_SHARED) {
-			$this->sharedLocks[$path] = true;
-		}
-	}
+    /**
+     * Mark a locally acquired lock
+     *
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    protected function markAcquire($path, $type) {
+        parent::markAcquire($path, $type);
+        if ($type === self::LOCK_SHARED) {
+            $this->sharedLocks[$path] = true;
+        }
+    }
 
-	/**
-	 * Change the type of an existing tracked lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markChange($path, $targetType) {
-		parent::markChange($path, $targetType);
-		if ($targetType === self::LOCK_SHARED) {
-			$this->sharedLocks[$path] = true;
-		} else if ($targetType === self::LOCK_EXCLUSIVE) {
-			$this->sharedLocks[$path] = false;
-		}
-	}
+    /**
+     * Change the type of an existing tracked lock
+     *
+     * @param string $path
+     * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    protected function markChange($path, $targetType) {
+        parent::markChange($path, $targetType);
+        if ($targetType === self::LOCK_SHARED) {
+            $this->sharedLocks[$path] = true;
+        } else if ($targetType === self::LOCK_EXCLUSIVE) {
+            $this->sharedLocks[$path] = false;
+        }
+    }
 
-	/**
-	 * @param \OCP\IDBConnection $connection
-	 * @param \OCP\ILogger $logger
-	 * @param \OCP\AppFramework\Utility\ITimeFactory $timeFactory
-	 * @param int $ttl
-	 */
-	public function __construct(IDBConnection $connection, ILogger $logger, ITimeFactory $timeFactory, $ttl = 3600) {
-		$this->connection = $connection;
-		$this->logger = $logger;
-		$this->timeFactory = $timeFactory;
-		$this->ttl = $ttl;
-	}
+    /**
+     * @param \OCP\IDBConnection $connection
+     * @param \OCP\ILogger $logger
+     * @param \OCP\AppFramework\Utility\ITimeFactory $timeFactory
+     * @param int $ttl
+     */
+    public function __construct(IDBConnection $connection, ILogger $logger, ITimeFactory $timeFactory, $ttl = 3600) {
+        $this->connection = $connection;
+        $this->logger = $logger;
+        $this->timeFactory = $timeFactory;
+        $this->ttl = $ttl;
+    }
 
-	/**
-	 * Insert a file locking row if it does not exists.
-	 *
-	 * @param string $path
-	 * @param int $lock
-	 * @return int number of inserted rows
-	 */
+    /**
+     * Insert a file locking row if it does not exists.
+     *
+     * @param string $path
+     * @param int $lock
+     * @return int number of inserted rows
+     */
 
-	protected function initLockField($path, $lock = 0) {
-		$expire = $this->getExpireTime();
-		return $this->connection->insertIfNotExist('*PREFIX*file_locks', ['key' => $path, 'lock' => $lock, 'ttl' => $expire], ['key']);
-	}
+    protected function initLockField($path, $lock = 0) {
+        $expire = $this->getExpireTime();
+        return $this->connection->insertIfNotExist('*PREFIX*file_locks', ['key' => $path, 'lock' => $lock, 'ttl' => $expire], ['key']);
+    }
 
-	/**
-	 * @return int
-	 */
-	protected function getExpireTime() {
-		return $this->timeFactory->getTime() + $this->ttl;
-	}
+    /**
+     * @return int
+     */
+    protected function getExpireTime() {
+        return $this->timeFactory->getTime() + $this->ttl;
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @return bool
-	 */
-	public function isLocked($path, $type) {
-		if ($this->hasAcquiredLock($path, $type)) {
-			return true;
-		}
-		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
-		$query->execute([$path]);
-		$lockValue = (int)$query->fetchColumn();
-		if ($type === self::LOCK_SHARED) {
-			if ($this->isLocallyLocked($path)) {
-				// if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
-				return $lockValue > 1;
-			} else {
-				return $lockValue > 0;
-			}
-		} else if ($type === self::LOCK_EXCLUSIVE) {
-			return $lockValue === -1;
-		} else {
-			return false;
-		}
-	}
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @return bool
+     */
+    public function isLocked($path, $type) {
+        if ($this->hasAcquiredLock($path, $type)) {
+            return true;
+        }
+        $query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
+        $query->execute([$path]);
+        $lockValue = (int)$query->fetchColumn();
+        if ($type === self::LOCK_SHARED) {
+            if ($this->isLocallyLocked($path)) {
+                // if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
+                return $lockValue > 1;
+            } else {
+                return $lockValue > 0;
+            }
+        } else if ($type === self::LOCK_EXCLUSIVE) {
+            return $lockValue === -1;
+        } else {
+            return false;
+        }
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock($path, $type) {
-		$expire = $this->getExpireTime();
-		if ($type === self::LOCK_SHARED) {
-			if (!$this->isLocallyLocked($path)) {
-				$result = $this->initLockField($path, 1);
-				if ($result <= 0) {
-					$result = $this->connection->executeUpdate(
-						'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1, `ttl` = ? WHERE `key` = ? AND `lock` >= 0',
-						[$expire, $path]
-					);
-				}
-			} else {
-				$result = 1;
-			}
-		} else {
-			$existing = 0;
-			if ($this->hasAcquiredLock($path, ILockingProvider::LOCK_SHARED) === false && $this->isLocallyLocked($path)) {
-				$existing = 1;
-			}
-			$result = $this->initLockField($path, -1);
-			if ($result <= 0) {
-				$result = $this->connection->executeUpdate(
-					'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = ?',
-					[$expire, $path, $existing]
-				);
-			}
-		}
-		if ($result !== 1) {
-			throw new LockedException($path);
-		}
-		$this->markAcquire($path, $type);
-	}
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock($path, $type) {
+        $expire = $this->getExpireTime();
+        if ($type === self::LOCK_SHARED) {
+            if (!$this->isLocallyLocked($path)) {
+                $result = $this->initLockField($path, 1);
+                if ($result <= 0) {
+                    $result = $this->connection->executeUpdate(
+                        'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1, `ttl` = ? WHERE `key` = ? AND `lock` >= 0',
+                        [$expire, $path]
+                    );
+                }
+            } else {
+                $result = 1;
+            }
+        } else {
+            $existing = 0;
+            if ($this->hasAcquiredLock($path, ILockingProvider::LOCK_SHARED) === false && $this->isLocallyLocked($path)) {
+                $existing = 1;
+            }
+            $result = $this->initLockField($path, -1);
+            if ($result <= 0) {
+                $result = $this->connection->executeUpdate(
+                    'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = ?',
+                    [$expire, $path, $existing]
+                );
+            }
+        }
+        if ($result !== 1) {
+            throw new LockedException($path);
+        }
+        $this->markAcquire($path, $type);
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	public function releaseLock($path, $type) {
-		$this->markRelease($path, $type);
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    public function releaseLock($path, $type) {
+        $this->markRelease($path, $type);
 
-		// we keep shared locks till the end of the request so we can re-use them
-		if ($type === self::LOCK_EXCLUSIVE) {
-			$this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
-				[$path]
-			);
-		}
-	}
+        // we keep shared locks till the end of the request so we can re-use them
+        if ($type === self::LOCK_EXCLUSIVE) {
+            $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
+                [$path]
+            );
+        }
+    }
 
-	/**
-	 * Change the type of an existing lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function changeLock($path, $targetType) {
-		$expire = $this->getExpireTime();
-		if ($targetType === self::LOCK_SHARED) {
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 1, `ttl` = ? WHERE `key` = ? AND `lock` = -1',
-				[$expire, $path]
-			);
-		} else {
-			// since we only keep one shared lock in the db we need to check if we have more then one shared lock locally manually
-			if (isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 1) {
-				throw new LockedException($path);
-			}
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = 1',
-				[$expire, $path]
-			);
-		}
-		if ($result !== 1) {
-			throw new LockedException($path);
-		}
-		$this->markChange($path, $targetType);
-	}
+    /**
+     * Change the type of an existing lock
+     *
+     * @param string $path
+     * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @throws \OCP\Lock\LockedException
+     */
+    public function changeLock($path, $targetType) {
+        $expire = $this->getExpireTime();
+        if ($targetType === self::LOCK_SHARED) {
+            $result = $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = 1, `ttl` = ? WHERE `key` = ? AND `lock` = -1',
+                [$expire, $path]
+            );
+        } else {
+            // since we only keep one shared lock in the db we need to check if we have more then one shared lock locally manually
+            if (isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 1) {
+                throw new LockedException($path);
+            }
+            $result = $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = 1',
+                [$expire, $path]
+            );
+        }
+        if ($result !== 1) {
+            throw new LockedException($path);
+        }
+        $this->markChange($path, $targetType);
+    }
 
-	/**
-	 * cleanup empty locks
-	 */
-	public function cleanExpiredLocks() {
-		$expire = $this->timeFactory->getTime();
-		try {
-			$this->connection->executeUpdate(
-				'DELETE FROM `*PREFIX*file_locks` WHERE `ttl` < ?',
-				[$expire]
-			);
-		} catch (\Exception $e) {
-			// If the table is missing, the clean up was successful
-			if ($this->connection->tableExists('file_locks')) {
-				throw $e;
-			}
-		}
-	}
+    /**
+     * cleanup empty locks
+     */
+    public function cleanExpiredLocks() {
+        $expire = $this->timeFactory->getTime();
+        try {
+            $this->connection->executeUpdate(
+                'DELETE FROM `*PREFIX*file_locks` WHERE `ttl` < ?',
+                [$expire]
+            );
+        } catch (\Exception $e) {
+            // If the table is missing, the clean up was successful
+            if ($this->connection->tableExists('file_locks')) {
+                throw $e;
+            }
+        }
+    }
 
-	/**
-	 * release all lock acquired by this instance which were marked using the mark* methods
-	 */
-	public function releaseAll() {
-		parent::releaseAll();
+    /**
+     * release all lock acquired by this instance which were marked using the mark* methods
+     */
+    public function releaseAll() {
+        parent::releaseAll();
 
-		// since we keep shared locks we need to manually clean those
-		$lockedPaths = array_keys($this->sharedLocks);
-		$lockedPaths = array_filter($lockedPaths, function ($path) {
-			return $this->sharedLocks[$path];
-		});
+        // since we keep shared locks we need to manually clean those
+        $lockedPaths = array_keys($this->sharedLocks);
+        $lockedPaths = array_filter($lockedPaths, function ($path) {
+            return $this->sharedLocks[$path];
+        });
 
-		$chunkedPaths = array_chunk($lockedPaths, 100);
+        $chunkedPaths = array_chunk($lockedPaths, 100);
 
-		foreach ($chunkedPaths as $chunk) {
-			$builder = $this->connection->getQueryBuilder();
+        foreach ($chunkedPaths as $chunk) {
+            $builder = $this->connection->getQueryBuilder();
 
-			$query = $builder->update('file_locks')
-				->set('lock', $builder->createFunction('`lock` -1'))
-				->where($builder->expr()->in('key', $builder->createNamedParameter($chunk, IQueryBuilder::PARAM_STR_ARRAY)))
-				->andWhere($builder->expr()->gt('lock', new Literal(0)));
+            $query = $builder->update('file_locks')
+                ->set('lock', $builder->createFunction('`lock` -1'))
+                ->where($builder->expr()->in('key', $builder->createNamedParameter($chunk, IQueryBuilder::PARAM_STR_ARRAY)))
+                ->andWhere($builder->expr()->gt('lock', new Literal(0)));
 
-			$query->execute();
-		}
-	}
+            $query->execute();
+        }
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -136,7 +136,7 @@ 
 		}
 		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
 		$query->execute([$path]);
-		$lockValue = (int)$query->fetchColumn();
+		$lockValue = (int) $query->fetchColumn();
 		if ($type === self::LOCK_SHARED) {
 			if ($this->isLocallyLocked($path)) {
 				// if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
@@ -261,7 +261,7 @@ 
 
 		// since we keep shared locks we need to manually clean those
 		$lockedPaths = array_keys($this->sharedLocks);
-		$lockedPaths = array_filter($lockedPaths, function ($path) {
+		$lockedPaths = array_filter($lockedPaths, function($path) {
 			return $this->sharedLocks[$path];
 		});
 

lib/private/Lock/NoopLockingProvider.php

Indentation +21 added lines, -21 removed lines

@@ -35,35 +35,35 @@
     /**
      * {@inheritdoc}
      */
-	public function isLocked($path, $type) {
-		return false;
-	}
+    public function isLocked($path, $type) {
+        return false;
+    }
 
     /**
      * {@inheritdoc}
      */
-	public function acquireLock($path, $type) {
-		// do nothing
-	}
+    public function acquireLock($path, $type) {
+        // do nothing
+    }
 
-	/**
+    /**
      * {@inheritdoc}
-	 */
-	public function releaseLock($path, $type) {
-		// do nothing
-	}
+     */
+    public function releaseLock($path, $type) {
+        // do nothing
+    }
 
-	/**1
+    /**1
 	 * {@inheritdoc}
 	 */
-	public function releaseAll() {
-		// do nothing
-	}
+    public function releaseAll() {
+        // do nothing
+    }
 
-	/**
-	 * {@inheritdoc}
-	 */
-	public function changeLock($path, $targetType) {
-		// do nothing
-	}
+    /**
+     * {@inheritdoc}
+     */
+    public function changeLock($path, $targetType) {
+        // do nothing
+    }
 }