MWLBFactory.php

Go to the documentation of this file.

<?php
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Logger\LoggerFactory;
use Wikimedia\Rdbms\LBFactory;
use Wikimedia\Rdbms\DatabaseDomain;

abstract class MWLBFactory {

    private static $loggedDeprecations = [];

    public static $applyDefaultConfigOptions = [
        'DBcompress',
        'DBDefaultGroup',
        'DBmwschema',
        'DBname',
        'DBpassword',
        'DBport',
        'DBprefix',
        'DBserver',
        'DBservers',
        'DBssl',
        'DBtype',
        'DBuser',
        'DBWindowsAuthentication',
        'DebugDumpSql',
        'DebugLogFile',
        'ExternalServers',
        'SQLiteDataDir',
        'SQLMode',
    ];

    public static function applyDefaultConfig(
        array $lbConf,
        ServiceOptions $options,
        ConfiguredReadOnlyMode $readOnlyMode,
        BagOStuff $srvCace,
        BagOStuff $mainStash,
        WANObjectCache $wanCache
    ) {
        $options->assertRequiredOptions( self::$applyDefaultConfigOptions );

        global $wgCommandLineMode;

        $typesWithSchema = self::getDbTypesWithSchemas();

        $lbConf += [
            'localDomain' => new DatabaseDomain(
                $options->get( 'DBname' ),
                $options->get( 'DBmwschema' ),
                $options->get( 'DBprefix' )
            ),
            'profiler' => function ( $section ) {
                return Profiler::instance()->scopedProfileIn( $section );
            },
            'trxProfiler' => Profiler::instance()->getTransactionProfiler(),
            'replLogger' => LoggerFactory::getInstance( 'DBReplication' ),
            'queryLogger' => LoggerFactory::getInstance( 'DBQuery' ),
            'connLogger' => LoggerFactory::getInstance( 'DBConnection' ),
            'perfLogger' => LoggerFactory::getInstance( 'DBPerformance' ),
            'errorLogger' => [ MWExceptionHandler::class, 'logException' ],
            'deprecationLogger' => [ static::class, 'logDeprecation' ],
            'cliMode' => $wgCommandLineMode,
            'hostname' => wfHostname(),
            'readOnlyReason' => $readOnlyMode->getReason(),
            'defaultGroup' => $options->get( 'DBDefaultGroup' ),
        ];

        $serversCheck = [];
        // When making changes here, remember to also specify MediaWiki-specific options
        // for Database classes in the relevant Installer subclass.
        // Such as MysqlInstaller::openConnection and PostgresInstaller::openConnectionWithParams.
        if ( $lbConf['class'] === Wikimedia\Rdbms\LBFactorySimple::class ) {
            if ( isset( $lbConf['servers'] ) ) {
                // Server array is already explicitly configured
            } elseif ( is_array( $options->get( 'DBservers' ) ) ) {
                $lbConf['servers'] = [];
                foreach ( $options->get( 'DBservers' ) as $i => $server ) {
                    $lbConf['servers'][$i] = self::initServerInfo( $server, $options );
                }
            } else {
                $server = self::initServerInfo(
                    [
                        'host' => $options->get( 'DBserver' ),
                        'user' => $options->get( 'DBuser' ),
                        'password' => $options->get( 'DBpassword' ),
                        'dbname' => $options->get( 'DBname' ),
                        'type' => $options->get( 'DBtype' ),
                        'load' => 1
                    ],
                    $options
                );

                $server['flags'] |= $options->get( 'DBssl' ) ? DBO_SSL : 0;
                $server['flags'] |= $options->get( 'DBcompress' ) ? DBO_COMPRESS : 0;

                $lbConf['servers'] = [ $server ];
            }
            if ( !isset( $lbConf['externalClusters'] ) ) {
                $lbConf['externalClusters'] = $options->get( 'ExternalServers' );
            }

            $serversCheck = $lbConf['servers'];
        } elseif ( $lbConf['class'] === Wikimedia\Rdbms\LBFactoryMulti::class ) {
            if ( isset( $lbConf['serverTemplate'] ) ) {
                if ( in_array( $lbConf['serverTemplate']['type'], $typesWithSchema, true ) ) {
                    $lbConf['serverTemplate']['schema'] = $options->get( 'DBmwschema' );
                }
                $lbConf['serverTemplate']['sqlMode'] = $options->get( 'SQLMode' );
            }
            $serversCheck = [ $lbConf['serverTemplate'] ] ?? [];
        }

        self::assertValidServerConfigs( $serversCheck, $options->get( 'DBname' ),
            $options->get( 'DBprefix' ) );

        $lbConf = self::injectObjectCaches( $lbConf, $srvCace, $mainStash, $wanCache );

        return $lbConf;
    }

    private static function getDbTypesWithSchemas() {
        return [ 'postgres', 'msssql' ];
    }

    private static function initServerInfo( array $server, ServiceOptions $options ) {
        if ( $server['type'] === 'sqlite' ) {
            $httpMethod = $_SERVER['REQUEST_METHOD'] ?? null;
            // T93097: hint for how file-based databases (e.g. sqlite) should go about locking.
            // See https://www.sqlite.org/lang_transaction.html
            // See https://www.sqlite.org/lockingv3.html#shared_lock
            $isHttpRead = in_array( $httpMethod, [ 'GET', 'HEAD', 'OPTIONS', 'TRACE' ] );
            $server += [
                'dbDirectory' => $options->get( 'SQLiteDataDir' ),
                'trxMode' => $isHttpRead ? 'DEFERRED' : 'IMMEDIATE'
            ];
        } elseif ( $server['type'] === 'postgres' ) {
            $server += [
                'port' => $options->get( 'DBport' ),
                // Work around the reserved word usage in MediaWiki schema
                'keywordTableMap' => [ 'user' => 'mwuser', 'text' => 'pagecontent' ]
            ];
        } elseif ( $server['type'] === 'oracle' ) {
            $server += [
                // Work around the reserved word usage in MediaWiki schema
                'keywordTableMap' => [ 'user' => 'mwuser', 'text' => 'pagecontent' ]
            ];
        } elseif ( $server['type'] === 'mssql' ) {
            $server += [
                'port' => $options->get( 'DBport' ),
                'useWindowsAuth' => $options->get( 'DBWindowsAuthentication' )
            ];
        }

        if ( in_array( $server['type'], self::getDbTypesWithSchemas(), true ) ) {
            $server += [ 'schema' => $options->get( 'DBmwschema' ) ];
        }

        $flags = DBO_DEFAULT;
        $flags |= $options->get( 'DebugDumpSql' ) ? DBO_DEBUG : 0;
        $flags |= $options->get( 'DebugLogFile' ) ? DBO_DEBUG : 0;
        if ( $server['type'] === 'oracle' ) {
            $flags |= $options->get( 'DBOracleDRCP' ) ? DBO_PERSISTENT : 0;
        }

        $server += [
            'tablePrefix' => $options->get( 'DBprefix' ),
            'flags' => $flags,
            'sqlMode' => $options->get( 'SQLMode' ),
        ];

        return $server;
    }

    private static function injectObjectCaches(
        array $lbConf, BagOStuff $sCache, BagOStuff $mStash, WANObjectCache $wCache
    ) {
        // Use APC/memcached style caching, but avoids loops with CACHE_DB (T141804)
        if ( $sCache->getQoS( $sCache::ATTR_EMULATION ) > $sCache::QOS_EMULATION_SQL ) {
            $lbConf['srvCache'] = $sCache;
        }
        if ( $mStash->getQoS( $mStash::ATTR_EMULATION ) > $mStash::QOS_EMULATION_SQL ) {
            $lbConf['memStash'] = $mStash;
        }
        if ( $wCache->getQoS( $wCache::ATTR_EMULATION ) > $wCache::QOS_EMULATION_SQL ) {
            $lbConf['wanCache'] = $wCache;
        }

        return $lbConf;
    }

    private static function assertValidServerConfigs( array $servers, $ldDB, $ldTP ) {
        foreach ( $servers as $server ) {
            $type = $server['type'] ?? null;
            $srvDB = $server['dbname'] ?? null; // server DB
            $srvTP = $server['tablePrefix'] ?? ''; // server table prefix

            if ( $type === 'mysql' ) {
                // A DB name is not needed to connect to mysql; 'dbname' is useless.
                // This field only defines the DB to use for unspecified DB domains.
                if ( $srvDB !== null && $srvDB !== $ldDB ) {
                    self::reportMismatchedDBs( $srvDB, $ldDB );
                }
            } elseif ( $type === 'postgres' ) {
                if ( $srvTP !== '' ) {
                    self::reportIfPrefixSet( $srvTP, $type );
                }
            }

            if ( $srvTP !== '' && $srvTP !== $ldTP ) {
                self::reportMismatchedPrefixes( $srvTP, $ldTP );
            }
        }
    }

    private static function reportIfPrefixSet( $prefix, $dbType ) {
        $e = new UnexpectedValueException(
            "\$wgDBprefix is set to '$prefix' but the database type is '$dbType'. " .
            "MediaWiki does not support using a table prefix with this RDBMS type."
        );
        MWExceptionRenderer::output( $e, MWExceptionRenderer::AS_PRETTY );
        exit;
    }

    private static function reportMismatchedDBs( $srvDB, $ldDB ) {
        $e = new UnexpectedValueException(
            "\$wgDBservers has dbname='$srvDB' but \$wgDBname='$ldDB'. " .
            "Set \$wgDBname to the database used by this wiki project. " .
            "There is rarely a need to set 'dbname' in \$wgDBservers. " .
            "Cross-wiki database access, use of WikiMap::getCurrentWikiDbDomain(), " .
            "use of Database::getDomainId(), and other features are not reliable when " .
            "\$wgDBservers does not match the local wiki database/prefix."
        );
        MWExceptionRenderer::output( $e, MWExceptionRenderer::AS_PRETTY );
        exit;
    }

    private static function reportMismatchedPrefixes( $srvTP, $ldTP ) {
        $e = new UnexpectedValueException(
            "\$wgDBservers has tablePrefix='$srvTP' but \$wgDBprefix='$ldTP'. " .
            "Set \$wgDBprefix to the table prefix used by this wiki project. " .
            "There is rarely a need to set 'tablePrefix' in \$wgDBservers. " .
            "Cross-wiki database access, use of WikiMap::getCurrentWikiDbDomain(), " .
            "use of Database::getDomainId(), and other features are not reliable when " .
            "\$wgDBservers does not match the local wiki database/prefix."
        );
        MWExceptionRenderer::output( $e, MWExceptionRenderer::AS_PRETTY );
        exit;
    }

    public static function getLBFactoryClass( array $config ) {
        // For configuration backward compatibility after removing
        // underscores from class names in MediaWiki 1.23.
        $bcClasses = [
            'LBFactory_Simple' => 'LBFactorySimple',
            'LBFactory_Single' => 'LBFactorySingle',
            'LBFactory_Multi' => 'LBFactoryMulti'
        ];

        $class = $config['class'];

        if ( isset( $bcClasses[$class] ) ) {
            $class = $bcClasses[$class];
            wfDeprecated(
                '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details',
                '1.23'
            );
        }

        // For configuration backward compatibility after moving classes to namespaces (1.29)
        $compat = [
            'LBFactorySingle' => Wikimedia\Rdbms\LBFactorySingle::class,
            'LBFactorySimple' => Wikimedia\Rdbms\LBFactorySimple::class,
            'LBFactoryMulti' => Wikimedia\Rdbms\LBFactoryMulti::class
        ];

        if ( isset( $compat[$class] ) ) {
            $class = $compat[$class];
        }

        return $class;
    }

    public static function setSchemaAliases( LBFactory $lbFactory, $dbType ) {
        if ( $dbType instanceof Config ) {
            // Before 1.34 this took a whole Config just to get $dbType
            wfDeprecated( __METHOD__ . ' with Config argument', '1.34' );
            $dbType = $dbType->get( 'DBtype' );
        }
        if ( $dbType === 'mysql' ) {
            $lbFactory->setIndexAliases( [
                'ar_usertext_timestamp' => 'usertext_timestamp',
                'un_user_id' => 'user_id',
                'un_user_ip' => 'user_ip',
            ] );
        }
    }

    public static function logDeprecation( $msg ) {
        global $wgDevelopmentWarnings;

        if ( isset( self::$loggedDeprecations[$msg] ) ) {
            return;
        }
        self::$loggedDeprecations[$msg] = true;

        if ( $wgDevelopmentWarnings ) {
            trigger_error( $msg, E_USER_DEPRECATED );
        }
        wfDebugLog( 'deprecated', $msg, 'private' );
    }
}