SiteStats.php

Go to the documentation of this file.

<?php
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use Wikimedia\Rdbms\Database;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILoadBalancer;
 
class SiteStats {
    private static $row;
 
    public static function unload() {
        self::$row = null;
    }
 
    protected static function load() {
        if ( self::$row === null ) {
            self::$row = self::loadAndLazyInit();
        }
    }
 
    protected static function loadAndLazyInit() {
        $config = MediaWikiServices::getInstance()->getMainConfig();
 
        $lb = self::getLB();
        $dbr = $lb->getConnectionRef( DB_REPLICA );
        wfDebug( __METHOD__ . ": reading site_stats from replica DB" );
        $row = self::doLoadFromDB( $dbr );
 
        if ( !self::isRowSensible( $row ) && $lb->hasOrMadeRecentPrimaryChanges() ) {
            // Might have just been initialized during this request? Underflow?
            wfDebug( __METHOD__ . ": site_stats damaged or missing on replica DB" );
            $row = self::doLoadFromDB( $lb->getConnectionRef( DB_PRIMARY ) );
        }
 
        if ( !self::isRowSensible( $row ) ) {
            if ( $config->get( MainConfigNames::MiserMode ) ) {
                // Start off with all zeroes, assuming that this is a new wiki or any
                // repopulations where done manually via script.
                SiteStatsInit::doPlaceholderInit();
            } else {
                // Normally the site_stats table is initialized at install time.
                // Some manual construction scenarios may leave the table empty or
                // broken, however, for instance when importing from a dump into a
                // clean schema with mwdumper.
                wfDebug( __METHOD__ . ": initializing damaged or missing site_stats" );
                SiteStatsInit::doAllAndCommit( $dbr );
            }
 
            $row = self::doLoadFromDB( $lb->getConnectionRef( DB_PRIMARY ) );
        }
 
        if ( !self::isRowSensible( $row ) ) {
            wfDebug( __METHOD__ . ": site_stats persistently nonsensical o_O" );
            // Always return a row-like object
            $row = self::salvageIncorrectRow( $row );
        }
 
        return $row;
    }
 
    public static function edits() {
        self::load();
 
        return (int)self::$row->ss_total_edits;
    }
 
    public static function articles() {
        self::load();
 
        return (int)self::$row->ss_good_articles;
    }
 
    public static function pages() {
        self::load();
 
        return (int)self::$row->ss_total_pages;
    }
 
    public static function users() {
        self::load();
 
        return (int)self::$row->ss_users;
    }
 
    public static function activeUsers() {
        self::load();
 
        return (int)self::$row->ss_active_users;
    }
 
    public static function images() {
        self::load();
 
        return (int)self::$row->ss_images;
    }
 
    public static function numberingroup( $group ) {
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $fname = __METHOD__;
 
        return $cache->getWithSetCallback(
            $cache->makeKey( 'SiteStats', 'groupcounts', $group ),
            $cache::TTL_HOUR,
            function ( $oldValue, &$ttl, array &$setOpts ) use ( $group, $fname ) {
                $dbr = self::getLB()->getConnectionRef( DB_REPLICA );
                $setOpts += Database::getCacheSetOptions( $dbr );
                return (int)$dbr->newSelectQueryBuilder()
                    ->select( 'COUNT(*)' )
                    ->from( 'user_groups' )
                    ->where(
                        [
                            'ug_group' => $group,
                            'ug_expiry IS NULL OR ug_expiry >= ' . $dbr->addQuotes( $dbr->timestamp() )
                        ]
                    )
                    ->caller( $fname )
                    ->fetchField();
            },
            [ 'pcTTL' => $cache::TTL_PROC_LONG ]
        );
    }
 
    public static function jobs() {
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
 
        return $cache->getWithSetCallback(
            $cache->makeKey( 'SiteStats', 'jobscount' ),
            $cache::TTL_MINUTE,
            static function ( $oldValue, &$ttl, array &$setOpts ) {
                try {
                    $jobs = array_sum( MediaWikiServices::getInstance()->getJobQueueGroup()->getQueueSizes() );
                } catch ( JobQueueError $e ) {
                    $jobs = 0;
                }
                return $jobs;
            },
            [ 'pcTTL' => $cache::TTL_PROC_LONG ]
        );
    }
 
    public static function pagesInNs( $ns ) {
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $fname = __METHOD__;
 
        return $cache->getWithSetCallback(
            $cache->makeKey( 'SiteStats', 'page-in-namespace', $ns ),
            $cache::TTL_HOUR,
            function ( $oldValue, &$ttl, array &$setOpts ) use ( $ns, $fname ) {
                $dbr = self::getLB()->getConnectionRef( DB_REPLICA );
                $setOpts += Database::getCacheSetOptions( $dbr );
 
                return (int)$dbr->selectField(
                    'page',
                    'COUNT(*)',
                    [ 'page_namespace' => $ns ],
                    $fname
                );
            },
            [ 'pcTTL' => $cache::TTL_PROC_LONG ]
        );
    }
 
    public static function selectFields() {
        return [
            'ss_total_edits',
            'ss_good_articles',
            'ss_total_pages',
            'ss_users',
            'ss_active_users',
            'ss_images',
        ];
    }
 
    private static function doLoadFromDB( IDatabase $db ) {
        $fields = self::selectFields();
        $rows = $db->newSelectQueryBuilder()
            ->select( $fields )
            ->from( 'site_stats' )
            ->caller( __METHOD__ )
            ->fetchResultSet();
        $finalRow = new stdClass();
        foreach ( $rows as $row ) {
            foreach ( $fields as $field ) {
                $finalRow->$field = $finalRow->$field ?? 0;
                if ( $row->$field ) {
                    $finalRow->$field += $row->$field;
                }
            }
 
        }
        return $finalRow;
    }
 
    private static function isRowSensible( $row ) {
        if ( $row === false
            || $row->ss_total_pages < $row->ss_good_articles
            || $row->ss_total_edits < $row->ss_total_pages
        ) {
            return false;
        }
        // Now check for underflow/overflow
        foreach ( [
            'ss_total_edits',
            'ss_good_articles',
            'ss_total_pages',
            'ss_users',
            'ss_images',
        ] as $member ) {
            if ( $row->$member < 0 ) {
                return false;
            }
        }
 
        return true;
    }
 
    private static function salvageIncorrectRow( $row ) {
        $map = $row ? (array)$row : [];
        // Fill in any missing values with zero
        $map += array_fill_keys( self::selectFields(), 0 );
        // Convert negative values to zero
        foreach ( $map as $field => $value ) {
            $map[$field] = max( 0, $value );
        }
 
        return (object)$row;
    }
 
    private static function getLB() {
        return MediaWikiServices::getInstance()->getDBLoadBalancer();
    }
}