1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
<?php
/**
* @defgroup LockManager Lock management
* @ingroup FileBackend
*/
/**
* @file
* @ingroup LockManager
* @author Aaron Schulz
*/
/**
* Class for handling resource locking.
*
* Locks on resource keys can either be shared or exclusive.
*
* Implementations must keep track of what is locked by this proccess
* in-memory and support nested locking calls (using reference counting).
* At least LOCK_UW and LOCK_EX must be implemented. LOCK_SH can be a no-op.
* Locks should either be non-blocking or have low wait timeouts.
*
* Subclasses should avoid throwing exceptions at all costs.
*
* @ingroup LockManager
* @since 1.19
*/
abstract class LockManager {
/** @var Array Mapping of lock types to the type actually used */
protected $lockTypeMap = array(
self::LOCK_SH => self::LOCK_SH,
self::LOCK_UW => self::LOCK_EX, // subclasses may use 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
*
* @param $config Array
*/
public function __construct( array $config ) {}
/**
* Lock the resources at the given abstract paths
*
* @param $paths Array List of resource names
* @param $type integer LockManager::LOCK_* constant
* @return Status
*/
final public function lock( array $paths, $type = self::LOCK_EX ) {
return $this->doLock( array_unique( $paths ), $this->lockTypeMap[$type] );
}
/**
* Unlock the resources at the given abstract paths
*
* @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @return Status
*/
final public function unlock( array $paths, $type = self::LOCK_EX ) {
return $this->doUnlock( array_unique( $paths ), $this->lockTypeMap[$type] );
}
/**
* Get the base 36 SHA-1 of a string, padded to 31 digits
*
* @param $path string
* @return string
*/
final protected static function sha1Base36( $path ) {
return wfBaseConvert( sha1( $path ), 16, 36, 31 );
}
/**
* Lock resources with the given keys and lock type
*
* @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @return string
*/
abstract protected function doLock( array $paths, $type );
/**
* Unlock resources with the given keys and lock type
*
* @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @return string
*/
abstract protected function doUnlock( array $paths, $type );
}
/**
* Self releasing locks
*
* LockManager helper class to handle scoped locks, which
* release when an object is destroyed or goes out of scope.
*
* @ingroup LockManager
* @since 1.19
*/
class ScopedLock {
/** @var LockManager */
protected $manager;
/** @var Status */
protected $status;
/** @var Array List of resource paths*/
protected $paths;
protected $type; // integer lock type
/**
* @param $manager LockManager
* @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @param $status Status
*/
protected function __construct(
LockManager $manager, array $paths, $type, Status $status
) {
$this->manager = $manager;
$this->paths = $paths;
$this->status = $status;
$this->type = $type;
}
protected function __clone() {}
/**
* Get a ScopedLock object representing a lock on resource paths.
* Any locks are released once this object goes out of scope.
* The status object is updated with any errors or warnings.
*
* @param $manager LockManager
* @param $paths Array List of storage paths
* @param $type integer LockManager::LOCK_* constant
* @param $status Status
* @return ScopedLock|null Returns null on failure
*/
public static function factory(
LockManager $manager, array $paths, $type, Status $status
) {
$lockStatus = $manager->lock( $paths, $type );
$status->merge( $lockStatus );
if ( $lockStatus->isOK() ) {
return new self( $manager, $paths, $type, $status );
}
return null;
}
function __destruct() {
$wasOk = $this->status->isOK();
$this->status->merge( $this->manager->unlock( $this->paths, $this->type ) );
if ( $wasOk ) {
// Make sure status is OK, despite any unlockFiles() fatals
$this->status->setResult( true, $this->status->value );
}
}
}
/**
* Simple version of LockManager that does nothing
* @since 1.19
*/
class NullLockManager extends LockManager {
protected function doLock( array $paths, $type ) {
return Status::newGood();
}
protected function doUnlock( array $paths, $type ) {
return Status::newGood();
}
}
|
