EliAndrewC
commented
10 years ago Since Github apparently doesn't let you attach files to issues, I'll just copy/paste websockets.js here:
var SideboardUtils = {
noop: function() { },
applyIf: function(d1, d2) {
d1 = d1 || {};
for(var k in d2) {
if(!(k in d1)) {
d1[k] = d2[k];
}
}
return d1;
},
bind: function(func, scope) {
return function() {
func.apply(scope, arguments);
};
},
getScheme: function() {
if(window.location.protocol == "https:") {
return "wss";
} else {
return "ws";
}
},
getDefaultUrl : function() {
var host = window.location.host;
// this is needed exclusively to simplify the need to have 443 be the http
// and 8443 be the ws port in the case of apache being the server
// if (window.location.protocol == "https:" && host.indexOf(":") === -1) {
// host += ":8443";
// }
return SideboardUtils.getScheme() + "://" + host + "/ws";
}
};
var SideboardWebSocket = function(url, protocols) {
this.url = url || this.url;
this.protocols = protocols || this.protocols;
this.eventQueues = {
open: [],
close: [],
error: [],
message: []
};
if (!this.WebSocketClass) {
throw "WebSockets not supported by this browser.";
}
this.CONNECTING = this.WebSocketClass.CONNECTING;
this.OPEN = this.WebSocketClass.OPEN;
this.CLOSING = this.WebSocketClass.CLOSING;
this.CLOSED = this.WebSocketClass.CLOSED;
return this;
};
SideboardWebSocket.prototype = {
url: "ws://" + window.location.host + "/ws",
protocols: null,
WebSocketClass: window.WebSocket,
on: function(eventName, callback, settings) {
settings = settings || {};
if (eventName in this.eventQueues) {
this.eventQueues[eventName].push({
callback: callback,
scope: settings.scope || this,
single: settings.single || false
});
} else {
throw new Error("'" + eventName + "' is not a valid event name");
}
},
fire: function(eventName) {
if (eventName in this.eventQueues) {
var args = Array.prototype.slice.call(arguments, 1);
var events = this.eventQueues[eventName];
var indexesToRemove = [];
for(var i=0, event; event=events[i]; i++) {
event.callback.apply(event.scope, args);
if (event.single) {
indexesToRemove.splice(0, 0, i);
}
}
for(var i=0; i<indexesToRemove.length; i++) {
events.pop(indexesToRemove[i]);
}
} else {
throw new Error("'" + eventName + "' is not a valid event name");
}
},
getUrl: function(webSocket) {
return webSocket.url || webSocket.URL;
},
getStatus: function() {
if (this.webSocket) {
return this.webSocket.readyState;
} else {
return this.CLOSED;
}
},
getStatusString: function() {
var status = this.getStatus();
if (status === this.CONNECTING) {
return "CONNECTING";
} else if (status === this.OPEN) {
return "OPEN";
} else if (status === this.CLOSING) {
return "CLOSING";
} else {
return "CLOSED";
}
},
connect: function(url, protocols) {
var doConnect = function() {
this.url = url || this.url;
this.protocols = protocols || this.protocols;
this.webSocket = new this.WebSocketClass(this.url, this.protocols);
this.webSocket.onopen = SideboardUtils.bind(this.handleOpen, this);
this.webSocket.onerror = SideboardUtils.bind(this.handleError, this);
this.webSocket.onclose = SideboardUtils.bind(this.handleClose, this);
this.webSocket.onmessage = SideboardUtils.bind(this.handleMessage, this);
};
if (!this.webSocket || this.webSocket.readyState == this.CLOSED) {
doConnect.call(this);
} else if (this.webSocket.readyState == this.CLOSING) {
this.on("close", doConnect, {single: true});
} else if (this.getStatus() == this.OPEN || this.getStatus() == this.CONNECTING) {
if (url && url != this.url) {
this.on("close", doConnect, {single: true});
this.close();
}
}
},
close: function(clamp, reason) {
this.webSocket.close(clamp, reason);
},
send: function(data) {
if (typeof(data) != "string") {
data = JSON.stringify(data)
}
if (this.getStatus() == this.OPEN) {
console.log("Socket send immediate", new Date().toISOString(), data);
this.webSocket.send(data);
} else {
throw new Error("Attemping to send data over a " + this.getStatusString() + " connection");
}
},
handleOpen: function(event) {
this.fire("open", this, event);
},
handleError: function(event) {
this.fire("error", this, event);
},
handleClose: function(event) {
this.webSocket.onopen = null;
this.webSocket.onerror = null;
this.webSocket.onclose = null;
this.webSocket.onmessage = null;
this.webSocket = null;
this.fire("close", this, event);
},
handleMessage: function(event) {
console.log("Socket receive message", new Date().toISOString(), event);
var data = event.data ? JSON.parse(event.data) : null;
this.fire("message", this, data, event);
}
};
var SideboardSocketManager = function() {
this.sockets = {};
this.requests = {};
return this;
};
SideboardSocketManager.prototype = {
currId: 0,
nextClientId: function() {
this.currId++;
return "client-" + this.currId;
},
nextCallbackId: function() {
this.currId++;
return "callback-" + this.currId;
},
requestFromStringOrObject: function(request) {
if (typeof(request) == "string") {
request = {client : request};
}
request = request || {};
request.url = request.url || SideboardUtils.getDefaultUrl();
return request;
},
normalizeRequest: function(request) {
request = this.requestFromStringOrObject(request);
if (!request.client) {
request.client = this.nextClientId()
}
return SideboardUtils.applyIf(request, {
scope: request,
single: false,
error: SideboardUtils.noop,
callback: SideboardUtils.noop,
url: SideboardUtils.getDefaultUrl()
});
},
closeAll: function() {
for(var url in this.sockets) {
try {
this.sockets[url].webSocket.close();
} catch(ex) { }
delete this.sockets[url];
}
},
open: function(opts) {
opts = SideboardUtils.applyIf(opts, {
scope: this,
callback: SideboardUtils.noop,
url: SideboardUtils.getDefaultUrl()
});
var url = opts.url;
if (!this.requests[url]) {
this.requests[url] = {};
}
if (this.sockets[url]) {
var ws = this.sockets[url];
if (ws.getStatus() == ws.CONNECTING) {
ws.on("open", opts.callback, {single: true, scope: opts.scope})
} else {
opts.callback.call(opts.scope);
}
} else {
var ws = this.sockets[url] = new SideboardWebSocket(url);
ws.connect();
ws.on("open", opts.callback, {single: true, scope: opts.scope});
ws.on("close", this.handleClose, {scope: this});
ws.on("message", this.handleMessage, {scope: this});
}
return this.sockets[url];
},
unsubscribe: function(client) {
var request = this.requestFromStringOrObject(client);
if (request.client) {
this.sockets[request.url].send({action: "unsubscribe", client: request.client});
if (request.url in this.requests) {
delete this.requests[request.url][request.client];
}
} else {
console.error("Unknown client id", client);
}
},
send: function(request) {
request = this.normalizeRequest(request);
this.open({
url: request.url,
callback: function() {
this.handleSend(request);
}
});
return request.client;
},
subscribe: function(request) {
request.single = false;
return this.send(request);
},
call: function(request) {
request.single = true;
return this.send(request);
},
handleSend: function(request) {
if (request.single) {
delete request.client;
request.cbid = this.nextCallbackId();
this.requests[request.url][request.cbid] = request;
} else {
this.requests[request.url][request.client] = request;
}
this.sockets[request.url].send({
method: request.method,
params: request.params,
client: request.client,
callback: request.cbid
});
},
handleClose: function(ws, event) {
delete this.sockets[ws.url];
delete this.requests[ws.url];
},
handleMessage: function(ws, json, event) {
var id = json && (json.client || json.callback);
var request = this.requests[ws.url][id];
if (request) {
fn = json.error ? "error" : "callback";
try {
request[fn].call(request.scope, json.data, ws, event);
} catch(ex) {
console.error("Error executing client." + fn, ex);
}
if (request.single) {
delete this.requests[request.url][id];
}
} else {
console.error("unknown client and/or callback id", json);
}
}
};
SocketManager = new SideboardSocketManager();
robdennis
We didn't take the time to open source our websocket.js library, which was woefully incomplete anyway. We'd ideally like to do the following:
The above might be too big for this one issue, so maybe we can split it up. At the very least, having a js client that implements our WebSocket RPC system would be great, especially since our old Ext one isn't really suitable for reuse outside of an Ext app.