Predis.php 102 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998
  1. <?php
  2. namespace Predis;
  3. class PredisException extends \Exception { }
  4. class ClientException extends PredisException { } // Client-side errors
  5. class AbortedMultiExec extends PredisException { } // Aborted multi/exec
  6. class ServerException extends PredisException { // Server-side errors
  7. public function toResponseError() {
  8. return new ResponseError($this->getMessage());
  9. }
  10. }
  11. class CommunicationException extends PredisException { // Communication errors
  12. private $_connection;
  13. public function __construct(Connection $connection, $message = null, $code = null) {
  14. $this->_connection = $connection;
  15. parent::__construct($message, $code);
  16. }
  17. public function getConnection() { return $this->_connection; }
  18. public function shouldResetConnection() { return true; }
  19. }
  20. class MalformedServerResponse extends CommunicationException { } // Unexpected responses
  21. /* ------------------------------------------------------------------------- */
  22. class Client {
  23. private $_options, $_connection, $_serverProfile, $_responseReader;
  24. public function __construct($parameters = null, $clientOptions = null) {
  25. $this->setupClient($clientOptions ?: new ClientOptions());
  26. $this->setupConnection($parameters);
  27. }
  28. public static function create(/* arguments */) {
  29. $argv = func_get_args();
  30. $argc = func_num_args();
  31. $options = null;
  32. $lastArg = $argv[$argc-1];
  33. if ($argc > 0 && !is_string($lastArg) && ($lastArg instanceof ClientOptions ||
  34. is_subclass_of($lastArg, '\Predis\RedisServerProfile'))) {
  35. $options = array_pop($argv);
  36. $argc--;
  37. }
  38. if ($argc === 0) {
  39. throw new ClientException('Missing connection parameters');
  40. }
  41. return new Client($argc === 1 ? $argv[0] : $argv, $options);
  42. }
  43. private static function filterClientOptions($options) {
  44. if ($options instanceof ClientOptions) {
  45. return $options;
  46. }
  47. if (is_array($options)) {
  48. return new ClientOptions($options);
  49. }
  50. if ($options instanceof RedisServerProfile) {
  51. return new ClientOptions(array(
  52. 'profile' => $options
  53. ));
  54. }
  55. if (is_string($options)) {
  56. return new ClientOptions(array(
  57. 'profile' => RedisServerProfile::get($options)
  58. ));
  59. }
  60. throw new \InvalidArgumentException("Invalid type for client options");
  61. }
  62. private function setupClient($options) {
  63. $this->_responseReader = new ResponseReader();
  64. $this->_options = self::filterClientOptions($options);
  65. $this->setProfile($this->_options->profile);
  66. if ($this->_options->iterable_multibulk === true) {
  67. $this->_responseReader->setHandler(
  68. Protocol::PREFIX_MULTI_BULK,
  69. new ResponseMultiBulkStreamHandler()
  70. );
  71. }
  72. if ($this->_options->throw_on_error === false) {
  73. $this->_responseReader->setHandler(
  74. Protocol::PREFIX_ERROR,
  75. new ResponseErrorSilentHandler()
  76. );
  77. }
  78. }
  79. private function setupConnection($parameters) {
  80. if ($parameters !== null && !(is_array($parameters) || is_string($parameters))) {
  81. throw new ClientException('Invalid parameters type (array or string expected)');
  82. }
  83. if (is_array($parameters) && isset($parameters[0])) {
  84. $cluster = new ConnectionCluster($this->_options->key_distribution);
  85. foreach ($parameters as $shardParams) {
  86. $cluster->add($this->createConnection($shardParams));
  87. }
  88. $this->setConnection($cluster);
  89. }
  90. else {
  91. $this->setConnection($this->createConnection($parameters));
  92. }
  93. }
  94. private function createConnection($parameters) {
  95. $params = $parameters instanceof ConnectionParameters
  96. ? $parameters
  97. : new ConnectionParameters($parameters);
  98. $connection = new Connection($params, $this->_responseReader);
  99. if ($params->password !== null) {
  100. $connection->pushInitCommand($this->createCommand(
  101. 'auth', array($params->password)
  102. ));
  103. }
  104. if ($params->database !== null) {
  105. $connection->pushInitCommand($this->createCommand(
  106. 'select', array($params->database)
  107. ));
  108. }
  109. return $connection;
  110. }
  111. private function setConnection(IConnection $connection) {
  112. $this->_connection = $connection;
  113. }
  114. public function setProfile($serverProfile) {
  115. if (!($serverProfile instanceof RedisServerProfile || is_string($serverProfile))) {
  116. throw new \InvalidArgumentException(
  117. "Invalid type for server profile, \Predis\RedisServerProfile or string expected"
  118. );
  119. }
  120. $this->_serverProfile = (is_string($serverProfile)
  121. ? RedisServerProfile::get($serverProfile)
  122. : $serverProfile
  123. );
  124. }
  125. public function getProfile() {
  126. return $this->_serverProfile;
  127. }
  128. public function getResponseReader() {
  129. return $this->_responseReader;
  130. }
  131. public function getClientFor($connectionAlias) {
  132. if (!Shared\Utils::isCluster($this->_connection)) {
  133. throw new ClientException(
  134. 'This method is supported only when the client is connected to a cluster of connections'
  135. );
  136. }
  137. $connection = $this->_connection->getConnectionById($connectionAlias);
  138. if ($connection === null) {
  139. throw new \InvalidArgumentException(
  140. "Invalid connection alias: '$connectionAlias'"
  141. );
  142. }
  143. $newClient = new Client();
  144. $newClient->setupClient($this->_options);
  145. $newClient->setConnection($connection);
  146. return $newClient;
  147. }
  148. public function connect() {
  149. $this->_connection->connect();
  150. }
  151. public function disconnect() {
  152. $this->_connection->disconnect();
  153. }
  154. public function isConnected() {
  155. return $this->_connection->isConnected();
  156. }
  157. public function getConnection($id = null) {
  158. if (!isset($id)) {
  159. return $this->_connection;
  160. }
  161. else {
  162. return Shared\Utils::isCluster($this->_connection)
  163. ? $this->_connection->getConnectionById($id)
  164. : $this->_connection;
  165. }
  166. }
  167. public function __call($method, $arguments) {
  168. $command = $this->_serverProfile->createCommand($method, $arguments);
  169. return $this->_connection->executeCommand($command);
  170. }
  171. public function createCommand($method, $arguments = array()) {
  172. return $this->_serverProfile->createCommand($method, $arguments);
  173. }
  174. public function executeCommand(Command $command) {
  175. return $this->_connection->executeCommand($command);
  176. }
  177. public function executeCommandOnShards(Command $command) {
  178. $replies = array();
  179. if (Shared\Utils::isCluster($this->_connection)) {
  180. foreach($this->_connection as $connection) {
  181. $replies[] = $connection->executeCommand($command);
  182. }
  183. }
  184. else {
  185. $replies[] = $this->_connection->executeCommand($command);
  186. }
  187. return $replies;
  188. }
  189. public function rawCommand($rawCommandData, $closesConnection = false) {
  190. if (Shared\Utils::isCluster($this->_connection)) {
  191. throw new ClientException('Cannot send raw commands when connected to a cluster of Redis servers');
  192. }
  193. return $this->_connection->rawCommand($rawCommandData, $closesConnection);
  194. }
  195. private function sharedInitializer($argv, $initializer) {
  196. $argc = count($argv);
  197. if ($argc === 0) {
  198. return $this->$initializer();
  199. }
  200. else if ($argc === 1) {
  201. list($arg0) = $argv;
  202. return is_array($arg0) ? $this->$initializer($arg0) : $this->$initializer(null, $arg0);
  203. }
  204. else if ($argc === 2) {
  205. list($arg0, $arg1) = $argv;
  206. return $this->$initializer($arg0, $arg1);
  207. }
  208. return $this->$initializer($this, $arguments);
  209. }
  210. public function pipeline(/* arguments */) {
  211. return $this->sharedInitializer(func_get_args(), 'initPipeline');
  212. }
  213. public function pipelineSafe($pipelineBlock = null) {
  214. return $this->initPipeline(array('safe' => true), $pipelineBlock);
  215. }
  216. private function initPipeline(Array $options = null, $pipelineBlock = null) {
  217. $pipeline = null;
  218. if (isset($options)) {
  219. if (isset($options['safe']) && $options['safe'] == true) {
  220. $connection = $this->getConnection();
  221. $pipeline = new CommandPipeline($this, $connection instanceof Connection
  222. ? new Pipeline\SafeExecutor($connection)
  223. : new Pipeline\SafeClusterExecutor($connection)
  224. );
  225. }
  226. else {
  227. $pipeline = new CommandPipeline($this);
  228. }
  229. }
  230. else {
  231. $pipeline = new CommandPipeline($this);
  232. }
  233. return $this->pipelineExecute($pipeline, $pipelineBlock);
  234. }
  235. private function pipelineExecute(CommandPipeline $pipeline, $block) {
  236. return $block !== null ? $pipeline->execute($block) : $pipeline;
  237. }
  238. public function multiExec(/* arguments */) {
  239. return $this->sharedInitializer(func_get_args(), 'initMultiExec');
  240. }
  241. private function initMultiExec(Array $options = null, $transBlock = null) {
  242. $multi = isset($options) ? new MultiExecBlock($this, $options) : new MultiExecBlock($this);
  243. return $transBlock !== null ? $multi->execute($transBlock) : $multi;
  244. }
  245. public function pubSubContext() {
  246. return new PubSubContext($this);
  247. }
  248. }
  249. /* ------------------------------------------------------------------------- */
  250. interface IClientOptionsHandler {
  251. public function validate($option, $value);
  252. public function getDefault();
  253. }
  254. class ClientOptionsProfile implements IClientOptionsHandler {
  255. public function validate($option, $value) {
  256. if ($value instanceof \Predis\RedisServerProfile) {
  257. return $value;
  258. }
  259. if (is_string($value)) {
  260. return \Predis\RedisServerProfile::get($value);
  261. }
  262. throw new \InvalidArgumentException("Invalid value for option $option");
  263. }
  264. public function getDefault() {
  265. return \Predis\RedisServerProfile::getDefault();
  266. }
  267. }
  268. class ClientOptionsKeyDistribution implements IClientOptionsHandler {
  269. public function validate($option, $value) {
  270. if ($value instanceof \Predis\Distribution\IDistributionStrategy) {
  271. return $value;
  272. }
  273. if (is_string($value)) {
  274. $valueReflection = new \ReflectionClass($value);
  275. if ($valueReflection->isSubclassOf('\Predis\Distribution\IDistributionStrategy')) {
  276. return new $value;
  277. }
  278. }
  279. throw new \InvalidArgumentException("Invalid value for option $option");
  280. }
  281. public function getDefault() {
  282. return new \Predis\Distribution\HashRing();
  283. }
  284. }
  285. class ClientOptionsIterableMultiBulk implements IClientOptionsHandler {
  286. public function validate($option, $value) {
  287. return (bool) $value;
  288. }
  289. public function getDefault() {
  290. return false;
  291. }
  292. }
  293. class ClientOptionsThrowOnError implements IClientOptionsHandler {
  294. public function validate($option, $value) {
  295. return (bool) $value;
  296. }
  297. public function getDefault() {
  298. return true;
  299. }
  300. }
  301. class ClientOptions {
  302. private static $_optionsHandlers;
  303. private $_options;
  304. public function __construct($options = null) {
  305. self::initializeOptionsHandlers();
  306. $this->initializeOptions($options ?: array());
  307. }
  308. private static function initializeOptionsHandlers() {
  309. if (!isset(self::$_optionsHandlers)) {
  310. self::$_optionsHandlers = self::getOptionsHandlers();
  311. }
  312. }
  313. private static function getOptionsHandlers() {
  314. return array(
  315. 'profile' => new \Predis\ClientOptionsProfile(),
  316. 'key_distribution' => new \Predis\ClientOptionsKeyDistribution(),
  317. 'iterable_multibulk' => new \Predis\ClientOptionsIterableMultiBulk(),
  318. 'throw_on_error' => new \Predis\ClientOptionsThrowOnError(),
  319. );
  320. }
  321. private function initializeOptions($options) {
  322. foreach ($options as $option => $value) {
  323. if (isset(self::$_optionsHandlers[$option])) {
  324. $handler = self::$_optionsHandlers[$option];
  325. $this->_options[$option] = $handler->validate($option, $value);
  326. }
  327. }
  328. }
  329. public function __get($option) {
  330. if (!isset($this->_options[$option])) {
  331. $defaultValue = self::$_optionsHandlers[$option]->getDefault();
  332. $this->_options[$option] = $defaultValue;
  333. }
  334. return $this->_options[$option];
  335. }
  336. public function __isset($option) {
  337. return isset(self::$_optionsHandlers[$option]);
  338. }
  339. }
  340. /* ------------------------------------------------------------------------- */
  341. class Protocol {
  342. const NEWLINE = "\r\n";
  343. const OK = 'OK';
  344. const ERROR = 'ERR';
  345. const QUEUED = 'QUEUED';
  346. const NULL = 'nil';
  347. const PREFIX_STATUS = '+';
  348. const PREFIX_ERROR = '-';
  349. const PREFIX_INTEGER = ':';
  350. const PREFIX_BULK = '$';
  351. const PREFIX_MULTI_BULK = '*';
  352. }
  353. abstract class Command {
  354. private $_arguments, $_hash;
  355. public abstract function getCommandId();
  356. public abstract function serializeRequest($command, $arguments);
  357. public function canBeHashed() {
  358. return true;
  359. }
  360. public function getHash(Distribution\IDistributionStrategy $distributor) {
  361. if (isset($this->_hash)) {
  362. return $this->_hash;
  363. }
  364. else {
  365. if (isset($this->_arguments[0])) {
  366. // TODO: should we throw an exception if the command does
  367. // not support sharding?
  368. $key = $this->_arguments[0];
  369. $start = strpos($key, '{');
  370. $end = strpos($key, '}');
  371. if ($start !== false && $end !== false) {
  372. $key = substr($key, ++$start, $end - $start);
  373. }
  374. $this->_hash = $distributor->generateKey($key);
  375. return $this->_hash;
  376. }
  377. }
  378. return null;
  379. }
  380. public function closesConnection() {
  381. return false;
  382. }
  383. protected function filterArguments(Array $arguments) {
  384. return $arguments;
  385. }
  386. public function setArguments(/* arguments */) {
  387. $this->_arguments = $this->filterArguments(func_get_args());
  388. unset($this->_hash);
  389. }
  390. public function setArgumentsArray(Array $arguments) {
  391. $this->_arguments = $this->filterArguments($arguments);
  392. unset($this->_hash);
  393. }
  394. public function getArguments() {
  395. return isset($this->_arguments) ? $this->_arguments : array();
  396. }
  397. public function getArgument($index = 0) {
  398. return isset($this->_arguments[$index]) ? $this->_arguments[$index] : null;
  399. }
  400. public function parseResponse($data) {
  401. return $data;
  402. }
  403. public final function __invoke() {
  404. return $this->serializeRequest($this->getCommandId(), $this->getArguments());
  405. }
  406. }
  407. abstract class InlineCommand extends Command {
  408. public function serializeRequest($command, $arguments) {
  409. if (isset($arguments[0]) && is_array($arguments[0])) {
  410. $arguments[0] = implode($arguments[0], ' ');
  411. }
  412. return $command . (count($arguments) > 0
  413. ? ' ' . implode($arguments, ' ') . Protocol::NEWLINE
  414. : Protocol::NEWLINE
  415. );
  416. }
  417. }
  418. abstract class BulkCommand extends Command {
  419. public function serializeRequest($command, $arguments) {
  420. $data = array_pop($arguments);
  421. if (is_array($data)) {
  422. $data = implode($data, ' ');
  423. }
  424. return $command . ' ' . implode($arguments, ' ') . ' ' . strlen($data) .
  425. Protocol::NEWLINE . $data . Protocol::NEWLINE;
  426. }
  427. }
  428. abstract class MultiBulkCommand extends Command {
  429. public function serializeRequest($command, $arguments) {
  430. $cmd_args = null;
  431. $argsc = count($arguments);
  432. if ($argsc === 1 && is_array($arguments[0])) {
  433. $cmd_args = $arguments[0];
  434. $argsc = count($cmd_args);
  435. }
  436. else {
  437. $cmd_args = $arguments;
  438. }
  439. $newline = Protocol::NEWLINE;
  440. $cmdlen = strlen($command);
  441. $reqlen = $argsc + 1;
  442. $buffer = "*{$reqlen}{$newline}\${$cmdlen}{$newline}{$command}{$newline}";
  443. foreach ($cmd_args as $argument) {
  444. $arglen = strlen($argument);
  445. $buffer .= "\${$arglen}{$newline}{$argument}{$newline}";
  446. }
  447. return $buffer;
  448. }
  449. }
  450. /* ------------------------------------------------------------------------- */
  451. interface IResponseHandler {
  452. function handle(Connection $connection, $payload);
  453. }
  454. class ResponseStatusHandler implements IResponseHandler {
  455. public function handle(Connection $connection, $status) {
  456. if ($status === Protocol::OK) {
  457. return true;
  458. }
  459. else if ($status === Protocol::QUEUED) {
  460. return new ResponseQueued();
  461. }
  462. return $status;
  463. }
  464. }
  465. class ResponseErrorHandler implements IResponseHandler {
  466. public function handle(Connection $connection, $errorMessage) {
  467. throw new ServerException(substr($errorMessage, 4));
  468. }
  469. }
  470. class ResponseErrorSilentHandler implements IResponseHandler {
  471. public function handle(Connection $connection, $errorMessage) {
  472. return new ResponseError(substr($errorMessage, 4));
  473. }
  474. }
  475. class ResponseBulkHandler implements IResponseHandler {
  476. public function handle(Connection $connection, $dataLength) {
  477. if (!is_numeric($dataLength)) {
  478. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  479. $connection, "Cannot parse '$dataLength' as data length"
  480. ));
  481. }
  482. if ($dataLength > 0) {
  483. $value = $connection->readBytes($dataLength);
  484. self::discardNewLine($connection);
  485. return $value;
  486. }
  487. else if ($dataLength == 0) {
  488. self::discardNewLine($connection);
  489. return '';
  490. }
  491. return null;
  492. }
  493. private static function discardNewLine(Connection $connection) {
  494. if ($connection->readBytes(2) !== Protocol::NEWLINE) {
  495. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  496. $connection, 'Did not receive a new-line at the end of a bulk response'
  497. ));
  498. }
  499. }
  500. }
  501. class ResponseMultiBulkHandler implements IResponseHandler {
  502. public function handle(Connection $connection, $rawLength) {
  503. if (!is_numeric($rawLength)) {
  504. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  505. $connection, "Cannot parse '$rawLength' as data length"
  506. ));
  507. }
  508. $listLength = (int) $rawLength;
  509. if ($listLength === -1) {
  510. return null;
  511. }
  512. $list = array();
  513. if ($listLength > 0) {
  514. $reader = $connection->getResponseReader();
  515. for ($i = 0; $i < $listLength; $i++) {
  516. $list[] = $reader->read($connection);
  517. }
  518. }
  519. return $list;
  520. }
  521. }
  522. class ResponseMultiBulkStreamHandler implements IResponseHandler {
  523. public function handle(Connection $connection, $rawLength) {
  524. if (!is_numeric($rawLength)) {
  525. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  526. $connection, "Cannot parse '$rawLength' as data length"
  527. ));
  528. }
  529. return new Shared\MultiBulkResponseIterator($connection, (int)$rawLength);
  530. }
  531. }
  532. class ResponseIntegerHandler implements IResponseHandler {
  533. public function handle(Connection $connection, $number) {
  534. if (is_numeric($number)) {
  535. return (int) $number;
  536. }
  537. else {
  538. if ($number !== Protocol::NULL) {
  539. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  540. $connection, "Cannot parse '$number' as numeric response"
  541. ));
  542. }
  543. return null;
  544. }
  545. }
  546. }
  547. class ResponseReader {
  548. private $_prefixHandlers;
  549. public function __construct() {
  550. $this->initializePrefixHandlers();
  551. }
  552. private function initializePrefixHandlers() {
  553. $this->_prefixHandlers = array(
  554. Protocol::PREFIX_STATUS => new ResponseStatusHandler(),
  555. Protocol::PREFIX_ERROR => new ResponseErrorHandler(),
  556. Protocol::PREFIX_INTEGER => new ResponseIntegerHandler(),
  557. Protocol::PREFIX_BULK => new ResponseBulkHandler(),
  558. Protocol::PREFIX_MULTI_BULK => new ResponseMultiBulkHandler(),
  559. );
  560. }
  561. public function setHandler($prefix, IResponseHandler $handler) {
  562. $this->_prefixHandlers[$prefix] = $handler;
  563. }
  564. public function getHandler($prefix) {
  565. if (isset($this->_prefixHandlers[$prefix])) {
  566. return $this->_prefixHandlers[$prefix];
  567. }
  568. }
  569. public function read(Connection $connection) {
  570. $header = $connection->readLine();
  571. if ($header === '') {
  572. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  573. $connection, 'Unexpected empty header'
  574. ));
  575. }
  576. $prefix = $header[0];
  577. $payload = strlen($header) > 1 ? substr($header, 1) : '';
  578. if (!isset($this->_prefixHandlers[$prefix])) {
  579. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  580. $connection, "Unknown prefix '$prefix'"
  581. ));
  582. }
  583. $handler = $this->_prefixHandlers[$prefix];
  584. return $handler->handle($connection, $payload);
  585. }
  586. }
  587. class ResponseError {
  588. private $_message;
  589. public function __construct($message) {
  590. $this->_message = $message;
  591. }
  592. public function __get($property) {
  593. if ($property == 'error') {
  594. return true;
  595. }
  596. if ($property == 'message') {
  597. return $this->_message;
  598. }
  599. }
  600. public function __isset($property) {
  601. return $property === 'error';
  602. }
  603. public function __toString() {
  604. return $this->_message;
  605. }
  606. }
  607. class ResponseQueued {
  608. public $queued = true;
  609. public function __toString() {
  610. return Protocol::QUEUED;
  611. }
  612. }
  613. /* ------------------------------------------------------------------------- */
  614. class CommandPipeline {
  615. private $_redisClient, $_pipelineBuffer, $_returnValues, $_running, $_executor;
  616. public function __construct(Client $redisClient, Pipeline\IPipelineExecutor $executor = null) {
  617. $this->_redisClient = $redisClient;
  618. $this->_executor = $executor ?: new Pipeline\StandardExecutor();
  619. $this->_pipelineBuffer = array();
  620. $this->_returnValues = array();
  621. }
  622. public function __call($method, $arguments) {
  623. $command = $this->_redisClient->createCommand($method, $arguments);
  624. $this->recordCommand($command);
  625. return $this;
  626. }
  627. private function recordCommand(Command $command) {
  628. $this->_pipelineBuffer[] = $command;
  629. }
  630. private function getRecordedCommands() {
  631. return $this->_pipelineBuffer;
  632. }
  633. public function flushPipeline() {
  634. if (count($this->_pipelineBuffer) > 0) {
  635. $connection = $this->_redisClient->getConnection();
  636. $this->_returnValues = array_merge(
  637. $this->_returnValues,
  638. $this->_executor->execute($connection, $this->_pipelineBuffer)
  639. );
  640. $this->_pipelineBuffer = array();
  641. }
  642. return $this;
  643. }
  644. private function setRunning($bool) {
  645. if ($bool == true && $this->_running == true) {
  646. throw new ClientException("This pipeline is already opened");
  647. }
  648. $this->_running = $bool;
  649. }
  650. public function execute($block = null) {
  651. if ($block && !is_callable($block)) {
  652. throw new \InvalidArgumentException('Argument passed must be a callable object');
  653. }
  654. // TODO: do not reuse previously executed pipelines
  655. $this->setRunning(true);
  656. $pipelineBlockException = null;
  657. try {
  658. if ($block !== null) {
  659. $block($this);
  660. }
  661. $this->flushPipeline();
  662. }
  663. catch (\Exception $exception) {
  664. $pipelineBlockException = $exception;
  665. }
  666. $this->setRunning(false);
  667. if ($pipelineBlockException !== null) {
  668. throw $pipelineBlockException;
  669. }
  670. return $this->_returnValues;
  671. }
  672. }
  673. class MultiExecBlock {
  674. private $_initialized, $_discarded, $_insideBlock;
  675. private $_redisClient, $_options, $_commands;
  676. private $_supportsWatch;
  677. public function __construct(Client $redisClient, Array $options = null) {
  678. $this->checkCapabilities($redisClient);
  679. $this->_initialized = false;
  680. $this->_discarded = false;
  681. $this->_insideBlock = false;
  682. $this->_redisClient = $redisClient;
  683. $this->_options = $options ?: array();
  684. $this->_commands = array();
  685. }
  686. private function checkCapabilities(Client $redisClient) {
  687. if (Shared\Utils::isCluster($redisClient->getConnection())) {
  688. throw new \Predis\ClientException(
  689. 'Cannot initialize a MULTI/EXEC context over a cluster of connections'
  690. );
  691. }
  692. $profile = $redisClient->getProfile();
  693. if ($profile->supportsCommands(array('multi', 'exec', 'discard')) === false) {
  694. throw new \Predis\ClientException(
  695. 'The current profile does not support MULTI, EXEC and DISCARD commands'
  696. );
  697. }
  698. $this->_supportsWatch = $profile->supportsCommands(array('watch', 'unwatch'));
  699. }
  700. private function isWatchSupported() {
  701. if ($this->_supportsWatch === false) {
  702. throw new \Predis\ClientException(
  703. 'The current profile does not support WATCH and UNWATCH commands'
  704. );
  705. }
  706. }
  707. private function initialize() {
  708. if ($this->_initialized === false) {
  709. if (isset($this->_options['watch'])) {
  710. $this->watch($this->_options['watch']);
  711. }
  712. $this->_redisClient->multi();
  713. $this->_initialized = true;
  714. $this->_discarded = false;
  715. }
  716. }
  717. private function setInsideBlock($value) {
  718. $this->_insideBlock = $value;
  719. }
  720. public function __call($method, $arguments) {
  721. $this->initialize();
  722. $command = $this->_redisClient->createCommand($method, $arguments);
  723. $response = $this->_redisClient->executeCommand($command);
  724. if (isset($response->queued)) {
  725. $this->_commands[] = $command;
  726. return $this;
  727. }
  728. else {
  729. $this->malformedServerResponse('The server did not respond with a QUEUED status reply');
  730. }
  731. }
  732. public function watch($keys) {
  733. $this->isWatchSupported();
  734. if ($this->_initialized === true) {
  735. throw new \Predis\ClientException('WATCH inside MULTI is not allowed');
  736. }
  737. $reply = null;
  738. if (is_array($keys)) {
  739. $reply = array();
  740. foreach ($keys as $key) {
  741. $reply = $this->_redisClient->watch($keys);
  742. }
  743. }
  744. else {
  745. $reply = $this->_redisClient->watch($keys);
  746. }
  747. return $reply;
  748. }
  749. public function multi() {
  750. $this->initialize();
  751. }
  752. public function unwatch() {
  753. $this->isWatchSupported();
  754. $this->_redisClient->unwatch();
  755. return $this;
  756. }
  757. public function discard() {
  758. $this->_redisClient->discard();
  759. $this->_commands = array();
  760. $this->_initialized = false;
  761. $this->_discarded = true;
  762. return $this;
  763. }
  764. public function exec() {
  765. return $this->execute();
  766. }
  767. public function execute($block = null) {
  768. if ($this->_insideBlock === true) {
  769. throw new \Predis\ClientException(
  770. "Cannot invoke 'execute' or 'exec' inside an active client transaction block"
  771. );
  772. }
  773. if ($block && !is_callable($block)) {
  774. throw new \InvalidArgumentException('Argument passed must be a callable object');
  775. }
  776. $blockException = null;
  777. $returnValues = array();
  778. if ($block !== null) {
  779. $this->setInsideBlock(true);
  780. try {
  781. $block($this);
  782. }
  783. catch (CommunicationException $exception) {
  784. $blockException = $exception;
  785. }
  786. catch (ServerException $exception) {
  787. $blockException = $exception;
  788. }
  789. catch (\Exception $exception) {
  790. $blockException = $exception;
  791. if ($this->_initialized === true) {
  792. $this->discard();
  793. }
  794. }
  795. $this->setInsideBlock(false);
  796. if ($blockException !== null) {
  797. throw $blockException;
  798. }
  799. }
  800. if ($this->_initialized === false) {
  801. return;
  802. }
  803. $reply = $this->_redisClient->exec();
  804. if ($reply === null) {
  805. throw new AbortedMultiExec('The current transaction has been aborted by the server');
  806. }
  807. $execReply = $reply instanceof \Iterator ? iterator_to_array($reply) : $reply;
  808. $commands = &$this->_commands;
  809. $sizeofReplies = count($execReply);
  810. if ($sizeofReplies !== count($commands)) {
  811. $this->malformedServerResponse('Unexpected number of responses for a MultiExecBlock');
  812. }
  813. for ($i = 0; $i < $sizeofReplies; $i++) {
  814. $returnValues[] = $commands[$i]->parseResponse($execReply[$i] instanceof \Iterator
  815. ? iterator_to_array($execReply[$i])
  816. : $execReply[$i]
  817. );
  818. unset($commands[$i]);
  819. }
  820. return $returnValues;
  821. }
  822. private function malformedServerResponse($message) {
  823. // NOTE: a MULTI/EXEC block cannot be initialized on a clustered
  824. // connection, which means that Predis\Client::getConnection
  825. // will always return an instance of Predis\Connection.
  826. Shared\Utils::onCommunicationException(new MalformedServerResponse(
  827. $this->_redisClient->getConnection(), $message
  828. ));
  829. }
  830. }
  831. class PubSubContext implements \Iterator {
  832. const SUBSCRIBE = 'subscribe';
  833. const UNSUBSCRIBE = 'unsubscribe';
  834. const PSUBSCRIBE = 'psubscribe';
  835. const PUNSUBSCRIBE = 'punsubscribe';
  836. const MESSAGE = 'message';
  837. const PMESSAGE = 'pmessage';
  838. const STATUS_VALID = 0x0001;
  839. const STATUS_SUBSCRIBED = 0x0010;
  840. const STATUS_PSUBSCRIBED = 0x0100;
  841. private $_redisClient, $_subscriptions, $_isStillValid, $_position;
  842. public function __construct(Client $redisClient) {
  843. $this->checkCapabilities($redisClient);
  844. $this->_redisClient = $redisClient;
  845. $this->_statusFlags = self::STATUS_VALID;
  846. }
  847. public function __destruct() {
  848. $this->closeContext();
  849. }
  850. private function checkCapabilities(Client $redisClient) {
  851. if (Shared\Utils::isCluster($redisClient->getConnection())) {
  852. throw new \Predis\ClientException(
  853. 'Cannot initialize a PUB/SUB context over a cluster of connections'
  854. );
  855. }
  856. $profile = $redisClient->getProfile();
  857. $commands = array('publish', 'subscribe', 'unsubscribe', 'psubscribe', 'punsubscribe');
  858. if ($profile->supportsCommands($commands) === false) {
  859. throw new \Predis\ClientException(
  860. 'The current profile does not support PUB/SUB related commands'
  861. );
  862. }
  863. }
  864. private function isFlagSet($value) {
  865. return ($this->_statusFlags & $value) === $value;
  866. }
  867. public function subscribe(/* arguments */) {
  868. $this->writeCommand(self::SUBSCRIBE, func_get_args());
  869. $this->_statusFlags |= self::STATUS_SUBSCRIBED;
  870. }
  871. public function unsubscribe(/* arguments */) {
  872. $this->writeCommand(self::UNSUBSCRIBE, func_get_args());
  873. }
  874. public function psubscribe(/* arguments */) {
  875. $this->writeCommand(self::PSUBSCRIBE, func_get_args());
  876. $this->_statusFlags |= self::STATUS_PSUBSCRIBED;
  877. }
  878. public function punsubscribe(/* arguments */) {
  879. $this->writeCommand(self::PUNSUBSCRIBE, func_get_args());
  880. }
  881. public function closeContext() {
  882. if ($this->valid()) {
  883. if ($this->isFlagSet(self::STATUS_SUBSCRIBED)) {
  884. $this->unsubscribe();
  885. }
  886. if ($this->isFlagSet(self::STATUS_PSUBSCRIBED)) {
  887. $this->punsubscribe();
  888. }
  889. }
  890. }
  891. private function writeCommand($method, $arguments) {
  892. if (count($arguments) === 1 && is_array($arguments[0])) {
  893. $arguments = $arguments[0];
  894. }
  895. $command = $this->_redisClient->createCommand($method, $arguments);
  896. $this->_redisClient->getConnection()->writeCommand($command);
  897. }
  898. public function rewind() {
  899. // NOOP
  900. }
  901. public function current() {
  902. return $this->getValue();
  903. }
  904. public function key() {
  905. return $this->_position;
  906. }
  907. public function next() {
  908. if ($this->isFlagSet(self::STATUS_VALID)) {
  909. $this->_position++;
  910. }
  911. return $this->_position;
  912. }
  913. public function valid() {
  914. $subscriptions = self::STATUS_SUBSCRIBED + self::STATUS_PSUBSCRIBED;
  915. return $this->isFlagSet(self::STATUS_VALID)
  916. && ($this->_statusFlags & $subscriptions) > 0;
  917. }
  918. private function invalidate() {
  919. $this->_statusFlags = 0x0000;
  920. }
  921. private function getValue() {
  922. $reader = $this->_redisClient->getResponseReader();
  923. $connection = $this->_redisClient->getConnection();
  924. $response = $reader->read($connection);
  925. switch ($response[0]) {
  926. case self::SUBSCRIBE:
  927. case self::UNSUBSCRIBE:
  928. case self::PSUBSCRIBE:
  929. case self::PUNSUBSCRIBE:
  930. if ($response[2] === 0) {
  931. $this->invalidate();
  932. }
  933. case self::MESSAGE:
  934. return (object) array(
  935. 'kind' => $response[0],
  936. 'channel' => $response[1],
  937. 'payload' => $response[2],
  938. );
  939. case self::PMESSAGE:
  940. return (object) array(
  941. 'kind' => $response[0],
  942. 'pattern' => $response[1],
  943. 'channel' => $response[2],
  944. 'payload' => $response[3],
  945. );
  946. default:
  947. throw new \Predis\ClientException(
  948. "Received an unknown message type {$response[0]} inside of a pubsub context"
  949. );
  950. }
  951. }
  952. }
  953. /* ------------------------------------------------------------------------- */
  954. class ConnectionParameters {
  955. const DEFAULT_HOST = '127.0.0.1';
  956. const DEFAULT_PORT = 6379;
  957. const DEFAULT_TIMEOUT = 5;
  958. private $_parameters;
  959. public function __construct($parameters = null) {
  960. $parameters = $parameters ?: array();
  961. $this->_parameters = is_array($parameters)
  962. ? self::filterConnectionParams($parameters)
  963. : self::parseURI($parameters);
  964. }
  965. private static function parseURI($uri) {
  966. $parsed = @parse_url($uri);
  967. if ($parsed == false || $parsed['scheme'] != 'redis' || $parsed['host'] == null) {
  968. throw new ClientException("Invalid URI: $uri");
  969. }
  970. if (array_key_exists('query', $parsed)) {
  971. $details = array();
  972. foreach (explode('&', $parsed['query']) as $kv) {
  973. list($k, $v) = explode('=', $kv);
  974. switch ($k) {
  975. case 'database':
  976. $details['database'] = $v;
  977. break;
  978. case 'password':
  979. $details['password'] = $v;
  980. break;
  981. case 'connection_async':
  982. $details['connection_async'] = $v;
  983. break;
  984. case 'connection_persistent':
  985. $details['connection_persistent'] = $v;
  986. break;
  987. case 'connection_timeout':
  988. $details['connection_timeout'] = $v;
  989. break;
  990. case 'read_write_timeout':
  991. $details['read_write_timeout'] = $v;
  992. break;
  993. case 'alias':
  994. $details['alias'] = $v;
  995. break;
  996. case 'weight':
  997. $details['weight'] = $v;
  998. break;
  999. }
  1000. }
  1001. $parsed = array_merge($parsed, $details);
  1002. }
  1003. return self::filterConnectionParams($parsed);
  1004. }
  1005. private static function getParamOrDefault(Array $parameters, $param, $default = null) {
  1006. return array_key_exists($param, $parameters) ? $parameters[$param] : $default;
  1007. }
  1008. private static function filterConnectionParams($parameters) {
  1009. return array(
  1010. 'host' => self::getParamOrDefault($parameters, 'host', self::DEFAULT_HOST),
  1011. 'port' => (int) self::getParamOrDefault($parameters, 'port', self::DEFAULT_PORT),
  1012. 'database' => self::getParamOrDefault($parameters, 'database'),
  1013. 'password' => self::getParamOrDefault($parameters, 'password'),
  1014. 'connection_async' => self::getParamOrDefault($parameters, 'connection_async', false),
  1015. 'connection_persistent' => self::getParamOrDefault($parameters, 'connection_persistent', false),
  1016. 'connection_timeout' => self::getParamOrDefault($parameters, 'connection_timeout', self::DEFAULT_TIMEOUT),
  1017. 'read_write_timeout' => self::getParamOrDefault($parameters, 'read_write_timeout'),
  1018. 'alias' => self::getParamOrDefault($parameters, 'alias'),
  1019. 'weight' => self::getParamOrDefault($parameters, 'weight'),
  1020. );
  1021. }
  1022. public function __get($parameter) {
  1023. return $this->_parameters[$parameter];
  1024. }
  1025. public function __isset($parameter) {
  1026. return isset($this->_parameters[$parameter]);
  1027. }
  1028. }
  1029. interface IConnection {
  1030. public function connect();
  1031. public function disconnect();
  1032. public function isConnected();
  1033. public function writeCommand(Command $command);
  1034. public function readResponse(Command $command);
  1035. public function executeCommand(Command $command);
  1036. }
  1037. class Connection implements IConnection {
  1038. private $_params, $_socket, $_initCmds, $_reader;
  1039. public function __construct(ConnectionParameters $parameters, ResponseReader $reader = null) {
  1040. $this->_params = $parameters;
  1041. $this->_initCmds = array();
  1042. $this->_reader = $reader ?: new ResponseReader();
  1043. }
  1044. public function __destruct() {
  1045. if (!$this->_params->connection_persistent) {
  1046. $this->disconnect();
  1047. }
  1048. }
  1049. public function isConnected() {
  1050. return is_resource($this->_socket);
  1051. }
  1052. public function connect() {
  1053. if ($this->isConnected()) {
  1054. throw new ClientException('Connection already estabilished');
  1055. }
  1056. $uri = sprintf('tcp://%s:%d/', $this->_params->host, $this->_params->port);
  1057. $connectFlags = STREAM_CLIENT_CONNECT;
  1058. if ($this->_params->connection_async) {
  1059. $connectFlags |= STREAM_CLIENT_ASYNC_CONNECT;
  1060. }
  1061. if ($this->_params->connection_persistent) {
  1062. $connectFlags |= STREAM_CLIENT_PERSISTENT;
  1063. }
  1064. $this->_socket = @stream_socket_client(
  1065. $uri, $errno, $errstr, $this->_params->connection_timeout, $connectFlags
  1066. );
  1067. if (!$this->_socket) {
  1068. $this->onCommunicationException(trim($errstr), $errno);
  1069. }
  1070. if (isset($this->_params->read_write_timeout)) {
  1071. $timeoutSeconds = floor($this->_params->read_write_timeout);
  1072. $timeoutUSeconds = ($this->_params->read_write_timeout - $timeoutSeconds) * 1000000;
  1073. stream_set_timeout($this->_socket, $timeoutSeconds, $timeoutUSeconds);
  1074. }
  1075. if (count($this->_initCmds) > 0){
  1076. $this->sendInitializationCommands();
  1077. }
  1078. }
  1079. public function disconnect() {
  1080. if ($this->isConnected()) {
  1081. fclose($this->_socket);
  1082. }
  1083. }
  1084. public function pushInitCommand(Command $command){
  1085. $this->_initCmds[] = $command;
  1086. }
  1087. private function sendInitializationCommands() {
  1088. foreach ($this->_initCmds as $command) {
  1089. $this->writeCommand($command);
  1090. }
  1091. foreach ($this->_initCmds as $command) {
  1092. $this->readResponse($command);
  1093. }
  1094. }
  1095. private function onCommunicationException($message, $code = null) {
  1096. Shared\Utils::onCommunicationException(
  1097. new CommunicationException($this, $message, $code)
  1098. );
  1099. }
  1100. public function writeCommand(Command $command) {
  1101. $this->writeBytes($command());
  1102. }
  1103. public function readResponse(Command $command) {
  1104. $response = $this->_reader->read($this);
  1105. $skipparse = isset($response->queued) || isset($response->error);
  1106. return $skipparse ? $response : $command->parseResponse($response);
  1107. }
  1108. public function executeCommand(Command $command) {
  1109. $this->writeCommand($command);
  1110. if ($command->closesConnection()) {
  1111. return $this->disconnect();
  1112. }
  1113. return $this->readResponse($command);
  1114. }
  1115. public function rawCommand($rawCommandData, $closesConnection = false) {
  1116. $this->writeBytes($rawCommandData);
  1117. if ($closesConnection) {
  1118. $this->disconnect();
  1119. return;
  1120. }
  1121. return $this->_reader->read($this);
  1122. }
  1123. public function writeBytes($value) {
  1124. $socket = $this->getSocket();
  1125. while (($length = strlen($value)) > 0) {
  1126. $written = fwrite($socket, $value);
  1127. if ($length === $written) {
  1128. return true;
  1129. }
  1130. if ($written === false || $written === 0) {
  1131. $this->onCommunicationException('Error while writing bytes to the server');
  1132. }
  1133. $value = substr($value, $written);
  1134. }
  1135. return true;
  1136. }
  1137. public function readBytes($length) {
  1138. if ($length == 0) {
  1139. throw new \InvalidArgumentException('Length parameter must be greater than 0');
  1140. }
  1141. $socket = $this->getSocket();
  1142. $value = '';
  1143. do {
  1144. $chunk = fread($socket, $length);
  1145. if ($chunk === false || $chunk === '') {
  1146. $this->onCommunicationException('Error while reading bytes from the server');
  1147. }
  1148. $value .= $chunk;
  1149. }
  1150. while (($length -= strlen($chunk)) > 0);
  1151. return $value;
  1152. }
  1153. public function readLine() {
  1154. $socket = $this->getSocket();
  1155. $value = '';
  1156. do {
  1157. $chunk = fgets($socket);
  1158. if ($chunk === false || strlen($chunk) == 0) {
  1159. $this->onCommunicationException('Error while reading line from the server');
  1160. }
  1161. $value .= $chunk;
  1162. }
  1163. while (substr($value, -2) !== Protocol::NEWLINE);
  1164. return substr($value, 0, -2);
  1165. }
  1166. public function getSocket() {
  1167. if (!$this->isConnected()) {
  1168. $this->connect();
  1169. }
  1170. return $this->_socket;
  1171. }
  1172. public function getResponseReader() {
  1173. return $this->_reader;
  1174. }
  1175. public function getParameters() {
  1176. return $this->_params;
  1177. }
  1178. public function __toString() {
  1179. return sprintf('%s:%d', $this->_params->host, $this->_params->port);
  1180. }
  1181. }
  1182. class ConnectionCluster implements IConnection, \IteratorAggregate {
  1183. private $_pool, $_distributor;
  1184. public function __construct(Distribution\IDistributionStrategy $distributor = null) {
  1185. $this->_pool = array();
  1186. $this->_distributor = $distributor ?: new Distribution\HashRing();
  1187. }
  1188. public function isConnected() {
  1189. foreach ($this->_pool as $connection) {
  1190. if ($connection->isConnected()) {
  1191. return true;
  1192. }
  1193. }
  1194. return false;
  1195. }
  1196. public function connect() {
  1197. foreach ($this->_pool as $connection) {
  1198. $connection->connect();
  1199. }
  1200. }
  1201. public function disconnect() {
  1202. foreach ($this->_pool as $connection) {
  1203. $connection->disconnect();
  1204. }
  1205. }
  1206. public function add(Connection $connection) {
  1207. $parameters = $connection->getParameters();
  1208. if (isset($parameters->alias)) {
  1209. $this->_pool[$parameters->alias] = $connection;
  1210. }
  1211. else {
  1212. $this->_pool[] = $connection;
  1213. }
  1214. $this->_distributor->add($connection, $parameters->weight);
  1215. }
  1216. public function getConnection(Command $command) {
  1217. if ($command->canBeHashed() === false) {
  1218. throw new ClientException(
  1219. sprintf("Cannot send '%s' commands to a cluster of connections", $command->getCommandId())
  1220. );
  1221. }
  1222. return $this->_distributor->get($command->getHash($this->_distributor));
  1223. }
  1224. public function getConnectionById($id = null) {
  1225. $alias = $id ?: 0;
  1226. return isset($this->_pool[$alias]) ? $this->_pool[$alias] : null;
  1227. }
  1228. public function getIterator() {
  1229. return new \ArrayIterator($this->_pool);
  1230. }
  1231. public function writeCommand(Command $command) {
  1232. $this->getConnection($command)->writeCommand($command);
  1233. }
  1234. public function readResponse(Command $command) {
  1235. return $this->getConnection($command)->readResponse($command);
  1236. }
  1237. public function executeCommand(Command $command) {
  1238. $connection = $this->getConnection($command);
  1239. $connection->writeCommand($command);
  1240. return $connection->readResponse($command);
  1241. }
  1242. }
  1243. /* ------------------------------------------------------------------------- */
  1244. abstract class RedisServerProfile {
  1245. private static $_serverProfiles;
  1246. private $_registeredCommands;
  1247. public function __construct() {
  1248. $this->_registeredCommands = $this->getSupportedCommands();
  1249. }
  1250. public abstract function getVersion();
  1251. protected abstract function getSupportedCommands();
  1252. public static function getDefault() {
  1253. return self::get('default');
  1254. }
  1255. public static function getDevelopment() {
  1256. return self::get('dev');
  1257. }
  1258. private static function predisServerProfiles() {
  1259. return array(
  1260. '1.2' => '\Predis\RedisServer_v1_2',
  1261. '2.0' => '\Predis\RedisServer_v2_0',
  1262. 'default' => '\Predis\RedisServer_v2_0',
  1263. 'dev' => '\Predis\RedisServer_vNext',
  1264. );
  1265. }
  1266. public static function registerProfile($profileClass, $aliases) {
  1267. if (!isset(self::$_serverProfiles)) {
  1268. self::$_serverProfiles = self::predisServerProfiles();
  1269. }
  1270. $profileReflection = new \ReflectionClass($profileClass);
  1271. if (!$profileReflection->isSubclassOf('\Predis\RedisServerProfile')) {
  1272. throw new ClientException("Cannot register '$profileClass' as it is not a valid profile class");
  1273. }
  1274. if (is_array($aliases)) {
  1275. foreach ($aliases as $alias) {
  1276. self::$_serverProfiles[$alias] = $profileClass;
  1277. }
  1278. }
  1279. else {
  1280. self::$_serverProfiles[$aliases] = $profileClass;
  1281. }
  1282. }
  1283. public static function get($version) {
  1284. if (!isset(self::$_serverProfiles)) {
  1285. self::$_serverProfiles = self::predisServerProfiles();
  1286. }
  1287. if (!isset(self::$_serverProfiles[$version])) {
  1288. throw new ClientException("Unknown server profile: $version");
  1289. }
  1290. $profile = self::$_serverProfiles[$version];
  1291. return new $profile();
  1292. }
  1293. public function supportsCommands(Array $commands) {
  1294. foreach ($commands as $command) {
  1295. if ($this->supportsCommand($command) === false) {
  1296. return false;
  1297. }
  1298. }
  1299. return true;
  1300. }
  1301. public function supportsCommand($command) {
  1302. return isset($this->_registeredCommands[$command]);
  1303. }
  1304. public function createCommand($method, $arguments = array()) {
  1305. if (!isset($this->_registeredCommands[$method])) {
  1306. throw new ClientException("'$method' is not a registered Redis command");
  1307. }
  1308. $commandClass = $this->_registeredCommands[$method];
  1309. $command = new $commandClass();
  1310. $command->setArgumentsArray($arguments);
  1311. return $command;
  1312. }
  1313. public function registerCommands(Array $commands) {
  1314. foreach ($commands as $command => $aliases) {
  1315. $this->registerCommand($command, $aliases);
  1316. }
  1317. }
  1318. public function registerCommand($command, $aliases) {
  1319. $commandReflection = new \ReflectionClass($command);
  1320. if (!$commandReflection->isSubclassOf('\Predis\Command')) {
  1321. throw new ClientException("Cannot register '$command' as it is not a valid Redis command");
  1322. }
  1323. if (is_array($aliases)) {
  1324. foreach ($aliases as $alias) {
  1325. $this->_registeredCommands[$alias] = $command;
  1326. }
  1327. }
  1328. else {
  1329. $this->_registeredCommands[$aliases] = $command;
  1330. }
  1331. }
  1332. public function __toString() {
  1333. return $this->getVersion();
  1334. }
  1335. }
  1336. class RedisServer_v1_2 extends RedisServerProfile {
  1337. public function getVersion() { return '1.2'; }
  1338. public function getSupportedCommands() {
  1339. return array(
  1340. /* miscellaneous commands */
  1341. 'ping' => '\Predis\Commands\Ping',
  1342. 'echo' => '\Predis\Commands\DoEcho',
  1343. 'auth' => '\Predis\Commands\Auth',
  1344. /* connection handling */
  1345. 'quit' => '\Predis\Commands\Quit',
  1346. /* commands operating on string values */
  1347. 'set' => '\Predis\Commands\Set',
  1348. 'setnx' => '\Predis\Commands\SetPreserve',
  1349. 'setPreserve' => '\Predis\Commands\SetPreserve',
  1350. 'mset' => '\Predis\Commands\SetMultiple',
  1351. 'setMultiple' => '\Predis\Commands\SetMultiple',
  1352. 'msetnx' => '\Predis\Commands\SetMultiplePreserve',
  1353. 'setMultiplePreserve' => '\Predis\Commands\SetMultiplePreserve',
  1354. 'get' => '\Predis\Commands\Get',
  1355. 'mget' => '\Predis\Commands\GetMultiple',
  1356. 'getMultiple' => '\Predis\Commands\GetMultiple',
  1357. 'getset' => '\Predis\Commands\GetSet',
  1358. 'getSet' => '\Predis\Commands\GetSet',
  1359. 'incr' => '\Predis\Commands\Increment',
  1360. 'increment' => '\Predis\Commands\Increment',
  1361. 'incrby' => '\Predis\Commands\IncrementBy',
  1362. 'incrementBy' => '\Predis\Commands\IncrementBy',
  1363. 'decr' => '\Predis\Commands\Decrement',
  1364. 'decrement' => '\Predis\Commands\Decrement',
  1365. 'decrby' => '\Predis\Commands\DecrementBy',
  1366. 'decrementBy' => '\Predis\Commands\DecrementBy',
  1367. 'exists' => '\Predis\Commands\Exists',
  1368. 'del' => '\Predis\Commands\Delete',
  1369. 'delete' => '\Predis\Commands\Delete',
  1370. 'type' => '\Predis\Commands\Type',
  1371. /* commands operating on the key space */
  1372. 'keys' => '\Predis\Commands\Keys',
  1373. 'randomkey' => '\Predis\Commands\RandomKey',
  1374. 'randomKey' => '\Predis\Commands\RandomKey',
  1375. 'rename' => '\Predis\Commands\Rename',
  1376. 'renamenx' => '\Predis\Commands\RenamePreserve',
  1377. 'renamePreserve' => '\Predis\Commands\RenamePreserve',
  1378. 'expire' => '\Predis\Commands\Expire',
  1379. 'expireat' => '\Predis\Commands\ExpireAt',
  1380. 'expireAt' => '\Predis\Commands\ExpireAt',
  1381. 'dbsize' => '\Predis\Commands\DatabaseSize',
  1382. 'databaseSize' => '\Predis\Commands\DatabaseSize',
  1383. 'ttl' => '\Predis\Commands\TimeToLive',
  1384. 'timeToLive' => '\Predis\Commands\TimeToLive',
  1385. /* commands operating on lists */
  1386. 'rpush' => '\Predis\Commands\ListPushTail',
  1387. 'pushTail' => '\Predis\Commands\ListPushTail',
  1388. 'lpush' => '\Predis\Commands\ListPushHead',
  1389. 'pushHead' => '\Predis\Commands\ListPushHead',
  1390. 'llen' => '\Predis\Commands\ListLength',
  1391. 'listLength' => '\Predis\Commands\ListLength',
  1392. 'lrange' => '\Predis\Commands\ListRange',
  1393. 'listRange' => '\Predis\Commands\ListRange',
  1394. 'ltrim' => '\Predis\Commands\ListTrim',
  1395. 'listTrim' => '\Predis\Commands\ListTrim',
  1396. 'lindex' => '\Predis\Commands\ListIndex',
  1397. 'listIndex' => '\Predis\Commands\ListIndex',
  1398. 'lset' => '\Predis\Commands\ListSet',
  1399. 'listSet' => '\Predis\Commands\ListSet',
  1400. 'lrem' => '\Predis\Commands\ListRemove',
  1401. 'listRemove' => '\Predis\Commands\ListRemove',
  1402. 'lpop' => '\Predis\Commands\ListPopFirst',
  1403. 'popFirst' => '\Predis\Commands\ListPopFirst',
  1404. 'rpop' => '\Predis\Commands\ListPopLast',
  1405. 'popLast' => '\Predis\Commands\ListPopLast',
  1406. 'rpoplpush' => '\Predis\Commands\ListPopLastPushHead',
  1407. 'listPopLastPushHead' => '\Predis\Commands\ListPopLastPushHead',
  1408. /* commands operating on sets */
  1409. 'sadd' => '\Predis\Commands\SetAdd',
  1410. 'setAdd' => '\Predis\Commands\SetAdd',
  1411. 'srem' => '\Predis\Commands\SetRemove',
  1412. 'setRemove' => '\Predis\Commands\SetRemove',
  1413. 'spop' => '\Predis\Commands\SetPop',
  1414. 'setPop' => '\Predis\Commands\SetPop',
  1415. 'smove' => '\Predis\Commands\SetMove',
  1416. 'setMove' => '\Predis\Commands\SetMove',
  1417. 'scard' => '\Predis\Commands\SetCardinality',
  1418. 'setCardinality' => '\Predis\Commands\SetCardinality',
  1419. 'sismember' => '\Predis\Commands\SetIsMember',
  1420. 'setIsMember' => '\Predis\Commands\SetIsMember',
  1421. 'sinter' => '\Predis\Commands\SetIntersection',
  1422. 'setIntersection' => '\Predis\Commands\SetIntersection',
  1423. 'sinterstore' => '\Predis\Commands\SetIntersectionStore',
  1424. 'setIntersectionStore' => '\Predis\Commands\SetIntersectionStore',
  1425. 'sunion' => '\Predis\Commands\SetUnion',
  1426. 'setUnion' => '\Predis\Commands\SetUnion',
  1427. 'sunionstore' => '\Predis\Commands\SetUnionStore',
  1428. 'setUnionStore' => '\Predis\Commands\SetUnionStore',
  1429. 'sdiff' => '\Predis\Commands\SetDifference',
  1430. 'setDifference' => '\Predis\Commands\SetDifference',
  1431. 'sdiffstore' => '\Predis\Commands\SetDifferenceStore',
  1432. 'setDifferenceStore' => '\Predis\Commands\SetDifferenceStore',
  1433. 'smembers' => '\Predis\Commands\SetMembers',
  1434. 'setMembers' => '\Predis\Commands\SetMembers',
  1435. 'srandmember' => '\Predis\Commands\SetRandomMember',
  1436. 'setRandomMember' => '\Predis\Commands\SetRandomMember',
  1437. /* commands operating on sorted sets */
  1438. 'zadd' => '\Predis\Commands\ZSetAdd',
  1439. 'zsetAdd' => '\Predis\Commands\ZSetAdd',
  1440. 'zincrby' => '\Predis\Commands\ZSetIncrementBy',
  1441. 'zsetIncrementBy' => '\Predis\Commands\ZSetIncrementBy',
  1442. 'zrem' => '\Predis\Commands\ZSetRemove',
  1443. 'zsetRemove' => '\Predis\Commands\ZSetRemove',
  1444. 'zrange' => '\Predis\Commands\ZSetRange',
  1445. 'zsetRange' => '\Predis\Commands\ZSetRange',
  1446. 'zrevrange' => '\Predis\Commands\ZSetReverseRange',
  1447. 'zsetReverseRange' => '\Predis\Commands\ZSetReverseRange',
  1448. 'zrangebyscore' => '\Predis\Commands\ZSetRangeByScore',
  1449. 'zsetRangeByScore' => '\Predis\Commands\ZSetRangeByScore',
  1450. 'zcard' => '\Predis\Commands\ZSetCardinality',
  1451. 'zsetCardinality' => '\Predis\Commands\ZSetCardinality',
  1452. 'zscore' => '\Predis\Commands\ZSetScore',
  1453. 'zsetScore' => '\Predis\Commands\ZSetScore',
  1454. 'zremrangebyscore' => '\Predis\Commands\ZSetRemoveRangeByScore',
  1455. 'zsetRemoveRangeByScore' => '\Predis\Commands\ZSetRemoveRangeByScore',
  1456. /* multiple databases handling commands */
  1457. 'select' => '\Predis\Commands\SelectDatabase',
  1458. 'selectDatabase' => '\Predis\Commands\SelectDatabase',
  1459. 'move' => '\Predis\Commands\MoveKey',
  1460. 'moveKey' => '\Predis\Commands\MoveKey',
  1461. 'flushdb' => '\Predis\Commands\FlushDatabase',
  1462. 'flushDatabase' => '\Predis\Commands\FlushDatabase',
  1463. 'flushall' => '\Predis\Commands\FlushAll',
  1464. 'flushDatabases' => '\Predis\Commands\FlushAll',
  1465. /* sorting */
  1466. 'sort' => '\Predis\Commands\Sort',
  1467. /* remote server control commands */
  1468. 'info' => '\Predis\Commands\Info',
  1469. 'slaveof' => '\Predis\Commands\SlaveOf',
  1470. 'slaveOf' => '\Predis\Commands\SlaveOf',
  1471. /* persistence control commands */
  1472. 'save' => '\Predis\Commands\Save',
  1473. 'bgsave' => '\Predis\Commands\BackgroundSave',
  1474. 'backgroundSave' => '\Predis\Commands\BackgroundSave',
  1475. 'lastsave' => '\Predis\Commands\LastSave',
  1476. 'lastSave' => '\Predis\Commands\LastSave',
  1477. 'shutdown' => '\Predis\Commands\Shutdown',
  1478. 'bgrewriteaof' => '\Predis\Commands\BackgroundRewriteAppendOnlyFile',
  1479. 'backgroundRewriteAppendOnlyFile' => '\Predis\Commands\BackgroundRewriteAppendOnlyFile',
  1480. );
  1481. }
  1482. }
  1483. class RedisServer_v2_0 extends RedisServer_v1_2 {
  1484. public function getVersion() { return '2.0'; }
  1485. public function getSupportedCommands() {
  1486. return array_merge(parent::getSupportedCommands(), array(
  1487. /* transactions */
  1488. 'multi' => '\Predis\Commands\Multi',
  1489. 'exec' => '\Predis\Commands\Exec',
  1490. 'discard' => '\Predis\Commands\Discard',
  1491. /* commands operating on string values */
  1492. 'setex' => '\Predis\Commands\SetExpire',
  1493. 'setExpire' => '\Predis\Commands\SetExpire',
  1494. 'append' => '\Predis\Commands\Append',
  1495. 'substr' => '\Predis\Commands\Substr',
  1496. /* commands operating on lists */
  1497. 'blpop' => '\Predis\Commands\ListPopFirstBlocking',
  1498. 'popFirstBlocking' => '\Predis\Commands\ListPopFirstBlocking',
  1499. 'brpop' => '\Predis\Commands\ListPopLastBlocking',
  1500. 'popLastBlocking' => '\Predis\Commands\ListPopLastBlocking',
  1501. /* commands operating on sorted sets */
  1502. 'zunionstore' => '\Predis\Commands\ZSetUnionStore',
  1503. 'zsetUnionStore' => '\Predis\Commands\ZSetUnionStore',
  1504. 'zinterstore' => '\Predis\Commands\ZSetIntersectionStore',
  1505. 'zsetIntersectionStore' => '\Predis\Commands\ZSetIntersectionStore',
  1506. 'zcount' => '\Predis\Commands\ZSetCount',
  1507. 'zsetCount' => '\Predis\Commands\ZSetCount',
  1508. 'zrank' => '\Predis\Commands\ZSetRank',
  1509. 'zsetRank' => '\Predis\Commands\ZSetRank',
  1510. 'zrevrank' => '\Predis\Commands\ZSetReverseRank',
  1511. 'zsetReverseRank' => '\Predis\Commands\ZSetReverseRank',
  1512. 'zremrangebyrank' => '\Predis\Commands\ZSetRemoveRangeByRank',
  1513. 'zsetRemoveRangeByRank' => '\Predis\Commands\ZSetRemoveRangeByRank',
  1514. /* commands operating on hashes */
  1515. 'hset' => '\Predis\Commands\HashSet',
  1516. 'hashSet' => '\Predis\Commands\HashSet',
  1517. 'hsetnx' => '\Predis\Commands\HashSetPreserve',
  1518. 'hashSetPreserve' => '\Predis\Commands\HashSetPreserve',
  1519. 'hmset' => '\Predis\Commands\HashSetMultiple',
  1520. 'hashSetMultiple' => '\Predis\Commands\HashSetMultiple',
  1521. 'hincrby' => '\Predis\Commands\HashIncrementBy',
  1522. 'hashIncrementBy' => '\Predis\Commands\HashIncrementBy',
  1523. 'hget' => '\Predis\Commands\HashGet',
  1524. 'hashGet' => '\Predis\Commands\HashGet',
  1525. 'hmget' => '\Predis\Commands\HashGetMultiple',
  1526. 'hashGetMultiple' => '\Predis\Commands\HashGetMultiple',
  1527. 'hdel' => '\Predis\Commands\HashDelete',
  1528. 'hashDelete' => '\Predis\Commands\HashDelete',
  1529. 'hexists' => '\Predis\Commands\HashExists',
  1530. 'hashExists' => '\Predis\Commands\HashExists',
  1531. 'hlen' => '\Predis\Commands\HashLength',
  1532. 'hashLength' => '\Predis\Commands\HashLength',
  1533. 'hkeys' => '\Predis\Commands\HashKeys',
  1534. 'hashKeys' => '\Predis\Commands\HashKeys',
  1535. 'hvals' => '\Predis\Commands\HashValues',
  1536. 'hashValues' => '\Predis\Commands\HashValues',
  1537. 'hgetall' => '\Predis\Commands\HashGetAll',
  1538. 'hashGetAll' => '\Predis\Commands\HashGetAll',
  1539. /* publish - subscribe */
  1540. 'subscribe' => '\Predis\Commands\Subscribe',
  1541. 'unsubscribe' => '\Predis\Commands\Unsubscribe',
  1542. 'psubscribe' => '\Predis\Commands\SubscribeByPattern',
  1543. 'punsubscribe' => '\Predis\Commands\UnsubscribeByPattern',
  1544. 'publish' => '\Predis\Commands\Publish',
  1545. /* remote server control commands */
  1546. 'config' => '\Predis\Commands\Config',
  1547. 'configuration' => '\Predis\Commands\Config',
  1548. ));
  1549. }
  1550. }
  1551. class RedisServer_vNext extends RedisServer_v2_0 {
  1552. public function getVersion() { return '2.1'; }
  1553. public function getSupportedCommands() {
  1554. return array_merge(parent::getSupportedCommands(), array(
  1555. /* transactions */
  1556. 'watch' => '\Predis\Commands\Watch',
  1557. 'unwatch' => '\Predis\Commands\Unwatch',
  1558. /* commands operating on string values */
  1559. 'strlen' => '\Predis\Commands\Strlen',
  1560. 'setrange' => '\Predis\Commands\SetRange',
  1561. 'getrange' => '\Predis\Commands\Substr',
  1562. 'setbit' => '\Predis\Commands\SetBit',
  1563. /* commands operating on the key space */
  1564. 'persist' => '\Predis\Commands\Persist',
  1565. /* commands operating on lists */
  1566. 'rpushx' => '\Predis\Commands\ListPushTailX',
  1567. 'lpushx' => '\Predis\Commands\ListPushHeadX',
  1568. 'linsert' => '\Predis\Commands\ListInsert',
  1569. /* commands operating on sorted sets */
  1570. 'zrevrangebyscore' => '\Predis\Commands\ZSetReverseRangeByScore',
  1571. ));
  1572. }
  1573. }
  1574. /* ------------------------------------------------------------------------- */
  1575. namespace Predis\Pipeline;
  1576. interface IPipelineExecutor {
  1577. public function execute(\Predis\IConnection $connection, &$commands);
  1578. }
  1579. class StandardExecutor implements IPipelineExecutor {
  1580. public function execute(\Predis\IConnection $connection, &$commands) {
  1581. $sizeofPipe = count($commands);
  1582. $values = array();
  1583. foreach ($commands as $command) {
  1584. $connection->writeCommand($command);
  1585. }
  1586. try {
  1587. for ($i = 0; $i < $sizeofPipe; $i++) {
  1588. $response = $connection->readResponse($commands[$i]);
  1589. $values[] = $response instanceof \Iterator
  1590. ? iterator_to_array($response)
  1591. : $response;
  1592. unset($commands[$i]);
  1593. }
  1594. }
  1595. catch (\Predis\ServerException $exception) {
  1596. // force disconnection to prevent protocol desynchronization
  1597. $connection->disconnect();
  1598. throw $exception;
  1599. }
  1600. return $values;
  1601. }
  1602. }
  1603. class SafeExecutor implements IPipelineExecutor {
  1604. public function execute(\Predis\IConnection $connection, &$commands) {
  1605. $sizeofPipe = count($commands);
  1606. $values = array();
  1607. foreach ($commands as $command) {
  1608. try {
  1609. $connection->writeCommand($command);
  1610. }
  1611. catch (\Predis\CommunicationException $exception) {
  1612. return array_fill(0, $sizeofPipe, $exception);
  1613. }
  1614. }
  1615. for ($i = 0; $i < $sizeofPipe; $i++) {
  1616. $command = $commands[$i];
  1617. unset($commands[$i]);
  1618. try {
  1619. $response = $connection->readResponse($command);
  1620. $values[] = ($response instanceof \Iterator
  1621. ? iterator_to_array($response)
  1622. : $response
  1623. );
  1624. }
  1625. catch (\Predis\ServerException $exception) {
  1626. $values[] = $exception->toResponseError();
  1627. }
  1628. catch (\Predis\CommunicationException $exception) {
  1629. $toAdd = count($commands) - count($values);
  1630. $values = array_merge($values, array_fill(0, $toAdd, $exception));
  1631. break;
  1632. }
  1633. }
  1634. return $values;
  1635. }
  1636. }
  1637. class SafeClusterExecutor implements IPipelineExecutor {
  1638. public function execute(\Predis\IConnection $connection, &$commands) {
  1639. $connectionExceptions = array();
  1640. $sizeofPipe = count($commands);
  1641. $values = array();
  1642. foreach ($commands as $command) {
  1643. $cmdConnection = $connection->getConnection($command);
  1644. if (isset($connectionExceptions[spl_object_hash($cmdConnection)])) {
  1645. continue;
  1646. }
  1647. try {
  1648. $cmdConnection->writeCommand($command);
  1649. }
  1650. catch (\Predis\CommunicationException $exception) {
  1651. $connectionExceptions[spl_object_hash($cmdConnection)] = $exception;
  1652. }
  1653. }
  1654. for ($i = 0; $i < $sizeofPipe; $i++) {
  1655. $command = $commands[$i];
  1656. unset($commands[$i]);
  1657. $cmdConnection = $connection->getConnection($command);
  1658. $connectionObjectHash = spl_object_hash($cmdConnection);
  1659. if (isset($connectionExceptions[$connectionObjectHash])) {
  1660. $values[] = $connectionExceptions[$connectionObjectHash];
  1661. continue;
  1662. }
  1663. try {
  1664. $response = $cmdConnection->readResponse($command);
  1665. $values[] = ($response instanceof \Iterator
  1666. ? iterator_to_array($response)
  1667. : $response
  1668. );
  1669. }
  1670. catch (\Predis\ServerException $exception) {
  1671. $values[] = $exception->toResponseError();
  1672. }
  1673. catch (\Predis\CommunicationException $exception) {
  1674. $values[] = $exception;
  1675. $connectionExceptions[$connectionObjectHash] = $exception;
  1676. }
  1677. }
  1678. return $values;
  1679. }
  1680. }
  1681. /* ------------------------------------------------------------------------- */
  1682. namespace Predis\Distribution;
  1683. interface IDistributionStrategy {
  1684. public function add($node, $weight = null);
  1685. public function remove($node);
  1686. public function get($key);
  1687. public function generateKey($value);
  1688. }
  1689. class EmptyRingException extends \Exception { }
  1690. class HashRing implements IDistributionStrategy {
  1691. const DEFAULT_REPLICAS = 128;
  1692. const DEFAULT_WEIGHT = 100;
  1693. private $_nodes, $_ring, $_ringKeys, $_ringKeysCount, $_replicas;
  1694. public function __construct($replicas = self::DEFAULT_REPLICAS) {
  1695. $this->_replicas = $replicas;
  1696. $this->_nodes = array();
  1697. }
  1698. public function add($node, $weight = null) {
  1699. // NOTE: in case of collisions in the hashes of the nodes, the node added
  1700. // last wins, thus the order in which nodes are added is significant.
  1701. $this->_nodes[] = array('object' => $node, 'weight' => (int) $weight ?: $this::DEFAULT_WEIGHT);
  1702. $this->reset();
  1703. }
  1704. public function remove($node) {
  1705. // NOTE: a node is removed by resetting the ring so that it's recreated from
  1706. // scratch, in order to reassign possible hashes with collisions to the
  1707. // right node according to the order in which they were added in the
  1708. // first place.
  1709. for ($i = 0; $i < count($this->_nodes); ++$i) {
  1710. if ($this->_nodes[$i]['object'] === $node) {
  1711. array_splice($this->_nodes, $i, 1);
  1712. $this->reset();
  1713. break;
  1714. }
  1715. }
  1716. }
  1717. private function reset() {
  1718. unset($this->_ring);
  1719. unset($this->_ringKeys);
  1720. unset($this->_ringKeysCount);
  1721. }
  1722. private function isInitialized() {
  1723. return isset($this->_ringKeys);
  1724. }
  1725. private function computeTotalWeight() {
  1726. // TODO: array_reduce + lambda for PHP 5.3
  1727. $totalWeight = 0;
  1728. foreach ($this->_nodes as $node) {
  1729. $totalWeight += $node['weight'];
  1730. }
  1731. return $totalWeight;
  1732. }
  1733. private function initialize() {
  1734. if ($this->isInitialized()) {
  1735. return;
  1736. }
  1737. if (count($this->_nodes) === 0) {
  1738. throw new EmptyRingException('Cannot initialize empty hashring');
  1739. }
  1740. $this->_ring = array();
  1741. $totalWeight = $this->computeTotalWeight();
  1742. $nodesCount = count($this->_nodes);
  1743. foreach ($this->_nodes as $node) {
  1744. $weightRatio = $node['weight'] / $totalWeight;
  1745. $this->addNodeToRing($this->_ring, $node, $nodesCount, $this->_replicas, $weightRatio);
  1746. }
  1747. ksort($this->_ring, SORT_NUMERIC);
  1748. $this->_ringKeys = array_keys($this->_ring);
  1749. $this->_ringKeysCount = count($this->_ringKeys);
  1750. }
  1751. protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio) {
  1752. $nodeObject = $node['object'];
  1753. $nodeHash = (string) $nodeObject;
  1754. $replicas = (int) round($weightRatio * $totalNodes * $replicas);
  1755. for ($i = 0; $i < $replicas; $i++) {
  1756. $key = crc32("$nodeHash:$i");
  1757. $ring[$key] = $nodeObject;
  1758. }
  1759. }
  1760. public function generateKey($value) {
  1761. return crc32($value);
  1762. }
  1763. public function get($key) {
  1764. return $this->_ring[$this->getNodeKey($key)];
  1765. }
  1766. private function getNodeKey($key) {
  1767. $this->initialize();
  1768. $ringKeys = $this->_ringKeys;
  1769. $upper = $this->_ringKeysCount - 1;
  1770. $lower = 0;
  1771. while ($lower <= $upper) {
  1772. $index = ($lower + $upper) >> 1;
  1773. $item = $ringKeys[$index];
  1774. if ($item > $key) {
  1775. $upper = $index - 1;
  1776. }
  1777. else if ($item < $key) {
  1778. $lower = $index + 1;
  1779. }
  1780. else {
  1781. return $item;
  1782. }
  1783. }
  1784. return $ringKeys[$this->wrapAroundStrategy($upper, $lower, $this->_ringKeysCount)];
  1785. }
  1786. protected function wrapAroundStrategy($upper, $lower, $ringKeysCount) {
  1787. // NOTE: binary search for the last item in _ringkeys with a value
  1788. // less or equal to the key. If no such item exists, return the
  1789. // last item.
  1790. return $upper >= 0 ? $upper : $ringKeysCount - 1;
  1791. }
  1792. }
  1793. class KetamaPureRing extends HashRing {
  1794. const DEFAULT_REPLICAS = 160;
  1795. public function __construct() {
  1796. parent::__construct($this::DEFAULT_REPLICAS);
  1797. }
  1798. protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio) {
  1799. $nodeObject = $node['object'];
  1800. $nodeHash = (string) $nodeObject;
  1801. $replicas = (int) floor($weightRatio * $totalNodes * ($replicas / 4));
  1802. for ($i = 0; $i < $replicas; $i++) {
  1803. $unpackedDigest = unpack('V4', md5("$nodeHash-$i", true));
  1804. foreach ($unpackedDigest as $key) {
  1805. $ring[$key] = $nodeObject;
  1806. }
  1807. }
  1808. }
  1809. public function generateKey($value) {
  1810. $hash = unpack('V', md5($value, true));
  1811. return $hash[1];
  1812. }
  1813. protected function wrapAroundStrategy($upper, $lower, $ringKeysCount) {
  1814. // NOTE: binary search for the first item in _ringkeys with a value
  1815. // greater or equal to the key. If no such item exists, return the
  1816. // first item.
  1817. return $lower < $ringKeysCount ? $lower : 0;
  1818. }
  1819. }
  1820. /* ------------------------------------------------------------------------- */
  1821. namespace Predis\Shared;
  1822. class Utils {
  1823. public static function isCluster(\Predis\IConnection $connection) {
  1824. return $connection instanceof \Predis\ConnectionCluster;
  1825. }
  1826. public static function onCommunicationException(\Predis\CommunicationException $exception) {
  1827. if ($exception->shouldResetConnection()) {
  1828. $connection = $exception->getConnection();
  1829. if ($connection->isConnected()) {
  1830. $connection->disconnect();
  1831. }
  1832. }
  1833. throw $exception;
  1834. }
  1835. }
  1836. abstract class MultiBulkResponseIteratorBase implements \Iterator, \Countable {
  1837. protected $_position, $_current, $_replySize;
  1838. public function rewind() {
  1839. // NOOP
  1840. }
  1841. public function current() {
  1842. return $this->_current;
  1843. }
  1844. public function key() {
  1845. return $this->_position;
  1846. }
  1847. public function next() {
  1848. if (++$this->_position < $this->_replySize) {
  1849. $this->_current = $this->getValue();
  1850. }
  1851. return $this->_position;
  1852. }
  1853. public function valid() {
  1854. return $this->_position < $this->_replySize;
  1855. }
  1856. public function count() {
  1857. // NOTE: use count if you want to get the size of the current multi-bulk
  1858. // response without using iterator_count (which actually consumes
  1859. // our iterator to calculate the size, and we cannot perform a rewind)
  1860. return $this->_replySize;
  1861. }
  1862. protected abstract function getValue();
  1863. }
  1864. class MultiBulkResponseIterator extends MultiBulkResponseIteratorBase {
  1865. private $_connection;
  1866. public function __construct(\Predis\Connection $connection, $size) {
  1867. $this->_connection = $connection;
  1868. $this->_reader = $connection->getResponseReader();
  1869. $this->_position = 0;
  1870. $this->_current = $size > 0 ? $this->getValue() : null;
  1871. $this->_replySize = $size;
  1872. }
  1873. public function __destruct() {
  1874. // when the iterator is garbage-collected (e.g. it goes out of the
  1875. // scope of a foreach) but it has not reached its end, we must sync
  1876. // the client with the queued elements that have not been read from
  1877. // the connection with the server.
  1878. $this->sync();
  1879. }
  1880. public function sync($drop = false) {
  1881. if ($drop == true) {
  1882. if ($this->valid()) {
  1883. $this->_position = $this->_replySize;
  1884. $this->_connection->disconnect();
  1885. }
  1886. }
  1887. else {
  1888. while ($this->valid()) {
  1889. $this->next();
  1890. }
  1891. }
  1892. }
  1893. protected function getValue() {
  1894. return $this->_reader->read($this->_connection);
  1895. }
  1896. }
  1897. class MultiBulkResponseKVIterator extends MultiBulkResponseIteratorBase {
  1898. private $_iterator;
  1899. public function __construct(MultiBulkResponseIterator $iterator) {
  1900. $virtualSize = count($iterator) / 2;
  1901. $this->_iterator = $iterator;
  1902. $this->_position = 0;
  1903. $this->_current = $virtualSize > 0 ? $this->getValue() : null;
  1904. $this->_replySize = $virtualSize;
  1905. }
  1906. public function __destruct() {
  1907. $this->_iterator->sync();
  1908. }
  1909. protected function getValue() {
  1910. $k = $this->_iterator->current();
  1911. $this->_iterator->next();
  1912. $v = $this->_iterator->current();
  1913. $this->_iterator->next();
  1914. return array($k, $v);
  1915. }
  1916. }
  1917. /* ------------------------------------------------------------------------- */
  1918. namespace Predis\Commands;
  1919. /* miscellaneous commands */
  1920. class Ping extends \Predis\MultiBulkCommand {
  1921. public function canBeHashed() { return false; }
  1922. public function getCommandId() { return 'PING'; }
  1923. public function parseResponse($data) {
  1924. return $data === 'PONG' ? true : false;
  1925. }
  1926. }
  1927. class DoEcho extends \Predis\MultiBulkCommand {
  1928. public function canBeHashed() { return false; }
  1929. public function getCommandId() { return 'ECHO'; }
  1930. }
  1931. class Auth extends \Predis\MultiBulkCommand {
  1932. public function canBeHashed() { return false; }
  1933. public function getCommandId() { return 'AUTH'; }
  1934. }
  1935. /* connection handling */
  1936. class Quit extends \Predis\MultiBulkCommand {
  1937. public function canBeHashed() { return false; }
  1938. public function getCommandId() { return 'QUIT'; }
  1939. public function closesConnection() { return true; }
  1940. }
  1941. /* commands operating on string values */
  1942. class Set extends \Predis\MultiBulkCommand {
  1943. public function getCommandId() { return 'SET'; }
  1944. }
  1945. class SetExpire extends \Predis\MultiBulkCommand {
  1946. public function getCommandId() { return 'SETEX'; }
  1947. }
  1948. class SetPreserve extends \Predis\MultiBulkCommand {
  1949. public function getCommandId() { return 'SETNX'; }
  1950. public function parseResponse($data) { return (bool) $data; }
  1951. }
  1952. class SetMultiple extends \Predis\MultiBulkCommand {
  1953. public function canBeHashed() { return false; }
  1954. public function getCommandId() { return 'MSET'; }
  1955. public function filterArguments(Array $arguments) {
  1956. if (count($arguments) === 1 && is_array($arguments[0])) {
  1957. $flattenedKVs = array();
  1958. $args = &$arguments[0];
  1959. foreach ($args as $k => $v) {
  1960. $flattenedKVs[] = $k;
  1961. $flattenedKVs[] = $v;
  1962. }
  1963. return $flattenedKVs;
  1964. }
  1965. return $arguments;
  1966. }
  1967. }
  1968. class SetMultiplePreserve extends \Predis\Commands\SetMultiple {
  1969. public function canBeHashed() { return false; }
  1970. public function getCommandId() { return 'MSETNX'; }
  1971. public function parseResponse($data) { return (bool) $data; }
  1972. }
  1973. class Get extends \Predis\MultiBulkCommand {
  1974. public function getCommandId() { return 'GET'; }
  1975. }
  1976. class GetMultiple extends \Predis\MultiBulkCommand {
  1977. public function canBeHashed() { return false; }
  1978. public function getCommandId() { return 'MGET'; }
  1979. }
  1980. class GetSet extends \Predis\MultiBulkCommand {
  1981. public function getCommandId() { return 'GETSET'; }
  1982. }
  1983. class Increment extends \Predis\MultiBulkCommand {
  1984. public function getCommandId() { return 'INCR'; }
  1985. }
  1986. class IncrementBy extends \Predis\MultiBulkCommand {
  1987. public function getCommandId() { return 'INCRBY'; }
  1988. }
  1989. class Decrement extends \Predis\MultiBulkCommand {
  1990. public function getCommandId() { return 'DECR'; }
  1991. }
  1992. class DecrementBy extends \Predis\MultiBulkCommand {
  1993. public function getCommandId() { return 'DECRBY'; }
  1994. }
  1995. class Exists extends \Predis\MultiBulkCommand {
  1996. public function getCommandId() { return 'EXISTS'; }
  1997. public function parseResponse($data) { return (bool) $data; }
  1998. }
  1999. class Delete extends \Predis\MultiBulkCommand {
  2000. public function getCommandId() { return 'DEL'; }
  2001. }
  2002. class Type extends \Predis\MultiBulkCommand {
  2003. public function getCommandId() { return 'TYPE'; }
  2004. }
  2005. class Append extends \Predis\MultiBulkCommand {
  2006. public function getCommandId() { return 'APPEND'; }
  2007. }
  2008. class SetRange extends \Predis\MultiBulkCommand {
  2009. public function getCommandId() { return 'SETRANGE'; }
  2010. }
  2011. class Substr extends \Predis\MultiBulkCommand {
  2012. public function getCommandId() { return 'SUBSTR'; }
  2013. }
  2014. class SetBit extends \Predis\MultiBulkCommand {
  2015. public function getCommandId() { return 'SETBIT'; }
  2016. }
  2017. class Strlen extends \Predis\MultiBulkCommand {
  2018. public function getCommandId() { return 'STRLEN'; }
  2019. }
  2020. /* commands operating on the key space */
  2021. class Keys extends \Predis\MultiBulkCommand {
  2022. public function canBeHashed() { return false; }
  2023. public function getCommandId() { return 'KEYS'; }
  2024. public function parseResponse($data) {
  2025. // TODO: is this behaviour correct?
  2026. if (is_array($data) || $data instanceof \Iterator) {
  2027. return $data;
  2028. }
  2029. return strlen($data) > 0 ? explode(' ', $data) : array();
  2030. }
  2031. }
  2032. class RandomKey extends \Predis\MultiBulkCommand {
  2033. public function canBeHashed() { return false; }
  2034. public function getCommandId() { return 'RANDOMKEY'; }
  2035. public function parseResponse($data) { return $data !== '' ? $data : null; }
  2036. }
  2037. class Rename extends \Predis\MultiBulkCommand {
  2038. public function canBeHashed() { return false; }
  2039. public function getCommandId() { return 'RENAME'; }
  2040. }
  2041. class RenamePreserve extends \Predis\MultiBulkCommand {
  2042. public function canBeHashed() { return false; }
  2043. public function getCommandId() { return 'RENAMENX'; }
  2044. public function parseResponse($data) { return (bool) $data; }
  2045. }
  2046. class Expire extends \Predis\MultiBulkCommand {
  2047. public function getCommandId() { return 'EXPIRE'; }
  2048. public function parseResponse($data) { return (bool) $data; }
  2049. }
  2050. class ExpireAt extends \Predis\MultiBulkCommand {
  2051. public function getCommandId() { return 'EXPIREAT'; }
  2052. public function parseResponse($data) { return (bool) $data; }
  2053. }
  2054. class Persist extends \Predis\MultiBulkCommand {
  2055. public function getCommandId() { return 'PERSIST'; }
  2056. public function parseResponse($data) { return (bool) $data; }
  2057. }
  2058. class DatabaseSize extends \Predis\MultiBulkCommand {
  2059. public function canBeHashed() { return false; }
  2060. public function getCommandId() { return 'DBSIZE'; }
  2061. }
  2062. class TimeToLive extends \Predis\MultiBulkCommand {
  2063. public function getCommandId() { return 'TTL'; }
  2064. }
  2065. /* commands operating on lists */
  2066. class ListPushTail extends \Predis\MultiBulkCommand {
  2067. public function getCommandId() { return 'RPUSH'; }
  2068. }
  2069. class ListPushTailX extends \Predis\MultiBulkCommand {
  2070. public function getCommandId() { return 'RPUSHX'; }
  2071. }
  2072. class ListPushHead extends \Predis\MultiBulkCommand {
  2073. public function getCommandId() { return 'LPUSH'; }
  2074. }
  2075. class ListPushHeadX extends \Predis\MultiBulkCommand {
  2076. public function getCommandId() { return 'LPUSHX'; }
  2077. }
  2078. class ListLength extends \Predis\MultiBulkCommand {
  2079. public function getCommandId() { return 'LLEN'; }
  2080. }
  2081. class ListRange extends \Predis\MultiBulkCommand {
  2082. public function getCommandId() { return 'LRANGE'; }
  2083. }
  2084. class ListTrim extends \Predis\MultiBulkCommand {
  2085. public function getCommandId() { return 'LTRIM'; }
  2086. }
  2087. class ListIndex extends \Predis\MultiBulkCommand {
  2088. public function getCommandId() { return 'LINDEX'; }
  2089. }
  2090. class ListSet extends \Predis\MultiBulkCommand {
  2091. public function getCommandId() { return 'LSET'; }
  2092. }
  2093. class ListRemove extends \Predis\MultiBulkCommand {
  2094. public function getCommandId() { return 'LREM'; }
  2095. }
  2096. class ListPopLastPushHead extends \Predis\MultiBulkCommand {
  2097. public function getCommandId() { return 'RPOPLPUSH'; }
  2098. }
  2099. class ListPopLastPushHeadBulk extends \Predis\MultiBulkCommand {
  2100. public function getCommandId() { return 'RPOPLPUSH'; }
  2101. }
  2102. class ListPopFirst extends \Predis\MultiBulkCommand {
  2103. public function getCommandId() { return 'LPOP'; }
  2104. }
  2105. class ListPopLast extends \Predis\MultiBulkCommand {
  2106. public function getCommandId() { return 'RPOP'; }
  2107. }
  2108. class ListPopFirstBlocking extends \Predis\MultiBulkCommand {
  2109. public function getCommandId() { return 'BLPOP'; }
  2110. }
  2111. class ListPopLastBlocking extends \Predis\MultiBulkCommand {
  2112. public function getCommandId() { return 'BRPOP'; }
  2113. }
  2114. class ListInsert extends \Predis\MultiBulkCommand {
  2115. public function getCommandId() { return 'LINSERT'; }
  2116. }
  2117. /* commands operating on sets */
  2118. class SetAdd extends \Predis\MultiBulkCommand {
  2119. public function getCommandId() { return 'SADD'; }
  2120. public function parseResponse($data) { return (bool) $data; }
  2121. }
  2122. class SetRemove extends \Predis\MultiBulkCommand {
  2123. public function getCommandId() { return 'SREM'; }
  2124. public function parseResponse($data) { return (bool) $data; }
  2125. }
  2126. class SetPop extends \Predis\MultiBulkCommand {
  2127. public function getCommandId() { return 'SPOP'; }
  2128. }
  2129. class SetMove extends \Predis\MultiBulkCommand {
  2130. public function canBeHashed() { return false; }
  2131. public function getCommandId() { return 'SMOVE'; }
  2132. public function parseResponse($data) { return (bool) $data; }
  2133. }
  2134. class SetCardinality extends \Predis\MultiBulkCommand {
  2135. public function getCommandId() { return 'SCARD'; }
  2136. }
  2137. class SetIsMember extends \Predis\MultiBulkCommand {
  2138. public function getCommandId() { return 'SISMEMBER'; }
  2139. public function parseResponse($data) { return (bool) $data; }
  2140. }
  2141. class SetIntersection extends \Predis\MultiBulkCommand {
  2142. public function getCommandId() { return 'SINTER'; }
  2143. }
  2144. class SetIntersectionStore extends \Predis\MultiBulkCommand {
  2145. public function getCommandId() { return 'SINTERSTORE'; }
  2146. }
  2147. class SetUnion extends \Predis\MultiBulkCommand {
  2148. public function getCommandId() { return 'SUNION'; }
  2149. }
  2150. class SetUnionStore extends \Predis\MultiBulkCommand {
  2151. public function getCommandId() { return 'SUNIONSTORE'; }
  2152. }
  2153. class SetDifference extends \Predis\MultiBulkCommand {
  2154. public function getCommandId() { return 'SDIFF'; }
  2155. }
  2156. class SetDifferenceStore extends \Predis\MultiBulkCommand {
  2157. public function getCommandId() { return 'SDIFFSTORE'; }
  2158. }
  2159. class SetMembers extends \Predis\MultiBulkCommand {
  2160. public function getCommandId() { return 'SMEMBERS'; }
  2161. }
  2162. class SetRandomMember extends \Predis\MultiBulkCommand {
  2163. public function getCommandId() { return 'SRANDMEMBER'; }
  2164. }
  2165. /* commands operating on sorted sets */
  2166. class ZSetAdd extends \Predis\MultiBulkCommand {
  2167. public function getCommandId() { return 'ZADD'; }
  2168. public function parseResponse($data) { return (bool) $data; }
  2169. }
  2170. class ZSetIncrementBy extends \Predis\MultiBulkCommand {
  2171. public function getCommandId() { return 'ZINCRBY'; }
  2172. }
  2173. class ZSetRemove extends \Predis\MultiBulkCommand {
  2174. public function getCommandId() { return 'ZREM'; }
  2175. public function parseResponse($data) { return (bool) $data; }
  2176. }
  2177. class ZSetUnionStore extends \Predis\MultiBulkCommand {
  2178. public function getCommandId() { return 'ZUNIONSTORE'; }
  2179. public function filterArguments(Array $arguments) {
  2180. $options = array();
  2181. $argc = count($arguments);
  2182. if ($argc > 1 && is_array($arguments[$argc - 1])) {
  2183. $options = $this->prepareOptions(array_pop($arguments));
  2184. }
  2185. $args = is_array($arguments[0]) ? $arguments[0] : $arguments;
  2186. return array_merge($args, $options);
  2187. }
  2188. private function prepareOptions($options) {
  2189. $opts = array_change_key_case($options, CASE_UPPER);
  2190. $finalizedOpts = array();
  2191. if (isset($opts['WEIGHTS']) && is_array($opts['WEIGHTS'])) {
  2192. $finalizedOpts[] = 'WEIGHTS';
  2193. foreach ($opts['WEIGHTS'] as $weight) {
  2194. $finalizedOpts[] = $weight;
  2195. }
  2196. }
  2197. if (isset($opts['AGGREGATE'])) {
  2198. $finalizedOpts[] = 'AGGREGATE';
  2199. $finalizedOpts[] = $opts['AGGREGATE'];
  2200. }
  2201. return $finalizedOpts;
  2202. }
  2203. }
  2204. class ZSetIntersectionStore extends \Predis\Commands\ZSetUnionStore {
  2205. public function getCommandId() { return 'ZINTERSTORE'; }
  2206. }
  2207. class ZSetRange extends \Predis\MultiBulkCommand {
  2208. private $_withScores = false;
  2209. public function getCommandId() { return 'ZRANGE'; }
  2210. public function filterArguments(Array $arguments) {
  2211. if (count($arguments) === 4) {
  2212. $lastType = gettype($arguments[3]);
  2213. if ($lastType === 'string' && strtolower($arguments[3]) === 'withscores') {
  2214. // used for compatibility with older versions
  2215. $arguments[3] = array('WITHSCORES' => true);
  2216. $lastType = 'array';
  2217. }
  2218. if ($lastType === 'array') {
  2219. $options = $this->prepareOptions(array_pop($arguments));
  2220. return array_merge($arguments, $options);
  2221. }
  2222. }
  2223. return $arguments;
  2224. }
  2225. protected function prepareOptions($options) {
  2226. $opts = array_change_key_case($options, CASE_UPPER);
  2227. $finalizedOpts = array();
  2228. if (isset($opts['WITHSCORES'])) {
  2229. $finalizedOpts[] = 'WITHSCORES';
  2230. $this->_withScores = true;
  2231. }
  2232. return $finalizedOpts;
  2233. }
  2234. public function parseResponse($data) {
  2235. if ($this->_withScores) {
  2236. if ($data instanceof \Iterator) {
  2237. return new \Predis\Shared\MultiBulkResponseKVIterator($data);
  2238. }
  2239. $result = array();
  2240. for ($i = 0; $i < count($data); $i++) {
  2241. $result[] = array($data[$i], $data[++$i]);
  2242. }
  2243. return $result;
  2244. }
  2245. return $data;
  2246. }
  2247. }
  2248. class ZSetReverseRange extends \Predis\Commands\ZSetRange {
  2249. public function getCommandId() { return 'ZREVRANGE'; }
  2250. }
  2251. class ZSetRangeByScore extends \Predis\Commands\ZSetRange {
  2252. public function getCommandId() { return 'ZRANGEBYSCORE'; }
  2253. protected function prepareOptions($options) {
  2254. $opts = array_change_key_case($options, CASE_UPPER);
  2255. $finalizedOpts = array();
  2256. if (isset($opts['LIMIT']) && is_array($opts['LIMIT'])) {
  2257. $limit = array_change_key_case($opts['LIMIT'], CASE_UPPER);
  2258. $finalizedOpts[] = 'LIMIT';
  2259. $finalizedOpts[] = isset($limit['OFFSET']) ? $limit['OFFSET'] : $limit[0];
  2260. $finalizedOpts[] = isset($limit['COUNT']) ? $limit['COUNT'] : $limit[1];
  2261. }
  2262. return array_merge($finalizedOpts, parent::prepareOptions($options));
  2263. }
  2264. }
  2265. class ZSetReverseRangeByScore extends \Predis\Commands\ZSetRangeByScore {
  2266. public function getCommandId() { return 'ZREVRANGEBYSCORE'; }
  2267. }
  2268. class ZSetCount extends \Predis\MultiBulkCommand {
  2269. public function getCommandId() { return 'ZCOUNT'; }
  2270. }
  2271. class ZSetCardinality extends \Predis\MultiBulkCommand {
  2272. public function getCommandId() { return 'ZCARD'; }
  2273. }
  2274. class ZSetScore extends \Predis\MultiBulkCommand {
  2275. public function getCommandId() { return 'ZSCORE'; }
  2276. }
  2277. class ZSetRemoveRangeByScore extends \Predis\MultiBulkCommand {
  2278. public function getCommandId() { return 'ZREMRANGEBYSCORE'; }
  2279. }
  2280. class ZSetRank extends \Predis\MultiBulkCommand {
  2281. public function getCommandId() { return 'ZRANK'; }
  2282. }
  2283. class ZSetReverseRank extends \Predis\MultiBulkCommand {
  2284. public function getCommandId() { return 'ZREVRANK'; }
  2285. }
  2286. class ZSetRemoveRangeByRank extends \Predis\MultiBulkCommand {
  2287. public function getCommandId() { return 'ZREMRANGEBYRANK'; }
  2288. }
  2289. /* commands operating on hashes */
  2290. class HashSet extends \Predis\MultiBulkCommand {
  2291. public function getCommandId() { return 'HSET'; }
  2292. public function parseResponse($data) { return (bool) $data; }
  2293. }
  2294. class HashSetPreserve extends \Predis\MultiBulkCommand {
  2295. public function getCommandId() { return 'HSETNX'; }
  2296. public function parseResponse($data) { return (bool) $data; }
  2297. }
  2298. class HashSetMultiple extends \Predis\MultiBulkCommand {
  2299. public function getCommandId() { return 'HMSET'; }
  2300. public function filterArguments(Array $arguments) {
  2301. if (count($arguments) === 2 && is_array($arguments[1])) {
  2302. $flattenedKVs = array($arguments[0]);
  2303. $args = &$arguments[1];
  2304. foreach ($args as $k => $v) {
  2305. $flattenedKVs[] = $k;
  2306. $flattenedKVs[] = $v;
  2307. }
  2308. return $flattenedKVs;
  2309. }
  2310. return $arguments;
  2311. }
  2312. }
  2313. class HashIncrementBy extends \Predis\MultiBulkCommand {
  2314. public function getCommandId() { return 'HINCRBY'; }
  2315. }
  2316. class HashGet extends \Predis\MultiBulkCommand {
  2317. public function getCommandId() { return 'HGET'; }
  2318. }
  2319. class HashGetMultiple extends \Predis\MultiBulkCommand {
  2320. public function getCommandId() { return 'HMGET'; }
  2321. public function filterArguments(Array $arguments) {
  2322. if (count($arguments) === 2 && is_array($arguments[1])) {
  2323. $flattenedKVs = array($arguments[0]);
  2324. $args = &$arguments[1];
  2325. foreach ($args as $v) {
  2326. $flattenedKVs[] = $v;
  2327. }
  2328. return $flattenedKVs;
  2329. }
  2330. return $arguments;
  2331. }
  2332. }
  2333. class HashDelete extends \Predis\MultiBulkCommand {
  2334. public function getCommandId() { return 'HDEL'; }
  2335. public function parseResponse($data) { return (bool) $data; }
  2336. }
  2337. class HashExists extends \Predis\MultiBulkCommand {
  2338. public function getCommandId() { return 'HEXISTS'; }
  2339. public function parseResponse($data) { return (bool) $data; }
  2340. }
  2341. class HashLength extends \Predis\MultiBulkCommand {
  2342. public function getCommandId() { return 'HLEN'; }
  2343. }
  2344. class HashKeys extends \Predis\MultiBulkCommand {
  2345. public function getCommandId() { return 'HKEYS'; }
  2346. }
  2347. class HashValues extends \Predis\MultiBulkCommand {
  2348. public function getCommandId() { return 'HVALS'; }
  2349. }
  2350. class HashGetAll extends \Predis\MultiBulkCommand {
  2351. public function getCommandId() { return 'HGETALL'; }
  2352. public function parseResponse($data) {
  2353. if ($data instanceof \Iterator) {
  2354. return new \Predis\Shared\MultiBulkResponseKVIterator($data);
  2355. }
  2356. $result = array();
  2357. for ($i = 0; $i < count($data); $i++) {
  2358. $result[$data[$i]] = $data[++$i];
  2359. }
  2360. return $result;
  2361. }
  2362. }
  2363. /* multiple databases handling commands */
  2364. class SelectDatabase extends \Predis\MultiBulkCommand {
  2365. public function canBeHashed() { return false; }
  2366. public function getCommandId() { return 'SELECT'; }
  2367. }
  2368. class MoveKey extends \Predis\MultiBulkCommand {
  2369. public function canBeHashed() { return false; }
  2370. public function getCommandId() { return 'MOVE'; }
  2371. public function parseResponse($data) { return (bool) $data; }
  2372. }
  2373. class FlushDatabase extends \Predis\MultiBulkCommand {
  2374. public function canBeHashed() { return false; }
  2375. public function getCommandId() { return 'FLUSHDB'; }
  2376. }
  2377. class FlushAll extends \Predis\MultiBulkCommand {
  2378. public function canBeHashed() { return false; }
  2379. public function getCommandId() { return 'FLUSHALL'; }
  2380. }
  2381. /* sorting */
  2382. class Sort extends \Predis\MultiBulkCommand {
  2383. public function getCommandId() { return 'SORT'; }
  2384. public function filterArguments(Array $arguments) {
  2385. if (count($arguments) === 1) {
  2386. return $arguments;
  2387. }
  2388. $query = array($arguments[0]);
  2389. $sortParams = array_change_key_case($arguments[1], CASE_UPPER);
  2390. if (isset($sortParams['BY'])) {
  2391. $query[] = 'BY';
  2392. $query[] = $sortParams['BY'];
  2393. }
  2394. if (isset($sortParams['GET'])) {
  2395. $getargs = $sortParams['GET'];
  2396. if (is_array($getargs)) {
  2397. foreach ($getargs as $getarg) {
  2398. $query[] = 'GET';
  2399. $query[] = $getarg;
  2400. }
  2401. }
  2402. else {
  2403. $query[] = 'GET';
  2404. $query[] = $getargs;
  2405. }
  2406. }
  2407. if (isset($sortParams['LIMIT']) && is_array($sortParams['LIMIT'])
  2408. && count($sortParams['LIMIT']) == 2) {
  2409. $query[] = 'LIMIT';
  2410. $query[] = $sortParams['LIMIT'][0];
  2411. $query[] = $sortParams['LIMIT'][1];
  2412. }
  2413. if (isset($sortParams['SORT'])) {
  2414. $query[] = strtoupper($sortParams['SORT']);
  2415. }
  2416. if (isset($sortParams['ALPHA']) && $sortParams['ALPHA'] == true) {
  2417. $query[] = 'ALPHA';
  2418. }
  2419. if (isset($sortParams['STORE'])) {
  2420. $query[] = 'STORE';
  2421. $query[] = $sortParams['STORE'];
  2422. }
  2423. return $query;
  2424. }
  2425. }
  2426. /* transactions */
  2427. class Multi extends \Predis\MultiBulkCommand {
  2428. public function canBeHashed() { return false; }
  2429. public function getCommandId() { return 'MULTI'; }
  2430. }
  2431. class Exec extends \Predis\MultiBulkCommand {
  2432. public function canBeHashed() { return false; }
  2433. public function getCommandId() { return 'EXEC'; }
  2434. }
  2435. class Discard extends \Predis\MultiBulkCommand {
  2436. public function canBeHashed() { return false; }
  2437. public function getCommandId() { return 'DISCARD'; }
  2438. }
  2439. class Watch extends \Predis\MultiBulkCommand {
  2440. public function canBeHashed() { return false; }
  2441. public function getCommandId() { return 'WATCH'; }
  2442. public function filterArguments(Array $arguments) {
  2443. if (isset($arguments[0]) && is_array($arguments[0])) {
  2444. return $arguments[0];
  2445. }
  2446. return $arguments;
  2447. }
  2448. public function parseResponse($data) { return (bool) $data; }
  2449. }
  2450. class Unwatch extends \Predis\MultiBulkCommand {
  2451. public function canBeHashed() { return false; }
  2452. public function getCommandId() { return 'UNWATCH'; }
  2453. public function parseResponse($data) { return (bool) $data; }
  2454. }
  2455. /* publish/subscribe */
  2456. class Subscribe extends \Predis\MultiBulkCommand {
  2457. public function canBeHashed() { return false; }
  2458. public function getCommandId() { return 'SUBSCRIBE'; }
  2459. }
  2460. class Unsubscribe extends \Predis\MultiBulkCommand {
  2461. public function canBeHashed() { return false; }
  2462. public function getCommandId() { return 'UNSUBSCRIBE'; }
  2463. }
  2464. class SubscribeByPattern extends \Predis\MultiBulkCommand {
  2465. public function canBeHashed() { return false; }
  2466. public function getCommandId() { return 'PSUBSCRIBE'; }
  2467. }
  2468. class UnsubscribeByPattern extends \Predis\MultiBulkCommand {
  2469. public function canBeHashed() { return false; }
  2470. public function getCommandId() { return 'PUNSUBSCRIBE'; }
  2471. }
  2472. class Publish extends \Predis\MultiBulkCommand {
  2473. public function canBeHashed() { return false; }
  2474. public function getCommandId() { return 'PUBLISH'; }
  2475. }
  2476. /* persistence control commands */
  2477. class Save extends \Predis\MultiBulkCommand {
  2478. public function canBeHashed() { return false; }
  2479. public function getCommandId() { return 'SAVE'; }
  2480. }
  2481. class BackgroundSave extends \Predis\MultiBulkCommand {
  2482. public function canBeHashed() { return false; }
  2483. public function getCommandId() { return 'BGSAVE'; }
  2484. public function parseResponse($data) {
  2485. if ($data == 'Background saving started') {
  2486. return true;
  2487. }
  2488. return $data;
  2489. }
  2490. }
  2491. class BackgroundRewriteAppendOnlyFile extends \Predis\MultiBulkCommand {
  2492. public function canBeHashed() { return false; }
  2493. public function getCommandId() { return 'BGREWRITEAOF'; }
  2494. public function parseResponse($data) {
  2495. return $data == 'Background append only file rewriting started';
  2496. }
  2497. }
  2498. class LastSave extends \Predis\MultiBulkCommand {
  2499. public function canBeHashed() { return false; }
  2500. public function getCommandId() { return 'LASTSAVE'; }
  2501. }
  2502. class Shutdown extends \Predis\MultiBulkCommand {
  2503. public function canBeHashed() { return false; }
  2504. public function getCommandId() { return 'SHUTDOWN'; }
  2505. public function closesConnection() { return true; }
  2506. }
  2507. /* remote server control commands */
  2508. class Info extends \Predis\MultiBulkCommand {
  2509. public function canBeHashed() { return false; }
  2510. public function getCommandId() { return 'INFO'; }
  2511. public function parseResponse($data) {
  2512. $info = array();
  2513. $infoLines = explode("\r\n", $data, -1);
  2514. foreach ($infoLines as $row) {
  2515. list($k, $v) = explode(':', $row);
  2516. if (!preg_match('/^db\d+$/', $k)) {
  2517. $info[$k] = $v;
  2518. }
  2519. else {
  2520. $db = array();
  2521. foreach (explode(',', $v) as $dbvar) {
  2522. list($dbvk, $dbvv) = explode('=', $dbvar);
  2523. $db[trim($dbvk)] = $dbvv;
  2524. }
  2525. $info[$k] = $db;
  2526. }
  2527. }
  2528. return $info;
  2529. }
  2530. }
  2531. class SlaveOf extends \Predis\MultiBulkCommand {
  2532. public function canBeHashed() { return false; }
  2533. public function getCommandId() { return 'SLAVEOF'; }
  2534. public function filterArguments(Array $arguments) {
  2535. if (count($arguments) === 0 || $arguments[0] === 'NO ONE') {
  2536. return array('NO', 'ONE');
  2537. }
  2538. return $arguments;
  2539. }
  2540. }
  2541. class Config extends \Predis\MultiBulkCommand {
  2542. public function canBeHashed() { return false; }
  2543. public function getCommandId() { return 'CONFIG'; }
  2544. }
  2545. ?>