SiteSQLStore.php

Go to the documentation of this file.

<?php

class SiteSQLStore implements SiteStore {

        protected $sites = null;

        protected $sitesTable;

        private $cacheKey = null;

        private $cacheTimeout = 3600;

        public static function newInstance( ORMTable $sitesTable = null ) {
                return new static( $sitesTable );
        }

        protected function __construct( ORMTable $sitesTable = null ) {
                if ( $sitesTable === null ) {
                        $sitesTable = $this->newSitesTable();
                }

                $this->sitesTable = $sitesTable;
        }

        protected function getCacheKey() {
                wfProfileIn( __METHOD__ );

                if ( $this->cacheKey === null ) {
                        $type = 'SiteList#' . SiteList::getSerialVersionId();
                        $source = $this->sitesTable->getName();

                        if ( $this->sitesTable->getTargetWiki() !== false ) {
                                $source = $this->sitesTable->getTargetWiki() . '.' . $source;
                        }

                        $this->cacheKey = wfMemcKey( "$source/$type" );
                }

                wfProfileOut( __METHOD__ );
                return $this->cacheKey;
        }

        public function getSites( $source = 'cache' ) {
                wfProfileIn( __METHOD__ );

                if ( $source === 'cache' ) {
                        if ( $this->sites === null ) {
                                $cache = wfGetMainCache();
                                $sites = $cache->get( $this->getCacheKey() );

                                if ( is_object( $sites ) ) {
                                        $this->sites = $sites;
                                } else {
                                        $this->loadSites();
                                }
                        }
                }
                else {
                        $this->loadSites();
                }

                wfProfileOut( __METHOD__ );
                return $this->sites;
        }

        protected function siteFromRow( ORMRow $siteRow ) {
                wfProfileIn( __METHOD__ );

                $site = Site::newForType( $siteRow->getField( 'type', Site::TYPE_UNKNOWN ) );

                $site->setGlobalId( $siteRow->getField( 'global_key' ) );

                $site->setInternalId( $siteRow->getField( 'id' ) );

                if ( $siteRow->hasField( 'forward' ) ) {
                        $site->setForward( $siteRow->getField( 'forward' ) );
                }

                if ( $siteRow->hasField( 'group' ) ) {
                        $site->setGroup( $siteRow->getField( 'group' ) );
                }

                if ( $siteRow->hasField( 'language' ) ) {
                        $site->setLanguageCode( $siteRow->getField( 'language' ) === '' ? null : $siteRow->getField( 'language' ) );
                }

                if ( $siteRow->hasField( 'source' ) ) {
                        $site->setSource( $siteRow->getField( 'source' ) );
                }

                if ( $siteRow->hasField( 'data' ) ) {
                        $site->setExtraData( $siteRow->getField( 'data' ) );
                }

                if ( $siteRow->hasField( 'config' ) ) {
                        $site->setExtraConfig( $siteRow->getField( 'config' ) );
                }

                wfProfileOut( __METHOD__ );
                return $site;
        }

        protected function loadSites() {
                wfProfileIn( __METHOD__ );

                $this->sites = new SiteList();

                foreach ( $this->sitesTable->select() as $siteRow ) {
                        $this->sites[] = $this->siteFromRow( $siteRow );
                }

                // Batch load the local site identifiers.
                $ids = wfGetDB( $this->sitesTable->getReadDb() )->select(
                        'site_identifiers',
                        array(
                                'si_site',
                                'si_type',
                                'si_key',
                        ),
                        array(),
                        __METHOD__
                );

                foreach ( $ids as $id ) {
                        if ( $this->sites->hasInternalId( $id->si_site ) ) {
                                $site = $this->sites->getSiteByInternalId( $id->si_site );
                                $site->addLocalId( $id->si_type, $id->si_key );
                                $this->sites->setSite( $site );
                        }
                }

                $cache = wfGetMainCache();
                $cache->set( $this->getCacheKey(), $this->sites, $this->cacheTimeout );

                wfProfileOut( __METHOD__ );
        }

        public function getSite( $globalId, $source = 'cache' ) {
                wfProfileIn( __METHOD__ );

                $sites = $this->getSites( $source );

                wfProfileOut( __METHOD__ );
                return $sites->hasSite( $globalId ) ? $sites->getSite( $globalId ) : null;
        }

        public function saveSite( Site $site ) {
                return $this->saveSites( array( $site ) );
        }

        public function saveSites( array $sites ) {
                wfProfileIn( __METHOD__ );

                if ( empty( $sites ) ) {
                        wfProfileOut( __METHOD__ );
                        return true;
                }

                $dbw = $this->sitesTable->getWriteDbConnection();

                $trx = $dbw->trxLevel();

                if ( $trx == 0 ) {
                        $dbw->begin( __METHOD__ );
                }

                $success = true;

                $internalIds = array();
                $localIds = array();

                foreach ( $sites as $site ) {
                        $fields = array(
                                // Site data
                                'global_key' => $site->getGlobalId(), // TODO: check not null
                                'type' => $site->getType(),
                                'group' => $site->getGroup(),
                                'source' => $site->getSource(),
                                'language' => $site->getLanguageCode() === null ? '' : $site->getLanguageCode(),
                                'protocol' => $site->getProtocol(),
                                'domain' => strrev( $site->getDomain() ) . '.',
                                'data' => $site->getExtraData(),

                                // Site config
                                'forward' => $site->shouldForward(),
                                'config' => $site->getExtraConfig(),
                        );

                        if ( $site->getInternalId() !== null ) {
                                $fields['id'] = $site->getInternalId();
                                $internalIds[] = $site->getInternalId();
                        }

                        $siteRow = new ORMRow( $this->sitesTable, $fields );
                        $success = $siteRow->save( __METHOD__ ) && $success;

                        foreach ( $site->getLocalIds() as $idType => $ids ) {
                                foreach ( $ids as $id ) {
                                        $localIds[] = array( $siteRow->getId(), $idType, $id );
                                }
                        }
                }

                if ( $internalIds !== array() ) {
                        $dbw->delete(
                                'site_identifiers',
                                array( 'si_site' => $internalIds ),
                                __METHOD__
                        );
                }

                foreach ( $localIds as $localId ) {
                        $dbw->insert(
                                'site_identifiers',
                                array(
                                        'si_site' => $localId[0],
                                        'si_type' => $localId[1],
                                        'si_key' => $localId[2],
                                ),
                                __METHOD__
                        );
                }

                if ( $trx == 0 ) {
                        $dbw->commit( __METHOD__ );
                }

                // purge cache
                $this->reset();

                wfProfileOut( __METHOD__ );
                return $success;
        }

        public function reset() {
                wfProfileIn( __METHOD__ );
                // purge cache
                $cache = wfGetMainCache();
                $cache->delete( $this->getCacheKey() );
                $this->sites = null;

                wfProfileOut( __METHOD__ );
        }

        public function clear() {
                wfProfileIn( __METHOD__ );
                $dbw = $this->sitesTable->getWriteDbConnection();

                $trx = $dbw->trxLevel();

                if ( $trx == 0 ) {
                        $dbw->begin( __METHOD__ );
                }

                $ok = $dbw->delete( 'sites', '*', __METHOD__ );
                $ok = $dbw->delete( 'site_identifiers', '*', __METHOD__ ) && $ok;

                if ( $trx == 0 ) {
                        $dbw->commit( __METHOD__ );
                }

                $this->reset();

                wfProfileOut( __METHOD__ );
                return $ok;
        }

        protected function newSitesTable() {
                return new ORMTable(
                        'sites',
                        array(
                                'id' => 'id',

                                // Site data
                                'global_key' => 'str',
                                'type' => 'str',
                                'group' => 'str',
                                'source' => 'str',
                                'language' => 'str',
                                'protocol' => 'str',
                                'domain' => 'str',
                                'data' => 'array',

                                // Site config
                                'forward' => 'bool',
                                'config' => 'array',
                        ),
                        array(
                                'type' => Site::TYPE_UNKNOWN,
                                'group' => Site::GROUP_NONE,
                                'source' => Site::SOURCE_LOCAL,
                                'data' => array(),

                                'forward' => false,
                                'config' => array(),
                                'language' => '',
                        ),
                        'ORMRow',
                        'site_'
                );
        }

}

class Sites extends SiteSQLStore {

        public static function newSite( $globalId = false ) {
                $site = new Site();

                if ( $globalId !== false ) {
                        $site->setGlobalId( $globalId );
                }

                return $site;
        }

        public static function singleton() {
                static $singleton;

                if ( $singleton === null ) {
                        $singleton = new static();
                }

                return $singleton;
        }

        public function getSiteGroup( $group ) {
                return $this->getSites()->getGroup( $group );
        }

}