CacheDependency.php

Go to the documentation of this file.

<?php
class DependencyWrapper {
    var $value;
    var $deps;

    function __construct( $value = false, $deps = array() ) {
        $this->value = $value;

        if ( !is_array( $deps ) ) {
            $deps = array( $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 = array(), $deps = array() )
    {
        $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 {
    var $filename, $timestamp;

    function __construct( $filename, $timestamp = null ) {
        $this->filename = $filename;
        $this->timestamp = $timestamp;
    }

    function __sleep() {
        $this->loadDependencyValues();
        return array( 'filename', 'timestamp' );
    }

    function loadDependencyValues() {
        if ( is_null( $this->timestamp ) ) {
            if ( !file_exists( $this->filename ) ) {
                # Dependency on a non-existent file
                # This is a valid concept!
                $this->timestamp = false;
            } else {
                $this->timestamp = filemtime( $this->filename );
            }
        }
    }

    function isExpired() {
        if ( !file_exists( $this->filename ) ) {
            if ( $this->timestamp === false ) {
                # Still nonexistent
                return false;
            } else {
                # Deleted
                wfDebug( "Dependency triggered: {$this->filename} deleted.\n" );
                return true;
            }
        } else {
            $lastmod = filemtime( $this->filename );
            if ( $lastmod > $this->timestamp ) {
                # Modified or created
                wfDebug( "Dependency triggered: {$this->filename} changed.\n" );
                return true;
            } else {
                # Not modified
                return false;
            }
        }
    }
}

class TitleDependency extends CacheDependency {
    var $titleObj;
    var $ns, $dbk;
    var $touched;

    function __construct( Title $title ) {
        $this->titleObj = $title;
        $this->ns = $title->getNamespace();
        $this->dbk = $title->getDBkey();
    }

    function loadDependencyValues() {
        $this->touched = $this->getTitle()->getTouched();
    }

    function __sleep() {
        return array( 'ns', 'dbk', 'touched' );
    }

    function getTitle() {
        if ( !isset( $this->titleObj ) ) {
            $this->titleObj = Title::makeTitle( $this->ns, $this->dbk );
        }

        return $this->titleObj;
    }

    function isExpired() {
        $touched = $this->getTitle()->getTouched();

        if ( $this->touched === false ) {
            if ( $touched === false ) {
                # Still missing
                return false;
            } else {
                # Created
                return true;
            }
        } elseif ( $touched === false ) {
            # Deleted
            return true;
        } elseif ( $touched > $this->touched ) {
            # Updated
            return true;
        } else {
            # Unmodified
            return false;
        }
    }
}

class TitleListDependency extends CacheDependency {
    var $linkBatch;
    var $timestamps;

    function __construct( LinkBatch $linkBatch ) {
        $this->linkBatch = $linkBatch;
    }

    function calculateTimestamps() {
        # Initialise values to false
        $timestamps = array();

        foreach ( $this->getLinkBatch()->data as $ns => $dbks ) {
            if ( count( $dbks ) > 0 ) {
                $timestamps[$ns] = array();

                foreach ( $dbks as $dbk => $value ) {
                    $timestamps[$ns][$dbk] = false;
                }
            }
        }

        # Do the query
        if ( count( $timestamps ) ) {
            $dbr = wfGetDB( DB_SLAVE );
            $where = $this->getLinkBatch()->constructSet( 'page', $dbr );
            $res = $dbr->select(
                'page',
                array( 'page_namespace', 'page_title', 'page_touched' ),
                $where,
                __METHOD__
            );

            foreach ( $res as $row ) {
                $timestamps[$row->page_namespace][$row->page_title] = $row->page_touched;
            }
        }

        return $timestamps;
    }

    function loadDependencyValues() {
        $this->timestamps = $this->calculateTimestamps();
    }

    function __sleep() {
        return array( 'timestamps' );
    }

    function getLinkBatch() {
        if ( !isset( $this->linkBatch ) ) {
            $this->linkBatch = new LinkBatch;
            $this->linkBatch->setArray( $this->timestamps );
        }
        return $this->linkBatch;
    }

    function isExpired() {
        $newTimestamps = $this->calculateTimestamps();

        foreach ( $this->timestamps as $ns => $dbks ) {
            foreach ( $dbks as $dbk => $oldTimestamp ) {
                $newTimestamp = $newTimestamps[$ns][$dbk];

                if ( $oldTimestamp === false ) {
                    if ( $newTimestamp === false ) {
                        # Still missing
                    } else {
                        # Created
                        return true;
                    }
                } elseif ( $newTimestamp === false ) {
                    # Deleted
                    return true;
                } elseif ( $newTimestamp > $oldTimestamp ) {
                    # Updated
                    return true;
                } else {
                    # Unmodified
                }
            }
        }

        return false;
    }
}

class GlobalDependency extends CacheDependency {
    var $name, $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 ConstantDependency extends CacheDependency {
    var $name, $value;

    function __construct( $name ) {
        $this->name = $name;
        $this->value = constant( $name );
    }

    function isExpired() {
        return constant( $this->name ) != $this->value;
    }
}