infinispan 0.9.0 → 0.11.0

package/spec/configs/infinispan-xsite-EARTH.xml

@@ -1,10 +1,10 @@
 <infinispan
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="urn:infinispan:config:12.1 https://infinispan.org/schemas/infinispan-config-12.1.xsd
-                            urn:infinispan:server:12.1 https://infinispan.org/schemas/infinispan-server-12.1.xsd
+        xsi:schemaLocation="urn:infinispan:config:13.0 https://infinispan.org/schemas/infinispan-config-13.0.xsd
+                            urn:infinispan:server:13.0 https://infinispan.org/schemas/infinispan-server-13.0.xsd
                             urn:org:jgroups http://www.jgroups.org/schema/jgroups-4.0.xsd"
-        xmlns="urn:infinispan:config:12.1"
-        xmlns:server="urn:infinispan:server:12.1"
+        xmlns="urn:infinispan:config:13.0"
+        xmlns:server="urn:infinispan:server:13.0">
 >
 
     <jgroups>
@@ -132,6 +132,7 @@
         <security>
             <authorization/>
         </security>
+        <metrics accurate-size="true"/>
         <distributed-cache name="xsiteCache" segments="20" remote-timeout="30000" >
             <locking acquire-timeout="30000" concurrency-level="1000" />
             <backups>
@@ -141,7 +142,7 @@
         </distributed-cache>
     </cache-container>
 
-    <server xmlns="urn:infinispan:server:12.1">
+    <server xmlns="urn:infinispan:server:13.0">
         <interfaces>
             <interface name="public">
                 <inet-address value="${infinispan.bind.address:127.0.0.1}"/>
@@ -174,15 +175,17 @@
         </security>
 
         <!-- not secured -->
-        <endpoints socket-binding="default" security-realm="default">
-            <hotrod-connector name="hotrod">
-                <authentication>
-                    <sasl mechanisms="PLAIN"/>
-                </authentication>
-            </hotrod-connector>
-            <rest-connector name="rest"/>
-            <!-- Uncomment to enable the memcached connector -->
-            <!-- memcached-connector socket-binding="memcached" / -->
+        <endpoints>
+            <endpoint socket-binding="default" security-realm="default">
+                <hotrod-connector name="hotrod">
+                    <authentication>
+                        <sasl mechanisms="PLAIN"/>
+                    </authentication>
+                </hotrod-connector>
+                <rest-connector name="rest"/>
+                <!-- Uncomment to enable the memcached connector -->
+                <!-- memcached-connector socket-binding="memcached" / -->
+            </endpoint>
         </endpoints>
     </server>
 </infinispan>

package/spec/configs/infinispan-xsite-MOON.xml

@@ -2,7 +2,7 @@
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="urn:infinispan:config:12.1 https://infinispan.org/schemas/infinispan-config-12.1.xsd
                             urn:infinispan:server:12.1 https://infinispan.org/schemas/infinispan-server-12.1.xsd
-                             urn:org:jgroups http://www.jgroups.org/schema/jgroups-4.0.xsd"
+                            urn:org:jgroups http://www.jgroups.org/schema/jgroups-4.0.xsd"
         xmlns="urn:infinispan:config:12.1"
         xmlns:server="urn:infinispan:server:12.1">
 
@@ -132,6 +132,7 @@
         <security>
             <authorization/>
         </security>
+        <metrics accurate-size="true"/>
         <distributed-cache name="xsiteCache" segments="20" remote-timeout="30000" >
             <locking acquire-timeout="30000" concurrency-level="1000"/>
             <backups>
@@ -143,7 +144,7 @@
         </distributed-cache>
     </cache-container>
 
-    <server xmlns="urn:infinispan:server:12.1">
+    <server xmlns="urn:infinispan:server:13.0">
         <interfaces>
             <interface name="public">
                 <inet-address value="${infinispan.bind.address:127.0.0.1}"/>
@@ -176,15 +177,17 @@
         </security>
 
         <!-- not secured -->
-        <endpoints socket-binding="default" security-realm="default">
-            <hotrod-connector name="hotrod">
-                <authentication>
-                    <sasl mechanisms="PLAIN"/>
-                </authentication>
-            </hotrod-connector>
-            <rest-connector name="rest"/>
-            <!-- Uncomment to enable the memcached connector -->
-            <!-- memcached-connector socket-binding="memcached" / -->
+        <endpoints>
+            <endpoint socket-binding="default" security-realm="default">
+                <hotrod-connector name="hotrod">
+                    <authentication>
+                        <sasl mechanisms="PLAIN"/>
+                    </authentication>
+                </hotrod-connector>
+                <rest-connector name="rest"/>
+                <!-- Uncomment to enable the memcached connector -->
+                <!-- memcached-connector socket-binding="memcached" / -->
+            </endpoint>
         </endpoints>
     </server>
 </infinispan>

package/spec/configs/infinispan.xml

@@ -1,14 +1,15 @@
 <infinispan
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="urn:infinispan:config:12.1 https://infinispan.org/schemas/infinispan-config-12.1.xsd
-                            urn:infinispan:server:12.1 https://infinispan.org/schemas/infinispan-server-12.1.xsd"
-        xmlns="urn:infinispan:config:12.1"
-        xmlns:server="urn:infinispan:server:12.1">
+        xsi:schemaLocation="urn:infinispan:config:13.0 https://infinispan.org/schemas/infinispan-config-13.0.xsd
+                            urn:infinispan:server:13.0 https://infinispan.org/schemas/infinispan-server-13.0.xsd"
+        xmlns="urn:infinispan:config:13.0"
+        xmlns:server="urn:infinispan:server:13.0">
 
    <cache-container name="default" statistics="true" default-cache="default">
 <!--      <security>-->
 <!--         <authorization/>-->
 <!--      </security>-->
+      <metrics accurate-size="true"/>
       <local-cache name="default">
          <locking acquire-timeout="30000" concurrency-level="1000" />
          <encoding media-type="text/plain"/>
@@ -23,9 +24,15 @@
       <local-cache name="jsonCache">
          <encoding media-type="text/plain"/>
       </local-cache>
+      <local-cache name="protoStreamCache">
+         <encoding>
+             <key media-type="text/plain"/>
+	     <value media-type="application/x-protostream"/>
+         </encoding>
+      </local-cache>
    </cache-container>
 
-   <server xmlns="urn:infinispan:server:12.1">
+   <server xmlns="urn:infinispan:server:13.0">
       <interfaces>
          <interface name="public">
             <inet-address value="${infinispan.bind.address:127.0.0.1}"/>
@@ -55,14 +62,16 @@
          </security-realms>
       </security>
 
-     <endpoints socket-binding="default" security-realm="default">
-         <hotrod-connector name="hotrod">
-            <authentication>
-               <sasl mechanisms="PLAIN DIGEST-MD5 SCRAM-SHA-1 SCRAM-SHA-256 SCRAM-SHA-384 SCRAM-SHA-512"
-                     server-name="infinispan"/>
-            </authentication>
-         </hotrod-connector>
-         <rest-connector name="rest"/>
+      <endpoints>
+         <endpoint socket-binding="default" security-realm="default">
+            <hotrod-connector name="hotrod">
+               <authentication>
+                  <sasl mechanisms="PLAIN DIGEST-MD5 SCRAM-SHA-1 SCRAM-SHA-256 SCRAM-SHA-384 SCRAM-SHA-512"
+                        server-name="infinispan"/>
+               </authentication>
+            </hotrod-connector>
+            <rest-connector name="rest"/>
+         </endpoint>
       </endpoints>
    </server>
 </infinispan>

package/spec/protostream_spec.js

@@ -0,0 +1,237 @@
+//'use strict';
+
+var _ = require('underscore');
+var path = require('path');
+var long = require('long');
+
+var t = require('./utils/testing'); // Testing dependency
+var protobuf = require('protobufjs');
+const { iteratee } = require('underscore');
+var ispn = require('../lib/infinispan');
+
+var myMsg = `package awesomepackage;
+syntax = "proto3";
+/**
+ * @TypeId(1000043)
+ */
+message AwesomeMessage {
+string awesome_field = 1;
+}`
+
+var myMsg2 = `package awesomepackage;
+/**
+ * @TypeId(1000043)
+ */
+message AwesomeMessage {
+    required string awesome_field = 1;
+}`
+
+var myMsg3 = `package awesomepackage;
+/**
+ * @TypeId(1000044)
+ */
+message AwesomeUser {
+    required string name = 1;
+    required int64 age = 2;
+    required bool isVerified =3;
+}`
+
+var p30 = t.protocol30({
+    dataFormat: {
+        keyType: 'text/plain',
+        valueType: 'application/x-protostream'
+    }
+});
+
+describe('Protobuf encoding', function () {
+    var expectedArray = [0x0a, 0x0d, 0x41, 0x77, 0x65, 0x73, 0x6f, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67];
+    var expectedBuffer = Buffer.from(expectedArray);
+    it("Encodes a proto message", function () {
+        root = protobuf.parse(myMsg).root;
+
+        // Obtain a message type
+        var AwesomeMessage = root.lookupType(".awesomepackage.AwesomeMessage");
+        var payload = { awesomeField: "AwesomeString" };
+        var errMsg = AwesomeMessage.verify(payload);
+        expect(errMsg === null).toBeTruthy();
+        var message = AwesomeMessage.create(payload); // or use .fromObject if conversion is necessary
+        var buffer = AwesomeMessage.encode(message).finish();
+        expect(Buffer.compare(buffer, expectedBuffer)).toBe(0);
+    });
+}
+);
+
+describe('Protostream encoding', function () {
+    p30.registerProtostreamType(".awesomepackage.AwesomeMessage", 1000043);
+
+    it("Returns the Protostream type", function () {
+        var psType = p30.lookupProtostreamTypeByName(".awesomepackage.AwesomeMessage");
+        expect(psType).toBe(1000043);
+    });
+
+    it("Encodes a Protostream message", function () {
+        root = protobuf.parse(myMsg).root;
+        protobuf.loadSync(path.join(__dirname + '/../lib/protostream/message-wrapping.proto'), root);
+        // Obtain message types
+        var AwesomeMessage = root.lookupType(".awesomepackage.AwesomeMessage");
+        var WrappedMessage = root.lookupType(".org.infinispan.protostream.WrappedMessage");
+        // Build input message
+        var payload = { awesomeField: "AwesomeString" };
+        var errMsg = AwesomeMessage.verify(payload);
+        expect(errMsg === null).toBeTruthy();
+        var message = AwesomeMessage.create(payload);
+        // Build manually WrappedMessage
+        var buffer = AwesomeMessage.encode(message).finish();
+        var wmPayload = {
+            wrappedMessage: buffer,
+            wrappedTypeId: 1000043
+        };
+        errMsg = WrappedMessage.verify(wmPayload);
+        expect(errMsg === null).toBeTruthy();
+        var wmMessage = WrappedMessage.create(wmPayload);
+        var expectedWMBuffer = WrappedMessage.encode(wmMessage).finish();
+
+        // Call client API for encoding
+        var outBuf = t.newByteBuf(32);
+        p30.encodeMediaValue(message)(outBuf);
+        // outBuf contains the WM encoded by the client
+
+        // Removing buf length at the beginning for comparison
+        var trimmed = outBuf.buf.slice(1, outBuf.offset);
+        // check the client produces same byte buffer
+        expect(Buffer.compare(trimmed, expectedWMBuffer)).toBe(0);
+
+    });
+}
+);
+
+describe("Put/Get protostream object to/from Infinispan", function () {
+    it("Puts protostream on Infinispan", async function (done) {
+        var root = protobuf.parse(myMsg).root;
+        var AwesomeMessage = root.lookupType(".awesomepackage.AwesomeMessage");
+    try {
+            var protoMetaClient = await ispn.client(t.local, { authentication: t.authOpts.authentication, cacheName: '___protobuf_metadata', dataFormat: { keyType: "text/plain", valueType: "text/plain" } });
+            var client = await t.client(t.local, { authentication: t.authOpts.authentication, cacheName: 'protoStreamCache', dataFormat: { keyType: "text/plain", valueType: "application/x-protostream" } });
+            var payload = { awesomeField: "AwesomeString" };
+            var errMsg = AwesomeMessage.verify(payload);
+            expect(errMsg === null).toBeTruthy();
+            var message = AwesomeMessage.create(payload);
+
+            await protoMetaClient.put("awesomepackage/AwesomeMessage.proto", myMsg2);
+
+            await client.clear();
+            expect(await client.size()).toBe(0);
+            await client.put("myKey", message);
+            expect(await client.size()).toBe(1);
+            await client.put("myKey1", 1.2);
+            await client.put("myKey2","string");
+            await client.put("myKey3",true);
+            await client.put("myKey4",new ArrayBuffer(8));
+            expect(await client.size()).toBe(5);
+
+            protoMetaClient.disconnect();
+            client.disconnect();
+            done();
+        } catch (error) {
+            protoMetaClient.disconnect();
+            client.disconnect();
+            done(new Error(error));
+        }
+    }
+    );
+
+    it("Gets protostream on Infinispan", async function (done) {
+        try {
+            var protoMetaClient = await ispn.client(t.local, { authentication: t.authOpts.authentication, cacheName: '___protobuf_metadata', dataFormat: { keyType: "text/plain", valueType: "text/plain" } });
+            var client = await t.client(t.local, { authentication: t.authOpts.authentication, cacheName: 'protoStreamCache', dataFormat: { keyType: "text/plain", valueType: "application/x-protostream" } });
+            client.registerProtostreamRoot(root);
+            var myObj=await client.get("myKey");
+            var myObj1=await client.get("myKey1");
+            var myObj2=await client.get("myKey2");
+            var myObj3=await client.get("myKey3");
+            var myObj4=await client.get("myKey4"); 
+            protoMetaClient.disconnect();
+            await client.clear();
+            client.disconnect();
+            done();
+        } catch (error) {
+            protoMetaClient.disconnect();
+            client.disconnect();
+            done(new Error(error));
+        }
+    }
+    );
+});
+
+describe('Querying in application/x-protostream format',function () {
+    var root = protobuf.parse(myMsg).root;
+    var AwesomeMessage = root.lookupType(".awesomepackage.AwesomeMessage");
+    var root2 = protobuf.parse(myMsg3).root;
+    var AwesomeUser = root2.lookupType(".awesomepackage.AwesomeUser");
+    it("Queries the server without projection", async function (done) {
+        try{
+            var protoMetaClient = await ispn.client(t.local, { authentication: t.authOpts.authentication, cacheName: '___protobuf_metadata', dataFormat: { keyType: "text/plain", valueType: "text/plain" } });
+            var client = await t.client(t.local, { authentication: t.authOpts.authentication, cacheName: 'protoStreamCache', dataFormat: { keyType: "application/x-protostream", valueType: "application/x-protostream" } });
+            await protoMetaClient.put("awesomepackage/AwesomeMessage.proto", myMsg2);
+            await client.clear();
+            for(let i=0;i<10;i++){
+                var payload = { awesomeField: "AwesomeString"+i };
+                var message = AwesomeMessage.create(payload);
+                await client.put(i,message)
+            }
+            var queryResp1 = await client.query({queryString:`from awesomepackage.AwesomeMessage ORDER BY awesome_field`});
+            expect(queryResp1.length).toBe(10);
+            var queryResp2 = await client.query({queryString:`from awesomepackage.AwesomeMessage a where a.awesome_field='AwesomeString1'`});
+            expect(queryResp2.length).toBe(1);
+            expect(queryResp2[0].awesomeField).toEqual('AwesomeString1');
+            var queryResp3 = await client.query({queryString:`from awesomepackage.AwesomeMessage a where a.awesome_field='AwesomeString100'`});
+            expect(queryResp3.length).toEqual(0);
+            protoMetaClient.disconnect();
+            await client.clear();
+            client.disconnect();
+            done();
+        }catch (error) {
+            protoMetaClient.disconnect();
+            client.disconnect();
+            done(new Error(error));
+        }
+    });
+
+    it("Queries the server with projection", async function (done) {
+        try{
+            var protoMetaClient = await ispn.client(t.local, { authentication: t.authOpts.authentication, cacheName: '___protobuf_metadata', dataFormat: { keyType: "text/plain", valueType: "text/plain" } });
+            var client = await t.client(t.local, { authentication: t.authOpts.authentication, cacheName: 'protoStreamCache', dataFormat: { keyType: "application/x-protostream", valueType: "application/x-protostream" } });
+            await protoMetaClient.put("awesomepackage/AwesomeUser.proto", myMsg3);
+            client.registerProtostreamRoot(root2);
+            client.registerProtostreamType(".awesomepackage.AwesomeUser",1000044);
+            await client.clear();
+            for (let i = 0; i < 10; i++){
+                var payload = { name: "AwesomeString"+i , age : i , isVerified: (Math.random()<0.5)};
+                var message = AwesomeUser.create(payload);
+                await client.put(i,message)
+            }
+            var query1 = await client.query({ queryString: `select u.name,u.age from awesomepackage.AwesomeUser u where u.age<20 order by u.name asc` });
+            expect(query1.length).toBe(10);
+            expect(query1[0].length).toBe(2);
+            for (let i = 0; i < 10; i++) {
+                expect(_.isEqual(query1[i][1], long.fromValue(i))).toBeTruthy();
+            }
+            var query2 = await client.query({queryString:`select u.name from awesomepackage.AwesomeUser u where u.age=2`});
+            expect(query2[0][0]).toBe("AwesomeString2");
+
+            var query3 = await client.query({queryString:`select u.name from awesomepackage.AwesomeUser u where u.age>20`});
+            expect(query3.length).toBe(0);
+
+            protoMetaClient.disconnect();
+            await client.clear();
+            client.disconnect();
+            done();
+        }catch (error) {
+            protoMetaClient.disconnect();
+            client.disconnect();
+            done(new Error(error));
+        }
+    });
+    
+}
+);

package/spec/utils/testing.js

@@ -4,9 +4,6 @@ var _ = require('underscore');
 
 var log4js = require('log4js');
 
-var promiseFinally = require('promise.prototype.finally');
-promiseFinally.shim(); // will be a no-op if not needed
-
 var readFile = require('fs').readFile;
 var httpRequest = require('request');
 var util = require('util');
@@ -96,6 +93,7 @@ exports.client = function(args, opts) {
 exports.protocol25 = function() { return protocols.version25(); };
 
 exports.protocol29 = function(clientOpts) { return protocols.version29(clientOpts); };
+exports.protocol30 = function(clientOpts) { return protocols.version30(clientOpts); };
 
 exports.put = function(k, v, opts) {
   return function(client) { return client.put(k, v, opts); }

package/types/README.md

@@ -0,0 +1,91 @@
+This directory contains all the type definitions that are used in this libray.
+
+The below code can be used for testing the type support.
+
+```
+const protobuf = require("protobufjs");
+const infinispan = require("./lib/infinispan.js");
+
+
+var client = infinispan.client(
+  { port: 11222, host: "127.0.0.1" },
+  {
+    dataFormat: {
+      keyType: "application/x-protostream",
+      valueType: "application/x-protostream",
+    },
+    authentication: {
+      enabled: true,
+      saslMechanism: "DIGEST-MD5",
+      userName: "admin",
+      password: "pass",
+      serverName: "infinispan",
+    },
+    cacheName: "protoStreamCache",
+  }
+);
+
+var protoMetaClient = infinispan.client({ port: 11222, host: "127.0.0.1" }, {
+  authentication: {
+    enabled: true,
+    saslMechanism: "DIGEST-MD5",
+    userName: "admin",
+    password: "pass",
+    serverName: "infinispan",
+  },
+  cacheName: "___protobuf_metadata",
+  dataFormat: { keyType: "text/plain", valueType: "text/plain" },
+});
+
+protoMetaClient.then(async function (client) {
+  var myMsg2 = `package awesomepackage;
+  /**
+   * @TypeId(1000042)
+   */
+  message AwesomeMessages {
+      required string name = 1;
+      required int64 age = 2;
+  
+  }`
+  await client.put("awesomepackage/AwesomeMessage.proto", myMsg2);
+  await client.disconnect();
+})
+
+
+client.then(async function (client) {
+  var myMsg2 = `package awesomepackage;
+    /**
+     * @TypeId(1000042)
+     */
+    message AwesomeMessages {
+        required string name = 1;
+        required int64 age = 2;
+    
+    }`;
+
+
+  let root = protobuf.parse(myMsg2).root;
+  let user = root.lookupType('awesomepackage.AwesomeMessages');
+  client.registerProtostreamType('.awesomepackage.AwesomeMessages', 1000042);
+  client.registerProtostreamRoot(root);
+  try {
+    for (let i = 0; i < 10; i++) {
+      let payload = { name: "Neeraj" + i, age: 20 + i };
+      let buf = user.create(payload);
+      await client.put(i + 1, buf);
+      console.log(await client.getWithMetadata(1));
+    }
+    var decoded = await client.query({ queryString: `select u.name,u.age from awesomepackage.AwesomeMessages u where u.age>20` });
+    console.log(decoded);
+    await client.disconnect();
+  } catch (error) {
+    console.log(error);
+  }
+
+});
+```
+
+In the put method, if someone provides only one argument then the compiler will throw the error as below :
+`index.ts:70:18 - error TS2554: Expected 2-3 arguments, but got 1.`
+
+The same follows for all the operations. There is a validation on client config also.