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 getRowFromSite( Site $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();
        }

        return new ORMRow( $this->sitesTable, $fields );
    }

    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();

        $dbw->startAtomic( __METHOD__ );

        $success = true;

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

        foreach ( $sites as $site ) {
            if ( $site->getInternalId() !== null ) {
                $internalIds[] = $site->getInternalId();
            }

            $siteRow = $this->getRowFromSite( $site );
            $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__
            );
        }

        $dbw->endAtomic( __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();

        $dbw->startAtomic( __METHOD__ );
        $ok = $dbw->delete( 'sites', '*', __METHOD__ );
        $ok = $dbw->delete( 'site_identifiers', '*', __METHOD__ ) && $ok;
        $dbw->endAtomic( __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 );
    }
}