websocket-rack 0.1.4 → 0.2.1

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.1 / 2011-04-01
+
+- bugfix: env passed to callbacks should be valid now
+
+## 0.2.0 / 2011-04-01
+
+- prepare for supporting server other that thin
+- small changes of API
+- change handling backend options
+- depend on em-websocket instead of copying source
+
 ## 0.1.4 / 2011-03-13
 
 - performance improvements thanks to rbtrace

data/README.md

@@ -12,7 +12,7 @@ Create sample rack config file, and inside build app basing on Rack::WebSocket::
     end
 
     map '/' do
-      run MyApp
+      run MyApp.new
     end
 
 After that just run Rack config from Rack server:
@@ -25,50 +25,50 @@ Done.
 
 Rack::WebSocket::Application make following methods available:
 
-### on_open
+### on_open(env)
 
-Called after client is connected.
+Called after client is connected. Rack env of client is passed as attribute.
 
 Example:
 
     class MyApp < Rack::WebSocket::Application
-      def on_open
+      def on_open(env)
         puts "Clien connected"
       end
     end
 
-### on_close
+### on_close(env)
 
-Called after client is disconnected
+Called after client is disconnected. Rack env of client is passed as attribute.
 
 Example:
 
     class MyApp < Rack::WebSocket::Application
-      def on_close
+      def on_close(env)
         puts "Clien disconnected"
       end
     end
 
-### on_message(msg)
+### on_message(env, msg)
 
-Called after server receive message
+Called after server receive message. Rack env of client is passed as attribute.
 
 Example:
 
     class MyApp < Rack::WebSocket::Application
-      def on_message(msg)
+      def on_message(env, msg)
         puts "Received message: " + msg
       end
     end
 
-### on_error(error)
+### on_error(env, error)
 
 Called after server catch error. Variable passed is instance of Ruby Exception class.
 
 Example:
 
     class MyApp < Rack::WebSocket::Application
-      def on_error(error)
+      def on_error(env, error)
         puts "Error occured: " + error.message
       end
     end
@@ -80,34 +80,50 @@ Sends data do client.
 Example:
 
     class MyApp < Rack::WebSocket::Application
-      def on_open
+      def on_open(env)
         send_data "Hello to you!"
       end
     end
 
+### close_websocket
+
+Closes connection.
+
+Example:
+
+    class MyApp < Rack::WebSocket::Application
+      def on_open(env)
+        close_websocket if env['REQUEST_PATH'] != '/websocket'
+      end
+    end
+
 ## Available variables:
 
-### @env
+### @options
 
-Rack env - contain all data sent by client when connectind.
+Options passed to app on initialize.
 
-### @conn
+Example:
 
-Connection - thin wrapper between client and EventMachine::Connection
+    # In config.ru
+    map '/' do
+      run MyApp.new :some => :variable
+    end
+    
+    # In application instance
+    @options # => { :some => :variable }
 
 ## FAQ
 
 ### Which Rack servers are supported?
 
-Currently only Thin. I plan to support also Rainbows! in future, but not yet.
+Currently we are supporting following servers:
 
-### Why (using Thin) user is disconnected after 30 seconds?
-
-This is bug in EventMachine < 1.0.0. Please consider updating to newer version or use thin-websocket wrapper around thin binary.
+- Thin
 
 ### How to enable debugging?
 
-Just use :websocket\_debug => true option when initializing your app.
+Just use :backend => { :debug => true } option when initializing your app.
 
 ### How to enable wss/SSL support?
 
@@ -117,10 +133,12 @@ Thin v1.2.8 have --ssl option - just use that! :)
 
 Check [Thin](http://code.macournoyer.com/thin/) config - any option supported by Thin(like demonizing, SSL etc.) is supported by WebSocket-Rack.
 
+### Why (using Thin) user is disconnected after 30 seconds?
+
+This is bug in EventMachine < 1.0.0. Please consider updating to newer version or use thin-websocket wrapper around thin binary.
+
 ## About
 
 Author: Bernard Potocki <<bernard.potocki@imanel.org>>
 
-Most source taken from [em-websocket](http://github.com/igrigorik/em-websocket)
-
 Released under MIT license.

data/Rakefile

@@ -4,7 +4,7 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/helper.rb"]
+  t.rspec_opts = ["-c", "-f progress"]
   t.pattern = 'spec/**/*_spec.rb'
 end
 

data/example/example.ru

@@ -1,7 +1,7 @@
 require 'lib/rack/websocket'
 
 class MyApp < Rack::WebSocket::Application
-  def on_open
+  def on_open(env)
     puts "client connected"
     EM.add_timer(5) do
       send_data "This message should show-up 5 secs later"
@@ -12,12 +12,12 @@ class MyApp < Rack::WebSocket::Application
     end
   end
 
-  def on_message(msg)
+  def on_message(env, msg)
     puts "message received: " + msg
-    send_data "Hello #{msg}"
+    send_data "Message: #{msg}"
   end
 
-  def on_close
+  def on_close(env)
     puts "client disconnected"
   end
 end
@@ -29,5 +29,5 @@ map '/' do
 end
 
 map '/websocket' do
-  run MyApp.new # :websocket_debug => true
+  run MyApp.new # :backend => { :debug => true }
 end

data/lib/rack/websocket/application.rb

@@ -2,77 +2,48 @@ module Rack
   module WebSocket
     class Application
       
+      DEFAULT_OPTIONS = {}
+      
       class << self
-        def new(*args)
-          if args.last == {:real_run => true}
-            args.pop
-            super(*args)
-          else
-            proc do |env|
-              self.new(*(args << {:real_run => true})).call(env)
-            end
-          end
-        end
+        attr_accessor :websocket_handler
       end
-
-      DEFAULT_OPTIONS = {}
-      attr_accessor :options
-
-      def on_open; end # Fired when a client is connected.
-      def on_message(msg); end # Fired when a message from a client is received.
-      def on_close; end # Fired when a client is disconnected.
-      def on_error(error); end # Fired when error occurs.
-
-      def initialize(*args)
-        app, options = args[0], args[1]
-        app, options = nil, app if app.is_a?(Hash)
-        @options = DEFAULT_OPTIONS.merge(options || {})
-        @app = app
+      
+      def on_open(env); end
+      def on_message(env, msg); end
+      def on_close(env); end
+      def on_error(env, error); end
+      
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
       end
-
+      
       def call(env)
-        if(env['HTTP_CONNECTION'].to_s.downcase == 'upgrade' && env['HTTP_UPGRADE'].to_s.downcase == 'websocket')
-          @env = env
-          socket = env['async.connection']
-          @conn = Connection.new(self, socket, :debug => !!@options[:websocket_debug])
-          @conn.dispatch(env) ? async_response : failure_response
-        elsif @app
-          @app.call(env)
-        else
-          not_found_response
-        end
+        detect_handler(env)
+        dup._call(env)
       end
-
-      def close_websocket
-        if @conn
-          @conn.close_websocket
-        else
-          raise WebSocketError, "WebSocket not opened"
-        end
+      
+      def _call(env)
+        websocket_handler.call(env)
       end
-
-      def send_data(data)
-        if @conn
-          @conn.send data
+      
+      def method_missing(sym, *args, &block)
+        if websocket_handler && websocket_handler.respond_to?(sym)
+          websocket_handler.send sym, *args, &block
         else
-          raise WebSocketError, "WebSocket not opened"
+          super
         end
       end
-
-      protected
-
-      def async_response
-        [-1, {}, []]
-      end
-
-      def failure_response
-        [ 400, { "Content-Type" => "text/plain" }, [ 'invalid data' ] ]
+      
+      private
+      
+      def detect_handler(env)
+        self.class.websocket_handler ||= Handler.detect(env)
       end
-
-      def not_found_response
-        [ 404, { "Content-Type" => "text/plain" }, [ 'not found' ] ]
+      
+      def websocket_handler
+        @websocket_handler ||= self.class.websocket_handler.new(self, @options || {})
       end
-
+      
     end
   end
 end

data/lib/rack/websocket/extensions/common.rb

@@ -0,0 +1,61 @@
+module Rack
+  module WebSocket
+    module Extensions
+        module Common
+
+        def self.included(base)
+          base.class_eval do
+            alias :receive_data_without_websocket :receive_data
+            alias :receive_data :receive_data_with_websocket
+
+            alias :unbind_without_websocket :unbind
+            alias :unbind :unbind_with_websocket
+
+            alias :receive_data_without_flash_policy_file :receive_data
+            alias :receive_data :receive_data_with_flash_policy_file
+          end
+        end
+
+        attr_accessor :websocket
+
+        def websocket?
+          !self.websocket.nil?
+        end
+
+        def receive_data_with_websocket(data)
+          if self.websocket?
+            self.websocket.receive_data(data)
+          else
+            receive_data_without_websocket(data)
+          end
+        end
+
+        def unbind_with_websocket
+          if self.websocket?
+            self.websocket.unbind
+          else
+            unbind_without_websocket
+          end
+        end
+
+        def receive_data_with_flash_policy_file(data)
+          # thin require data to be proper http request - in it's not
+          # then @request.parse raises exception and data isn't parsed
+          # by futher methods. Here we only check if it is flash
+          # policy file request ("<policy-file-request/>\000") and
+          # if so then flash policy file is returned. if not then
+          # rest of request is handled.
+          if (data == "<policy-file-request/>\000")
+            file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+            # ignore errors - we will close this anyway
+            send_data(file) rescue nil
+            close_connection_after_writing
+          else
+            receive_data_without_flash_policy_file(data)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/websocket/extensions/thin/connection.rb

@@ -4,66 +4,18 @@ module Rack
       module Thin
         module Connection
 
-          def self.included(thin_conn)
-            thin_conn.class_eval do
+          def self.included(base)
+            base.class_eval do
               alias :pre_process_without_websocket :pre_process
               alias :pre_process :pre_process_with_websocket
-
-              alias :receive_data_without_websocket :receive_data
-              alias :receive_data :receive_data_with_websocket
-
-              alias :unbind_without_websocket :unbind
-              alias :unbind :unbind_with_websocket
-
-              alias :receive_data_without_flash_policy_file :receive_data
-              alias :receive_data :receive_data_with_flash_policy_file
             end
           end
 
-          attr_accessor :websocket
-
-          def websocket?
-            !self.websocket.nil?
-          end
-
           def pre_process_with_websocket
             @request.env['async.connection'] = self
             pre_process_without_websocket
           end
 
-          def receive_data_with_websocket(data)
-            if self.websocket?
-              self.websocket.receive_data(data)
-            else
-              receive_data_without_websocket(data)
-            end
-          end
-
-          def unbind_with_websocket
-            if self.websocket?
-              self.websocket.unbind
-            else
-              unbind_without_websocket
-            end
-          end
-
-          def receive_data_with_flash_policy_file(data)
-            # thin require data to be proper http request - in it's not
-            # then @request.parse raises exception and data isn't parsed
-            # by futher methods. Here we only check if it is flash
-            # policy file request ("<policy-file-request/>\000") and
-            # if so then flash policy file is returned. if not then
-            # rest of request is handled.
-            if (data == "<policy-file-request/>\000")
-              file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
-              # ignore errors - we will close this anyway
-              send_data(file) rescue nil
-              close_connection_after_writing
-            else
-              receive_data_without_flash_policy_file(data)
-            end
-          end
-
         end
       end
     end

data/lib/rack/websocket/extensions/thin.rb

@@ -5,9 +5,9 @@ module Rack
 
         autoload :Connection, "#{::File.dirname(__FILE__)}/thin/connection"
 
-        def self.included(thin)
-          thin_connection = thin.const_get(:Connection)
-          thin_connection.send(:include, Thin.const_get(:Connection))
+        def self.apply!
+          ::Thin::Connection.send(:include, ::Rack::WebSocket::Extensions::Common)
+          ::Thin::Connection.send(:include, ::Rack::WebSocket::Extensions::Thin::Connection)
         end
 
       end

data/lib/rack/websocket/extensions.rb

@@ -0,0 +1,14 @@
+module Rack
+  module WebSocket
+    module Extensions
+      
+      autoload :Common,   "#{ROOT_PATH}/websocket/extensions/common"
+      autoload :Thin,     "#{ROOT_PATH}/websocket/extensions/thin"
+      
+      def self.apply!
+        Thin.apply! if defined?(::Thin)
+      end
+      
+    end
+  end
+end

data/lib/rack/websocket/handler/base.rb

@@ -0,0 +1,41 @@
+module Rack
+  module WebSocket
+    module Handler
+      class Base
+                
+        def on_open; @parent.on_open(@env); end # Fired when a client is connected.
+        def on_message(msg); @parent.on_message(@env, msg); end # Fired when a message from a client is received.
+        def on_close; @parent.on_close(@env); end # Fired when a client is disconnected.
+        def on_error(error); @parent.on_error(@env, error); end # Fired when error occurs.
+
+        def initialize(parent, options = {})
+          @parent = parent
+          @options = options[:backend] || {}
+        end
+
+        def call(env)
+          raise 'Not implemented'
+        end
+
+        def send_data(data)
+          raise 'Not implemented'
+        end
+
+        def close_websocket
+          raise 'Not implemented'
+        end
+
+        protected
+
+        def async_response
+          [-1, {}, []]
+        end
+
+        def failure_response
+          [ 400, {'Content-Type' => 'text/plain'}, [ 'Bad request' ] ]
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/websocket/handler/stub.rb

@@ -0,0 +1,14 @@
+module Rack
+  module WebSocket
+    module Handler
+      class Stub < Base
+
+        def call(env)
+          raise 'Unknown handler!'
+          close_websocket
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/websocket/handler/thin/connection.rb

@@ -0,0 +1,89 @@
+require 'addressable/uri'
+
+module Rack
+  module WebSocket
+    module Handler
+      class Thin
+        class Connection < ::EventMachine::WebSocket::Connection
+
+          # Overwrite new from EventMachine
+          def self.new(*args)
+            instance = allocate
+            instance.__send__(:initialize, *args)
+            instance
+          end
+
+          def trigger_on_message(msg)
+            @app.on_message(msg)
+          end
+          def trigger_on_open
+            @app.on_open
+          end
+          def trigger_on_close
+            @app.on_close
+          end
+          def trigger_on_error(error)
+            @app.on_error(error)
+          end
+
+          def initialize(app, socket, options = {})
+            @app = app
+            @socket = socket
+            @options = options
+            @debug = options[:debug] || false
+            @ssl = socket.backend.respond_to?(:ssl?) && socket.backend.ssl?
+
+            socket.websocket = self
+            socket.comm_inactivity_timeout = 0
+
+            if socket.comm_inactivity_timeout != 0
+              puts "WARNING: You are using old EventMachine version. " +
+                   "Please consider updating to EM version >= 1.0.0 " +
+                   "or running Thin using thin-websocket."
+            end
+
+            debug [:initialize]
+          end
+
+          def dispatch(request)
+            return false if request.nil?
+            debug [:inbound_headers, request]
+            @handler = HandlerFactory.build_with_request(self, request, request['body'], @ssl, @debug)
+            unless @handler
+              # The whole header has not been received yet.
+              return false
+            end
+            @handler.run
+            return true
+          rescue => e
+            debug [:error, e]
+            process_bad_request(e)
+            return false
+          end
+
+          def process_bad_request(reason)
+            trigger_on_error(reason)
+            send_data "HTTP/1.1 400 Bad request\r\n\r\n"
+            close_connection_after_writing
+          end
+
+          def close_with_error(message)
+            trigger_on_error(message)
+            close_connection_after_writing
+          end
+
+          # Overwrite send_data from EventMachine
+          def send_data(*args)
+            @socket.send_data(*args)
+          end
+
+          # Overwrite close_connection from EventMachine
+          def close_connection(*args)
+            @socket.close_connection(*args)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rack/websocket/handler/thin/handler_factory.rb

@@ -0,0 +1,56 @@
+module Rack
+  module WebSocket
+    module Handler
+      class Thin
+        class HandlerFactory < ::EventMachine::WebSocket::HandlerFactory
+
+          # Bottom half of em-websocket HandlerFactory
+          # Taken from http://github.com/dj2/em-websocket
+          # This method is also used in experimental branch of Goliath
+          def self.build_with_request(connection, request, remains, secure = false, debug = false)
+            version = request['Sec-WebSocket-Key1'] ? 76 : 75
+            case version
+            when 75
+              if !remains.empty?
+                raise ::EventMachine::WebSocket::HandshakeError, "Extra bytes after header"
+              end
+            when 76
+              if remains.length < 8
+                # The whole third-key has not been received yet.
+                return nil
+              elsif remains.length > 8
+                raise ::EventMachine::WebSocket::HandshakeError, "Extra bytes after third key"
+              end
+              request['Third-Key'] = remains
+            else
+              raise ::EventMachine::WebSocket::WebSocketError, "Must not happen"
+            end
+
+            unless request['Connection'] == 'Upgrade' and request['Upgrade'] == 'WebSocket'
+              raise ::EventMachine::WebSocket::HandshakeError, "Connection and Upgrade headers required"
+            end
+
+            # transform headers
+            protocol = (secure ? "wss" : "ws")
+            request['Host'] = Addressable::URI.parse("#{protocol}://"+request['Host'])
+
+            if version = request['Sec-WebSocket-Draft']
+              if version == '1' || version == '2' || version == '3'
+                # We'll use handler03 - I believe they're all compatible
+                ::EventMachine::WebSocket::Handler03.new(connection, request, debug)
+              else
+                # According to spec should abort the connection
+                raise ::EventMachine::WebSocket::WebSocketError, "Unknown draft version: #{version}"
+              end
+            elsif request['Sec-WebSocket-Key1']
+              ::EventMachine::WebSocket::Handler76.new(connection, request, debug)
+            else
+              ::EventMachine::WebSocket::Handler75.new(connection, request, debug)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end