Broadcast instruction implemented

Josema · Josema · commit dce82120fff1 · 2017-01-04T13:45:00.000+08:00
diff --git a/dist/browser.js b/dist/browser.js
diff --git a/dist/browser.min.js b/dist/browser.min.js
diff --git a/dist/nodejs.js b/dist/nodejs.js
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "dop",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "main": "./dist/nodejs.js",
   "browser": "./dist/browser.js",
   "unpkg": "./dist/browser.min.js",
diff --git a/src/api/isBroadcastFunction.js b/src/api/isBroadcastFunction.js
@@ -0,0 +1,4 @@
+
+dop.isBroadcastFunction = function(fun) {
+    return (isFunction(fun) && fun.name===dop.cons.BROADCAST_FUNCTION);
+};
diff --git a/src/api/setBroadcastFunction.js b/src/api/setBroadcastFunction.js
@@ -0,0 +1,10 @@
+
+dop.setBroadcastFunction = function (object, namefunction) {
+    dop.util.invariant(dop.isRegistered(object), 'Object passed to dop.setBroadcastFunction must be a registered object');
+    var path = dop.getObjectDop(object).slice(0),
+        object_id = path.shift();
+    path.push(namefunction);
+    dop.getObjectTarget(object)[namefunction] = function $DOP_BROADCAST_FUNCTION() {
+        return dop.protocol.broadcast(object_id, path, arguments);
+    }
+};
diff --git a/src/core/protocol/encodeFunction.js b/src/core/protocol/encodeFunction.js
@@ -1,4 +1,4 @@
 
 dop.core.encodeFunction = function(property, value) {
-    return (isFunction(value)) ? '~F' : dop.core.encode(property, value);
+    return (isFunction(value) && !dop.isBroadcastFunction(value)) ? '~F' : dop.core.encode(property, value);
 };
diff --git a/src/dop.js b/src/dop.js
@@ -28,6 +28,7 @@ var dop = {
         SEND: '~SEND',
         DISCONNECT: '~DISCONNECT',
         REMOTE_FUNCTION: '$DOP_REMOTE_FUNCTION',
+        BROADCAST_FUNCTION: '$DOP_BROADCAST_FUNCTION',
     }
-    
+
 };
diff --git a/src/protocol/_onbroadcast.js b/src/protocol/_onbroadcast.js
@@ -0,0 +1,4 @@
+
+dop.protocol._onbroadcast = function(node, request_id, request, response) {
+    dop.protocol._oncall(node, request_id, request, response);
+};
diff --git a/src/protocol/_oncall.js b/src/protocol/_oncall.js
@@ -0,0 +1,13 @@
+
+dop.protocol._oncall = function(node, request_id, request, response) {
+    var rejection = response[0],
+        promise = request.promise;
+    if (rejection !== undefined) {
+        if (rejection === 0)
+            promise.resolve(response[1]);
+        else if (rejection===dop.core.error.reject_remote.CUSTOM_REJECTION)
+            promise.reject(response[1]);
+        else
+            promise.reject(dop.core.getRejectError(rejection));
+    }
+};
diff --git a/src/protocol/broadcast.js b/src/protocol/broadcast.js
@@ -0,0 +1,29 @@
+
+dop.protocol.broadcast = function(object_id, path, params) {
+
+    var object_data = dop.data.object[object_id],
+        promises = [];
+
+    if (isObject(object_data) && isObject(object_data.node)) {
+        var token, node, request, 
+            nodes = object_data.node;
+        params = Array.prototype.slice.call(params, 0);
+        for (token in nodes) {
+            if (nodes[token].subscriber === 1) {
+                node = dop.data.node[token];
+                request = dop.core.createRequest(
+                    node,
+                    dop.protocol.instructions.broadcast,
+                    object_id,
+                    path,
+                    params
+                );
+                request.promise.node = node;
+                dop.core.storeSendMessages(node, request);
+                promises.push(request.promise);
+            }
+        }
+    }
+    
+    return promises;
+};
diff --git a/src/protocol/call.js b/src/protocol/call.js
@@ -17,57 +17,4 @@ dop.protocol.call = function(node, object_id, path, params) {
     }
     else
         return Promise.reject(dop.core.error.reject_local.NODE_NOT_FOUND);
-};
-
-
-dop.protocol.oncall = function(node, request_id, request) {
-    var object_id = request[1],
-        path = request[2],
-        params = request[3],
-        object_data = dop.data.object[object_id];
-
-    if (isObject(object_data) && isObject(object_data.node[node.token]) && object_data.node[node.token].subscriber) {
-        var functionName = path.pop(),
-            object = dop.util.get(object_data.object, path),
-            f = object[functionName];
-        if (isFunction(f)) {
-            function resolve(value) {
-                var response = dop.core.createResponse(request_id, 0);
-                if (value !== undefined)
-                    response.push(value);
-                dop.core.storeSendMessages(node, response);
-                return value;
-            }
-            function reject(err){
-                dop.core.storeSendMessages(node, dop.core.createResponse(request_id, dop.core.error.reject_remote.CUSTOM_REJECTION, err));
-            }
-
-            if (dop.isRemoteFunction(f))
-                f.apply(null, params).then(resolve).catch(reject);
-            else
-                dop.core.localProcedureCall(f, params, resolve, reject, function(req) {
-                    req.node = node;
-                    return req;
-                }, object);
-
-            return;
-        }
-    }
-    
-    dop.core.storeSendMessages(node, dop.core.createResponse(request_id, dop.core.error.reject_remote.FUNCTION_NOT_FOUND));
-};
-
-
-dop.protocol._oncall = function(node, request_id, request, response) {
-    var rejection = response[0],
-        promise = request.promise;
-    if (rejection !== undefined) {
-        if (rejection === 0)
-            promise.resolve(response[1]);
-        else if (rejection===dop.core.error.reject_remote.CUSTOM_REJECTION)
-            promise.reject(response[1]);
-        else
-            promise.reject(dop.core.getRejectError(rejection));
-    }
-};
-
+};
diff --git a/src/protocol/instructions.js b/src/protocol/instructions.js
@@ -37,7 +37,11 @@ dop.protocol.instructions = {
                         // [-1234, 0, <return>]
 
                         // Owner -> Subscriptor
-    mutation: 4,        // [ 1234, <instruction>, <object_id>, <version>, <mutation>]
+    broadcast: 4,       // [ 1234, <instruction>, <object_id>, ['path','path'], [<params...>]]
+                        // [-1234, 0, <return>]
+
+                        // Owner -> Subscriptor
+    mutation: 5,        // [ 1234, <instruction>, <object_id>, <version>, <mutation>]
                         // [-1234, 0]
 };
 
diff --git a/src/protocol/onbroadcast.js b/src/protocol/onbroadcast.js
@@ -0,0 +1,6 @@
+
+dop.protocol.onbroadcast = function(node, request_id, request) {
+    dop.protocol.onfunction(node, request_id, request, function(permission, object_id) {
+        return permission.owner===object_id;
+    });
+};
diff --git a/src/protocol/oncall.js b/src/protocol/oncall.js
@@ -0,0 +1,6 @@
+
+dop.protocol.oncall = function(node, request_id, request) {
+    dop.protocol.onfunction(node, request_id, request, function(permission) {
+        return permission.subscriber===1;
+    });
+}
diff --git a/src/protocol/onfunction.js b/src/protocol/onfunction.js
@@ -0,0 +1,37 @@
+// Used by dop.protocol.oncall && dop.protocol.onbroadcast
+dop.protocol.onfunction = function(node, request_id, request, validator) {
+    var object_id = request[1],
+        path = request[2],
+        params = request[3],
+        object_data = dop.data.object[object_id];
+
+    if (isObject(object_data) && isObject(object_data.node[node.token]) && validator(object_data.node[node.token], object_id)) {
+        var functionName = path.pop(),
+            object = dop.util.get(object_data.object, path),
+            f = object[functionName];
+        if (isFunction(f) && !dop.isBroadcastFunction(f)) {
+            function resolve(value) {
+                var response = dop.core.createResponse(request_id, 0);
+                if (value !== undefined)
+                    response.push(value);
+                dop.core.storeSendMessages(node, response);
+                return value;
+            }
+            function reject(err){
+                dop.core.storeSendMessages(node, dop.core.createResponse(request_id, dop.core.error.reject_remote.CUSTOM_REJECTION, err));
+            }
+
+            if (dop.isRemoteFunction(f))
+                f.apply(null, params).then(resolve).catch(reject);
+            else
+                dop.core.localProcedureCall(f, params, resolve, reject, function(req) {
+                    req.node = node;
+                    return req;
+                }, object);
+
+            return;
+        }
+    }
+    
+    dop.core.storeSendMessages(node, dop.core.createResponse(request_id, dop.core.error.reject_remote.FUNCTION_NOT_FOUND));
+};
diff --git a/src/umd.js b/src/umd.js
@@ -11,7 +11,7 @@ else if (typeof module == 'object' && module.exports)
     module.exports = dop;
 
 // Browser
-else if (window && typeof window == 'object')
+else if (typeof window == 'object' && window)
     window.dop = dop;
 
 else
diff --git a/test/transports/broadcast.js b/test/transports/broadcast.js
@@ -0,0 +1,61 @@
+var test = require('tape');
+var dop = require('../../dist/nodejs').create();
+var dopClient1 = require('../../dist/nodejs').create();
+var dopClient2 = require('../../dist/nodejs').create();
+var transportName = process.argv[2] || 'local';
+var transportListen = require('dop-transports').listen[transportName];
+var transportConnect = require('dop-transports').connect[transportName];
+
+dop.env = 'SERVER';
+dopClient1.env = 'CLIENT1';
+dopClient2.env = 'CLIENT2';
+
+var server = dop.listen({transport:transportListen})
+var client1 = dopClient1.connect({transport:transportConnect, listener:server})
+var client2 = dopClient2.connect({transport:transportConnect, listener:server})
+
+
+
+
+
+var objServer = {
+    number:1,
+    subobject:{}
+}
+dop.register(objServer);
+dop.setBroadcastFunction(objServer.subobject,'broadcast');
+dop.onsubscribe(function(){
+    return objServer;
+})
+
+
+
+
+// setBroadcastFunction(object, 'namefunction')
+
+test('BROADCASTING TO CLIENTS', function(t) {
+
+client1.subscribe().into({subobject:{broadcast:function(a,b){return a+b}}})
+.then(function(obj) {
+    return client2.subscribe().into({subobject:{broadcast:function(a,b){return a*b}}})
+})
+.then(function(obj) {
+    
+    var promises = objServer.subobject.broadcast(2,5);
+    t.equal(Array.isArray(promises), true, 'Promises is array');
+    t.equal(promises.length, 2, 'Promises are two promises');
+    t.equal(promises[0] instanceof Promise, true, 'First promise is instanceof Promise');
+    Promise.all(promises)
+    .then(function(values){
+        t.equal(values[0], 7, 'First value must be 2+5=7');
+        t.equal(values[0], 7, 'Second value must be 2*5=10');
+        t.end()
+    })
+    // .catch(function(err){
+    //     console.log( err );
+    // })
+})
+})
+
+
+// More test todo

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "dop",`
`3`		`- "version": "0.8.0",`
	`3`	`+ "version": "0.9.0",`
`4`	`4`	`"main": "./dist/nodejs.js",`
`5`	`5`	`"browser": "./dist/browser.js",`
`6`	`6`	`"unpkg": "./dist/browser.min.js",`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
++
 +dop.isBroadcastFunction = function(fun) {
 +    return (isFunction(fun) && fun.name===dop.cons.BROADCAST_FUNCTION);
 +};
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ var dop = {`
`28`	`28`	`SEND: '~SEND',`
`29`	`29`	`DISCONNECT: '~DISCONNECT',`
`30`	`30`	`REMOTE_FUNCTION: '$DOP_REMOTE_FUNCTION',`
	`31`	`+ BROADCAST_FUNCTION: '$DOP_BROADCAST_FUNCTION',`
`31`	`32`	`}`
`32`		`-`
	`33`	`+`
`33`	`34`	`};`