MemCachedClient.inc.php

Go to the documentation of this file.

<?php
/*
 * MemCached PHP client
 * Copyright (c) 2003
 * Ryan Gilfether <hotrodder@rocketmail.com>
 * http://www.gilfether.com
 *
 * Originally translated from Brad Fitzpatrick's <brad@danga.com> MemCached Perl client
 * See the memcached website:
 * http://www.danga.com/memcached/
 *
 * This module is Copyright (c) 2003 Ryan Gilfether.
 * All rights reserved.
 * You may distribute under the terms of the GNU General Public License
 * This is free software. IT COMES WITHOUT WARRANTY OF ANY KIND.
 *
 */

define("MC_VERSION", "1.0.10");
define("MC_BUFFER_SZ", 1024);
define("MC_ERR_NOT_ACTIVE", 1001);      // no active servers
define("MC_ERR_SOCKET_WRITE", 1002);    // socket_write() failed
define("MC_ERR_SOCKET_READ", 1003);     // socket_read() failed
define("MC_ERR_SOCKET_CONNECT", 1004);  // failed to connect to host
define("MC_ERR_DELETE", 1005);          // delete() did not recieve DELETED command
define("MC_ERR_HOST_FORMAT", 1006);     // sock_to_host() invalid host format
define("MC_ERR_HOST_DEAD", 1007);       // sock_to_host() host is dead
define("MC_ERR_GET_SOCK", 1008);        // get_sock() failed to find a valid socket
define("MC_ERR_SET", 1009);             // _set() failed to receive the STORED response
define("MC_ERR_GET_KEY", 1010);         // _load_items no values returned for key(s)
define("MC_ERR_LOADITEM_END", 1011);    // _load_items failed to receive END response
define("MC_ERR_LOADITEM_BYTES", 1012);  // _load_items bytes read larger than bytes available


class MemCachedClient
{
    var $host_dead;
    var $cache_sock;
    var $debug;
    var $servers;
    var $active;
    var $errno;
    var $errstr;
    var $compress = 1;
    var $comp_active = 1;

    var $bucket;


        function MemCachedClient($options = 0)
        {
                if(is_array($options))
                {
                        $this->set_servers($options["servers"]);
                        $this->debug = $options["debug"];
                        $this->compress = $options["compress"];
                        $this->cache_sock = array();
                }

                $this->errno = 0;
                $this->errstr = "";
        }


        function set_servers($servers)
        {
                $this->servers = $servers;
                $this->active = count($this->servers);
        }


        function set_debug($do_debug)
        {
                $this->debug = $do_debug;
        }


        function forget_dead_hosts()
        {
                unset($this->host_dead);
        }


        function disconnect_all()
        {
                foreach($this->cache_sock as $sock)
                        socket_close($sock);

                unset($this->cache_sock);
                $this->active = 0;
        }


        function delete($key, $time = 0)
        {
                if(!$this->active)
                {
                        $this->errno = MC_ERR_NOT_ACTIVE;
                        $this->errstr = "No active servers are available";

                        if($this->debug)
                                $this->_debug("delete(): There are no active servers available.");

                        return FALSE;
                }

                $sock = $this->get_sock($key);

                if(!is_resource($sock))
                {
                        $this->errno = MC_ERR_GET_SOCK;
                        $this->errstr = "Unable to retrieve a valid socket.";

                        if($this->debug)
                                $this->_debug("delete(): get_sock() returned an invalid socket.");

                        return FALSE;
                }

                if(is_array($key))
                        $key = $key[1];

                $cmd = "delete $key $time\r\n";
                $cmd_len = strlen($cmd);
                $offset = 0;

                // now send the command
                while($offset < $cmd_len)
                {
                        $result = socket_write($sock, substr($cmd, $offset, MC_BUFFER_SZ), MC_BUFFER_SZ);

                        if($result !== FALSE)
                                $offset += $result;
                        else if($offset < $cmd_len)
                        {
                                $this->errno = MC_ERR_SOCKET_WRITE;
                                $this->errstr = "Failed to write to socket.";

                                if($this->debug)
                                {
                                        $sockerr = socket_last_error($sock);
                                        $this->_debug("delete(): socket_write() returned FALSE. Socket Error $sockerr: ".socket_strerror($sockerr));
                                }

                                return FALSE;
                        }
                }

                // now read the server's response
                if(($retval = socket_read($sock, MC_BUFFER_SZ, PHP_NORMAL_READ)) === FALSE)
                {
                        $this->errno = MC_ERR_SOCKET_READ;
                        $this->errstr = "Failed to read from socket.";

                        if($this->debug)
                        {
                                $sockerr = socket_last_error($sock);
                                $this->_debug("delete(): socket_read() returned FALSE. Socket Error $sockerr: ".socket_strerror($sockerr));
                        }

                        return FALSE;
                }

                // remove the \r\n from the end
                $retval = rtrim($retval);

                // now read the server's response
                if($retval == "DELETED")
                        return TRUE;
                else
                {
                        // something went wrong, create the error
                        $this->errno = MC_ERR_DELETE;
                        $this->errstr = "Failed to receive DELETED response from server.";

                        if($this->debug)
                                $this->_debug("delete(): Failed to receive DELETED response from server. Received $retval instead.");

                        return FALSE;
                }
        }


        function add($key, $val, $exptime = 0)
        {
                return $this->_set("add", $key, $val, $exptime);
        }


        function replace($key, $val, $exptime = 0)
        {
                return $this->_set("replace", $key, $val, $exptime);
        }


        function set($key, $val, $exptime = 0)
        {
                return $this->_set("set", $key, $val, $exptime);
        }


        function get($key)
        {
                $val =& $this->get_multi($key);

                if(!$val)
                {
                        $this->errno = MC_ERR_GET_KEY;
                        $this->errstr = "No value found for key $key";

                        if($this->debug)
                                $this->_debug("get(): No value found for key $key");

                        return FALSE;
                }

                return $val[$key];
        }


        function get_multi($keys)
        {
                $sock_keys = array();
                $socks = array();
                $val = 0;

                if(!$this->active)
                {
                        $this->errno = MC_ERR_NOT_ACTIVE;
                        $this->errstr = "No active servers are available";

                        if($this->debug)
                                $this->_debug("get_multi(): There are no active servers available.");

                        return FALSE;
                }

                if(!is_array($keys))
                {
                        $arr[] = $keys;
                        $keys = $arr;
                }

                foreach($keys as $k)
                {
                        $sock = $this->get_sock($k);

                        if($sock)
                        {
                                $k = is_array($k) ? $k[1] : $k;

                                if(@!is_array($sock_keys[$sock]))
                                        $sock_keys[$sock] = array();

                                // if $sock_keys[$sock] doesn't exist, create it
                                if(!$sock_keys[$sock])
                                        $socks[] = $sock;

                                $sock_keys[$sock][] = $k;
                        }
                }

                if(!is_array($socks))
                {
                        $arr[] = $socks;
                        $socks = $arr;
                }

                foreach($socks as $s)
                {
                        $this->_load_items($s, $val, $sock_keys[$sock]);
                }

                if($this->debug)
                {
                        while(list($k, $v) = @each($val))
                                $this->_debug("MemCache: got $k = $v\n");
                }

                return $val;
        }


        function incr($key, $value = 1)
        {
                return $this->_incrdecr("incr", $key, $value);
        }


        function decr($key, $value = 1)
        {
                return $this->_incrdecr("decr", $key, $value);
        }


        function error()
        {
                return $this->errno;
        }


        function error_string()
        {
                return $this->errstr;
        }


        function error_clear()
        {
                // reset to no error
                $this->errno = 0;
                $this->errstr = "";
        }


        function set_compression($setting=1) {
                if ($setting != 0) {
                        $this->comp_active = 1;
                } else {
                        $this->comp_active = 0;
                }
        }



        /*
         * PRIVATE FUNCTIONS
         */


        function sock_to_host($host)
        {
                if(is_array($host))
                        $host = array_shift($host);

                $now = time();

                // seperate the ip from the port, index 0 = ip, index 1 = port
                $conn = explode(":", $host);
                if(count($conn) != 2)
                {
                        $this->errno = MC_ERR_HOST_FORMAT;
                        $this->errstr = "Host address was not in the format of host:port";

                        if($this->debug)
                                $this->_debug("sock_to_host(): Host address was not in the format of host:port");

                        return FALSE;
                }

                if(@($this->host_dead[$host] && $this->host_dead[$host] > $now) ||
                @($this->host_dead[$conn[0]] && $this->host_dead[$conn[0]] > $now))
                {
                        $this->errno = MC_ERR_HOST_DEAD;
                        $this->errstr = "Host $host is not available.";

                        if($this->debug)
                                $this->_debug("sock_to_host(): Host $host is not available.");

                        return FALSE;
                }

                // connect to the server, if it fails, add it to the host_dead below
                $sock = socket_create (AF_INET, SOCK_STREAM, getprotobyname("TCP"));

                // we need surpress the error message if a connection fails
                if(!@socket_connect($sock, $conn[0], $conn[1]))
                {
                        $this->host_dead[$host]=$this->host_dead[$conn[0]]=$now+60+intval(rand(0, 10));

                        $this->errno = MC_ERR_SOCKET_CONNECT;
                        $this->errstr = "Failed to connect to ".$conn[0].":".$conn[1];

                        if($this->debug)
                                $this->_debug("sock_to_host(): Failed to connect to ".$conn[0].":".$conn[1]);

                        return FALSE;
                }

                // success, add to the list of sockets
                $cache_sock[$host] = $sock;

                return $sock;
        }


        function get_sock($key)
        {
                if(!$this->active)
                {
                        $this->errno = MC_ERR_NOT_ACTIVE;
                        $this->errstr = "No active servers are available";

                        if($this->debug)
                                $this->_debug("get_sock(): There are no active servers available.");

                        return FALSE;
                }

                $hv = is_array($key) ? intval($key[0]) : $this->_hashfunc($key);

                if(!$this->buckets)
                {
                        $bu = $this->buckets = array();

                        foreach($this->servers as $v)
                        {
                                if(is_array($v))
                                {
                                        for($i = 1;  $i <= $v[1]; ++$i)
                                                $bu[] =  $v[0];
                                }
                                else
                                        $bu[] = $v;
                        }

                        $this->buckets = $bu;
                }

                $real_key = is_array($key) ? $key[1] : $key;
                $tries = 0;
                while($tries < 20)
                {
                        $host = @$this->buckets[$hv % count($this->buckets)];
                        $sock = $this->sock_to_host($host);

                        if(is_resource($sock))
                                return $sock;

                        $hv += $this->_hashfunc($tries.$real_key);
                        ++$tries;
                }

                $this->errno = MC_ERR_GET_SOCK;
                $this->errstr = "Unable to retrieve a valid socket.";

                if($this->debug)
                        $this->_debug("get_sock(): Unable to retrieve a valid socket.");

                return FALSE;
        }


        function _incrdecr($cmdname, $key, $value)
        {
                if(!$this->active)
                {
                        $this->errno = MC_ERR_NOT_ACTIVE;
                        $this->errstr = "No active servers are available";

                        if($this->debug)
                                $this->_debug("_incrdecr(): There are no active servers available.");

                        return FALSE;
                }

                $sock = $this->get_sock($key);
                if(!is_resource($sock))
                {
                        $this->errno = MC_ERR_GET_SOCK;
                        $this->errstr = "Unable to retrieve a valid socket.";

                        if($this->debug)
                                $this->_debug("_incrdecr(): Invalid socket returned by get_sock().");

                        return FALSE;
                }

                if($value == "")
                        $value = 1;

                $cmd = "$cmdname $key $value\r\n";
                $cmd_len = strlen($cmd);
                $offset = 0;

                // write the command to the server
                while($offset < $cmd_len)
                {
                        $result = socket_write($sock, substr($cmd, $offset, MC_BUFFER_SZ), MC_BUFFER_SZ);

                        if($result !== FALSE)
                                $offset += $result;
                        else if($offset < $cmd_len)
                        {
                                $this->errno = MC_ERR_SOCKET_WRITE;
                                $this->errstr = "Failed to write to socket.";

                                if($this->debug)
                                {
                                        $sockerr = socket_last_error($sock);
                                        $this->_debug("_incrdecr(): socket_write() returned FALSE. Error $errno: ".socket_strerror($sockerr));
                                }

                                return FALSE;
                        }
                }

                // now read the server's response
                if(($retval = socket_read($sock, MC_BUFFER_SZ, PHP_NORMAL_READ)) === FALSE)
                {
                        $this->errno = MC_ERR_SOCKET_READ;
                        $this->errstr = "Failed to read from socket.";

                        if($this->debug)
                        {
                                $sockerr = socket_last_error($sock);
                                $this->_debug("_incrdecr(): socket_read() returned FALSE. Socket Error $errno: ".socket_strerror($sockerr));
                        }

                        return FALSE;
                }

                // strip the /r/n from the end and return value
                return trim($retval);
        }

        function _set($cmdname, $key, $val, $exptime = 0)
        {
                if(!$this->active)
                {
                        $this->errno = MC_ERR_NOT_ACTIVE;
                        $this->errstr = "No active servers are available";

                        if($this->debug)
                                $this->_debug("_set(): No active servers are available.");

                        return FALSE;
                }

                $sock = $this->get_sock($key);
                if(!is_resource($sock))
                {
                        $this->errno = MC_ERR_GET_SOCK;
                        $this->errstr = "Unable to retrieve a valid socket.";

                        if($this->debug)
                                $this->_debug("_set(): Invalid socket returned by get_sock().");

                        return FALSE;
                }

                $flags = 0;
                $key = is_array($key) ? $key[1] : $key;

                $raw_val = $val;

                // if the value is not scalar, we need to serialize it
                if(!is_scalar($val))
                {
                        $val = serialize($val);
                        $flags |= 1;
                }

                if (($this->compress_active) && ($this->compress > 0) && (strlen($val) > $this->compress)) {
                        $this->_debug("_set(): compressing data. size in:".strlen($val));
                        $cval=gzcompress($val);
                        $this->_debug("_set(): done compressing data. size out:".strlen($cval));
                        if ((strlen($cval) < strlen($val)) && (strlen($val) - strlen($cval) > 2048)){
                                $flags |= 2;
                                $val=$cval;
                        }
                        unset($cval);
                }

                $len = strlen($val);
                if (!is_int($exptime))
                        $exptime = 0;

                // send off the request
                $cmd = "$cmdname $key $flags $exptime $len\r\n$val\r\n";
                $cmd_len = strlen($cmd);
                $offset = 0;

                // write the command to the server
                while($offset < $cmd_len)
                {
                        $result = socket_write($sock, substr($cmd, $offset, MC_BUFFER_SZ), MC_BUFFER_SZ);

                        if($result !== FALSE)
                                $offset += $result;
                        else if($offset < $cmd_len)
                        {
                                $this->errno = MC_ERR_SOCKET_WRITE;
                                $this->errstr = "Failed to write to socket.";

                                if($this->debug)
                                {
                                        $errno = socket_last_error($sock);
                                        $this->_debug("_set(): socket_write() returned FALSE. Error $errno: ".socket_strerror($errno));
                                }

                                return FALSE;
                        }
                }

                // now read the server's response
                if(($l_szResponse = socket_read($sock, 6, PHP_NORMAL_READ)) === FALSE)
                {
                        $this->errno = MC_ERR_SOCKET_READ;
                        $this->errstr = "Failed to read from socket.";

                        if($this->debug)
                        {
                                $errno = socket_last_error($sock);
                                $this->_debug("_set(): socket_read() returned FALSE. Error $errno: ".socket_strerror($errno));
                        }

                        return FALSE;
                }

                if($l_szResponse == "STORED")
                {
                        if($this->debug)
                                $this->_debug("MemCache: $cmdname $key = $raw_val");

                        return TRUE;
                }

                $this->errno = MC_ERR_SET;
                $this->errstr = "Failed to receive the STORED response from the server.";

                if($this->debug)
                        $this->_debug("_set(): Did not receive STORED as the server response! Received $l_szResponse instead.");

                return FALSE;
        }


        function _load_items($sock, &$val, $sock_keys)
        {
                $val = array();
                $cmd = "get ";

                if(!is_array($sock_keys))
                {
                        $arr[] = $sock_keys;
                        $sock_keys = $arr;
                }

                foreach($sock_keys as $sk)
                        $cmd .= $sk." ";

                $cmd .="\r\n";
                $cmd_len = strlen($cmd);
                $offset = 0;

                // write the command to the server
                while($offset < $cmd_len)
                {
                        $result = socket_write($sock, substr($cmd, $offset, MC_BUFFER_SZ), MC_BUFFER_SZ);

                        if($result !== FALSE)
                                $offset += $result;
                        else if($offset < $cmd_len)
                        {
                                $this->errno = MC_ERR_SOCKET_WRITE;
                                $this->errstr = "Failed to write to socket.";

                                if($this->debug)
                                {
                                        $errno = socket_last_error($sock);
                                        $this->_debug("_load_items(): socket_write() returned FALSE. Error $errno: ".socket_strerror($errno));
                                }

                                return FALSE;
                        }
                }

                $len = 0;
                $buf = "";
                $flags_array = array();

                // now read the response from the server
                while($line = socket_read($sock, MC_BUFFER_SZ, PHP_BINARY_READ))
                {
                        // check for a socket_read error
                        if($line === FALSE)
                        {
                                $this->errno = MC_ERR_SOCKET_READ;
                                $this->errstr = "Failed to read from socket.";

                                if($this->debug)
                                {
                                        $errno = socket_last_error($sock);
                                        $this->_debug("_load_items(): socket_read() returned FALSE. Error $errno: ".socket_strerror($errno));
                                }

                                return FALSE;
                        }

                        if($len == 0)
                        {
                                $header = substr($line, 0, strpos($line, "\r\n"));
                                $matches = explode(" ", $header);

                                if(is_string($matches[1]) && is_numeric($matches[2]) && is_numeric($matches[3]))
                                {
                                        $rk = $matches[1];
                                        $flags = $matches[2];
                                        $len = $matches[3];

                                        if($flags)
                                                $flags_array[$rk] = $flags;

                                        $len_array[$rk] = $len;
                                        $bytes_read = 0;

                                        // get the left over data after the header is read
                                        $line = substr($line, strpos($line, "\r\n")+2, strlen($line));
                                }
                                else
                                {
                                        $this->errno = MC_ERR_GET_KEY;
                                        $this->errstr = "Requested key(s) returned no values.";

                                        // something went wrong, we never recieved the header
                                        if($this->debug)
                                                $this->_debug("_load_items(): Requested key(s) returned no values.");

                                        return FALSE;
                                }
                        }

                        // skip over the extra return or newline
                        if($line == "\r" || $line == "\n")
                                continue;

                        $bytes_read += strlen($line);
                        $buf .= $line;

                        // if we're almost at the end, read the rest, so 
                        // that we don't corrupt the \r\nEND\r\n
                        if ($bytes_read >= $len && $bytes_read < ($len +7))
                        {
                                $lastbit = socket_read($sock, $len - $bytes_read + 7, PHP_BINARY_READ);
                                $line .= $lastbit;
                                $buf .= $lastbit;
                                $bytes_read += strlen($lastbit);
                        }

                        // we read the all of the data, take in account
                        // for the /r/nEND/r/n
                        if($bytes_read == ($len + 7))
                        {
                                $end = substr($buf, $len+2, 3);
                                if($end == "END")
                                {
                                        $val[$rk] = substr($buf, 0, $len);

                                        foreach($sock_keys as $sk)
                                        {
                                                if(!isset($val[$sk]))
                                                        continue;

                                                if(strlen($val[$sk]) != $len_array[$sk])
                                                        continue;
                                                if(@$flags_array[$sk] & 2)
                                                        $val[$sk] = gzuncompress($val[$sk]);

                                                if(@$flags_array[$sk] & 1)
                                                        $val[$sk] = unserialize($val[$sk]);
                                        }

                                        return TRUE;
                                }
                                else
                                {
                                        $this->errno = MC_ERR_LOADITEM_END;
                                        $this->errstr = "Failed to receive END response from server.";

                                        if($this->debug)
                                                $this->_debug("_load_items(): Failed to receive END. Received $end instead.");

                                        return FALSE;
                                }
                        }

                        // take in consideration for the "\r\nEND\r\n"
                        if($bytes_read > ($len + 7))
                        {
                                $this->errno = MC_ERR_LOADITEM_BYTES;
                                $this->errstr = "Bytes read from server greater than size of data.";

                                if($this->debug)
                                        $this->_debug("_load_items(): Bytes read is greater than requested data size.");

                                return FALSE;
                        }

                }
        }


        function _hashfunc($num)
        {
                $hash = sprintf("%u",crc32($num));

                return $hash;
        }

    function _debug($text)
    {
                print $text . "\r\n";
    }
}

?>

---