| Index: trunk/phase3/maintenance/archives/patch-concurrencycheck.sql |
| — | — | @@ -1,25 +0,0 @@ |
| 2 | | -CREATE TABLE /*_*/concurrencycheck ( |
| 3 | | - -- a string describing the resource or application being checked out. |
| 4 | | - cc_resource_type varchar(255) NOT NULL, |
| 5 | | - |
| 6 | | - -- the (numeric) ID of the record that's being checked out. |
| 7 | | - cc_record int unsigned NOT NULL, |
| 8 | | - |
| 9 | | - -- the user who has control of the resource |
| 10 | | - cc_user int unsigned NOT NULL, |
| 11 | | - |
| 12 | | - -- the date/time on which this record expires |
| 13 | | - cc_expiration varbinary(14) not null |
| 14 | | - |
| 15 | | -) /*$wgDBTableOptions*/; |
| 16 | | -CREATE UNIQUE INDEX /*i*/cc_resource_record ON /*_*/concurrencycheck (cc_resource_type, cc_record); |
| 17 | | -CREATE INDEX /*i*/cc_user ON /*_*/concurrencycheck (cc_user); |
| 18 | | -CREATE INDEX /*i*/cc_expiration ON /*_*/concurrencycheck (cc_expiration); |
| Index: trunk/phase3/maintenance/sqlite/archives/patch-concurrencycheck.sql |
| — | — | @@ -1,25 +0,0 @@ |
| 2 | | -CREATE TABLE /*_*/concurrencycheck ( |
| 3 | | - -- a string describing the resource or application being checked out. |
| 4 | | - cc_resource_type varchar(255) NOT NULL, |
| 5 | | - |
| 6 | | - -- the (numeric) ID of the record that's being checked out. |
| 7 | | - cc_record int unsigned NOT NULL, |
| 8 | | - |
| 9 | | - -- the user who has control of the resource |
| 10 | | - cc_user int unsigned NOT NULL, |
| 11 | | - |
| 12 | | - -- the date/time on which this record expires |
| 13 | | - cc_expiration varbinary(14) not null |
| 14 | | - |
| 15 | | -) /*$wgDBTableOptions*/; |
| 16 | | -CREATE UNIQUE INDEX /*i*/cc_resource_record ON /*_*/concurrencycheck (cc_resource_type, cc_record); |
| 17 | | -CREATE INDEX /*i*/cc_user ON /*_*/concurrencycheck (cc_user); |
| 18 | | -CREATE INDEX /*i*/cc_expiration ON /*_*/concurrencycheck (cc_expiration); |
| Index: trunk/phase3/maintenance/tables.sql |
| — | — | @@ -1483,31 +1483,4 @@ |
| 1484 | 1484 | -- Should cover *most* configuration - strings, ints, bools, etc. |
| 1485 | 1485 | CREATE INDEX /*i*/cf_name_value ON /*_*/config (cf_name,cf_value(255)); |
| 1486 | 1486 | |
| 1487 | | -CREATE TABLE /*_*/concurrencycheck ( |
| 1488 | | - -- a string describing the resource or application being checked out. |
| 1489 | | - cc_resource_type varchar(255) NOT NULL, |
| 1490 | | - |
| 1491 | | - -- the (numeric) ID of the record that's being checked out. |
| 1492 | | - cc_record int unsigned NOT NULL, |
| 1493 | | - |
| 1494 | | - -- the user who has control of the resource |
| 1495 | | - cc_user int unsigned NOT NULL, |
| 1496 | | - |
| 1497 | | - -- the date/time on which this record expires |
| 1498 | | - cc_expiration varbinary(14) not null |
| 1499 | | - |
| 1500 | | -) /*$wgDBTableOptions*/; |
| 1501 | | -CREATE UNIQUE INDEX /*i*/cc_resource_record ON /*_*/concurrencycheck (cc_resource_type, cc_record); |
| 1502 | | -CREATE INDEX /*i*/cc_user ON /*_*/concurrencycheck (cc_user); |
| 1503 | | -CREATE INDEX /*i*/cc_expiration ON /*_*/concurrencycheck (cc_expiration); |
| 1504 | | - |
| 1505 | | - |
| 1506 | 1487 | -- vim: sw=2 sts=2 et |
| Property changes on: trunk/phase3/maintenance/tables.sql |
| ___________________________________________________________________ |
| Modified: svn:mergeinfo |
| 1507 | 1488 | Reverse-merged /branches/concurrency/maintenance/tables.sql:r108302-108557 |
| Index: trunk/phase3/tests/phpunit/includes/ConcurrencyCheckTest.php |
| — | — | @@ -1,106 +0,0 @@ |
| 2 | | -<?php |
| 3 | | - |
| 4 | | -class ConcurrencyCheckTest extends MediaWikiTestCase { |
| 5 | | - /** |
| 6 | | - * @var Array of test users |
| 7 | | - */ |
| 8 | | - public static $users; |
| 9 | | - |
| 10 | | - // Prepare test environment |
| 11 | | - |
| 12 | | - public function setUp() { |
| 13 | | - parent::setUp(); |
| 14 | | - |
| 15 | | - self::$users = array( |
| 16 | | - 'user1' => new ApiTestUser( |
| 17 | | - 'Concurrencychecktestuser1', |
| 18 | | - 'ConcurrencyCheck Test User 1', |
| 19 | | - 'concurrency_check_test_user_1@example.com', |
| 20 | | - array() |
| 21 | | - ), |
| 22 | | - 'user2' => new ApiTestUser( |
| 23 | | - 'Concurrencychecktestuser2', |
| 24 | | - 'ConcurrencyCheck Test User 2', |
| 25 | | - 'concurrency_check_test_user_2@example.com', |
| 26 | | - array() |
| 27 | | - ), |
| 28 | | - ); |
| 29 | | - |
| 30 | | - // turn on memcached for this test. |
| 31 | | - // if no memcached is present, this still works fine. |
| 32 | | - global $wgMainCacheType, $wgConcurrency; |
| 33 | | - $this->oldcache = $wgMainCacheType; |
| 34 | | - $wgMainCacheType = CACHE_MEMCACHED; |
| 35 | | - $wgConcurrency['ExpirationMin'] = -60; // negative numbers are needed for testing |
| 36 | | - } |
| 37 | | - |
| 38 | | - public function tearDown() { |
| 39 | | - // turn off caching again. |
| 40 | | - global $wgMainCacheType; |
| 41 | | - $wgMainCacheType = $this->oldcache; |
| 42 | | - |
| 43 | | - parent::tearDown(); |
| 44 | | - } |
| 45 | | - |
| 46 | | - // Actual tests from here down |
| 47 | | - |
| 48 | | - public function testCheckoutCheckin() { |
| 49 | | - $first = new ConcurrencyCheck( 'CCUnitTest', self::$users['user1']->user ); |
| 50 | | - $second = new ConcurrencyCheck( 'CCUnitTest', self::$users['user2']->user ); |
| 51 | | - $testKey = 1337; |
| 52 | | - |
| 53 | | - // clean up after any previously failed tests |
| 54 | | - $first->checkin($testKey); |
| 55 | | - $second->checkin($testKey); |
| 56 | | - |
| 57 | | - // tests |
| 58 | | - /* turning these tests off per robla, since I need to go home. |
| 59 | | - $this->assertTrue( $first->checkout($testKey), "Initial checkout" ); |
| 60 | | - $this->assertTrue( $first->checkout($testKey), "Cache hit" ); |
| 61 | | - $this->assertFalse( $second->checkout($testKey), "Checkout of locked resource fails as different user" ); |
| 62 | | - $this->assertTrue( $first->checkout($testKey), "Checkout of locked resource succeeds as original user" ); |
| 63 | | - $this->assertFalse( $second->checkin($testKey), "Checkin of locked resource fails as different user" ); |
| 64 | | - $this->assertTrue( $first->checkin($testKey), "Checkin of locked resource succeeds as original user" ); |
| 65 | | - $second->setExpirationTime(-5); |
| 66 | | - $this->assertTrue( $second->checkout($testKey), "Checked-in resource is now available to second user" ); |
| 67 | | - $second->setExpirationTime(); |
| 68 | | - $this->assertTrue( $first->checkout($testKey), "Checkout of expired resource succeeds as first user"); |
| 69 | | - $this->assertTrue( $second->checkout($testKey, true), "Checkout override" ); |
| 70 | | - $this->assertFalse( $first->checkout($testKey), "Checkout of overriden resource fails as different user" ); |
| 71 | | - |
| 72 | | - |
| 73 | | - // cleanup |
| 74 | | - $this->assertTrue( $second->checkin($testKey), "Checkin of record with changed ownership" ); |
| 75 | | - */ |
| 76 | | - } |
| 77 | | - |
| 78 | | - public function testExpire() { |
| 79 | | - $cc = new ConcurrencyCheck( 'CCUnitTest', self::$users['user1']->user ); |
| 80 | | - $cc->setExpirationTime(-1); |
| 81 | | - $cc->checkout( 1338 ); // these numbers are test record ids. |
| 82 | | - $cc->checkout( 1339 ); |
| 83 | | - $cc->setExpirationTime(); |
| 84 | | - $cc->checkout( 13310 ); |
| 85 | | - |
| 86 | | - // tests |
| 87 | | - $this->assertEquals( 2, $cc->expire(), "Resource expiration" ); |
| 88 | | - $this->assertTrue( $cc->checkin( 13310 ), "Checkin succeeds after expiration" ); |
| 89 | | - } |
| 90 | | - |
| 91 | | - public function testStatus() { |
| 92 | | - $cc = new ConcurrencyCheck( 'CCUnitTest', self::$users['user1']->user ); |
| 93 | | - $cc->checkout( 1337 ); |
| 94 | | - $cc->checkout( 1338 ); |
| 95 | | - $cc->setExpirationTime(-5); |
| 96 | | - $cc->checkout( 1339 ); |
| 97 | | - $cc->setExpirationTime(); |
| 98 | | - |
| 99 | | - // tests |
| 100 | | - $output = $cc->status( array( 1337, 1338, 1339, 13310 ) ); |
| 101 | | - $this->assertEquals( true, is_array( $output ), "Status returns values" ); |
| 102 | | - $this->assertEquals( 4, count( $output ), "Output has the correct number of records" ); |
| 103 | | - $this->assertEquals( 'valid', $output[1337]['status'], "Current checkouts are listed as valid"); |
| 104 | | - $this->assertEquals( 'invalid', $output[1339]['status'], "Expired checkouts are invalid"); |
| 105 | | - $this->assertEquals( 'invalid', $output[13310]['status'], "Missing checkouts are invalid"); |
| 106 | | - } |
| 107 | | -} |
| Index: trunk/phase3/tests/phpunit/includes/api/ApiConcurrencyTest.php |
| — | — | @@ -1,172 +0,0 @@ |
| 2 | | -<?php |
| 3 | | - |
| 4 | | -class ApiConcurrencyTest extends ApiTestCase { |
| 5 | | - /** |
| 6 | | - * @var Array of test users |
| 7 | | - */ |
| 8 | | - public static $users; |
| 9 | | - |
| 10 | | - // Prepare test environment |
| 11 | | - |
| 12 | | - function setUp() { |
| 13 | | - parent::setUp(); |
| 14 | | - |
| 15 | | - self::$users['one'] = new ApiTestUser( |
| 16 | | - 'ApitestuserA', |
| 17 | | - 'Api Test UserA', |
| 18 | | - 'api_test_userA@example.com', |
| 19 | | - array() |
| 20 | | - ); |
| 21 | | - |
| 22 | | - self::$users['two'] = new ApiTestUser( |
| 23 | | - 'ApitestuserB', |
| 24 | | - 'Api Test UserB', |
| 25 | | - 'api_test_userB@example.com', |
| 26 | | - array() |
| 27 | | - ); |
| 28 | | - } |
| 29 | | - |
| 30 | | - public function tearDown() { |
| 31 | | - parent::tearDown(); |
| 32 | | - } |
| 33 | | - |
| 34 | | - function testLogin() { |
| 35 | | - |
| 36 | | - $sessionArray = array(); |
| 37 | | - |
| 38 | | - foreach ( self::$users as $key => $user ) { |
| 39 | | - |
| 40 | | - $params = array( |
| 41 | | - 'action' => 'login', |
| 42 | | - 'lgname' => $user->username, |
| 43 | | - 'lgpassword' => $user->password |
| 44 | | - ); |
| 45 | | - list( $result, , $session ) = $this->doApiRequest( $params ); |
| 46 | | - $this->assertArrayHasKey( "login", $result ); |
| 47 | | - $this->assertArrayHasKey( "result", $result['login'] ); |
| 48 | | - $this->assertEquals( "NeedToken", $result['login']['result'] ); |
| 49 | | - $token = $result['login']['token']; |
| 50 | | - |
| 51 | | - $params = array( |
| 52 | | - 'action' => 'login', |
| 53 | | - 'lgtoken' => $token, |
| 54 | | - 'lgname' => $user->username, |
| 55 | | - 'lgpassword' => $user->password |
| 56 | | - ); |
| 57 | | - list( $result, , $session ) = $this->doApiRequest( $params, $session ); |
| 58 | | - $this->assertArrayHasKey( "login", $result ); |
| 59 | | - $this->assertArrayHasKey( "result", $result['login'] ); |
| 60 | | - $this->assertEquals( "Success", $result['login']['result'] ); |
| 61 | | - $this->assertArrayHasKey( 'lgtoken', $result['login'] ); |
| 62 | | - |
| 63 | | - $this->assertNotEmpty( $session, 'API Login must return a session' ); |
| 64 | | - |
| 65 | | - $sessionArray[$key] = $session; |
| 66 | | - |
| 67 | | - } |
| 68 | | - |
| 69 | | - return $sessionArray; |
| 70 | | - |
| 71 | | - } |
| 72 | | - |
| 73 | | - /** |
| 74 | | - * @depends testLogin |
| 75 | | - */ |
| 76 | | - function testCheckOut( $sessionArray ) { |
| 77 | | - |
| 78 | | - global $wgUser; |
| 79 | | - |
| 80 | | - $wgUser = self::$users['one']->user; |
| 81 | | - /* commenting these out since i need to go home and they're breakin CI. See commit summary for details. |
| 82 | | - |
| 83 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 84 | | - 'action' => 'concurrency', |
| 85 | | - 'ccaction' => 'checkout', |
| 86 | | - 'record' => 1, |
| 87 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['one'], self::$users['one']->user ); |
| 88 | | - |
| 89 | | - $this->assertEquals( "success", $result['concurrency']['result'] ); |
| 90 | | - |
| 91 | | - $wgUser = self::$users['two']->user; |
| 92 | | - |
| 93 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 94 | | - 'action' => 'concurrency', |
| 95 | | - 'ccaction' => 'checkout', |
| 96 | | - 'record' => 1, |
| 97 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['two'], self::$users['two']->user ); |
| 98 | | - |
| 99 | | - $this->assertEquals( "failure", $result['concurrency']['result'] ); |
| 100 | | - |
| 101 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 102 | | - 'action' => 'concurrency', |
| 103 | | - 'ccaction' => 'checkout', |
| 104 | | - 'record' => 2, |
| 105 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['two'], self::$users['two']->user ); |
| 106 | | - |
| 107 | | - $this->assertEquals( "success", $result['concurrency']['result'] ); |
| 108 | | - */ |
| 109 | | - } |
| 110 | | - |
| 111 | | - /** |
| 112 | | - * @depends testLogin |
| 113 | | - */ |
| 114 | | - function testCheckIn( $sessionArray ) { |
| 115 | | - |
| 116 | | - global $wgUser; |
| 117 | | - |
| 118 | | - $wgUser = self::$users['one']->user; |
| 119 | | - /* commenting these out since i need to go home and they're breakin CI. See commit summary for details. |
| 120 | | - |
| 121 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 122 | | - 'action' => 'concurrency', |
| 123 | | - 'ccaction' => 'checkin', |
| 124 | | - 'record' => 1, |
| 125 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['one'], self::$users['one']->user ); |
| 126 | | - |
| 127 | | - $this->assertEquals( "success", $result['concurrency']['result'] ); |
| 128 | | - |
| 129 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 130 | | - 'action' => 'concurrency', |
| 131 | | - 'ccaction' => 'checkin', |
| 132 | | - 'record' => 2, |
| 133 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['one'], self::$users['one']->user ); |
| 134 | | - |
| 135 | | - $this->assertEquals( "failure", $result['concurrency']['result'] ); |
| 136 | | - |
| 137 | | - $wgUser = self::$users['two']->user; |
| 138 | | - |
| 139 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 140 | | - 'action' => 'concurrency', |
| 141 | | - 'ccaction' => 'checkin', |
| 142 | | - 'record' => 2, |
| 143 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['two'], self::$users['two']->user ); |
| 144 | | - |
| 145 | | - $this->assertEquals( "success", $result['concurrency']['result'] ); |
| 146 | | - */ |
| 147 | | - } |
| 148 | | - |
| 149 | | - /** |
| 150 | | - * @depends testLogin |
| 151 | | - */ |
| 152 | | - function testInvalidCcacton( $sessionArray ) { |
| 153 | | - $exception = false; |
| 154 | | - try { |
| 155 | | - global $wgUser; |
| 156 | | - |
| 157 | | - $wgUser = self::$users['one']->user; |
| 158 | | - |
| 159 | | - list( $result, , $session ) = $this->doApiRequestWithToken( array( |
| 160 | | - 'action' => 'concurrency', |
| 161 | | - 'ccaction' => 'checkinX', |
| 162 | | - 'record' => 1, |
| 163 | | - 'resourcetype' => 'responding-to-moodbar-feedback'), $sessionArray['one'], self::$users['one']->user ); |
| 164 | | - } catch ( UsageException $e ) { |
| 165 | | - $exception = true; |
| 166 | | - $this->assertEquals("Unrecognized value for parameter 'ccaction': checkinX", |
| 167 | | - $e->getMessage() ); |
| 168 | | - } |
| 169 | | - $this->assertTrue( $exception, "Got exception" ); |
| 170 | | - |
| 171 | | - } |
| 172 | | - |
| 173 | | -} |
| Index: trunk/phase3/includes/ConcurrencyCheck.php |
| — | — | @@ -1,358 +0,0 @@ |
| 2 | | -<?php |
| 3 | | - |
| 4 | | -/** |
| 5 | | - * Class for cooperative locking of web resources |
| 6 | | - * |
| 7 | | - * Each resource is identified by a combination of the "resource type" (the application, the type |
| 8 | | - * of content, etc), and the resource's primary key or some other unique numeric ID. |
| 9 | | - * |
| 10 | | - * Currently, a resource can only be checked out by a single user. Other attempts to check it out result |
| 11 | | - * in the checkout failing. In the future, an option for multiple simulataneous checkouts could be added |
| 12 | | - * without much trouble. |
| 13 | | - * |
| 14 | | - * This could be done with named locks, except then it would be impossible to build a list of all the |
| 15 | | - * resources currently checked out for a given application. There's no good way to construct a query |
| 16 | | - * that answers the question, "What locks do you have starting with [foo]" This could be done really well |
| 17 | | - * with a concurrent, reliable, distributed key/value store, but we don't have one of those right now. |
| 18 | | - * |
| 19 | | - * @author Ian Baker <ian@wikimedia.org> |
| 20 | | - */ |
| 21 | | -class ConcurrencyCheck { |
| 22 | | - |
| 23 | | - protected $expirationTime; |
| 24 | | - |
| 25 | | - /** |
| 26 | | - * @var User |
| 27 | | - */ |
| 28 | | - protected $user; |
| 29 | | - |
| 30 | | - /** |
| 31 | | - * Constructor |
| 32 | | - * |
| 33 | | - * @var $resourceType String The calling application or type of resource, conceptually like a namespace |
| 34 | | - * @var $user User object, the current user |
| 35 | | - * @var $expirationTime Integer (optional) How long should a checkout last, in seconds |
| 36 | | - */ |
| 37 | | - public function __construct( $resourceType, $user, $expirationTime = null ) { |
| 38 | | - |
| 39 | | - // All database calls are to the master, since the whole point of this class is maintaining |
| 40 | | - // concurrency. Most reads should come from cache anyway. |
| 41 | | - $this->dbw = wfGetDb( DB_MASTER ); |
| 42 | | - |
| 43 | | - $this->user = $user; |
| 44 | | - // TODO: create a registry of all valid resourceTypes that client app can add to. |
| 45 | | - $this->resourceType = $resourceType; |
| 46 | | - $this->setExpirationTime( $expirationTime ); |
| 47 | | - } |
| 48 | | - |
| 49 | | - /** |
| 50 | | - * Check out a resource. This establishes an atomically generated, cooperative lock |
| 51 | | - * on a key. The lock is tied to the current user. |
| 52 | | - * |
| 53 | | - * @var $record Integer containing the record id to check out |
| 54 | | - * @var $override Boolean (optional) describing whether to override an existing checkout |
| 55 | | - * @return boolean |
| 56 | | - */ |
| 57 | | - public function checkout( $record, $override = null ) { |
| 58 | | - global $wgMemc; |
| 59 | | - $this->validateId( $record ); |
| 60 | | - $dbw = $this->dbw; |
| 61 | | - $userId = $this->user->getId(); |
| 62 | | - $cacheKey = wfMemcKey( 'concurrencycheck', $this->resourceType, $record ); |
| 63 | | - |
| 64 | | - // when operating with a single memcached cluster, it's reasonable to check the cache here. |
| 65 | | - global $wgConcurrency; |
| 66 | | - if( $wgConcurrency['TrustMemc'] ) { |
| 67 | | - $cached = $wgMemc->get( $cacheKey ); |
| 68 | | - if( $cached ) { |
| 69 | | - if( ! $override && $cached['userId'] != $userId && $cached['expiration'] > time() ) { |
| 70 | | - // this is already checked out. |
| 71 | | - return false; |
| 72 | | - } |
| 73 | | - } |
| 74 | | - } |
| 75 | | - |
| 76 | | - // attempt an insert, check success (this is atomic) |
| 77 | | - $insertError = null; |
| 78 | | - $res = $dbw->insert( |
| 79 | | - 'concurrencycheck', |
| 80 | | - array( |
| 81 | | - 'cc_resource_type' => $this->resourceType, |
| 82 | | - 'cc_record' => $record, |
| 83 | | - 'cc_user' => $userId, |
| 84 | | - 'cc_expiration' => wfTimestamp( TS_MW, time() + $this->expirationTime ), |
| 85 | | - ), |
| 86 | | - __METHOD__, |
| 87 | | - array( 'IGNORE' ) |
| 88 | | - ); |
| 89 | | - |
| 90 | | - // if the insert succeeded, checkout is done. |
| 91 | | - if( $dbw->affectedRows() === 1 ) { |
| 92 | | - // delete any existing cache key. can't create a new key here |
| 93 | | - // since the insert didn't happen inside a transaction. |
| 94 | | - $wgMemc->delete( $cacheKey ); |
| 95 | | - return true; |
| 96 | | - } |
| 97 | | - |
| 98 | | - // if the insert failed, it's necessary to check the expiration. |
| 99 | | - // here, check by deleting, since that permits the use of write locks |
| 100 | | - // (SELECT..LOCK IN SHARE MODE), rather than read locks (SELECT..FOR UPDATE) |
| 101 | | - $dbw->begin(); |
| 102 | | - $dbw->delete( |
| 103 | | - 'concurrencycheck', |
| 104 | | - array( |
| 105 | | - 'cc_resource_type' => $this->resourceType, |
| 106 | | - 'cc_record' => $record, |
| 107 | | - '(cc_user = ' . $userId . ' OR cc_expiration <= ' . $dbw->addQuotes(wfTimestamp( TS_MW )) . ')', // only the owner can perform a checkin |
| 108 | | - ), |
| 109 | | - __METHOD__, |
| 110 | | - array() |
| 111 | | - ); |
| 112 | | - |
| 113 | | - // delete failed: not checked out by current user, checkout is unexpired, override is unset |
| 114 | | - if( $dbw->affectedRows() !== 1 && ! $override) { |
| 115 | | - // fetch the existing data to cache it |
| 116 | | - $row = $dbw->selectRow( |
| 117 | | - 'concurrencycheck', |
| 118 | | - array( '*' ), |
| 119 | | - array( |
| 120 | | - 'cc_resource_type' => $this->resourceType, |
| 121 | | - 'cc_record' => $record, |
| 122 | | - ), |
| 123 | | - __METHOD__, |
| 124 | | - array() |
| 125 | | - ); |
| 126 | | - |
| 127 | | - // this was a cache miss. populate the cache with data from the db. |
| 128 | | - // cache is set to expire at the same time as the checkout, since it'll become invalid then anyway. |
| 129 | | - // inside this transaction, a row-level lock is established which ensures cache concurrency |
| 130 | | - $wgMemc->set( $cacheKey, array( 'userId' => $row->cc_user, 'expiration' => wfTimestamp( TS_UNIX, $row->cc_expiration ) ), wfTimestamp( TS_UNIX, $row->cc_expiration ) - time() ); |
| 131 | | - $dbw->rollback(); |
| 132 | | - return false; |
| 133 | | - } |
| 134 | | - |
| 135 | | - $expiration = time() + $this->expirationTime; |
| 136 | | - |
| 137 | | - // delete succeeded, insert a new row. |
| 138 | | - // replace is used here to support the override parameter |
| 139 | | - $res = $dbw->replace( |
| 140 | | - 'concurrencycheck', |
| 141 | | - array( 'cc_resource_type', 'cc_record' ), |
| 142 | | - array( |
| 143 | | - 'cc_resource_type' => $this->resourceType, |
| 144 | | - 'cc_record' => $record, |
| 145 | | - 'cc_user' => $userId, |
| 146 | | - 'cc_expiration' => wfTimestamp( TS_MW, $expiration ), |
| 147 | | - ), |
| 148 | | - __METHOD__ |
| 149 | | - ); |
| 150 | | - |
| 151 | | - // cache the result. |
| 152 | | - $wgMemc->set( $cacheKey, array( 'userId' => $userId, 'expiration' => $expiration ), $this->expirationTime ); |
| 153 | | - |
| 154 | | - $dbw->commit(); |
| 155 | | - return true; |
| 156 | | - } |
| 157 | | - |
| 158 | | - /** |
| 159 | | - * Check in a resource. Only works if the resource is checked out by the current user. |
| 160 | | - * |
| 161 | | - * @var $record Integer containing the record id to checkin |
| 162 | | - * @return Boolean |
| 163 | | - */ |
| 164 | | - public function checkin( $record ) { |
| 165 | | - global $wgMemc; |
| 166 | | - $this->validateId( $record ); |
| 167 | | - $dbw = $this->dbw; |
| 168 | | - $userId = $this->user->getId(); |
| 169 | | - $cacheKey = wfMemcKey( 'concurrencycheck', $this->resourceType, $record ); |
| 170 | | - |
| 171 | | - $dbw->delete( |
| 172 | | - 'concurrencycheck', |
| 173 | | - array( |
| 174 | | - 'cc_resource_type' => $this->resourceType, |
| 175 | | - 'cc_record' => $record, |
| 176 | | - 'cc_user' => $userId, // only the owner can perform a checkin |
| 177 | | - ), |
| 178 | | - __METHOD__, |
| 179 | | - array() |
| 180 | | - ); |
| 181 | | - |
| 182 | | - // check row count (this is atomic, select would not be) |
| 183 | | - if( $dbw->affectedRows() === 1 ) { |
| 184 | | - $wgMemc->delete( $cacheKey ); |
| 185 | | - return true; |
| 186 | | - } |
| 187 | | - |
| 188 | | - return false; |
| 189 | | - } |
| 190 | | - |
| 191 | | - /** |
| 192 | | - * Remove all expired checkouts. |
| 193 | | - * |
| 194 | | - * @return Integer describing the number of records expired. |
| 195 | | - */ |
| 196 | | - public function expire() { |
| 197 | | - // TODO: run this in a few other places that db access happens, to make sure the db stays non-crufty. |
| 198 | | - $dbw = $this->dbw; |
| 199 | | - $now = time(); |
| 200 | | - |
| 201 | | - // remove the rows from the db. trust memcached to expire the cache. |
| 202 | | - $dbw->delete( |
| 203 | | - 'concurrencycheck', |
| 204 | | - array( |
| 205 | | - 'cc_expiration <= ' . $dbw->addQuotes( wfTimestamp( TS_MW, $now ) ), |
| 206 | | - ), |
| 207 | | - __METHOD__, |
| 208 | | - array() |
| 209 | | - ); |
| 210 | | - |
| 211 | | - // return the number of rows removed. |
| 212 | | - return $dbw->affectedRows(); |
| 213 | | - } |
| 214 | | - |
| 215 | | - public function status( $keys ) { |
| 216 | | - global $wgMemc, $wgDBtype; |
| 217 | | - $dbw = $this->dbw; |
| 218 | | - $now = time(); |
| 219 | | - |
| 220 | | - $checkouts = array(); |
| 221 | | - $toSelect = array(); |
| 222 | | - |
| 223 | | - // validate keys, attempt to retrieve from cache. |
| 224 | | - foreach( $keys as $key ) { |
| 225 | | - $this->validateId( $key ); |
| 226 | | - |
| 227 | | - $cached = $wgMemc->get( wfMemcKey( 'concurrencycheck', $this->resourceType, $key ) ); |
| 228 | | - if( $cached && $cached['expiration'] > $now ) { |
| 229 | | - $checkouts[$key] = array( |
| 230 | | - 'status' => 'valid', |
| 231 | | - 'cc_resource_type' => $this->resourceType, |
| 232 | | - 'cc_record' => $key, |
| 233 | | - 'cc_user' => $cached['userId'], |
| 234 | | - 'cc_expiration' => wfTimestamp( TS_MW, $cached['expiration'] ), |
| 235 | | - 'cache' => 'cached', |
| 236 | | - ); |
| 237 | | - } else { |
| 238 | | - $toSelect[] = $key; |
| 239 | | - } |
| 240 | | - } |
| 241 | | - |
| 242 | | - // if there were cache misses... |
| 243 | | - if( $toSelect ) { |
| 244 | | - // If it's time to go to the database, go ahead and expire old rows. |
| 245 | | - $this->expire(); |
| 246 | | - |
| 247 | | - |
| 248 | | - // Why LOCK IN SHARE MODE, you might ask? To avoid a race condition: Otherwise, it's possible for |
| 249 | | - // a checkin and/or checkout to occur between this select and the value being stored in cache, which |
| 250 | | - // makes for an incorrect cache. This, in turn, could make checkout() above (which uses the cache) |
| 251 | | - // function incorrectly. |
| 252 | | - // |
| 253 | | - // Another option would be to run the select, then check each row in-turn before setting the cache |
| 254 | | - // key using either SELECT (with LOCK IN SHARE MODE) or UPDATE that checks a timestamp (and which |
| 255 | | - // would establish the same lock). That method would mean smaller, quicker locks, but more overall |
| 256 | | - // database overhead. |
| 257 | | - // |
| 258 | | - // It appears all the DBMSes we use support LOCK IN SHARE MODE, but if that's not the case, the second |
| 259 | | - // solution above could be implemented instead. |
| 260 | | - $queryParams = array(); |
| 261 | | - if( $wgDBtype === 'mysql' ) { |
| 262 | | - $queryParamsp[] = 'LOCK IN SHARE MODE'; |
| 263 | | - |
| 264 | | - // the transaction seems incongruous, I know, but it's to keep the cache update atomic. |
| 265 | | - $dbw->begin(); |
| 266 | | - } |
| 267 | | - |
| 268 | | - $res = $dbw->select( |
| 269 | | - 'concurrencycheck', |
| 270 | | - array( '*' ), |
| 271 | | - array( |
| 272 | | - 'cc_resource_type' => $this->resourceType, |
| 273 | | - 'cc_record' => $toSelect, |
| 274 | | - 'cc_expiration > ' . $dbw->addQuotes( wfTimestamp( TS_MW ) ), |
| 275 | | - ), |
| 276 | | - __METHOD__, |
| 277 | | - $queryParams |
| 278 | | - ); |
| 279 | | - |
| 280 | | - while( $res && $record = $res->fetchRow() ) { |
| 281 | | - $record['status'] = 'valid'; |
| 282 | | - $checkouts[ $record['cc_record'] ] = $record; |
| 283 | | - |
| 284 | | - // TODO: implement strategy #2 above, determine which DBMSes need which method. |
| 285 | | - // for now, disable adding to cache here for databases that don't support read locking |
| 286 | | - if( $wgDBtype !== 'mysql' ) { |
| 287 | | - // safe to store values since this is inside the transaction |
| 288 | | - $wgMemc->set( |
| 289 | | - wfMemcKey( 'concurrencycheck', $this->resourceType, $record['cc_record'] ), |
| 290 | | - array( 'userId' => $record['cc_user'], 'expiration' => wfTimestamp( TS_UNIX, $record['cc_expiration'] ) ), |
| 291 | | - wfTimestamp( TS_UNIX, $record['cc_expiration'] ) - time() |
| 292 | | - ); |
| 293 | | - } |
| 294 | | - } |
| 295 | | - |
| 296 | | - if( $wgDBtype === 'mysql' ) { |
| 297 | | - // end the transaction. |
| 298 | | - $dbw->rollback(); |
| 299 | | - } |
| 300 | | - } |
| 301 | | - |
| 302 | | - // if a key was passed in but has no (unexpired) checkout, include it in the |
| 303 | | - // result set to make things easier and more consistent on the client-side. |
| 304 | | - foreach( $keys as $key ) { |
| 305 | | - if( ! array_key_exists( $key, $checkouts ) ) { |
| 306 | | - $checkouts[$key]['status'] = 'invalid'; |
| 307 | | - } |
| 308 | | - } |
| 309 | | - |
| 310 | | - return $checkouts; |
| 311 | | - } |
| 312 | | - |
| 313 | | - public function listCheckouts() { |
| 314 | | - // TODO: fill in the function that lets you get the complete set of checkouts for a given application. |
| 315 | | - } |
| 316 | | - |
| 317 | | - /** |
| 318 | | - * @param $user user |
| 319 | | - */ |
| 320 | | - public function setUser( $user ) { |
| 321 | | - $this->user = $user; |
| 322 | | - } |
| 323 | | - |
| 324 | | - public function setExpirationTime( $expirationTime = null ) { |
| 325 | | - global $wgConcurrency; |
| 326 | | - |
| 327 | | - // check to make sure the time is a number |
| 328 | | - // negative number are allowed, though mostly only used for testing |
| 329 | | - if( $expirationTime && (int) $expirationTime == $expirationTime ) { |
| 330 | | - if( $expirationTime > $wgConcurrency['ExpirationMax'] ) { |
| 331 | | - $this->expirationTime = $wgConcurrency['ExpirationMax']; // if the number is too high, limit it to the max value. |
| 332 | | - } elseif ( $expirationTime < $wgConcurrency['ExpirationMin'] ) { |
| 333 | | - $this->expirationTime = $wgConcurrency['ExpirationMin']; // low limit, default -1 min |
| 334 | | - } else { |
| 335 | | - $this->expirationTime = $expirationTime; // the amount of time before a checkout expires. |
| 336 | | - } |
| 337 | | - } else { |
| 338 | | - $this->expirationTime = $wgConcurrency['ExpirationDefault']; // global default is 15 mins. |
| 339 | | - } |
| 340 | | - } |
| 341 | | - |
| 342 | | - /** |
| 343 | | - * Check to make sure a record ID is numeric, throw an exception if not. |
| 344 | | - * |
| 345 | | - * @var $record Integer |
| 346 | | - * @throws ConcurrencyCheckBadRecordIdException |
| 347 | | - * @return boolean |
| 348 | | - */ |
| 349 | | - private static function validateId ( $record ) { |
| 350 | | - if( (int) $record !== $record || $record <= 0 ) { |
| 351 | | - throw new ConcurrencyCheckBadRecordIdException( 'Record ID ' . $record . ' must be a positive integer' ); |
| 352 | | - } |
| 353 | | - |
| 354 | | - // TODO: add a hook here for client-side validation. |
| 355 | | - return true; |
| 356 | | - } |
| 357 | | -} |
| 358 | | - |
| 359 | | -class ConcurrencyCheckBadRecordIdException extends MWException {} |
| Index: trunk/phase3/includes/installer/SqliteUpdater.php |
| — | — | @@ -71,7 +71,6 @@ |
| 72 | 72 | array( 'modifyField', 'user', 'ug_group', 'patch-ug_group-length-increase.sql' ), |
| 73 | 73 | array( 'addField', 'uploadstash', 'us_chunk_inx', 'patch-uploadstash_chunk.sql' ), |
| 74 | 74 | array( 'addfield', 'job', 'job_timestamp', 'patch-jobs-add-timestamp.sql' ), |
| 75 | | - array( 'addTable', 'concurrencycheck', 'patch-concurrencycheck.sql'), |
| 76 | 75 | ); |
| 77 | 76 | } |
| 78 | 77 | |
| Index: trunk/phase3/includes/installer/MysqlUpdater.php |
| — | — | @@ -192,7 +192,6 @@ |
| 193 | 193 | array( 'modifyField', 'user', 'ug_group', 'patch-ug_group-length-increase.sql' ), |
| 194 | 194 | array( 'addField', 'uploadstash', 'us_chunk_inx', 'patch-uploadstash_chunk.sql' ), |
| 195 | 195 | array( 'addfield', 'job', 'job_timestamp', 'patch-jobs-add-timestamp.sql' ), |
| 196 | | - array( 'addTable', 'concurrencycheck', 'patch-concurrencycheck.sql'), |
| 197 | 196 | ); |
| 198 | 197 | } |
| 199 | 198 | |
| Index: trunk/phase3/includes/AutoLoader.php |
| — | — | @@ -43,7 +43,6 @@ |
| 44 | 44 | 'ChannelFeed' => 'includes/Feed.php', |
| 45 | 45 | 'Collation' => 'includes/Collation.php', |
| 46 | 46 | 'ConcatenatedGzipHistoryBlob' => 'includes/HistoryBlob.php', |
| 47 | | - 'ConcurrencyCheck' => 'includes/ConcurrencyCheck.php', |
| 48 | 47 | 'ConfEditor' => 'includes/ConfEditor.php', |
| 49 | 48 | 'ConfEditorParseError' => 'includes/ConfEditor.php', |
| 50 | 49 | 'ConfEditorToken' => 'includes/ConfEditor.php', |
| — | — | @@ -53,6 +52,7 @@ |
| 54 | 53 | 'DeferredUpdates' => 'includes/DeferredUpdates.php', |
| 55 | 54 | 'DerivativeRequest' => 'includes/WebRequest.php', |
| 56 | 55 | 'DiffHistoryBlob' => 'includes/HistoryBlob.php', |
| | 56 | + |
| 57 | 57 | 'DoubleReplacer' => 'includes/StringUtils.php', |
| 58 | 58 | 'DummyLinker' => 'includes/Linker.php', |
| 59 | 59 | 'Dump7ZipOutput' => 'includes/Export.php', |
| — | — | @@ -271,7 +271,6 @@ |
| 272 | 272 | 'ApiBase' => 'includes/api/ApiBase.php', |
| 273 | 273 | 'ApiBlock' => 'includes/api/ApiBlock.php', |
| 274 | 274 | 'ApiComparePages' => 'includes/api/ApiComparePages.php', |
| 275 | | - 'ApiConcurrency' => 'includes/api/ApiConcurrency.php', |
| 276 | 275 | 'ApiDelete' => 'includes/api/ApiDelete.php', |
| 277 | 276 | 'ApiDisabled' => 'includes/api/ApiDisabled.php', |
| 278 | 277 | 'ApiEditPage' => 'includes/api/ApiEditPage.php', |
| Property changes on: trunk/phase3/includes/AutoLoader.php |
| ___________________________________________________________________ |
| Modified: svn:mergeinfo |
| 279 | 278 | Reverse-merged /branches/concurrency/includes/AutoLoader.php:r108302-108557 |
| Index: trunk/phase3/includes/api/ApiConcurrency.php |
| — | — | @@ -1,105 +0,0 @@ |
| 2 | | -<?php |
| 3 | | - |
| 4 | | -/** |
| 5 | | - * API module that handles cooperative locking of web resources |
| 6 | | - */ |
| 7 | | -class ApiConcurrency extends ApiBase { |
| 8 | | - public function __construct( $main, $action ) { |
| 9 | | - parent::__construct( $main, $action ); |
| 10 | | - } |
| 11 | | - |
| 12 | | - public function execute() { |
| 13 | | - global $wgUser; |
| 14 | | - |
| 15 | | - $this->checkPermission( $wgUser ); |
| 16 | | - |
| 17 | | - $params = $this->extractRequestParams(); |
| 18 | | - |
| 19 | | - $res = array(); |
| 20 | | - |
| 21 | | - $concurrencyCheck = new ConcurrencyCheck( $params['resourcetype'], $wgUser ); |
| 22 | | - |
| 23 | | - switch ( $params['ccaction'] ) { |
| 24 | | - case 'checkout': |
| 25 | | - case 'checkin': |
| 26 | | - if ( $concurrencyCheck->$params['ccaction']( $params['record'] ) ) { |
| 27 | | - $res['result'] = 'success'; |
| 28 | | - } else { |
| 29 | | - $res['result'] = 'failure'; |
| 30 | | - } |
| 31 | | - break; |
| 32 | | - |
| 33 | | - default: |
| 34 | | - ApiBase::dieDebug( __METHOD__, "Unhandled concurrency action: {$params['ccaction']}" ); |
| 35 | | - } |
| 36 | | - |
| 37 | | - $this->getResult()->addValue( null, $this->getModuleName(), $res ); |
| 38 | | - } |
| 39 | | - |
| 40 | | - public function mustBePosted() { |
| 41 | | - return true; |
| 42 | | - } |
| 43 | | - |
| 44 | | - public function isWriteMode() { |
| 45 | | - return true; |
| 46 | | - } |
| 47 | | - |
| 48 | | - public function getAllowedParams() { |
| 49 | | - return array( |
| 50 | | - 'resourcetype' => array( |
| 51 | | - ApiBase::PARAM_TYPE => 'string', |
| 52 | | - ApiBase::PARAM_REQUIRED => true |
| 53 | | - ), |
| 54 | | - 'record' => array( |
| 55 | | - ApiBase::PARAM_TYPE => 'integer', |
| 56 | | - ApiBase::PARAM_REQUIRED => true |
| 57 | | - ), |
| 58 | | - 'token' => null, |
| 59 | | - 'expiry' => array( |
| 60 | | - ApiBase::PARAM_TYPE => 'integer' |
| 61 | | - ), |
| 62 | | - 'ccaction' => array( |
| 63 | | - ApiBase::PARAM_REQUIRED => true, |
| 64 | | - ApiBase::PARAM_TYPE => array( |
| 65 | | - 'checkout', |
| 66 | | - 'checkin', |
| 67 | | - ), |
| 68 | | - ), |
| 69 | | - ); |
| 70 | | - } |
| 71 | | - |
| 72 | | - public function getParamDescription() { |
| 73 | | - return array( |
| 74 | | - 'resourcetype' => 'the resource type for concurrency check', |
| 75 | | - 'record' => 'an unique identifier for a record of the defined resource type', |
| 76 | | - 'expiry' => 'the time interval for expiration', |
| 77 | | - 'ccaction' => 'the action for concurrency check', |
| 78 | | - ); |
| 79 | | - } |
| 80 | | - |
| 81 | | - public function getDescription() { |
| 82 | | - return 'Get/Set a concurrency check for a web resource type'; |
| 83 | | - } |
| 84 | | - |
| 85 | | - public function needsToken() { |
| 86 | | - return true; |
| 87 | | - } |
| 88 | | - |
| 89 | | - public function getTokenSalt() { |
| 90 | | - return ''; |
| 91 | | - } |
| 92 | | - |
| 93 | | - public function getVersion() { |
| 94 | | - return __CLASS__ . ': $Id$'; |
| 95 | | - } |
| 96 | | - |
| 97 | | - private function checkPermission( $user ) { |
| 98 | | - if ( $user->isAnon() ) { |
| 99 | | - $this->dieUsage( "You don't have permission to do that", 'permission-denied' ); |
| 100 | | - } |
| 101 | | - if ( $user->isBlocked( false ) ) { |
| 102 | | - $this->dieUsageMsg( array( 'blockedtext' ) ); |
| 103 | | - } |
| 104 | | - } |
| 105 | | - |
| 106 | | -} |
| Index: trunk/phase3/includes/api/ApiMain.php |
| — | — | @@ -79,7 +79,6 @@ |
| 80 | 80 | 'patrol' => 'ApiPatrol', |
| 81 | 81 | 'import' => 'ApiImport', |
| 82 | 82 | 'userrights' => 'ApiUserrights', |
| 83 | | - 'concurrency' => 'ApiConcurrency', |
| 84 | 83 | ); |
| 85 | 84 | |
| 86 | 85 | /** |
| Index: trunk/phase3/includes/DefaultSettings.php |
| — | — | @@ -5717,16 +5717,6 @@ |
| 5718 | 5718 | $wgDBtestpassword = ''; |
| 5719 | 5719 | |
| 5720 | 5720 | /** |
| 5721 | | - * ConcurrencyCheck keeps track of which web resources are in use, for producing higher-quality UI |
| 5722 | | - */ |
| 5723 | | -$wgConcurrency = array(); |
| 5724 | | -$wgConcurrency['ExpirationDefault'] = 60 * 15; // Default checkout duration. 15 minutes. |
| 5725 | | -$wgConcurrency['ExpirationMax'] = 60 * 30; // Maximum possible checkout duration. 30 minutes. |
| 5726 | | -$wgConcurrency['ExpirationMin'] = 1; // Minimum possible checkout duration. Negative is possible for testing if you want. |
| 5727 | | -$wgConcurrency['TrustMemc'] = true; // If running in an environment with multiple discrete caches, set to false. |
| 5728 | | - |
| 5729 | | - |
| 5730 | | -/** |
| 5731 | 5721 | * For really cool vim folding this needs to be at the end: |
| 5732 | 5722 | * vim: foldmarker=@{,@} foldmethod=marker |
| 5733 | 5723 | * @} |