infinispan 0.13.0 → 0.14.0

package/lib/sasl/digest.js

@@ -16,6 +16,8 @@
      * References:
      *  - [RFC 2831](http://tools.ietf.org/html/rfc2831)
      *
+     * @param {Object} options Configuration options.
+     * @returns {void}
      * @api public
      */
     function Mechanism(options) {
@@ -36,7 +38,8 @@
      *  - `serviceType`
      *  - `authzid`   authorization identity (optional)
      *
-     * @param {Object} cred
+     * @param {Object} cred Credentials containing username, password, host, serviceType, and optional authzid.
+     * @returns {String} The encoded DIGEST response string.
      * @api public
      */
     Mechanism.prototype.response = function (cred) {
@@ -56,9 +59,9 @@
         //       the fact that TLS has largely superseded this functionality,
         //       implementing it is a low priority.
 
-        var uri = cred.serviceType + '/' + cred.host;
+        var uri = `${cred.serviceType  }/${  cred.host}`;
         if (cred.serviceName && cred.host !== cred.serviceName) {
-            uri += '/' + serviceName;
+            uri += `/${  serviceName}`;
         }
         var realm = cred.realm || this._realm || ''
             , cnonce = this._genNonce()
@@ -68,13 +71,13 @@
             , ha2
             , digest;
         var str = '';
-        str += 'username="' + cred.username + '"';
-        if (realm) { str += ',realm="' + realm + '"'; };
-        str += ',nonce="' + this._nonce + '"';
-        str += ',cnonce="' + cnonce + '"';
-        str += ',nc=' + nc;
-        str += ',qop=' + qop;
-        str += ',digest-uri="' + uri + '"';
+        str += `username="${  cred.username  }"`;
+        if (realm) { str += `,realm="${  realm  }"`; };
+        str += `,nonce="${  this._nonce  }"`;
+        str += `,cnonce="${  cnonce  }"`;
+        str += `,nc=${  nc}`;
+        str += `,qop=${  qop}`;
+        str += `,digest-uri="${  uri  }"`;
         var base = crypto.createHash('md5')
             .update(cred.username)
             .update(':')
@@ -112,17 +115,17 @@
             .update(':')
             .update(ha2)
             .digest('hex');
-        str += ',response=' + digest;
+        str += `,response=${  digest}`;
         if (this._charset == 'utf-8') { str += ',charset=utf-8'; }
-        if (cred.authzid) { str += 'authzid="' + cred.authzid + '"'; }
+        if (cred.authzid) { str += `authzid="${  cred.authzid  }"`; }
         return str;
     };
 
     /**
      * Decode a challenge issued by the server.
      *
-     * @param {String} chal
-     * @return {Mechanism} for chaining
+     * @param {String} chal Challenge string from server.
+     * @returns {Mechanism} for chaining
      * @api public
      */
     Mechanism.prototype.challenge = function (chal) {
@@ -146,6 +149,8 @@
     /**
      * Parse challenge.
      *
+     * @param {String} chal Challenge string to parse.
+     * @returns {Object} Parsed directives.
      * @api private
      */
     function parse(chal) {
@@ -166,8 +171,8 @@
      *     genNonce(10)();
      *     // => "FDaS435D2z"
      *
-     * @param {Number} len
-     * @return {Function}
+     * @param {Number} len Length of the nonce.
+     * @returns {Function} A function that generates a random nonce.
      * @api private
      */
     function genNonce(len) {
@@ -180,7 +185,7 @@
                 buf.push(chars[Math.random() * charlen | 0]);
             }
             return buf.join('');
-        }
+        };
     }
 
     exports = module.exports = Mechanism;

package/lib/sasl/external.js

@@ -14,11 +14,12 @@
    * This class implements the EXTERNAL SASL mechanism.
    *
    * The EXTERNAL SASL mechanism provides support for authentication using
-   * credentials established by external means. 
+   * credentials established by external means.
    *
    * References:
    *  - [RFC 4422](http://tools.ietf.org/html/rfc4422)
    *
+   * @returns {void}
    * @api public
    */
   function Mechanism() {
@@ -33,7 +34,8 @@
    * Options:
    *  - `authzid`   authorization identity (optional)
    *
-   * @param {Object} cred
+   * @param {Object} cred Credentials containing optional authzid.
+   * @returns {String} The authorization identity or empty string.
    * @api public
    */
   Mechanism.prototype.response = function (cred) {
@@ -43,10 +45,11 @@
   /**
    * Decode a challenge issued by the server.
    *
-   * @param {String} chal
+   * @param {String} chal Challenge string from server.
+   * @returns {void}
    * @api public
    */
-  Mechanism.prototype.challenge = function (chal) {
+  Mechanism.prototype.challenge = function (chal) { // eslint-disable-line no-unused-vars
   };
 
   exports = module.exports = Mechanism;

package/lib/sasl/factory.js

@@ -11,6 +11,7 @@
     /**
      * `Factory` constructor.
      *
+     * @returns {void}
      * @api public
      */
     function Factory() {
@@ -27,9 +28,9 @@
      *
      *     factory.use('XFOO', FooMechanism);
      *
-     * @param {String|Mechanism} name
-     * @param {Mechanism} mech
-     * @return {Factory} for chaining
+     * @param {String|Mechanism} name Mechanism name or constructor.
+     * @param {Mechanism} mech Mechanism constructor when name is a string.
+     * @returns {Factory} for chaining
      * @api public
      */
     Factory.prototype.use = function(name, mech) {
@@ -50,8 +51,8 @@
      *
      *     var mech = factory.create(['FOO', 'BAR']);
      *
-     * @param {Array} mechs
-     * @return {Mechanism}
+     * @param {Array} mechs List of supported mechanism names.
+     * @returns {Mechanism} A new mechanism instance or null.
      * @api public
      */
     Factory.prototype.create = function(mechs) {

package/lib/sasl/oauthbearer.js

@@ -18,6 +18,7 @@
    * References:
    *  - [RFC 4616](http://tools.ietf.org/html/rfc4616)
    *
+   * @returns {void}
    * @api public
    */
   function Mechanism() {
@@ -33,13 +34,14 @@
    *  - `token`     an OAuth token
    *  - `authzid`   authorization identity (optional)
    *
-   * @param {Object} cred
+   * @param {Object} cred Credentials containing token and optional authzid.
+   * @returns {String} The encoded OAUTHBEARER response string.
    * @api public
    */
   Mechanism.prototype.response = function (cred) {
     var str = 'n,';
     if (cred.authzid) {
-      str += 'a=' + cred.authzid;
+      str += `a=${  cred.authzid}`;
     }
     str += ',%x01,auth=Bearer ';
     str += cred.token;
@@ -50,11 +52,11 @@
   /**
    * Decode a challenge issued by the server.
    *
-   * @param {String} chal
-   * @return {Mechanism} for chaining
+   * @param {String} chal Challenge string from server.
+   * @returns {Mechanism} for chaining
    * @api public
    */
-  Mechanism.prototype.challenge = function (chal) {
+  Mechanism.prototype.challenge = function (chal) { // eslint-disable-line no-unused-vars
     return this;
   };
 

package/lib/sasl/plain.js

@@ -20,6 +20,7 @@
    * References:
    *  - [RFC 4616](http://tools.ietf.org/html/rfc4616)
    *
+   * @returns {void}
    * @api public
    */
   function Mechanism() {
@@ -36,7 +37,8 @@
    *  - `password`
    *  - `authzid`   authorization identity (optional)
    *
-   * @param {Object} cred
+   * @param {Object} cred Credentials containing username, password, and optional authzid.
+   * @returns {String} The encoded PLAIN response string.
    * @api public
    */
   Mechanism.prototype.response = function (cred) {
@@ -52,11 +54,11 @@
   /**
    * Decode a challenge issued by the server.
    *
-   * @param {String} chal
-   * @return {Mechanism} for chaining
+   * @param {String} chal Challenge string from server.
+   * @returns {Mechanism} for chaining
    * @api public
    */
-  Mechanism.prototype.challenge = function (chal) {
+  Mechanism.prototype.challenge = function (chal) { // eslint-disable-line no-unused-vars
     return this;
   };
 

package/lib/sasl/scram.js

@@ -11,6 +11,12 @@
     var CLIENT_KEY = 'Client Key';
     var SERVER_KEY = 'Server Key';
 
+    /**
+     * Constructs a SCRAM SASL mechanism instance.
+     * @param {Object} [options] Optional configuration with a genNonce function.
+     * @constructs Mechanism
+     * @returns {void}
+     */
     function Mechanism(options) {
         options = options || {};
         this._genNonce = options.genNonce || utils.genNonce;
@@ -40,6 +46,8 @@
     /**
      * Parse challenge.
      *
+     * @param {String} chal Challenge string to parse.
+     * @returns {Object} Parsed key-value pairs.
      * @api private
      */
     function parse(chal) {
@@ -60,15 +68,15 @@
 
         var authzid = '';
         if (cred.authzid) {
-            authzid = 'a=' + utils.saslname(cred.authzid);
+            authzid = `a=${  utils.saslname(cred.authzid)}`;
         }
 
-        mech._gs2Header = 'n,' + authzid + ',';
+        mech._gs2Header = `n,${  authzid  },`;
 
-        var nonce = 'r=' + mech._cnonce;
-        var username = 'n=' + utils.saslname(cred.username || '');
+        var nonce = `r=${  mech._cnonce}`;
+        var username = `n=${  utils.saslname(cred.username || '')}`;
 
-        mech._clientFirstMessageBare = username + ',' + nonce;
+        mech._clientFirstMessageBare = `${username  },${  nonce}`;
         var result = mech._gs2Header + mech._clientFirstMessageBare;
 
         mech._stage = 'two';
@@ -79,11 +87,11 @@
 
     RESP.two = function (mech, cred) {
         var gs2Header = Buffer.from(mech._gs2Header).toString('base64');
-        mech._clientFinalMessageWithoutProof = 'c=' + gs2Header + ',r=' + mech._nonce;
+        mech._clientFinalMessageWithoutProof = `c=${  gs2Header  },r=${  mech._nonce}`;
 
         var saltedPassword, clientKey, serverKey;
 
-        var algorithm = cred.mechanism.substring(6).toLowerCase().replace("-", "");
+        var algorithm = cred.mechanism.substring(6).toLowerCase().replace('-', '');
 
         // If our cached salt is the same, we can reuse cached credentials to speed
         // up the hashing process.
@@ -103,16 +111,16 @@
         }
 
         var storedKey = bitops.H(algorithm, clientKey);
-        var authMessage = mech._clientFirstMessageBare + ',' +
-            mech._challenge + ',' +
-            mech._clientFinalMessageWithoutProof;
+        var authMessage = `${mech._clientFirstMessageBare  },${ 
+            mech._challenge  },${ 
+            mech._clientFinalMessageWithoutProof}`;
         var clientSignature = bitops.HMAC(algorithm, storedKey, authMessage);
 
         var clientProof = bitops.XOR(clientKey, clientSignature).toString('base64');
 
         mech._serverSignature = bitops.HMAC(algorithm, serverKey, authMessage);
 
-        var result = mech._clientFinalMessageWithoutProof + ',p=' + clientProof;
+        var result = `${mech._clientFinalMessageWithoutProof  },p=${  clientProof}`;
 
         mech._stage = 'final';
 

package/lib/utils.js

@@ -15,9 +15,9 @@
   exports.context = function(size) {
     return {buf: Buffer.alloc(size), offset: 0, id: parseInt(_.uniqueId()), triedAddrs: []};
   };
-  exports.showAddress = function(addr) { return addr.host + ':' + addr.port; };
+  exports.showAddress = function(addr) { return `${addr.host  }:${  addr.port}`; };
   exports.showArrayAddress = function(addrs) {
-    return ["[", _.map(addrs, function(a) { return exports.showAddress(a); }).join(","), "]"].join('');
+    return ['[', _.map(addrs, function(a) { return exports.showAddress(a); }).join(','), ']'].join('');
   };
 
   exports.parse = function (chal) {
@@ -89,7 +89,7 @@
           logger.trace.apply(logger, fun());
       },
       error: function() { logger.error.apply(logger, arguments); }
-    }
+    };
   };
 
   var ReplayableBuffer = function() {
@@ -129,42 +129,69 @@
         buf.copy(b);
         return b;
       }
-    }
+    };
   };
 
   var polyToString = f.dispatch(
-      function(s) { return !f.existy(s) ? 'undefined' : undefined },
-      function(s) { return _.isString(s) ? (s.length > 1024 ? s.substring(0, 1024) + '...' : s) : undefined},
-      function(s) { return _.isArray(s) ? stringifyArray(s) : undefined },
-      function(s) { return _.isObject(s) ? JSON.stringify(s) : undefined },
-      function(s) { return s.toString() });
-
+      function(s) { return !f.existy(s) ? 'undefined' : undefined; },
+      function(s) { return _.isString(s) ? (s.length > 1024 ? `${s.substring(0, 1024)  }...` : s) : undefined;},
+      function(s) { return _.isArray(s) ? stringifyArray(s) : undefined; },
+      function(s) { return _.isObject(s) ? JSON.stringify(s) : undefined; },
+      function(s) { return s.toString(); });
+
+  /**
+   * Converts a value to its string representation using polymorphic dispatch.
+   * @param {*} o Value to convert to string.
+   * @returns {string} String representation of the value.
+   */
   function str(o) {
     return polyToString(o);
   }
 
+  /**
+   * Converts an array to a bracketed, comma-separated string.
+   * @param {Array} ary Array to stringify.
+   * @returns {string} String representation of the array.
+   */
   function stringifyArray(ary) {
-    return ["[", _.map(ary, polyToString).join(","), "]"].join('');
+    return ['[', _.map(ary, polyToString).join(','), ']'].join('');
   }
 
+  /**
+   * Normalizes server address arguments into a uniform array of address objects.
+   * @param {Object|Object[]|undefined} args Address object, array of addresses, or undefined.
+   * @returns {Object[]} Array of address objects with host and port properties.
+   */
   function normalizeAddresses(args) {
     var normalizer = f.dispatch(
-        function(xs) { return _.isArray(xs) ? xs : undefined },
-        function(x) { return _.isObject(x) ? [x] : undefined },
+        function(xs) { return _.isArray(xs) ? xs : undefined; },
+        function(x) { return _.isObject(x) ? [x] : undefined; },
         function(x) {
-          if (f.existy(x)) throw new Error('Unknown server addresses: ' + x);
-          return [{port: 11222, host: '127.0.0.1'}]
+          if (f.existy(x)) throw new Error(`Unknown server addresses: ${  x}`);
+          return [{port: 11222, host: '127.0.0.1'}];
         });
     return normalizer(args);
   }
 
   var MurmurHash3 = function() {
+    /**
+     * XORs two 64-bit integers represented as two-element 32-bit int arrays.
+     * @param {number[]} m First 64-bit integer as [high, low].
+     * @param {number[]} n Second 64-bit integer as [high, low].
+     * @returns {number[]} XOR result as [high, low].
+     */
     function x64Xor(m, n) {
       // Given two 64bit ints (as an array of two 32bit ints) returns the two
       // xored together as a 64bit int (as an array of two 32bit ints).
       return [m[0] ^ n[0], m[1] ^ n[1]];
     }
 
+    /**
+     * Multiplies two 64-bit integers represented as two-element 32-bit int arrays.
+     * @param {number[]} m First 64-bit integer as [high, low].
+     * @param {number[]} n Second 64-bit integer as [high, low].
+     * @returns {number[]} Product as [high, low].
+     */
     function x64Multiply(m, n) {
       // Given two 64bit ints (as an array of two 32bit ints) returns the two
       // multiplied together as a 64bit int (as an array of two 32bit ints).
@@ -202,6 +229,12 @@
       return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
     }
 
+    /**
+     * Rotates a 64-bit integer left by the given number of bit positions.
+     * @param {number[]} m 64-bit integer as [high, low].
+     * @param {number} n Number of bit positions to rotate.
+     * @returns {number[]} Rotated result as [high, low].
+     */
     function x64Rotl(m, n) {
       // Given a 64bit int (as an array of two 32bit ints) and an int
       // representing a number of bit positions, returns the 64bit int (as an
@@ -218,6 +251,12 @@
       }
     }
 
+    /**
+     * Adds two 64-bit integers represented as two-element 32-bit int arrays.
+     * @param {number[]} m First 64-bit integer as [high, low].
+     * @param {number[]} n Second 64-bit integer as [high, low].
+     * @returns {number[]} Sum as [high, low].
+     */
     function x64Add(m, n) {
       // Given two 64bit ints (as an array of two 32bit ints) returns the two
       // added together as a 64bit int (as an array of two 32bit ints).
@@ -243,6 +282,12 @@
       return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
     }
 
+    /**
+     * Shifts a 64-bit integer left by the given number of bit positions.
+     * @param {number[]} m 64-bit integer as [high, low].
+     * @param {number} n Number of bit positions to shift.
+     * @returns {number[]} Shifted result as [high, low].
+     */
     function x64LeftShift(m, n) {
       // Given a 64bit int (as an array of two 32bit ints) and an int
       // representing a number of bit positions, returns the 64bit int (as an
@@ -257,6 +302,12 @@
         return [m[1] << (n - 32), 0];
     }
 
+    /**
+     * Reads a 64-bit block from the key buffer at the given byte index.
+     * @param {Buffer} key Key buffer to read from.
+     * @param {number} i Byte offset into the key buffer.
+     * @returns {number[]} 64-bit block as [high, low].
+     */
     function getblock(key, i) {
       return [
         ((key[i + 4] & 0xff))
@@ -270,6 +321,11 @@
       ];
     }
 
+    /**
+     * Performs the MurmurHash3 block mix operation on the hash state.
+     * @param {Object} state Mutable hash state with h1, h2, k1, k2, c1, c2 fields.
+     * @returns {void}
+     */
     function bmix(state) {
       state.k1 = x64Multiply(state.k1, state.c1);
       state.k1 = x64Rotl(state.k1, 23);
@@ -293,6 +349,11 @@
       state.c2 = x64Add(x64Multiply(state.c2, [0, 5]), [0, 0x6bce6396]);
     }
 
+    /**
+     * Applies the MurmurHash3 final mix (fmix) to a 64-bit block.
+     * @param {number[]} h 64-bit block as [high, low].
+     * @returns {number[]} Mixed result as [high, low].
+     */
     function x64Fmix(h) {
       // Given a block, returns murmurHash3's final x64 mix of that block.
       // (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the
@@ -305,17 +366,21 @@
       return h;
     }
 
-    // Used for debugging hashing
-    function toHex(bignum) {
-      var tmp0 = bignum[0] < 0 ? (bignum[0]>>>0) : bignum[0];
-      var tmp1 = bignum[1] < 0 ? (bignum[1]>>>0) : bignum[1];
-      return tmp0.toString(16) + tmp1.toString(16);
-    }
-
+    /**
+     * Converts a 32-bit integer to a 64-bit representation as a two-element array.
+     * @param {number} num 32-bit integer.
+     * @returns {number[]} 64-bit representation as [high, low].
+     */
     function _x32tox64(num) {
       return num < 0 ? [0xffffffff, num] : [0, num];
     }
 
+    /**
+     * Computes the MurmurHash3 x64 128-bit hash and returns the first 64 bits.
+     * @param {Buffer} key Key buffer to hash.
+     * @param {number[]} seed 64-bit seed as [high, low].
+     * @returns {number[]} First 64-bit hash value as [high, low].
+     */
     function murmurHash3_x64_64(key, seed) {
       var state = {};
 
@@ -389,7 +454,7 @@
         var h = murmurHash3_x64_64(key, [0, 9001]);
         return h[0] >>> 32;
       }
-    }
-  }
+    };
+  };
 
 }.call(this));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinispan",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Infinispan Javascript client",
   "main": "index",
   "typings": "./types",
@@ -8,7 +8,7 @@
     "test": "test"
   },
   "scripts": {
-    "lint": "eslint --ignore-path .gitignore .",
+    "lint": "eslint --ignore-path .gitignore lib spec index.js",
     "test": "jasmine"
   },
   "author": "Infinispan Community",

package/run-docker-testsuite.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+COMPOSE_PROJECT="ispn-test"
+
+# Always tear down on exit
+cleanup() {
+  echo "Tearing down Docker containers..."
+  docker compose -p "$COMPOSE_PROJECT" --profile failover down --remove-orphans 2>/dev/null || true
+}
+trap cleanup EXIT
+
+# ── Step 1: Generate SSL certificates if needed ─────────────────────────
+if [ ! -f "out/ssl/server/server.p12" ]; then
+  echo "Generating SSL certificates..."
+  ./make-ssl.sh
+fi
+
+# ── Step 2: Start containers ────────────────────────────────────────────
+echo "Starting Infinispan containers..."
+docker compose -p "$COMPOSE_PROJECT" up -d --wait
+docker compose -p "$COMPOSE_PROJECT" --profile failover create server-failover-one server-failover-two server-failover-three
+
+# ── Step 3: Detect container IPs ────────────────────────────────────────
+get_container_ip() {
+  docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$1"
+}
+
+export ISPN_LOCAL_HOST=$(get_container_ip ispn-local)
+export ISPN_CLUSTER1_HOST=$(get_container_ip ispn-cluster-1)
+export ISPN_CLUSTER2_HOST=$(get_container_ip ispn-cluster-2)
+export ISPN_CLUSTER3_HOST=$(get_container_ip ispn-cluster-3)
+export ISPN_SSL_HOST=$(get_container_ip ispn-ssl)
+export ISPN_EARTH_HOST=$(get_container_ip ispn-earth)
+export ISPN_MOON_HOST=$(get_container_ip ispn-moon)
+export ISPN_FAILOVER1_HOST=$(get_container_ip ispn-failover-1)
+export ISPN_FAILOVER2_HOST=$(get_container_ip ispn-failover-2)
+export ISPN_FAILOVER3_HOST=$(get_container_ip ispn-failover-3)
+export ISPN_DOCKER=true
+
+echo "Container IPs:"
+echo "  local:    $ISPN_LOCAL_HOST"
+echo "  cluster:  $ISPN_CLUSTER1_HOST, $ISPN_CLUSTER2_HOST, $ISPN_CLUSTER3_HOST"
+echo "  ssl:      $ISPN_SSL_HOST"
+echo "  failover: $ISPN_FAILOVER1_HOST, $ISPN_FAILOVER2_HOST, $ISPN_FAILOVER3_HOST"
+echo "  earth:    $ISPN_EARTH_HOST"
+echo "  moon:     $ISPN_MOON_HOST"
+
+# ── Step 4: Wait for cluster to form ────────────────────────────────────
+echo "Waiting for cluster to form..."
+MAX_RETRIES=30
+for i in $(seq 1 $MAX_RETRIES); do
+  CLUSTER_SIZE=$(curl -sf --digest -u admin:pass "http://$ISPN_CLUSTER1_HOST:11222/rest/v2/container" 2>/dev/null | python3 -c "import sys,json; print(json.load(sys.stdin).get('cluster_size',0))" 2>/dev/null || echo "0")
+  if [ "$CLUSTER_SIZE" = "3" ]; then
+    echo "Cluster formed with 3 nodes."
+    break
+  fi
+  if [ "$i" = "$MAX_RETRIES" ]; then
+    echo "ERROR: Cluster did not form within timeout (size=$CLUSTER_SIZE)"
+    exit 1
+  fi
+  echo "  Cluster size: $CLUSTER_SIZE (attempt $i/$MAX_RETRIES)"
+  sleep 5
+done
+
+# ── Step 5: Run tests ──────────────────────────────────────────────────
+echo "Running tests..."
+npx jasmine "$@"