in taverna-interaction-activity/src/main/resources/pmrpc.js [20:686]
pmrpc = self.pmrpc = function() {
// check if JSON library is available
if (typeof JSON === "undefined" || typeof JSON.stringify === "undefined" ||
typeof JSON.parse === "undefined") {
throw "pmrpc requires the JSON library";
}
// TODO: make "contextType" private variable
// check if postMessage APIs are available
if (typeof this.postMessage === "undefined" && // window or worker
typeof this.onconnect === "undefined") { // shared worker
throw "pmrpc requires the HTML5 cross-document messaging and worker APIs";
}
// Generates a version 4 UUID
function generateUUID() {
var uuid = [], nineteen = "89AB", hex = "0123456789ABCDEF";
for (var i=0; i<36; i++) {
uuid[i] = hex[Math.floor(Math.random() * 16)];
}
uuid[14] = '4';
uuid[19] = nineteen[Math.floor(Math.random() * 4)];
uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
return uuid.join('');
}
// TODO: remove this - make everything a regex?
// Converts a wildcard expression into a regular expression
function convertWildcardToRegex(wildcardExpression) {
var regex = wildcardExpression.replace(
/([\^\$\.\+\?\=\!\:\|\\\/\(\)\[\]\{\}])/g, "\\$1");
regex = "^" + regex.replace(/\*/g, ".*") + "$";
return regex;
}
// Checks whether a domain satisfies the access control list. The access
// control list has a whitelist and a blacklist. In order to satisfy the acl,
// the domain must be on the whitelist, and must not be on the blacklist.
function checkACL(accessControlList, origin) {
var aclWhitelist = accessControlList.whitelist;
var aclBlacklist = accessControlList.blacklist;
var isWhitelisted = false;
var isBlacklisted = false;
for (var i=0; i<aclWhitelist.length; ++i) {
var aclRegex = convertWildcardToRegex(aclWhitelist[i]);
if(origin.match(aclRegex)) {
isWhitelisted = true;
break;
}
}
for (var j=0; i<aclBlacklist.length; ++j) {
var aclRegex = convertWildcardToRegex(aclBlacklist[j]);
if(origin.match(aclRegex)) {
isBlacklisted = true;
break;
}
}
return isWhitelisted && !isBlacklisted;
}
// Calls a function with either positional or named parameters
// In either case, additionalParams will be appended to the end
function invokeProcedure(fn, self, params, additionalParams) {
if (!(params instanceof Array)) {
// get string representation of function
var fnDef = fn.toString();
// parse the string representation and retrieve order of parameters
var argNames = fnDef.substring(fnDef.indexOf("(")+1, fnDef.indexOf(")"));
argNames = (argNames === "") ? [] : argNames.split(", ");
var argIndexes = {};
for (var i=0; i<argNames.length; i++) {
argIndexes[argNames[i]] = i;
}
// construct an array of arguments from a dictionary
var callParameters = [];
for (var paramName in params) {
if (typeof argIndexes[paramName] !== "undefined") {
callParameters[argIndexes[paramName]] = params[paramName];
} else {
throw "No such param!";
}
}
params = callParameters;
}
// append additional parameters
if (typeof additionalParams !== "undefined") {
params = params.concat(additionalParams);
}
// invoke function with specified context and arguments array
return fn.apply(self, params);
}
// JSON encode an object into pmrpc message
function encode(obj) {
return "pmrpc." + JSON.stringify(obj);
}
// JSON decode a pmrpc message
function decode(str) {
return JSON.parse(str.substring("pmrpc.".length));
}
// Creates a base JSON-RPC object, usable for both request and response.
// As of JSON-RPC 2.0 it only contains one field "jsonrpc" with value "2.0"
function createJSONRpcBaseObject() {
var call = {};
call.jsonrpc = "2.0";
return call;
}
// Creates a JSON-RPC request object for the given method and parameters
function createJSONRpcRequestObject(procedureName, parameters, id) {
var call = createJSONRpcBaseObject();
call.method = procedureName;
call.params = parameters;
if (typeof id !== "undefined") {
call.id = id;
}
return call;
}
// Creates a JSON-RPC error object complete with message and error code
function createJSONRpcErrorObject(errorcode, message, data) {
var error = {};
error.code = errorcode;
error.message = message;
error.data = data;
return error;
}
// Creates a JSON-RPC response object.
function createJSONRpcResponseObject(error, result, id) {
var response = createJSONRpcBaseObject();
response.id = id;
if (typeof error === "undefined" || error === null) {
response.result = (result === "undefined") ? null : result;
} else {
response.error = error;
}
return response;
}
// dictionary of services registered for remote calls
var registeredServices = {};
// dictionary of requests being processed on the client side
var callQueue = {};
var reservedProcedureNames = {};
// register a service available for remote calls
// if no acl is given, assume that it is available to everyone
function register(config) {
if (config.publicProcedureName in reservedProcedureNames) {
return false;
} else {
registeredServices[config.publicProcedureName] = {
"publicProcedureName" : config.publicProcedureName,
"procedure" : config.procedure,
"context" : config.procedure.context,
"isAsync" : typeof config.isAsynchronous !== "undefined" ?
config.isAsynchronous : false,
"acl" : typeof config.acl !== "undefined" ?
config.acl : {whitelist: ["*"], blacklist: []}};
return true;
}
}
// unregister a previously registered procedure
function unregister(publicProcedureName) {
if (publicProcedureName in reservedProcedureNames) {
return false;
} else {
delete registeredServices[publicProcedureName];
return true;
}
}
// retreive service for a specific procedure name
function fetchRegisteredService(publicProcedureName){
return registeredServices[publicProcedureName];
}
// receive and execute a pmrpc call which may be a request or a response
function processPmrpcMessage(eventParams) {
var serviceCallEvent = eventParams.event;
var eventSource = eventParams.source;
var isWorkerComm = typeof eventSource !== "undefined" && eventSource !== null;
// if the message is not for pmrpc, ignore it.
if (serviceCallEvent.data.indexOf("pmrpc.") !== 0) {
return;
} else {
var message = decode(serviceCallEvent.data);
//if (typeof console !== "undefined" && console.log !== "undefined" && (typeof this.frames !== "undefined")) { console.log("Received:" + encode(message)); }
if (typeof message.method !== "undefined") {
// this is a request
// ako je
var newServiceCallEvent = {
data : serviceCallEvent.data,
source : isWorkerComm ? eventSource : serviceCallEvent.source,
origin : isWorkerComm ? "*" : serviceCallEvent.origin,
shouldCheckACL : !isWorkerComm
};
response = processJSONRpcRequest(message, newServiceCallEvent);
// return the response
if (response !== null) {
sendPmrpcMessage(
newServiceCallEvent.source, response, newServiceCallEvent.origin);
}
} else {
// this is a response
processJSONRpcResponse(message);
}
}
}
// Process a single JSON-RPC Request
function processJSONRpcRequest(request, serviceCallEvent, shouldCheckACL) {
if (request.jsonrpc !== "2.0") {
// Invalid JSON-RPC request
return createJSONRpcResponseObject(
createJSONRpcErrorObject(-32600, "Invalid request.",
"The recived JSON is not a valid JSON-RPC 2.0 request."),
null,
null);
}
var id = request.id;
var service = fetchRegisteredService(request.method);
if (typeof service !== "undefined") {
// check the acl rights
if (!serviceCallEvent.shouldCheckACL ||
checkACL(service.acl, serviceCallEvent.origin)) {
try {
if (service.isAsync) {
// if the service is async, create a callback which the service
// must call in order to send a response back
var cb = function (returnValue) {
sendPmrpcMessage(
serviceCallEvent.source,
createJSONRpcResponseObject(null, returnValue, id),
serviceCallEvent.origin);
};
invokeProcedure(
service.procedure, service.context, request.params, [cb, serviceCallEvent]);
return null;
} else {
// if the service is not async, just call it and return the value
var returnValue = invokeProcedure(
service.procedure,
service.context,
request.params, [serviceCallEvent]);
return (typeof id === "undefined") ? null :
createJSONRpcResponseObject(null, returnValue, id);
}
} catch (error) {
if (typeof id === "undefined") {
// it was a notification nobody cares if it fails
return null;
}
if (error === "No such param!") {
return createJSONRpcResponseObject(
createJSONRpcErrorObject(
-32602, "Invalid params.", error.description),
null,
id);
}
// the -1 value is "application defined"
return createJSONRpcResponseObject(
createJSONRpcErrorObject(
-1, "Application error.", error.description),
null,
id);
}
} else {
// access denied
return (typeof id === "undefined") ? null : createJSONRpcResponseObject(
createJSONRpcErrorObject(
-2, "Application error.", "Access denied on server."),
null,
id);
}
} else {
// No such method
return (typeof id === "undefined") ? null : createJSONRpcResponseObject(
createJSONRpcErrorObject(
-32601,
"Method not found.",
"The requestd remote procedure does not exist or is not available."),
null,
id);
}
}
// internal rpc service that receives responses for rpc calls
function processJSONRpcResponse(response) {
var id = response.id;
var callObj = callQueue[id];
if (typeof callObj === "undefined" || callObj === null) {
return;
} else {
delete callQueue[id];
}
// check if the call was sucessful or not
if (typeof response.error === "undefined") {
callObj.onSuccess( {
"destination" : callObj.destination,
"publicProcedureName" : callObj.publicProcedureName,
"params" : callObj.params,
"status" : "success",
"returnValue" : response.result} );
} else {
callObj.onError( {
"destination" : callObj.destination,
"publicProcedureName" : callObj.publicProcedureName,
"params" : callObj.params,
"status" : "error",
"description" : response.error.message + " " + response.error.data} );
}
}
// call remote procedure
function call(config) {
// check that number of retries is not -1, that is a special internal value
if (config.retries && config.retries < 0) {
throw new Exception("number of retries must be 0 or higher");
}
var destContexts = [];
if (typeof config.destination === "undefined" || config.destination === null || config.destination === "workerParent") {
destContexts = [{context : null, type : "workerParent"}];
} else if (config.destination === "publish") {
destContexts = findAllReachableContexts();
} else if (config.destination instanceof Array) {
for (var i=0; i<config.destination.length; i++) {
if (config.destination[i] === "workerParent") {
destContexts.push({context : null, type : "workerParent"});
} else if (typeof config.destination[i].frames !== "undefined") {
destContexts.push({context : config.destination[i], type : "window"});
} else {
destContexts.push({context : config.destination[i], type : "worker"});
}
}
} else {
if (typeof config.destination.frames !== "undefined") {
destContexts.push({context : config.destination, type : "window"});
} else {
destContexts.push({context : config.destination, type : "worker"});
}
}
for (var i=0; i<destContexts.length; i++) {
var callObj = {
destination : destContexts[i].context,
destinationDomain : typeof config.destinationDomain === "undefined" ? ["*"] : (typeof config.destinationDomain === "string" ? [config.destinationDomain] : config.destinationDomain),
publicProcedureName : config.publicProcedureName,
onSuccess : typeof config.onSuccess !== "undefined" ?
config.onSuccess : function (){},
onError : typeof config.onError !== "undefined" ?
config.onError : function (){},
retries : typeof config.retries !== "undefined" ? config.retries : 5,
timeout : typeof config.timeout !== "undefined" ? config.timeout : 500,
status : "requestNotSent"
};
isNotification = typeof config.onError === "undefined" && typeof config.onSuccess === "undefined";
params = (typeof config.params !== "undefined") ? config.params : [];
callId = generateUUID();
callQueue[callId] = callObj;
if (isNotification) {
callObj.message = createJSONRpcRequestObject(
config.publicProcedureName, params);
} else {
callObj.message = createJSONRpcRequestObject(
config.publicProcedureName, params, callId);
}
waitAndSendRequest(callId);
}
}
// Use the postMessage API to send a pmrpc message to a destination
function sendPmrpcMessage(destination, message, acl) {
//if (typeof console !== "undefined" && console.log !== "undefined" && (typeof this.frames !== "undefined")) { console.log("Sending:" + encode(message)); }
if (typeof destination === "undefined" || destination === null) {
self.postMessage(encode(message));
} else if (typeof destination.frames !== "undefined") {
return destination.postMessage(encode(message), acl);
} else {
destination.postMessage(encode(message));
}
}
// Execute a remote call by first pinging the destination and afterwards
// sending the request
function waitAndSendRequest(callId) {
var callObj = callQueue[callId];
if (typeof callObj === "undefined") {
return;
} else if (callObj.retries <= -1) {
processJSONRpcResponse(
createJSONRpcResponseObject(
createJSONRpcErrorObject(
-4, "Application error.", "Destination unavailable."),
null,
callId));
} else if (callObj.status === "requestSent") {
return;
} else if (callObj.retries === 0 || callObj.status === "available") {
callObj.status = "requestSent";
callObj.retries = -1;
callQueue[callId] = callObj;
for (var i=0; i<callObj.destinationDomain.length; i++) {
sendPmrpcMessage(
callObj.destination, callObj.message, callObj.destinationDomain[i], callObj);
self.setTimeout(function() { waitAndSendRequest(callId); }, callObj.timeout);
}
} else {
// if we can ping some more - send a new ping request
callObj.status = "pinging";
callObj.retries = callObj.retries - 1;
call({
"destination" : callObj.destination,
"publicProcedureName" : "receivePingRequest",
"onSuccess" : function (callResult) {
if (callResult.returnValue === true &&
typeof callQueue[callId] !== 'undefined') {
callQueue[callId].status = "available";
waitAndSendRequest(callId);
}
},
"params" : [callObj.publicProcedureName],
"retries" : 0,
"destinationDomain" : callObj.destinationDomain});
callQueue[callId] = callObj;
self.setTimeout(function() { waitAndSendRequest(callId); }, callObj.timeout / callObj.retries);
}
}
// attach the pmrpc event listener
function addCrossBrowserEventListerner(obj, eventName, handler, bubble) {
if ("addEventListener" in obj) {
// FF
obj.addEventListener(eventName, handler, bubble);
} else {
// IE
obj.attachEvent("on" + eventName, handler);
}
}
function createHandler(method, source, destinationType) {
return function(event) {
var params = {event : event, source : source, destinationType : destinationType};
method(params);
};
}
if ('window' in this) {
// window object - window-to-window comm
var handler = createHandler(processPmrpcMessage, null, "window");
addCrossBrowserEventListerner(this, "message", handler, false);
} else if ('onmessage' in this) {
// dedicated worker - parent X to worker comm
var handler = createHandler(processPmrpcMessage, this, "worker");
addCrossBrowserEventListerner(this, "message", handler, false);
} else if ('onconnect' in this) {
// shared worker - parent X to shared-worker comm
var connectHandler = function(e) {
//this.sendPort = e.ports[0];
var handler = createHandler(processPmrpcMessage, e.ports[0], "sharedWorker");
addCrossBrowserEventListerner(e.ports[0], "message", handler, false);
e.ports[0].start();
};
addCrossBrowserEventListerner(this, "connect", connectHandler, false);
} else {
throw "Pmrpc must be loaded within a browser window or web worker.";
}
// Override Worker and SharedWorker constructors so that pmrpc may relay
// messages. For each message received from the worker, call pmrpc processing
// method. This is child worker to parent communication.
var createDedicatedWorker = this.Worker;
this.nonPmrpcWorker = createDedicatedWorker;
var createSharedWorker = this.SharedWorker;
this.nonPmrpcSharedWorker = createSharedWorker;
var allWorkers = [];
this.Worker = function(scriptUri) {
var newWorker = new createDedicatedWorker(scriptUri);
allWorkers.push({context : newWorker, type : 'worker'});
var handler = createHandler(processPmrpcMessage, newWorker, "worker");
addCrossBrowserEventListerner(newWorker, "message", handler, false);
return newWorker;
};
this.SharedWorker = function(scriptUri, workerName) {
var newWorker = new createSharedWorker(scriptUri, workerName);
allWorkers.push({context : newWorker, type : 'sharedWorker'});
var handler = createHandler(processPmrpcMessage, newWorker.port, "sharedWorker");
addCrossBrowserEventListerner(newWorker.port, "message", handler, false);
newWorker.postMessage = function (msg, portArray) {
return newWorker.port.postMessage(msg, portArray);
};
newWorker.port.start();
return newWorker;
};
// function that receives pings for methods and returns responses
function receivePingRequest(publicProcedureName) {
return typeof fetchRegisteredService(publicProcedureName) !== "undefined";
}
function subscribe(params) {
return register(params);
}
function unsubscribe(params) {
return unregister(params);
}
function findAllWindows() {
var allWindowContexts = [];
if (typeof window !== 'undefined') {
allWindowContexts.push( { context : window.top, type : 'window' } );
// walk through all iframes, starting with window.top
for (var i=0; typeof allWindowContexts[i] !== 'undefined'; i++) {
var currentWindow = allWindowContexts[i];
for (var j=0; j<currentWindow.context.frames.length; j++) {
allWindowContexts.push({
context : currentWindow.context.frames[j],
type : 'window'
});
}
}
} else {
allWindowContexts.push( {context : this, type : 'workerParent'} );
}
return allWindowContexts;
}
function findAllWorkers() {
return allWorkers;
}
function findAllReachableContexts() {
var allWindows = findAllWindows();
var allWorkers = findAllWorkers();
var allContexts = allWindows.concat(allWorkers);
return allContexts;
}
// register method for receiving and returning pings
register({
"publicProcedureName" : "receivePingRequest",
"procedure" : receivePingRequest});
function getRegisteredProcedures() {
var regSvcs = [];
var origin = typeof this.frames !== "undefined" ? (window.location.protocol + "//" + window.location.host + (window.location.port !== "" ? ":" + window.location.port : "")) : "";
for (publicProcedureName in registeredServices) {
if (publicProcedureName in reservedProcedureNames) {
continue;
} else {
regSvcs.push( {
"publicProcedureName" : registeredServices[publicProcedureName].publicProcedureName,
"acl" : registeredServices[publicProcedureName].acl,
"origin" : origin
} );
}
}
return regSvcs;
}
// register method for returning registered procedures
register({
"publicProcedureName" : "getRegisteredProcedures",
"procedure" : getRegisteredProcedures});
function discover(params) {
var windowsForDiscovery = null;
if (typeof params.destination === "undefined") {
windowsForDiscovery = findAllReachableContexts();
for (var i=0; i<windowsForDiscovery.length; i++) {
windowsForDiscovery[i] = windowsForDiscovery[i].context;
}
} else {
windowsForDiscovery = params.destination;
}
var originRegex = typeof params.origin === "undefined" ?
".*" : params.origin;
var nameRegex = typeof params.publicProcedureName === "undefined" ?
".*" : params.publicProcedureName;
var counter = windowsForDiscovery.length;
var discoveredMethods = [];
function addToDiscoveredMethods(methods, destination) {
for (var i=0; i<methods.length; i++) {
if (methods[i].origin.match(originRegex) && methods[i].publicProcedureName.match(nameRegex)) {
discoveredMethods.push({
publicProcedureName : methods[i].publicProcedureName,
destination : destination,
procedureACL : methods[i].acl,
destinationOrigin : methods[i].origin
});
}
}
}
pmrpc.call({
destination : windowsForDiscovery,
destinationDomain : "*",
publicProcedureName : "getRegisteredProcedures",
onSuccess : function (callResult) {
counter--;
addToDiscoveredMethods(callResult.returnValue, callResult.destination);
if (counter === 0) {
params.callback(discoveredMethods);
}
},
onError : function (callResult) {
counter--;
if (counter === 0) {
params.callback(discoveredMethods);
}
}
});
}
reservedProcedureNames = {"getRegisteredProcedures" : null, "receivePingRequest" : null};
// return public methods
return {
register : register,
unregister : unregister,
call : call,
discover : discover
};
}();