infinispan 0.9.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);
       }
     }
   };

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

package/lib/protocols.js

@@ -3,14 +3,14 @@
 (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 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'));
@@ -55,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'); }
@@ -117,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() {
@@ -361,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) {
@@ -749,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);
     }
 
@@ -768,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 [
@@ -873,9 +894,9 @@
         if (keyMediaType.continue) {
           var valueMediaType = decodeServerMediaType(bytebuf);
           if (valueMediaType.continue)
+          
             return {result: undefined, continue: true};
         }
-
         return {continue: false};
       }
     }
@@ -943,6 +964,73 @@
     }
   }());
 
+  var Ping29Mixin = (function() {
+    return {
+      decodePingResponse: function(header,bytebuf){
+        logger.debugf("header and bytebuf %s %s",header,bytebuf);
+        return MediaTypesMixin.decodeServerMediaTypes(header,bytebuf);
+      }
+    }
+  }());
+
+  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));
+        }
+        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");
+        }
+      }
+    }
+  }());
+  
+
   function Protocol(v, clientOpts) {
     this.version = v;
     this.clientOpts = clientOpts;
@@ -963,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 },
@@ -978,6 +1070,8 @@
     , ListenersMixin
     , NoListenerInterestsMixin
     , NoMediaTypesMixin
+    , ProtostreamType
+    , ProtobufRoot
   );
 
   _.extend(Protocol25.prototype
@@ -989,6 +1083,8 @@
       , NoListenerInterestsMixin
       , IteratorMixin
       , NoMediaTypesMixin
+      , ProtostreamType
+      , ProtobufRoot
   );
 
   _.extend(Protocol29.prototype
@@ -1001,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
@@ -1010,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);
   };
@@ -1022,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;
+}