tests/phpunit/includes/db/LBFactoryTest.php

   1 <?php
   2 /**
   3  * Holds tests for LBFactory abstract MediaWiki class.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @author Antoine Musso
  22  * @copyright © 2013 Antoine Musso
  23  * @copyright © 2013 Wikimedia Foundation Inc.
  24  */
  25
  26 use Wikimedia\Rdbms\LBFactorySimple;
  27 use Wikimedia\Rdbms\LBFactoryMulti;
  28 use Wikimedia\Rdbms\ChronologyProtector;
  29 use Wikimedia\Rdbms\MySQLMasterPos;
  30 use Wikimedia\Rdbms\DatabaseDomain;
  31
  32 /**
  33  * @group Database
  34  * @covers \Wikimedia\Rdbms\LBFactorySimple
  35  * @covers \Wikimedia\Rdbms\LBFactoryMulti
  36  */
  37 class LBFactoryTest extends MediaWikiTestCase {
  38
  39         /**
  40          * @covers MWLBFactory::getLBFactoryClass
  41          * @dataProvider getLBFactoryClassProvider
  42          */
  43         public function testGetLBFactoryClass( $expected, $deprecated ) {
  44                 $mockDB = $this->getMockBuilder( 'DatabaseMysqli' )
  45                         ->disableOriginalConstructor()
  46                         ->getMock();
  47
  48                 $config = [
  49                         'class'          => $deprecated,
  50                         'connection'     => $mockDB,
  51                         # Various other parameters required:
  52                         'sectionsByDB'   => [],
  53                         'sectionLoads'   => [],
  54                         'serverTemplate' => [],
  55                 ];
  56
  57                 $this->hideDeprecated( '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details' );
  58                 $result = MWLBFactory::getLBFactoryClass( $config );
  59
  60                 $this->assertEquals( $expected, $result );
  61         }
  62
  63         public function getLBFactoryClassProvider() {
  64                 return [
  65                         # Format: new class, old class
  66                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactory_Simple' ],
  67                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactory_Single' ],
  68                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactory_Multi' ],
  69                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactorySimple' ],
  70                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactorySingle' ],
  71                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactoryMulti' ],
  72                 ];
  73         }
  74
  75         public function testLBFactorySimpleServer() {
  76                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
  77
  78                 $servers = [
  79                         [
  80                                 'host'        => $wgDBserver,
  81                                 'dbname'      => $wgDBname,
  82                                 'user'        => $wgDBuser,
  83                                 'password'    => $wgDBpassword,
  84                                 'type'        => $wgDBtype,
  85                                 'dbDirectory' => $wgSQLiteDataDir,
  86                                 'load'        => 0,
  87                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
  88                         ],
  89                 ];
  90
  91                 $factory = new LBFactorySimple( [ 'servers' => $servers ] );
  92                 $lb = $factory->getMainLB();
  93
  94                 $dbw = $lb->getConnection( DB_MASTER );
  95                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
  96
  97                 $dbr = $lb->getConnection( DB_REPLICA );
  98                 $this->assertTrue( $dbr->getLBInfo( 'master' ), 'DB_REPLICA also gets the master' );
  99
 100                 $factory->shutdown();
 101                 $lb->closeAll();
 102         }
 103
 104         public function testLBFactorySimpleServers() {
 105                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 106
 107                 $servers = [
 108                         [ // master
 109                                 'host'        => $wgDBserver,
 110                                 'dbname'      => $wgDBname,
 111                                 'user'        => $wgDBuser,
 112                                 'password'    => $wgDBpassword,
 113                                 'type'        => $wgDBtype,
 114                                 'dbDirectory' => $wgSQLiteDataDir,
 115                                 'load'        => 0,
 116                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 117                         ],
 118                         [ // emulated slave
 119                                 'host'        => $wgDBserver,
 120                                 'dbname'      => $wgDBname,
 121                                 'user'        => $wgDBuser,
 122                                 'password'    => $wgDBpassword,
 123                                 'type'        => $wgDBtype,
 124                                 'dbDirectory' => $wgSQLiteDataDir,
 125                                 'load'        => 100,
 126                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 127                         ]
 128                 ];
 129
 130                 $factory = new LBFactorySimple( [
 131                         'servers' => $servers,
 132                         'loadMonitorClass' => 'LoadMonitorNull'
 133                 ] );
 134                 $lb = $factory->getMainLB();
 135
 136                 $dbw = $lb->getConnection( DB_MASTER );
 137                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 138                 $this->assertEquals(
 139                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 140                         $dbw->getLBInfo( 'clusterMasterHost' ),
 141                         'cluster master set' );
 142
 143                 $dbr = $lb->getConnection( DB_REPLICA );
 144                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 145                 $this->assertEquals(
 146                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 147                         $dbr->getLBInfo( 'clusterMasterHost' ),
 148                         'cluster master set' );
 149
 150                 $factory->shutdown();
 151                 $lb->closeAll();
 152         }
 153
 154         public function testLBFactoryMulti() {
 155                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 156
 157                 $factory = new LBFactoryMulti( [
 158                         'sectionsByDB' => [],
 159                         'sectionLoads' => [
 160                                 'DEFAULT' => [
 161                                         'test-db1' => 0,
 162                                         'test-db2' => 100,
 163                                 ],
 164                         ],
 165                         'serverTemplate' => [
 166                                 'dbname'      => $wgDBname,
 167                                 'user'        => $wgDBuser,
 168                                 'password'    => $wgDBpassword,
 169                                 'type'        => $wgDBtype,
 170                                 'dbDirectory' => $wgSQLiteDataDir,
 171                                 'flags'       => DBO_DEFAULT
 172                         ],
 173                         'hostsByName' => [
 174                                 'test-db1'  => $wgDBserver,
 175                                 'test-db2'  => $wgDBserver
 176                         ],
 177                         'loadMonitorClass' => 'LoadMonitorNull'
 178                 ] );
 179                 $lb = $factory->getMainLB();
 180
 181                 $dbw = $lb->getConnection( DB_MASTER );
 182                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 183
 184                 $dbr = $lb->getConnection( DB_REPLICA );
 185                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 186
 187                 $factory->shutdown();
 188                 $lb->closeAll();
 189         }
 190
 191         /**
 192          * @covers \Wikimedia\Rdbms\ChronologyProtector
 193          */
 194         public function testChronologyProtector() {
 195                 // (a) First HTTP request
 196                 $m1Pos = new MySQLMasterPos( 'db1034-bin.000976', '843431247' );
 197                 $m2Pos = new MySQLMasterPos( 'db1064-bin.002400', '794074907' );
 198
 199                 $now = microtime( true );
 200
 201                 // Master DB 1
 202                 $mockDB1 = $this->getMockBuilder( 'DatabaseMysqli' )
 203                         ->disableOriginalConstructor()
 204                         ->getMock();
 205                 $mockDB1->method( 'writesOrCallbacksPending' )->willReturn( true );
 206                 $mockDB1->method( 'lastDoneWrites' )->willReturn( $now );
 207                 $mockDB1->method( 'getMasterPos' )->willReturn( $m1Pos );
 208                 // Load balancer for master DB 1
 209                 $lb1 = $this->getMockBuilder( 'LoadBalancer' )
 210                         ->disableOriginalConstructor()
 211                         ->getMock();
 212                 $lb1->method( 'getConnection' )->willReturn( $mockDB1 );
 213                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 214                 $lb1->method( 'getAnyOpenConnection' )->willReturn( $mockDB1 );
 215                 $lb1->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 216                                 function () use ( $mockDB1 ) {
 217                                         $p = 0;
 218                                         $p |= call_user_func( [ $mockDB1, 'writesOrCallbacksPending' ] );
 219                                         $p |= call_user_func( [ $mockDB1, 'lastDoneWrites' ] );
 220
 221                                         return (bool)$p;
 222                                 }
 223                         ) );
 224                 $lb1->method( 'getMasterPos' )->willReturn( $m1Pos );
 225                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 226                 // Master DB 2
 227                 $mockDB2 = $this->getMockBuilder( 'DatabaseMysqli' )
 228                         ->disableOriginalConstructor()
 229                         ->getMock();
 230                 $mockDB2->method( 'writesOrCallbacksPending' )->willReturn( true );
 231                 $mockDB2->method( 'lastDoneWrites' )->willReturn( $now );
 232                 $mockDB2->method( 'getMasterPos' )->willReturn( $m2Pos );
 233                 // Load balancer for master DB 2
 234                 $lb2 = $this->getMockBuilder( 'LoadBalancer' )
 235                         ->disableOriginalConstructor()
 236                         ->getMock();
 237                 $lb2->method( 'getConnection' )->willReturn( $mockDB2 );
 238                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 239                 $lb2->method( 'getAnyOpenConnection' )->willReturn( $mockDB2 );
 240                 $lb2->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 241                         function () use ( $mockDB2 ) {
 242                                 $p = 0;
 243                                 $p |= call_user_func( [ $mockDB2, 'writesOrCallbacksPending' ] );
 244                                 $p |= call_user_func( [ $mockDB2, 'lastDoneWrites' ] );
 245
 246                                 return (bool)$p;
 247                         }
 248                 ) );
 249                 $lb2->method( 'getMasterPos' )->willReturn( $m2Pos );
 250                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 251
 252                 $bag = new HashBagOStuff();
 253                 $cp = new ChronologyProtector(
 254                         $bag,
 255                         [
 256                                 'ip' => '127.0.0.1',
 257                                 'agent' => "Totally-Not-FireFox"
 258                         ]
 259                 );
 260
 261                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 262                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 263                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 264                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 265
 266                 // Nothing to wait for on first HTTP request start
 267                 $cp->initLB( $lb1 );
 268                 $cp->initLB( $lb2 );
 269                 // Record positions in stash on first HTTP request end
 270                 $cp->shutdownLB( $lb1 );
 271                 $cp->shutdownLB( $lb2 );
 272                 $cpIndex = null;
 273                 $cp->shutdown( null, 'sync', $cpIndex );
 274
 275                 $this->assertEquals( 1, $cpIndex, "CP write index set" );
 276
 277                 // (b) Second HTTP request
 278
 279                 // Load balancer for master DB 1
 280                 $lb1 = $this->getMockBuilder( 'LoadBalancer' )
 281                         ->disableOriginalConstructor()
 282                         ->getMock();
 283                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 284                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 285                 $lb1->expects( $this->once() )
 286                         ->method( 'waitFor' )->with( $this->equalTo( $m1Pos ) );
 287                 // Load balancer for master DB 2
 288                 $lb2 = $this->getMockBuilder( 'LoadBalancer' )
 289                         ->disableOriginalConstructor()
 290                         ->getMock();
 291                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 292                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 293                 $lb2->expects( $this->once() )
 294                         ->method( 'waitFor' )->with( $this->equalTo( $m2Pos ) );
 295
 296                 $cp = new ChronologyProtector(
 297                         $bag,
 298                         [
 299                                 'ip' => '127.0.0.1',
 300                                 'agent' => "Totally-Not-FireFox"
 301                         ],
 302                         $cpIndex
 303                 );
 304
 305                 // Wait for last positions to be reached on second HTTP request start
 306                 $cp->initLB( $lb1 );
 307                 $cp->initLB( $lb2 );
 308                 // Shutdown (nothing to record)
 309                 $cp->shutdownLB( $lb1 );
 310                 $cp->shutdownLB( $lb2 );
 311                 $cpIndex = null;
 312                 $cp->shutdown( null, 'sync', $cpIndex );
 313
 314                 $this->assertEquals( null, $cpIndex, "CP write index retained" );
 315         }
 316
 317         private function newLBFactoryMulti( array $baseOverride = [], array $serverOverride = [] ) {
 318                 global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBprefix, $wgDBtype;
 319                 global $wgSQLiteDataDir;
 320
 321                 return new LBFactoryMulti( $baseOverride + [
 322                         'sectionsByDB' => [],
 323                         'sectionLoads' => [
 324                                 'DEFAULT' => [
 325                                         'test-db1' => 1,
 326                                 ],
 327                         ],
 328                         'serverTemplate' => $serverOverride + [
 329                                 'dbname' => $wgDBname,
 330                                 'tablePrefix' => $wgDBprefix,
 331                                 'user' => $wgDBuser,
 332                                 'password' => $wgDBpassword,
 333                                 'type' => $wgDBtype,
 334                                 'dbDirectory' => $wgSQLiteDataDir,
 335                                 'flags' => DBO_DEFAULT
 336                         ],
 337                         'hostsByName' => [
 338                                 'test-db1' => $wgDBserver,
 339                         ],
 340                         'loadMonitorClass' => 'LoadMonitorNull',
 341                         'localDomain' => new DatabaseDomain( $wgDBname, null, $wgDBprefix )
 342                 ] );
 343         }
 344
 345         public function testNiceDomains() {
 346                 global $wgDBname, $wgDBtype;
 347
 348                 if ( $wgDBtype === 'sqlite' ) {
 349                         $tmpDir = $this->getNewTempDirectory();
 350                         $dbPath = "$tmpDir/unit_test_db.sqlite";
 351                         file_put_contents( $dbPath, '' );
 352                         $tempFsFile = new TempFSFile( $dbPath );
 353                         $tempFsFile->autocollect();
 354                 } else {
 355                         $dbPath = null;
 356                 }
 357
 358                 $factory = $this->newLBFactoryMulti(
 359                         [],
 360                         [ 'dbFilePath' => $dbPath ]
 361                 );
 362                 $lb = $factory->getMainLB();
 363
 364                 if ( $wgDBtype !== 'sqlite' ) {
 365                         $db = $lb->getConnectionRef( DB_MASTER );
 366                         $this->assertEquals(
 367                                 wfWikiID(),
 368                                 $db->getDomainID()
 369                         );
 370                         unset( $db );
 371                 }
 372
 373                 /** @var Database $db */
 374                 $db = $lb->getConnection( DB_MASTER, [], '' );
 375
 376                 $this->assertEquals(
 377                         $wgDBname,
 378                         $db->getDomainId(),
 379                         'Main domain ID handle used; same DB name'
 380                 );
 381                 $this->assertEquals(
 382                         $wgDBname,
 383                         $db->getDBname(),
 384                         'Main domain ID handle used; same DB name'
 385                 );
 386                 $this->assertEquals(
 387                         '',
 388                         $db->tablePrefix(),
 389                         'Main domain ID handle used; prefix is empty though'
 390                 );
 391                 $this->assertEquals(
 392                         $this->quoteTable( $db, 'page' ),
 393                         $db->tableName( 'page' ),
 394                         "Correct full table name"
 395                 );
 396                 $this->assertEquals(
 397                         $this->quoteTable( $db, $wgDBname ) . '.' . $this->quoteTable( $db, 'page' ),
 398                         $db->tableName( "$wgDBname.page" ),
 399                         "Correct full table name"
 400                 );
 401                 $this->assertEquals(
 402                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 403                         $db->tableName( 'nice_db.page' ),
 404                         "Correct full table name"
 405                 );
 406
 407                 $lb->reuseConnection( $db ); // don't care
 408
 409                 $db = $lb->getConnection( DB_MASTER ); // local domain connection
 410                 $factory->setDomainPrefix( 'my_' );
 411
 412                 $this->assertEquals(
 413                         "$wgDBname-my_",
 414                         $db->getDomainID()
 415                 );
 416                 $this->assertEquals(
 417                         $this->quoteTable( $db, 'my_page' ),
 418                         $db->tableName( 'page' ),
 419                         "Correct full table name"
 420                 );
 421                 $this->assertEquals(
 422                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 423                         $db->tableName( 'other_nice_db.page' ),
 424                         "Correct full table name"
 425                 );
 426
 427                 $factory->closeAll();
 428                 $factory->destroy();
 429         }
 430
 431         public function testTrickyDomain() {
 432                 global $wgDBtype, $wgDBname;
 433
 434                 if ( $wgDBtype === 'sqlite' ) {
 435                         $tmpDir = $this->getNewTempDirectory();
 436                         $dbPath = "$tmpDir/unit_test_db.sqlite";
 437                         file_put_contents( $dbPath, '' );
 438                         $tempFsFile = new TempFSFile( $dbPath );
 439                         $tempFsFile->autocollect();
 440                 } else {
 441                         $dbPath = null;
 442                 }
 443
 444                 $dbname = 'unittest-domain'; // explodes if DB is selected
 445                 $factory = $this->newLBFactoryMulti(
 446                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 447                         [ 'dbFilePath' => $dbPath ]
 448                 );
 449                 $lb = $factory->getMainLB();
 450                 /** @var Database $db */
 451                 $db = $lb->getConnection( DB_MASTER, [], '' );
 452
 453                 $this->assertEquals(
 454                         $wgDBname,
 455                         $db->getDomainID()
 456                 );
 457
 458                 $this->assertEquals(
 459                         $this->quoteTable( $db, 'page' ),
 460                         $db->tableName( 'page' ),
 461                         "Correct full table name"
 462                 );
 463
 464                 $this->assertEquals(
 465                         $this->quoteTable( $db, $dbname ) . '.' . $this->quoteTable( $db, 'page' ),
 466                         $db->tableName( "$dbname.page" ),
 467                         "Correct full table name"
 468                 );
 469
 470                 $this->assertEquals(
 471                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 472                         $db->tableName( 'nice_db.page' ),
 473                         "Correct full table name"
 474                 );
 475
 476                 $lb->reuseConnection( $db ); // don't care
 477
 478                 $factory->setDomainPrefix( 'my_' );
 479                 $db = $lb->getConnection( DB_MASTER, [], "$wgDBname-my_" );
 480
 481                 $this->assertEquals(
 482                         $this->quoteTable( $db, 'my_page' ),
 483                         $db->tableName( 'page' ),
 484                         "Correct full table name"
 485                 );
 486                 $this->assertEquals(
 487                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 488                         $db->tableName( 'other_nice_db.page' ),
 489                         "Correct full table name"
 490                 );
 491                 $this->assertEquals(
 492                         $this->quoteTable( $db, 'garbage-db' ) . '.' . $this->quoteTable( $db, 'page' ),
 493                         $db->tableName( 'garbage-db.page' ),
 494                         "Correct full table name"
 495                 );
 496
 497                 if ( $db->databasesAreIndependent() ) {
 498                         try {
 499                                 $e = null;
 500                                 $db->selectDB( 'garbage-db' );
 501                         } catch ( \Wikimedia\Rdbms\DBConnectionError $e ) {
 502                                 // expected
 503                         }
 504                         $this->assertInstanceOf( '\Wikimedia\Rdbms\DBConnectionError', $e );
 505                         $this->assertFalse( $db->isOpen() );
 506                 } else {
 507                         \MediaWiki\suppressWarnings();
 508                         $this->assertFalse( $db->selectDB( 'garbage-db' ) );
 509                         \MediaWiki\restoreWarnings();
 510                 }
 511
 512                 $lb->reuseConnection( $db ); // don't care
 513
 514                 $factory->closeAll();
 515                 $factory->destroy();
 516         }
 517
 518         private function quoteTable( Database $db, $table ) {
 519                 if ( $db->getType() === 'sqlite' ) {
 520                         return $table;
 521                 } else {
 522                         return $db->addIdentifierQuotes( $table );
 523                 }
 524         }
 525 }