- Notifications
You must be signed in to change notification settings - Fork1
♠ Spade, a robust, full-featured, multi-module client for Redis.
License
rootslab/spade
Folders and files
| Name | Name | Last commit message | Last commit date | |
|---|---|---|---|---|
Repository files navigation
♠Spade, a robust, full-featured, multi-module,Redis client:
- It offers the ability to restrictcommands to a particular Redis version via thesemverconstructor option. Specifying this option turnsSpade indevelop mode, it enables a seriesof mix-ins to get brief descriptions of every implemented command.
- It implements a simpledelayed mechanism for re-connecting to socket when the client connection was not voluntarily interrupted.
- It collects commands in thequeue also when the client isoffline.
- It implements an automaticcommand rollback mechanism forsubscriptions when connection is lost and becames ready again.
- It implementsAUTH logic andautomatic db SELECT on socket (re)connection, configurablevia thesecurity constructor option.
- It offers automaticLUA scripts caching, using a simpleNFU withlinear aging evictionalgorithm (NFU stands forNot Frequently Used ).
- Itcorrectly handles multiple (p)(un)subscription commands as we will expect (1 command : multiple replies : multiple callback execution); it was well tested against some weird edge cases.Seetests for pubsub.
- It supports the newPING command signature also inPubSub mode.
- It implements apolling mechanism, useful to forceautomatic re-connection when client hangs while inPubSub mode.
- It facilitates scanning of Redis keyspace, implementing some simple iterators forSCAN/HSCAN/SSCAN/ZSCAN commands. See#loadIterators.
♠Spade makes use of somewell tested modules:
- Σ Syllabus module forcommand encoding andcommand helpers mix-ins, it also offers a series ofhelpers functions to convert a raw data reply in a usable format.
Internally it usesHoar module to handleSemantic Versioning 2.0,Sermone to encode commands,Abaco andBolgia modules to get some utilities. Moreover,Syllabus mantains acache forLUA scripts, using theCamphora module.
- ♎ Libra module to handle bindings between commands which have been sent and relativeRedis replies; it handles alsocommands queue rollbacks with the help ofTrain module.
- Cocker module to properly handlesocket reconnection when the connection is lost.
- Hiboris, a utility module to loadhiredisnative parser, or to fall back toBoris, apure js parser module forRedis string protocol; internallyBoris usesPeela as command stack.
- Cucu, a tiny module to handle thescheduled execution of repetitive methods/tasks.
- Gerry, a tiny module to handleevent logging to console, for debugging and testing purpose.
- Dado, for running tests.
- Vapid, a vacuousRedis implementation, with fully functional PubSub system.
NOTE : If you need aminimal Redis client based on♠ Spade code,specific for PubSub and Monitor mode try 🂢Deuces.
NOTE: onlynode engines">=v0.10.x" are supported.
$ npm install spade [-g] // clone repo $ git clone git@github.com:rootslab/spade.git
install and update devDependencies:
$cd spade/ $ npm install# update $ npm update
require
varSpade=require('spade');
Seeexamples.
to run all test files, install devDependecies:
$cd spade/# install or update devDependecies $ npm install# run tests $ npmtest
to execute a single test file simply do:
$ node test/file-name.js
NOTE:
run benchmarks forspade (fast/tight checks/turtle developer).
$cd spade/ $ npm run benchrun benchmarks fornode_redis (faster/loose checks/an army of contributors).
$cd spade/ $ npm install redis $ npm run node_redis_benchrun benchmarks forioredis (slowest/loose checks/unsafe pubsub).
$cd spade/ $ npm install ioredis $ npm run ioredis_benchNOTE:
- benchmarks need a runningRedis server instance, with default/stock configuration.
- to switch to the fasterhiredis native parser, installdevDependencies .
Create an instance, the argument within [ ] is optional.
Spade([Objectopt])// ornewSpade([Objectopt])
Default options are listed.
opt={/* * Syllabus option to enable develop mode and restrict * commands to a particular Redis semantic version. * Use: * - boolean 'true' or string '*' for all commands available. * - semver string to restrict commands ( like '1.0.0' ). * * NOTE, develop mode enables some utility methods to get command * descriptions, like: * - Spade.mixins#info( String command ) get cmd infos * - Spade.mixins#size() get the current number of commands * - Spade.mixins#stick( [ Boolean attach ] ) attach #info to every mix-in. * * See https://github.com/rootslab/syllabus#properties-methods. */semver :null/* * Hiboris option. For default, the loading * of 'hiredis' native parser is disabled * in favour of ( the slower ) Boris JS parser. */,hiredis :false/* * Cocker socket options */,socket :{path :null,address :{// 'localhost'host :'127.0.0.1',port :6379,family :null},reconnection :{trials :3,interval :1000/* * A value to use for calculating the pause between two * connection attempts. Default value is the golden ratio. * Final value is calculated as: * interval * Math.pow( factor, curr.attempts + 1 ) */,factor :(Math.sqrt(5)+1)/2},connection :{/* * encoding could be: 'ascii', 'utf8', 'utf16le' or * 'ucs2','buffer'. It defaults to null or 'buffer'. */encoding :null/* * keepAlive defaults to true ( it is false in net.Socket ). * Specify a number to set also the initialDelay. */,keepAlive :true/* * 'timeout' event delay, default is 0 ( no timeout ). */,timeout :0/* * noDelay is true for default, it disables the Nagle * algorithm ( no TCP data buffering for socket.write ). */,noDelay :true/* * If true, the socket won't automatically send a FIN * packet when the other end of the socket sends a FIN * packet. Defaults to false. */,allowHalfOpen :false}}/* * Security options. * * Options for db selection and password sending when the * client connects to a particular host. * An entry will be automatically added with the socket.address * or socket.path defined in the constructor option. However, * two sample entries are already present in the cache, holding * default values from redis.conf. * * Every entry should be a file path ('/path/to/file.sock'), * or a network path ('ip:port'), and should contain a: * * - 'requirepass' property, it contains the Redis password string * for the current host. It defaults to null. * Whenever a client connection is established and if an entry is * found in the security hash. an AUTH command will be sent to Redis, * before any other command in the command queue. * * - 'db' property, it defaults to 0. On every reconnection the first * command to send after AUTH is SELECT db. If db === -1, on client * reconnection the SELECT command will not been sent. * * NOTE: If the AUTH reply is erroneous, an 'authfailed' event will * be emitted, then the client will be automatically disconnected to * force re-AUTH on reconnection; it also happens if AUTH isn't required * by Redis, but was sent by the client. * If authorization is granted by Redis, an 'authorize' event will be * emitted, then if the command queue is not empty, it will be processed. */,security :{// a network path (ip:port)'127.0.0.1:6379' :{requirepass :null,db :0}// a unix domain socket path,'/tmp/redis.sock' :{requirepass :null,db :0}}/* * Command queue options. */,queue :{/* * Set the max size for the rollback queue. * It defaults to 2^16, to disable set it to 0. */rollback :64*1024/* * Log the last access time to the queue's head. * It is disabled for default. * * NOTE: It is used to store the last time a reply was received. */,timestamps :false}}
Don't mess with these properties!
/* * A property that holds the initial config object. */Spade.options :Object/* * An Object that holds all Redis commands/methods mix-ins * from Syllabus. It is a shortcut for Spade.mixins.commands. * See https://github.com/rootslab/syllabus#syllabus-commands. */Spade.commands :Object/* * A flag to indicate if the connection to Redis Server * is currently active. */Spade.ready :Boolean/* * A flag to avoid initializing scripts cache multiple times, * when the client is offline ( multiple #initCache() calls ). */Spade.cacheready :Boolean/* * An Object that holds all scheduled tasks. * See Spade#initTasks method to load defaults entries like 'polling'. * See Spade.qq property to handle tasks. */Spade.tasks :Object/* * Some shortcuts to internal modules. *//* * Cocker module that inherits from net.Socket. */Spade.socket :Cocker/* * Parser module, it could be an instance of Hiboris, a module * wrapper for the hiredis native parser, or the Boris JS parser. */Spade.parser :Hiboris|Boris/* * Libra Queue Manager for Commands/Replies bindings. */Spade.queue :Libra/* * Property that contains all mix-ins for the current semantic * version specified. Spade default value is false, interpreted * as '*'. * * NOTE: Specifying a particular semver version enables develop * mode, some mix-ins will be added to get infos about commands. * See Syllabus module for some examples. */Spade.mixins :Syllabus/* * A property that holds LUA commands and Cache, a shortcut * for Spade.mixins.lua. * See https://github.com/rootslab/syllabus#properties-methods. */Spade.lua :Object/* * Current cache property, an instance of Camphora. * * NOTE: the LUA script cache remains hidden until you explicitly * call the #initCache method. */Spade.lua.cache :Camphora/* * Cucu module to handle tasks. * See https://github.com/rootslab/cucu */Spade.qq :Cucu/* * A property that holds iterators for commands like SCAN, HSCAN, SSCAN, ZSCAN, * loaded with Spade#loadIterators. */Spade.iterators :Object/* * Debug Properties *//* * Gerry module to handle events logging. * See https://github.com/rootslab/gerry */Spade.logger :Gerry
Arguments within [ ] are optional.
Enable event logging to console.
This method enables/logs some extra event for debugging/testing purpose:
- reply for Redis replies.
- scanqueue when the "offline" command queue is processed.
- queued for commands executed when the client is offline.
NOTE:
- the'enable' option defaults to true.
- the'logger' fn gets event name and event arguments.
Spade#cli([Booleanenable[,Functionlogger[,Booleancollect_events]]]) :undefined
See "Other Debug Events" section.
Open a connection to the Redis Server:
- When the connection is fully established, theready event will be emitted.
- You can optionally use a callback that will be executed on theready event.
- It accepts an optional socket confguration object.
- It returns the current Spade instance.
NOTE: You don't need to listen for theready event, commandswill be queued in"offline mode" and written to socket when theconnection will be ready.
/* * socket_opt = { * address : { * host : '127.0.0.1' * , port : 6379 * } * , reconnection : { * trials : 3 * , interval : 1000 * } * , connection : { * ... * } * } */Spade#connect([Objectsocket_opt[,Functioncback]]) :Spade
Disconnect client from the Redis Server:
- You can optionally use a cback that will be executed after socketdisconnection.
- It returns the current Spade instance.
NOTE: From the client point of view, executing disconnect has the sameeffect of sending and executing the RedisQUIT command. Connection willbe closed and no other re-connection attempts will be made.
Spade#disconnect([Functioncback]) :Spade
Initialize or reveal the (hidden) LUA script cache:
- It loads and sends all the files found in the./node_modules/syllabus/lib/lua/scriptsdirectory, to the Redis Server, always after theready event.
- It triggerscacheinit,cacheload,cacheready andscriptfailure events.
- Optionally you could specify:
- a custom loading path with something like :{ filepath : '/my/scripts/dir' }.
- a custom init configuration for the Camphora costructor to (re)build the cache.
- a cback that will be executed oncacheready passing the current cache instanceas argument.
NOTE: Empty files and scripts, processed and then refused by Redis with an error reply,are automatically evicted from the cache.
NOTE: Ifcache_opt is already set, the cache will be re-initialized; it happensonly if the cache is ready, or when no other script commands are already been queued andnot yet been sent to Redis (for example, when the client is offline); otherwise the cachewill remain intact and an Error will be passed to the callback as the first argument.
/* * Default values for 'cache_opt' are: * { * capacity : 128 * , encrypt_keys : false * , algorithm : 'sha1' * , output_encoding : 'hex' * , input_encoding : 'binary' * } */Spade#initCache([Objectf_opt[,Objectcache_opt,[Functioncback]]]) :undefined
SeeCamphora#load for a list of availableoptions for cache.
See "Script Cache Events" Section for the list of events.
Load methods/tasks from'spade/lib/tasks' directory.It returns the currentSpade.tasks property (or Cucu.ttable).
// filenames should be without '.js' extension.Spade#initTasks([Arrayfile_list]) :Object
For default, the 'connection.js' file exports/adds a single polling method to tasks.Whenpolling is enabled, the client starts toPING server every 60 secs; it couldbe useful for testing connection aliveness, when the client is in PubSub mode.
Start the polling task:
Spade.tasks.polling.run([Numberinterval[,Arraypolling_fn_args[,Numbertimes]]]) :Number
the polling method could receive 4 optional arguments, through thepolling_fn_args Array:
pollingFn :function([Functioncback[,Stringping_msg[,Numbertimeout[,Booleanreconnect]]]])
for example:
/* * Pinging server every 2 seconds, with a 'BANG!' message and stop after 10 times. * For every reply received client emits 'polling' event. * If no reply will be received within 1 sec, client emits the 'hangup' event, then * disconnects and reconnects to the server. */varclient=require('spade')()...client.cli();client.connect(); ...client.initTasks();client.tasks.polling.run(2000,[null,'BANG!',1000,true],10); ...client.task.polling.stop();..
NOTE:
- executing #initTasks, automatically enables/adds thepolling andhangup events.
- when inPubSub mode, therollback mechanism doesn't save PINGs sent by thepolling task.
SeeTasks Events.
SeeCucu to see all available options to handle tasks.
Seepolling tests.
Load default iterators, for commands likeSCAN,SSCAN,HSCAN,ZSCAN,from'spade/lib/iterators' dir, you could restrict files to load, specifying somefilenames without '.js' extension, for example: [ 'scan' ].
Spade#loadIterators([Arrayfile_list]) :Object
It returns the currentSpade.iterators property filled with:
Spade.iterators :{scan :function(Numbercursor[,Objectopt[,Functioncback]]) :Object,hscan:function(Stringkey,Numbercursor[,Objectopt[,Functioncback]]) :Object,sscan:function(Stringkey,Numbercursor[,Objectopt[,Functioncback]]) :Object,zscan :function(Stringkey,Numbercursor[,Objectopt[,Functioncback]]) :Object}// you could use #next outside the callback to receive other results.Object :{next :Function}// default options for iterator commands:opt :{match :null,count :10}// 'cback' gets 3 arguments, you could call 'iterate' function inside the callback to receive next results.cback :function(Booleanis_err_reply,Arrayreply,Functioniterate)// reply Array for SCAN command:reply :[Booleanis_last_iter,Arraykeys,Numberiter_counter,Numberkeys_counter]// for HSCAN, SSCAN, ZSCAN commands, the last element is the current hash/set/zset key being scanned.reply :[Booleanis_last_iter,Arraykeys,Numberiter_counter,Numberkeys_counter,Stringkey]
NOTE:
- signatures are the same as for relativeSpade.commands, but they returnsiterator objects.
- when console logging is enabled withSpade#cli, 3 additionaldebug events will be added:
- scan
- sscan
- hscan
- zscan
Seescan example.
Seeiterators events.
TheSpade.commands property contains all methods to encode and sendRedis commands,via theSyllabus module.
Brief List of Redis Command Types:
- Cluster :1 command (19 missing).
- Connection :6 commands.
- Geo :6 commands.
- Hashes :15 commands.
- HyperLogLog :4 commands.
- Keys :24 commands.
- Lists :17 commands.
- PubSub :6 commands.
- Scripting :7 commands.
- Sets :15 commands.
- Server :31 commands.
- Sorted Sets :21 commands.
- Strings :23 commands, (1 missing).
- Transactions :5 commands.
SeeSyllabus Commands Section for all signatures and available commands.
Every command mix-in accepts a callback function as the last argument, it will get3 arguments:
/* * 'is_err_reply' is a Boolean that signals an ERROR reply from Redis, * ( not a JS Error ), then reply data will contain the error message(s). * * 'data' is a list containing reply data Buffers ( or Strings if hiredis is used ). * * 'reveal' is a utility function that converts the raw Redis Reply in a simple * and usable form. * * NOTE: The utility function is not the same for all command replies, because, * as we surely know, some reply needs particular format and type conversions. */'callback' :function(Booleanis_err_reply,Arraydata,Functionreveal) :undefined
Example Code:
varlog=console.log,Spade=require('spade'),client=Spade({});// start async connection to Redisclient.connect();// execute TIME commandclient.commands.time(function(is_err_reply,reply_data_arr,reveal_fn){log('- error reply:',is_err_reply);log('- raw reply:',reply_data_arr);log('- converted reply:',reveal_fn(reply_data_arr));});
Specifying asemver option ( like* or1.0.0 ) enablesSyllabusdevelopment mode for commands.
Example Code for REPL
$cd spade/$ node# you can directly load the interactive example file executing:# > cd spade/example# > .load repl-example.js# create a client instance with all commands (*)> var client = require('./' )( { semver:'*' } )..# enable automatic console logging for events>client.cli()..# get info about a command via mixins (Syllabus) property> client.mixins.info('CoNfiG'){ req:'CoNfiG', name:'config', args: -1, type:'server', cmd:'CONFIG', sub: ['GET','RESETSTAT','REWRITE','SET' ] }# you can also stick the #info method to all available commands>client.mixins.stick()..returns a number..# now get info about a method/command>client.commands.ping.info(){ req:'ping', name:'ping', args: 0, type:'connection', cmd:'PING', sub: [], url:'http://redis.io/commands/ping', rtype:'+', since:'1.0.0', hint:'PING', descr:'Ping the server.' }# now get info about a nested method/command>client.commands.pubsub.numpat.info(){ req:'pubsub numpat', name:'pubsub.numpat', args: 0, type:'pubsub', cmd:'PUBSUB NUMPAT', sub: [], url:'http://redis.io/commands/pubsub', rtype:':', since:'2.8.0', hint:'PUBSUB NUMPAT', descr:'Returns the total number of patterns all the clients are subscribed to.' }# ok stop, now execute the command>client.commands.pubsub.numpat()!queued: [ { bulks: 2, cmd:'PUBSUB', ecmd:'*2\r\n$6\r\nPUBSUB\r\n$6\r\nNUMPAT\r\n', fn: [Function], zn: [Function] }, 1 ]# ops, command is not sent but queued, then open client connection..>client.connect()..# read your reply, then quit or disconnect>client.commands.quit()..
SeeSyllabus Properties and Methods Section andrepl-example.js.
Manually execute scripts commands, differently fromSpade.commands.script methods,Spade.lua.script will also update the hidden cache forLUA scripts.
NOTE: these mix-ins are used internally by theinitCache method ,for loading script files and for revealing the hiddenLUA cache.
/* * Get a script from the cache and send it to Redis. * It executes an EVALSHA command with the digest of the current script, * if it already exists. */#run(Stringname,Arraykeys,Arrayargs[,Functioncback]) :undefined/* * Manually load a script into the cache and send it to Redis. * It executes a SCRIPT LOAD command. 'lback' function will be called with an * argument that represents the entry loaded in the cache, or undefined if an * error occurs. */#load(Stringkey,Stringdata[,Functioncback[,Functionlback]]) :undefined/* * Clear Spade and Redis cache. It executes a SCRIPT FLUSH command. * 'fback' function will be called with the number of elements flushed from the * cache. */#flush([Functioncback[,Functionfback]]) :undefined
SeeSyllabus.lua.
- Events Sequence Diagram
- Error Events
- Auth Events
- Select Events
- Script Cache Events
- Socket Connection Events
- PubSub Events
- Monitor Events
- Other Debug Events
- the event emitted for first could be:-connect oroffline, after the execution ofconnect ordisconnect methods.-cacheinit, after the execution ofinitCache method.-error, it"simply" happens.
++||vvconnect+------->(timeout)error+|+-------->(authorized) +|+|V|v+(authfailed)+-----+-----+(cacheinit)|+||+v|vv|+------->offline<----+-----+----+(dbfailed)(dbselected)||+||+|||||||+v||v|lost<----+(*attempt*)|+------------------+ready+------------+++|+|||+--+(*monitor*)<--+|v||||+--------+-------++->connect<-++---------+||+|vv|(listen)<----+(*scriptfailure*)(*cacheload*)v+++ ...|||v+--------+-------+(*message*)+--->(shutup)|v(cacheready)
NOTE:
- events between() could never happen, most of them depends on client configuration.
- events within* could be emitted more than once, namely0 ork times withk >= 1.
- timeout could happen in"any" moment after theconnect event.
- listen signals that client is entering in subscription mode
- shutup signals that client is (voluntarily) leaving subscription mode.
- monitor mode could end only with aQUIT command (then 'offline').
/* * A parser or command encoding error has occurred. */'error' :function(Errorerr,Objectcommand)
These events are emitted on every client (re)connection to Redis and only ifAUTH is set to be mandatory for the current connected host; namely, shouldexist an entry,'ip:port' or'/path/to/file', in the options.security hash,withrequirepass property set to a non empty string.
/* * The reply to AUTH command is an Error, then client will be disconnected; * it also happens when AUTH is not required by Redis but issued by the client. * No 'ready' event could be launched. */'authfailed' :function(Stringpassword,Arrayreply,Objectaddress)/* * Client authorization was successful. After that, the command queue will be * processed and the 'ready' event could be launched. */'authorized' :function(Stringpassword,Arrayreply,Objectaddress)
These events are emitted on every client (re)connection toRedis. If thedbproperty is set ( >== 0 ) in the options.security hash, for the current connectedRedis host, theSELECT db command will be sent before all the other commandsalready present in the queue.
NOTE:WhenRedis needs authentication,SELECT command will be sentonly afterhaving sent theAUTH command and having received a successful reply fromRedis.
/* * The reply to SELECT command is an Error, then client will be disconnected. * No 'ready' event could be launched. */'dbfailed' :function(Stringdb,Arrayreply,Objectaddress)/* * Client authorization is successful. Now the command queue will be processed, * the 'ready' event could be launched. */'dbselected' :function(Stringdb,Arrayreply,Objectaddress)
/* * Cache was initialized, script files are loaded in memory and a list * of SCRIPT LOAD commands are ready to be written to the socket. * Now that script commands are queued, it is possible to use and send * these and other commands. */'cacheinit' :function(Arrayscript_load_commands)/* * A script was processed and refused by Redis with an error reply. * Errored scripts are not added to local cache. */'scriptfailure' :function(Stringscript_name,Stringerror_message)/* * A script was loaded in the cache and was successfully processed by Redis. */'cacheload' :function(Stringscript_name,Bufferdata,Stringtxt)/* * All scripts, found in the Syllabus scripts directory, are written to socket * and processed by Redis. * * NOTE: 'cacheready' event happens always after the 'ready' connection event, * because all scripts should be processed by Redis before launching this event. * * NOTE: cache for LUA scripts is an instance of Camphora module. */'cacheready' :function(Camphoralua_script_cache)
/* * After that the client has established a connection to the Redis host, * it is now ready to write commands to the socket and to receive the * relative replies from Redis. It happens after processing AUTH and * SELECT commands and finally the offline queue. * * NOTE: Every commands executed by the client before the 'ready' event, * will be enqueued in 'offline mode' and sent/written to socket when * 'ready' will be emitted. */'ready' :function(Objectaddress,Numberqueued_command_sent)/* * A client connection is fully established with Redis host. This event * happens before 'ready' and AUTH/SELECT related events. */'connect' :function(Objectaddress)/* * Connection is currently down ( on the first 'close' event from the socket ). */'offline' :function(Objectaddress)/* * Client is trying to reconnect to Redis server, k is the number of current * connection attempt. * * NOTE: 'millis' indicates the last interval of time between attempts. */'attempt' :function(Numberk,Numbermillis,Objectaddress)/* * The connection is definitively lost ( after opt.reconnection.trials times ). */'lost' :function(Objectaddress)/* * The socket times out for inactivity. * It only notifies that the socket has been idle. */'timeout' :function(Numbertimeout,Objectaddress)
NOTE: for multiple (P)(UN)SUBSCRIBE commands,callbacks are executedone time for every message reply, thosemessages will be received also through thePub/Subsystem. However the first callback signals that the command is succesfully processed by Redis.
For example:
- subscribe( [ 'a', 'a', 'b', 'b', 'c', 'c' ], cback ) :
- executes callback6 times
- produces6 messages
- 3 actual subscriptions
- unsubscribe( null, cback ):
- executes cback3 times
- produces3 messages
- 0 subscriptions.
/* * A message was received through the PubSub system when the client * is in PubSub mode. * * NOTE: the 'formatter' function converts the received 'message' to * an obj/hash. * For example, a message reply to a (P)(UN)SUBSCRIBE command issued * by the client, could be: * * 'message' -> [ 'unsubscribe', 'channel', 0 ] * * will be converted to: * * { * type : 'unsubscribe' * , chan : 'channel' * . subs : 0 * } * * a typical message received from publisher(s): * * 'message' -> [ 'message', 'channel', 'Hello folks!' ] * * will be converted to: * * { * type : 'message' * , chan : 'channel' * . msg : 'Hello folks!!' * } * * See also Syllabus.formatters. * */'message' :function(Arraymessage,Functionformatter)/* * An event to signal that the client is entering in PubSub mode after a * subscription command. From now, all replies to (un)subscription commands * will be received as messages. */'listen' :function()/* * An event to signal that client is leaving PubSub mode after a successfull * execution of a unsubscription command. * It doesn't happen if the client disconnects while in PubSub mode. */'shutup' :function()
/* * A 'message' was received when the client is in Monitor mode. * * NOTE: the 'formatter' function converts the 'message' to an obj/hash. * For example, with an input like: * * message = '1405478664.248185 [0 127.0.0.1:47573] "ping"', * * executing formatter( message ) will output: * * { * ip: '127.0.0.1', * port: 47573, * db: 0, * cmd: '"ping"', * utime: 1405478664248, * time: [ 1405478664, 248185 ] * } * * See also Syllabus.formatters. * */'monitor' :function(Stringmessage,Functionformatter)
NOTE: to enable logging for events below, executeSpade#initTasks method.
/* * polling event will be emitted every time a reply for PING will be received. */'polling' :function(Numberis_pubsub_active,Numberis_monitor_active)/* * When the client doesn't receive a reply within the timeout interval specified * with Spade.tasks.polling#run, it disconnects from server, and optionally * reconnects. */'hangup' :function(Numberis_pubsub_active,Numberis_monitor_active)
Seepolling task.
NOTE: to enable logging for debug events , executeSpade#cli method.
/* * When the client is offline, commands are not sent but queued. */'queued' :function(Objectcommand,Numberoffline_queue_size)/* * When the client will be online once again, this event is emitted * before performing a scan for sending enqueued commands, then always * before the 'ready' event. */'scanqueue' :function(Numberoffline_queue_size)/* * The client receives a command reply from Redis. It always happens after * the 'ready' event. */'reply' :function(Objectcommand,Stringreply)/* * The client receives an error reply from Redis. It always happens after * the 'ready' event. */'error-reply' :function(Objectcommand,Stringerr_reply)
NOTE: to enable logging for events below, execute alsoSpade#loadIterators method.
'scan' :function(Booleanis_last_iter,Numberiterations,Numberkeys_counter)'hscan' :function(Booleanis_last_iter,Numberiterations,Numberkeys_counter,Stringkey)'sscan' :function(Booleanis_last_iter,Numberiterations,Numberkeys_counter,Stringkey)'zscan' :function(Booleanis_last_iter,Numberiterations,Numberkeys_counter,Stringkey)
See#loadIterators.
Copyright (c) 2014-present < Guglielmo Ferri :44gatti@gmail.com >
Permission is hereby granted, free of charge, to any person obtaininga copy of this software and associated documentation files (the'Software'), to deal in the Software without restriction, includingwithout limitation the rights to use, copy, modify, merge, publish,distribute, sublicense, and/or sell copies of the Software, and topermit persons to whom the Software is furnished to do so, subject tothe following conditions:
The above copyright notice and this permission notice shall beincluded in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OFMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANYCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THESOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
About
♠ Spade, a robust, full-featured, multi-module client for Redis.