Subversion Repositories SmartDukaan

<?php defined('BASEPATH') OR exit('No direct script access allowed');
/**
 * CodeIgniter Redis
 *
 * A CodeIgniter library to interact with Redis
 *
 * @package          CodeIgniter
 * @category            Libraries
 * @author              Jo‘l Cox
 * @version                     v0.4
 * @link                        https://github.com/joelcox/codeigniter-redis
 * @link                        http://joelcox.nl
 * @license         http://www.opensource.org/licenses/mit-license.html
 */
class CI_Redis {
 
        /**
         * CI
         *
         * CodeIgniter instance
         * @var         object
         */
        private $_ci;
 
        /**
         * Connection
         *
         * Socket handle to the Redis server
         * @var         handle
         */
        private $_connection;
 
        /**
         * Debug
         *
         * Whether we're in debug mode
         * @var         bool
         */
        public $debug = FALSE;
 
        /**
         * CRLF
         *
         * User to delimiter arguments in the Redis unified request protocol
         * @var         string
         */
        const CRLF = "\r\n";
 
        /**
         * Constructor
         */
        public function __construct($params = array())
        {
 
                log_message('debug', 'Redis Class Initialized');
 
                $this->_ci = get_instance();
                $this->_ci->load->config('redis');
 
                // Check for the different styles of configs
                if (isset($params['connection_group']))
                {
                        // Specific connection group
                        $config = $this->_ci->config->item('redis_' . $params['connection_group']);
                }
                elseif (is_array($this->_ci->config->item('redis_default')))
                {
                        // Default connection group
                        $config = $this->_ci->config->item('redis_default');
                }
                else
                {
                        // Original config style
                        $config = array(
                                'host' => $this->_ci->config->item('redis_host'),
                                'port' => $this->_ci->config->item('redis_port'),
                                'password' => $this->_ci->config->item('redis_password'),
                        );
                }
 
                // Connect to Redis
                $this->_connection = @fsockopen($config['host'], $config['port'], $errno, $errstr, 3);
 
                // Display an error message if connection failed
                if ( ! $this->_connection)
                {
                        show_error('Could not connect to Redis at ' . $config['host'] . ':' . $config['port']);
                }
 
                // Authenticate when needed
                $this->_auth($config['password']);
 
        }
 
        /**
         * Call
         *
         * Catches all undefined methods
         * @param       string  method that was called
         * @param       mixed   arguments that were passed
         * @return      mixed
         */
        public function __call($method, $arguments)
        {
                $request = $this->_encode_request($method, $arguments);
                return $this->_write_request($request);
        }
 
        /**
         * Command
         *
         * Generic command function, just like redis-cli
         * @param       string  full command as a string
         * @return      mixed
         */
        public function command($string)
        {
                $slices = explode(' ', $string);
                $request = $this->_encode_request($slices[0], array_slice($slices, 1));
 
                return $this->_write_request($request);
        }
 
        /**
         * Auth
         *
         * Runs the AUTH command when password is set
         * @param       string  password for the Redis server
         * @return      void
         */
        private function _auth($password = NULL)
        {
 
                // Authenticate when password is set
                if ( ! empty($password))
                {
 
                        // See if we authenticated successfully
                        if ($this->command('AUTH ' . $password) !== 'OK')
                        {
                                show_error('Could not connect to Redis, invalid password');
                        }
 
                }
 
        }
 
        /**
         * Write request
         *
         * Write the formatted request to the socket
         * @param       string  request to be written
         * @return      mixed
         */
        private function _write_request($request)
        {
 
                if ($this->debug === TRUE)
                {
                        log_message('debug', 'Redis unified request: ' . $request);
                }
 
                fwrite($this->_connection, $request);
                return $this->_read_request();
 
        }
 
        /**
         * Read request
         *
         * Route each response to the appropriate interpreter
         * @return      mixed
         */
        private function _read_request()
        {
 
                $type = fgetc($this->_connection);
 
                if ($this->debug === TRUE)
                {
                        log_message('debug', 'Redis response type: ' . $type);
                }
 
                switch ($type)
                {
                        case '+':
                                return $this->_single_line_reply();
                                break;
                        case '-':
                                return $this->_error_reply();
                                break;
                        case ':':
                                return $this->_integer_reply();
                                break;
                        case '$':
                                return $this->_bulk_reply();
                                break;
                        case '*':
                                return $this->_multi_bulk_reply();
                                break;
                        default:
                                return FALSE;
                }
 
        }
 
        /**
         * Single line reply
         *
         * Reads the reply before the EOF
         * @return      mixed
         */
        private function _single_line_reply()
        {
                $value = trim(fgets($this->_connection));
                return $value;
        }
 
        /**
         * Error reply
         *
         * Write error to log and return false
         * @return      bool
         */
        private function _error_reply()
        {
                // Extract the error message
                $error = substr(fgets($this->_connection), 4);
                log_message('error', 'Redis server returned an error: ' . $error);
 
                return FALSE;
        }
 
        /**
         * Integer reply
         *
         * Returns an integer reply
         * @return      int
         */
        private function _integer_reply()
        {
                return (int) fgets($this->_connection);
        }
 
        /**
         * Bulk reply
         *
         * Reads to amount of bits to be read and returns value within
         * the pointer and the ending delimiter
         * @return      string
         */
        private function _bulk_reply()
        {
                // Get the amount of bits to be read
                $value_length = (int) fgets($this->_connection);
 
                if ($value_length <= 0) return NULL;
 
                $read = 0;
                $response = '';
 
                // handle if reply data more than 8192 bytes.
                while ($read < $value_length)
                {
                  $remaining = $value_length - $read;
 
                  $block = $remaining < 8192 ? $remaining : 8192;
 
                  $response .= rtrim(fread($this->_connection, $block));
 
                  $read += $block;
                }
 
                // Make sure to remove the new line and carriage from the socket buffer
                fgets($this->_connection);
                return isset($response) ? $response : FALSE;
        }
 
        /**
         * Multi bulk reply
         *
         * Reads n bulk replies and return them as an array
         * @return      array
         */
        private function _multi_bulk_reply()
        {
                // Get the amount of values in the response
                $total_values = (int) fgets($this->_connection);
 
                // Loop all values and add them to the response array
                for ($i = 0; $i < $total_values; $i++)
                {
                        // Remove the new line and carriage return before reading
                        // another bulk reply
                        fgets($this->_connection, 2);
                        $response[] = $this->_bulk_reply();
                }
 
                return isset($response) ? $response : FALSE;
        }
 
        /**
         * Encode request
         *
         * Encode plain-text request to Redis protocol format
         * @link        http://redis.io/topics/protocol
         * @param       string  request in plain-text
         * @param   string  additional data (string or array, depending on the request)
         * @return      string  encoded according to Redis protocol
         */
        private function _encode_request($method, $arguments = array())
        {
                $argument_count = $this->_count_arguments($arguments);
 
                // Set the argument count and prepend the method
                $request = '*' . $argument_count . self::CRLF;
                $request .= '$' . strlen($method) . self::CRLF . $method . self::CRLF;
 
                if ($argument_count === 1) return $request;
 
                // Append all the arguments in the request string
                foreach ($arguments as $argument)
                {
 
                        if (is_array($argument))
                        {
                                $is_associative_array = self::is_associative_array($argument);
 
                                foreach ($argument as $key => $value)
                                {
                                        // Prepend the key if we're dealing with a hash
                                        if ($is_associative_array)
                                        {
                                                $request .= '$' . strlen($key) . self::CRLF . $key . self::CRLF;
                                        }
 
                                        $request .= '$' . strlen($value) . self::CRLF . $value . self::CRLF;
                                }
                        }
                        else
                        {
                                $request .= '$' . strlen($argument) . self::CRLF . $argument . self::CRLF;
                        }
 
                }
 
                return $request;
        }
 
        /**
         * Count arguments
         *
         * Count the amount of arguments we need to pass to Redis while taking
         * into consideration lists, hashes and strings
         */
        private function _count_arguments($arguments)
        {
                $argument_count = 1;
 
                // Count how many arguments we need to push over the wire
                foreach ($arguments as $argument)
                {
 
                        // We're dealing with 2n arguments if we're consider the
                        // keys as arguments too.
                        if (is_array($argument) AND self::is_associative_array($argument))
                        {
                                $argument_count += (count($argument) * 2);
                        }
                        elseif (is_array($argument))
                        {
                                $argument_count += count($argument);
                        }
                        else
                        {
                                $argument_count++;
                        }
 
                }
 
                return $argument_count;
 
        }
 
        /**
         * Info
         *
         * Overrides the default Redis response, so we can return a nice array
         * of the server info instead of a nasty string.
         * @return      array
         */
        public function info()
        {
                $response = $this->command('INFO');
                $data = array();
                $lines = explode(self::CRLF, $response);
 
                // Extract the key and value
                foreach ($lines as $line)
                {
                        $parts = explode(':', $line);
                        if (isset($parts[1])) $data[$parts[0]] = $parts[1];
                }
 
                return $data;
        }
 
        /**
         * Debug
         *
         * Set debug mode
         * @param       bool    set the debug mode on or off
         * @return      void
         */
        public function debug($bool)
        {
                $this->debug = (bool) $bool;
        }
 
        /**
         * Destructor
         *
         * Kill the connection
         * @return      void
         */
        function __destruct()
        {
          if($this->_connection)
          {
                  fclose($this->_connection);
                }
        }
 
        /**
         * Is associative array
         *
         * Checkes whether the array has only intergers as key, starting at
         * index 0, untill the array length - 1.
         * @param       array   the array to be checked
         * @return      bool
         */
        public static function is_associative_array($array)
        {
                $keys = array_keys($array);
 
                if (min($keys) === 0 AND max($keys) === count($array) - 1) return FALSE;
                return TRUE;
        }
 
}