ExternalStore.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
class ExternalStore {
    public static function getStoreObject( $proto, array $params = [] ) {
        return MediaWikiServices::getInstance()
            ->getExternalStoreFactory()
            ->getStoreObject( $proto, $params );
    }
 
    public static function fetchFromURL( $url, array $params = [] ) {
        $parts = explode( '://', $url, 2 );
        if ( count( $parts ) != 2 ) {
            return false; // invalid URL
        }
 
        list( $proto, $path ) = $parts;
        if ( $path == '' ) { // bad URL
            return false;
        }
 
        $store = self::getStoreObject( $proto, $params );
        if ( $store === false ) {
            return false;
        }
 
        return $store->fetchFromURL( $url );
    }
 
    public static function batchFetchFromURLs( array $urls ) {
        $batches = [];
        foreach ( $urls as $url ) {
            $scheme = parse_url( $url, PHP_URL_SCHEME );
            if ( $scheme ) {
                $batches[$scheme][] = $url;
            }
        }
        $retval = [];
        foreach ( $batches as $proto => $batchedUrls ) {
            $store = self::getStoreObject( $proto );
            if ( $store === false ) {
                continue;
            }
            $retval += $store->batchFetchFromURLs( $batchedUrls );
        }
        // invalid, not found, db dead, etc.
        $missing = array_diff( $urls, array_keys( $retval ) );
        if ( $missing ) {
            foreach ( $missing as $url ) {
                $retval[$url] = false;
            }
        }
 
        return $retval;
    }
 
    public static function insert( $url, $data, array $params = [] ) {
        $parts = explode( '://', $url, 2 );
        if ( count( $parts ) != 2 ) {
            return false; // invalid URL
        }
 
        list( $proto, $path ) = $parts;
        if ( $path == '' ) { // bad URL
            return false;
        }
 
        $store = self::getStoreObject( $proto, $params );
        if ( $store === false ) {
            return false;
        } else {
            return $store->store( $path, $data );
        }
    }
 
    public static function insertToDefault( $data, array $params = [] ) {
        global $wgDefaultExternalStore;
 
        return self::insertWithFallback( (array)$wgDefaultExternalStore, $data, $params );
    }
 
    public static function insertWithFallback( array $tryStores, $data, array $params = [] ) {
        $error = false;
        while ( count( $tryStores ) > 0 ) {
            $index = mt_rand( 0, count( $tryStores ) - 1 );
            $storeUrl = $tryStores[$index];
            wfDebug( __METHOD__ . ": trying $storeUrl\n" );
            list( $proto, $path ) = explode( '://', $storeUrl, 2 );
            $store = self::getStoreObject( $proto, $params );
            if ( $store === false ) {
                throw new MWException( "Invalid external storage protocol - $storeUrl" );
            }
 
            try {
                if ( $store->isReadOnly( $path ) ) {
                    $msg = 'read only';
                } else {
                    $url = $store->store( $path, $data );
                    if ( $url !== false ) {
                        return $url; // a store accepted the write; done!
                    }
                    $msg = 'operation failed';
                }
            } catch ( Exception $error ) {
                $msg = 'caught exception';
            }
 
            unset( $tryStores[$index] ); // Don't try this one again!
            $tryStores = array_values( $tryStores ); // Must have consecutive keys
            wfDebugLog( 'ExternalStorage',
                "Unable to store text to external storage $storeUrl ($msg)" );
        }
        // All stores failed
        if ( $error ) {
            throw $error; // rethrow the last error
        } else {
            throw new MWException( "Unable to store text to external storage" );
        }
    }
 
    public static function defaultStoresAreReadOnly() {
        global $wgDefaultExternalStore;
 
        $tryStores = (array)$wgDefaultExternalStore;
        if ( !$tryStores ) {
            return false; // no stores exists which can be "read only"
        }
 
        foreach ( $tryStores as $storeUrl ) {
            list( $proto, $path ) = explode( '://', $storeUrl, 2 );
            $store = self::getStoreObject( $proto, [] );
            if ( !$store->isReadOnly( $path ) ) {
                return false; // at least one store is not read-only
            }
        }
 
        return true; // all stores are read-only
    }
 
    public static function insertToForeignDefault( $data, $wiki ) {
        return self::insertToDefault( $data, [ 'wiki' => $wiki ] );
    }
}