Pluggable HashRing and TypeScript definitions

README.md

@@ -107,6 +107,27 @@ Note that values are always returned as `Buffer`s, regardless of whether a
   * `err` : error
   * `val` : value retrieved as a `Buffer`
 
+### Pluggable Hashing
+
+MemJS supports pluggable hashing algorithms. You can set the hashing algorithm
+by setting the `HashRing` property on a `Client` instance. For example:
+
+``` javascript
+var memjs = require('memjs');
+var php7hashRing = require('memjs/hashring/Php7Memcache4CompatibleHashRing');
+var crc32 = require('memjs/hashring/algorithms/Crc32');
+
+var servers = ['localhost:11211', 'localhost:11212', 'localhost:11213'];
+
+var client = memjs.Client.create(servers);
+
+// the php 7 hashring requires a hashing algorithm, here we are using crc32
+var hashRing = new php7hashRing(servers, crc32)
+client.HashRing = hashRing;
+```
+
+The `Php7Memcache4CompatibleHashRing` and related `Crc32` algorithm are provided.
+
 ## Contributing
 
 The best way to contribute to the project is by reporting bugs and testing unpublished

lib/memjs/hashring/HashRingInterface.d.ts

@@ -0,0 +1,5 @@
+export type AlgorithmFunc = (key: string) => number;
+export default abstract class HashRingInterface {
+    constructor(servers: Array<string>, algorithm: AlgorithmFunc);
+    abstract get(key: string): string;
+}

lib/memjs/hashring/HashRingInterface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HashRingInterface {
+    constructor(servers, algorithm) { }
+}
+exports.default = HashRingInterface;

lib/memjs/hashring/Php7Memcache4CompatibleHashRing.d.ts

@@ -0,0 +1,22 @@
+import HashRingInterface from './HashRingInterface';
+import { AlgorithmFunc } from './HashRingInterface';
+export default class HashRing implements HashRingInterface {
+    private servers;
+    private algorithm;
+    private weight;
+    private readonly MMC_CONSISTENT_POINTS;
+    private readonly MMC_CONSISTENT_BUCKETS;
+    private points;
+    private numPoints;
+    private numServers;
+    private bucketsPopulated;
+    private buckets;
+    constructor(servers: Array<string>, algorithm: AlgorithmFunc);
+    private addServer;
+    private populateBuckets;
+    private find;
+    get(key: string): string;
+    range(key: string, size: number, unique: boolean): void;
+    swap(from: string, to: string): void;
+    remove(server: string): void;
+}

lib/memjs/hashring/Php7Memcache4CompatibleHashRing.js

@@ -0,0 +1,96 @@
+"use strict";
+// this is a copy of the consistant hash algorithm used by PECL memcache 4.0.5.2
+// https://github.com/websupport-sk/pecl-memcache/blob/4.0.5.2/php7/memcache_consistent_hash.c
+Object.defineProperty(exports, "__esModule", { value: true });
+class HashRing {
+    constructor(servers, algorithm) {
+        this.weight = 1;
+        this.MMC_CONSISTENT_POINTS = 160;
+        this.MMC_CONSISTENT_BUCKETS = 1024;
+        this.points = [];
+        this.numPoints = 0;
+        this.numServers = 0;
+        this.bucketsPopulated = false;
+        this.buckets = [];
+        this.servers = servers;
+        this.algorithm = algorithm;
+        this.servers.forEach(server => {
+            this.addServer(server);
+        });
+    }
+    addServer(server) {
+        var points = this.weight * this.MMC_CONSISTENT_POINTS;
+        for (var i = 0; i < points; i++) {
+            var key = `${server}-${i}`;
+            var hash = this.algorithm(key);
+            this.points[this.numPoints + i] = {
+                server: server,
+                point: hash
+            };
+        }
+        this.numPoints += points;
+        this.numServers++;
+        this.bucketsPopulated = false;
+    }
+    populateBuckets() {
+        var step = 0xffffffff / this.MMC_CONSISTENT_BUCKETS;
+        this.points.sort((a, b) => {
+            return a.point - b.point;
+        });
+        for (var i = 0; i < this.MMC_CONSISTENT_BUCKETS; i++) {
+            this.buckets[i] = this.find(step * i);
+        }
+        this.bucketsPopulated = true;
+    }
+    find(point) {
+        var lo = 0;
+        var hi = this.numPoints - 1;
+        var mid;
+        while (true) {
+            /* point is outside interval or lo >= hi, wrap-around */
+            if (point <= this.points[lo].point || point > this.points[hi].point) {
+                return this.points[lo].server;
+            }
+            /* test middle point */
+            mid = lo + Math.floor((hi - lo) / 2);
+            /* perfect match */
+            if (point <= this.points[mid].point && point > (mid ? this.points[mid - 1].point : 0)) {
+                return this.points[mid].server;
+            }
+            /* too low, go up */
+            if (this.points[mid].point < point) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+    }
+    // was find_server() in PHP
+    get(key) {
+        if (this.numServers > 1) {
+            if (!this.bucketsPopulated) {
+                this.populateBuckets();
+            }
+            var hash = hash = this.algorithm(key);
+            return this.buckets[hash % this.MMC_CONSISTENT_BUCKETS];
+        }
+        return this.points[0].server;
+    }
+    // Note: these functions are here for compatability with JS memcached NPM module
+    // but should never be called in our use case
+    // should not be called unless 'redundancy' and 'queryRedundancy' is set in Memcached
+    range(key, size, unique) {
+        throw '"range" call unsupported';
+    }
+    // should not be called unless 'failOverServers' is set in Memcached
+    swap(from, to) {
+        throw '"swap" call unsupported';
+    }
+    // should not be called as we do not want a server to not exist as it would
+    // end up not finding keys anyway - we've never used it this way
+    remove(server) {
+        throw '"remove" call unsupported';
+    }
+}
+exports.default = HashRing;

lib/memjs/hashring/algorithm/Crc32.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * A crc32 function that will produce the same result as PHP's crc32() function
+ * (http://php.net/crc32).
+ *
+ * The string used in PHP must be encoded in UTF-8 or the checksums will be
+ * different. Use the following PHP to get the unsigned integer result:
+ *
+ *     sprintf('%u', crc32($string));
+ *
+ * Copyright 2010, Will Bond <[email protected]>
+ * Released under the MIT license
+ */
+export default function (string: any): number;

lib/memjs/hashring/algorithm/Crc32.js

@@ -0,0 +1,75 @@
+"use strict";
+/*!
+ * A crc32 function that will produce the same result as PHP's crc32() function
+ * (http://php.net/crc32).
+ *
+ * The string used in PHP must be encoded in UTF-8 or the checksums will be
+ * different. Use the following PHP to get the unsigned integer result:
+ *
+ *     sprintf('%u', crc32($string));
+ *
+ * Copyright 2010, Will Bond <[email protected]>
+ * Released under the MIT license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var table = [
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
+    0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+    0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
+    0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
+    0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
+    0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
+    0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
+    0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+    0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
+    0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
+    0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
+    0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+    0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
+    0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
+    0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+];
+function default_1(string) {
+    // This converts a unicode string to UTF-8 bytes
+    string = unescape(encodeURI(string));
+    var crc = 0 ^ (-1);
+    var len = string.length;
+    for (var i = 0; i < len; i++) {
+        crc = (crc >>> 8) ^ table[(crc ^ string.charCodeAt(i)) & 0xFF];
+    }
+    crc = crc ^ (-1);
+    // Turns the signed integer into an unsigned integer
+    if (crc < 0) {
+        crc += 4294967296;
+    }
+    return crc;
+}
+exports.default = default_1;

lib/memjs/header.d.ts

@@ -0,0 +1,22 @@
+export function fromBuffer(headerBuf: any): {
+    magic?: undefined;
+    opcode?: undefined;
+    keyLength?: undefined;
+    extrasLength?: undefined;
+    dataType?: undefined;
+    status?: undefined;
+    totalBodyLength?: undefined;
+    opaque?: undefined;
+    cas?: undefined;
+} | {
+    magic: any;
+    opcode: any;
+    keyLength: any;
+    extrasLength: any;
+    dataType: any;
+    status: any;
+    totalBodyLength: any;
+    opaque: any;
+    cas: any;
+};
+export function toBuffer(header: any): Buffer;

lib/memjs/memjs.d.ts

@@ -0,0 +1,17 @@
+import HashRingInterface from './hashring/HashRingInterface'
+
+export default class Client {
+  HashRing:HashRingInterface
+  constructor(serverUris:Array<string>, options?:any)
+  get(key:string):Promise<{ value:Buffer }>
+  set(key:string, value:Buffer, options?:{ expires:number }):Promise<boolean>
+  add(key:string, value:Buffer, options?:{ expires:number }):Promise<boolean>
+  replace(key:string, value:Buffer, options?:{ expires:number }):Promise<boolean>
+  delete(key:string):Promise<boolean> 
+  increment(key:string, amount:number, options?:{ initial?:number, expires?:number }):Promise<{success:boolean, value:number}>
+  decrement(key:string, amount:number, options?:{ initial?:number, expires?:number }):Promise<{success:boolean, value:number}>
+  append(key:string, value:Buffer):Promise<boolean>
+  prepend(key:string, value:Buffer):Promise<boolean>
+  touch(key:string, expires:number):Promise<boolean>
+  // flush():Promise<Record<string, boolean>>
+}

lib/memjs/memjs.js

@@ -11,8 +11,9 @@ var makeAmountInitialAndExpiration = require('./utils').makeAmountInitialAndExpi
 
 // Client initializer takes a list of `Server`s and an `options` dictionary.
 // See `Client.create` for details.
-var Client = function(servers, options) {
+var Client = function(servers, options, serversLookup) {
   this.servers = servers;
+  this.serversLookup = serversLookup;
   this.seq = 0;
   this.options = merge(options || {},
     {failoverTime: 60, retries: 2, retry_delay: 0.2, expires: 0, logger: console});
@@ -73,13 +74,15 @@ Client.create = function(serversStr, options) {
   serversStr = serversStr || process.env.MEMCACHIER_SERVERS ||
                              process.env.MEMCACHE_SERVERS || 'localhost:11211';
   var serverUris = serversStr.split(',');
+  var serversLookup = {};
   var servers = serverUris.map(function(uri) {
     var uriParts = uri.split('@');
     var hostPort = uriParts[uriParts.length - 1].split(':');
     var userPass = (uriParts[uriParts.length - 2] || '').split(':');
+    serversLookup[uri] = server;
     return new Server(hostPort[0], parseInt(hostPort[1] || 11211, 10), userPass[0], userPass[1], options);
   });
-  return new Client(servers, options);
+  return new Client(servers, options, serversLookup);
 };
 
 // An overridable method you can use for determing
@@ -107,6 +110,11 @@ Client.prototype.getServer = function(key) {
 // Chooses the server to talk to by hashing the given key.
 Client.prototype.server = function(key) {
   // mechanisms
+  // allow use of a pluggable HashRing ie: https://github.com/3rd-Eden/node-hashr`ing
+  if (this.HashRing) {
+    const serverUri = this.HashRing.get(key);
+    return this.serversLookup[serverUri]
+  }
   var total = this.servers.length;
   var origIdx = total > 1 ? this.getServer(key) : 0;
   var idx = origIdx;

lib/memjs/noop-serializer.d.ts

@@ -0,0 +1,10 @@
+export namespace noopSerializer {
+    function serialize(opcode: any, value: any, extras: any): {
+        value: any;
+        extras: any;
+    };
+    function deserialize(opcode: any, value: any, extras: any): {
+        value: any;
+        extras: any;
+    };
+}

lib/memjs/protocol.d.ts

@@ -0,0 +1 @@
+export const errors: typeof errors;

lib/memjs/server.d.ts

@@ -0,0 +1,30 @@
+export = Server;
+declare class Server extends events {
+    constructor(host: any, port: any, username: any, password: any, options: any);
+    responseBuffer: Buffer;
+    host: any;
+    port: any;
+    connected: boolean;
+    timeoutSet: boolean;
+    connectCallbacks: any[];
+    responseCallbacks: {};
+    requestTimeouts: any[];
+    errorCallbacks: {};
+    options: any;
+    username: any;
+    password: any;
+    onConnect(func: any): void;
+    onResponse(seq: any, func: any): void;
+    respond(response: any): void;
+    onError(seq: any, func: any): void;
+    error(err: any): void;
+    listSasl(): void;
+    saslAuth(): void;
+    appendToBuffer(dataBuf: any): Buffer;
+    responseHandler(dataBuf: any): void;
+    sock(sasl: any, go: any): void;
+    write(blob: any): void;
+    writeSASL(blob: any): void;
+    close(): void;
+}
+import events = require("events");