CacheDependency.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
class DependencyWrapper {
    private $value;
    private $deps;
 
    function __construct( $value = false, $deps = [] ) {
        $this->value = $value;
 
        if ( !is_array( $deps ) ) {
            $deps = [ $deps ];
        }
 
        $this->deps = $deps;
    }
 
    function isExpired() {
        foreach ( $this->deps as $dep ) {
            if ( $dep->isExpired() ) {
                return true;
            }
        }
 
        return false;
    }
 
    function initialiseDeps() {
        foreach ( $this->deps as $dep ) {
            $dep->loadDependencyValues();
        }
    }
 
    function getValue() {
        return $this->value;
    }
 
    function storeToCache( $cache, $key, $expiry = 0 ) {
        $this->initialiseDeps();
        $cache->set( $key, $this, $expiry );
    }
 
    static function getValueFromCache( $cache, $key, $expiry = 0, $callback = false,
        $callbackParams = [], $deps = []
    ) {
        $obj = $cache->get( $key );
 
        if ( is_object( $obj ) && $obj instanceof DependencyWrapper && !$obj->isExpired() ) {
            $value = $obj->value;
        } elseif ( $callback ) {
            $value = call_user_func_array( $callback, $callbackParams );
            # Cache the newly-generated value
            $wrapper = new DependencyWrapper( $value, $deps );
            $wrapper->storeToCache( $cache, $key, $expiry );
        } else {
            $value = null;
        }
 
        return $value;
    }
}
 
abstract class CacheDependency {
    abstract function isExpired();
 
    function loadDependencyValues() {
    }
}
 
class FileDependency extends CacheDependency {
    private $filename;
    private $timestamp;
 
    function __construct( $filename, $timestamp = null ) {
        $this->filename = $filename;
        $this->timestamp = $timestamp;
    }
 
    function __sleep() {
        $this->loadDependencyValues();
 
        return [ 'filename', 'timestamp' ];
    }
 
    function loadDependencyValues() {
        if ( is_null( $this->timestamp ) ) {
            MediaWiki\suppressWarnings();
            # Dependency on a non-existent file stores "false"
            # This is a valid concept!
            $this->timestamp = filemtime( $this->filename );
            MediaWiki\restoreWarnings();
        }
    }
 
    function isExpired() {
        MediaWiki\suppressWarnings();
        $lastmod = filemtime( $this->filename );
        MediaWiki\restoreWarnings();
        if ( $lastmod === false ) {
            if ( $this->timestamp === false ) {
                # Still nonexistent
                return false;
            } else {
                # Deleted
                wfDebug( "Dependency triggered: {$this->filename} deleted.\n" );
 
                return true;
            }
        } else {
            if ( $lastmod > $this->timestamp ) {
                # Modified or created
                wfDebug( "Dependency triggered: {$this->filename} changed.\n" );
 
                return true;
            } else {
                # Not modified
                return false;
            }
        }
    }
}
 
class GlobalDependency extends CacheDependency {
    private $name;
    private $value;
 
    function __construct( $name ) {
        $this->name = $name;
        $this->value = $GLOBALS[$name];
    }
 
    function isExpired() {
        if ( !isset( $GLOBALS[$this->name] ) ) {
            return true;
        }
 
        return $GLOBALS[$this->name] != $this->value;
    }
}
 
class MainConfigDependency extends CacheDependency {
    private $name;
    private $value;
 
    function __construct( $name ) {
        $this->name = $name;
        $this->value = $this->getConfig()->get( $this->name );
    }
 
    private function getConfig() {
        return MediaWikiServices::getInstance()->getMainConfig();
    }
 
    function isExpired() {
        if ( !$this->getConfig()->has( $this->name ) ) {
            return true;
        }
 
        return $this->getConfig()->get( $this->name ) != $this->value;
    }
}
 
class ConstantDependency extends CacheDependency {
    private $name;
    private $value;
 
    function __construct( $name ) {
        $this->name = $name;
        $this->value = constant( $name );
    }
 
    function isExpired() {
        return constant( $this->name ) != $this->value;
    }
}