juggernaut_rails 0.5.9

data/media/jquerynaut.js

@@ -0,0 +1,57 @@
+// Simply overwrites prototype specific functions 
+// with jquery specific versions 
+
+Juggernaut.fn.fire_event = function(fx_name) {
+     $(document).trigger("juggernaut:" + fx_name);
+   };
+
+Juggernaut.fn.bindToWindow = function() {
+    $(window).bind("load", this, function(e) {
+      juggernaut = e.data;
+      e.data.appendFlashObject();
+    });
+  };
+
+Juggernaut.toJSON = function(hash) {
+    return $.toJSON(hash) ;
+  };
+
+Juggernaut.parseJSON = function(string) {
+    return $.parseJSON(string);
+  };
+
+Juggernaut.fn.swf = function(){
+    return $('#' + this.options.swf_name)[0];
+  };
+  
+Juggernaut.fn.appendElement = function() {
+    this.element = $('<div id=juggernaut>');
+    $("body").append(this.element);
+  };
+
+Juggernaut.fn.refreshFlashObject = function(){
+    $(this.swf()).remove();
+    this.appendFlashObject();
+  };
+
+Juggernaut.fn.reconnect = function(){
+    if(this.options.reconnect_attempts){
+      this.attempting_to_reconnect = true;
+      this.fire_event('reconnect');
+      this.logger('Will attempt to reconnect ' + this.options.reconnect_attempts + ' times, the first in ' + (this.options.reconnect_intervals || 3) + ' seconds');
+      var self = this;
+      for(var i=0; i < this.options.reconnect_attempts; i++){
+        setTimeout(function(){
+          if(!self.is_connected){
+            self.logger('Attempting reconnect');
+            if(!self.ever_been_connected){
+              self.refreshFlashObject();
+            } else {
+              self.connect();
+            }
+          }
+        }, (this.options.reconnect_intervals || 3) * 1000 * (i + 1));
+        
+      }
+    }
+  };

data/media/json.js

@@ -0,0 +1,97 @@
+(function ($) {
+    var m = {
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '"' : '\\"',
+            '\\': '\\\\'
+        },
+        s = {
+            'array': function (x) {
+                var a = ['['], b, f, i, l = x.length, v;
+                for (i = 0; i < l; i += 1) {
+                    v = x[i];
+                    f = s[typeof v];
+                    if (f) {
+                        v = f(v);
+                        if (typeof v == 'string') {
+                            if (b) {
+                                a[a.length] = ',';
+                            }
+                            a[a.length] = v;
+                            b = true;
+                        }
+                    }
+                }
+                a[a.length] = ']';
+                return a.join('');
+            },
+            'boolean': function (x) {
+                return String(x);
+            },
+            'null': function (x) {
+                return "null";
+            },
+            'number': function (x) {
+                return isFinite(x) ? String(x) : 'null';
+            },
+            'object': function (x) {
+                if (x) {
+                    if (x instanceof Array) {
+                        return s.array(x);
+                    }
+                    var a = ['{'], b, f, i, v;
+                    for (i in x) {
+                        v = x[i];
+                        f = s[typeof v];
+                        if (f) {
+                            v = f(v);
+                            if (typeof v == 'string') {
+                                if (b) {
+                                    a[a.length] = ',';
+                                }
+                                a.push(s.string(i), ':', v);
+                                b = true;
+                            }
+                        }
+                    }
+                    a[a.length] = '}';
+                    return a.join('');
+                }
+                return 'null';
+            },
+            'string': function (x) {
+                if (/["\\\x00-\x1f]/.test(x)) {
+                    x = x.replace(/([\x00-\x1f\\"])/g, function(a, b) {
+                        var c = m[b];
+                        if (c) {
+                            return c;
+                        }
+                        c = b.charCodeAt();
+                        return '\\u00' +
+                            Math.floor(c / 16).toString(16) +
+                            (c % 16).toString(16);
+                    });
+                }
+                return '"' + x + '"';
+            }
+        };
+
+	$.toJSON = function(v) {
+		var f = isNaN(v) ? s[typeof v] : s['number'];
+		if (f) return f(v);
+	};
+	
+	$.parseJSON = function(v, safe) {
+		if (safe === undefined) safe = $.parseJSON.safe;
+		if (safe && !/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.test(v))
+			return undefined;
+		return eval('('+v+')');
+	};
+	
+	$.parseJSON.safe = false;
+
+})(jQuery);
+

data/media/juggernaut.as

@@ -0,0 +1,79 @@
+/*
+Copyright (c) 2007 Alexander MacCaw
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+  Compile using MTACS (http://www.mtasc.org/)
+  mtasc -version 8 -header 1:1:1 -main -swf juggernaut.swf juggernaut.as
+*/
+
+import flash.external.ExternalInterface;
+
+class SocketServer {
+  
+  static var socket : XMLSocket;
+  
+  static function connect(host:String, port:Number) {
+    // The following line was causing crashes on Leopard
+    // System.security.loadPolicyFile('xmlsocket://' + host + ':' + port);
+
+    socket = new XMLSocket();
+    socket.onData = onData;
+    socket.onConnect = onConnect;
+    socket.onClose = onDisconnect;
+    socket.connect(host, port);
+  }
+  
+  static function disconnect(){
+    socket.close();
+  }
+  
+  static function onConnect(success:Boolean) {
+    if(success){
+      ExternalInterface.call("juggernaut.connected");
+    } else {
+      ExternalInterface.call("juggernaut.errorConnecting");
+    }
+  }
+  
+  static function sendData(data:String){
+    socket.send(unescape(data));
+  }
+  
+  static function onDisconnect() {
+    ExternalInterface.call("juggernaut.disconnected");
+  }
+  
+  static function onData(data:String) {    
+    ExternalInterface.call("juggernaut.receiveData", escape(data));
+  }
+  
+  static function main() {
+    ExternalInterface.addCallback("connect", null, connect);
+    ExternalInterface.addCallback("sendData", null, sendData);
+    ExternalInterface.addCallback("disconnect", null, disconnect);
+    
+    ExternalInterface.call("juggernaut.initialized");
+  }
+  
+}
+

data/media/juggernaut.js

@@ -0,0 +1,204 @@
+/*
+Copyright (c) 2008 Alexander MacCaw
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+function Juggernaut(options) {
+  this.is_connected = false;
+  this.attempting_to_reconnect = false;
+  this.ever_been_connected = false;
+  this.hasLogger = "console" in window && "log" in window.console;
+  this.options = options;
+  this.bindToWindow();
+};
+
+Juggernaut.fn = Juggernaut.prototype;
+
+Juggernaut.fn.logger = function(msg) {
+  if (this.options.debug) {
+    msg = "Juggernaut: " + msg + " on " + this.options.host + ':' + this.options.port;
+    this.hasLogger ? console.log(msg) : alert(msg);
+  }
+};
+
+Juggernaut.fn.initialized = function(){
+  this.fire_event('initialized');
+  this.connect();
+};
+  
+Juggernaut.fn.broadcast = function(body, type, client_ids, channels){
+  var msg = {command: 'broadcast', body: body, type: (type||'to_channels')};
+  if(channels)  msg['channels'] = channels;
+  if(client_ids) msg['client_ids'] = client_ids;
+  this.sendData(Juggernaut.toJSON(msg));
+};
+  
+Juggernaut.fn.sendData = function(data){
+  this.swf().sendData(escape(data));
+};
+
+Juggernaut.fn.connect = function(){
+  if(!this.is_connected){
+    this.fire_event('connect');
+    this.swf().connect(this.options.host, this.options.port);
+  }
+};
+  
+Juggernaut.fn.disconnect = function(){
+  if(this.is_connected) {
+    this.swf().disconnect();
+    this.is_connected = false;
+  }
+};
+
+Juggernaut.fn.handshake = function() {
+  var handshake = {};
+  handshake['command'] = 'subscribe';
+  if(this.options.session_id) handshake['session_id'] = this.options.session_id;
+  if(this.options.client_id)  handshake['client_id'] = this.options.client_id;
+  if(this.options.channels)   handshake['channels'] = this.options.channels;
+  if(this.currentMsgId) {
+    handshake['last_msg_id'] = this.currentMsgId;
+    handshake['signature'] = this.currentSignature;
+  }
+
+  return handshake;
+};
+
+Juggernaut.fn.connected = function(e) {
+  var json = Juggernaut.toJSON(this.handshake());
+  this.sendData(json);
+  this.ever_been_connected = true;
+  this.is_connected = true;
+  var self = this;
+  setTimeout(function(){
+    if(self.is_connected) self.attempting_to_reconnect = false;
+  }, 1 * 1000);
+  this.logger('Connected');
+  this.fire_event('connected');
+};
+
+Juggernaut.fn.receiveData = function(e) {
+  var msg = Juggernaut.parseJSON(unescape(e.toString()));
+  this.currentMsgId = msg.id;
+  this.currentSignature = msg.signature;
+  this.logger("Received data:\n" + msg.body + "\n");
+  this.dispatchMessage(msg);
+};
+  
+Juggernaut.fn.dispatchMessage = function(msg) {
+  eval(msg.body);
+}
+
+var juggernaut;
+
+// Prototype specific - override for other frameworks
+Juggernaut.fn.fire_event = function(fx_name) {
+  $(document).fire("juggernaut:" + fx_name);
+};
+
+Juggernaut.fn.bindToWindow = function() {
+  Event.observe(window, 'load', function() {      
+    juggernaut = this;
+    this.appendFlashObject();
+  }.bind(this));
+};
+
+Juggernaut.toJSON = function(hash) {
+  return Object.toJSON(hash);
+};
+
+Juggernaut.parseJSON = function(string) {
+  return string.evalJSON();
+};
+
+Juggernaut.fn.swf = function(){
+  return $(this.options.swf_name);    
+};
+  
+Juggernaut.fn.appendElement = function() {
+  this.element = new Element('div', { id: 'juggernaut' });
+  $(document.body).insert({ bottom: this.element });
+};
+
+/*** END PROTOTYPE SPECIFIC ***/
+
+Juggernaut.fn.appendFlashObject = function(){
+  if(this.swf()) {
+    throw("Juggernaut error. 'swf_name' must be unique per juggernaut instance.");
+  }
+  Juggernaut.fn.appendElement();
+  swfobject.embedSWF(
+    this.options.swf_address, 
+    'juggernaut', 
+    this.options.width, 
+    this.options.height, 
+    String(this.options.flash_version),
+    this.options.ei_swf_address,
+    {'bridgeName': this.options.bridge_name},
+    {},
+    {'id': this.options.swf_name, 'name': this.options.swf_name}
+  );
+};
+
+Juggernaut.fn.refreshFlashObject = function(){
+  this.swf().remove();
+  this.appendFlashObject();
+};
+  
+Juggernaut.fn.errorConnecting = function(e) {
+  this.is_connected = false;
+  if(!this.attempting_to_reconnect) {
+    this.logger('There has been an error connecting');
+    this.fire_event('errorConnecting');
+    this.reconnect();
+  }
+};
+
+Juggernaut.fn.disconnected = function(e) {
+  this.is_connected = false;
+  if(!this.attempting_to_reconnect) {
+    this.logger('Connection has been lost');
+    this.fire_event('disconnected');
+    this.reconnect();
+  }
+};
+  
+Juggernaut.fn.reconnect = function(){
+  if(this.options.reconnect_attempts){
+    this.attempting_to_reconnect = true;
+    this.fire_event('reconnect');
+    this.logger('Will attempt to reconnect ' + this.options.reconnect_attempts + ' times,\
+the first in ' + (this.options.reconnect_intervals || 3) + ' seconds');
+    for(var i=0; i < this.options.reconnect_attempts; i++){
+      setTimeout(function(){
+        if(!this.is_connected){
+          this.logger('Attempting reconnect');
+          if(!this.ever_been_connected){
+            this.refreshFlashObject();
+          } else {
+            this.connect();
+          }
+        }
+      }.bind(this), (this.options.reconnect_intervals || 3) * 1000 * (i + 1));
+    }
+  }
+};

data/media/juggernaut.yml

@@ -0,0 +1,121 @@
+# 
+# == Juggernaut Server Configuration
+# 
+
+development:
+  :allowed_ips: 
+              - 127.0.0.1
+  :port: 5001
+production:
+  :allowed_ips: 
+              - 127.0.0.1
+  :port: 5001
+test:
+  :allowed_ips: 
+              - 127.0.0.1
+  :port: 5001
+
+# Common options:  
+#
+# :store_messages: true
+# :secret_key: your_secret_key_here
+# :log_path: log/juggernaut.log # Default
+# :pid_path: tmp/pids/juggernaut.5001.pid # Default
+# :debug: true # Automatically turned on in development
+# :host: 0.0.0.0
+# :public_port: 5001
+# :timeout: 10
+  
+# ======================
+# Juggernaut Options
+# ======================
+  
+# === Subscription authentication ===
+# Leave all subscription options uncommented to allow anyone to subscribe.
+
+# If specified, subscription_url is called everytime a client subscribes.
+# Parameters passed are: session_id, client_id and an array of channels.
+# 
+# The server should check that the session_id matches up to the client_id
+# and that the client is allowed to access the specified channels.
+# 
+# If a status code other than 200 is encountered, the subscription_request fails
+# and the client is disconnected.
+# 
+# :subscription_url:  http://localhost:3000/sessions/juggernaut_subscription
+    
+# === Broadcast and query authentication ===
+# Leave all broadcast/query options uncommented to allow anyone to broadcast/query.
+# 
+# Broadcast authentication in a production environment is very importantant since broadcasters
+# can execute JavaScript on subscribed clients, leaving you vulnerable to cross site scripting
+# attacks if broadcasters aren't authenticated. 
+
+# 1) Via IP address
+# 
+# If specified, if a client has an ip that is specified in allowed_ips, than it is automatically
+# authenticated, even if a secret_key isn't provided. 
+# 
+# This is the recommended method for broadcast authentication.
+#
+#:allowed_ips: 
+#             - 127.0.0.1
+#             # - 192.168.0.1
+#
+# 2) Via HTTP request
+# 
+# If specified, if a client attempts a broadcast/query, without a secret_key or using an IP
+# no included in allowed_ips, then broadcast_query_login_url will be called.
+# Parameters passed, if given, are: session_id, client_id, channels and type.
+# 
+# The server should check that the session_id matches up to the client id, and the client
+# is allowed to perform that particular type of broadcast/query.
+# 
+# If a status code other than 200 is encountered, the broadcast_query_login_url fails
+# and the client is disconnected.
+# 
+# :broadcast_query_login_url: http://localhost:3000/sessions/juggernaut_broadcast
+
+# 3) Via shared secret key
+# 
+# This secret key must be sent with any query/broadcast commands. 
+# It must be the same as the one in the Rails config file.
+# 
+# You shouldn't authenticate broadcasts from subscribed clients using this method
+# since the secret_key will be easily visible in the page (and not so secret any more)!
+# 
+# :secret_key: 8a01f4941eac46fcb36354c62487ef04d113cdbe
+  
+# == Subscription Logout ==
+
+# If specified, logout_connection_url is called everytime a specific connection from a subscribed client disconnects. 
+# Parameters passed are session_id, client_id and an array of channels specific to that connection.
+# 
+# :logout_connection_url: http://localhost:3000/sessions/juggernaut_connection_logout
+
+# Logout url is called when all connections from a subscribed client are closed.
+# Parameters passed are session_id and client_id.
+# 
+# :logout_url: http://localhost:3000/sessions/juggernaut_logout
+
+# === Miscellaneous ===
+
+# timeout defaults to 10. A timeout is the time between when a client closes a connection
+# and a logout_request or logout_connection_request is made. The reason for this is that a client
+# may only temporarily be disconnected, and may attempt a reconnect very soon.
+# 
+# :timeout: 10
+
+# store_messages defaults to false. If this option is true, messages send to connections will be stored. 
+# This is useful since a client can then receive broadcasted message that it has missed (perhaps it was disconnected).
+#
+# :store_messages: false
+  
+# === Server ===
+
+# Host defaults to "0.0.0.0". You shouldn't need to change this.
+# :host: 0.0.0.0
+
+# Port is mandatory
+#:port: 5001
+