| public executeCommand ( Predis\Command\CommandInterface $command ) | ||
| $command | Predis\Command\CommandInterface | |
/**
* * Add a value to the cache under a unique key
*
* @param string $key
* @param mixed $value
* @param int $ttl
*/
public function set($key, $value, $ttl = null)
{
$this->client->set($key, $value);
if ($ttl) {
$cmd = $this->client->createCommand('EXPIRE');
$cmd->setArguments(array($key, $ttl));
$this->client->executeCommand($cmd);
}
}
/**
* {@inheritdoc}
*/
public function set($key, $value, $ttl = null)
{
$this->predis->set($key, $this->pack($value));
if (!$ttl) {
$ttl = $this->ttl;
}
$cmd = $this->predis->createCommand('EXPIRE');
$cmd->setArguments([$key, $ttl]);
$this->predis->executeCommand($cmd);
}
/**
* @param string $cmd The command
* @param Counter|string $counter The counter
* @param int $value The value
*
* @return Counter
*/
protected function doIncrement($cmd, $counter, $value)
{
$counter = $this->transformCounter($counter);
$cmd = $this->client->createCommand($cmd, array($counter->getName(), $value));
$value = (int) $this->client->executeCommand($cmd);
return new Counter($counter->getName(), $value);
}
/**
* @param string[] $tags
* @return string[] Ids
*/
public function getIdsByAnyTags(array $tags)
{
$command = $this->redis->createCommand('sunion', $this->getIdsForTagKeys($tags));
$response = $this->redis->executeCommand($command);
if ($response instanceof ResponseErrorInterface) {
return null;
}
return $response;
}
/**
* Execute commands
*
* @param string $command
* @param array $parameters
*
* @return mixed
*/
public function execute($command, $parameters = array())
{
try {
$cmdSet = $this->client->createCommand($command, $parameters);
return $this->client->executeCommand($cmdSet);
} catch (\Exception $e) {
$this->exception = $e;
return false;
}
}
/**
* 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]);
}
}
/**
* @group disconnected
*/
public function testClientResendScriptedCommandUsingEvalOnNoScriptErrors()
{
$command = $this->getMockForAbstractClass('Predis\\Command\\ScriptedCommand', array(), '', true, true, true, array('parseResponse'));
$command->expects($this->once())->method('getScript')->will($this->returnValue('return redis.call(\'exists\', KEYS[1])'));
$command->expects($this->once())->method('parseResponse')->with('OK')->will($this->returnValue(true));
$connection = $this->getMock('Predis\\Connection\\SingleConnectionInterface');
$connection->expects($this->at(0))->method('executeCommand')->with($command)->will($this->returnValue(new ResponseError('NOSCRIPT')));
$connection->expects($this->at(1))->method('executeCommand')->with($this->isInstanceOf('Predis\\Command\\ServerEval'))->will($this->returnValue('OK'));
$client = new Client($connection);
$this->assertTrue($client->executeCommand($command));
}
/**
* clear all redis cache.
*/
public function clear()
{
$this->redis->executeCommand($this->redis->createCommand('FLUSHALL'));
}
/**
* @group disconnected
*/
public function testExecuteCommand()
{
$ping = ServerProfile::getDefault()->createCommand('ping', array());
$connection = $this->getMock('Predis\\Network\\IConnection');
$connection->expects($this->once())->method('executeCommand')->with($ping)->will($this->returnValue(true));
$client = new Client($connection);
$this->assertTrue($client->executeCommand($ping));
}
/**
* Execute a Predis command
*
* @param string $name
* @param array $arguments
* @return mixed
*/
protected function executeCommand($name, array $arguments)
{
$command = $this->client->createCommand($name, $arguments);
return $this->client->executeCommand($command);
}