cache.inc.php

Go to the documentation of this file.

<?
class CacheBot
{
    private static $bot = null;

    private function __construct()
    {
    }
    
    public static function getBot()
    {
        //is it legit?
        if (self::$bot instanceOf EasyCache)
            return self::$bot;
        //nope, default to no caching.
        else
        {
            self::setBot(new NoCache());
            return self::getBot();
        }
    }

    public static function setBot($bot, $prefix = '')
    {
        if ($bot instanceOf EasyCache)
            self::$bot = $bot;
        else
            throw new Exception('Cachebots must be a derivitive of EasyCache');
    }

    public static function get($key, $life = null)
    {
        //if we're not null... set our life.
        if ($life !== null)
        {
            $oldLife = EasyCache::$life;
            EasyCache::$life = (int)$life;
        }
            
        $rval = self::$bot->get($key);
        
        //set the bot back to its old value.
        if (isset($oldLife))
            EasyCache::$life = $oldLife;

        return $rval;
    }
    
    public static function set($key, $data, $life = null)
    {
        //if we're not null... set our life.
        if ($life !== null)
        {
            $oldLife = EasyCache::$life;
            EasyCache::$life = (int)$life;
        }
            
        //save it.
        $rval = self::$bot->set($key, $data);
    
        //set the bot back to its old value.
        if (isset($oldLife))
            EasyCache::$life = $oldLife;

        //return it!
        return $rval;
    }

    public static function delete($key)
    {
        return self::$bot->delete($key);
    }
    
    public static function flush()
    {
        return self::$bot->flush();
    }
}

abstract class EasyCache
{
    public static $life = 3600;

    public static $hits = 0;

    private static $keys = array();

    public function __construct($life = null)
    {
        if ($life)
            self::$life = (int)$life;
    }
    
    abstract public function get($key);

    abstract public function set($key, $data);

    abstract public function delete($key);

    abstract public function flush();

    public static function markCacheHit($key, $type = 'get')
    {
        //increment the total number
        self::$hits++;

        //add it to our array
        if (Config::get("bj_track_cache"))
        {
            self::$keys['keys'][] = $key;
            self::$keys['type'][] = $type;
        }
    }

    public static function drawCacheStats()
    {
        global $me;
        
        echo "<div class=\"cacheHits\">";
        foreach (self::$keys['keys'] AS $index => $key)
        {
            if (is_array($key))
            {
                $links = array();
                foreach ($key AS $val)
                    $links[] = $me->getLink("admin.viewcache?val=" . base64_encode($val), $val);
                
                echo "<p>Get Keyset:" . implode(", ", $links) . "</p>";
            }
            else
                echo "<p>" . ucfirst(self::$keys['type'][$index]) . ": " . $me->getLink("admin.viewcache?key=" . base64_encode($key), $key) . "</p>\n";
        }
        echo "</div>";
    }
}

class EasyMemCache extends EasyCache
{
    public $mc;
    
    public function __construct($servers = 'localhost:112211', $life = null)
    {
        //error checking.
        if (!class_exists('Memcache'))
            throw new Exception('Memcache is not installed in PHP.');

        //call mommy.
        parent::__construct($life);
        
        //create our cache object
        $this->mc = new Memcache;
        
        //did we get a string?
        if (is_string($servers))
            $servers = array($servers);
        
        //connect to servers.
        if (count($servers))
            foreach ($servers AS $server)
                if (preg_match('/^(.*):([0-9]*)$/', $server, $matches))
                    $this->mc->addServer($matches[1], $matches[2]);
        else
            throw new Exception('Weird servers passed to EasyMemCache.');
    }

    public function get($key)
    {
        self::markCacheHit($key, 'get');
        
        //get an array of keys.
        if (is_array($key))
        {
            $ret = array();

            //only do something if its no empty
            if (count($key))
            {
                //init.
                foreach ($key AS $id)
                    $ret[$id] = false;
                
                //get all our keys.
                $data = $this->mc->get($key);
                
                //save our data.
                foreach ($data AS $index => $val)
                    $ret[$index] = $val;
            }

            return $ret;
        }
        //return our single value
        else
            return $this->mc->get($key);
    }

    public function set($key, $data)
    {
        self::markCacheHit($key, 'set');
        
        return $this->mc->set($key, $data, MEMCACHE_COMPRESSED, self::$life);
    }

    public function delete($key)
    {
        self::markCacheHit($key, 'delete');
        
        return $this->mc->delete($key);
    }

    public function flush()
    {
        $this->mc->flush();
    }
}

class EasyFileCache extends EasyCache
{
    private $path;
    
    public function __construct($path = "/tmp/EasyCache/", $life = null)
    {
        parent::__construct($life);
        
        $this->path = $path;

        //make sure our cache directory exists.
        if (!is_dir($this->path))
            mkdir($this->path, 0777, true);
    }
    
    public function get($key)
    {
        //if its an array... then we want want to lookup all the caches
        if (is_array($key))
        {
            $ret = array();

            //if there are keys, look them up individually (this is the downfall of file cache)
            if (count($key))
                foreach ($key AS $single)
                    $ret[$single] = $this->get($single);
        
            return $ret;
        }
        //nope, just a single key...
        else
        {
            //mark it here because arrays all go here.
            self::markCacheHit($key, 'get');
            
            //get the cache.
            if ($this->isCached($key))
            {
                $data = file_get_contents($this->getCachePath($key));
                return unserialize($data);
            }
            else
                return null;
        }
    }

    public function set($key, $data)
    {
        self::markCacheHit($key, 'set');
        
        file_put_contents($this->getCachePath($key), serialize($data));
    }

    public function delete($key)
    {
        self::markCacheHit($key, 'delete');
        
        $file = $this->getCachePath($key);

        if (file_exists($file))
            unlink($file);
    }

    public function flush()
    {
        //delete everything on the path.
        $cmd = "find $this->path -type f | xargs rm";
        Util::shellExec($cmd);
    }
    
    protected function isCached($key)
    {
        $file = $this->getCachePath($key);

        //does it exist?
        if (file_exists($file))
        {
            //okay, now is it legit?
            $minAge = time() - self::$life;
            if (filemtime($file) >= $minAge)
                return true;
            //nope, stale... kill it
            else
                $this->delete($key);
        }

        return false;
    }
    
    protected function getCachePath($key)
    {
        return $this->path . sha1($key);
    }
}

class EasyDBCache extends EasyCache
{
    private $table;
    
    public function __construct($table = "easy_cache", $life = null)
    {
        parent::__construct($life);
        
        $this->table = $table;

//umm... we shoudl put this somewhere else.
//      if (!BaseJumper::dbHasTable($this->table))
//          $this->createTable();
    }

    protected function createTable()
    {
        dbQuery("
            CREATE TABLE $this->table
            (
                `id` varchar(255) default '' not null,
                `data` mediumtext default '' not null,
                `expire_date` datetime not null,
                KEY(id)
            ) ENGINE=InnoDB 
        ");
    }
    
    public function get($key)
    {
        self::markCacheHit($key, 'get');
        
        //if its an array, then get all the keys
        if (is_array($key))
        {
            //init our array.
            $rval = array();
            
            //make sure we got some.
            if (count($key))
            {
                //init it incase we dont find it.
                foreach ($key AS $id)
                    $rval[$id] = false; 
            
                //do our query
                $rs = dbQuery("
                    SELECT ec.*, ec.expire_date <= NOW() AS expired
                    FROM $this->table ec
                    WHERE ec.id IN ('" . implode("', '", $key) . "')
                ");

                //get them all
                while ($ar = dbFetchAssoc($rs))
                {
                    //what one?
                    $id = $ar['id'];
                    
                    //if we're expired... delete it.
                    if ((int)$ar['expired'])
                        $this->delete($id);
                    //nope, we go it.. save it.
                    else
                        $rval[$id] = unserialize($ar['data']);
                }
            }

            //send the array of cached stuff back
            return $rval;
        }
        $ar = dbFetchAssoc(dbQuery("
            SELECT ec.*, ec.expire_date <= NOW() AS expired
            FROM $this->table ec
            WHERE id = '$key'
        "));

        if (is_array($ar))
        {
            //if we're expired... delete it.
            if ((int)$ar['expired'])
                $this->delete($key);
            else
                return unserialize($ar['data']);
        }

        //if we didnt return before, we will now =)
        return null;
    }

    public function set($key, $data)
    {
        self::markCacheHit($key, 'set');
        
        //first delete our old data.
        $this->delete($key);

        //format our data.
        $data = dbEscape(serialize($data));

        //insert it!
        dbExecute("
            INSERT INTO $this->table
                (id, data, expire_date)
            VALUES
                ('$key', '$data', DATE_ADD(NOW(), INTERVAL " . self::$life . " SECOND))
        ");
    } 

    public function delete($key)
    {
        self::markCacheHit($key, 'delete');
        
        dbExecute("
            DELETE FROM $this->table
            WHERE id = '$key'
        ");
    }

    public function flush()
    {
        dbExecute("
            DELETE FROM $this->table
        ");
    }
}

class NoCache extends EasyCache
{
    public function get($key)
    {
        self::markCacheHit($key, 'get');
        return null;
    }
    
    public function set($key, $data)
    {
        self::markCacheHit($key, 'set');
        return true;
    }
    
    public function delete($key)
    {
        self::markCacheHit($key, 'delete');
        return true;
    }

    public function flush()
    {
        return true;
    }
}

?>

---