infinispan 0.13.0 → 0.15.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/uri.js

@@ -0,0 +1,206 @@
+'use strict';
+
+(function() {
+
+  var _ = require('underscore');
+
+  var DEFAULT_PORT = 11222;
+
+  var QUERY_PARAMS = {
+    'sasl_mechanism':         { path: ['authentication', 'saslMechanism'], type: 'string' },
+    'trust_store_file_name':  { path: ['ssl', 'trustCerts'], type: 'string_array' },
+    'trust_ca':               { path: ['ssl', 'trustCerts'], type: 'string_array' },
+    'key_store_file_name':    { path: ['ssl', 'clientAuth', 'cert'], type: 'string' },
+    'client_cert':            { path: ['ssl', 'clientAuth', 'cert'], type: 'string' },
+    'key_store_password':     { path: ['ssl', 'clientAuth', 'key'], type: 'string' },
+    'client_key':             { path: ['ssl', 'clientAuth', 'key'], type: 'string' },
+    'sni_host_name':          { path: ['ssl', 'sniHostName'], type: 'string' },
+    'sni_host':               { path: ['ssl', 'sniHostName'], type: 'string' },
+    'max_retries':            { path: ['maxRetries'], type: 'int' },
+    'cache_name':             { path: ['cacheName'], type: 'string' }
+  };
+
+  /**
+   * Checks whether the argument is a Hot Rod URI string.
+   * @param {*} arg Value to check.
+   * @returns {boolean} True if the argument is a hotrod:// or hotrods:// URI.
+   */
+  function isHotrodURI(arg) {
+    return _.isString(arg) &&
+      (arg.indexOf('hotrod://') === 0 || arg.indexOf('hotrods://') === 0);
+  }
+
+  /**
+   * Splits a host string into host and port, handling IPv6 bracket notation.
+   * @param {string} hostStr Host string like "host:port" or "[::1]:port".
+   * @returns {{host: string, port: number}} Parsed host and port.
+   */
+  function splitHostPort(hostStr) {
+    hostStr = hostStr.trim();
+    if (hostStr.length === 0) {
+      throw new Error('Empty host in URI');
+    }
+
+    // IPv6 bracket notation: [::1]:port
+    if (hostStr.charAt(0) === '[') {
+      var closeBracket = hostStr.indexOf(']');
+      if (closeBracket === -1) {
+        throw new Error(`Invalid IPv6 address, missing closing bracket: ${hostStr}`);
+      }
+      var ipv6Host = hostStr.substring(1, closeBracket);
+      var afterBracket = hostStr.substring(closeBracket + 1);
+      if (afterBracket.length === 0) {
+        return { host: ipv6Host, port: DEFAULT_PORT };
+      }
+      if (afterBracket.charAt(0) === ':') {
+        var ipv6Port = parseInt(afterBracket.substring(1), 10);
+        if (isNaN(ipv6Port)) {
+          throw new Error(`Invalid port in URI: ${afterBracket.substring(1)}`);
+        }
+        return { host: ipv6Host, port: ipv6Port };
+      }
+      throw new Error(`Invalid IPv6 host format: ${hostStr}`);
+    }
+
+    var lastColon = hostStr.lastIndexOf(':');
+    if (lastColon === -1) {
+      return { host: hostStr, port: DEFAULT_PORT };
+    }
+
+    var host = hostStr.substring(0, lastColon);
+    var portStr = hostStr.substring(lastColon + 1);
+    var port = parseInt(portStr, 10);
+    if (isNaN(port)) {
+      throw new Error(`Invalid port in URI: ${portStr}`);
+    }
+    return { host: host, port: port };
+  }
+
+  /**
+   * Sets a nested value in an object given a path array.
+   * @param {Object} obj Target object.
+   * @param {string[]} path Array of keys.
+   * @param {*} value Value to set.
+   * @returns {void}
+   */
+  function setNested(obj, path, value) {
+    var current = obj;
+    for (var i = 0; i < path.length - 1; i++) {
+      if (!current[path[i]] || !_.isObject(current[path[i]])) {
+        current[path[i]] = {};
+      }
+      current = current[path[i]];
+    }
+    current[path[path.length - 1]] = value;
+  }
+
+  /**
+   * Parses a Hot Rod URI string into servers and options.
+   * @param {string} uriString URI in the format hotrod://[user:pass@]host1[:port1][,host2[:port2]][?params].
+   * @returns {{servers: Array<{host: string, port: number}>, options: Object}} Parsed result.
+   */
+  function parseHotrodURI(uriString) {
+    var tls = false;
+    var rest;
+
+    if (uriString.indexOf('hotrods://') === 0) {
+      tls = true;
+      rest = uriString.substring('hotrods://'.length);
+    } else if (uriString.indexOf('hotrod://') === 0) {
+      rest = uriString.substring('hotrod://'.length);
+    } else {
+      throw new Error('Invalid URI scheme, expected hotrod:// or hotrods://');
+    }
+
+    // Split authority from query string
+    var queryString = '';
+    var qIndex = rest.indexOf('?');
+    var authority;
+    if (qIndex !== -1) {
+      authority = rest.substring(0, qIndex);
+      queryString = rest.substring(qIndex + 1);
+    } else {
+      authority = rest;
+    }
+
+    // Split userinfo from hosts (find last @ to handle passwords with @)
+    var userName, password;
+    var atIndex = authority.lastIndexOf('@');
+    var hostsStr;
+    if (atIndex !== -1) {
+      var userinfo = authority.substring(0, atIndex);
+      hostsStr = authority.substring(atIndex + 1);
+      var colonIndex = userinfo.indexOf(':');
+      if (colonIndex !== -1) {
+        userName = decodeURIComponent(userinfo.substring(0, colonIndex));
+        password = decodeURIComponent(userinfo.substring(colonIndex + 1));
+      } else {
+        userName = decodeURIComponent(userinfo);
+      }
+    } else {
+      hostsStr = authority;
+    }
+
+    if (hostsStr.length === 0) {
+      throw new Error('No host specified in URI');
+    }
+
+    // Parse comma-separated hosts
+    var hostParts = hostsStr.split(',');
+    var servers = [];
+    for (var i = 0; i < hostParts.length; i++) {
+      if (hostParts[i].length > 0) {
+        servers.push(splitHostPort(hostParts[i]));
+      }
+    }
+    if (servers.length === 0) {
+      throw new Error('No host specified in URI');
+    }
+
+    // Build options from URI components
+    var options = {};
+
+    if (tls) {
+      setNested(options, ['ssl', 'enabled'], true);
+    }
+
+    if (userName !== undefined) {
+      setNested(options, ['authentication', 'enabled'], true);
+      setNested(options, ['authentication', 'userName'], userName);
+      if (password !== undefined) {
+        setNested(options, ['authentication', 'password'], password);
+      }
+      setNested(options, ['authentication', 'saslMechanism'], 'PLAIN');
+    }
+
+    // Parse query parameters
+    if (queryString.length > 0) {
+      var params = new URLSearchParams(queryString);
+      params.forEach(function(value, key) {
+        var mapping = QUERY_PARAMS[key];
+        if (!mapping) {
+          throw new Error(`Unknown URI parameter: ${key}`);
+        }
+
+        var parsed;
+        if (mapping.type === 'int') {
+          parsed = parseInt(value, 10);
+          if (isNaN(parsed)) {
+            throw new Error(`Invalid integer value for ${key}: ${value}`);
+          }
+        } else if (mapping.type === 'string_array') {
+          parsed = [value];
+        } else {
+          parsed = value;
+        }
+        setNested(options, mapping.path, parsed);
+      });
+    }
+
+    return { servers: servers, options: options };
+  }
+
+  exports.isHotrodURI = isHotrodURI;
+  exports.parseHotrodURI = parseHotrodURI;
+
+}.call(this));