* Only use hash keys later on in the data flow rather than right when doLock() is called. This allows for error messages in Status objects to use human readable paths rather than ugly hash keys.
* Moved $locksHeld declaration duplication up to the base class.
* Fixed __destruct() in FSLockManager to not use bogus doSingleUnlock() lock type parameter.
protected $safeDelay; // integer number of seconds
protected $session = 0; // random integer
- /** @var Array Map of (locked key => lock type => count) */
- protected $locksHeld = array();
/** @var Array Map Database connections (DB name => Database) */
protected $conns = array();
$this->session = wfBaseConvert( sha1( $this->session ), 16, 36, 31 );
}
- protected function doLock( array $keys, $type ) {
+ /**
+ * @see LockManager::doLock()
+ */
+ protected function doLock( array $paths, $type ) {
$status = Status::newGood();
- $keysToLock = array();
+ $pathsToLock = array();
// Get locks that need to be acquired (buckets => locks)...
- foreach ( $keys as $key ) {
- if ( isset( $this->locksHeld[$key][$type] ) ) {
- ++$this->locksHeld[$key][$type];
- } elseif ( isset( $this->locksHeld[$key][self::LOCK_EX] ) ) {
- $this->locksHeld[$key][$type] = 1;
+ foreach ( $paths as $path ) {
+ if ( isset( $this->locksHeld[$path][$type] ) ) {
+ ++$this->locksHeld[$path][$type];
+ } elseif ( isset( $this->locksHeld[$path][self::LOCK_EX] ) ) {
+ $this->locksHeld[$path][$type] = 1;
} else {
- $bucket = $this->getBucketFromKey( $key );
- $keysToLock[$bucket][] = $key;
+ $bucket = $this->getBucketFromKey( $path );
+ $pathsToLock[$bucket][] = $path;
}
}
- $lockedKeys = array(); // files locked in this attempt
+ $lockedPaths = array(); // files locked in this attempt
// Attempt to acquire these locks...
- foreach ( $keysToLock as $bucket => $keys ) {
+ foreach ( $pathsToLock as $bucket => $paths ) {
// Try to acquire the locks for this bucket
- $res = $this->doLockingQueryAll( $bucket, $keys, $type );
+ $res = $this->doLockingQueryAll( $bucket, $paths, $type );
if ( $res === 'cantacquire' ) {
// Resources already locked by another process.
// Abort and unlock everything we just locked.
- $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $keys ) );
- $status->merge( $this->doUnlock( $lockedKeys, $type ) );
+ $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $paths ) );
+ $status->merge( $this->doUnlock( $lockedPaths, $type ) );
return $status;
} elseif ( $res !== true ) {
// Couldn't contact any DBs for this bucket.
// Abort and unlock everything we just locked.
$status->fatal( 'lockmanager-fail-db-bucket', $bucket );
- $status->merge( $this->doUnlock( $lockedKeys, $type ) );
+ $status->merge( $this->doUnlock( $lockedPaths, $type ) );
return $status;
}
// Record these locks as active
- foreach ( $keys as $key ) {
- $this->locksHeld[$key][$type] = 1; // locked
+ foreach ( $paths as $path ) {
+ $this->locksHeld[$path][$type] = 1; // locked
}
// Keep track of what locks were made in this attempt
- $lockedKeys = array_merge( $lockedKeys, $keys );
+ $lockedPaths = array_merge( $lockedPaths, $paths );
}
return $status;
}
- protected function doUnlock( array $keys, $type ) {
+ /**
+ * @see LockManager::doUnlock()
+ */
+ protected function doUnlock( array $paths, $type ) {
$status = Status::newGood();
- foreach ( $keys as $key ) {
- if ( !isset( $this->locksHeld[$key] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
- } elseif ( !isset( $this->locksHeld[$key][$type] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
+ foreach ( $paths as $path ) {
+ if ( !isset( $this->locksHeld[$path] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
+ } elseif ( !isset( $this->locksHeld[$path][$type] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
} else {
- --$this->locksHeld[$key][$type];
- if ( $this->locksHeld[$key][$type] <= 0 ) {
- unset( $this->locksHeld[$key][$type] );
+ --$this->locksHeld[$path][$type];
+ if ( $this->locksHeld[$path][$type] <= 0 ) {
+ unset( $this->locksHeld[$path][$type] );
}
- if ( !count( $this->locksHeld[$key] ) ) {
- unset( $this->locksHeld[$key] ); // no SH or EX locks left for key
+ if ( !count( $this->locksHeld[$path] ) ) {
+ unset( $this->locksHeld[$path] ); // no SH or EX locks left for key
}
}
}
}
/**
- * Get a connection to a lock DB and acquire locks on $keys.
+ * Get a connection to a lock DB and acquire locks on $paths.
* This does not use GET_LOCK() per http://bugs.mysql.com/bug.php?id=1118.
*
* @param $lockDb string
- * @param $keys Array
+ * @param $paths Array
* @param $type integer LockManager::LOCK_EX or LockManager::LOCK_SH
* @return bool Resources able to be locked
* @throws DBError
*/
- protected function doLockingQuery( $lockDb, array $keys, $type ) {
+ protected function doLockingQuery( $lockDb, array $paths, $type ) {
if ( $type == self::LOCK_EX ) { // writer locks
$db = $this->getConnection( $lockDb );
if ( !$db ) {
return false; // bad config
}
+ $keys = array_unique( array_map( 'LockManager::sha1Base36', $paths ) );
+ # Build up values for INSERT clause
$data = array();
foreach ( $keys as $key ) {
$data[] = array( 'fle_key' => $key );
* This should avoid throwing any exceptions.
*
* @param $bucket integer
- * @param $keys Array List of resource keys to lock
+ * @param $paths Array List of resource keys to lock
* @param $type integer LockManager::LOCK_EX or LockManager::LOCK_SH
* @return bool|string One of (true, 'cantacquire', 'dberrors')
*/
- protected function doLockingQueryAll( $bucket, array $keys, $type ) {
+ protected function doLockingQueryAll( $bucket, array $paths, $type ) {
$yesVotes = 0; // locks made on trustable DBs
$votesLeft = count( $this->dbsByBucket[$bucket] ); // remaining DBs
$quorum = floor( $votesLeft/2 + 1 ); // simple majority
if ( $this->cacheCheckFailures( $lockDb ) ) {
try {
// Attempt to acquire the lock on this DB
- if ( !$this->doLockingQuery( $lockDb, $keys, $type ) ) {
+ if ( !$this->doLockingQuery( $lockDb, $paths, $type ) ) {
return 'cantacquire'; // vetoed; resource locked
}
++$yesVotes; // success for this peer
}
}
}
- $votesLeft--;
+ --$votesLeft;
$votesNeeded = $quorum - $yesVotes;
if ( $votesNeeded > $votesLeft ) {
// In "trust cache" mode we don't have to meet the quorum
*/
protected function cacheCheckFailures( $lockDb ) {
if ( $this->statusCache && $this->safeDelay > 0 ) {
- $key = $this->getMissKey( $lockDb );
- $misses = $this->statusCache->get( $key );
+ $path = $this->getMissKey( $lockDb );
+ $misses = $this->statusCache->get( $path );
return !$misses;
}
return true;
*/
protected function cacheRecordFailure( $lockDb ) {
if ( $this->statusCache && $this->safeDelay > 0 ) {
- $key = $this->getMissKey( $lockDb );
- $misses = $this->statusCache->get( $key );
+ $path = $this->getMissKey( $lockDb );
+ $misses = $this->statusCache->get( $path );
if ( $misses ) {
- return $this->statusCache->incr( $key );
+ return $this->statusCache->incr( $path );
} else {
- return $this->statusCache->add( $key, 1, $this->safeDelay );
+ return $this->statusCache->add( $path, 1, $this->safeDelay );
}
}
return true;
}
/**
- * Get the bucket for lock key.
+ * Get the bucket for resource path.
* This should avoid throwing any exceptions.
*
- * @param $key string (31 char hex key)
+ * @param $path string
* @return integer
*/
- protected function getBucketFromKey( $key ) {
- $prefix = substr( $key, 0, 2 ); // first 2 hex chars (8 bits)
+ protected function getBucketFromKey( $path ) {
+ $prefix = substr( sha1( $path ), 0, 2 ); // first 2 hex chars (8 bits)
return intval( base_convert( $prefix, 16, 10 ) ) % count( $this->dbsByBucket );
}
$db->query( "SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;" );
}
- protected function doLockingQuery( $lockDb, array $keys, $type ) {
+ protected function doLockingQuery( $lockDb, array $paths, $type ) {
$db = $this->getConnection( $lockDb );
if ( !$db ) {
return false;
}
+ $keys = array_unique( array_map( 'LockManager::sha1Base36', $paths ) );
+ # Build up values for INSERT clause
$data = array();
foreach ( $keys as $key ) {
$data[] = array( 'fls_key' => $key, 'fls_session' => $this->session );
__METHOD__
);
if ( !$blocked ) {
+ # Build up values for INSERT clause
$data = array();
foreach ( $keys as $key ) {
$data[] = array( 'fle_key' => $key );
protected $lockDir; // global dir for all servers
- /** @var Array Map of (locked key => lock type => count) */
- protected $locksHeld = array();
/** @var Array Map of (locked key => lock type => lock file handle) */
protected $handles = array();
$this->lockDir = $config['lockDirectory'];
}
- protected function doLock( array $keys, $type ) {
+ protected function doLock( array $paths, $type ) {
$status = Status::newGood();
- $lockedKeys = array(); // files locked in this attempt
- foreach ( $keys as $key ) {
- $subStatus = $this->doSingleLock( $key, $type );
+ $lockedPaths = array(); // files locked in this attempt
+ foreach ( $paths as $path ) {
+ $subStatus = $this->doSingleLock( $path, $type );
$status->merge( $subStatus );
if ( $status->isOK() ) {
- // Don't append to $lockedKeys if $key is already locked.
+ // Don't append to $lockedPaths if $path is already locked.
// We do NOT want to unlock the key if we have to rollback.
if ( $subStatus->isGood() ) { // no warnings/fatals?
- $lockedKeys[] = $key;
+ $lockedPaths[] = $path;
}
} else {
// Abort and unlock everything
- $status->merge( $this->doUnlock( $lockedKeys, $type ) );
+ $status->merge( $this->doUnlock( $lockedPaths, $type ) );
return $status;
}
}
return $status;
}
- protected function doUnlock( array $keys, $type ) {
+ protected function doUnlock( array $paths, $type ) {
$status = Status::newGood();
- foreach ( $keys as $key ) {
- $status->merge( $this->doSingleUnlock( $key, $type ) );
+ foreach ( $paths as $path ) {
+ $status->merge( $this->doSingleUnlock( $path, $type ) );
}
return $status;
/**
* Lock a single resource key
*
- * @param $key string
+ * @param $path string
* @param $type integer
* @return Status
*/
- protected function doSingleLock( $key, $type ) {
+ protected function doSingleLock( $path, $type ) {
$status = Status::newGood();
- if ( isset( $this->locksHeld[$key][$type] ) ) {
- ++$this->locksHeld[$key][$type];
- } elseif ( isset( $this->locksHeld[$key][self::LOCK_EX] ) ) {
- $this->locksHeld[$key][$type] = 1;
+ if ( isset( $this->locksHeld[$path][$type] ) ) {
+ ++$this->locksHeld[$path][$type];
+ } elseif ( isset( $this->locksHeld[$path][self::LOCK_EX] ) ) {
+ $this->locksHeld[$path][$type] = 1;
} else {
wfSuppressWarnings();
- $handle = fopen( $this->getLockPath( $key ), 'a+' );
+ $handle = fopen( $this->getLockPath( $path ), 'a+' );
wfRestoreWarnings();
if ( !$handle ) { // lock dir missing?
wfMkdirParents( $this->lockDir );
- $handle = fopen( $this->getLockPath( $key ), 'a+' ); // try again
+ $handle = fopen( $this->getLockPath( $path ), 'a+' ); // try again
}
if ( $handle ) {
// Either a shared or exclusive lock
$lock = ( $type == self::LOCK_SH ) ? LOCK_SH : LOCK_EX;
if ( flock( $handle, $lock | LOCK_NB ) ) {
// Record this lock as active
- $this->locksHeld[$key][$type] = 1;
- $this->handles[$key][$type] = $handle;
+ $this->locksHeld[$path][$type] = 1;
+ $this->handles[$path][$type] = $handle;
} else {
fclose( $handle );
- $status->fatal( 'lockmanager-fail-acquirelock', $key );
+ $status->fatal( 'lockmanager-fail-acquirelock', $path );
}
} else {
- $status->fatal( 'lockmanager-fail-openlock', $key );
+ $status->fatal( 'lockmanager-fail-openlock', $path );
}
}
/**
* Unlock a single resource key
*
- * @param $key string
+ * @param $path string
* @param $type integer
* @return Status
*/
- protected function doSingleUnlock( $key, $type ) {
+ protected function doSingleUnlock( $path, $type ) {
$status = Status::newGood();
- if ( !isset( $this->locksHeld[$key] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
- } elseif ( !isset( $this->locksHeld[$key][$type] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
+ if ( !isset( $this->locksHeld[$path] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
+ } elseif ( !isset( $this->locksHeld[$path][$type] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
} else {
$handlesToClose = array();
- --$this->locksHeld[$key][$type];
- if ( $this->locksHeld[$key][$type] <= 0 ) {
- unset( $this->locksHeld[$key][$type] );
+ --$this->locksHeld[$path][$type];
+ if ( $this->locksHeld[$path][$type] <= 0 ) {
+ unset( $this->locksHeld[$path][$type] );
// If a LOCK_SH comes in while we have a LOCK_EX, we don't
// actually add a handler, so check for handler existence.
- if ( isset( $this->handles[$key][$type] ) ) {
+ if ( isset( $this->handles[$path][$type] ) ) {
// Mark this handle to be unlocked and closed
- $handlesToClose[] = $this->handles[$key][$type];
- unset( $this->handles[$key][$type] );
+ $handlesToClose[] = $this->handles[$path][$type];
+ unset( $this->handles[$path][$type] );
}
}
// Unlock handles to release locks and delete
if ( wfIsWindows() ) {
// Windows: for any process, including this one,
// calling unlink() on a locked file will fail
- $status->merge( $this->closeLockHandles( $key, $handlesToClose ) );
- $status->merge( $this->pruneKeyLockFiles( $key ) );
+ $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
+ $status->merge( $this->pruneKeyLockFiles( $path ) );
} else {
// Unix: unlink() can be used on files currently open by this
// process and we must do so in order to avoid race conditions
- $status->merge( $this->pruneKeyLockFiles( $key ) );
- $status->merge( $this->closeLockHandles( $key, $handlesToClose ) );
+ $status->merge( $this->pruneKeyLockFiles( $path ) );
+ $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
}
}
return $status;
}
- private function closeLockHandles( $key, array $handlesToClose ) {
+ private function closeLockHandles( $path, array $handlesToClose ) {
$status = Status::newGood();
foreach ( $handlesToClose as $handle ) {
wfSuppressWarnings();
if ( !flock( $handle, LOCK_UN ) ) {
- $status->fatal( 'lockmanager-fail-releaselock', $key );
+ $status->fatal( 'lockmanager-fail-releaselock', $path );
}
if ( !fclose( $handle ) ) {
- $status->warning( 'lockmanager-fail-closelock', $key );
+ $status->warning( 'lockmanager-fail-closelock', $path );
}
wfRestoreWarnings();
}
return $status;
}
- private function pruneKeyLockFiles( $key ) {
+ private function pruneKeyLockFiles( $path ) {
$status = Status::newGood();
- if ( !count( $this->locksHeld[$key] ) ) {
+ if ( !count( $this->locksHeld[$path] ) ) {
wfSuppressWarnings();
# No locks are held for the lock file anymore
- if ( !unlink( $this->getLockPath( $key ) ) ) {
- $status->warning( 'lockmanager-fail-deletelock', $key );
+ if ( !unlink( $this->getLockPath( $path ) ) ) {
+ $status->warning( 'lockmanager-fail-deletelock', $path );
}
wfRestoreWarnings();
- unset( $this->locksHeld[$key] );
- unset( $this->handles[$key] );
+ unset( $this->locksHeld[$path] );
+ unset( $this->handles[$path] );
}
return $status;
}
/**
* Get the path to the lock file for a key
- * @param $key string
+ * @param $path string
* @return string
*/
- protected function getLockPath( $key ) {
- return "{$this->lockDir}/{$key}.lock";
+ protected function getLockPath( $path ) {
+ $hash = self::sha1Base36( $path );
+ return "{$this->lockDir}/{$hash}.lock";
}
function __destruct() {
// Make sure remaining locks get cleared for sanity
- foreach ( $this->locksHeld as $key => $locks ) {
- $this->doSingleUnlock( $key, 0 );
+ foreach ( $this->locksHeld as $path => $locks ) {
+ $this->doSingleUnlock( $path, self::LOCK_EX );
+ $this->doSingleUnlock( $path, self::LOCK_SH );
}
}
}
/** @var Array Map of bucket indexes to peer server lists */
protected $srvsByBucket; // (bucket index => (lsrv1, lsrv2, ...))
- /** @var Array Map of (locked key => lock type => count) */
- protected $locksHeld = array();
/** @var Array Map Server connections (server name => resource) */
protected $conns = array();
$this->session = wfBaseConvert( sha1( $this->session ), 16, 36, 31 );
}
- protected function doLock( array $keys, $type ) {
+ protected function doLock( array $paths, $type ) {
$status = Status::newGood();
- $keysToLock = array();
+ $pathsToLock = array();
// Get locks that need to be acquired (buckets => locks)...
- foreach ( $keys as $key ) {
- if ( isset( $this->locksHeld[$key][$type] ) ) {
- ++$this->locksHeld[$key][$type];
- } elseif ( isset( $this->locksHeld[$key][self::LOCK_EX] ) ) {
- $this->locksHeld[$key][$type] = 1;
+ foreach ( $paths as $path ) {
+ if ( isset( $this->locksHeld[$path][$type] ) ) {
+ ++$this->locksHeld[$path][$type];
+ } elseif ( isset( $this->locksHeld[$path][self::LOCK_EX] ) ) {
+ $this->locksHeld[$path][$type] = 1;
} else {
- $bucket = $this->getBucketFromKey( $key );
- $keysToLock[$bucket][] = $key;
+ $bucket = $this->getBucketFromKey( $path );
+ $pathsToLock[$bucket][] = $path;
}
}
- $lockedKeys = array(); // files locked in this attempt
+ $lockedPaths = array(); // files locked in this attempt
// Attempt to acquire these locks...
- foreach ( $keysToLock as $bucket => $keys ) {
+ foreach ( $pathsToLock as $bucket => $paths ) {
// Try to acquire the locks for this bucket
- $res = $this->doLockingRequestAll( $bucket, $keys, $type );
+ $res = $this->doLockingRequestAll( $bucket, $paths, $type );
if ( $res === 'cantacquire' ) {
// Resources already locked by another process.
// Abort and unlock everything we just locked.
- $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $keys ) );
- $status->merge( $this->doUnlock( $lockedKeys, $type ) );
+ $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $paths ) );
+ $status->merge( $this->doUnlock( $lockedPaths, $type ) );
return $status;
} elseif ( $res !== true ) {
// Couldn't contact any servers for this bucket.
// Abort and unlock everything we just locked.
- $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $keys ) );
- $status->merge( $this->doUnlock( $lockedKeys, $type ) );
+ $status->fatal( 'lockmanager-fail-acquirelocks', implode( ', ', $paths ) );
+ $status->merge( $this->doUnlock( $lockedPaths, $type ) );
return $status;
}
// Record these locks as active
- foreach ( $keys as $key ) {
- $this->locksHeld[$key][$type] = 1; // locked
+ foreach ( $paths as $path ) {
+ $this->locksHeld[$path][$type] = 1; // locked
}
// Keep track of what locks were made in this attempt
- $lockedKeys = array_merge( $lockedKeys, $keys );
+ $lockedPaths = array_merge( $lockedPaths, $paths );
}
return $status;
}
- protected function doUnlock( array $keys, $type ) {
+ protected function doUnlock( array $paths, $type ) {
$status = Status::newGood();
- foreach ( $keys as $key ) {
- if ( !isset( $this->locksHeld[$key] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
- } elseif ( !isset( $this->locksHeld[$key][$type] ) ) {
- $status->warning( 'lockmanager-notlocked', $key );
+ foreach ( $paths as $path ) {
+ if ( !isset( $this->locksHeld[$path] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
+ } elseif ( !isset( $this->locksHeld[$path][$type] ) ) {
+ $status->warning( 'lockmanager-notlocked', $path );
} else {
- --$this->locksHeld[$key][$type];
- if ( $this->locksHeld[$key][$type] <= 0 ) {
- unset( $this->locksHeld[$key][$type] );
+ --$this->locksHeld[$path][$type];
+ if ( $this->locksHeld[$path][$type] <= 0 ) {
+ unset( $this->locksHeld[$path][$type] );
}
- if ( !count( $this->locksHeld[$key] ) ) {
- unset( $this->locksHeld[$key] ); // no SH or EX locks left for key
+ if ( !count( $this->locksHeld[$path] ) ) {
+ unset( $this->locksHeld[$path] ); // no SH or EX locks left for key
}
}
}
}
/**
- * Get a connection to a lock server and acquire locks on $keys
+ * Get a connection to a lock server and acquire locks on $paths
*
* @param $lockSrv string
- * @param $keys Array
+ * @param $paths Array
* @param $type integer LockManager::LOCK_EX or LockManager::LOCK_SH
* @return bool Resources able to be locked
*/
- protected function doLockingRequest( $lockSrv, array $keys, $type ) {
+ protected function doLockingRequest( $lockSrv, array $paths, $type ) {
if ( $type == self::LOCK_SH ) { // reader locks
$type = 'SH';
} elseif ( $type == self::LOCK_EX ) { // writer locks
}
// Send out the command and get the response...
+ $keys = array_unique( array_map( 'LockManager::sha1Base36', $paths ) );
$response = $this->sendCommand( $lockSrv, 'ACQUIRE', $type, $keys );
return ( $response === 'ACQUIRED' );
* Attempt to acquire locks with the peers for a bucket
*
* @param $bucket integer
- * @param $keys Array List of resource keys to lock
+ * @param $paths Array List of resource keys to lock
* @param $type integer LockManager::LOCK_EX or LockManager::LOCK_SH
* @return bool|string One of (true, 'cantacquire', 'srverrors')
*/
- protected function doLockingRequestAll( $bucket, array $keys, $type ) {
+ protected function doLockingRequestAll( $bucket, array $paths, $type ) {
$yesVotes = 0; // locks made on trustable servers
$votesLeft = count( $this->srvsByBucket[$bucket] ); // remaining peers
$quorum = floor( $votesLeft/2 + 1 ); // simple majority
// Get votes for each peer, in order, until we have enough...
foreach ( $this->srvsByBucket[$bucket] as $index => $lockSrv ) {
// Attempt to acquire the lock on this peer
- if ( !$this->doLockingRequest( $lockSrv, $keys, $type ) ) {
+ if ( !$this->doLockingRequest( $lockSrv, $paths, $type ) ) {
return 'cantacquire'; // vetoed; resource locked
}
++$yesVotes; // success for this peer
if ( $yesVotes >= $quorum ) {
return true; // lock obtained
}
- $votesLeft--;
+ --$votesLeft;
$votesNeeded = $quorum - $yesVotes;
if ( $votesNeeded > $votesLeft ) {
// In "trust cache" mode we don't have to meet the quorum
}
/**
- * Get the bucket for lock key
+ * Get the bucket for resource path.
+ * This should avoid throwing any exceptions.
*
- * @param $key string (31 char hex key)
+ * @param $path string
* @return integer
*/
- protected function getBucketFromKey( $key ) {
- $prefix = substr( $key, 0, 2 ); // first 2 hex chars (8 bits)
- return intval( base_convert( $prefix, 16, 10 ) ) % count( $this->srvsByBucket );
+ protected function getBucketFromKey( $path ) {
+ $prefix = substr( sha1( $path ), 0, 2 ); // first 2 hex chars (8 bits)
+ return intval( base_convert( $prefix, 16, 10 ) ) % count( $this->dbsByBucket );
}
/**
* @since 1.19
*/
abstract class LockManager {
- /* Lock types; stronger locks have higher values */
- const LOCK_SH = 1; // shared lock (for reads)
- const LOCK_UW = 2; // shared lock (for reads used to write elsewhere)
- const LOCK_EX = 3; // exclusive lock (for writes)
-
/** @var Array Mapping of lock types to the type actually used */
protected $lockTypeMap = array(
self::LOCK_SH => self::LOCK_SH,
self::LOCK_EX => self::LOCK_EX
);
+ /** @var Array Map of (resource path => lock type => count) */
+ protected $locksHeld = array();
+
+ /* Lock types; stronger locks have higher values */
+ const LOCK_SH = 1; // shared lock (for reads)
+ const LOCK_UW = 2; // shared lock (for reads used to write elsewhere)
+ const LOCK_EX = 3; // exclusive lock (for writes)
+
/**
* Construct a new instance from configuration
*
* @return Status
*/
final public function lock( array $paths, $type = self::LOCK_EX ) {
- $keys = array_unique( array_map( 'LockManager::sha1Base36', $paths ) );
- return $this->doLock( $keys, $this->lockTypeMap[$type] );
+ return $this->doLock( array_unique( $paths ), $this->lockTypeMap[$type] );
}
/**
* @return Status
*/
final public function unlock( array $paths, $type = self::LOCK_EX ) {
- $keys = array_unique( array_map( 'LockManager::sha1Base36', $paths ) );
- return $this->doUnlock( $keys, $this->lockTypeMap[$type] );
+ return $this->doUnlock( array_unique( $paths ), $this->lockTypeMap[$type] );
}
/**
/**
* Lock resources with the given keys and lock type
*
- * @param $key Array List of keys to lock (40 char hex hashes)
+ * @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @return string
*/
- abstract protected function doLock( array $keys, $type );
+ abstract protected function doLock( array $paths, $type );
/**
* Unlock resources with the given keys and lock type
*
- * @param $key Array List of keys to unlock (40 char hex hashes)
+ * @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @return string
*/
- abstract protected function doUnlock( array $keys, $type );
+ abstract protected function doUnlock( array $paths, $type );
}
/**
* Simple version of LockManager that does nothing
*/
class NullLockManager extends LockManager {
- protected function doLock( array $keys, $type ) {
+ protected function doLock( array $paths, $type ) {
return Status::newGood();
}
- protected function doUnlock( array $keys, $type ) {
+ protected function doUnlock( array $paths, $type ) {
return Status::newGood();
}
}
dépôts / lhc / web / wiklou.git / commitdiff