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