SafeCache.class.php

<?php

/*

 */
class SafeCache {

  private $work_dir;

  private $_WLock;
  private $_RLock;
  private $content_fp;
  // persistent counter/etc.
  // private $seen = array();
  private $isReadyToRead = false;

  public $publisher;
  public $file; // string id
  public $temp_file;

  private $hash_id;
  private $opt;

  function __construct ($id, $arg=array()) {

    $this->file = $id;
    $this->temp_file = $id .".temp";
    $this->hash_id = md5($id);

    $this->opt = $arg + array(
      "work_dir" => "/tmp/safe_resource_access",
      "work_dir_perm" => 0755,
      "cacheTTL" => 3*60, // sec; cache expiration for readers
      "diffTTL"  => 15,   // sec; for publisher cache expires after cacheTTL-diffTTL
      "clearstatcache" => true,
    );

    $this->work_dir = $this->opt["work_dir"];
    // mkdir recursive
    if (! is_dir($this->work_dir) ) mkdir($this->work_dir, $this->opt["work_dir_perm"], true);

  }

  // call user func or inherit this method
  function hasResourceExpired () {

    $func = $this->opt["hasResourceExpired"];

    if ($func) return $func($this);

    $cacheTTL = $this->opt["cacheTTL"];
    if ($this->publisher) $cacheTTL -= $this->opt["diffTTL"];

    if ($this->opt["clearstatcache"]) clearstatcache();
    $filemtime = file_exists($this->file) ? filemtime($this->file) : 0;

    return ($filemtime + $cacheTTL < time());
  }
  // call user func or inherit this method
  function newContent () {

    $func = $this->opt["newContent"];

    if (!$func) return false;

    // $fp = $this->get_temp_fp();
    $fp = fopen($this->temp_file, "wb");
    if (!$fp) return false;

    $content = $func($this, $fp);
    if (isset($content) and $content !== false) fwrite($fp, $content);

    return fclose($fp);
  }

  // print static content
  function output () {

    $this->ready();
    $ok = readfile($this->file) !== false;
    $this->finish();

    return $ok;
  }

  // include php file
  function include_php () {

    $this->ready();
    include $this->file;
    $this->finish();
  }

  // get file contents
  function get () {

    $this->ready();
    $ret = file_get_contents($this->file);
    $this->finish();

    return $ret;
  }

  // get file handle
  function getHandle ($force=false) {

    $this->ready();

    if (!$this->content_fp or $force) {
      $this->content_fp = fopen($this->file, "r");
    }
    // $this->finish();
    return $this->content_fp;
  }

  //
  function ready () {

    if ($this->isReadyToRead) return;

    $this->publisher = $this->getExclusive();

    if ($this->publisher) {

      if ( $this->hasResourceExpired() ) {
        // generate new content in $this->temp_file
        $this->newContent();
        // publish new content
        $this->publish();
      }
      // do reading..
      // $this->doneExclusive();
    }
    else {
      if ( $this->hasResourceExpired() ) $this->waitForRefresh();
      $this->waitForReading();
      // do reading..
      // $this->doneReading();
    }

    $this->isReadyToRead = true;

  }

  // manually release locks
  function finish () {
    $this->isReadyToRead = false;
    $this->content_fp = null;
    return $this->publisher ? $this->doneExclusive() : $this->doneReading();
  }

  // acquire ex. Wlock; nonblocking, return true|false
  function getExclusive() {

    return $this->getWLock($block=0);
  }

  // publish new content
  function publish () {

    // $this->waitForWriting();
    $this->getRLock($exclusive=1);

    rename($this->temp_file, $this->file);

    // $this->doneWriting();
    $this->doneReading();
  }

  // release sh. Rlock
  function doneReading () {

    $ok = $this->releaseLock($this->_RLock);
    unset($this->_RLock);
    return $ok;
  }

  // acquire and release ex Wlock
  function waitForRefresh () {
    $ok = $this->getWLock($block=1) && $this->doneExclusive();
    return $ok;
  }

  // acquire sh. Rlock
  function waitForReading () {

    return $this->getRLock($exclusive=0);
  }

  // release ex. Wlock
  function doneExclusive () {

    $ok = $this->releaseLock($this->_WLock);
    unset($this->_WLock);
    return $ok;
  }


  //
  function releaseLock($fp) {

    if (!$fp) return;
    $ok = flock($fp, LOCK_UN);
    // fclose alone does unlock
    $ok = fclose($fp);

    return $ok;
  }

  // write lock is always exclusive (only my thread and nobody else)
  function getWLock($block) {
    $lock = $block ? LOCK_EX : LOCK_EX|LOCK_NB;

    $lfile = $this->work_dir ."/". $this->hash_id .".wlock";

    $fp = fopen($lfile, "wb");
    if (!$fp) return false;

    // get exclusive lock
    $ok = flock($fp, $lock);
    if ($ok) { $this->_WLock = $fp; } else { fclose($fp); }

    return $ok;
  }

  // read lock is always blocking (always waiting for lock)
  function getRLock($exclusive) {
    $lock = $exclusive ? LOCK_EX : LOCK_SH;

    $lfile = $this->work_dir ."/". $this->hash_id .".rlock";

    $fp = fopen($lfile, "wb");
    if (!$fp) return false;

    // get shared (read) or ex. lock
    $ok = flock($fp, $lock);
    if ($ok) { $this->_RLock = $fp; } else { fclose($fp); }

    return $ok;
  }

}