infinispan 0.14.0 → 0.16.0

package/lib/protocols.js

@@ -23,6 +23,15 @@
   var INFINITE_LIFESPAN = 0x01, INFINITE_MAXIDLE = 0x02; // Duration flag masks
   var MAGIC = 0xA0;
 
+  var FLAGS = {
+    FORCE_RETURN_VALUE: 0x0001,
+    DEFAULT_LIFESPAN: 0x0002,
+    DEFAULT_MAXIDLE: 0x0004,
+    SKIP_CACHE_LOAD: 0x0008,
+    SKIP_INDEXING: 0x0010,
+    SKIP_LISTENER_NOTIFICATION: 0x0020
+  };
+
   /**
    * Creates decode actions for a key-value pair.
    * @param {Object} decoderKey Key decoder descriptor.
@@ -129,8 +138,10 @@
     };
 
     return {
-      buildFlags: function (opts) { // TODO: Move out to a Mixin (similar to expiry)
-        return hasOptPrev(opts) ? 0x01 : 0;
+      buildFlags: function (opts) {
+        var result = hasOptPrev(opts) ? FLAGS.FORCE_RETURN_VALUE : 0;
+        if (hasOpt(opts, 'flags')) result |= opts.flags;
+        return result;
       },
       /**
        * Returns the protocol version as a human-readable string (e.g. '3.1').
@@ -577,8 +588,8 @@
         return hasPrevious(header.status);
       },
       isEvent: function(header) {
-        //return ((op(header) >> 4) & 0x06) == 0x06;
-        return ((header.opCode >> 4) & 0x06) == 0x06;
+        var op = header.opCode;
+        return op >= 0x60 && op <= 0x64;
       },
       isError: function(header) {
         return header.opCode == 0x50;
@@ -699,18 +710,31 @@
 
         var steps = [
           codec.encodeString(listenerId),     // listener id
-          codec.encodeUByte(includeState),    // include state
-          codec.encodeUByte(0)                // TODO filter factory name
+          codec.encodeUByte(includeState)     // include state
         ];
 
+        // Filter factory
+        if (_.has(opts, 'filterFactory') && _.has(opts.filterFactory, 'name')) {
+          steps.push(codec.encodeString(opts.filterFactory.name));
+          var filterParams = opts.filterFactory.params || [];
+          steps.push(codec.encodeUByte(filterParams.length));
+          filterParams.forEach(function(p) { steps.push(codec.encodeBytesWithLength(p)); });
+        } else {
+          steps.push(codec.encodeUByte(0));
+        }
+
+        // Converter factory
         if (_.has(opts, 'converterFactory') && _.has(opts.converterFactory, 'name')) {
           steps.push(codec.encodeString(opts.converterFactory.name));
-          steps.push(codec.encodeUByte(0));   // TODO add converter parameter support
+          var converterParams = opts.converterFactory.params || [];
+          steps.push(codec.encodeUByte(converterParams.length));
+          converterParams.forEach(function(p) { steps.push(codec.encodeBytesWithLength(p)); });
         } else {
-          steps.push(codec.encodeUByte(0));   // no converter
+          steps.push(codec.encodeUByte(0));
         }
 
-        steps.push(codec.encodeUByte(0));     // raw data disabled
+        // Raw data
+        steps.push(codec.encodeUByte(hasOpt(opts, 'useRawData') ? 1 : 0));
 
         return function() {
           return steps;
@@ -1105,9 +1129,9 @@
         var authDone = DECODE_UBYTE(bytebuf);
         if(authDone == 1) {
           logger.tracef('SASL authentication complete');
-          return {result:  {response: DECODE_UBYTE(bytebuf)}, continue: true};
+          return {result:  {response: DECODE_UBYTE(bytebuf), complete: true}, continue: true};
         } else {
-          return {result:  {response: DECODE_STRING(bytebuf)}, continue: true};
+          return {result:  {response: DECODE_STRING(bytebuf), complete: false}, continue: true};
         }
       }
     };
@@ -1310,6 +1334,81 @@
     };
   }());
 
+  var MultimapMixin = (function() {
+    var SUPPORTS_DUPLICATES = codec.encodeUByte(0x00);
+
+    return {
+      encodeMultimapKey: function(k) {
+        var outer = this;
+        return function() {
+          return [outer.encodeMediaKey(k), SUPPORTS_DUPLICATES];
+        };
+      },
+      encodeMultimapPut: function(k, v) {
+        var outer = this;
+        return function(opts) {
+          return f.cat(
+            [outer.encodeMediaKey(k)],
+            outer.encodeExpiry(opts),
+            [outer.encodeMediaValue(v), SUPPORTS_DUPLICATES]
+          );
+        };
+      },
+      encodeMultimapKeyValue: function(k, v) {
+        var outer = this;
+        return function() {
+          return f.cat(
+            [outer.encodeMediaKey(k)],
+            [codec.encodeUByte(0x77)],
+            [outer.encodeMediaValue(v), SUPPORTS_DUPLICATES]
+          );
+        };
+      },
+      encodeMultimapValue: function(v) {
+        var outer = this;
+        return function() {
+          return [codec.encodeUByte(0x77), outer.encodeMediaValue(v), SUPPORTS_DUPLICATES];
+        };
+      },
+      encodeMultimapSupportsDuplicates: function() {
+        return function() {
+          return [SUPPORTS_DUPLICATES];
+        };
+      },
+      decodeMultimapCollection: function() {
+        var decoderValue = decoderMedia(this.valueMediaType);
+        var decodeSingleValue = decodeSingle(decoderValue);
+        return function(header, bytebuf) {
+          if (header.status !== 0x00 && header.status !== 0x03)
+            return {result: [], continue: true};
+          var count = DECODE_VINT(bytebuf);
+          if (!f.existy(count))
+            return {continue: false};
+          var values = [];
+          for (var i = 0; i < count; i++) {
+            var v = decodeSingleValue(bytebuf);
+            if (!f.existy(v))
+              return {continue: false};
+            values.push(v);
+          }
+          return {result: values, continue: true};
+        };
+      },
+      decodeMultimapBoolean: function(header, bytebuf) {
+        var b = DECODE_UBYTE(bytebuf);
+        if (!f.existy(b))
+          return {continue: false};
+        return {result: b !== 0, continue: true};
+      },
+      decodeMultimapSize: function(header, bytebuf) {
+        var size = f.actions([codec.decodeVLong()], codec.lastDecoded)(bytebuf);
+        if (!f.existy(size) && size !== 0)
+          return {continue: false};
+        return {result: size, continue: true};
+      }
+    };
+  }());
+
   /**
    * Protocol 4.0+ requires an 'otherParams' map after media types in the header.
    * This mixin overrides stepsHeader to append the count (0 = no params).
@@ -1415,6 +1514,54 @@
   }());
   
 
+  var DECODE_INT = f.actions([codec.decodeInt()], codec.lastDecoded);
+
+  var TransactionMixin = {
+    encodeXid: function(xid) {
+      return [
+        codec.encodeSignedInt(xid.formatId),
+        codec.encodeBytesWithLength(xid.globalTxId),
+        codec.encodeBytesWithLength(xid.branchQualifier)
+      ];
+    },
+    encodePrepare: function(xid, modifications, onePhaseCommit, timeout) {
+      var outer = this;
+      return function() {
+        var steps = outer.encodeXid(xid);
+        steps.push(codec.encodeUByte(onePhaseCommit ? 1 : 0));
+        steps.push(codec.encodeUByte(0)); // not recoverable
+        steps.push(codec.encodeLong(timeout));
+        steps.push(codec.encodeVInt(modifications.length));
+        for (var i = 0; i < modifications.length; i++) {
+          var mod = modifications[i];
+          steps.push(outer.encodeMediaKey(mod.key));
+          steps.push(codec.encodeUByte(mod.controlByte));
+          if (!(mod.controlByte & 0x1) && !(mod.controlByte & 0x2)) {
+            steps.push(codec.encodeBytes(mod.versionRead));
+          }
+          if (!(mod.controlByte & 0x4)) {
+            steps.push(codec.encodeUByte(0x77));
+            steps.push(outer.encodeMediaValue(mod.value));
+          }
+        }
+        return steps;
+      };
+    },
+    encodeXidOnly: function(xid) {
+      var outer = this;
+      return function() {
+        return outer.encodeXid(xid);
+      };
+    },
+    decodeXaResponse: function() {
+      return function(header, bytebuf) {
+        var code = DECODE_INT(bytebuf);
+        if (!f.existy(code)) return {continue: false};
+        return {result: code, continue: true};
+      };
+    }
+  };
+
   /**
    * Constructs a Hot Rod protocol instance for the given version.
    * @param {number} v Protocol version number.
@@ -1503,13 +1650,7 @@
       , Ping29Mixin
       , ProtostreamType
       , ProtobufRoot
-      // TODO 2.6 new ops: getStream and putStream
-      // TODO 2.6 add listener change: listener event interests
-      // TODO 2.7 new ops: prepare, commit and rollback
-      // TODO 2.7 new ops: counter operations
-      // TODO 2.7 new events: counter events
-      // TODO 2.8 listener events: can come from any connection
-      // TODO 2.8 header change: media types
+      , TransactionMixin
   );
 
   _.extend(Protocol30.prototype
@@ -1525,6 +1666,7 @@
     , Ping30Mixin
     , ProtostreamType
     , ProtobufRoot
+    , TransactionMixin
   );
 
   _.extend(Protocol31.prototype
@@ -1539,9 +1681,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
-    // TODO 3.1 new ops: bloom filter near-cache
+    , TransactionMixin
   );
 
   _.extend(Protocol40.prototype
@@ -1558,8 +1701,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
+    , TransactionMixin
   );
 
   _.extend(Protocol41.prototype
@@ -1576,9 +1721,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
-    // TODO 4.1 new ops: chunked streaming (GetStreamStart/Next/End, PutStreamStart/Next/End)
+    , TransactionMixin
   );
 
   exports.version22 = function(clientOpts) {
@@ -1613,6 +1759,8 @@
 
   exports.VERSION_ORDER = VERSION_ORDER;
 
+  exports.FLAGS = FLAGS;
+
   /**
    * Creates a protocol instance for the given version string.
    * @param {string} version Protocol version (e.g. '3.1', '4.0').

package/lib/transaction.js

@@ -0,0 +1,123 @@
+'use strict';
+
+(function() {
+
+  var crypto = require('crypto');
+
+  var FORMAT_ID = 0x48525458;
+  var NOT_READ = 0x1, NON_EXISTING = 0x2, REMOVE_OP = 0x4;
+  var XA_OK = 0, XA_RDONLY = 3;
+
+  function generateXid() {
+    return {
+      formatId: FORMAT_ID,
+      globalTxId: crypto.randomBytes(16),
+      branchQualifier: crypto.randomBytes(16)
+    };
+  }
+
+  function TransactionContext() {
+    this.xid = generateXid();
+    // key (string) → { value, removed (bool), versionRead (Buffer|null), wasRead (bool), existed (bool) }
+    this.entries = new Map();
+    this.active = true;
+  }
+
+  TransactionContext.prototype.trackPut = function(key, value) {
+    var entry = this.entries.get(key);
+    if (entry) {
+      entry.value = value;
+      entry.removed = false;
+    } else {
+      this.entries.set(key, {
+        value: value,
+        removed: false,
+        versionRead: null,
+        wasRead: false,
+        existed: false
+      });
+    }
+  };
+
+  TransactionContext.prototype.trackRemove = function(key) {
+    var entry = this.entries.get(key);
+    if (entry) {
+      entry.removed = true;
+      entry.value = undefined;
+    } else {
+      this.entries.set(key, {
+        value: undefined,
+        removed: true,
+        versionRead: null,
+        wasRead: false,
+        existed: false
+      });
+    }
+  };
+
+  TransactionContext.prototype.trackRead = function(key, meta) {
+    var entry = this.entries.get(key);
+    var version = meta ? meta.version : null;
+    var existed = meta !== undefined;
+    if (entry) {
+      if (!entry.wasRead) {
+        entry.wasRead = true;
+        entry.versionRead = version;
+        entry.existed = existed;
+      }
+    } else {
+      this.entries.set(key, {
+        value: meta ? meta.value : undefined,
+        removed: false,
+        versionRead: version,
+        wasRead: true,
+        existed: existed
+      });
+    }
+  };
+
+  TransactionContext.prototype.getLocalValue = function(key) {
+    var entry = this.entries.get(key);
+    if (!entry) return { found: false };
+    if (entry.removed) return { found: true, value: undefined };
+    if (entry.value !== undefined) return { found: true, value: entry.value };
+    return { found: false };
+  };
+
+  TransactionContext.prototype.computeControlByte = function(entry) {
+    var control = 0;
+    if (!entry.wasRead) {
+      control |= NOT_READ;
+    } else if (!entry.existed) {
+      control |= NON_EXISTING;
+    }
+    if (entry.removed) {
+      control |= REMOVE_OP;
+    }
+    return control;
+  };
+
+  TransactionContext.prototype.getModifications = function() {
+    var mods = [];
+    this.entries.forEach(function(entry, key) {
+      var control = this.computeControlByte(entry);
+      mods.push({
+        key: key,
+        controlByte: control,
+        versionRead: entry.versionRead,
+        value: entry.value
+      });
+    }.bind(this));
+    return mods;
+  };
+
+  exports.TransactionContext = TransactionContext;
+  exports.generateXid = generateXid;
+  exports.FORMAT_ID = FORMAT_ID;
+  exports.NOT_READ = NOT_READ;
+  exports.NON_EXISTING = NON_EXISTING;
+  exports.REMOVE_OP = REMOVE_OP;
+  exports.XA_OK = XA_OK;
+  exports.XA_RDONLY = XA_RDONLY;
+
+}.call(this));

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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinispan",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Infinispan Javascript client",
   "main": "index",
   "typings": "./types",
@@ -9,7 +9,12 @@
   },
   "scripts": {
     "lint": "eslint --ignore-path .gitignore lib spec index.js",
-    "test": "jasmine"
+    "test": "node scripts/docker-test.js",
+    "docker:up": "docker compose -p ispn-test up -d --wait && docker compose -p ispn-test --profile failover create server-failover-one server-failover-two server-failover-three",
+    "docker:down": "docker compose -p ispn-test --profile failover down --remove-orphans",
+    "ssl:generate": "node scripts/make-ssl.js",
+    "docs:api": "jsdoc lib/*.js",
+    "docs:user": "node scripts/gen-asciidoc.js"
   },
   "author": "Infinispan Community",
   "license": "Apache-2.0",
@@ -28,7 +33,6 @@
   },
   "dependencies": {
     "buffer-xor": "^2.0.2",
-    "jsdoc": "^4.0.2",
     "log4js": "^6.4.6",
     "protobufjs": "^7.0.0",
     "underscore": "^1.13.3",
@@ -37,6 +41,7 @@
   "devDependencies": {
     "eslint": "^8.26.0",
     "jasmine": "^6.1.0",
+    "jsdoc": "^4.0.2",
     "long": "^5.2.3"
   }
 }