includes/SiteStats.php

   1 <?php
   2
   3 /**
   4  * Static accessor class for site_stats and related things
   5  */
   6 class SiteStats {
   7         static $row, $loaded = false;
   8         static $admins;
   9         static $pageCount = array();
  10
  11         static function recache() {
  12                 self::load( true );
  13         }
  14
  15         static function load( $recache = false ) {
  16                 if ( self::$loaded && !$recache ) {
  17                         return;
  18                 }
  19
  20                 self::$row = self::loadAndLazyInit();
  21
  22                 # This code is somewhat schema-agnostic, because I'm changing it in a minor release -- TS
  23                 if ( !isset( self::$row->ss_total_pages ) && self::$row->ss_total_pages == -1 ) {
  24                         # Update schema
  25                         $u = new SiteStatsUpdate( 0, 0, 0 );
  26                         $u->doUpdate();
  27                         self::$row = $dbr->selectRow( 'site_stats', '*', false, __METHOD__ );
  28                 }
  29         }
  30
  31         static function loadAndLazyInit() {
  32                 wfDebug( __METHOD__ . ": reading site_stats from slave\n" );
  33                 $row = self::doLoad( wfGetDB( DB_SLAVE ) );
  34
  35                 if( $row === false ) {
  36                         // Might have just been initialzed during this request?
  37                         wfDebug( __METHOD__ . ": site_stats missing on slave\n" );
  38                         $row = self::doLoad( wfGetDB( DB_MASTER ) );
  39                 }
  40
  41                 if( $row === false ) {
  42                         // Normally the site_stats table is initialized at install time.
  43                         // Some manual construction scenarios may leave the table empty,
  44                         // however, for instance when importing from a dump into a clean
  45                         // schema with mwdumper.
  46                         wfDebug( __METHOD__ . ": initializing empty site_stats\n" );
  47
  48                         global $IP;
  49                         require_once "$IP/maintenance/initStats.inc";
  50
  51                         ob_start();
  52                         wfInitStats();
  53                         ob_end_clean();
  54
  55                         $row = self::doLoad( wfGetDB( DB_MASTER ) );
  56                 }
  57
  58                 if( $row === false ) {
  59                         wfDebug( __METHOD__ . ": init of site_stats failed o_O\n" );
  60                 }
  61                 return $row;
  62         }
  63
  64         static function doLoad( $db ) {
  65                 return $db->selectRow( 'site_stats', '*', false, __METHOD__ );
  66         }
  67
  68         static function views() {
  69                 self::load();
  70                 return self::$row->ss_total_views;
  71         }
  72
  73         static function edits() {
  74                 self::load();
  75                 return self::$row->ss_total_edits;
  76         }
  77
  78         static function articles() {
  79                 self::load();
  80                 return self::$row->ss_good_articles;
  81         }
  82
  83         static function pages() {
  84                 self::load();
  85                 return self::$row->ss_total_pages;
  86         }
  87
  88         static function users() {
  89                 self::load();
  90                 return self::$row->ss_users;
  91         }
  92
  93         static function images() {
  94                 self::load();
  95                 return self::$row->ss_images;
  96         }
  97
  98         static function admins() {
  99                 if ( !isset( self::$admins ) ) {
 100                         $dbr = wfGetDB( DB_SLAVE );
 101                         self::$admins = $dbr->selectField( 'user_groups', 'COUNT(*)', array( 'ug_group' => 'sysop' ), __METHOD__ );
 102                 }
 103                 return self::$admins;
 104         }
 105
 106         static function pagesInNs( $ns ) {
 107                 wfProfileIn( __METHOD__ );
 108                 if( !isset( self::$pageCount[$ns] ) ) {
 109                         $dbr = wfGetDB( DB_SLAVE );
 110                         $pageCount[$ns] = (int)$dbr->selectField( 'page', 'COUNT(*)', array( 'page_namespace' => $ns ), __METHOD__ );
 111                 }
 112                 wfProfileOut( __METHOD__ );
 113                 return $pageCount[$ns];
 114         }
 115
 116 }
 117
 118
 119 /**
 120  *
 121  */
 122 class SiteStatsUpdate {
 123
 124         var $mViews, $mEdits, $mGood, $mPages, $mUsers;
 125
 126         function __construct( $views, $edits, $good, $pages = 0, $users = 0 ) {
 127                 $this->mViews = $views;
 128                 $this->mEdits = $edits;
 129                 $this->mGood = $good;
 130                 $this->mPages = $pages;
 131                 $this->mUsers = $users;
 132         }
 133
 134         function appendUpdate( &$sql, $field, $delta ) {
 135                 if ( $delta ) {
 136                         if ( $sql ) {
 137                                 $sql .= ',';
 138                         }
 139                         if ( $delta < 0 ) {
 140                                 $sql .= "$field=$field-1";
 141                         } else {
 142                                 $sql .= "$field=$field+1";
 143                         }
 144                 }
 145         }
 146
 147         function doUpdate() {
 148                 $fname = 'SiteStatsUpdate::doUpdate';
 149                 $dbw = wfGetDB( DB_MASTER );
 150
 151                 # First retrieve the row just to find out which schema we're in
 152                 $row = $dbw->selectRow( 'site_stats', '*', false, $fname );
 153
 154                 $updates = '';
 155
 156                 $this->appendUpdate( $updates, 'ss_total_views', $this->mViews );
 157                 $this->appendUpdate( $updates, 'ss_total_edits', $this->mEdits );
 158                 $this->appendUpdate( $updates, 'ss_good_articles', $this->mGood );
 159
 160                 if ( isset( $row->ss_total_pages ) ) {
 161                         # Update schema if required
 162                         if ( $row->ss_total_pages == -1 && !$this->mViews ) {
 163                                 $dbr = wfGetDB( DB_SLAVE, array( 'SpecialStatistics', 'vslow') );
 164                                 list( $page, $user ) = $dbr->tableNamesN( 'page', 'user' );
 165
 166                                 $sql = "SELECT COUNT(page_namespace) AS total FROM $page";
 167                                 $res = $dbr->query( $sql, $fname );
 168                                 $pageRow = $dbr->fetchObject( $res );
 169                                 $pages = $pageRow->total + $this->mPages;
 170
 171                                 $sql = "SELECT COUNT(user_id) AS total FROM $user";
 172                                 $res = $dbr->query( $sql, $fname );
 173                                 $userRow = $dbr->fetchObject( $res );
 174                                 $users = $userRow->total + $this->mUsers;
 175
 176                                 if ( $updates ) {
 177                                         $updates .= ',';
 178                                 }
 179                                 $updates .= "ss_total_pages=$pages, ss_users=$users";
 180                         } else {
 181                                 $this->appendUpdate( $updates, 'ss_total_pages', $this->mPages );
 182                                 $this->appendUpdate( $updates, 'ss_users', $this->mUsers );
 183                         }
 184                 }
 185                 if ( $updates ) {
 186                         $site_stats = $dbw->tableName( 'site_stats' );
 187                         $sql = $dbw->limitResultForUpdate("UPDATE $site_stats SET $updates", 1);
 188                         $dbw->begin();
 189                         $dbw->query( $sql, $fname );
 190                         $dbw->commit();
 191                 }
 192
 193                 /*
 194                 global $wgDBname, $wgTitle;
 195                 if ( $this->mGood && $wgDBname == 'enwiki' ) {
 196                         $good = $dbw->selectField( 'site_stats', 'ss_good_articles', '', $fname );
 197                         error_log( $good . ' ' . $wgTitle->getPrefixedDBkey() . "\n", 3, '/home/wikipedia/logs/million.log' );
 198                 }
 199                 */
 200         }
 201 }
 202 ?>