infinispan 0.14.0 → 0.16.0

package/lib/infinispan.js

@@ -13,10 +13,12 @@
   var f = require('./functional');
   var codec = require('./codec');
   var u = require('./utils');
+  var uri = require('./uri');
   var protocols = require('./protocols');
   var io = require('./io');
   var listeners = require('./listeners');
   var nearCacheFactory = require('./near-cache');
+  var tx = require('./transaction');
 
   var Client = function(addrs, clientOpts) {
     var logger = u.logger('client');
@@ -38,6 +40,7 @@
     var p = protocolResolver(clientOpts['version']);
     var listen = listeners(p);
     var nc = clientOpts.nearCache ? nearCacheFactory(clientOpts.nearCache.maxEntries) : null;
+    var txCtx = null;
 
     var TINY = 16, SMALL = 32, MEDIUM = 64, BIG = 128;
 
@@ -326,6 +329,17 @@
        * @since 0.3
        */
       get: function(k) {
+        if (txCtx) {
+          var local = txCtx.getLocalValue(k);
+          if (local.found) return Promise.resolve(local.value);
+          var ctx = transport.context(SMALL);
+          logger.debugf('Invoke transactional get(msgId=%d,key=%s)', ctx.id, u.str(k));
+          var decoder = p.decodeWithMeta();
+          return futureKey(ctx, 0x1B, k, p.encodeKey(k), decoder).then(function(meta) {
+            txCtx.trackRead(k, meta);
+            return meta ? meta.value : undefined;
+          });
+        }
         if (nc) {
           var cached = nc.get(k);
           if (cached !== undefined) {
@@ -438,6 +452,8 @@
        * Lifespan for the stored entry.
        * @property {DurationUnit} maxIdle -
        * Max idle time for the stored entry.
+       * @property {Number} flags - Bitwise OR of Hot Rod flags
+       * (e.g. infinispan.flags.SKIP_CACHE_LOAD | infinispan.flags.SKIP_INDEXING).
        * @since 0.3
        */
       /**
@@ -454,6 +470,11 @@
        * @since 0.3
        */
       put: function(k, v, opts) {
+        if (txCtx) {
+          logger.debugf('Transactional put(key=%s)', u.str(k));
+          txCtx.trackPut(k, v);
+          return Promise.resolve(undefined);
+        }
         if (nc) nc.remove(k);
         var ctx = transport.context(MEDIUM);
         logger.debugl(function() { return ['Invoke put(msgId=%d,key=%s,value=%s,opts=%s)',
@@ -485,6 +506,11 @@
        * @since 0.3
        */
       remove: function(k, opts) {
+        if (txCtx) {
+          logger.debugf('Transactional remove(key=%s)', u.str(k));
+          txCtx.trackRemove(k);
+          return Promise.resolve(true);
+        }
         if (nc) nc.remove(k);
         var ctx = transport.context(SMALL);
         logger.debugl(function() {return ['Invoke remove(msgId=%d,key=%s,opts=%s)',
@@ -824,6 +850,58 @@
           return false;
         });
       },
+      /**
+       * Continuous query options.
+       *
+       * @typedef {Object} ContinuousQueryOptions
+       * @property {Object} [params] - Named parameter bindings for the Ickle query.
+       * @since 0.16
+       */
+      /**
+       * Register a continuous query that watches for cache changes
+       * matching the given Ickle query.
+       *
+       * @param {String} queryString Ickle query string.
+       * @param {ContinuousQueryOptions=} opts Optional CQ options.
+       * @returns {Promise<Object>}
+       * A promise completed with a ContinuousQuery handle.
+       * Use cq.on('joining', fn), cq.on('leaving', fn), cq.on('updated', fn)
+       * to receive events.
+       * @memberof Client#
+       * @since 0.16
+       */
+      addContinuousQuery: function(queryString, opts) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke addContinuousQuery(msgId=%d,query=%s)', ctx.id, queryString);
+        return listen.addContinuousQueryListener(transport, ctx, queryString, opts);
+      },
+      /**
+       * Remove a continuous query.
+       *
+       * @param {Object} cq ContinuousQuery handle returned by addContinuousQuery.
+       * @returns {Promise}
+       * A promise completed when the continuous query has been removed.
+       * @memberof Client#
+       * @since 0.16
+       */
+      removeContinuousQuery: function(cq) {
+        var listenerId = cq.getListenerId();
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke removeContinuousQuery(msgId=%d,listenerId=%s)', ctx.id, listenerId);
+        var conn = listen.findConnectionListener(listenerId);
+        if (!f.existy(conn))
+          return Promise.reject(
+            new Error(`No server connection for CQ listener (listenerId=${  listenerId  })`));
+
+        var remote = futurePinned(ctx, 0x27, p.encodeListenerId(listenerId), p.complete(p.hasSuccess), conn);
+        return remote.then(function (success) {
+          if (success) {
+            listen.removeListeners(listenerId);
+            return true;
+          }
+          return false;
+        });
+      },
       /**
        * Add script to server(s).
        *
@@ -1020,6 +1098,122 @@
         logger.debugf('Invoke counterGetAndSet(msgId=%d,name=%s,value=%d)', ctx.id, name, value);
         return future(ctx, 0x7F, p.encodeCounterNameValue(name, value), p.decodeCounterValue);
       },
+      /**
+       * Get all values associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key to retrieve.
+       * @returns {Promise.<Array>}
+       * A promise that will be completed with an array of values,
+       * or an empty array if the key does not exist.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapGet: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapGet(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x67, k, p.encodeMultimapKey(k), p.decodeMultimapCollection());
+      },
+      /**
+       * Add a value to the collection associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value to add.
+       * @param {Object=} opts Optional store options (lifespan, maxIdle).
+       * @returns {Promise}
+       * A promise that will be completed when the value has been added.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapPut: function(k, v, opts) {
+        var ctx = transport.context(MEDIUM);
+        logger.debugf('Invoke multimapPut(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x6B, k, p.encodeMultimapPut(k, v), p.complete(_.constant(undefined)), opts);
+      },
+      /**
+       * Remove all values associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key to remove.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the key existed.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapRemoveKey: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapRemoveKey(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x6D, k, p.encodeMultimapKey(k), p.decodeMultimapBoolean);
+      },
+      /**
+       * Remove a specific value from the collection associated with a key.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value to remove.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the entry existed.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapRemoveEntry: function(k, v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapRemoveEntry(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x6F, k, p.encodeMultimapKeyValue(k, v), p.decodeMultimapBoolean);
+      },
+      /**
+       * Get the total number of key-value pairs in the multimap.
+       *
+       * @returns {Promise.<Number>}
+       * A promise that will be completed with the total size.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapSize: function() {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapSize(msgId=%d)', ctx.id);
+        return future(ctx, 0x71, p.encodeMultimapSupportsDuplicates(), p.decodeMultimapSize);
+      },
+      /**
+       * Check whether a specific key-value pair exists in the multimap.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the entry exists.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsEntry: function(k, v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsEntry(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x73, k, p.encodeMultimapKeyValue(k, v), p.decodeMultimapBoolean);
+      },
+      /**
+       * Check whether a key exists in the multimap.
+       *
+       * @param {(String|Object)} k Key to check.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the key exists.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsKey: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsKey(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x75, k, p.encodeMultimapKey(k), p.decodeMultimapBoolean);
+      },
+      /**
+       * Check whether any key contains the given value in the multimap.
+       *
+       * @param {(String|Object)} v Value to check.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if any key contains the value.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsValue: function(v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsValue(msgId=%d,value=%s)', ctx.id, u.str(v));
+        return future(ctx, 0x77, p.encodeMultimapValue(v), p.decodeMultimapBoolean);
+      },
       /**
        * Get server topology related information.
        *
@@ -1208,6 +1402,73 @@
           logger.debugf('Invoke admin.removeSchema(msgId=%d,name=%s)', ctx.id, name);
           return future(ctx, 0x2B, p.encodeNameParams('@@schemas@delete', {name: name}), p.decodeValue());
         }
+      },
+      /**
+       * Get the transaction manager for this client.
+       * Transactions buffer put/remove operations locally and send them
+       * to the server atomically on commit via PREPARE_TX_2.
+       * During an active transaction, get() reads local writes first,
+       * falling back to getWithMetadata to capture entry versions for
+       * conflict detection.
+       *
+       * @returns {Object} Transaction manager with begin(), commit(), and rollback() methods.
+       * @memberof Client#
+       * @since 0.16
+       */
+      getTransactionManager: function() {
+        return {
+          begin: function() {
+            if (txCtx) throw new Error('Transaction already active');
+            txCtx = new tx.TransactionContext();
+            logger.debugf('Transaction started (xid=%s)',
+              txCtx.xid.globalTxId.toString('hex'));
+            return Promise.resolve();
+          },
+          commit: function() {
+            if (!txCtx) throw new Error('No active transaction');
+            var xid = txCtx.xid;
+            var mods = txCtx.getModifications();
+            if (mods.length === 0) {
+              txCtx = null;
+              return Promise.resolve();
+            }
+            var ctx = transport.context(BIG);
+            logger.debugf('Invoke prepareTx(msgId=%d, mods=%d)', ctx.id, mods.length);
+            var decoder = p.decodeXaResponse();
+            return future(ctx, 0x7D, p.encodePrepare(xid, mods, true, 60000), decoder)
+              .then(function(xaCode) {
+                txCtx = null;
+                if (xaCode !== tx.XA_OK && xaCode !== tx.XA_RDONLY) {
+                  throw new Error(`Transaction prepare failed: XA code ${xaCode}`);
+                }
+              })
+              .catch(function(err) {
+                txCtx = null;
+                throw err;
+              });
+          },
+          rollback: function() {
+            if (!txCtx) throw new Error('No active transaction');
+            var xid = txCtx.xid;
+            var mods = txCtx.getModifications();
+            if (mods.length === 0) {
+              txCtx = null;
+              return Promise.resolve();
+            }
+            var ctx = transport.context(SMALL);
+            logger.debugf('Invoke rollbackTx(msgId=%d)', ctx.id);
+            var decoder = p.decodeXaResponse();
+            return future(ctx, 0x3F, p.encodeXidOnly(xid), decoder)
+              .then(function() { txCtx = null; })
+              .catch(function(err) {
+                txCtx = null;
+                throw err;
+              });
+          },
+          isActive: function() {
+            return txCtx !== null;
+          }
+        };
       }
     };
   };
@@ -1294,8 +1555,24 @@
    */
   /**
    * Infinispan client constructor taking an optional initial address,
-   * or multiple addresses, to which the client will try to connect to,
-   * as well as optional configuration settings.
+   * multiple addresses, or a Hot Rod URI string to which the client
+   * will try to connect, as well as optional configuration settings.
+   *
+   * @example
+   * // Connect with a Hot Rod URI
+   * client('hotrod://admin:password@localhost:11222')
+   *
+   * @example
+   * // URI with TLS and query parameters
+   * client('hotrods://admin:password@localhost:11222?trust_ca=/ca.pem')
+   *
+   * @example
+   * // URI with programmatic overrides
+   * client('hotrod://admin:password@localhost:11222', {authentication: {saslMechanism: 'SCRAM-SHA-256'}})
+   *
+   * @example
+   * // URI with multiple servers
+   * client('hotrod://admin:password@node1:11222,node2:11322')
    *
    * @example
    * client({port: 11222, host: 'localhost'})
@@ -1310,18 +1587,31 @@
    * client([{port: 11522, host: 'myhost'}, {port: 11622, host: 'myhost'}],
    *        {version: '2.2', cacheName: 'myCache'})
    *
-   * @param {(ServerAddress|ServerAddress[])} args
-   * Optional single or multiple addresses to which to connect. If none
-   * provided, the client will connect to localhost:11222 address by default.
+   * @param {(String|ServerAddress|ServerAddress[])} args
+   * A Hot Rod URI string (hotrod:// or hotrods://), a single server address,
+   * or an array of server addresses. If none provided, the client connects
+   * to localhost:11222 by default.
    * @param {ClientOptions=} options
-   * Optional configuration settings.
+   * Optional configuration settings. When a URI is provided, these settings
+   * override URI values.
    * @constructs Client
    * @returns {Promise<ReturnType<Client>>} A promise that resolves to a connected client.
    * @since 0.3
    */
+  exports.flags = protocols.FLAGS;
+
   exports.client = function client(args, options) {
-    var merged = f.merge(Client.config, options);
-    var c = new Client(u.normalizeAddresses(args), merged);
+    var addrs, uriOpts;
+    if (uri.isHotrodURI(args)) {
+      var parsed = uri.parseHotrodURI(args);
+      addrs = parsed.servers;
+      uriOpts = parsed.options;
+    } else {
+      addrs = u.normalizeAddresses(args);
+      uriOpts = {};
+    }
+    var merged = f.deepMerge(Client.config, uriOpts, options || {});
+    var c = new Client(addrs, merged);
 
     return c.connect();
   };
@@ -1389,16 +1679,7 @@
       enabled: false,
       secureProtocol: 'TLS_client_method',
       trustCerts: [],
-      clientAuth: {
-        key: undefined,
-        passphrase: undefined,
-        cert: undefined
-      },
-      sniHostName: undefined,
-      cryptoStore: {
-        path: undefined,
-        passphrase: undefined
-      }
+      sniHostName: undefined
     },
     dataFormat : {
       keyType: 'text/plain',

package/lib/io.js

@@ -1116,6 +1116,9 @@
       f.actions(p.stepsHeaderBody(ctx, 0x23, p.sasl(transport.authOpts(), holder), undefined), codec.bytesEncoded)(ctx);
       var result = transport.writeCommandPinned(ctx, p.decodeSasl, conn);
       return result.then(function (r) {
+        if (r.complete) {
+          return r;
+        }
         ctx = u.context(16);
         ctx.topologyId = topologyId;
         holder.challenge = r.response;
@@ -1123,7 +1126,6 @@
         return transport.writeCommandPinned(ctx, p.decodeSasl, conn).then(function (r) {
           return r;
         });
-        return r;
       });
     }
 

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