Someone

<?php
require_once('settings/Config.class.php');
require_once('lib/RedisClient.class.php');
require_once('lib/Pool/ConnectionHandler.class.php');
require_once('lib/Monitoring/PinbaClient.class.php');

class RedisMapper {
  private $pool = array();

  private static $globalRedis = null;
  private static $instance = null;

  public static function getRedis($node_id) {
    return self::$instance->_getRedis($node_id);
  }
  
  public function _getRedis($node_id) {
    if(!array_key_exists($node_id, $this->pool)) {
      Daemon::log('Unknown node: '.$node_id);
      Daemon::log(Debug::Dump(array_keys($this->pool)));
      Daemon::log(Debug::backtrace());
      return false;
    }

    $obj = null;
    $timer = PinbaClient::createCmdExecTimer('RedisPoolSearch')->start();
    $s = sizeof($this->pool[$node_id]);
    $l = $s - 1;
    $acq_r = null;
    for($i = 0; $i < $s; ++$i) {
      if($this->pool[$node_id][$i]->acquire()) {
        $obj = $this->pool[$node_id][$i];
        break;
      }

      if($i == $l) {
        $i = 0;
        usleep(100); // FIXME: we need in this usleep call?
      }
    }
    $timer->stop();
    
    $obj->ping();
    return $obj;
  }

  private static function connect(array $conf) {
    $redis = null;
    if(array_key_exists('socket', $conf)) {
      $redis = new RedisClient(null, null, $conf['socket'], $conf['db']);
    }
    else {
      $redis = new RedisClient($conf['host'], $conf['port'], null, $conf['db']);
    }
    $redis->connect();
    return $redis;
  }

  public static function getPersistent($node_id) {
    if(!array_key_exists($node_id, Config::getRedisNodes())) {
      Daemon::log('Unknown node: '.$node_id);
      Daemon::log(Debug::Dump(array_keys(self::$pool)));
      Daemon::log(Debug::backtrace());
      return false;
    }

    return self::connect(Config::getRedisNodeParams($node_id));
  }

  public static function init() {
    self::$instance = new RedisMapper();
    self::$instance->_init();
  }

  public function __construct() {
  }

  public function _init() {
    $nodes = array_keys(Config::getRedisNodes());
    $params = array();
    foreach($nodes as $id) {
      $this->pool[$id] = array();
      $params = Config::getRedisNodeParams($id);
      for($i = 0; $i < $params['max_connections']; ++$i) {
        $this->pool[$id][] = ConnectionHandler::getCHandler(self::connect($params), ConnectionHandler::REDIS_LOCK_PREFIX);
      }
    }
  }

  public static function tearDown() {
    self::$instance->_tearDown();
    self::$instance = null;
  }

  public function _tearDown() {
    $keys = array_keys($this->pool);
    for($i = 0, $s = sizeof($this->pool); $i < $s; ++$i) {
      for($j = 0, $l = sizeof($this->pool[$keys[$i]]); $j < $l; ++$j) {
        if($this->pool[$keys[$i]][$j] instanceof ConnectionHandler) {
          $this->pool[$keys[$i]][$j]->tearDown();
          $this->pool[$keys[$i]][$j] = null;
        }
      }
    }

    $this->pool = null;
  }
}