infinispan 0.14.0 → 0.15.0

package/lib/listeners.js

@@ -10,6 +10,8 @@
 
   var events = require('events');
 
+  var CQ_FACTORY = 'continuous-query-filter-converter-factory';
+
   module.exports = listeners;
 
   /**
@@ -132,8 +134,10 @@
       dispatchEvent: function(event, listenerId, bytebuf, emitFunc) {
         return function() {
           var l = listeners.get(listenerId);
-          if (f.existy(l))
-            return emitFunc(event, l.emitter, bytebuf, listenerId);
+          if (f.existy(l)) {
+            var emit = l.cqEmit || emitFunc;
+            return emit(event, l.emitter, bytebuf, listenerId);
+          }
 
           logger.error('No emitter exists for listener %s', listenerId);
           return true;
@@ -152,7 +156,117 @@
       setProtocol: function(newProtocol) {
         protocol = newProtocol;
       },
+      /**
+       * Register a continuous query listener.
+       * @param {Object} transport Transport instance.
+       * @param {Object} ctx Request context.
+       * @param {string} queryString Ickle query string.
+       * @param {Object} [opts] Options with optional params map.
+       * @returns {Promise<Object>} ContinuousQuery handle.
+       */
+      addContinuousQueryListener: function(transport, ctx, queryString, opts) {
+        opts = opts || {};
+        var listenerId = _.uniqueId('cq_');
+        logger.debugl(function() {
+          return ['Invoke addContinuousQueryListener(msgId=%d,query=%s,listenerId=%s)',
+                  ctx.id, queryString, listenerId]; });
+
+        var cqParams = buildCQParams(queryString, opts.params);
+
+        var listenerOpts = {
+          includeState: true,
+          useRawData: true,
+          filterFactory: { name: CQ_FACTORY, params: cqParams },
+          converterFactory: { name: CQ_FACTORY, params: cqParams }
+        };
+
+        var encodeListenerAddCommon = protocol.encodeListenerAdd(listenerId, listenerOpts)();
+        var encodeListenerAddInterests = protocol.encodeListenerInterests(listenerOpts);
+        var encodeListenerAdd = function() {
+          return f.cat(encodeListenerAddCommon, encodeListenerAddInterests);
+        };
+
+        var bufferedEvents = [];
+        var buffering = true;
+
+        var cqEmitFn = function(event, emitter, bytebuf) {
+          var payloadLength = codec.decodeVariableBytes()(bytebuf);
+          if (!f.existy(payloadLength) || !f.existy(payloadLength.answer))
+            return false;
+          var payload = payloadLength.answer;
+          var wrapped = codec.decodeWrappedMessage(payload);
+          if (!f.existy(wrapped) || !f.existy(wrapped.wrappedMessage))
+            return true;
+          var cqResult = codec.decodeContinuousQueryResult(wrapped.wrappedMessage);
+          if (buffering) {
+            bufferedEvents.push(cqResult);
+          } else {
+            emitter.emit(cqResult.resultType, cqResult.key, cqResult.value, cqResult.projection);
+          }
+          return true;
+        };
+
+        var preWrite = function(conn) {
+          var emitter = new events.EventEmitter();
+          listeners.put(listenerId, {
+            id: listenerId,
+            emitter: emitter,
+            conn: conn,
+            cqEmit: cqEmitFn
+          });
+        };
+
+        var remote = futurePreWrite(transport, ctx, 0x25
+          , encodeListenerAdd, protocol.complete(protocol.hasSuccess)
+          , listenerOpts, preWrite);
+
+        return remote
+          .then(function(success) {
+            if (success) {
+              var l = listeners.get(listenerId);
+              var emitter = l.emitter;
+              return {
+                on: function(event, callback) {
+                  emitter.on(event, callback);
+                  if (buffering) {
+                    buffering = false;
+                    bufferedEvents.forEach(function(ev) {
+                      emitter.emit(ev.resultType, ev.key, ev.value, ev.projection);
+                    });
+                    bufferedEvents = [];
+                  }
+                  return this;
+                },
+                getListenerId: function() { return listenerId; }
+              };
+            }
+            listen.removeListeners(listenerId);
+            return undefined;
+          })
+          .catch(function(err) {
+            listen.removeListeners(listenerId);
+            throw err;
+          });
+      },
     };
+
+    /**
+     * Build CQ factory params from query and named params.
+     * @param {string} queryString Ickle query.
+     * @param {Object} [params] Named parameter map.
+     * @returns {Buffer[]} Array of wrapped param byte arrays.
+     */
+    function buildCQParams(queryString, params) {
+      var result = [codec.wrapScalar(queryString)];
+      if (f.existy(params)) {
+        _.each(params, function(value, name) {
+          result.push(codec.wrapScalar(name));
+          result.push(codec.wrapScalar(value));
+        });
+      }
+      return result;
+    }
+
     return listen;
   }
 

package/lib/protocols.js

@@ -699,18 +699,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 +1118,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};
         }
       }
     };

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.15.0",
   "description": "Infinispan Javascript client",
   "main": "index",
   "typings": "./types",
@@ -9,7 +9,13 @@
   },
   "scripts": {
     "lint": "eslint --ignore-path .gitignore lib spec index.js",
-    "test": "jasmine"
+    "test": "jasmine",
+    "test:docker": "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 +34,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 +42,7 @@
   "devDependencies": {
     "eslint": "^8.26.0",
     "jasmine": "^6.1.0",
+    "jsdoc": "^4.0.2",
     "long": "^5.2.3"
   }
 }

package/types/index.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Connect to an Infinispan Server using a Hot Rod URI.
+ *
+ * URI format: hotrod://[user:pass@]host1[:port1][,host2[:port2]][?params]
+ * Use hotrods:// to enable TLS.
+ *
+ * Supported query parameters:
+ *   sasl_mechanism, trust_store_file_name (alias trust_ca),
+ *   key_store_file_name (alias client_cert), key_store_password (alias client_key),
+ *   sni_host_name (alias sni_host), max_retries, cache_name.
+ *
+ * @param uri Hot Rod URI string.
+ * @param options Optional overrides (take precedence over URI values).
+ */
+export function client(uri: string, options?: Record<string, any>): Promise<any>;
+
 export function client(args: {
     /**
      * - Server host name.
@@ -668,6 +684,34 @@ export function client(args: {
          * @since 0.3
          */
         removeListener: (listenerId: string) => Promise<any>;
+        /**
+         * Register a continuous query that watches for cache changes
+         * matching the given Ickle query.
+         *
+         * @param queryString Ickle query string.
+         * @param opts Optional CQ options.
+         * @returns A promise completed with a ContinuousQuery handle.
+         * @memberof Client#
+         * @since 0.16
+         */
+        addContinuousQuery: (queryString: string, opts?: {
+            /** Named parameter bindings for the Ickle query. */
+            params?: { [name: string]: string | number | boolean };
+        }) => Promise<{
+            /** Register a callback for continuous query events. */
+            on(event: 'joining' | 'leaving' | 'updated', callback: (key: Buffer, value: Buffer, projection?: any[]) => void): any;
+            /** Get the listener ID for this continuous query. */
+            getListenerId(): string;
+        }>;
+        /**
+         * Remove a continuous query.
+         *
+         * @param cq ContinuousQuery handle returned by addContinuousQuery.
+         * @returns A promise completed when the continuous query has been removed.
+         * @memberof Client#
+         * @since 0.16
+         */
+        removeContinuousQuery: (cq: { getListenerId(): string }) => Promise<any>;
         /**
          * Create a distributed counter.
          *

package/Dockerfile.server

@@ -1,8 +0,0 @@
-FROM quay.io/infinispan/server:16.1.3
-
-# Install Nashorn script engine for server-side JavaScript execution
-RUN /opt/infinispan/bin/cli.sh install org.openjdk.nashorn:nashorn-core:15.4 && \
-    /opt/infinispan/bin/cli.sh install org.ow2.asm:asm:9.4 && \
-    /opt/infinispan/bin/cli.sh install org.ow2.asm:asm-commons:9.4 && \
-    /opt/infinispan/bin/cli.sh install org.ow2.asm:asm-tree:9.4 && \
-    /opt/infinispan/bin/cli.sh install org.ow2.asm:asm-util:9.4