infinispan 0.8.0 → 0.10.0

package/lib/protocols.js

@@ -3,16 +3,22 @@
 (function() {
 
   var _ = require('underscore');
-
+  
   var f = require('./functional');
   var u = require('./utils');
   var codec = require('./codec');
 
   var logger = u.logger('protocols');
-  var s = require('saslmechanisms');
-  var factory = new s.Factory();
-  var scramSha1 = factory.use(require('./scram')).create(['SCRAM-SHA-1']);
-  var digest = factory.use(require('sasl-digest-md5')).create(['DIGEST-MD5']);;
+  var Factory = require('./sasl/factory');
+  var factory = new Factory();
+  factory.use(require('./sasl/plain'));
+  factory.use(require('./sasl/external'));
+  factory.use('DIGEST-MD5', require('./sasl/digest'));
+  factory.use('SCRAM-SHA-1', require('./sasl/scram'));
+  factory.use('SCRAM-SHA-256', require('./sasl/scram'));
+  factory.use('SCRAM-SHA-384', require('./sasl/scram'));
+  factory.use('SCRAM-SHA-512', require('./sasl/scram'));
+  factory.use('OAUTHBEARER', require('./sasl/oauthbearer'));
 
   var INFINITE_LIFESPAN = 0x01, INFINITE_MAXIDLE = 0x02; // Duration flag masks
   var MAGIC = 0xA0;
@@ -49,6 +55,7 @@
   var DECODE_TIMESTAMP = f.actions([codec.decodeLong(), codec.decodeVInt()], codec.allDecoded(2));
   var DECODE_UBYTE = f.actions([codec.decodeUByte()], codec.lastDecoded);
   var DECODE_VINT = f.actions([codec.decodeVInt()], codec.lastDecoded);
+  var DECODE_SHORT = f.actions([codec.decodeShort()], codec.lastDecoded);
 
   function hasOpt(opts, name) { return _.has(opts, name) && f.truthy(opts[name]); }
   function hasOptPrev(opts) { return hasOpt(opts, 'previous'); }
@@ -111,6 +118,11 @@
           return [outer.encodeMediaKey(k)]; // key
         }
       },
+      encodeQuery: function (q) {
+        return function() {
+          return [codec.encodeQuery(q)]; // query
+        }
+      },
       encodeKeyVersion: function (k, version) {
         var outer = this;
         return function() {
@@ -355,6 +367,12 @@
           return decodeObject(header, bytebuf, decodeAction);
         }
       },
+      decodeQuery: function() {
+        return function(header, bytebuf) {
+          var decodeAction = f.actions([f.partial2(codec.decodeQuery,ProtostreamType.lookupProtostreamTypeById,ProtobufRoot.findRootByTypeName)()],codec.lastDecoded);
+          return decodeObject(header, bytebuf, decodeAction);
+        }
+      },
       decodeWithMeta: function() {
         var decoderValue = decoderMedia(this.valueMediaType);
         return function(header, bytebuf) {
@@ -743,6 +761,7 @@
       return f.dispatch(
         f.isa('application/json', encoder(2, encoderJson, decoderJson()))
         , f.isa('text/plain', encoder(13, encoderString, decoderString()))
+        , f.isa('application/x-protostream', encoder(12, encoderProtobuf, decoderProtobuf()))
       )(mediaType);
     }
 
@@ -762,6 +781,14 @@
       return codec.decodeString();
     }
 
+    function encoderProtobuf(message){
+      return codec.encodeProtobuf(message,ProtostreamType.lookupProtostreamTypeByName);
+    }
+
+    function decoderProtobuf(){
+      return f.partial2(codec.decodeProtobuf,ProtostreamType.lookupProtostreamTypeById,ProtobufRoot.findRootByTypeName)();
+    }
+
     function encoder(id, mediaEncoder, mediaDecoder) {
       return function() {
         return [
@@ -867,9 +894,9 @@
         if (keyMediaType.continue) {
           var valueMediaType = decodeServerMediaType(bytebuf);
           if (valueMediaType.continue)
+          
             return {result: undefined, continue: true};
         }
-
         return {continue: false};
       }
     }
@@ -877,8 +904,6 @@
 
   var SASLMixin = (function() {
     var logger = u.logger('sasl');
-    var currentAuthMech = '';
-    var challengeNum = 0;
     return {
       decodeAuthMech: function(header, bytebuf) {
         var authMechsCount = DECODE_VINT(bytebuf);
@@ -894,82 +919,117 @@
         logger.tracef(authMechs);
         return {result: authMechs, continue: true};
       },
-
-      sasl: function(authOpts, challenge) {
-        logger.debugf(authOpts);
+      sasl: function(authOpts, holder) {
+        logger.tracef(authOpts);
         return function () {
           var response;
-            switch (authOpts.saslMechanism) {
-              case 'PLAIN':
-                challengeNum = 1;
-                logger.tracef('Try auth with PLAIN');
-                currentAuthMech = 'PLAIN';
-                response = '';
-                response += '\0';
-                response += authOpts.userName;
-                response += '\0';
-                response += authOpts.password;
-                return [codec.encodeString('PLAIN'), codec.encodeString(response)];
-              case 'SCRAM-SHA-1':
-                logger.tracef('Try auth with SCRAM-SHA-1');
-                currentAuthMech = 'SCRAM-SHA-1';
-                if (challenge == undefined) {
-                  // initial challenge
-                  logger.tracef('Initial SCRAM-SHA-1 challenge');
-                  challengeNum = 1;
-                  var initial = scramSha1.response({username: authOpts.userName, password: authOpts.password});
-                  return [codec.encodeString('SCRAM-SHA-1'), codec.encodeString(initial)];
-                }
-
-                logger.tracef('Second SCRAM-SHA-1 challenge');
-                challengeNum = 2;
-                var scramSecResp = scramSha1.challenge(challenge)
-                    .response({username: authOpts.userName, password: authOpts.password});
-
-                return  [ codec.encodeString('SCRAM-SHA-1'), codec.encodeString(scramSecResp)];
-              case 'DIGEST-MD5':
-                logger.tracef('Try auth with DIGEST');
-                currentAuthMech = 'DIGEST-MD5';
-                if (challenge == undefined) {
-                  // initial challenge
-                  logger.tracef('Initial DIGEST challenge');
-                  challengeNum = 1;
-                  return [codec.encodeString('DIGEST-MD5'), codec.encodeString('')];
-                }
-                var digestResponse = digest.challenge(challenge)
-                    .response({ username: authOpts.userName,
-                      password: authOpts.password});
-                return  [codec.encodeString('DIGEST-MD5'), codec.encodeString(digestResponse)];
-              default:
-                throw new Error('Unsupported auth mechanism mech [' + authOpts.saslMechanism) + ']';
+          if (holder.mech == undefined) {
+            holder.mech = factory.create([authOpts.saslMechanism]);
+            if (holder.mech.clientFirst) {
+              response = holder.mech.response({
+                username: authOpts.userName, 
+                password: authOpts.password, 
+                mechanism: authOpts.saslMechanism,
+                qop: 'auth',
+                serviceType: 'hotrod', 
+                host: 'infinispan'
+              });
+            } else {
+              response = '';
+            }
+          } else {
+            logger.tracef("SASL server challenge response [%s]", holder.mech.name);
+            response = holder.mech.challenge(holder.challenge).response({
+              username: authOpts.userName, 
+              password: authOpts.password, 
+              mechanism: authOpts.saslMechanism,
+              qop: 'auth',
+              serviceType: 'hotrod', 
+              host: 'infinispan'
+            });
           }
+          logger.tracef("SASL client response [%s]", holder.mech.name);
+          return [codec.encodeString(authOpts.saslMechanism), codec.encodeString(response)];
         }
       },
       decodeSasl: function(header, bytebuf) {
         var authDone = DECODE_UBYTE(bytebuf);
         if(authDone == 1) {
-          logger.tracef('Auth done, authenticated');
-          currentAuthMech = '';
-          challengeNum = 0;
-          return {result:  {challenge: 0, response: DECODE_UBYTE(bytebuf)}, continue: true}
+          logger.tracef('SASL authentication complete');
+          return {result:  {response: DECODE_UBYTE(bytebuf)}, continue: true};
+        } else {
+          return {result:  {response: DECODE_STRING(bytebuf)}, continue: true};
         }
+      }
+    }
+  }());
 
-        logger.tracef('Auth not done, continue for next challenge');
+  var Ping29Mixin = (function() {
+    return {
+      decodePingResponse: function(header,bytebuf){
+        logger.debugf("header and bytebuf %s %s",header,bytebuf);
+        return MediaTypesMixin.decodeServerMediaTypes(header,bytebuf);
+      }
+    }
+  }());
 
-        if (currentAuthMech == 'SCRAM-SHA-1' && challengeNum == 1) {
-          logger.tracef('Decode challenge 1');
-          return {result:  {challenge: challengeNum, response: DECODE_STRING(bytebuf)}, continue: true}
+  var Ping30Mixin = (function() {
+    return {
+      decodePingResponse: function(header,bytebuf){
+        var serverMediaTypes= MediaTypesMixin.decodeServerMediaTypes(header,bytebuf);
+        var version=DECODE_UBYTE(bytebuf);
+        var opCount=DECODE_VINT(bytebuf);
+        var opRequestCodes=[];
+        for(let i=0;i<opCount;i++){
+          opRequestCodes.push(DECODE_SHORT(bytebuf));
         }
-        if (currentAuthMech == 'DIGEST-MD5' && challengeNum == 1) {
-          logger.tracef('Decode challenge 1');
-          var challenge = DECODE_STRING(bytebuf)
-          return {result:  {challenge: challengeNum, response: challenge}, continue: true}
+        return serverMediaTypes;
+      }
+    }
+  }());
+
+  var ProtostreamType = (function() {
+    var protostreamTypes=[];
+    return {
+      registerProtostreamType: function(protostreamTypeName,protostreamDescriptorId){
+        var protostreamType={
+          protostreamTypeName,
+          protostreamDescriptorId
+        };
+        protostreamTypes.push(protostreamType);
+        return protostreamType;
+      },
+      lookupProtostreamTypeByName: function (protostreamTypeName) {
+        return _.find(protostreamTypes,function(protostreamType){
+          return _.isEqual(protostreamType.protostreamTypeName,protostreamTypeName)
+        }).protostreamDescriptorId;
+      },
+      lookupProtostreamTypeById: function(protostreamDescriptorId){
+        return _.find(protostreamTypes,function(protostreamType){
+          return _.isEqual(protostreamType.protostreamDescriptorId,protostreamDescriptorId)
+        }).protostreamTypeName;
+      }
+    }
+  }());
+
+  var ProtobufRoot = (function() {
+    var protobufRoot;
+    return {
+      registerProtostreamRoot: function(root){
+        protobufRoot=root;
+        return protobufRoot;
+      },
+      findRootByTypeName: function(typeName){
+        try{
+          var root= protobufRoot.lookupType(typeName);
+          return root;
+        }catch(err){
+          throw new Error("Protobuf root not found");
         }
-        // continue for the next challenge
-        return {result: 'auth error', continue: false};
       }
     }
   }());
+  
 
   function Protocol(v, clientOpts) {
     this.version = v;
@@ -991,6 +1051,10 @@
     Protocol.call(this, 29, clientOpts);
   };
 
+  var Protocol30 = function(clientOpts) {
+    Protocol.call(this, 30, clientOpts);
+  };
+
   // TODO: Missing operations, just for reference
   var IdsMixin = {
     queryId: function() { return 0x1F },
@@ -1006,6 +1070,8 @@
     , ListenersMixin
     , NoListenerInterestsMixin
     , NoMediaTypesMixin
+    , ProtostreamType
+    , ProtobufRoot
   );
 
   _.extend(Protocol25.prototype
@@ -1017,6 +1083,8 @@
       , NoListenerInterestsMixin
       , IteratorMixin
       , NoMediaTypesMixin
+      , ProtostreamType
+      , ProtobufRoot
   );
 
   _.extend(Protocol29.prototype
@@ -1029,6 +1097,9 @@
       , IteratorMixin
       , MediaTypesMixin
       , SASLMixin
+      , 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
@@ -1038,6 +1109,28 @@
       // TODO 2.8 header change: media types
   );
 
+  _.extend(Protocol30.prototype
+    , EncodeMixin
+    , ExpiryEncodeMixin
+    , DecodeMixin
+    , IdsMixin
+    , ListenersMixin
+    , ListenerInterestsMixin
+    , IteratorMixin
+    , MediaTypesMixin
+    , SASLMixin
+    , Ping30Mixin
+    , 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
+);
+
   exports.version22 = function(clientOpts) {
     return new Protocol22(clientOpts);
   };
@@ -1050,4 +1143,8 @@
     return new Protocol29(clientOpts);
   };
 
+  exports.version30 = function(clientOpts) {
+    return new Protocol30(clientOpts);
+  };
+
 }.call(this));

package/lib/protostream/message-wrapping.proto

@@ -0,0 +1,134 @@
+syntax = "proto2";
+
+package org.infinispan.protostream;
+
+/**
+ * Protobuf messages do not indicate their message type or structure. Readers of protobuf data streams are expected to
+ * know in advance what message type to expect next in the stream. Also, the wire format is not self-delimiting so the
+ * length of the next message must be computed based on the known schema so that not too much nor too little is read.
+ * This is particularly important if a sequence of multiple messages are contained in a stream. A detailed explanation
+ * is offered here: https://developers.google.com/protocol-buffers/docs/techniques#streaming
+ * <p>
+ * WrappedMessage solves this problem of self-describing messages by allowing the stream reader to detect
+ * the type of the message. Still, only the type name (or type id) is provided but the actual schema is not provided as
+ * it would not be efficient to carry so much information over the wire with each message. The application is expected
+ * to have knowledge of the schema and use it once it learns the type name/id.
+ * <p>
+ * This is similar to 'google.protobuf.Any' but is also able to handle scalars not just messages.
+ * <p>
+ * Fields should ideally arrive in the data stream in the order defined here for efficiency reasons, but implementations
+ * should be able to deal with any field order.
+ *
+ * @TypeId(0)
+ */
+message WrappedMessage {
+
+   // Exactly one of the following fields is used if the wrapped value is a primitive (scalar) type.
+   oneof scalarOrMessage {
+      double wrappedDouble = 1;
+      float wrappedFloat = 2;
+      int64 wrappedInt64 = 3;
+      uint64 wrappedUInt64 = 4;
+      int32 wrappedInt32 = 5;
+      fixed64 wrappedFixed64 = 6;
+      fixed32 wrappedFixed32 = 7;
+      bool wrappedBool = 8;
+      string wrappedString = 9;
+      bytes wrappedBytes = 10;
+      uint32 wrappedUInt32 = 11;
+      sfixed32 wrappedSFixed32 = 12;
+      sfixed64 wrappedSFixed64 = 13;
+      sint32 wrappedSInt32 = 14;
+      sint64 wrappedSInt64 = 15;
+
+      /** There is no native char type in protobuf so it is mapped to int32. */
+      int32 wrappedChar = 20;
+
+      /** There is no native short type in protobuf so it is mapped to int32. */
+      int32 wrappedShort = 21;
+
+      /** There is no native byte type in protobuf so it is mapped to int32. */
+      int32 wrappedByte = 22;
+
+      /** There is no native Date type in protobuf so it is mapped to int64 (milliseconds). */
+      int64 wrappedDateMillis = 23;
+
+      /**
+      * There is no native Instant type in protobuf so it is mapped to an int64 (the seconds) + an int32 (the nanoseconds).
+      * The field wrappedInstantNanos must be also present if this field is present.
+      * A close equivalent to this, with binary compatible representation, is google.protobuf.Timestamp defined in timestamp.proto.
+      */
+      int64 wrappedInstantSeconds = 24;
+
+      /**
+       * This is used if the wrapped value is an enum. The actual type is indicated by oneof typeNameOrId, which
+       * is required if this field is present.
+       */
+      int32 wrappedEnum = 18;
+
+      /**
+       * Stores the message's protobuf encoded bytes when the wrapped value is a message type.
+       * This is similar to google.protobuf.Any.value field. The actual type is indicated by oneof typeNameOrId, which
+       * is required if this field is present.
+       */
+      bytes wrappedMessage = 17;
+
+      /**
+       * A flag that indicates that the contents of the wrapper is empty/null.
+       */
+      bool wrappedEmpty = 26;
+   }
+
+   /**
+    * The nanoseconds of the Instant. Always present if wrappedInstantSeconds is present.
+    * This field is declared outside of scalarOrMessage oneof because it's not legal to have two of the oneof fields
+    * present simultaneously in the data stream.
+    */
+   optional int32 wrappedInstantNanos = 25;
+
+   /**
+    * Stores the fully qualified type name or the optional numeric type id of the payload. This is not used for primitive types
+    * (scalars), only for message and enum types.
+    */
+   oneof typeNameOrId {
+
+      /**
+       * Stores the fully qualified type name if the wrapped value is a message or an enum type.
+       * This is similar to google.protobuf.Any.type_url field.
+       */
+      string wrappedTypeName = 16;
+
+      /**
+       * This is used as an alternative to wrappedTypeName if a unique id was assigned to the type with the TypeId
+       * annotation. Values in the range 0..65535 are reserved for internal use by Protostream and other projects
+       * from the Infinispan organisation.
+       */
+      uint32 wrappedTypeId = 19;
+   }
+
+   /**
+    * Number of repeated elements. Optional; if present it indicates a container (array or Collection). The value must
+    * be positive, or 0 if the array/collection is empty. If this is present, then containerTypeNameOrId and
+    * containerMessage must also be present.
+    */
+   optional uint32 wrappedContainerSize = 27;
+
+   oneof wrappedContainerTypeNameOrId {
+
+      /**
+       * Stores the fully qualified type name if the container.
+       */
+      string wrappedContainerTypeName = 28;
+
+      /**
+       * This is used as an alternative to wrappedContainerTypeName if a unique id was assigned to the type with the
+       */
+      uint32 wrappedContainerTypeId = 29;
+   }
+
+   /**
+    * The fields of the container itself. Must always be present when wrappedContainerSize is present. If the container
+    * type itself does not have any fields then this will be a zero length bytes field.
+    */
+   optional bytes wrappedContainerMessage = 30;
+}

package/lib/protostream/query.proto

@@ -0,0 +1,122 @@
+/**********************************************************************************************************************
+ *                                  REMOTE QUERY RELATED PROTOBUF DEFINITIONS                                         *
+ *                                                                                                                    *
+ *         Allocated TypeId range is: [4400 .. 4599] (see org.infinispan.commons.marshall.ProtoStreamTypeIds)         *
+ *         Actually used range is: [4400 .. 4403]                                                                     *
+ *********************************************************************************************************************/
+syntax = "proto2";
+import "Protos/message-wrapping.proto";
+
+package org.infinispan.query.remote.client;
+
+/**
+ * @TypeId(4400)
+ */
+message QueryRequest {
+
+   /**
+    * The query string, in Infinispan's query language aka Ickle (a JP-QL micro-subset with full-text enhancements).
+    */
+   required string queryString = 1;
+
+
+   /**
+    * The number of matching results to skip before the first returned result.
+    */
+   optional int64 startOffset = 3;
+
+   /**
+    * Maximum number of matching results to return.
+    */
+   optional int32 maxResults = 4;
+
+   /**
+    * Multiple, optional, named parameters. Each name must occur only once.
+    */
+   repeated NamedParameter namedParameters = 5;
+   /**
+    * Whether the query is limited to the data from node that receives the request
+    */
+   optional bool local = 6;
+
+   message NamedParameter {
+
+      /**
+       * Parameter unique name.
+       */
+      required string name = 1;
+
+      /**
+       * Parameter value.
+       */
+      required org.infinispan.protostream.WrappedMessage value = 2;
+   }
+}
+
+/**
+ * @TypeId(4401)
+ */
+message QueryResponse {
+
+   /**
+    * The number of returned results.
+    */
+   required int32 numResults = 1;
+
+   /**
+    * Indicates presence and size of projections.
+    *
+    *      0 - no projection
+    * 1 .. N - projection with N components
+    *    < 0 - illegal value
+    */
+   required int32 projectionSize = 2;
+
+   /**
+    * The list of matching results. The size should be either numResults, if no projections are used, or numResults *
+    * projectionSize otherwise. If projections are used, then each group of projectionSize consecutive elements
+    * represent together a row from the result. We use this simple schema in order to avoid bi-dimensional arrays when
+    * projections are present.
+    */
+   repeated org.infinispan.protostream.WrappedMessage results = 3;
+
+   /**
+    * Total number of results that match the query. This is usually larger than numResults due to
+    * QueryRequest.startOffset and QueryRequest.maxResults.
+    */
+   required int64 totalResults = 4;
+}
+
+/**
+ * @TypeId(4402)
+ */
+message FilterResult {
+
+   optional bytes instance = 1;
+
+   repeated org.infinispan.protostream.WrappedMessage projection = 2;
+
+   repeated org.infinispan.protostream.WrappedMessage sortProjection = 3;
+}
+
+/**
+ * @TypeId(4403)
+ */
+message ContinuousQueryResult {
+
+   enum ResultType {
+      LEAVING = 0;
+      JOINING = 1;
+      UPDATED = 2;
+   }
+
+   required ResultType resultType = 1;
+
+   required bytes key = 2;
+
+   /* Only present if resultType is JOINING or UPDATED and 'projection' field is missing */
+   optional bytes value = 3;
+
+   /* Only present if resultType is JOINING or UPDATED and 'value' field is missing */
+   repeated org.infinispan.protostream.WrappedMessage projection = 4;
+}

package/lib/sasl/bitops.js

@@ -0,0 +1,24 @@
+var crypto = require('crypto');
+var xor = require('buffer-xor');
+
+exports.XOR = xor;
+
+exports.H = function (algorithm, str) {
+    return crypto.createHash(algorithm).update(str).digest();
+};
+
+exports.HMAC = function (algorithm, key, str) {
+    return crypto.createHmac(algorithm, key).update(str).digest();
+};
+
+exports.Hi = function (algorithm, str, salt, iterations) {
+    var INT1 = Buffer.from([0, 0, 0, 1], 'binary');
+    var ui1 = crypto.createHmac(algorithm, str).update(salt).update(INT1).digest();
+    var ui = ui1;
+    for (var i = 1; i < iterations; i++) {
+        ui1 = exports.HMAC(algorithm, str, ui1);
+        ui = exports.XOR(ui, ui1);
+    }
+    return ui;
+};
+