sonixlabs-em-websocket 0.3.7

data/examples/js/web_socket.js

@@ -0,0 +1,312 @@
+// Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+// Lincense: New BSD Lincense
+// Reference: http://dev.w3.org/html5/websockets/
+// Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+
+(function() {
+  
+  if (window.WebSocket) return;
+
+  var console = window.console;
+  if (!console) console = {log: function(){ }, error: function(){ }};
+
+  function hasFlash() {
+    if ('navigator' in window && 'plugins' in navigator && navigator.plugins['Shockwave Flash']) {
+      return !!navigator.plugins['Shockwave Flash'].description;
+    }
+    if ('ActiveXObject' in window) {
+      try {
+        return !!new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version');
+      } catch (e) {}
+    }
+    return false;
+  }
+  
+  if (!hasFlash()) {
+    console.error("Flash Player is not installed.");
+    return;
+  }
+
+  WebSocket = function(url, protocol, proxyHost, proxyPort, headers) {
+    var self = this;
+    self.readyState = WebSocket.CONNECTING;
+    self.bufferedAmount = 0;
+    WebSocket.__addTask(function() {
+      self.__flash =
+        WebSocket.__flash.create(url, protocol, proxyHost || null, proxyPort || 0, headers || null);
+
+      self.__flash.addEventListener("open", function(fe) {
+        try {
+          if (self.onopen) self.onopen();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("close", function(fe) {
+        try {
+          if (self.onclose) self.onclose();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("message", function(fe) {
+        var data = decodeURIComponent(fe.getData());
+        try {
+          if (self.onmessage) {
+            var e;
+            if (window.MessageEvent) {
+              e = document.createEvent("MessageEvent");
+              e.initMessageEvent("message", false, false, data, null, null, window);
+            } else { // IE
+              e = {data: data};
+            }
+            self.onmessage(e);
+          }
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("stateChange", function(fe) {
+        try {
+          self.readyState = fe.getReadyState();
+          self.bufferedAmount = fe.getBufferedAmount();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      //console.log("[WebSocket] Flash object is ready");
+    });
+  }
+
+  WebSocket.prototype.send = function(data) {
+    if (!this.__flash || this.readyState == WebSocket.CONNECTING) {
+      throw "INVALID_STATE_ERR: Web Socket connection has not been established";
+    }
+    var result = this.__flash.send(data);
+    if (result < 0) { // success
+      return true;
+    } else {
+      this.bufferedAmount = result;
+      return false;
+    }
+  };
+
+  WebSocket.prototype.close = function() {
+    if (!this.__flash) return;
+    if (this.readyState != WebSocket.OPEN) return;
+    this.__flash.close();
+    // Sets/calls them manually here because Flash WebSocketConnection.close cannot fire events
+    // which causes weird error:
+    // > You are trying to call recursively into the Flash Player which is not allowed.
+    this.readyState = WebSocket.CLOSED;
+    if (this.onclose) this.onclose();
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture !NB Not implemented yet
+   * @return void
+   */
+  WebSocket.prototype.addEventListener = function(type, listener, useCapture) {
+    if (!('__events' in this)) {
+      this.__events = {};
+    }
+    if (!(type in this.__events)) {
+      this.__events[type] = [];
+      if ('function' == typeof this['on' + type]) {
+        this.__events[type].defaultHandler = this['on' + type];
+        this['on' + type] = WebSocket_FireEvent(this, type);
+      }
+    }
+    this.__events[type].push(listener);
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture NB! Not implemented yet
+   * @return void
+   */
+  WebSocket.prototype.removeEventListener = function(type, listener, useCapture) {
+    if (!('__events' in this)) {
+      this.__events = {};
+    }
+    if (!(type in this.__events)) return;
+    for (var i = this.__events.length; i > -1; --i) {
+      if (listener === this.__events[type][i]) {
+        this.__events[type].splice(i, 1);
+        break;
+      }
+    }
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {WebSocketEvent} event
+   * @return void
+   */
+  WebSocket.prototype.dispatchEvent = function(event) {
+    if (!('__events' in this)) throw 'UNSPECIFIED_EVENT_TYPE_ERR';
+    if (!(event.type in this.__events)) throw 'UNSPECIFIED_EVENT_TYPE_ERR';
+
+    for (var i = 0, l = this.__events[event.type].length; i < l; ++ i) {
+      this.__events[event.type][i](event);
+      if (event.cancelBubble) break;
+    }
+
+    if (false !== event.returnValue &&
+        'function' == typeof this.__events[event.type].defaultHandler)
+    {
+      this.__events[event.type].defaultHandler(event);
+    }
+  };
+
+  /**
+   *
+   * @param {object} object
+   * @param {string} type
+   */
+  function WebSocket_FireEvent(object, type) {
+    return function(data) {
+      var event = new WebSocketEvent();
+      event.initEvent(type, true, true);
+      event.target = event.currentTarget = object;
+      for (var key in data) {
+        event[key] = data[key];
+      }
+      object.dispatchEvent(event, arguments);
+    };
+  }
+
+  /**
+   * Basic implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface">DOM 2 EventInterface</a>}
+   *
+   * @class
+   * @constructor
+   */
+  function WebSocketEvent(){}
+
+  /**
+   *
+   * @type boolean
+   */
+  WebSocketEvent.prototype.cancelable = true;
+
+  /**
+   *
+   * @type boolean
+   */
+  WebSocketEvent.prototype.cancelBubble = false;
+
+  /**
+   *
+   * @return void
+   */
+  WebSocketEvent.prototype.preventDefault = function() {
+    if (this.cancelable) {
+      this.returnValue = false;
+    }
+  };
+
+  /**
+   *
+   * @return void
+   */
+  WebSocketEvent.prototype.stopPropagation = function() {
+    this.cancelBubble = true;
+  };
+
+  /**
+   *
+   * @param {string} eventTypeArg
+   * @param {boolean} canBubbleArg
+   * @param {boolean} cancelableArg
+   * @return void
+   */
+  WebSocketEvent.prototype.initEvent = function(eventTypeArg, canBubbleArg, cancelableArg) {
+    this.type = eventTypeArg;
+    this.cancelable = cancelableArg;
+    this.timeStamp = new Date();
+  };
+
+
+  WebSocket.CONNECTING = 0;
+  WebSocket.OPEN = 1;
+  WebSocket.CLOSED = 2;
+
+  WebSocket.__tasks = [];
+
+  WebSocket.__initialize = function() {
+    if (!WebSocket.__swfLocation) {
+      //console.error("[WebSocket] set WebSocket.__swfLocation to location of WebSocketMain.swf");
+      //return;
+      WebSocket.__swfLocation = "js/WebSocketMain.swf";
+    }
+    var container = document.createElement("div");
+    container.id = "webSocketContainer";
+    // Puts the Flash out of the window. Note that we cannot use display: none or visibility: hidden
+    // here because it prevents Flash from loading at least in IE.
+    container.style.position = "absolute";
+    container.style.left = "-100px";
+    container.style.top = "-100px";
+    var holder = document.createElement("div");
+    holder.id = "webSocketFlash";
+    container.appendChild(holder);
+    document.body.appendChild(container);
+    swfobject.embedSWF(
+      WebSocket.__swfLocation, "webSocketFlash", "8", "8", "9.0.0",
+      null, {bridgeName: "webSocket"}, null, null,
+      function(e) {
+        if (!e.success) console.error("[WebSocket] swfobject.embedSWF failed");
+      }
+    );
+    FABridge.addInitializationCallback("webSocket", function() {
+      try {
+        //console.log("[WebSocket] FABridge initializad");
+        WebSocket.__flash = FABridge.webSocket.root();
+        WebSocket.__flash.setCallerUrl(location.href);
+        for (var i = 0; i < WebSocket.__tasks.length; ++i) {
+          WebSocket.__tasks[i]();
+        }
+        WebSocket.__tasks = [];
+      } catch (e) {
+        console.error("[WebSocket] " + e.toString());
+      }
+    });
+  };
+
+  WebSocket.__addTask = function(task) {
+    if (WebSocket.__flash) {
+      task();
+    } else {
+      WebSocket.__tasks.push(task);
+    }
+  }
+
+  // called from Flash
+  function webSocketLog(message) {
+    console.log(decodeURIComponent(message));
+  }
+
+  // called from Flash
+  function webSocketError(message) {
+    console.error(decodeURIComponent(message));
+  }
+
+  if (window.addEventListener) {
+    window.addEventListener("load", WebSocket.__initialize, false);
+  } else {
+    window.attachEvent("onload", WebSocket.__initialize);
+  }
+  
+})();

data/examples/multicast.rb

@@ -0,0 +1,47 @@
+require 'em-websocket'
+# requires the twitter-stream gem
+require 'twitter/json_stream'
+require 'json'
+
+#
+# broadcast all ruby related tweets to all connected users!
+#
+
+username = ARGV.shift
+password = ARGV.shift
+raise "need username and password" if !username or !password
+
+EventMachine.run {
+  @channel = EM::Channel.new
+
+  @twitter = Twitter::JSONStream.connect(
+    :path => '/1/statuses/filter.json?track=ruby',
+    :auth => "#{username}:#{password}",
+    :ssl => true
+  )
+
+  @twitter.each_item do |status|
+    status = JSON.parse(status)
+    @channel.push "#{status['user']['screen_name']}: #{status['text']}"
+  end
+
+
+  EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080, :debug => true) do |ws|
+
+    ws.onopen {
+      sid = @channel.subscribe { |msg| ws.send msg }
+      @channel.push "#{sid} connected!"
+
+      ws.onmessage { |msg|
+        @channel.push "<#{sid}>: #{msg}"
+      }
+
+      ws.onclose {
+        @channel.unsubscribe(sid)
+      }
+    }
+
+  end
+
+  puts "Server started"
+}

data/examples/test.html

@@ -0,0 +1,30 @@
+<html>
+  <head>
+    <script src='js/swfobject.js'></script>
+    <script src='js/FABridge.js'></script>
+    <script src='js/web_socket.js'></script>
+    <script>
+      function init() {
+        function debug(string) {
+          var element = document.getElementById("debug");
+          var p = document.createElement("p");
+          p.appendChild(document.createTextNode(string));
+          element.appendChild(p);
+        }
+
+        var Socket = "MozWebSocket" in window ? MozWebSocket : WebSocket;
+        var ws = new Socket("ws://localhost:8080/");
+        ws.onmessage = function(evt) { debug("Message: " + evt.data); };
+        ws.onclose = function() { debug("socket closed"); };
+        ws.onopen = function() {
+          debug("connected...");
+          ws.send("hello server");
+          ws.send("hello again");
+        };
+      };
+    </script>
+  </head>
+  <body onload="init();">
+    <div id="debug"></div>
+  </body>
+</html>

data/lib/em-websocket/client_connection.rb

@@ -0,0 +1,19 @@
+require 'addressable/uri'
+
+module EventMachine
+  module WebSocket
+    class ClientConnection < EventMachine::WebSocket::Connection
+
+      def initialize(options)
+        super
+        @handler = Handler08.new( self, options, options[:debug] )
+        @handler.run_client
+      end
+
+      def dispatch(data)
+        # server's handshake response
+        @handler.client_handle_server_handshake_response(data)
+      end
+    end
+  end
+end

data/lib/em-websocket/close03.rb

@@ -0,0 +1,11 @@
+module EventMachine
+  module WebSocket
+    module Close03
+      def close_websocket(code, body)
+        # TODO: Ideally send body data and check that it matches in ack
+        send_frame(:close, '')
+        @state = :closing
+      end
+    end
+  end
+end

data/lib/em-websocket/close05.rb

@@ -0,0 +1,11 @@
+module EventMachine
+  module WebSocket
+    module Close05
+      def close_websocket(code, body)
+        # TODO: Ideally send body data and check that it matches in ack
+        send_frame(:close, "\x53")
+        @state = :closing
+      end
+    end
+  end
+end

data/lib/em-websocket/close06.rb

@@ -0,0 +1,16 @@
+module EventMachine
+  module WebSocket
+    module Close06
+      def close_websocket(code, body)
+        if code
+          close_data = [code].pack('n')
+          close_data << body if body
+          send_frame(:close, close_data)
+        else
+          send_frame(:close, '')
+        end
+        @state = :closing
+      end
+    end
+  end
+end

data/lib/em-websocket/close75.rb

@@ -0,0 +1,10 @@
+module EventMachine
+  module WebSocket
+    module Close75
+      def close_websocket(code, body)
+        @state = :closed
+        @connection.close_connection_after_writing
+      end
+    end
+  end
+end

data/lib/em-websocket/connection.rb

@@ -0,0 +1,184 @@
+require 'addressable/uri'
+
+module EventMachine
+  module WebSocket
+    class Connection < EventMachine::Connection
+      include Debugger
+
+      # define WebSocket callbacks
+      def onopen(&blk);     @onopen = blk;    end
+      def onclose(&blk);    @onclose = blk;   end
+      def onerror(&blk);    @onerror = blk;   end
+      def onmessage(&blk);  @onmessage = blk; end
+
+      def trigger_on_message(msg, type=:text)
+        if @onmessage
+          if @onmessage.arity == 2
+            @onmessage.call msg, type
+          else
+            @onmessage.call msg
+          end
+        end
+      end
+      def trigger_on_open
+        @onopen.call if @onopen
+      end
+      def trigger_on_close
+        @onclose.call if @onclose
+      end
+      def trigger_on_error(reason)
+        return false unless @onerror
+        @onerror.call(reason)
+        true
+      end
+
+      def initialize(options)
+        @options = options
+        @debug = options[:debug] || false
+        @secure = options[:secure] || false
+        @tls_options = options[:tls_options] || {}
+        @data = ''
+
+        debug [:initialize]
+      end
+
+      # Use this method to close the websocket connection cleanly
+      # This sends a close frame and waits for acknowlegement before closing
+      # the connection
+      def close_websocket(code = nil, body = nil)
+        if code && !(4000..4999).include?(code)
+          raise "Application code may only use codes in the range 4000-4999"
+        end
+
+        # If code not defined then set to 1000 (normal closure)
+        code ||= 1000
+
+        close_websocket_private(code, body)
+      end
+
+      def post_init
+        start_tls(@tls_options) if @secure
+      end
+
+      def receive_data(data)
+        debug [:receive_data, data]
+
+        if @handler and state != :handshake #TODO a different way to catch client sent handshake, is waiting state
+          @handler.receive_data(data)
+        else
+          dispatch(data)
+        end
+      rescue HandshakeError => e
+        debug [:error, e]
+        trigger_on_error(e)
+        # Errors during the handshake require the connection to be aborted
+        abort
+      rescue WebSocketError => e
+        debug [:error, e]
+        trigger_on_error(e)
+        close_websocket_private(1002) # 1002 indicates a protocol error
+      rescue => e
+        debug [:error, e]
+        # These are application errors - raise unless onerror defined
+        trigger_on_error(e) || raise(e)
+        # There is no code defined for application errors, so use 3000
+        # (which is reserved for frameworks)
+        close_websocket_private(3000)
+      end
+
+      def unbind
+        debug [:unbind, :connection]
+
+        @handler.unbind if @handler
+      rescue => e
+        debug [:error, e]
+        # These are application errors - raise unless onerror defined
+        trigger_on_error(e) || raise(e)
+      end
+
+      def dispatch(data)
+        if data.match(/\A<policy-file-request\s*\/>/)
+          send_flash_cross_domain_file
+          return false
+        else
+          debug [:inbound_headers, data]
+          @data << data
+          @handler = HandlerFactory.build(self, @data, @secure, @debug)
+          unless @handler
+            # The whole header has not been received yet.
+            return false
+          end
+          @data = nil
+          @handler.run_server
+          return true
+        end
+      end
+
+      def send_flash_cross_domain_file
+        file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+        debug [:cross_domain, file]
+        send_data file
+
+        # handle the cross-domain request transparently
+        # no need to notify the user about this connection
+        @onclose = nil
+        close_connection_after_writing
+      end
+
+      def send(data, type=:text)
+        if type == :text
+          # If we're using Ruby 1.9, be pedantic about encodings
+          if data.respond_to?(:force_encoding)
+            # Also accept ascii only data in other encodings for convenience
+            unless (data.encoding == Encoding.find("UTF-8") && data.valid_encoding?) || data.ascii_only?
+              raise WebSocketError, "Data sent to WebSocket must be valid UTF-8 but was #{data.encoding} (valid: #{data.valid_encoding?})"
+            end
+            # This labels the encoding as binary so that it can be combined with
+            # the BINARY framing
+            data.force_encoding("BINARY")
+          else
+            # TODO: Check that data is valid UTF-8
+          end
+
+          if @handler
+            @handler.send_text_frame(data)
+          else
+            raise WebSocketError, "Cannot send data before onopen callback"
+          end
+        else
+          if @handler
+            @handler.send_frame(type, data)
+          else
+            raise WebSocketError, "Cannot send data before onopen callback"
+          end
+        end
+      end
+
+      def request
+        @handler ? @handler.request : {}
+      end
+
+      def state
+        @handler ? @handler.state : :handshake
+      end
+
+      private
+
+      # As definited in draft 06 7.2.2, some failures require that the server
+      # abort the websocket connection rather than close cleanly
+      def abort
+        close_connection
+      end
+
+      def close_websocket_private(code, body = nil)
+        if @handler
+          debug [:closing, code]
+          @handler.close_websocket(code, body)
+        else
+          # The handshake hasn't completed - should be safe to terminate
+          abort
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/debugger.rb

@@ -0,0 +1,17 @@
+module EventMachine
+  module WebSocket
+    module Debugger
+
+      private
+
+      def debug(*data)
+        if @debug
+          require 'pp'
+          pp data
+          puts
+        end
+      end
+
+    end
+  end
+end