diff --git a/lib/private/files/lock.php b/lib/private/files/lock.php
new file mode 100644
index 0000000000000000000000000000000000000000..b752b16f02395810a0d7d2dee4294b32534ba906
--- /dev/null
+++ b/lib/private/files/lock.php
@@ -0,0 +1,308 @@
+<?php
+/**
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ *
+ * This library 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 library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\Files;
+
+use OCP\Config;
+use OC\Files\Filesystem;
+
+/**
+ * Class Lock
+ * @package OC\Files
+ */
+class Lock implements \OCP\Files\Lock {
+
+ /** @var int $retries Number of lock retries to attempt */
+ public static $retries = 40;
+
+ /** @var int $retryInterval Milliseconds between retries */
+ public static $retryInterval = 50;
+
+ /** @var string $path Filename of the file as represented in storage */
+ protected $path;
+
+ /** @var array $stack A stack of lock data */
+ protected $stack = array();
+
+ /** @var resource $handle A file handle used to maintain a lock */
+ protected $handle;
+
+ /** @var string $lockFile Filename of the lock file */
+ protected $lockFile;
+
+ /** @var resource $lockFileHandle The file handle used to maintain a lock on the lock file */
+ protected $lockFileHandle;
+
+ /**
+ * Constructor for the lock instance
+ * @param string $path Absolute pathname for a local file on which to obtain a lock
+ */
+ public function __construct($path) {
+ $this->path = Filesystem::normalizePath($path);
+ }
+
+ protected function obtainReadLock($existingHandle = null) {
+ \OC_Log::write('lock', sprintf('INFO: Read lock requested for %s', $this->path), \OC_Log::DEBUG);
+ $timeout = Lock::$retries;
+
+ // Re-use an existing handle or get a new one
+ if(empty($existingHandle)) {
+ $handle = fopen($this->path, 'r');
+ }
+ else {
+ $handle = $existingHandle;
+ }
+
+ do {
+ if($this->isLockFileLocked($this->getLockFile($this->path))) {
+ \OC_Log::write('lock', sprintf('INFO: Read lock has locked lock file %s for %s', $this->getLockFile($this->path), $this->path), \OC_Log::DEBUG);
+ do {
+ usleep(Lock::$retryInterval);
+ $timeout--;
+ } while($this->isLockFileLocked($this->getLockFile($this->path)) && $timeout > 0);
+ \OC_Log::write('lock', sprintf('INFO: Lock file %s has become unlocked for %s', $this->getLockFile($this->path), $this->path), \OC_Log::DEBUG);
+ }
+ } while ((!$lockReturn = flock($handle, LOCK_SH | LOCK_NB, $wouldBlock)) && $timeout > 0);
+ if ($wouldBlock == true || $lockReturn == false || $timeout <= 0) {
+ \OC_Log::write('lock', sprintf('FAIL: Failed to acquire read lock for %s', $this->path), \OC_Log::DEBUG);
+ return false;
+ }
+ $this->handle = $handle;
+ \OC_Log::write('lock', sprintf('PASS: Acquired read lock for %s', $this->path), \OC_Log::DEBUG);
+ return true;
+ }
+
+ protected function obtainWriteLock($existingHandle = null) {
+ \OC_Log::write('lock', sprintf('INFO: Write lock requested for %s', $this->path), \OC_Log::DEBUG);
+
+ // Re-use an existing handle or get a new one
+ if (empty($existingHandle)) {
+ $handle = fopen($this->path, 'c');
+ }
+ else {
+ $handle = $existingHandle;
+ }
+
+ // If the file doesn't exist, but we can create a lock for it
+ if (!file_exists($this->path) && $this->lockLockFile($this->path)) {
+ $lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock);
+ if ($lockReturn == false || $wouldBlock == true) {
+ \OC_Log::write('lock', sprintf('FAIL: Write lock failed, unable to exclusively lock new file %s', $this->path), \OC_Log::DEBUG);
+ return false;
+ }
+ $this->handle = $handle;
+ return true;
+ }
+
+
+ // Since this file does exist, wait for locks to release to get an exclusive lock
+ $timeout = Lock::$retries;
+ $haveBlock = false;
+ while ((!$lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock)) && $timeout > 0) {
+ // We don't have a lock on the original file, try to get a lock on its lock file
+ if ($haveBlock || $haveBlock = $this->lockLockFile($this->lockFile)) {
+ usleep(Lock::$retryInterval);
+ }
+ else {
+ \OC_Log::write('lock', sprintf('FAIL: Write lock failed, unable to lock original %s or lock file', $this->path), \OC_Log::DEBUG);
+ return false;
+ }
+ $timeout--;
+ }
+ if ($wouldBlock == true || $lockReturn == false) {
+ \OC_Log::write('lock', sprintf('FAIL: Write lock failed due to timeout on %s', $this->path), \OC_Log::DEBUG);
+ return false;
+ }
+ \OC_Log::write('lock', sprintf('PASS: Write lock succeeded on %s', $this->path), \OC_Log::DEBUG);
+
+ return true;
+ }
+
+ /**
+ * Create a lock file and lock it
+ * Sets $this->lockFile to the specified lock file, indicating that the lock file is IN USE for this lock instance
+ * Also sets $this->lockFileHandle to a file handle of the lock file
+ * @param string $filename The name of the file to lock
+ * @return bool False if lock can't be acquired, true if it can.
+ */
+ protected function lockLockFile ( $filename ) {
+ $lockFile = $this->getLockFile($filename);
+ \OC_Log::write('lock', sprintf('INFO: Locking lock file %s for %s', $lockFile, $filename), \OC_Log::DEBUG);
+
+ // If we already manage the lockfile, success
+ if(!empty($this->lockFile)) {
+ \OC_Log::write('lock', sprintf('PASS: Lock file %s was locked by this request for %s', $lockFile, $filename), \OC_Log::DEBUG);
+ return true;
+ }
+
+ // Check if the lockfile exists, and if not, try to create it
+ \OC_Log::write('lock', sprintf('INFO: Does lock file %s already exist? %s', $lockFile, file_exists($lockFile) ? 'yes' : 'no'), \OC_Log::DEBUG);
+ $handle = fopen($lockFile, 'c');
+ if(!$handle) {
+ \OC_Log::write('lock', sprintf('FAIL: Could not create lock file %s', $lockFile), \OC_Log::DEBUG);
+ return false;
+ }
+
+ // Attempt to acquire lock on lock file
+ $wouldBlock = false;
+ $timeout = self::$retries;
+ // Wait for lock over timeout
+ while((!$lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock)) && $timeout > 0) {
+ \OC_Log::write('lock', sprintf('FAIL: Could not acquire lock on lock file %s, %s timeout increments remain.', $lockFile, $timeout), \OC_Log::DEBUG);
+ usleep(self::$retryInterval);
+ $timeout--;
+ }
+ if ($wouldBlock == true || $lockReturn == false) {
+ \OC_Log::write('lock', sprintf('FAIL: Could not acquire lock on lock file %s', $lockFile), \OC_Log::DEBUG);
+ return false;
+ }
+ fwrite($handle, $filename);
+ \OC_Log::write('lock', sprintf('PASS: Wrote filename to lock lock file %s', $lockFile), \OC_Log::DEBUG);
+
+ $this->lockFile = $lockFile;
+ $this->lockFileHandle = $handle;
+
+ return true;
+ }
+
+ /**
+ * Add a lock of a specific type to the stack
+ * @param integer $lockType A constant representing the type of lock to queue
+ * @param null|resource $existingHandle An existing file handle from an fopen()
+ * @throws LockNotAcquiredException
+ */
+ public function addLock($lockType, $existingHandle = null) {
+ if(!isset($this->stack[$lockType])) {
+ switch($lockType) {
+ case Lock::READ:
+ $result = $this->obtainReadLock($existingHandle);
+ break;
+ case Lock::WRITE:
+ $result = $this->obtainWriteLock($existingHandle);
+ break;
+ default:
+ $result = false;
+ break;
+ }
+ if($result) {
+ $this->stack[$lockType] = 0;
+ }
+ else {
+ throw new LockNotAcquiredException($this->path, $lockType);
+ }
+ }
+
+ \OC_Log::write('lock', sprintf('INFO: Incrementing lock type %d count for %s', $lockType, $this->path), \OC_Log::DEBUG);
+ $this->stack[$lockType]++;
+
+ }
+
+ /**
+ * Release locks on handles and files
+ */
+ public function release($lockType) {
+ if(isset($this->stack[$lockType])) {
+ $this->stack[$lockType]--;
+ if($this->stack[$lockType] <= 0) {
+ unset($this->stack[$lockType]);
+ }
+ }
+
+ if(count($this->stack) == 0) {
+ // No more locks needed on this file, release the handle and/or lockfile
+ $this->releaseAll();
+ }
+
+ return true;
+ }
+
+
+ /**
+ * Get the lock file associated to a file
+ * @param string $filename The filename of the file to create a lock file for
+ * @return string The filename of the lock file
+ */
+ public static function getLockFile($filename) {
+ static $locksDir = false;
+ if(!$locksDir) {
+ $dataDir = Config::getSystemValue('datadirectory');
+ $locksDir = $dataDir . '/.locks';
+ if(!file_exists($locksDir)) {
+ mkdir($locksDir);
+ }
+ }
+ $filename = Filesystem::normalizePath($filename);
+ return $locksDir . '/' . sha1($filename) . '.lock';
+ }
+
+ /**
+ * Determine if a file has an associated and flocked lock file
+ * @param string $lockFile The filename of the lock file to check
+ * @return bool True if the lock file is flocked
+ */
+ protected function isLockFileLocked($lockFile) {
+ if(file_exists($lockFile)) {
+ if($handle = fopen($lockFile, 'c')) {
+ if($lock = flock($handle, LOCK_EX | LOCK_NB)) {
+ // Got lock, not blocking, release and unlink
+ unlink($lockFile);
+ fclose($handle);
+ flock($lock, LOCK_UN);
+ return false;
+ }
+ else {
+ return true;
+ }
+ }
+ else {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Release all queued locks on the file
+ * @return bool
+ */
+ public function releaseAll() {
+ $this->stack = array();
+ \OC_Log::write('lock', sprintf('INFO: Releasing locks on %s', $this->path), \OC_Log::DEBUG);
+ if (!empty($this->handle) && is_resource($this->handle)) {
+ flock($this->handle, LOCK_UN);
+ \OC_Log::write('lock', sprintf('INFO: Released lock handle %s on %s', $this->handle, $this->path), \OC_Log::DEBUG);
+ $this->handle = null;
+ }
+ if (!empty($this->lockFile) && file_exists($this->lockFile)) {
+ unlink($this->lockFile);
+ \OC_Log::write('lock', sprintf('INFO: Released lock file %s on %s', $this->lockFile, $this->path), \OC_Log::DEBUG);
+ $this->lockFile = null;
+ }
+ \OC_Log::write('lock', sprintf('FREE: Released locks on %s', $this->path), \OC_Log::DEBUG);
+ return true;
+ }
+
+ public function __destruct() {
+ // Only releaseAll if we have locks to release
+ if(!empty($this->handle) || !empty($this->lockFile)) {
+ \OC_Log::write('lock', sprintf('INFO: Destroying locks on %s', $this->path), \OC_Log::DEBUG);
+ $this->releaseAll();
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/lib/private/files/storage/wrapper/lockingwrapper.php b/lib/private/files/storage/wrapper/lockingwrapper.php
index 4f41c528253d21cd35796afea7e8e0da6edb1d5e..428c2c516a42a07c404914c78d537c264dc3b952 100644
--- a/lib/private/files/storage/wrapper/lockingwrapper.php
+++ b/lib/private/files/storage/wrapper/lockingwrapper.php
@@ -10,7 +10,7 @@
namespace OC\Files\Storage\Wrapper;
use OC\Files\Filesystem;
-use OCP\Files\Lock;
+use OC\Files\Lock;
/**
* Class LockingWrapper
@@ -23,7 +23,7 @@ use OCP\Files\Lock;
*/
class LockingWrapper extends Wrapper {
- /** @var array $locks Holds an array of lock instances indexed by path for this storage */
+ /** @var \OCP\Files\Lock[] $locks Holds an array of lock instances indexed by path for this storage */
protected $locks = array();
/**
diff --git a/lib/public/files/lock.php b/lib/public/files/lock.php
index 196134724d30397be17959af3d2a18367808b292..34d307e89394ddfec6d9d3f104cebd3e094edf5f 100644
--- a/lib/public/files/lock.php
+++ b/lib/public/files/lock.php
@@ -18,169 +18,20 @@
namespace OCP\Files;
-use OCP\Config;
-use OC\Files\Filesystem;
-
/**
* Class Lock
* @package OC\Files
*/
-class Lock {
+interface Lock {
const READ = 1;
const WRITE = 2;
- /** @var int $retries Number of lock retries to attempt */
- public static $retries = 40;
-
- /** @var int $retryInterval Milliseconds between retries */
- public static $retryInterval = 50;
-
- /** @var string $path Filename of the file as represented in storage */
- protected $path;
-
- /** @var array $stack A stack of lock data */
- protected $stack = array();
-
- /** @var resource $handle A file handle used to maintain a lock */
- protected $handle;
-
- /** @var string $lockFile Filename of the lock file */
- protected $lockFile;
-
- /** @var resource $lockFileHandle The file handle used to maintain a lock on the lock file */
- protected $lockFileHandle;
-
/**
* Constructor for the lock instance
* @param string $path Absolute pathname for a local file on which to obtain a lock
*/
- public function __construct($path) {
- $this->path = Filesystem::normalizePath($path);
- }
-
- protected function obtainReadLock($existingHandle = null) {
- \OC_Log::write('lock', sprintf('INFO: Read lock requested for %s', $this->path), \OC_Log::DEBUG);
- $timeout = Lock::$retries;
-
- // Re-use an existing handle or get a new one
- if(empty($existingHandle)) {
- $handle = fopen($this->path, 'r');
- }
- else {
- $handle = $existingHandle;
- }
-
- do {
- if($this->isLockFileLocked($this->getLockFile($this->path))) {
- \OC_Log::write('lock', sprintf('INFO: Read lock has locked lock file %s for %s', $this->getLockFile($this->path), $this->path), \OC_Log::DEBUG);
- do {
- usleep(Lock::$retryInterval);
- $timeout--;
- } while($this->isLockFileLocked($this->getLockFile($this->path)) && $timeout > 0);
- \OC_Log::write('lock', sprintf('INFO: Lock file %s has become unlocked for %s', $this->getLockFile($this->path), $this->path), \OC_Log::DEBUG);
- }
- } while ((!$lockReturn = flock($handle, LOCK_SH | LOCK_NB, $wouldBlock)) && $timeout > 0);
- if ($wouldBlock == true || $lockReturn == false || $timeout <= 0) {
- \OC_Log::write('lock', sprintf('FAIL: Failed to acquire read lock for %s', $this->path), \OC_Log::DEBUG);
- return false;
- }
- $this->handle = $handle;
- \OC_Log::write('lock', sprintf('PASS: Acquired read lock for %s', $this->path), \OC_Log::DEBUG);
- return true;
- }
-
- protected function obtainWriteLock($existingHandle = null) {
- \OC_Log::write('lock', sprintf('INFO: Write lock requested for %s', $this->path), \OC_Log::DEBUG);
-
- // Re-use an existing handle or get a new one
- if (empty($existingHandle)) {
- $handle = fopen($this->path, 'c');
- }
- else {
- $handle = $existingHandle;
- }
-
- // If the file doesn't exist, but we can create a lock for it
- if (!file_exists($this->path) && $this->lockLockFile($this->path)) {
- $lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock);
- if ($lockReturn == false || $wouldBlock == true) {
- \OC_Log::write('lock', sprintf('FAIL: Write lock failed, unable to exclusively lock new file %s', $this->path), \OC_Log::DEBUG);
- return false;
- }
- $this->handle = $handle;
- return true;
- }
-
-
- // Since this file does exist, wait for locks to release to get an exclusive lock
- $timeout = Lock::$retries;
- $haveBlock = false;
- while ((!$lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock)) && $timeout > 0) {
- // We don't have a lock on the original file, try to get a lock on its lock file
- if ($haveBlock || $haveBlock = $this->lockLockFile($this->lockFile)) {
- usleep(Lock::$retryInterval);
- }
- else {
- \OC_Log::write('lock', sprintf('FAIL: Write lock failed, unable to lock original %s or lock file', $this->path), \OC_Log::DEBUG);
- return false;
- }
- $timeout--;
- }
- if ($wouldBlock == true || $lockReturn == false) {
- \OC_Log::write('lock', sprintf('FAIL: Write lock failed due to timeout on %s', $this->path), \OC_Log::DEBUG);
- return false;
- }
- \OC_Log::write('lock', sprintf('PASS: Write lock succeeded on %s', $this->path), \OC_Log::DEBUG);
-
- return true;
- }
-
- /**
- * Create a lock file and lock it
- * Sets $this->lockFile to the specified lock file, indicating that the lock file is IN USE for this lock instance
- * Also sets $this->lockFileHandle to a file handle of the lock file
- * @param string $filename The name of the file to lock
- * @return bool False if lock can't be acquired, true if it can.
- */
- protected function lockLockFile ( $filename ) {
- $lockFile = $this->getLockFile($filename);
- \OC_Log::write('lock', sprintf('INFO: Locking lock file %s for %s', $lockFile, $filename), \OC_Log::DEBUG);
-
- // If we already manage the lockfile, success
- if(!empty($this->lockFile)) {
- \OC_Log::write('lock', sprintf('PASS: Lock file %s was locked by this request for %s', $lockFile, $filename), \OC_Log::DEBUG);
- return true;
- }
-
- // Check if the lockfile exists, and if not, try to create it
- \OC_Log::write('lock', sprintf('INFO: Does lock file %s already exist? %s', $lockFile, file_exists($lockFile) ? 'yes' : 'no'), \OC_Log::DEBUG);
- $handle = fopen($lockFile, 'c');
- if(!$handle) {
- \OC_Log::write('lock', sprintf('FAIL: Could not create lock file %s', $lockFile), \OC_Log::DEBUG);
- return false;
- }
-
- // Attempt to acquire lock on lock file
- $wouldBlock = false;
- $timeout = self::$retries;
- // Wait for lock over timeout
- while((!$lockReturn = flock($handle, LOCK_EX | LOCK_NB, $wouldBlock)) && $timeout > 0) {
- \OC_Log::write('lock', sprintf('FAIL: Could not acquire lock on lock file %s, %s timeout increments remain.', $lockFile, $timeout), \OC_Log::DEBUG);
- usleep(self::$retryInterval);
- $timeout--;
- }
- if ($wouldBlock == true || $lockReturn == false) {
- \OC_Log::write('lock', sprintf('FAIL: Could not acquire lock on lock file %s', $lockFile), \OC_Log::DEBUG);
- return false;
- }
- fwrite($handle, $filename);
- \OC_Log::write('lock', sprintf('PASS: Wrote filename to lock lock file %s', $lockFile), \OC_Log::DEBUG);
-
- $this->lockFile = $lockFile;
- $this->lockFileHandle = $handle;
+ public function __construct($path);
- return true;
- }
/**
* Add a lock of a specific type to the stack
@@ -188,50 +39,12 @@ class Lock {
* @param null|resource $existingHandle An existing file handle from an fopen()
* @throws LockNotAcquiredException
*/
- public function addLock($lockType, $existingHandle = null) {
- if(!isset($this->stack[$lockType])) {
- switch($lockType) {
- case Lock::READ:
- $result = $this->obtainReadLock($existingHandle);
- break;
- case Lock::WRITE:
- $result = $this->obtainWriteLock($existingHandle);
- break;
- default:
- $result = false;
- break;
- }
- if($result) {
- $this->stack[$lockType] = 0;
- }
- else {
- throw new LockNotAcquiredException($this->path, $lockType);
- }
- }
-
- \OC_Log::write('lock', sprintf('INFO: Incrementing lock type %d count for %s', $lockType, $this->path), \OC_Log::DEBUG);
- $this->stack[$lockType]++;
-
- }
+ public function addLock($lockType, $existingHandle = null);
/**
* Release locks on handles and files
*/
- public function release($lockType) {
- if(isset($this->stack[$lockType])) {
- $this->stack[$lockType]--;
- if($this->stack[$lockType] <= 0) {
- unset($this->stack[$lockType]);
- }
- }
-
- if(count($this->stack) == 0) {
- // No more locks needed on this file, release the handle and/or lockfile
- $this->releaseAll();
- }
-
- return true;
- }
+ public function release($lockType);
/**
@@ -239,72 +52,12 @@ class Lock {
* @param string $filename The filename of the file to create a lock file for
* @return string The filename of the lock file
*/
- public static function getLockFile($filename) {
- static $locksDir = false;
- if(!$locksDir) {
- $dataDir = Config::getSystemValue('datadirectory');
- $locksDir = $dataDir . '/.locks';
- if(!file_exists($locksDir)) {
- mkdir($locksDir);
- }
- }
- $filename = Filesystem::normalizePath($filename);
- return $locksDir . '/' . sha1($filename) . '.lock';
- }
-
- /**
- * Determine if a file has an associated and flocked lock file
- * @param string $lockFile The filename of the lock file to check
- * @return bool True if the lock file is flocked
- */
- protected function isLockFileLocked($lockFile) {
- if(file_exists($lockFile)) {
- if($handle = fopen($lockFile, 'c')) {
- if($lock = flock($handle, LOCK_EX | LOCK_NB)) {
- // Got lock, not blocking, release and unlink
- unlink($lockFile);
- fclose($handle);
- flock($lock, LOCK_UN);
- return false;
- }
- else {
- return true;
- }
- }
- else {
- return true;
- }
- }
- return false;
- }
+ public static function getLockFile($filename);
/**
* Release all queued locks on the file
* @return bool
*/
- public function releaseAll() {
- $this->stack = array();
- \OC_Log::write('lock', sprintf('INFO: Releasing locks on %s', $this->path), \OC_Log::DEBUG);
- if (!empty($this->handle) && is_resource($this->handle)) {
- flock($this->handle, LOCK_UN);
- \OC_Log::write('lock', sprintf('INFO: Released lock handle %s on %s', $this->handle, $this->path), \OC_Log::DEBUG);
- $this->handle = null;
- }
- if (!empty($this->lockFile) && file_exists($this->lockFile)) {
- unlink($this->lockFile);
- \OC_Log::write('lock', sprintf('INFO: Released lock file %s on %s', $this->lockFile, $this->path), \OC_Log::DEBUG);
- $this->lockFile = null;
- }
- \OC_Log::write('lock', sprintf('FREE: Released locks on %s', $this->path), \OC_Log::DEBUG);
- return true;
- }
-
- public function __destruct() {
- // Only releaseAll if we have locks to release
- if(!empty($this->handle) || !empty($this->lockFile)) {
- \OC_Log::write('lock', sprintf('INFO: Destroying locks on %s', $this->path), \OC_Log::DEBUG);
- $this->releaseAll();
- }
- }
+ public function releaseAll();
}
\ No newline at end of file