infinispan 0.8.0 → 0.10.0

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/lib/bitops.js

@@ -1,26 +0,0 @@
-var createHash = require('create-hash');
-var createHmac = require('create-hmac');
-var xor = require('bitwise-xor');
-
-
-exports.XOR = xor;
-
-exports.H = function (text) {
-    return createHash('sha1').update(text).digest();
-};
-
-exports.HMAC = function (key, msg) {
-    return createHmac('sha1', key).update(msg).digest();
-};
-
-exports.Hi = function (text, salt, iterations) {
-    var ui1 = exports.HMAC(text, Buffer.from([salt, Buffer.from([0, 0, 0, 1], 'binary')]));
-    var ui = ui1;
-    for (var i = 0; i < iterations - 1; i++) {
-        ui1 = exports.HMAC(text, ui1);
-        ui = exports.XOR(ui, ui1);
-    }
-
-    return ui;
-};
-

package/lib/scram.js

@@ -1,116 +0,0 @@
-var bitops = require('./bitops');
-var utils = require('./utils');
-
-var RESP = {};
-var CLIENT_KEY = 'Client Key';
-var SERVER_KEY = 'Server Key';
-
-
-function Mechanism(options) {
-    options = options || {};
-    this._genNonce = options.genNonce || utils.genNonce;
-    this._stage = 'initial';
-}
-
-// Conform to the SASL lib's expectations
-Mechanism.Mechanism = Mechanism;
-
-
-Mechanism.prototype.name = 'SCRAM-SHA-1';
-Mechanism.prototype.clientFirst = true;
-
-
-Mechanism.prototype.response = function (cred) {
-    return RESP[this._stage](this, cred);
-};
-
-Mechanism.prototype.challenge = function (chal) {
-    var values = utils.parse(chal);
-    this._salt = Buffer.from(values.s, 'base64');
-    this._iterationCount = parseInt(values.i, 10);
-    this._nonce = values.r;
-    this._verifier = values.v;
-    this._error = values.e;
-    this._challenge = chal;
-
-    return this;
-};
-
-
-RESP.initial = function (mech, cred) {
-    mech._cnonce = mech._genNonce();
-
-    var authzid = '';
-    if (cred.authzid) {
-        authzid = 'a=' + utils.saslname(cred.authzid);
-    }
-
-    mech._gs2Header = 'n,' + authzid + ',';
-
-    var nonce = 'r=' + mech._cnonce;
-    var username = 'n=' + utils.saslname(cred.username || '');
-
-    mech._clientFirstMessageBare = username + ',' + nonce;
-    var result = mech._gs2Header + mech._clientFirstMessageBare;
-
-    mech._stage = 'challenge';
-
-    return result;
-};
-
-
-RESP.challenge = function (mech, cred) {
-    var gs2Header = Buffer.from(mech._gs2Header).toString('base64');
-    mech._clientFinalMessageWithoutProof = 'c=' + gs2Header + ',r=' + mech._nonce;
-
-    var saltedPassword, clientKey, serverKey;
-
-    // If our cached salt is the same, we can reuse cached credentials to speed
-    // up the hashing process.
-    if (cred.salt && Buffer.compare(cred.salt, mech._salt) === 0) {
-        if (cred.clientKey && cred.serverKey) {
-            clientKey = cred.clientKey;
-            serverKey = cred.serverKey;
-        } else if (cred.saltedPassword) {
-            saltedPassword = cred.saltedPassword;
-            clientKey = bitops.HMAC(saltedPassword, CLIENT_KEY);
-            serverKey = bitops.HMAC(saltedPassword, SERVER_KEY);
-        }
-    } else {
-        saltedPassword = bitops.Hi(cred.password || '', mech._salt, mech._iterationCount);
-        clientKey = bitops.HMAC(saltedPassword, CLIENT_KEY);
-        serverKey = bitops.HMAC(saltedPassword, SERVER_KEY);
-    }
-
-    var storedKey = bitops.H(clientKey);
-    var authMessage = mech._clientFirstMessageBare + ',' +
-                      mech._challenge + ',' +
-                      mech._clientFinalMessageWithoutProof;
-    var clientSignature = bitops.HMAC(storedKey, authMessage);
-
-    var clientProof = bitops.XOR(clientKey, clientSignature).toString('base64');
-
-    mech._serverSignature = bitops.HMAC(serverKey, authMessage);
-
-    var result = mech._clientFinalMessageWithoutProof + ',p=' + clientProof;
-
-    mech._stage = 'final';
-
-    mech.cache = {
-        salt: mech._salt,
-        saltedPassword: saltedPassword,
-        clientKey: clientKey,
-        serverKey: serverKey
-    };
-
-    return result;
-};
-
-RESP.final = function () {
-    // TODO: Signal errors
-    return '';
-};
-
-
-
-module.exports = Mechanism;