tests/phpunit/includes/db/LBFactoryTest.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @file
  19  * @author Antoine Musso
  20  * @copyright © 2013 Antoine Musso
  21  * @copyright © 2013 Wikimedia Foundation Inc.
  22  */
  23
  24 use MediaWiki\WikiMap\WikiMap;
  25 use Wikimedia\ObjectCache\HashBagOStuff;
  26 use Wikimedia\Rdbms\ChronologyProtector;
  27 use Wikimedia\Rdbms\Database;
  28 use Wikimedia\Rdbms\DatabaseDomain;
  29 use Wikimedia\Rdbms\IDatabase;
  30 use Wikimedia\Rdbms\IDatabaseForOwner;
  31 use Wikimedia\Rdbms\ILBFactory;
  32 use Wikimedia\Rdbms\IMaintainableDatabase;
  33 use Wikimedia\Rdbms\IReadableDatabase;
  34 use Wikimedia\Rdbms\LBFactoryMulti;
  35 use Wikimedia\Rdbms\LBFactorySimple;
  36 use Wikimedia\Rdbms\LoadBalancer;
  37 use Wikimedia\Rdbms\LoadMonitorNull;
  38 use Wikimedia\Rdbms\MySQLPrimaryPos;
  39 use Wikimedia\TestingAccessWrapper;
  40
  41 /**
  42  * @group Database
  43  * @covers \Wikimedia\Rdbms\ChronologyProtector
  44  * @covers \Wikimedia\Rdbms\DatabaseMySQL
  45  * @covers \Wikimedia\Rdbms\DatabasePostgres
  46  * @covers \Wikimedia\Rdbms\DatabaseSqlite
  47  * @covers \Wikimedia\Rdbms\LBFactory
  48  * @covers \Wikimedia\Rdbms\LBFactory
  49  * @covers \Wikimedia\Rdbms\LBFactoryMulti
  50  * @covers \Wikimedia\Rdbms\LBFactorySimple
  51  * @covers \Wikimedia\Rdbms\LoadBalancer
  52  */
  53 class LBFactoryTest extends MediaWikiIntegrationTestCase {
  54
  55         private function getPrimaryServerConfig() {
  56                 global $wgDBserver, $wgDBport, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype;
  57                 global $wgSQLiteDataDir;
  58
  59                 return [
  60                         'serverName'  => 'db1',
  61                         'host'        => $wgDBserver,
  62                         'port'        => $wgDBport,
  63                         'dbname'      => $wgDBname,
  64                         'user'        => $wgDBuser,
  65                         'password'    => $wgDBpassword,
  66                         'type'        => $wgDBtype,
  67                         'dbDirectory' => $wgSQLiteDataDir,
  68                         'load'        => 0,
  69                         'flags'       => DBO_TRX // REPEATABLE-READ for consistency
  70                 ];
  71         }
  72
  73         public function testLBFactorySimpleServer() {
  74                 $servers = [ $this->getPrimaryServerConfig() ];
  75                 $factory = new LBFactorySimple( [ 'servers' => $servers ] );
  76                 $lb = $factory->getMainLB();
  77
  78                 $dbw = $lb->getConnection( DB_PRIMARY );
  79                 $this->assertNotFalse( $dbw );
  80                 $dbr = $lb->getConnection( DB_REPLICA );
  81                 $this->assertNotFalse( $dbr );
  82
  83                 $this->assertSame( 'DEFAULT', $lb->getClusterName() );
  84
  85                 $factory->shutdown();
  86         }
  87
  88         public function testLBFactorySimpleServers() {
  89                 $primaryConfig = $this->getPrimaryServerConfig();
  90                 $fakeReplica = [ 'serverName' => 'db2', 'load' => 100 ] + $primaryConfig;
  91
  92                 $servers = [
  93                         $primaryConfig,
  94                         $fakeReplica
  95                 ];
  96
  97                 $factory = new LBFactorySimple( [
  98                         'servers' => $servers,
  99                         'loadMonitor' => [ 'class' => LoadMonitorNull::class ],
 100                 ] );
 101                 $lb = $factory->getMainLB();
 102
 103                 $dbw = $lb->getConnection( DB_PRIMARY );
 104                 $this->assertNotFalse( $dbw );
 105                 $dbr = $lb->getConnection( DB_REPLICA );
 106                 $this->assertNotFalse( $dbr );
 107
 108                 $factory->shutdown();
 109         }
 110
 111         public function testLBFactoryMultiConns() {
 112                 $factory = $this->newLBFactoryMultiLBs();
 113
 114                 $this->assertSame( 's3', $factory->getMainLB()->getClusterName() );
 115
 116                 $lb = $factory->getMainLB();
 117                 $dbw = $lb->getConnection( DB_PRIMARY );
 118                 $this->assertNotFalse( $dbw );
 119                 $dbr = $lb->getConnection( DB_REPLICA );
 120                 $this->assertNotFalse( $dbr );
 121
 122                 // Destructor should trigger without round stage errors
 123                 unset( $factory );
 124         }
 125
 126         public function testLBFactoryMultiRoundCallbacks() {
 127                 $called = 0;
 128                 $countLBsFunc = static function ( LBFactoryMulti $factory ) {
 129                         $count = 0;
 130                         foreach ( $factory->getAllLBs() as $lb ) {
 131                                 ++$count;
 132                         }
 133
 134                         return $count;
 135                 };
 136
 137                 $factory = $this->newLBFactoryMultiLBs();
 138                 $this->assertSame( 0, $countLBsFunc( $factory ) );
 139                 $dbw = $factory->getMainLB()->getConnection( DB_PRIMARY );
 140                 $this->assertSame( 1, $countLBsFunc( $factory ) );
 141                 // Test that LoadBalancer instances made during pre-commit callbacks in do not
 142                 // throw DBTransactionError due to transaction ROUND_* stages being mismatched.
 143                 $factory->beginPrimaryChanges( __METHOD__ );
 144                 $dbw->onTransactionPreCommitOrIdle( static function () use ( $factory, &$called ) {
 145                         ++$called;
 146                         // Trigger s1 LoadBalancer instantiation during "finalize" stage.
 147                         // There is no s1wiki DB to select so it is not in getConnection(),
 148                         // but this fools getMainLB() at least.
 149                         $factory->getMainLB( 's1wiki' )->getConnection( DB_PRIMARY );
 150                 } );
 151                 $factory->commitPrimaryChanges( __METHOD__ );
 152                 $this->assertSame( 1, $called );
 153                 $this->assertEquals( 2, $countLBsFunc( $factory ) );
 154                 $factory->shutdown();
 155                 $factory->closeAll( __METHOD__ );
 156
 157                 $called = 0;
 158                 $factory = $this->newLBFactoryMultiLBs();
 159                 $this->assertSame( 0, $countLBsFunc( $factory ) );
 160                 $dbw = $factory->getMainLB()->getConnection( DB_PRIMARY );
 161                 $this->assertSame( 1, $countLBsFunc( $factory ) );
 162                 // Test that LoadBalancer instances made during pre-commit callbacks in do not
 163                 // throw DBTransactionError due to transaction ROUND_* stages being mismatched.hrow
 164                 // DBTransactionError due to transaction ROUND_* stages being mismatched.
 165                 $factory->beginPrimaryChanges( __METHOD__ );
 166                 // phpcs:ignore MediaWiki.Usage.DbrQueryUsage.DbrQueryFound
 167                 $dbw->query( "SELECT 1 as t", __METHOD__ );
 168                 $dbw->onTransactionResolution( static function () use ( $factory, &$called ) {
 169                         ++$called;
 170                         // Trigger s1 LoadBalancer instantiation during "finalize" stage.
 171                         // There is no s1wiki DB to select so it is not in getConnection(),
 172                         // but this fools getMainLB() at least.
 173                         $factory->getMainLB( 's1wiki' )->getConnection( DB_PRIMARY );
 174                 } );
 175                 $factory->commitPrimaryChanges( __METHOD__ );
 176                 $this->assertSame( 1, $called );
 177                 $this->assertEquals( 2, $countLBsFunc( $factory ) );
 178                 $factory->shutdown();
 179                 $factory->closeAll( __METHOD__ );
 180
 181                 $factory = $this->newLBFactoryMultiLBs();
 182                 $dbw = $factory->getMainLB()->getConnection( DB_PRIMARY );
 183                 // DBTransactionError should not be thrown
 184                 $ran = 0;
 185                 $dbw->onTransactionPreCommitOrIdle( static function () use ( &$ran ) {
 186                         ++$ran;
 187                 } );
 188                 $factory->commitPrimaryChanges( __METHOD__ );
 189                 $this->assertSame( 1, $ran );
 190
 191                 $factory->shutdown();
 192                 $factory->closeAll( __METHOD__ );
 193         }
 194
 195         public function testLBFactoryMultiRoundTransactionSnapshots() {
 196                 $factory = $this->newLBFactoryMultiLBs();
 197                 $dbr = $factory->getMainLB()->getConnection( DB_REPLICA );
 198                 $dbw = $factory->getMainLB()->getConnection( DB_PRIMARY );
 199
 200                 $dbr->begin( __METHOD__, $dbr::TRANSACTION_INTERNAL );
 201                 $this->assertSame( 1, $dbr->trxLevel() );
 202                 $this->assertSame( 0, $dbw->trxLevel() );
 203
 204                 $factory->beginPrimaryChanges( __METHOD__ );
 205                 $this->assertSame( 0, $dbr->trxLevel() );
 206                 $this->assertSame( 0, $dbw->trxLevel() );
 207
 208                 $dbr->begin( __METHOD__, $dbr::TRANSACTION_INTERNAL );
 209                 $dbw->begin( __METHOD__, $dbw::TRANSACTION_INTERNAL );
 210                 $this->assertSame( 1, $dbr->trxLevel() );
 211                 $this->assertSame( 1, $dbw->trxLevel() );
 212
 213                 $factory->commitPrimaryChanges( __METHOD__ );
 214                 $this->assertSame( 0, $dbr->trxLevel() );
 215                 $this->assertSame( 0, $dbw->trxLevel() );
 216
 217                 $factory->beginPrimaryChanges( __METHOD__ );
 218                 // phpcs:ignore MediaWiki.Usage.DbrQueryUsage.DbrQueryFound
 219                 $dbr->query( 'SELECT 1', __METHOD__ );
 220                 $this->assertSame( 1, $dbr->trxLevel() );
 221                 $this->assertSame( 0, $dbw->trxLevel() );
 222
 223                 $factory->commitPrimaryChanges( __METHOD__ );
 224                 $this->assertSame( 0, $dbr->trxLevel() );
 225                 $this->assertSame( 0, $dbw->trxLevel() );
 226         }
 227
 228         private function newLBFactoryMultiLBs() {
 229                 global $wgDBserver, $wgDBport, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype;
 230                 global $wgSQLiteDataDir;
 231
 232                 return new LBFactoryMulti( [
 233                         'sectionsByDB' => [
 234                                 's1wiki' => 's1',
 235                                 'DEFAULT' => 's3'
 236                         ],
 237                         'sectionLoads' => [
 238                                 's1' => [
 239                                         'test-db3' => 0,
 240                                         'test-db4' => 100,
 241                                 ],
 242                                 's3' => [
 243                                         'test-db1' => 0,
 244                                         'test-db2' => 100,
 245                                 ]
 246                         ],
 247                         'serverTemplate' => [
 248                                 'port' => $wgDBport,
 249                                 'dbname' => $wgDBname,
 250                                 'user' => $wgDBuser,
 251                                 'password' => $wgDBpassword,
 252                                 'type' => $wgDBtype,
 253                                 'dbDirectory' => $wgSQLiteDataDir,
 254                                 'flags' => DBO_DEFAULT
 255                         ],
 256                         'hostsByName' => [
 257                                 'test-db1' => $wgDBserver,
 258                                 'test-db2' => $wgDBserver,
 259                                 'test-db3' => $wgDBserver,
 260                                 'test-db4' => $wgDBserver
 261                         ],
 262                         'loadMonitor' => [ 'class' => LoadMonitorNull::class ],
 263                 ] );
 264         }
 265
 266         /**
 267          * @covers \Wikimedia\Rdbms\ChronologyProtector
 268          */
 269         public function testChronologyProtector() {
 270                 $now = microtime( true );
 271
 272                 $hasChangesFunc = static function ( $mockDB ) {
 273                         $p = $mockDB->writesOrCallbacksPending();
 274                         $last = $mockDB->lastDoneWrites();
 275
 276                         return is_float( $last ) || $p;
 277                 };
 278
 279                 // (a) First HTTP request
 280                 $m1Pos = new MySQLPrimaryPos( 'db1034-bin.000976/843431247', $now );
 281                 $m2Pos = new MySQLPrimaryPos( 'db1064-bin.002400/794074907', $now );
 282
 283                 // Primary DB 1
 284                 /** @var IDatabaseForOwner|\PHPUnit\Framework\MockObject\MockObject $mockDB1 */
 285                 $mockDB1 = $this->createMock( IDatabaseForOwner::class );
 286                 $mockDB1->method( 'writesOrCallbacksPending' )->willReturn( true );
 287                 $mockDB1->method( 'lastDoneWrites' )->willReturn( $now );
 288                 // Load balancer for primary DB 1
 289                 $lb1 = $this->createMock( LoadBalancer::class );
 290                 $lb1->method( 'getConnection' )->willReturn( $mockDB1 );
 291                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 292                 $lb1->method( 'hasReplicaServers' )->willReturn( true );
 293                 $lb1->method( 'hasStreamingReplicaServers' )->willReturn( true );
 294                 $lb1->method( 'getAnyOpenConnection' )->willReturn( $mockDB1 );
 295                 $lb1->method( 'hasOrMadeRecentPrimaryChanges' )->willReturnCallback(
 296                         static function () use ( $mockDB1, $hasChangesFunc ) {
 297                                 return $hasChangesFunc( $mockDB1 );
 298                         }
 299                 );
 300                 $lb1->method( 'getPrimaryPos' )->willReturn( $m1Pos );
 301                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 302                 // Primary DB 2
 303                 /** @var IDatabaseForOwner|\PHPUnit\Framework\MockObject\MockObject $mockDB2 */
 304                 $mockDB2 = $this->createMock( IDatabaseForOwner::class );
 305                 $mockDB2->method( 'writesOrCallbacksPending' )->willReturn( true );
 306                 $mockDB2->method( 'lastDoneWrites' )->willReturn( $now );
 307                 // Load balancer for primary DB 2
 308                 $lb2 = $this->createMock( LoadBalancer::class );
 309                 $lb2->method( 'getConnection' )->willReturn( $mockDB2 );
 310                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 311                 $lb2->method( 'hasReplicaServers' )->willReturn( true );
 312                 $lb2->method( 'hasStreamingReplicaServers' )->willReturn( true );
 313                 $lb2->method( 'getAnyOpenConnection' )->willReturn( $mockDB2 );
 314                 $lb2->method( 'hasOrMadeRecentPrimaryChanges' )->willReturnCallback(
 315                         static function () use ( $mockDB2, $hasChangesFunc ) {
 316                                 return $hasChangesFunc( $mockDB2 );
 317                         }
 318                 );
 319                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 320                 $lb2->method( 'getPrimaryPos' )->willReturn( $m2Pos );
 321
 322                 $bag = new HashBagOStuff();
 323                 $cp = new ChronologyProtector( $bag, null, false );
 324                 $cp->setRequestInfo( [
 325                         'IPAddress' => '127.0.0.1',
 326                         'UserAgent' => 'Totally-Not-Firefox',
 327                         'ChronologyClientId' => 'random_id',
 328                 ] );
 329
 330                 $mockDB1->expects( $this->once() )->method( 'writesOrCallbacksPending' );
 331                 $mockDB1->expects( $this->once() )->method( 'lastDoneWrites' );
 332                 $mockDB2->expects( $this->once() )->method( 'writesOrCallbacksPending' );
 333                 $mockDB2->expects( $this->once() )->method( 'lastDoneWrites' );
 334
 335                 // Nothing to wait for on first HTTP request start
 336                 $sPos1 = $cp->getSessionPrimaryPos( $lb1 );
 337                 $sPos2 = $cp->getSessionPrimaryPos( $lb2 );
 338                 // Record positions in stash on first HTTP request end
 339                 $cp->stageSessionPrimaryPos( $lb1 );
 340                 $cp->stageSessionPrimaryPos( $lb2 );
 341                 $cpIndex = null;
 342                 $cp->persistSessionReplicationPositions( $cpIndex );
 343
 344                 $this->assertNull( $sPos1 );
 345                 $this->assertNull( $sPos2 );
 346                 $this->assertSame( 1, $cpIndex, "CP write index set" );
 347
 348                 // (b) Second HTTP request
 349
 350                 // Load balancer for primary DB 1
 351                 $lb1 = $this->createMock( LoadBalancer::class );
 352                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 353                 $lb1->method( 'hasReplicaServers' )->willReturn( true );
 354                 $lb1->method( 'hasStreamingReplicaServers' )->willReturn( true );
 355                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 356                 // Load balancer for primary DB 2
 357                 $lb2 = $this->createMock( LoadBalancer::class );
 358                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 359                 $lb2->method( 'hasReplicaServers' )->willReturn( true );
 360                 $lb2->method( 'hasStreamingReplicaServers' )->willReturn( true );
 361                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 362
 363                 $cp = new ChronologyProtector( $bag, null, false );
 364                 $cp->setRequestInfo(
 365                 [
 366                         'IPAddress' => '127.0.0.1',
 367                         'UserAgent' => 'Totally-Not-Firefox',
 368                         'ChronologyClientId' => 'random_id',
 369                         'ChronologyPositionIndex' => $cpIndex
 370                 ] );
 371
 372                 // Get last positions to be reached on second HTTP request start
 373                 $sPos1 = $cp->getSessionPrimaryPos( $lb1 );
 374                 $sPos2 = $cp->getSessionPrimaryPos( $lb2 );
 375                 // Shutdown (nothing to record)
 376                 $cp->stageSessionPrimaryPos( $lb1 );
 377                 $cp->stageSessionPrimaryPos( $lb2 );
 378                 $cpIndex = null;
 379                 $cp->persistSessionReplicationPositions( $cpIndex );
 380
 381                 $this->assertNotNull( $sPos1 );
 382                 $this->assertNotNull( $sPos2 );
 383                 $this->assertSame( $m1Pos->__toString(), $sPos1->__toString() );
 384                 $this->assertSame( $m2Pos->__toString(), $sPos2->__toString() );
 385                 $this->assertNull( $cpIndex, "CP write index retained" );
 386
 387                 $this->assertEquals( 'random_id', $cp->getClientId() );
 388         }
 389
 390         private function newLBFactoryMulti( array $baseOverride = [], array $serverOverride = [] ) {
 391                 global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBprefix, $wgDBtype;
 392                 global $wgSQLiteDataDir;
 393
 394                 return new LBFactoryMulti( $baseOverride + [
 395                         'sectionsByDB' => [],
 396                         'sectionLoads' => [
 397                                 'DEFAULT' => [
 398                                         'test-db1' => 1,
 399                                 ],
 400                         ],
 401                         'serverTemplate' => $serverOverride + [
 402                                 'dbname' => $wgDBname,
 403                                 'tablePrefix' => $wgDBprefix,
 404                                 'user' => $wgDBuser,
 405                                 'password' => $wgDBpassword,
 406                                 'type' => $wgDBtype,
 407                                 'dbDirectory' => $wgSQLiteDataDir,
 408                                 'flags' => DBO_DEFAULT
 409                         ],
 410                         'hostsByName' => [
 411                                 'test-db1' => $wgDBserver,
 412                         ],
 413                         'loadMonitor' => [ 'class' => LoadMonitorNull::class ],
 414                         'localDomain' => new DatabaseDomain( $wgDBname, null, $wgDBprefix ),
 415                         'agent' => 'MW-UNIT-TESTS'
 416                 ] );
 417         }
 418
 419         public function testNiceDomains() {
 420                 global $wgDBname;
 421
 422                 if ( $this->getDb()->databasesAreIndependent() ) {
 423                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 424                         return;
 425                 }
 426
 427                 $factory = $this->newLBFactoryMulti(
 428                         [],
 429                         []
 430                 );
 431                 $lb = $factory->getMainLB();
 432
 433                 $db = $lb->getConnection( DB_PRIMARY );
 434                 $this->assertEquals(
 435                         WikiMap::getCurrentWikiId(),
 436                         $db->getDomainID()
 437                 );
 438                 unset( $db );
 439
 440                 /** @var IMaintainableDatabase $db */
 441                 $db = $lb->getConnection( DB_PRIMARY, [], $lb::DOMAIN_ANY );
 442
 443                 $this->assertSame(
 444                         '',
 445                         $db->getDomainID(),
 446                         'Null domain ID handle used'
 447                 );
 448                 $this->assertNull(
 449                         $db->getDBname(),
 450                         'Null domain ID handle used'
 451                 );
 452                 $this->assertSame(
 453                         '',
 454                         $db->tablePrefix(),
 455                         'Main domain ID handle used; prefix is empty though'
 456                 );
 457                 $this->assertEquals(
 458                         $this->quoteTable( $db, 'page' ),
 459                         $db->tableName( 'page' ),
 460                         "Correct full table name"
 461                 );
 462                 $this->assertEquals(
 463                         $this->quoteTable( $db, $wgDBname ) . '.' . $this->quoteTable( $db, 'page' ),
 464                         $db->tableName( "$wgDBname.page" ),
 465                         "Correct full table name"
 466                 );
 467                 $this->assertEquals(
 468                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 469                         $db->tableName( 'nice_db.page' ),
 470                         "Correct full table name"
 471                 );
 472
 473                 unset( $db );
 474
 475                 $factory->setLocalDomainPrefix( 'my_' );
 476                 $db = $lb->getConnection( DB_PRIMARY ); // local domain connection
 477
 478                 $this->assertEquals( $wgDBname, $db->getDBname() );
 479                 $this->assertEquals(
 480                         "$wgDBname-my_",
 481                         $db->getDomainID()
 482                 );
 483                 $this->assertEquals(
 484                         $this->quoteTable( $db, 'my_page' ),
 485                         $db->tableName( 'page' ),
 486                         "Correct full table name"
 487                 );
 488                 $this->assertEquals(
 489                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 490                         $db->tableName( 'other_nice_db.page' ),
 491                         "Correct full table name"
 492                 );
 493
 494                 $factory->closeAll( __METHOD__ );
 495                 $factory->destroy();
 496         }
 497
 498         public function testTrickyDomain() {
 499                 global $wgDBname;
 500
 501                 if ( $this->getDb()->databasesAreIndependent() ) {
 502                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 503                         return;
 504                 }
 505
 506                 $dbname = 'unittest-domain'; // explodes if DB is selected
 507                 $factory = $this->newLBFactoryMulti(
 508                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 509                         [
 510                                 'dbname' => 'do_not_select_me' // explodes if DB is selected
 511                         ]
 512                 );
 513                 $lb = $factory->getMainLB();
 514                 /** @var IMaintainableDatabase $db */
 515                 $db = $lb->getConnection( DB_PRIMARY, [], $lb::DOMAIN_ANY );
 516
 517                 $this->assertSame( '', $db->getDomainID(), "Null domain used" );
 518
 519                 $this->assertEquals(
 520                         $this->quoteTable( $db, 'page' ),
 521                         $db->tableName( 'page' ),
 522                         "Correct full table name"
 523                 );
 524
 525                 $this->assertEquals(
 526                         $this->quoteTable( $db, $dbname ) . '.' . $this->quoteTable( $db, 'page' ),
 527                         $db->tableName( "$dbname.page" ),
 528                         "Correct full table name"
 529                 );
 530
 531                 $this->assertEquals(
 532                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 533                         $db->tableName( 'nice_db.page' ),
 534                         "Correct full table name"
 535                 );
 536
 537                 unset( $db );
 538
 539                 $factory->setLocalDomainPrefix( 'my_' );
 540                 $db = $lb->getConnection( DB_PRIMARY, [], "$wgDBname-my_" );
 541
 542                 $this->assertEquals(
 543                         $this->quoteTable( $db, 'my_page' ),
 544                         $db->tableName( 'page' ),
 545                         "Correct full table name"
 546                 );
 547                 $this->assertEquals(
 548                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 549                         $db->tableName( 'other_nice_db.page' ),
 550                         "Correct full table name"
 551                 );
 552                 $this->assertEquals(
 553                         $this->quoteTable( $db, 'garbage-db' ) . '.' . $this->quoteTable( $db, 'page' ),
 554                         $db->tableName( 'garbage-db.page' ),
 555                         "Correct full table name"
 556                 );
 557
 558                 $factory->closeAll( __METHOD__ );
 559                 $factory->destroy();
 560         }
 561
 562         public function testInvalidSelectDB() {
 563                 if ( $this->getDb()->databasesAreIndependent() ) {
 564                         $this->markTestSkipped( "Not applicable per databasesAreIndependent()" );
 565                 }
 566
 567                 $dbname = 'unittest-domain'; // explodes if DB is selected
 568                 $factory = $this->newLBFactoryMulti(
 569                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 570                         [
 571                                 'dbname' => 'do_not_select_me' // explodes if DB is selected
 572                         ]
 573                 );
 574                 $lb = $factory->getMainLB();
 575                 /** @var IDatabase $db */
 576                 $db = $lb->getConnection( DB_PRIMARY, [], $lb::DOMAIN_ANY );
 577
 578                 $this->expectException( \Wikimedia\Rdbms\DBUnexpectedError::class );
 579                 $db->selectDomain( 'garbagedb' );
 580         }
 581
 582         public function testInvalidSelectDBIndependent() {
 583                 $dbname = 'unittest-domain'; // explodes if DB is selected
 584                 $factory = $this->newLBFactoryMulti(
 585                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 586                         [
 587                                 // Explodes with SQLite and Postgres during open/USE
 588                                 'dbname' => 'bad_dir/do_not_select_me'
 589                         ]
 590                 );
 591                 $lb = $factory->getMainLB();
 592
 593                 // FIXME: this should probably be lower (T235311)
 594                 $this->expectException( \Wikimedia\Rdbms\DBConnectionError::class );
 595                 if ( !$factory->getMainLB()->getServerAttributes( 0 )[Database::ATTR_DB_IS_FILE] ) {
 596                         $this->markTestSkipped( "Not applicable per ATTR_DB_IS_FILE" );
 597                 }
 598
 599                 /** @var IDatabase $db */
 600                 $this->assertNotNull( $lb->getConnectionInternal( DB_PRIMARY, [], $lb::DOMAIN_ANY ) );
 601         }
 602
 603         public function testInvalidSelectDBIndependent2() {
 604                 $dbname = 'unittest-domain'; // explodes if DB is selected
 605                 $factory = $this->newLBFactoryMulti(
 606                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 607                         [
 608                                 // Explodes with SQLite and Postgres during open/USE
 609                                 'dbname' => 'bad_dir/do_not_select_me'
 610                         ]
 611                 );
 612                 $lb = $factory->getMainLB();
 613
 614                 // FIXME: this should probably be lower (T235311)
 615                 $this->expectException( \Wikimedia\Rdbms\DBExpectedError::class );
 616                 if ( !$lb->getConnection( DB_PRIMARY )->databasesAreIndependent() ) {
 617                         $this->markTestSkipped( "Not applicable per databasesAreIndependent()" );
 618                 }
 619
 620                 $db = $lb->getConnectionInternal( DB_PRIMARY );
 621                 $db->selectDomain( 'garbage-db' );
 622         }
 623
 624         public function testRedefineLocalDomain() {
 625                 global $wgDBname;
 626
 627                 if ( $this->getDb()->databasesAreIndependent() ) {
 628                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 629                         return;
 630                 }
 631
 632                 $factory = $this->newLBFactoryMulti(
 633                         [],
 634                         []
 635                 );
 636                 $lb = $factory->getMainLB();
 637
 638                 $conn1 = $lb->getConnection( DB_PRIMARY );
 639                 $this->assertEquals(
 640                         WikiMap::getCurrentWikiId(),
 641                         $conn1->getDomainID()
 642                 );
 643                 unset( $conn1 );
 644
 645                 $factory->redefineLocalDomain( 'somedb-prefix_' );
 646                 $this->assertEquals( 'somedb-prefix_', $factory->getLocalDomainID() );
 647
 648                 $domain = new DatabaseDomain( $wgDBname, null, 'pref_' );
 649                 $factory->redefineLocalDomain( $domain );
 650
 651                 /** @var LoadBalancer $lbWrapper */
 652                 $lbWrapper = TestingAccessWrapper::newFromObject( $lb );
 653                 $n = iterator_count( $lbWrapper->getOpenConnections() );
 654                 $this->assertSame( 0, $n, "Connections closed" );
 655
 656                 $conn2 = $lb->getConnection( DB_PRIMARY );
 657                 $this->assertEquals(
 658                         $domain->getId(),
 659                         $conn2->getDomainID()
 660                 );
 661                 unset( $conn2 );
 662
 663                 $factory->closeAll( __METHOD__ );
 664                 $factory->destroy();
 665         }
 666
 667         public function testVirtualDomains() {
 668                 $baseOverrides = [
 669                         'localDomain' => ( new DatabaseDomain( 'localdomain', null, '' ) )->getId(),
 670                         'sectionLoads' => [
 671                                 'DEFAULT' => [
 672                                         'test-db1' => 1,
 673                                 ],
 674                                 'shareddb' => [
 675                                         'test-db1' => 1,
 676                                 ],
 677                         ],
 678                         'externalLoads' => [
 679                                 'extension1' => [
 680                                         'test-db1' => 1,
 681                                 ],
 682                         ],
 683                         'virtualDomains' => [ 'virtualdomain1', 'virtualdomain2', 'virtualdomain3', 'virtualdomain4' ],
 684                         'virtualDomainsMapping' => [
 685                                 'virtualdomain1' => [ 'db' => 'extdomain', 'cluster' => 'extension1' ],
 686                                 'virtualdomain2' => [ 'db' => false, 'cluster' => 'extension1' ],
 687                                 'virtualdomain3' => [ 'db' => 'shareddb' ],
 688                         ]
 689                 ];
 690                 $factory = $this->newLBFactoryMulti( $baseOverrides );
 691                 $db1 = $factory->getPrimaryDatabase( 'virtualdomain1' );
 692                 $this->assertEquals(
 693                         'extdomain',
 694                         $db1->getDomainID()
 695                 );
 696                 $this->assertEquals(
 697                         'extdomain',
 698                         $factory->getAutoCommitPrimaryConnection( 'virtualdomain1' )->getDomainID()
 699                 );
 700                 $this->assertEquals(
 701                         'extension1',
 702                         $factory->getLoadBalancer( 'virtualdomain1' )->getClusterName()
 703                 );
 704
 705                 $db2 = $factory->getPrimaryDatabase( 'virtualdomain2' );
 706                 $this->assertEquals(
 707                         'localdomain',
 708                         $db2->getDomainID()
 709                 );
 710                 $this->assertEquals(
 711                         'localdomain',
 712                         $factory->getAutoCommitPrimaryConnection( 'virtualdomain2' )->getDomainID()
 713                 );
 714                 $this->assertEquals(
 715                         'extension1',
 716                         $factory->getLoadBalancer( 'virtualdomain2' )->getClusterName()
 717                 );
 718
 719                 $db3 = $factory->getPrimaryDatabase( 'virtualdomain3' );
 720                 $this->assertEquals(
 721                         'shareddb',
 722                         $db3->getDomainID()
 723                 );
 724                 $this->assertEquals(
 725                         'shareddb',
 726                         $factory->getAutoCommitPrimaryConnection( 'virtualdomain3' )->getDomainID()
 727                 );
 728                 $this->assertEquals(
 729                         'DEFAULT',
 730                         $factory->getLoadBalancer( 'virtualdomain3' )->getClusterName()
 731                 );
 732
 733                 $db4 = $factory->getPrimaryDatabase( 'virtualdomain4' );
 734                 $this->assertEquals(
 735                         'localdomain',
 736                         $db4->getDomainID()
 737                 );
 738                 $this->assertEquals(
 739                         'localdomain',
 740                         $factory->getAutoCommitPrimaryConnection( 'virtualdomain4' )->getDomainID()
 741                 );
 742                 $this->assertEquals(
 743                         'DEFAULT',
 744                         $factory->getLoadBalancer( 'virtualdomain4' )->getClusterName()
 745                 );
 746         }
 747
 748         private function quoteTable( IReadableDatabase $db, $table ) {
 749                 if ( $db->getType() === 'sqlite' ) {
 750                         return $table;
 751                 } else {
 752                         return $db->addIdentifierQuotes( $table );
 753                 }
 754         }
 755
 756         public function testGetChronologyProtectorTouched() {
 757                 $store = new HashBagOStuff;
 758                 $chronologyProtector = new ChronologyProtector( $store, '', false );
 759                 $chronologyProtector->setRequestInfo( [ 'ChronologyClientId' => 'ii' ] );
 760
 761                 // 2019-02-05T05:03:20Z
 762                 $mockWallClock = 1549343000.0;
 763                 $priorTime = $mockWallClock; // reference time
 764                 $chronologyProtector->setMockTime( $mockWallClock );
 765
 766                 $cpWrap = TestingAccessWrapper::newFromObject( $chronologyProtector );
 767                 $cpWrap->store->set(
 768                         $cpWrap->key,
 769                         $cpWrap->mergePositions(
 770                                 false,
 771                                 [],
 772                                 [ ILBFactory::CLUSTER_MAIN_DEFAULT => $priorTime ]
 773                         ),
 774                         3600
 775                 );
 776
 777                 $lbFactory = $this->newLBFactoryMulti( [ 'chronologyProtector' => $chronologyProtector ] );
 778                 $mockWallClock += 1.0;
 779                 $touched = $chronologyProtector->getTouched( $lbFactory->getMainLB() );
 780                 $this->assertEquals( $priorTime, $touched );
 781         }
 782
 783         public function testReconfigureWithOneReplica() {
 784                 $primaryConfig = $this->getPrimaryServerConfig();
 785                 $fakeReplica = [ 'load' => 100, 'serverName' => 'replica' ] + $primaryConfig;
 786
 787                 $conf = [ 'servers' => [
 788                         $primaryConfig,
 789                         $fakeReplica
 790                 ] ];
 791
 792                 // Configure an LBFactory with one replica
 793                 $factory = new LBFactorySimple( $conf );
 794                 $lb = $factory->getMainLB();
 795                 $this->assertSame( 2, $lb->getServerCount() );
 796
 797                 $con = $lb->getConnectionInternal( DB_REPLICA );
 798                 $ref = $lb->getConnection( DB_REPLICA );
 799
 800                 // Call reconfigure with the same config, should have no effect
 801                 $factory->reconfigure( $conf );
 802                 $this->assertSame( 2, $lb->getServerCount() );
 803                 $this->assertTrue( $con->isOpen() );
 804                 $this->assertTrue( $ref->isOpen() );
 805
 806                 // Call reconfigure with empty config, should have no effect
 807                 $factory->reconfigure( [] );
 808                 $this->assertSame( 2, $lb->getServerCount() );
 809                 $this->assertTrue( $con->isOpen() );
 810                 $this->assertTrue( $ref->isOpen() );
 811
 812                 // Reconfigure the LBFactory to only have a single server.
 813                 $conf['servers'] = [ $this->getPrimaryServerConfig() ];
 814                 $factory->reconfigure( $conf );
 815
 816                 // The LoadBalancer should have been reconfigured automatically.
 817                 $this->assertSame( 1, $lb->getServerCount() );
 818
 819                 // Reconfiguring should not close connections immediately.
 820                 $this->assertTrue( $con->isOpen() );
 821
 822                 // Connection refs should detect the config change, close the old connection,
 823                 // and get a new connection.
 824                 $this->assertTrue( $ref->isOpen() );
 825
 826                 // The old connection should have been closed by DBConnRef.
 827                 $this->assertFalse( $con->isOpen() );
 828         }
 829
 830         public function testReconfigureWithThreeReplicas() {
 831                 $primaryConfig = $this->getPrimaryServerConfig();
 832                 $replica1Config = [ 'serverName' => 'db2', 'load' => 0 ] + $primaryConfig;
 833                 $replica2Config = [ 'serverName' => 'db3', 'load' => 1 ] + $primaryConfig;
 834                 $replica3Config = [ 'serverName' => 'db4', 'load' => 1 ] + $primaryConfig;
 835
 836                 $conf = [ 'servers' => [
 837                         $primaryConfig,
 838                         $replica1Config,
 839                         $replica2Config,
 840                         $replica3Config
 841                 ] ];
 842
 843                 // Configure an LBFactory with two replicas
 844                 $factory = new LBFactorySimple( $conf );
 845                 $lb = $factory->getMainLB();
 846                 $this->assertSame( 4, $lb->getServerCount() );
 847                 $this->assertSame( 'db1', $lb->getServerName( 0 ) );
 848                 $this->assertSame( 'db2', $lb->getServerName( 1 ) );
 849                 $this->assertSame( 'db3', $lb->getServerName( 2 ) );
 850                 $this->assertSame( 'db4', $lb->getServerName( 3 ) );
 851
 852                 $con = $lb->getConnectionInternal( DB_REPLICA );
 853                 $ref = $lb->getConnection( DB_REPLICA );
 854
 855                 // Call reconfigure with the same config, should have no effect
 856                 $factory->reconfigure( $conf );
 857                 $this->assertSame( 4, $lb->getServerCount() );
 858                 $this->assertSame( 'db1', $lb->getServerName( 0 ) );
 859                 $this->assertSame( 'db2', $lb->getServerName( 1 ) );
 860                 $this->assertSame( 'db3', $lb->getServerName( 2 ) );
 861                 $this->assertSame( 'db4', $lb->getServerName( 3 ) );
 862                 $this->assertTrue( $con->isOpen() );
 863                 $this->assertTrue( $ref->isOpen() );
 864
 865                 // Call reconfigure with empty config, should have no effect
 866                 $factory->reconfigure( [] );
 867                 $this->assertSame( 4, $lb->getServerCount() );
 868                 $this->assertSame( 'db1', $lb->getServerName( 0 ) );
 869                 $this->assertSame( 'db2', $lb->getServerName( 1 ) );
 870                 $this->assertSame( 'db3', $lb->getServerName( 2 ) );
 871                 $this->assertSame( 'db4', $lb->getServerName( 3 ) );
 872                 $this->assertTrue( $con->isOpen() );
 873                 $this->assertTrue( $ref->isOpen() );
 874
 875                 // Reconfigure the LBFactory to only have a two servers (server indexes shifted).
 876                 $conf['servers'] = [ $primaryConfig, $replica2Config, $replica3Config ];
 877                 $factory->reconfigure( $conf );
 878                 // The LoadBalancer should have been reconfigured automatically.
 879                 $this->assertSame( 3, $lb->getServerCount() );
 880                 $this->assertSame( 'db1', $lb->getServerName( 0 ) );
 881                 $this->assertSame( false, $lb->getServerInfo( 1 ) );
 882                 $this->assertSame( 'db3', $lb->getServerName( 2 ) );
 883                 $this->assertSame( 'db4', $lb->getServerName( 3 ) );
 884                 // Reconfiguring should not close connections immediately.
 885                 $this->assertTrue( $con->isOpen() );
 886                 // Connection refs should detect the config change, close the old connection,
 887                 // and get a new connection.
 888                 $this->assertTrue( $ref->isOpen() );
 889                 // The old connection should have been closed by DBConnRef.
 890                 $this->assertFalse( $con->isOpen() );
 891         }
 892
 893         public function testAutoReconfigure() {
 894                 $primaryConfig = $this->getPrimaryServerConfig();
 895                 $fakeReplica = [ 'load' => 100, 'serverName' => 'replica1' ] + $primaryConfig;
 896
 897                 $conf = [
 898                         'servers' => [
 899                                 $primaryConfig,
 900                                 $fakeReplica
 901                         ],
 902                 ];
 903
 904                 // The config callback should return $conf, reflecting changes
 905                 // made to the local variable.
 906                 $conf['configCallback'] = static function () use ( &$conf ) {
 907                         static $calls = 0;
 908                         $calls++;
 909                         if ( $calls == 1 ) {
 910                                 return $conf;
 911                         } else {
 912                                 unset( $conf['servers'][1] );
 913                                 return $conf;
 914                         }
 915                 };
 916
 917                 // Configure an LBFactory with one replica
 918                 $factory = new LBFactorySimple( $conf );
 919
 920                 $lb = $factory->getMainLB();
 921                 $this->assertSame( 2, $lb->getServerCount() );
 922
 923                 $con = $lb->getConnectionInternal( DB_REPLICA );
 924                 $ref = $lb->getConnection( DB_REPLICA );
 925
 926                 // Nothing changed, autoReconfigure() should do nothing.
 927                 $factory->autoReconfigure();
 928
 929                 $this->assertSame( 2, $lb->getServerCount() );
 930                 $this->assertTrue( $con->isOpen() );
 931                 $this->assertTrue( $ref->isOpen() );
 932
 933                 // Now autoReconfigure() should detect the change and reconfigure all LoadBalancers.
 934                 $factory->autoReconfigure();
 935
 936                 // The LoadBalancer should have been reconfigured now.
 937                 $this->assertSame( 1, $lb->getServerCount() );
 938
 939                 // Reconfiguring should not close connections immediately.
 940                 $this->assertTrue( $con->isOpen() );
 941
 942                 // Connection refs should detect the config change, close the old connection,
 943                 // and get a new connection.
 944                 $this->assertTrue( $ref->isOpen() );
 945
 946                 // The old connection should have been called by DBConnRef.
 947                 $this->assertFalse( $con->isOpen() );
 948         }
 949
 950         public function testSetWaitForReplicationListener() {
 951                 $factory = $this->newLBFactoryMultiLBs();
 952
 953                 $allLBs = iterator_to_array( $factory->getAllLBs() );
 954                 $this->assertCount( 0, $allLBs );
 955
 956                 $runs = 0;
 957                 $callback = static function () use ( &$runs ) {
 958                         ++$runs;
 959                 };
 960                 $factory->setWaitForReplicationListener( 'test', $callback );
 961
 962                 $this->assertSame( 0, $runs );
 963                 $factory->waitForReplication();
 964                 $this->assertSame( 1, $runs );
 965
 966                 $factory->getMainLB();
 967                 $allLBs = iterator_to_array( $factory->getAllLBs() );
 968                 $this->assertCount( 1, $allLBs );
 969                 $factory->waitForReplication();
 970                 $this->assertSame( 2, $runs );
 971         }
 972 }