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