infinispan 0.8.0 → 0.10.0

package/lib/codec.js

@@ -6,6 +6,9 @@
       , INT = Math.pow(2, 31);
 
   var _ = require('underscore');
+  var protobuf = require('protobufjs');
+  var path = require('path');
+
   var f = require('./functional');
   var utils = require('./utils');
 
@@ -16,8 +19,11 @@
   exports.encodeVLong = f.lift(doEncodeVLong, _.identity);
   exports.encodeJSON = f.lift(doEncodeJSON, _.identity);
   exports.encodeBytes = f.lift(doEncodeBytes, _.identity);
+  exports.encodeBytesWithLength = f.lift(doEncodeBytesWithLength, _.identity);
   exports.encodeString = f.lift(doEncodeString, _.identity);
   exports.encodeSignedInt = f.lift(doEncodeSignedInt, _.identity);
+  exports.encodeProtobuf = f.lift(doEncodeProtobuf, _.identity);
+  exports.encodeQuery = f.lift(doEncodeQuery,_.identity);
 
   exports.decodeUByte = f.lift(doDecodeUByte, _.identity);
   exports.decodeVInt = f.lift(doDecodeVInt, _.identity);
@@ -29,6 +35,8 @@
   exports.decodeSignedInt = f.lift(doDecodeSignedInt, _.identity);
   exports.decodeVariableBytes = f.lift(doDecodeVariableBytes, _.identity);
   exports.decodeShort = f.lift(doDecodeShort, _.identity);
+  exports.decodeProtobuf = f.lift(doDecodeProtobuf, _.identity);
+  exports.decodeQuery = f.lift(doDecodeQuery,_.identity);
 
   exports.lastDecoded = function(values) {
     return values[0];
@@ -79,10 +87,54 @@
     return _.compose(updateEncOffset(bytebuf), checkedWriteBytes(bytebuf))(bytes);
   }
 
+  function doEncodeBytesWithLength(bytebuf, bytes) {
+    return _.compose(updateEncOffset(bytebuf), checkedWriteBytesWithLength(bytebuf))(bytes);
+  }
+
   function doEncodeSignedInt(bytebuf, num) {
     return _.compose(updateEncOffset(bytebuf), checkedWriteSignedInt(bytebuf), zigZag)(num);
   }
 
+  function doEncodeProtobuf(bytebuf, message, typeId) {
+    return doEncodeBytesWithLength(bytebuf,encodeProtobuf(message,typeId));
+  }
+
+  function encodeProtobufInstance(root){
+    return function(obj){
+      return root.encode(obj).finish();
+    }
+  }
+
+  function encodeProtobuf(message,typeId){
+    return _.compose(encodeProtobufInstance(WrappedMessage), createWrappedMessage)(message,typeId);
+  }
+
+  function doEncodeQuery(bytebuf,query){
+    return doEncodeBytesWithLength(bytebuf,encodeProtobufInstance(Query.QueryRequest)(query));
+  }
+
+  function createWrappedMessage(message,typeId){
+    var wrappedMessage={};
+    if(_.isNumber(message)){
+      return f.merge(wrappedMessage,{'wrappedDouble':message});
+    }
+    if(_.isString(message)){
+      return f.merge(wrappedMessage,{'wrappedString':message});
+    }
+    if(_.isBoolean(message)){
+      return f.merge(wrappedMessage,{'wrappedBool':message});
+    }
+    if(_.isArrayBuffer(message)){
+      return f.merge(wrappedMessage,{'wrappedBytes':message});
+    }
+    if(f.existy(message.$type)){
+      var encodedMessage = encodeProtobufInstance(message.$type)(message);
+      var messageTypeId = typeId(message.$type.fullName);
+      return f.merge(wrappedMessage,{'wrappedMessage':encodedMessage},{'wrappedTypeId':messageTypeId});
+    }
+    throw new Error("Provide valid data types.");
+  }
+
   function zigZag(num) {
     return (num << 1) ^ (num >> 31);
   }
@@ -90,8 +142,8 @@
   var nullCheck = f.validator('must not be null', f.existy);
   var number = f.validator('must be a number', _.isNumber);
   var positiveOrZero = f.validator('must be >= 0', f.greaterThan(-1));
-  var intTooBig = f.validator('must be less than 2^31', f.lessThan(Math.pow(2, 31)));
-  var shortTooBig = f.validator('must be less than 2^15', f.lessThan(Math.pow(2, 15)));
+  var intTooBig = f.validator('must be less than 2^32', f.lessThan(Math.pow(2, 32)));
+  var shortTooBig = f.validator('must be less than 2^16', f.lessThan(Math.pow(2, 16)));
   var longTooBig = f.validator('must be less than 2^53 (javascript safe integer limitation)',
                                f.lessThan(Math.pow(2, 53)));
   var stringOrNullCheck = f.validator('must be a String or null', stringOrNull);
@@ -124,6 +176,10 @@
     return f.partial1(f.condition1(nullCheck), uncheckedWriteBytes(bytebuf));
   }
 
+  function checkedWriteBytesWithLength(bytebuf) {
+    return f.partial1(f.condition1(nullCheck), uncheckedWriteBytesWithLength(bytebuf));
+  }
+
   function checkedWriteSignedInt(bytebuf) {
     return f.partial1(f.condition1(number, intTooBig), uncheckedWriteVNum(bytebuf));
   }
@@ -209,6 +265,19 @@
     }
   }
 
+  function uncheckedWriteBytesWithLength(bytebuf) {
+    return function(bytes) {
+      var buffNumBytes = f.existy(bytes) ? Buffer.byteLength(bytes) : 0;
+      var offsetAfterBytes = doEncodeVInt(bytebuf, buffNumBytes);
+      if (buffNumBytes > 0) {
+        bytebuf = bytebufOverflowProtect(bytebuf, bytes.length);
+        var targetStart = bytebuf.offset;
+        bytes.copy(bytebuf.buf, targetStart);
+      }
+      return targetStart + buffNumBytes;
+    }
+  }
+
   function doDecodeUByte(bytebuf) {
     return uncheckedReadUByte(bytebuf)();
   }
@@ -253,6 +322,68 @@
     return uncheckedReadShort(bytebuf)();
   }
 
+  function doDecodeProtobuf(bytebuf,protostreamTypename,root){
+    var wrappedObject = _.compose(decodeProtobufMessage(WrappedMessage),trimBytebuf)(bytebuf);
+    return unwrapWrappedMessage(wrappedObject,protostreamTypename,root);
+  }
+
+  function unwrapWrappedMessage(wrappedObject,protostreamTypename,root){
+    switch(true){
+      case _.has(wrappedObject,'wrappedDouble'):
+        return wrappedObject.wrappedDouble;
+      case _.has(wrappedObject,'wrappedString'):
+        return wrappedObject.wrappedString;
+      case _.has(wrappedObject,'wrappedBool'):
+        return wrappedObject.wrappedBool;
+      case _.has(wrappedObject,'wrappedBytes'):
+        return wrappedObject.wrappedBytes;
+      case _.has(wrappedObject,'wrappedMessage'):
+        var messageBytes= wrappedObject.wrappedMessage;
+        var protobufRoot = findRootByTypeId(protostreamTypename,root)(wrappedObject.wrappedTypeId);
+        return decodeProtobufMessage(protobufRoot)(messageBytes);
+    }
+  }
+
+  function decodeProtobufMessage(root){
+    return function(bytebuf){
+      return root.decode(bytebuf);
+    }
+  }
+
+  function findRootByTypeId(protostreamTypename,root){
+    return function(wrappedTypeId){
+      return _.compose(root,protostreamTypename)(wrappedTypeId);
+    } 
+  }
+
+  function trimBytebuf(bytebuf,length){
+    if(!f.existy(length)) length = doDecodeVInt(bytebuf);
+    var retBuf = bytebuf.buf.slice(bytebuf.offset, bytebuf.offset + length);
+    bytebuf.offset += length;
+    return retBuf;
+  }
+
+  function doDecodeQuery(bytebuf,protostreamTypename,root){
+    var queryResponse = decodeProtobufMessage(Query.QueryResponse)(trimBytebuf(bytebuf));
+    var queryResults = queryResponse.results;
+    var projectionSize = queryResponse.projectionSize;
+    return f.greaterThan(0)(projectionSize) ? unwrapQueryWithProj(queryResults,projectionSize) :  unwrapQueryWithoutProj(queryResults,protostreamTypename,root);
+  }
+
+  function decodeWrappedBytes(result,protostreamTypename,root){
+    return _.compose(f.curry3(unwrapWrappedMessage)(root)(protostreamTypename),decodeProtobufMessage(WrappedMessage))(result.wrappedBytes);
+  }
+
+  function unwrapQueryWithoutProj(queryResults,protostreamTypeName,root){
+    return queryResults.map(f.curry3(decodeWrappedBytes)(root)(protostreamTypeName));
+  }
+
+  function unwrapQueryWithProj(queryResults,projectionSize){
+    return _.reduce(queryResults,function(acc,cur,i){
+      return ((i%projectionSize) ? acc[acc.length-1].push(_.values(cur)[0]) : acc.push([_.values(cur)[0]])) && acc;
+    },[]);
+  }
+
   function uncheckedReadUByte(bytebuf) {
     return function() {
       if (1 > bytebuf.buf.length - bytebuf.offset) {
@@ -346,4 +477,24 @@
     }
   }
 
+  var WrappedMessage = (function() {
+    var root=protobuf.loadSync(path.join(__dirname+'/protostream/message-wrapping.proto'));
+
+    var wrappedMessage = root.lookupType('org.infinispan.protostream.WrappedMessage');
+
+    return wrappedMessage;
+  }());
+
+  var Query = (function() {
+    var root=protobuf.loadSync(path.join(__dirname+'/protostream/query.proto'));
+    protobuf.loadSync(path.join(__dirname+'/protostream/message-wrapping.proto'),root); //loaded the wrappedMessage.proto to the root
+    var QueryRequest = root.lookupType('org.infinispan.query.remote.client.QueryRequest');
+    var QueryResponse = root.lookupType('org.infinispan.query.remote.client.QueryResponse');
+
+    return {
+      QueryRequest,
+      QueryResponse
+    };
+  }());
+
 }.call(this));

package/lib/infinispan.js

@@ -24,6 +24,7 @@
       logger.debugf('Using protocol version: %s', version);
 
       switch (version) {
+        case '3.0': return protocols.version30(clientOpts);
         case '2.9': return protocols.version29(clientOpts);
         case '2.5': return protocols.version25(clientOpts);
         case '2.2': return protocols.version22(clientOpts);
@@ -225,6 +226,23 @@
         var decoder = p.decodeValue();
         return futureKey(ctx, 0x03, k, p.encodeKey(k), decoder);
       },
+      /**
+       * Query the server with the given queryString.
+       *
+       * @param q {(Object)} query to retrieve.
+       * @returns {module:promise.Promise.<?Object[]>}
+       * A promise that will be completed with the array of values associated with
+       * the query, or empty array if the no values matches the query.
+       * @memberof Client#
+       * @since 1.3
+       */
+      query: function(q) {
+        //TODO : extend the support of query with application/json datatypes
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke query(msgId=%d,key=%s)', ctx.id, u.str(q));
+        var decoder = p.decodeQuery();
+        return futureKey(ctx, 0x1F, q, p.encodeQuery(q), decoder);
+      },
       /**
        * Check whether the given key is present.
        *
@@ -564,7 +582,7 @@
       ping: function() {
         var ctx = transport.context(TINY);
         logger.debugf('Invoke ping(msgId=%d)', ctx.id);
-        return futureDecodeOnly(ctx, 0x17, p.decodeServerMediaTypes);
+        return futureDecodeOnly(ctx, 0x17, p.decodePingResponse);
       },
 
       /**
@@ -735,6 +753,14 @@
        */
       toString: function() {
         return util.format('Client(%s)', transport);
+      },
+
+      registerProtostreamType: function(typeName,descriptorId){
+        return p.registerProtostreamType(typeName,descriptorId);
+      },
+
+      registerProtostreamRoot: function(root){
+        return p.registerProtostreamRoot(root);
       }
     }
   };
@@ -879,6 +905,12 @@
    * @property {?String} ssl.sniHostName - Optional SNI host name.
    * @property {?String} ssl.cryptoStore.path - Optional crypto store path.
    * @property {?String} ssl.cryptoStore.passphrase - Optional password for crypto store.
+   * @property {?boolean} authentication.enabled - Enable authentication.
+   * @property {?String} authentication.saslMechanism - Select the SASL mechanism to use. Can be one of PLAIN, DIGEST-MD5, SCRAM-SHA-1, SCRAM-SHA-256, SCRAM-SHA-384, SCRAM-SHA-512, EXTERNAL, OAUTHBEARER
+   * @property {?String} authentication.userName - The authentication username. Required by the PLAIN, DIGEST and SCRAM mechanisms.
+   * @property {?String} authentication.password - The authentication password. Required by the PLAIN, DIGEST and SCRAM mechanisms.
+   * @property {?String} authentication.token - The OAuth token. Required by the OAUTHBEARER mechanism.
+   * @property {?String} authentication.authzid - The SASL authorization ID.
    * @property {?boolean} [topologyUpdates=true] - Optional flag to controls whether the client deals with topology updates or not.
    * @property {?(text/plain|application/json)} [mediaType=text/plain] - Media type of the cache contents.
    * @property {?Cluster[]} clusters - Optional additional clusters for cross-site failovers.

package/lib/io.js

@@ -7,9 +7,6 @@
   var fs = require('fs');
   var net = require('net');
 
-  var promiseFinally = require('promise.prototype.finally');
-  promiseFinally.shim(); // will be a no-op if not needed
-
   var tls = require('tls');
   var util = require('util');
 
@@ -259,10 +256,19 @@
         });
       },
       write: function(buffer) {
-        var flushed = sock.write(buffer);
-        if (!flushed)
-          logger.debugf('Buffer write not fully flushed, part of of data queued for: %s',
-            buffer.toString('hex').toUpperCase());
+        return new Promise(function (fulfill, reject) {
+          var flushed = sock.write(buffer, (err) => {
+            if (err) {
+              logger.error('Error writing to socket: %s', err);
+              transport.retryRpcs(addr); // retry RPCs in case of error
+            }
+            fulfill();
+          });
+          if (!flushed)
+            logger.debugf('Buffer write not fully flushed, part of of data queued for: %s',
+              buffer.toString('hex').toUpperCase());
+        });
+
       },
       getAddress: function() {
         return addr;
@@ -745,7 +751,7 @@
       logger.debugf('Invoke ping(msgId=%d)', ctx.id);
       var p = transport.getProtocol();
       f.actions(p.stepsHeader(ctx, 0x17, undefined), codec.bytesEncoded)(ctx);
-      return transport.writeCommandPinned(ctx, p.decodeServerMediaTypes, conn);
+      return transport.writeCommandPinned(ctx, p.decodePingResponse, conn);
     }
 
     function auth(transport, conn, topologyId) {
@@ -758,16 +764,17 @@
       ctx.topologyId = topologyId;
       var p = transport.getProtocol();
       logger.debugf('Invoke auth(msgId=%d)', ctx.id);
-      f.actions(p.stepsHeaderBody(ctx, 0x23, p.sasl(transport.authOpts()), undefined), codec.bytesEncoded)(ctx);
+      var holder = {};
+      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.challenge > 0) {
-          f.actions(p.stepsHeaderBody(ctx, 0x23, p.sasl(transport.authOpts(), r.response), undefined), codec.bytesEncoded)(ctx);
-          return transport.writeCommandPinned(ctx, p.decodeSasl, conn).then(function (r) {
-            return r;
-          });
-        }
+        ctx = u.context(16);
+        ctx.topologyId = topologyId;
+        holder.challenge = r.response;
+        f.actions(p.stepsHeaderBody(ctx, 0x23, p.sasl(transport.authOpts(), holder) , undefined), codec.bytesEncoded)(ctx);
+        return transport.writeCommandPinned(ctx, p.decodeSasl, conn).then(function (r) {
+          return r;
+        });
         return r;
       });
     }