includes/site/SiteSQLStore.php

   1 <?php
   2
   3 /**
   4  * Represents the site configuration of a wiki.
   5  * Holds a list of sites (ie SiteList) and takes care
   6  * of retrieving and caching site information when appropriate.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  * http://www.gnu.org/copyleft/gpl.html
  22  *
  23  * @since 1.21
  24  *
  25  * @file
  26  * @ingroup Site
  27  *
  28  * @license GNU GPL v2+
  29  * @author Jeroen De Dauw < jeroendedauw@gmail.com >
  30  */
  31 class SiteSQLStore implements SiteStore {
  32
  33         /**
  34          * @since 1.21
  35          *
  36          * @var SiteList|null
  37          */
  38         protected $sites = null;
  39
  40         /**
  41          * @var ORMTable
  42          */
  43         protected $sitesTable;
  44
  45         /**
  46          * @var string|null
  47          */
  48         private $cacheKey = null;
  49
  50         /**
  51          * @var int
  52          */
  53         private $cacheTimeout = 3600;
  54
  55         /**
  56          * @since 1.21
  57          *
  58          * @param ORMTable|null $sitesTable
  59          *
  60          * @return SiteStore
  61          */
  62         public static function newInstance( ORMTable $sitesTable = null ) {
  63                 return new static( $sitesTable );
  64         }
  65
  66         /**
  67          * Constructor.
  68          *
  69          * @since 1.21
  70          *
  71          * @param ORMTable|null $sitesTable
  72          */
  73         protected function __construct( ORMTable $sitesTable = null ) {
  74                 if ( $sitesTable === null ) {
  75                         $sitesTable = $this->newSitesTable();
  76                 }
  77
  78                 $this->sitesTable = $sitesTable;
  79         }
  80
  81         /**
  82          * Constructs a cache key to use for caching the list of sites.
  83          *
  84          * This includes the concrete class name of the site list as well as a version identifier
  85          * for the list's serialization, to avoid problems when unserializing site lists serialized
  86          * by an older version, e.g. when reading from a cache.
  87          *
  88          * The cache key also includes information about where the sites were loaded from, e.g.
  89          * the name of a database table.
  90          *
  91          * @see SiteList::getSerialVersionId
  92          *
  93          * @return string The cache key.
  94          */
  95         protected function getCacheKey() {
  96                 wfProfileIn( __METHOD__ );
  97
  98                 if ( $this->cacheKey === null ) {
  99                         $type = 'SiteList#' . SiteList::getSerialVersionId();
 100                         $source = $this->sitesTable->getName();
 101
 102                         if ( $this->sitesTable->getTargetWiki() !== false ) {
 103                                 $source = $this->sitesTable->getTargetWiki() . '.' . $source;
 104                         }
 105
 106                         $this->cacheKey = wfMemcKey( "$source/$type" );
 107                 }
 108
 109                 wfProfileOut( __METHOD__ );
 110                 return $this->cacheKey;
 111         }
 112
 113         /**
 114          * @see SiteStore::getSites
 115          *
 116          * @since 1.21
 117          *
 118          * @param string $source Either 'cache' or 'recache'
 119          *
 120          * @return SiteList
 121          */
 122         public function getSites( $source = 'cache' ) {
 123                 wfProfileIn( __METHOD__ );
 124
 125                 if ( $source === 'cache' ) {
 126                         if ( $this->sites === null ) {
 127                                 $cache = wfGetMainCache();
 128                                 $sites = $cache->get( $this->getCacheKey() );
 129
 130                                 if ( is_object( $sites ) ) {
 131                                         $this->sites = $sites;
 132                                 } else {
 133                                         $this->loadSites();
 134                                 }
 135                         }
 136                 }
 137                 else {
 138                         $this->loadSites();
 139                 }
 140
 141                 wfProfileOut( __METHOD__ );
 142                 return $this->sites;
 143         }
 144
 145         /**
 146          * Returns a new Site object constructed from the provided ORMRow.
 147          *
 148          * @since 1.21
 149          *
 150          * @param ORMRow $siteRow
 151          *
 152          * @return Site
 153          */
 154         protected function siteFromRow( ORMRow $siteRow ) {
 155                 wfProfileIn( __METHOD__ );
 156
 157                 $site = Site::newForType( $siteRow->getField( 'type', Site::TYPE_UNKNOWN ) );
 158
 159                 $site->setGlobalId( $siteRow->getField( 'global_key' ) );
 160
 161                 $site->setInternalId( $siteRow->getField( 'id' ) );
 162
 163                 if ( $siteRow->hasField( 'forward' ) ) {
 164                         $site->setForward( $siteRow->getField( 'forward' ) );
 165                 }
 166
 167                 if ( $siteRow->hasField( 'group' ) ) {
 168                         $site->setGroup( $siteRow->getField( 'group' ) );
 169                 }
 170
 171                 if ( $siteRow->hasField( 'language' ) ) {
 172                         $site->setLanguageCode( $siteRow->getField( 'language' ) === '' ? null : $siteRow->getField( 'language' ) );
 173                 }
 174
 175                 if ( $siteRow->hasField( 'source' ) ) {
 176                         $site->setSource( $siteRow->getField( 'source' ) );
 177                 }
 178
 179                 if ( $siteRow->hasField( 'data' ) ) {
 180                         $site->setExtraData( $siteRow->getField( 'data' ) );
 181                 }
 182
 183                 if ( $siteRow->hasField( 'config' ) ) {
 184                         $site->setExtraConfig( $siteRow->getField( 'config' ) );
 185                 }
 186
 187                 wfProfileOut( __METHOD__ );
 188                 return $site;
 189         }
 190
 191         /**
 192          * Get a new ORMRow from a Site object
 193          *
 194          * @since 1.22
 195          *
 196          * @param Site $site
 197          *
 198          * @return ORMRow
 199          */
 200         protected function getRowFromSite( Site $site ) {
 201                 $fields = array(
 202                         // Site data
 203                         'global_key' => $site->getGlobalId(), // TODO: check not null
 204                         'type' => $site->getType(),
 205                         'group' => $site->getGroup(),
 206                         'source' => $site->getSource(),
 207                         'language' => $site->getLanguageCode() === null ? '' : $site->getLanguageCode(),
 208                         'protocol' => $site->getProtocol(),
 209                         'domain' => strrev( $site->getDomain() ) . '.',
 210                         'data' => $site->getExtraData(),
 211
 212                         // Site config
 213                         'forward' => $site->shouldForward(),
 214                         'config' => $site->getExtraConfig(),
 215                 );
 216
 217                 if ( $site->getInternalId() !== null ) {
 218                         $fields['id'] = $site->getInternalId();
 219                 }
 220
 221                 return new ORMRow( $this->sitesTable, $fields );
 222         }
 223
 224         /**
 225          * Fetches the site from the database and loads them into the sites field.
 226          *
 227          * @since 1.21
 228          */
 229         protected function loadSites() {
 230                 wfProfileIn( __METHOD__ );
 231
 232                 $this->sites = new SiteList();
 233
 234                 foreach ( $this->sitesTable->select() as $siteRow ) {
 235                         $this->sites[] = $this->siteFromRow( $siteRow );
 236                 }
 237
 238                 // Batch load the local site identifiers.
 239                 $ids = wfGetDB( $this->sitesTable->getReadDb() )->select(
 240                         'site_identifiers',
 241                         array(
 242                                 'si_site',
 243                                 'si_type',
 244                                 'si_key',
 245                         ),
 246                         array(),
 247                         __METHOD__
 248                 );
 249
 250                 foreach ( $ids as $id ) {
 251                         if ( $this->sites->hasInternalId( $id->si_site ) ) {
 252                                 $site = $this->sites->getSiteByInternalId( $id->si_site );
 253                                 $site->addLocalId( $id->si_type, $id->si_key );
 254                                 $this->sites->setSite( $site );
 255                         }
 256                 }
 257
 258                 $cache = wfGetMainCache();
 259                 $cache->set( $this->getCacheKey(), $this->sites, $this->cacheTimeout );
 260
 261                 wfProfileOut( __METHOD__ );
 262         }
 263
 264         /**
 265          * @see SiteStore::getSite
 266          *
 267          * @since 1.21
 268          *
 269          * @param string $globalId
 270          * @param string $source
 271          *
 272          * @return Site|null
 273          */
 274         public function getSite( $globalId, $source = 'cache' ) {
 275                 wfProfileIn( __METHOD__ );
 276
 277                 $sites = $this->getSites( $source );
 278
 279                 wfProfileOut( __METHOD__ );
 280                 return $sites->hasSite( $globalId ) ? $sites->getSite( $globalId ) : null;
 281         }
 282
 283         /**
 284          * @see SiteStore::saveSite
 285          *
 286          * @since 1.21
 287          *
 288          * @param Site $site
 289          *
 290          * @return bool Success indicator
 291          */
 292         public function saveSite( Site $site ) {
 293                 return $this->saveSites( array( $site ) );
 294         }
 295
 296         /**
 297          * @see SiteStore::saveSites
 298          *
 299          * @since 1.21
 300          *
 301          * @param Site[] $sites
 302          *
 303          * @return bool Success indicator
 304          */
 305         public function saveSites( array $sites ) {
 306                 wfProfileIn( __METHOD__ );
 307
 308                 if ( empty( $sites ) ) {
 309                         wfProfileOut( __METHOD__ );
 310                         return true;
 311                 }
 312
 313                 $dbw = $this->sitesTable->getWriteDbConnection();
 314
 315                 $trx = $dbw->trxLevel();
 316
 317                 if ( $trx == 0 ) {
 318                         $dbw->begin( __METHOD__ );
 319                 }
 320
 321                 $success = true;
 322
 323                 $internalIds = array();
 324                 $localIds = array();
 325
 326                 foreach ( $sites as $site ) {
 327                         if ( $site->getInternalId() !== null ) {
 328                                 $internalIds[] = $site->getInternalId();
 329                         }
 330
 331                         $siteRow = $this->getRowFromSite( $site );
 332                         $success = $siteRow->save( __METHOD__ ) && $success;
 333
 334                         foreach ( $site->getLocalIds() as $idType => $ids ) {
 335                                 foreach ( $ids as $id ) {
 336                                         $localIds[] = array( $siteRow->getId(), $idType, $id );
 337                                 }
 338                         }
 339                 }
 340
 341                 if ( $internalIds !== array() ) {
 342                         $dbw->delete(
 343                                 'site_identifiers',
 344                                 array( 'si_site' => $internalIds ),
 345                                 __METHOD__
 346                         );
 347                 }
 348
 349                 foreach ( $localIds as $localId ) {
 350                         $dbw->insert(
 351                                 'site_identifiers',
 352                                 array(
 353                                         'si_site' => $localId[0],
 354                                         'si_type' => $localId[1],
 355                                         'si_key' => $localId[2],
 356                                 ),
 357                                 __METHOD__
 358                         );
 359                 }
 360
 361                 if ( $trx == 0 ) {
 362                         $dbw->commit( __METHOD__ );
 363                 }
 364
 365                 // purge cache
 366                 $this->reset();
 367
 368                 wfProfileOut( __METHOD__ );
 369                 return $success;
 370         }
 371
 372         /**
 373          * Purges the internal and external cache of the site list, forcing the list
 374          * of sites to be re-read from the database.
 375          *
 376          * @since 1.21
 377          */
 378         public function reset() {
 379                 wfProfileIn( __METHOD__ );
 380                 // purge cache
 381                 $cache = wfGetMainCache();
 382                 $cache->delete( $this->getCacheKey() );
 383                 $this->sites = null;
 384
 385                 wfProfileOut( __METHOD__ );
 386         }
 387
 388         /**
 389          * Clears the list of sites stored in the database.
 390          *
 391          * @see SiteStore::clear()
 392          *
 393          * @return bool Success
 394          */
 395         public function clear() {
 396                 wfProfileIn( __METHOD__ );
 397                 $dbw = $this->sitesTable->getWriteDbConnection();
 398
 399                 $trx = $dbw->trxLevel();
 400
 401                 if ( $trx == 0 ) {
 402                         $dbw->begin( __METHOD__ );
 403                 }
 404
 405                 $ok = $dbw->delete( 'sites', '*', __METHOD__ );
 406                 $ok = $dbw->delete( 'site_identifiers', '*', __METHOD__ ) && $ok;
 407
 408                 if ( $trx == 0 ) {
 409                         $dbw->commit( __METHOD__ );
 410                 }
 411
 412                 $this->reset();
 413
 414                 wfProfileOut( __METHOD__ );
 415                 return $ok;
 416         }
 417
 418         /**
 419          * @since 1.21
 420          *
 421          * @return ORMTable
 422          */
 423         protected function newSitesTable() {
 424                 return new ORMTable(
 425                         'sites',
 426                         array(
 427                                 'id' => 'id',
 428
 429                                 // Site data
 430                                 'global_key' => 'str',
 431                                 'type' => 'str',
 432                                 'group' => 'str',
 433                                 'source' => 'str',
 434                                 'language' => 'str',
 435                                 'protocol' => 'str',
 436                                 'domain' => 'str',
 437                                 'data' => 'array',
 438
 439                                 // Site config
 440                                 'forward' => 'bool',
 441                                 'config' => 'array',
 442                         ),
 443                         array(
 444                                 'type' => Site::TYPE_UNKNOWN,
 445                                 'group' => Site::GROUP_NONE,
 446                                 'source' => Site::SOURCE_LOCAL,
 447                                 'data' => array(),
 448
 449                                 'forward' => false,
 450                                 'config' => array(),
 451                                 'language' => '',
 452                         ),
 453                         'ORMRow',
 454                         'site_'
 455                 );
 456         }
 457
 458 }
 459
 460 /**
 461  * @deprecated
 462  */
 463 class Sites extends SiteSQLStore {
 464
 465         /**
 466          * Factory for creating new site objects.
 467          *
 468          * @since 1.21
 469          * @deprecated
 470          *
 471          * @param string|bool $globalId
 472          *
 473          * @return Site
 474          */
 475         public static function newSite( $globalId = false ) {
 476                 $site = new Site();
 477
 478                 if ( $globalId !== false ) {
 479                         $site->setGlobalId( $globalId );
 480                 }
 481
 482                 return $site;
 483         }
 484
 485         /**
 486          * @deprecated
 487          * @return SiteStore
 488          */
 489         public static function singleton() {
 490                 static $singleton;
 491
 492                 if ( $singleton === null ) {
 493                         $singleton = new static();
 494                 }
 495
 496                 return $singleton;
 497         }
 498
 499         /**
 500          * @deprecated
 501          * @param string $group
 502          * @return SiteList
 503          */
 504         public function getSiteGroup( $group ) {
 505                 return $this->getSites()->getGroup( $group );
 506         }
 507
 508 }