PHP Client::ping方法代碼示例

 public function setUp()
 {
     $this->client = new Client();
     try {
         $this->client->ping();
     } catch (ConnectionException $e) {
         $this->markTestSkipped('cannot redis connection!');
     }
     $this->adapter = new RedisHandler($this->client);
 }

 protected function setUp()
 {
     $this->predis = new Client();
     if (true !== $this->predis->ping()) {
         unset($this->predis);
         $this->markTestSkipped('Could not ping Redis instance');
     }
     $this->predis->flushAll();
     parent::setUp();
 }

 /**
  * @group connected
  */
 public function testDispatcherLoopAgainstRedisServer()
 {
     $parameters = array('host' => REDIS_SERVER_HOST, 'port' => REDIS_SERVER_PORT, 'database' => REDIS_SERVER_DBNUM, 'read_write_timeout' => 2);
     $producer = new Client($parameters, REDIS_SERVER_VERSION);
     $producer->connect();
     $consumer = new Client($parameters, REDIS_SERVER_VERSION);
     $consumer->connect();
     $dispatcher = new DispatcherLoop($consumer);
     $function01 = $this->getMock('stdClass', array('__invoke'));
     $function01->expects($this->exactly(2))->method('__invoke')->with($this->logicalOr($this->equalTo('01:argument'), $this->equalTo('01:quit')))->will($this->returnCallback(function ($arg) use($dispatcher) {
         if ($arg === '01:quit') {
             $dispatcher->stop();
         }
     }));
     $function02 = $this->getMock('stdClass', array('__invoke'));
     $function02->expects($this->once())->method('__invoke')->with('02:argument');
     $function03 = $this->getMock('stdClass', array('__invoke'));
     $function03->expects($this->never())->method('__invoke');
     $dispatcher->attachCallback('function:01', $function01);
     $dispatcher->attachCallback('function:02', $function02);
     $dispatcher->attachCallback('function:03', $function03);
     $producer->publish('function:01', '01:argument');
     $producer->publish('function:02', '02:argument');
     $producer->publish('function:01', '01:quit');
     $dispatcher->run();
     $this->assertTrue($consumer->ping());
 }

 /**
  * Perform the check
  *
  * @see \ZendDiagnostics\Check\CheckInterface::check()
  * @return Failure|Success
  */
 public function check()
 {
     if (!class_exists('Predis\\Client')) {
         return new Failure('Predis is not installed');
     }
     $client = new Client(array('host' => $this->host, 'port' => $this->port));
     $client->ping();
     return new Success();
 }

 /**
  * @param MessageQueuePHP\Config\ConfigInterface $config
  */
 public function __construct(ConfigInterface $config)
 {
     #extract $host, $port, $key, $channel and $path
     extract($this->prepareConfig($config->getConfig()));
     $redisClient = new RedisClient(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
     try {
         $redisClient->ping();
         $handler = new RedisHandler($redisClient, $key);
     } catch (Exception $e) {
         $handler = new StreamHandler($path);
     }
     $formatter = new LogstashFormatter($channel);
     $handler->setFormatter($formatter);
     $this->logger = new Logger($channel, array($handler));
 }

 /**
  * @group connected
  */
 public function testDispatcherLoopAgainstRedisServerWithPrefix()
 {
     $parameters = array('host' => REDIS_SERVER_HOST, 'port' => REDIS_SERVER_PORT, 'database' => REDIS_SERVER_DBNUM, 'read_write_timeout' => 2);
     $options = array('profile' => REDIS_SERVER_VERSION);
     $producerNonPfx = new Client($parameters, $options);
     $producerNonPfx->connect();
     $producerPfx = new Client($parameters, $options + array('prefix' => 'foobar'));
     $producerPfx->connect();
     $consumer = new Client($parameters, $options + array('prefix' => 'foobar'));
     $dispatcher = new DispatcherLoop($consumer);
     $callback = $this->getMock('stdClass', array('__invoke'));
     $callback->expects($this->exactly(1))->method('__invoke')->with($this->equalTo('arg:prefixed'))->will($this->returnCallback(function ($arg) use($dispatcher) {
         $dispatcher->stop();
     }));
     $dispatcher->attachCallback('callback', $callback);
     $producerNonPfx->publish('callback', 'arg:non-prefixed');
     $producerPfx->publish('callback', 'arg:prefixed');
     $dispatcher->run();
     $this->assertTrue($consumer->ping());
 }

 /**
  * @group connected
  */
 public function testMonitorAgainstRedisServer()
 {
     $parameters = array('host' => REDIS_SERVER_HOST, 'port' => REDIS_SERVER_PORT, 'database' => REDIS_SERVER_DBNUM, 'read_write_timeout' => 2);
     $options = array('profile' => REDIS_SERVER_VERSION);
     $echoed = array();
     $producer = new Client($parameters, $options);
     $producer->connect();
     $consumer = new Client($parameters, $options);
     $consumer->connect();
     $monitor = new MonitorContext($consumer);
     $producer->echo('message1');
     $producer->echo('message2');
     $producer->echo('QUIT');
     foreach ($monitor as $message) {
         if ($message->command == 'ECHO') {
             $echoed[] = $arguments = trim($message->arguments, '"');
             if ($arguments == 'QUIT') {
                 $monitor->closeContext();
             }
         }
     }
     $this->assertSame(array('message1', 'message2', 'QUIT'), $echoed);
     $this->assertFalse($monitor->valid());
     $this->assertTrue($consumer->ping());
 }

 /**
  * @group disconnected
  */
 public function testCallingRedisCommandReturnsErrorResponseOnRedisError()
 {
     $expectedResponse = new ResponseError('ERR Operation against a key holding the wrong kind of value');
     $connection = $this->getMock('Predis\\Connection\\ConnectionInterface');
     $connection->expects($this->once())->method('executeCommand')->with($this->isInstanceOf('Predis\\Command\\ConnectionPing'))->will($this->returnValue($expectedResponse));
     $client = new Client($connection, array('exceptions' => false));
     $response = $client->ping();
     $this->assertSame($response, $expectedResponse);
 }

 /**
  * @group connected
  */
 public function testPubSubAgainstRedisServer()
 {
     $parameters = array('host' => REDIS_SERVER_HOST, 'port' => REDIS_SERVER_PORT, 'database' => REDIS_SERVER_DBNUM, 'read_write_timeout' => 2);
     $options = array('profile' => REDIS_SERVER_VERSION);
     $messages = array();
     $producer = new Client($parameters, $options);
     $producer->connect();
     $consumer = new Client($parameters, $options);
     $consumer->connect();
     $pubsub = new PubSubContext($consumer);
     $pubsub->subscribe('channel:foo');
     $producer->publish('channel:foo', 'message1');
     $producer->publish('channel:foo', 'message2');
     $producer->publish('channel:foo', 'QUIT');
     foreach ($pubsub as $message) {
         if ($message->kind !== 'message') {
             continue;
         }
         $messages[] = $payload = $message->payload;
         if ($payload === 'QUIT') {
             $pubsub->closeContext();
         }
     }
     $this->assertSame(array('message1', 'message2', 'QUIT'), $messages);
     $this->assertFalse($pubsub->valid());
     $this->assertTrue($consumer->ping());
 }