93c0d894a6492ac3c548eaee952d2a42bf7da6ed
[OpenSRF.git] / src / javascript / opensrf_ws_shared.js
1 /* -----------------------------------------------------------------------
2  * Copyright (C) 2014  Equinox Software, Inc.
3  * Bill Erickson <berick@esilibrary.com>
4  *  
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  * ----------------------------------------------------------------------- */
15
16 var WEBSOCKET_URL_PATH = '/osrf-websocket-translator';
17 var WEBSOCKET_PORT = 7680;
18 var WEBSOCKET_PORT_SSL = 7682;
19
20 // set of shared ports (i.e. browser tabs)
21 var connected_ports = {};
22 var port_identifier = 0;
23
24 // maps osrf message threads to a port index in connected_ports
25 var thread_port_map = {}; 
26
27 // our shared websocket
28 var websocket;
29
30 function send_msg_to_port(ident, msg) {
31     console.debug('sending msg to port ' + ident + ' : ' + msg.action);
32     try {
33         connected_ports[ident].postMessage(msg);
34     } catch(E) {
35         // some browsers (Opera) throw an exception when messaging
36         // a disconnected port.
37         console.log('unable to send msg to port ' + ident);
38         delete connected_ports[ident];
39     }
40 }
41
42 // send a message to all listeners
43 function broadcast(msg) {
44     for (var ident in connected_ports)
45       send_msg_to_port(ident, msg);
46 }
47
48
49 // opens the websocket connection
50 // port_ident refers to the requesting port
51 function open_websocket(port_ident) {
52     var port = connected_ports[port_ident];
53
54     if (websocket) {
55         switch (websocket.readyState) {
56
57             case websocket.CONNECTING:
58                 // nothing to do.  The port will get notified on open
59                 return;
60
61             case websocket.OPEN:
62                 // websocket is already open, let the connecting.
63                 // other ports have been notified already, so
64                 // no broadcast is required.
65                 send_msg_to_port(port_ident, {action : 'socket_connected'});
66                 return;
67
68             default:
69                 // websocket is no longer connected.  We need a new socket.
70                 websocket = null;
71         }
72     }
73
74     // TODO:
75     // assume non-SSL for now.  SSL silently dies if the cert is
76     // invalid and has not been added as an exception.
77     var path = 'ws://' + location.host + ':' + 
78         WEBSOCKET_PORT + WEBSOCKET_URL_PATH
79
80     console.log('connecting websocket to ' + path);
81
82     websocket = new WebSocket(path);
83
84     websocket.onopen = function() {
85         // tell all ports the websocket is open and ready
86         console.log('websocket.onopen()');
87         broadcast({action : 'socket_connected'});
88     }
89
90     websocket.onmessage = function(evt) {
91         var message = evt.data;
92
93         // this is a hack to avoid having to run JSON2js multiple 
94         // times on the same message.  Hopefully match() is faster.
95         var thread;
96         var match = message.match(/"thread":"(.*?)"/);
97         if (!match || !(thread = match[1])) {
98             throw new Error("Websocket message malformed; no thread: " + message);
99         }
100
101         console.debug('websocket received message for thread ' + thread);
102
103         var port_msg = {action: 'message', message : message};
104         var port_ident = thread_port_map[thread];
105
106         if (port_ident) {
107             send_msg_to_port(port_ident, port_msg);
108         } else {
109             // don't know who it's for, broadcast and let the ports
110             // sort it out for themselves.
111             broadcast(port_msg);
112         }
113
114         /* poor man's memory management.  We are not cleaning up our
115          * thread_port_map as we go, because that gets messy.  Instead,
116          * after the map has reached a certain size, clear it.  If any
117          * pending messages are afield that depend on the map, they 
118          * will be broadcast to all ports on arrival (see above).  Only the 
119          * port expecting a message with the given thread will honor the 
120          * message, all other ports will drop it silently.  We could just 
121          * do that for every messsage, but this is more efficient.
122          */
123         if (Object.keys(thread_port_map).length > 1000) {
124             thread_port_map = {};
125         }
126     }
127
128     websocket.onerror = function(evt) {
129         var err = "WebSocket Error " + evt + ' : ' + evt.data;
130         // propagate to all ports so it can be logged, etc. 
131         broadcast({action : 'error', message : err});
132         throw new Error(err);
133     }
134
135     websocket.onclose = function() {
136         console.log('closing websocket');
137     }
138 }
139
140 // called when a new port (tab) is opened
141 onconnect = function(e) {
142     var port = e.ports[0];
143
144     // we have no way of identifying ports within the message handler,
145     // so we apply an identifier to each and toss that into a closer.
146     var port_ident = port_identifier++;
147     connected_ports[port_ident] = port;
148
149     // message handler
150     port.addEventListener('message', function(e) {
151         var data = e.data;
152
153         if (data.action == 'message') {
154             thread_port_map[data.thread] = port_ident;
155             websocket.send(data.message);
156             return;
157         } 
158
159         if (messsage.action == 'close') {
160             // TODO: add me to body onunload in calling pages.
161             delete connected_ports[port_ident];
162             console.log('closed port ' + port_ident + 
163                 '; ' + Object.keys(connected_ports).length + ' remaining');
164             return;
165         }
166
167     }, false);
168
169     port.start();
170
171     console.log('added port ' + port_ident + 
172       '; ' + Object.keys(connected_ports).length + ' total');
173
174     open_websocket(port_ident);
175 }
176