The Robot Lives

connect('localhost', 11211);
        }
        return self::$memcache;
    }
}
 
/**
 * The Key Group is the basic tag + version_info node which our fractional
 * key system relies on.
 */
interface FractionalKeyGroup
{
    public function __construct($group, $index, $version);
    public function getVersion();
    public function setVersion($version,$update);
    public function getGroupTag();
    public function getGroupName();
    public function IncrementVersion();
    public function ResetVersion();
    public function DelegateMemcacheQuery();
}
 
/**
 * The various key groups are merged together to form our final cache key.
 */
interface FractionalKey
{
    public function __construct($key, $groupId, array $keyGroups);
    public function AddKeyGroup(FractionalKeyGroup $keyGroup);
    public function getKey();
}
 
/**
 * This is the Standard Implementation of a KeyGroup.
 *    Additional Implementations are:
 * - Database or File Backed KeyGroups - Commonly you will want to persist versioning information on a layer that
 *   is less volatile than memcache. Memcache will perform garbage collection and could remove a keygroup that underpins a large set of data.
 *   If this keygroup is not persisted to a database or file persistence layer this garbage collection could result in a unnecessarily large swatch of
 *   cache in-validations.
 * - The Constant KeyGroup (A keygroup where the version number is static)
 * - The Time Delayed KeyGroup (a keygroup that uses a time delay when incrementing keygroup version. For example you may only want data up-to-date within
 * 10-30  minutes for some uses and within 1-2 minutes for other uses. A time delayed key group tracks multiple versions itself set to expire at different time intervals.).
 * allowing the end user to specify how stale of data they are willing to work with.
 */
class StandardKeyGroup implements FractionalKeyGroup
{
    protected $groupName;
    protected $groupIndex;
    protected $version;
    protected $memcache;
    static protected $VERSION_SEPERATOR = ":v";
    static protected $INDEX_SEPERATOR = "_";
 
    /**
     * This Control function is used to determine if the fractionalkey that contains this keygroup may multiget memcache for its version value.
     * For items like Static Keys we set this value to false to reduce strain on the memcache server albeit at increased php processing time to check this value.
     */
    public function DelegateMemcacheQuery() {
         return true;
    }
 
    /**
     *
     * @param string $group - name of group ("user", "day_of_week", "username", etc)
     * @param string $index - index  for group (unique id of group record in question)
     * @param int $version - group version can be manually set if desired.
     * @param bool $update - group version will not actually be updated in memcache unless specified.
     */
    public function __construct($group, $index = "na", $version = null, $update = false)
    {
        $this->groupName = $group;
        $this->groupIndex = $index;
        if(!empty($version)) {
            $this->version = $version;
            if($update){
                $this->_StoreVersion();
            }
        }
        $this->memcache = MemcacheSingleton::getInstance();
    }
 
    /**
     * returns the current version value for this group.
     * @return int
     */
    public function getVersion()
    {
        return isset($this->version) ? $this->version : $this->_getVersion();
    }
 
    /**
     * Modify the version used for this group.
     * @param int $version
     * @param bool $update  - Update Memcache/Persistant store.
     */
    public function setVersion($version, $update)
    {
        $this->version = $version;
        if($update) {
            $this->_StoreVersion();
        }
    }
 
    /**
     * Retrieve this groups tag (Unique GroupName Plus Versioning Info );
     * @return
     */
    public function getGroupTag() {
        return $this->getGroupName() . self::$VERSION_SEPERATOR . $this->getVersion();
    }
 
    /**
     * Retrive this groups name. (For example  USER_123423);
     * @return
     */
    public function getGroupName()
    {
        return $this->groupName . self::$INDEX_SEPERATOR . $this->groupIndex;
    }
 
    /**
     * Increment version number.
     */
    public function IncrementVersion()
    {
        if($this->version == null) {
            $this->ResetVersion();
        } else {
            $this->version += 1;
            $this->_StoreVersion();
        }
    }
 
    /**
     * Reset version number. We use a microtime stamp to insure this value is
     * always unique and will not result in a pull of invalidated data.
     */
    public function ResetVersion()
    {
        $this->version = intval(microtime(true) * 1000);
        $this->_StoreVersion();
    }
 
    protected function _getVersion()
    {
        if($this->version == null)
        {
            $result = $this->memcache->get($this->getGroupName());
            if(empty($result)) {
                $this->ResetVersion();
            }
            return $result;
        } else {
            return $this->version;
        }
    }
 
    protected function _StoreVersion()
    {
        $this->memcache->set($this->getGroupName(),$this->version);
    }
}
 
/**
*  This is a standard implementation of a fractional key, One obvious extensions would deal with the nesting of keys within keys.
*/
class StandardKey {
    protected $key;
    protected $groupId;
    protected $memcache;
    protected $keyGroups = array();
    static protected $TAG_SEPERATOR = ":t";
    static protected $INDEX_SEPERATOR = "_";
 
    public function __construct($key, $groupId, array $keyGroups = array()) {
        $this->key = $key;
        $this->groupId = $groupId;
 
        foreach($keyGroups as $keyGroup)
        {
            $this->keyGroups[$keyGroup->getGroupName()] = $keyGroup;
        }
        $this->memcache = MemcacheSingleton::getInstance();
    }
 
    public function AddKeyGroup(FractionalKeyGroup $keyGroup) {
        $this->keyGroups[$keyGroup->getGroupTag()] = $keyGroup;
    }
 
    public function getKey()
    {
        $key =  $this->key . self::$INDEX_SEPERATOR . $this->groupId . self::$TAG_SEPERATOR . implode(self::$TAG_SEPERATOR, $this->gatherTags());
        return $key;
    }
 
    /**
     *  While it would be architecturally cleaner to gather group versions from a KeyGroup function call
     *  the use of memcache multiget helps us avoid some bottle-necking produced by the increased number of key-versions we
     *  need to look-up when using this fractional key system.
     */
    protected function GatherGroupVersions() {
        $group_tags = array_keys($this->keyGroups);
 
        foreach ($group_tags as $group_tag) {
            if($this->keyGroups[$group_tag]->DelegateMemcacheQuery() == false) {
                unset($group_tag);
            }
        }
 
        $tags = $this->memcache->get($group_tags);
        foreach($this->keyGroups as $key => &$group) {
            if(array_key_exists($key, $tags))
            {
                $group->setVersion($tags[$key],false);
            } else {
                $group->ResetVersion();
            }
        }
    }
 
    /**
     *
     * @return array tag strings of all tags included within this key.
     */
    protected function GatherTags()
    {
        $this->GatherGroupVersions();
        $tags = array();
        foreach($this->keyGroups as $group)
        {
            $tags[] = $group->getGroupTag();
        }
        return $tags;
    }
}