infinispan 0.9.0 → 0.10.0

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/documentation/asciidoc/stories/assembly_getting_started.adoc

@@ -1,11 +0,0 @@
-[id='getting-started']
-:context: getting-started
-= Getting started with {hr_js} clients
-Ensure your system meets requirements before installing the {hr_js} client.
-
-include::{topics}/proc_installing_clients.adoc[leveloffset=+1]
-include::{topics}/ref_basic_usage.adoc[leveloffset=+1]
-
-// Restore the parent context.
-ifdef::parent-context[:context: {parent-context}]
-ifndef::parent-context[:!context:]

package/documentation/asciidoc/topics/community-attributes.adoc

@@ -1,10 +0,0 @@
-:brandname: Infinispan
-:hr_js: Hot Rod JS
-:rhel_long: Red Hat Enterprise Linux (RHEL)
-:rhel_short: RHEL
-:win_long: Microsoft Windows
-:win_short: Windows
-
-:doc_home: https://infinispan.org/documentation/
-:download_url: https://infinispan.org/hotrod-clients
-:js_api_docs: https://docs.jboss.org/infinispan/hotrod-clients/javascript/1.0/apidocs/

package/documentation/asciidoc/topics/downstream-attributes.adoc

@@ -1,10 +0,0 @@
-:brandname: Data Grid
-:hr_js: Hot Rod JS
-:rhel_long: Red Hat Enterprise Linux (RHEL)
-:rhel_short: RHEL
-:win_long: Microsoft Windows
-:win_short: Windows
-
-:doc_home: https://access.redhat.com/documentation/en-us/red_hat_data_grid/
-:download_url: https://access.redhat.com/jbossnetwork/restricted/listSoftware.html?product=data.grid&downloadType=distributions
-:js_api_docs: https://access.redhat.com/webassets/avalon/d/red-hat-data-grid/8.2/node/

package/documentation/asciidoc/topics/proc_executing_scripts.adoc

@@ -1,16 +0,0 @@
-[id='executing-scripts_{context}']
-= Executing scripts on {brandname} Server
-
-You can add custom scripts, such as the following to {brandname} Server:
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/sample-script.js[]
-----
-
-The {hr_js} client can load and execute the sample script as follows:
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/sample-script-execute.js[]
-----

package/documentation/asciidoc/topics/proc_registering_event_listeners.adoc

@@ -1,31 +0,0 @@
-[id='registering-event-listeners_{context}']
-= Registering event listeners
-
-Clients can register event listeners that get invoked when data changes happen.
-Create, modified, remove and expired events are supported.
-Create and modified events emit key and version of value after event.
-Remove and expired events only emit key information.
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/register-event-listener.js[]
-----
-
-Starting with client version `0.7` and Infinispan `9.4.x` server,
-it's possible to tailor events to add or remove information from each event.
-
-For example, a user might want to find out the value associated with the key after an event.
-If the value was sent back along with the key within the event, unnecessary round trips to fetch the value would be avoided.
-This can be achieved configuring the listener with a remote event converter.
-
-Infinispan servers come with a converter called `key-value-with-previous-converter-factory` which can be used for this purpose:
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/key-value-converter.js[]
-----
-
-You can also create and deploy your own converters into Infinispan server instances.
-See the
-[event filter and conversion](https://infinispan.org/docs/stable/titles/developing/developing.html#event_filtering_and_conversion)
-section in the Developers Guide for more information.

package/documentation/asciidoc/topics/proc_using_async_await.adoc

@@ -1,23 +0,0 @@
-[id='using-async-await_{context}']
-= Using Async and Await constructs
-
-Examples above can be greatly simplified taking advantage of `async` / `await` constructs,
-which are available in Node.js since version `7.10.0`.
-
-This section shows how some of the examples above can be written using `async` / `await`:
-
-[discrete]
-== Working with single entries and statistics
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/await-single-entries.js[]
-----
-
-[discrete]
-== Working with multiple entries
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/await-multiple-entries.js[]
-----

package/documentation/asciidoc/topics/proc_using_conditional_operations.adoc

@@ -1,7 +0,0 @@
-[id='using-conditional-operations_{context}']
-= Using conditional operations
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/conditional-operations.js[]
-----

package/documentation/asciidoc/topics/proc_working_ephemeral_data.adoc

@@ -1,7 +0,0 @@
-[id='working-ephemeral-data_{context}']
-= Working with ephemeral data
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/ephemeral-data.js[]
-----

package/documentation/asciidoc/topics/proc_working_multiple_entries.adoc

@@ -1,7 +0,0 @@
-[id='working-multiple-entries_{context}']
-= Working with multiple entries
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/multiple-entries.js[]
-----

package/documentation/asciidoc/topics/proc_working_single_entries_statistics.adoc

@@ -1,7 +0,0 @@
-[id='working-single-entries-statistics_{context}']
-= Working with single entries and statistics
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/single-entries.js[]
-----

package/documentation/asciidoc/topics/ref_basic_usage.adoc

@@ -1,8 +0,0 @@
-[id='basic-usage_{context}']
-= Basic {hr_js} client usage
-Review a basic example for using the {hr_js} client with {brandname} Server.
-
-[source,javascript,options="nowrap",subs=attributes+]
-----
-include::code_examples/hello-world.js[]
-----