PHP Client::getConnection方法代码示例

 /**
  * Lazy connection
  *
  * Get the connection to Redis server and return it
  *
  * @throws \Predis\Connection\ConnectionException
  */
 public function getRedisClient()
 {
     if (empty($this->redisHandler)) {
         $this->redisHandler = new RedisHandler();
     }
     return $this->redisHandler->getConnection();
 }

 public function flushNamespacedKeys()
 {
     $params = $this->redis->getConnection()->getParameters();
     // redis cli connection string
     $conn = sprintf("redis-cli -h %s -p %s -n %s --raw", $params->host, $params->port, $params->database);
     // remove namespaced keys only
     $proc = new Process(sprintf("%s KEYS '*%s*' | xargs --delim='\\n' %s DEL", $conn, $this->ns, $conn));
     $proc->run();
     return $proc->getOutput();
 }

    protected function getParametersAndOptions(Client $client)
    {
        $parameters = $client->getConnection()->getParameters();
        $options = $client->getOptions();

        return array($parameters, $options);
    }

 /**
  * Scan key-value indices and return the value of all matching keys
  *
  * @param string $key
  *
  * @return string[]
  */
 public function scan($key)
 {
     $cursor = 0;
     $results = [];
     $connection = $this->client->getConnection();
     do {
         if ($connection instanceof ReplicationInterface) {
             /** @var NodeConnectionInterface[] $slaves */
             $slaves = $connection->getSlaves();
             if (count($slaves) == 1) {
                 $slave = $slaves[0];
             } elseif ($slaves) {
                 $slave = $slaves[rand(0, count($slaves) - 1)];
             } else {
                 $slave = $connection->getMaster();
             }
             $cmd = new KeyScan();
             $cmd->setArguments([$cursor, 'MATCH', $key]);
             $set = $slave->executeCommand($cmd);
         } elseif ($connection instanceof PredisCluster) {
             $iterator = $connection->getIterator();
             /** @var NodeConnectionInterface $node */
             $node = $iterator->current();
             $cmd = new KeyScan();
             $cmd->setArguments([$cursor, 'MATCH', $key]);
             $set = $node->executeCommand($cmd);
         } else {
             $set = $this->clientCmd('scan', [$cursor, ['MATCH' => $key]]);
         }
         $cursor = $set[0];
         $results = array_merge($results, $set[1]);
     } while ($cursor != 0);
     return $results;
 }

 /**
  * Checks if the passed client instance satisfies the required conditions
  * needed to initialize a Publish / Subscribe context.
  *
  * @param Client Client instance used by the context.
  */
 private function checkCapabilities(Client $client)
 {
     if (Helpers::isCluster($client->getConnection())) {
         throw new NotSupportedException('Cannot initialize a PUB/SUB context over a cluster of connections');
     }
     $commands = array('publish', 'subscribe', 'unsubscribe', 'psubscribe', 'punsubscribe');
     if ($client->getProfile()->supportsCommands($commands) === false) {
         throw new NotSupportedException('The current profile does not support PUB/SUB related commands');
     }
 }

 /**
  * Start listening to subscribed channels of the Redis PubSub mechanism.
  * Add a callback to a particular subscription channel.
  *
  * @param callable $callback
  * @return void
  */
 public function listenToPubSub(callable $callback)
 {
     while (1) {
         $command = RawCommand::create('PSUBSCRIBE', sprintf('%s-%s', $this->pubsub_channel_prefix, '*'));
         $this->client->executeCommand($command);
         if ($this->client->getConnection() instanceof MasterSlaveReplication) {
             $payload = $this->client->getConnection()->getConnection($command)->read();
         } else {
             $payload = $this->client->getConnection()->read();
         }
         $channel = ltrim($payload[2], sprintf('%s%s', $this->pubsub_channel_prefix, '-'));
         $message = base64_decode($payload[3]);
         call_user_func($callback, ['channel' => $channel, 'message' => $message]);
     }
 }

 /**
  * Returns a pipeline executor depending on the kind of the underlying
  * connection and the passed options.
  *
  * @param Client Client instance used by the context.
  * @param array Options for the context initialization.
  * @return IPipelineExecutor
  */
 protected function createExecutor(Client $client, array $options)
 {
     if (!$options) {
         return new StandardExecutor();
     }
     if (isset($options['executor'])) {
         $executor = $options['executor'];
         if (!$executor instanceof IPipelineExecutor) {
             throw new \InvalidArgumentException('The executor option accepts only instances ' . 'of Predis\\Pipeline\\IPipelineExecutor');
         }
         return $executor;
     }
     if (isset($options['safe']) && $options['safe'] == true) {
         $isCluster = Helpers::isCluster($client->getConnection());
         return $isCluster ? new SafeClusterExecutor() : new SafeExecutor();
     }
     return new StandardExecutor();
 }

 /**
  * Checks if the passed client instance satisfies the required conditions
  * needed to initialize a transaction context.
  *
  * @param Client Client instance used by the context.
  */
 private function checkCapabilities(Client $client)
 {
     if (Helpers::isCluster($client->getConnection())) {
         throw new NotSupportedException('Cannot initialize a MULTI/EXEC context over a cluster of connections');
     }
     $profile = $client->getProfile();
     if ($profile->supportsCommands(array('multi', 'exec', 'discard')) === false) {
         throw new NotSupportedException('The current profile does not support MULTI, EXEC and DISCARD');
     }
     $this->canWatch = $profile->supportsCommands(array('watch', 'unwatch'));
 }

 /**
  * @group disconnected
  */
 public function testCreateClientWithConnectionFromAggregatedConnection()
 {
     $client = new Client(array('tcp://host1?alias=node01', 'tcp://host2?alias=node02'), array('prefix' => 'pfx:'));
     $this->assertInstanceOf('Predis\\Connection\\ClusterConnectionInterface', $cluster = $client->getConnection());
     $this->assertInstanceOf('Predis\\Connection\\SingleConnectionInterface', $node01 = $client->getConnectionById('node01'));
     $this->assertInstanceOf('Predis\\Connection\\SingleConnectionInterface', $node02 = $client->getConnectionById('node02'));
     $clientNode02 = $client->getClientFor('node02');
     $this->assertInstanceOf('Predis\\Client', $clientNode02);
     $this->assertSame($node02, $clientNode02->getConnection());
     $this->assertSame($client->getOptions(), $clientNode02->getOptions());
 }

 /**
  * @group disconnected
  * @expectedException Predis\NotSupportedException
  * @expectedExceptionMessage Retrieving connections by alias is supported only with aggregated connections
  */
 public function testGetConnectionWithAliasWorksOnlyWithCluster()
 {
     $client = new Client();
     $client->getConnection('node01');
 }

 /**
  * Checks if the passed client instance satisfies the required conditions
  * needed to initialize a monitor context.
  *
  * @param Client Client instance used by the context.
  */
 private function checkCapabilities(Client $client)
 {
     if (Helpers::isCluster($client->getConnection())) {
         throw new ClientException('Cannot initialize a monitor context over a cluster of connections');
     }
     if ($client->getProfile()->supportsCommand('monitor') === false) {
         throw new ClientException('The current profile does not support the MONITOR command');
     }
 }