Client.php 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397
  1. <?php
  2. /*
  3. * This file is part of the Predis package.
  4. *
  5. * (c) Daniele Alessandri <suppakilla@gmail.com>
  6. *
  7. * For the full copyright and license information, please view the LICENSE
  8. * file that was distributed with this source code.
  9. */
  10. namespace Predis;
  11. use Predis\Command\CommandInterface;
  12. use Predis\Option\ClientOptionsInterface;
  13. use Predis\Connection\ConnectionInterface;
  14. use Predis\Profile\ServerProfileInterface;
  15. use Predis\Option\ClientOptions;
  16. use Predis\Profile\ServerProfile;
  17. use Predis\PubSub\PubSubContext;
  18. use Predis\Monitor\MonitorContext;
  19. use Predis\Pipeline\PipelineContext;
  20. use Predis\Transaction\MultiExecContext;
  21. /**
  22. * Main class that exposes the most high-level interface to interact with Redis.
  23. *
  24. * @author Daniele Alessandri <suppakilla@gmail.com>
  25. */
  26. class Client
  27. {
  28. const VERSION = '0.8.0-dev';
  29. private $options;
  30. private $profile;
  31. private $connection;
  32. private $connections;
  33. /**
  34. * Initializes a new client with optional connection parameters and client options.
  35. *
  36. * @param mixed $parameters Connection parameters for one or multiple servers.
  37. * @param mixed $options Options that specify certain behaviours for the client.
  38. */
  39. public function __construct($parameters = null, $options = null)
  40. {
  41. $options = $this->filterOptions($options);
  42. $this->options = $options;
  43. $this->profile = $options->profile;
  44. $this->connections = $options->connections;
  45. $this->connection = $this->initializeConnection($parameters);
  46. }
  47. /**
  48. * Creates an instance of Predis\Option\ClientOptions from various types of
  49. * arguments (string, array, Predis\Profile\ServerProfile) or returns the
  50. * passed object if it is an instance of Predis\Option\ClientOptions.
  51. *
  52. * @param mixed $options Client options.
  53. * @return ClientOptions
  54. */
  55. protected function filterOptions($options)
  56. {
  57. if ($options === null) {
  58. return new ClientOptions();
  59. }
  60. if (is_array($options)) {
  61. return new ClientOptions($options);
  62. }
  63. if ($options instanceof ClientOptionsInterface) {
  64. return $options;
  65. }
  66. if ($options instanceof ServerProfileInterface || is_string($options)) {
  67. return new ClientOptions(array('profile' => $options));
  68. }
  69. throw new \InvalidArgumentException("Invalid type for client options");
  70. }
  71. /**
  72. * Initializes one or multiple connection (cluster) objects from various
  73. * types of arguments (string, array) or returns the passed object if it
  74. * implements Predis\Connection\ConnectionInterface.
  75. *
  76. * @param mixed $parameters Connection parameters or instance.
  77. * @return ConnectionInterface
  78. */
  79. protected function initializeConnection($parameters)
  80. {
  81. if ($parameters instanceof ConnectionInterface) {
  82. return $parameters;
  83. }
  84. if (is_array($parameters) && isset($parameters[0])) {
  85. $replication = isset($this->options->replication) && $this->options->replication;
  86. $connection = $this->options->{$replication ? 'replication' : 'cluster'};
  87. return $this->connections->createAggregated($connection, $parameters, $this->profile);
  88. }
  89. return $this->connections->create($parameters, $this->profile);
  90. }
  91. /**
  92. * Returns the server profile used by the client.
  93. *
  94. * @return ServerProfileInterface
  95. */
  96. public function getProfile()
  97. {
  98. return $this->profile;
  99. }
  100. /**
  101. * Returns the client options specified upon initialization.
  102. *
  103. * @return ClientOptions
  104. */
  105. public function getOptions()
  106. {
  107. return $this->options;
  108. }
  109. /**
  110. * Returns the connection factory object used by the client.
  111. *
  112. * @return ConnectionFactoryInterface
  113. */
  114. public function getConnectionFactory()
  115. {
  116. return $this->connections;
  117. }
  118. /**
  119. * Returns a new instance of a client for the specified connection when the
  120. * client is connected to a cluster. The new instance will use the same
  121. * options of the original client.
  122. *
  123. * @return Client
  124. */
  125. public function getClientFor($connectionAlias)
  126. {
  127. if (($connection = $this->getConnection($connectionAlias)) === null) {
  128. throw new \InvalidArgumentException("Invalid connection alias: '$connectionAlias'");
  129. }
  130. return new Client($connection, $this->options);
  131. }
  132. /**
  133. * Opens the connection to the server.
  134. */
  135. public function connect()
  136. {
  137. $this->connection->connect();
  138. }
  139. /**
  140. * Disconnects from the server.
  141. */
  142. public function disconnect()
  143. {
  144. $this->connection->disconnect();
  145. }
  146. /**
  147. * Disconnects from the server.
  148. *
  149. * This method is an alias of disconnect().
  150. */
  151. public function quit()
  152. {
  153. $this->disconnect();
  154. }
  155. /**
  156. * Checks if the underlying connection is connected to Redis.
  157. *
  158. * @return Boolean True means that the connection is open.
  159. * False means that the connection is closed.
  160. */
  161. public function isConnected()
  162. {
  163. return $this->connection->isConnected();
  164. }
  165. /**
  166. * Returns the underlying connection instance or, when connected to a cluster,
  167. * one of the connection instances identified by its alias.
  168. *
  169. * @param string $id The alias of a connection when connected to a cluster.
  170. * @return ConnectionInterface
  171. */
  172. public function getConnection($id = null)
  173. {
  174. if (isset($id)) {
  175. if (!Helpers::isAggregated($this->connection)) {
  176. $message = 'Retrieving connections by alias is supported only with aggregated connections (cluster or replication)';
  177. throw new NotSupportedException($message);
  178. }
  179. return $this->connection->getConnectionById($id);
  180. }
  181. return $this->connection;
  182. }
  183. /**
  184. * Dinamically invokes a Redis command with the specified arguments.
  185. *
  186. * @param string $method The name of a Redis command.
  187. * @param array $arguments The arguments for the command.
  188. * @return mixed
  189. */
  190. public function __call($method, $arguments)
  191. {
  192. $command = $this->profile->createCommand($method, $arguments);
  193. return $this->connection->executeCommand($command);
  194. }
  195. /**
  196. * Creates a new instance of the specified Redis command.
  197. *
  198. * @param string $method The name of a Redis command.
  199. * @param array $arguments The arguments for the command.
  200. * @return CommandInterface
  201. */
  202. public function createCommand($method, $arguments = array())
  203. {
  204. return $this->profile->createCommand($method, $arguments);
  205. }
  206. /**
  207. * Executes the specified Redis command.
  208. *
  209. * @param CommandInterface $command A Redis command.
  210. * @return mixed
  211. */
  212. public function executeCommand(CommandInterface $command)
  213. {
  214. return $this->connection->executeCommand($command);
  215. }
  216. /**
  217. * Executes the specified Redis command on all the nodes of a cluster.
  218. *
  219. * @param CommandInterface $command A Redis command.
  220. * @return array
  221. */
  222. public function executeCommandOnShards(CommandInterface $command)
  223. {
  224. if (Helpers::isCluster($this->connection)) {
  225. $replies = array();
  226. foreach ($this->connection as $connection) {
  227. $replies[] = $connection->executeCommand($command);
  228. }
  229. return $replies;
  230. }
  231. return array($this->connection->executeCommand($command));
  232. }
  233. /**
  234. * Calls the specified initializer method on $this with 0, 1 or 2 arguments.
  235. *
  236. * TODO: Invert $argv and $initializer.
  237. *
  238. * @param array $argv Arguments for the initializer.
  239. * @param string $initializer The initializer method.
  240. * @return mixed
  241. */
  242. private function sharedInitializer($argv, $initializer)
  243. {
  244. switch (count($argv)) {
  245. case 0:
  246. return $this->$initializer();
  247. case 1:
  248. list($arg0) = $argv;
  249. return is_array($arg0) ? $this->$initializer($arg0) : $this->$initializer(null, $arg0);
  250. case 2:
  251. list($arg0, $arg1) = $argv;
  252. return $this->$initializer($arg0, $arg1);
  253. default:
  254. return $this->$initializer($this, $argv);
  255. }
  256. }
  257. /**
  258. * Creates a new pipeline context and returns it, or returns the results of
  259. * a pipeline executed inside the optionally provided callable object.
  260. *
  261. * @param mixed $arg,... Options for the context, a callable object, or both.
  262. * @return PipelineContext|array
  263. */
  264. public function pipeline(/* arguments */)
  265. {
  266. return $this->sharedInitializer(func_get_args(), 'initPipeline');
  267. }
  268. /**
  269. * Pipeline context initializer.
  270. *
  271. * @param array $options Options for the context.
  272. * @param mixed $callable Optional callable object used to execute the context.
  273. * @return PipelineContext|array
  274. */
  275. protected function initPipeline(Array $options = null, $callable = null)
  276. {
  277. $pipeline = new PipelineContext($this, $options);
  278. return $this->pipelineExecute($pipeline, $callable);
  279. }
  280. /**
  281. * Executes a pipeline context when a callable object is passed.
  282. *
  283. * @param array $options Options of the context initialization.
  284. * @param mixed $callable Optional callable object used to execute the context.
  285. * @return PipelineContext|array
  286. */
  287. private function pipelineExecute(PipelineContext $pipeline, $callable)
  288. {
  289. return isset($callable) ? $pipeline->execute($callable) : $pipeline;
  290. }
  291. /**
  292. * Creates a new transaction context and returns it, or returns the results of
  293. * a transaction executed inside the optionally provided callable object.
  294. *
  295. * @param mixed $arg,... Options for the context, a callable object, or both.
  296. * @return MultiExecContext|array
  297. */
  298. public function multiExec(/* arguments */)
  299. {
  300. return $this->sharedInitializer(func_get_args(), 'initMultiExec');
  301. }
  302. /**
  303. * Transaction context initializer.
  304. *
  305. * @param array $options Options for the context.
  306. * @param mixed $callable Optional callable object used to execute the context.
  307. * @return MultiExecContext|array
  308. */
  309. protected function initMultiExec(Array $options = null, $callable = null)
  310. {
  311. $transaction = new MultiExecContext($this, $options ?: array());
  312. return isset($callable) ? $transaction->execute($callable) : $transaction;
  313. }
  314. /**
  315. * Creates a new Publish / Subscribe context and returns it, or executes it
  316. * inside the optionally provided callable object.
  317. *
  318. * @param mixed $arg,... Options for the context, a callable object, or both.
  319. * @return MultiExecContext|array
  320. */
  321. public function pubSub(/* arguments */)
  322. {
  323. return $this->sharedInitializer(func_get_args(), 'initPubSub');
  324. }
  325. /**
  326. * Publish / Subscribe context initializer.
  327. *
  328. * @param array $options Options for the context.
  329. * @param mixed $callable Optional callable object used to execute the context.
  330. * @return PubSubContext
  331. */
  332. protected function initPubSub(Array $options = null, $callable = null)
  333. {
  334. $pubsub = new PubSubContext($this, $options);
  335. if (!isset($callable)) {
  336. return $pubsub;
  337. }
  338. foreach ($pubsub as $message) {
  339. if (call_user_func($callable, $pubsub, $message) === false) {
  340. $pubsub->closeContext();
  341. }
  342. }
  343. }
  344. /**
  345. * Returns a new monitor context.
  346. *
  347. * @return MonitorContext
  348. */
  349. public function monitor()
  350. {
  351. return new MonitorContext($this);
  352. }
  353. }