17 files changed, 471 insertions, 59 deletions

diff --git a/core/css/fonts.css b/core/css/fonts.css
index aa6e71bef21..de2742c6368 100644
--- a/core/css/fonts.css
+++ b/core/css/fonts.css
@@ -1,13 +1,13 @@
 @font-face {
 	font-family: 'Open Sans';
 	font-style: normal;
-	font-weight: normal;
-	src: local('Open Sans'), local('OpenSans'), url(../fonts/OpenSans-Regular.woff) format('woff');
+	font-weight: 300;
+	src: local('Open Sans Light'), local('OpenSans-Light'), url(../fonts/OpenSans-Light.woff) format('woff');
 }
 
 @font-face {
 	font-family: 'Open Sans';
 	font-style: normal;
-	font-weight: bold;
-	src: local('Open Sans Bold'), local('OpenSans-Bold'), url(../fonts/OpenSans-Bold.woff) format('woff');
-}
\ No newline at end of file
+	font-weight: 600;
+	src: local('Open Sans Semibold'), local('OpenSans-Semibold'), url(../fonts/OpenSans-Semibold.woff) format('woff');
+}
diff --git a/core/css/styles.css b/core/css/styles.css
index 6f5906c7533..5ad81fd12aa 100644
--- a/core/css/styles.css
+++ b/core/css/styles.css
@@ -16,7 +16,7 @@ ul { list-style:none; }
 
 body {
 	background-color: #ffffff;
-	font-weight: normal;
+	font-weight: 300;
 	font-size: .8em;
 	line-height: 1.6em;
 	font-family: 'Open Sans', Frutiger, Calibri, 'Myriad Pro', Myriad, sans-serif;
@@ -198,7 +198,7 @@ button, .button,
 	min-width: 25px;
 	padding: 5px;
 	background-color: rgba(240,240,240,.9);
-	font-weight: bold;
+	font-weight: 600;
 	color: #555;
 	border: 1px solid rgba(240,240,240,.9);
 	cursor: pointer;
@@ -370,6 +370,7 @@ input[type="submit"].enabled {
 }
 #emptycontent h2,
 .emptycontent h2 {
+	font-weight: 600;
 	font-size: 22px;
 	margin-bottom: 10px;
 }
@@ -444,7 +445,7 @@ input[type="submit"].enabled {
 	padding-top: 20px;
 }
 #body-login p.info a {
-	font-weight: bold;
+	font-weight: 600;
 	padding: 13px;
 	margin: -13px;
 }
@@ -708,7 +709,7 @@ label.infield {
 .warning a,
 .error a {
 	color: #fff !important;
-	font-weight: bold !important;
+	font-weight: 600 !important;
 }
 .error pre {
 	white-space: pre-wrap;
@@ -803,7 +804,7 @@ label.infield {
 	overflow: hidden;
 }
 
-.bold { font-weight:bold; }
+.bold { font-weight:600; }
 .center { text-align:center; }
 .inlineblock { display: inline-block; }
 
@@ -1035,7 +1036,7 @@ div.crumb:first-child a {
 	top: 13px;
 }
 div.crumb.last {
-	font-weight: bold;
+	font-weight: 600;
 	margin-right: 10px;
 }
 div.crumb a.ellipsislink {
@@ -1081,7 +1082,7 @@ div.crumb:active {
 
 #body-public footer .info a {
 	color: #777;
-	font-weight: bold;
+	font-weight: 600;
 	padding: 13px;
 	margin: -13px;
 }
diff --git a/core/fonts/OpenSans-Bold.woff b/core/fonts/OpenSans-Bold.woff
deleted file mode 100644
index ee2ea797d1c..00000000000
--- a/core/fonts/OpenSans-Bold.woff
+++ /dev/null
diff --git a/core/fonts/OpenSans-Light.woff b/core/fonts/OpenSans-Light.woff
new file mode 100644
index 00000000000..937323df0d9
--- /dev/null
+++ b/core/fonts/OpenSans-Light.woff
diff --git a/core/fonts/OpenSans-Regular.woff b/core/fonts/OpenSans-Regular.woff
deleted file mode 100644
index 2abc3ed69fd..00000000000
--- a/core/fonts/OpenSans-Regular.woff
+++ /dev/null
diff --git a/core/fonts/OpenSans-Semibold.woff b/core/fonts/OpenSans-Semibold.woff
new file mode 100644
index 00000000000..8c0313ff36b
--- /dev/null
+++ b/core/fonts/OpenSans-Semibold.woff
diff --git a/db_structure.xml b/db_structure.xml
index 870c0ab018d..c7b7ffec601 100644
--- a/db_structure.xml
+++ b/db_structure.xml
@@ -1192,5 +1192,78 @@
 
 	</table>
 
+	<table>
+
+		<!--
+		Table for storing transactional file locking
+		-->
+		<name>*dbprefix*file_locks</name>
+
+		<declaration>
+
+			<field>
+				<name>id</name>
+				<type>integer</type>
+				<default>0</default>
+				<notnull>true</notnull>
+				<unsigned>true</unsigned>
+				<length>4</length>
+				<autoincrement>1</autoincrement>
+			</field>
+
+			<field>
+				<name>lock</name>
+				<type>integer</type>
+				<default>0</default>
+				<notnull>true</notnull>
+				<length>4</length>
+			</field>
+
+			<field>
+				<name>key</name>
+				<type>text</type>
+				<notnull>true</notnull>
+				<length>64</length>
+			</field>
+
+			<field>
+				<name>ttl</name>
+				<type>integer</type>
+				<default>-1</default>
+				<notnull>true</notnull>
+				<length>4</length>
+			</field>
+
+			<index>
+				<primary>true</primary>
+				<unique>true</unique>
+				<name>lock_id_index</name>
+				<field>
+					<name>id</name>
+					<sorting>ascending</sorting>
+				</field>
+			</index>
+
+			<index>
+				<unique>true</unique>
+				<name>lock_key_index</name>
+				<field>
+					<name>key</name>
+					<sorting>ascending</sorting>
+				</field>
+			</index>
+
+			<index>
+				<name>lock_ttl_index</name>
+				<field>
+					<name>ttl</name>
+					<sorting>ascending</sorting>
+				</field>
+			</index>
+
+		</declaration>
+
+	</table>
+
 
 </database>
diff --git a/lib/private/appframework/db/db.php b/lib/private/appframework/db/db.php
index cde85831687..8e3fa6e4197 100644
--- a/lib/private/appframework/db/db.php
+++ b/lib/private/appframework/db/db.php
@@ -154,6 +154,15 @@ class Db implements IDb {
 	}
 
 	/**
+	 * Check if a transaction is active
+	 *
+	 * @return bool
+	 */
+	public function inTransaction() {
+		return $this->connection->inTransaction();
+	}
+
+	/**
 	 * Commit the database changes done during a transaction that is in progress
 	 */
 	public function commit() {
diff --git a/lib/private/db/connection.php b/lib/private/db/connection.php
index def3f2fd120..4d33cd968af 100644
--- a/lib/private/db/connection.php
+++ b/lib/private/db/connection.php
@@ -291,4 +291,14 @@ class Connection extends \Doctrine\DBAL\Connection implements IDBConnection {
 	protected function replaceTablePrefix($statement) {
 		return str_replace( '*PREFIX*', $this->tablePrefix, $statement );
 	}
+
+	/**
+	 * Check if a transaction is active
+	 *
+	 * @return bool
+	 * @since 8.2.0
+	 */
+	public function inTransaction() {
+		return $this->getTransactionNestingLevel() > 0;
+	}
 }
diff --git a/lib/private/l10n.php b/lib/private/l10n.php
index d367dbae690..17acaac1692 100644
--- a/lib/private/l10n.php
+++ b/lib/private/l10n.php
@@ -449,8 +449,11 @@ class OC_L10N implements \OCP\IL10N {
 			return self::$language;
 		}
 
-		if(OC_User::getUser() && \OC::$server->getConfig()->getUserValue(OC_User::getUser(), 'core', 'lang')) {
-			$lang = \OC::$server->getConfig()->getUserValue(OC_User::getUser(), 'core', 'lang');
+		$config = \OC::$server->getConfig();
+		$userId = \OC_User::getUser();
+
+		if($userId && $config->getUserValue($userId, 'core', 'lang')) {
+			$lang = $config->getUserValue($userId, 'core', 'lang');
 			self::$language = $lang;
 			if(is_array($app)) {
 				$available = $app;
@@ -463,13 +466,18 @@ class OC_L10N implements \OCP\IL10N {
 			}
 		}
 
-		$default_language = \OC::$server->getConfig()->getSystemValue('default_language', false);
+		$default_language = $config->getSystemValue('default_language', false);
 
 		if($default_language !== false) {
 			return $default_language;
 		}
 
-		return self::setLanguageFromRequest($app);
+		$lang = self::setLanguageFromRequest($app);
+		if($userId && !$config->getUserValue($userId, 'core', 'lang')) {
+			$config->setUserValue($userId, 'core', 'lang', $lang);
+		}
+
+		return $lang;
 	}
 
 	/**
diff --git a/lib/private/lock/abstractlockingprovider.php b/lib/private/lock/abstractlockingprovider.php
new file mode 100644
index 00000000000..eb86be68500
--- /dev/null
+++ b/lib/private/lock/abstractlockingprovider.php
@@ -0,0 +1,102 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2015, ownCloud, Inc.
+ * @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 OC\Lock;
+
+use OCP\Lock\ILockingProvider;
+
+/**
+ * Base locking provider that keeps track of locks acquired during the current request
+ * to release any left over locks at the end of the request
+ */
+abstract class AbstractLockingProvider implements ILockingProvider {
+	protected $acquiredLocks = [
+		'shared' => [],
+		'exclusive' => []
+	];
+
+	/**
+	 * Mark a locally acquired lock
+	 *
+	 * @param string $path
+	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+	 */
+	protected function markAcquire($path, $type) {
+		if ($type === self::LOCK_SHARED) {
+			if (!isset($this->acquiredLocks['shared'][$path])) {
+				$this->acquiredLocks['shared'][$path] = 0;
+			}
+			$this->acquiredLocks['shared'][$path]++;
+		} else {
+			$this->acquiredLocks['exclusive'][$path] = true;
+		}
+	}
+
+	/**
+	 * Mark a release of a locally acquired lock
+	 *
+	 * @param string $path
+	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+	 */
+	protected function markRelease($path, $type) {
+		if ($type === self::LOCK_SHARED) {
+			if (isset($this->acquiredLocks['shared'][$path]) and $this->acquiredLocks['shared'][$path] > 0) {
+				$this->acquiredLocks['shared'][$path]--;
+			}
+		} else if ($type === self::LOCK_EXCLUSIVE) {
+			unset($this->acquiredLocks['exclusive'][$path]);
+		}
+	}
+
+	/**
+	 * 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) {
+		if ($targetType === self::LOCK_SHARED) {
+			unset($this->acquiredLocks['exclusive'][$path]);
+			if (!isset($this->acquiredLocks['shared'][$path])) {
+				$this->acquiredLocks['shared'][$path] = 0;
+			}
+			$this->acquiredLocks['shared'][$path]++;
+		} else if ($targetType === self::LOCK_EXCLUSIVE) {
+			$this->acquiredLocks['exclusive'][$path] = true;
+			$this->acquiredLocks['shared'][$path]--;
+		}
+	}
+
+	/**
+	 * release all lock acquired by this instance which were marked using the mark* methods
+	 */
+	public function releaseAll() {
+		foreach ($this->acquiredLocks['shared'] as $path => $count) {
+			for ($i = 0; $i < $count; $i++) {
+				$this->releaseLock($path, self::LOCK_SHARED);
+			}
+		}
+
+		foreach ($this->acquiredLocks['exclusive'] as $path => $hasLock) {
+			$this->releaseLock($path, self::LOCK_EXCLUSIVE);
+		}
+	}
+}
diff --git a/lib/private/lock/dblockingprovider.php b/lib/private/lock/dblockingprovider.php
new file mode 100644
index 00000000000..f3e684d0b4d
--- /dev/null
+++ b/lib/private/lock/dblockingprovider.php
@@ -0,0 +1,162 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2015, ownCloud, Inc.
+ * @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 OC\Lock;
+
+use OCP\IDBConnection;
+use OCP\ILogger;
+use OCP\Lock\LockedException;
+
+/**
+ * Locking provider that stores the locks in the database
+ */
+class DBLockingProvider extends AbstractLockingProvider {
+	/**
+	 * @var \OCP\IDBConnection
+	 */
+	private $connection;
+
+	/**
+	 * @var \OCP\ILogger
+	 */
+	private $logger;
+
+	/**
+	 * @param \OCP\IDBConnection $connection
+	 * @param \OCP\ILogger $logger
+	 */
+	public function __construct(IDBConnection $connection, ILogger $logger) {
+		$this->connection = $connection;
+		$this->logger = $logger;
+	}
+
+	protected function initLockField($path) {
+		$this->connection->insertIfNotExist('*PREFIX*file_locks', ['key' => $path, 'lock' => 0, 'ttl' => 0], ['key']);
+	}
+
+	/**
+	 * @param string $path
+	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+	 * @return bool
+	 */
+	public function isLocked($path, $type) {
+		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
+		$query->execute([$path]);
+		$lockValue = (int)$query->fetchColumn();
+		if ($type === self::LOCK_SHARED) {
+			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) {
+		if ($this->connection->inTransaction()){
+			$this->logger->warning("Trying to acquire a lock for '$path' while inside a transition");
+		}
+
+		$this->connection->beginTransaction();
+		$this->initLockField($path);
+		if ($type === self::LOCK_SHARED) {
+			$result = $this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1 WHERE `key` = ? AND `lock` >= 0',
+				[$path]
+			);
+		} else {
+			$result = $this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = -1 WHERE `key` = ? AND `lock` = 0',
+				[$path]
+			);
+		}
+		$this->connection->commit();
+		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->initLockField($path);
+		if ($type === self::LOCK_SHARED) {
+			$this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` - 1 WHERE `key` = ? AND `lock` > 0',
+				[$path]
+			);
+		} else {
+			$this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
+				[$path]
+			);
+		}
+
+		$this->markRelease($path, $type);
+	}
+
+	/**
+	 * 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) {
+		$this->initLockField($path);
+		if ($targetType === self::LOCK_SHARED) {
+			$result = $this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = 1 WHERE `key` = ? AND `lock` = -1',
+				[$path]
+			);
+		} else {
+			$result = $this->connection->executeUpdate(
+				'UPDATE `*PREFIX*file_locks` SET `lock` = -1 WHERE `key` = ? AND `lock` = 1',
+				[$path]
+			);
+		}
+		if ($result !== 1) {
+			throw new LockedException($path);
+		}
+		$this->markChange($path, $targetType);
+	}
+
+	/**
+	 * cleanup empty locks
+	 */
+	public function cleanEmptyLocks() {
+		$this->connection->executeUpdate(
+			'DELETE FROM `*PREFIX*file_locks` WHERE `lock` = 0'
+		);
+	}
+
+	public function __destruct() {
+		$this->cleanEmptyLocks();
+	}
+}
diff --git a/lib/private/lock/memcachelockingprovider.php b/lib/private/lock/memcachelockingprovider.php
index 5f2b5e5a4b8..871572f7e3e 100644
--- a/lib/private/lock/memcachelockingprovider.php
+++ b/lib/private/lock/memcachelockingprovider.php
@@ -23,21 +23,15 @@
 
 namespace OC\Lock;
 
-use OCP\Lock\ILockingProvider;
 use OCP\Lock\LockedException;
 use OCP\IMemcache;
 
-class MemcacheLockingProvider implements ILockingProvider {
+class MemcacheLockingProvider extends AbstractLockingProvider {
 	/**
 	 * @var \OCP\IMemcache
 	 */
 	private $memcache;
 
-	private $acquiredLocks = [
-		'shared' => [],
-		'exclusive' => []
-	];
-
 	/**
 	 * @param \OCP\IMemcache $memcache
 	 */
@@ -71,17 +65,13 @@ class MemcacheLockingProvider implements ILockingProvider {
 			if (!$this->memcache->inc($path)) {
 				throw new LockedException($path);
 			}
-			if (!isset($this->acquiredLocks['shared'][$path])) {
-				$this->acquiredLocks['shared'][$path] = 0;
-			}
-			$this->acquiredLocks['shared'][$path]++;
 		} else {
 			$this->memcache->add($path, 0);
 			if (!$this->memcache->cas($path, 0, 'exclusive')) {
 				throw new LockedException($path);
 			}
-			$this->acquiredLocks['exclusive'][$path] = true;
 		}
+		$this->markAcquire($path, $type);
 	}
 
 	/**
@@ -92,13 +82,12 @@ class MemcacheLockingProvider implements ILockingProvider {
 		if ($type === self::LOCK_SHARED) {
 			if (isset($this->acquiredLocks['shared'][$path]) and $this->acquiredLocks['shared'][$path] > 0) {
 				$this->memcache->dec($path);
-				$this->acquiredLocks['shared'][$path]--;
 				$this->memcache->cad($path, 0);
 			}
 		} else if ($type === self::LOCK_EXCLUSIVE) {
 			$this->memcache->cad($path, 'exclusive');
-			unset($this->acquiredLocks['exclusive'][$path]);
 		}
+		$this->markRelease($path, $type);
 	}
 
 	/**
@@ -113,33 +102,12 @@ class MemcacheLockingProvider implements ILockingProvider {
 			if (!$this->memcache->cas($path, 'exclusive', 1)) {
 				throw new LockedException($path);
 			}
-			unset($this->acquiredLocks['exclusive'][$path]);
-			if (!isset($this->acquiredLocks['shared'][$path])) {
-				$this->acquiredLocks['shared'][$path] = 0;
-			}
-			$this->acquiredLocks['shared'][$path]++;
 		} else if ($targetType === self::LOCK_EXCLUSIVE) {
 			// we can only change a shared lock to an exclusive if there's only a single owner of the shared lock
 			if (!$this->memcache->cas($path, 1, 'exclusive')) {
 				throw new LockedException($path);
 			}
-			$this->acquiredLocks['exclusive'][$path] = true;
-			$this->acquiredLocks['shared'][$path]--;
-		}
-	}
-
-	/**
-	 * release all lock acquired by this instance
-	 */
-	public function releaseAll() {
-		foreach ($this->acquiredLocks['shared'] as $path => $count) {
-			for ($i = 0; $i < $count; $i++) {
-				$this->releaseLock($path, self::LOCK_SHARED);
-			}
-		}
-
-		foreach ($this->acquiredLocks['exclusive'] as $path => $hasLock) {
-			$this->releaseLock($path, self::LOCK_EXCLUSIVE);
 		}
+		$this->markChange($path, $targetType);
 	}
 }
diff --git a/lib/private/server.php b/lib/private/server.php
index 5a3a6328fae..287b70eb806 100644
--- a/lib/private/server.php
+++ b/lib/private/server.php
@@ -49,6 +49,7 @@ use OC\Diagnostics\QueryLogger;
 use OC\Files\Node\Root;
 use OC\Files\View;
 use OC\Http\Client\ClientService;
+use OC\Lock\DBLockingProvider;
 use OC\Lock\MemcacheLockingProvider;
 use OC\Lock\NoopLockingProvider;
 use OC\Mail\Mailer;
@@ -441,13 +442,10 @@ class Server extends SimpleContainer implements IServerContainer {
 				/** @var \OC\Memcache\Factory $memcacheFactory */
 				$memcacheFactory = $c->getMemCacheFactory();
 				$memcache = $memcacheFactory->createLocking('lock');
-				if (!($memcache instanceof \OC\Memcache\NullCache)) {
-					return new MemcacheLockingProvider($memcache);
-				}
-				throw new HintException(
-					'File locking is enabled but the locking cache class was not found',
-					'Please check the "memcache.locking" setting and make sure the matching PHP module is installed and enabled'
-				);
+//				if (!($memcache instanceof \OC\Memcache\NullCache)) {
+//					return new MemcacheLockingProvider($memcache);
+//				}
+				return new DBLockingProvider($c->getDatabaseConnection(), $c->getLogger());
 			}
 			return new NoopLockingProvider();
 		});
diff --git a/lib/public/idbconnection.php b/lib/public/idbconnection.php
index 0d04c43d73e..6a4373583fa 100644
--- a/lib/public/idbconnection.php
+++ b/lib/public/idbconnection.php
@@ -115,6 +115,14 @@ interface IDBConnection {
 	public function beginTransaction();
 
 	/**
+	 * Check if a transaction is active
+	 *
+	 * @return bool
+	 * @since 8.2.0
+	 */
+	public function inTransaction();
+
+	/**
 	 * Commit the database changes done during a transaction that is in progress
 	 * @since 6.0.0
 	 */
diff --git a/tests/lib/lock/dblockingprovider.php b/tests/lib/lock/dblockingprovider.php
new file mode 100644
index 00000000000..fd6550d9c47
--- /dev/null
+++ b/tests/lib/lock/dblockingprovider.php
@@ -0,0 +1,43 @@
+<?php
+/**
+ * @author Robin Appelman <icewind@owncloud.com>
+ *
+ * @copyright Copyright (c) 2015, ownCloud, Inc.
+ * @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 Test\Lock;
+
+class DBLockingProvider extends LockingProvider {
+
+	/**
+	 * @var \OCP\IDBConnection
+	 */
+	private $connection;
+
+	/**
+	 * @return \OCP\Lock\ILockingProvider
+	 */
+	protected function getInstance() {
+		$this->connection = \OC::$server->getDatabaseConnection();
+		return new \OC\Lock\DBLockingProvider($this->connection, \OC::$server->getLogger());
+	}
+
+	public function tearDown() {
+		$this->connection->executeQuery('DELETE FROM `*PREFIX*file_locks`');
+		parent::tearDown();
+	}
+}
diff --git a/tests/lib/lock/lockingprovider.php b/tests/lib/lock/lockingprovider.php
index efd6e1939f2..ca72c1bb7f3 100644
--- a/tests/lib/lock/lockingprovider.php
+++ b/tests/lib/lock/lockingprovider.php
@@ -120,6 +120,36 @@ abstract class LockingProvider extends TestCase {
 		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
 	}
 
+	public function testReleaseAllAfterChange() {
+		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);
+
+		$this->instance->changeLock('bar', ILockingProvider::LOCK_EXCLUSIVE);
+
+		$this->instance->releaseAll();
+
+		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
+		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_SHARED));
+		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_EXCLUSIVE));
+		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
+	}
+
+	public function testReleaseAllAfterUnlock() {
+		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
+		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);
+
+		$this->instance->releaseLock('bar', ILockingProvider::LOCK_SHARED);
+
+		$this->instance->releaseAll();
+
+		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
+		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
+	}
+
 	public function testReleaseAfterReleaseAll() {
 		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
 		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);