websocket-rack 0.2.1 → 0.3.0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.0 / 2011-05-10
+
+- support for WebSocket drafts 05 and 06
+- fix tests in Ruby 1.9.2
+- better documentation
+
 ## 0.2.1 / 2011-04-01
 
 - bugfix: env passed to callbacks should be valid now

data/example/example.ru

@@ -1,4 +1,4 @@
-require 'lib/rack/websocket'
+require './lib/rack/websocket'
 
 class MyApp < Rack::WebSocket::Application
   def on_open(env)

data/lib/rack/websocket/application.rb

@@ -1,31 +1,36 @@
 module Rack
   module WebSocket
     class Application
-      
+
       DEFAULT_OPTIONS = {}
-      
+
       class << self
         attr_accessor :websocket_handler
       end
-      
+
+      # Standard WebSocket calls
       def on_open(env); end
       def on_message(env, msg); end
       def on_close(env); end
       def on_error(env, error); end
-      
+
+      # Initializer
       def initialize(options = {})
         @options = DEFAULT_OPTIONS.merge(options)
       end
-      
+
+      # Detect handler and duplicate it's instance
       def call(env)
         detect_handler(env)
         dup._call(env)
       end
-      
+
+      # Forward call to duplicated handler
       def _call(env)
         websocket_handler.call(env)
       end
-      
+
+      # Forward all missing methods to handler
       def method_missing(sym, *args, &block)
         if websocket_handler && websocket_handler.respond_to?(sym)
           websocket_handler.send sym, *args, &block
@@ -33,13 +38,15 @@ module Rack
           super
         end
       end
-      
+
       private
-      
+
+      # Detect handler
       def detect_handler(env)
         self.class.websocket_handler ||= Handler.detect(env)
       end
-      
+
+      # Create and cache handler for current server
       def websocket_handler
         @websocket_handler ||= self.class.websocket_handler.new(self, @options || {})
       end

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

@@ -18,10 +18,13 @@ module Rack
 
         attr_accessor :websocket
 
+        # Is this connection WebSocket?
         def websocket?
           !self.websocket.nil?
         end
 
+        # Skip default receive_data if this is
+        # WebSocket connection
         def receive_data_with_websocket(data)
           if self.websocket?
             self.websocket.receive_data(data)
@@ -30,6 +33,8 @@ module Rack
           end
         end
 
+        # Skip standard unbind it this is
+        # WebSocket connection
         def unbind_with_websocket
           if self.websocket?
             self.websocket.unbind
@@ -38,6 +43,7 @@ module Rack
           end
         end
 
+        # Send flash policy file if requested
         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

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

@@ -11,6 +11,7 @@ module Rack
             end
           end
 
+          # Set 'async.connection' Rack env
           def pre_process_with_websocket
             @request.env['async.connection'] = self
             pre_process_without_websocket

data/lib/rack/websocket/handler.rb

@@ -1,11 +1,12 @@
 module Rack
   module WebSocket
     module Handler
-      
+
       autoload :Base, "#{ROOT_PATH}/websocket/handler/base"
       autoload :Stub, "#{ROOT_PATH}/websocket/handler/stub"
       autoload :Thin, "#{ROOT_PATH}/websocket/handler/thin"
-      
+
+      # Detect current server using software Rack string
       def self.detect(env)
         server_software = env['SERVER_SOFTWARE']
         if server_software.match(/\Athin /i)

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

@@ -3,34 +3,42 @@ module Rack
     module Handler
       class Base
                 
+        autoload :Connection,     "#{ROOT_PATH}/websocket/handler/base/connection"
+
         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.
 
+        # Set application as parent and forward options
         def initialize(parent, options = {})
           @parent = parent
           @options = options[:backend] || {}
         end
 
+        # Implemented in subclass
         def call(env)
           raise 'Not implemented'
         end
 
+        # Implemented in subclass
         def send_data(data)
           raise 'Not implemented'
         end
 
+        # Implemented in subclass
         def close_websocket
           raise 'Not implemented'
         end
 
         protected
 
+        # Standard async response
         def async_response
           [-1, {}, []]
         end
 
+        # Standard 400 response
         def failure_response
           [ 400, {'Content-Type' => 'text/plain'}, [ 'Bad request' ] ]
         end

data/lib/rack/websocket/handler/{thin → base}/connection.rb

@@ -3,29 +3,47 @@ require 'addressable/uri'
 module Rack
   module WebSocket
     module Handler
-      class Thin
+      class Base
         class Connection < ::EventMachine::WebSocket::Connection
 
+          #########################
+          ### EventMachine part ###
+          #########################
+
           # Overwrite new from EventMachine
+          # we need to skip standard procedure called
+          # when socket is created - this is just a stub
           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
+          # Overwrite send_data from EventMachine
+          # delegate send_data to rack server
+          def send_data(*args)
+            @socket.send_data(*args)
           end
-          def trigger_on_error(error)
-            @app.on_error(error)
+
+          # Overwrite close_connection from EventMachine
+          # delegate close_connection to rack server
+          def close_connection(*args)
+            @socket.close_connection(*args)
           end
 
+          #########################
+          ### EM-WebSocket part ###
+          #########################
+
+          # Overwrite triggers from em-websocket
+          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); true; end
+
+          # Overwrite initialize from em-websocket
+          # set all standard options and disable
+          # EM connection inactivity timeout
           def initialize(app, socket, options = {})
             @app = app
             @socket = socket
@@ -45,41 +63,19 @@ module Rack
             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)
+          # Overwrite dispath from em-websocket
+          # we already have request headers parsed so
+          # we can skip it and call build_with_request
+          def dispatch(data)
+            return false if data.nil?
+            debug [:inbound_headers, data]
+            @handler = EventMachine::WebSocket::HandlerFactory.build_with_request(self, data, data['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

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

@@ -3,6 +3,7 @@ module Rack
     module Handler
       class Stub < Base
 
+        # Always close socket
         def call(env)
           raise 'Unknown handler!'
           close_websocket

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

@@ -5,50 +5,47 @@ module Rack
     module Handler
       class Thin < Base
 
-        autoload :Connection,     "#{ROOT_PATH}/websocket/handler/thin/connection"
-        autoload :HandlerFactory, "#{ROOT_PATH}/websocket/handler/thin/handler_factory"
-
+        # Build request from Rack env
         def call(env)
           @env = env
           socket = env['async.connection']
           request = request_from_env(env)
-          @conn = Connection.new(self, socket, :debug => @options[:debug])
-          @conn.dispatch(request) ? async_response : failure_response
+          @connection = Connection.new(self, socket, :debug => @options[:debug])
+          @connection.dispatch(request) ? async_response : failure_response
         end
 
+        # Forward send_data to server
         def send_data(data)
-          if @conn
-            @conn.send data
+          if @connection
+            @connection.send data
           else
             raise WebSocketError, "WebSocket not opened"
           end
         end
 
+        # Forward close_websocket to server
         def close_websocket
-          if @conn
-            @conn.close_websocket
+          if @connection
+            @connection.close_websocket
           else
             raise WebSocketError, "WebSocket not opened"
           end
         end
-        
+
         private
-        
+
+        # Parse Rack env to em-websocket-compatible format
+        # this probably should be moved to Base in future
         def request_from_env(env)
           request = {}
-          request['Path']   = env['REQUEST_PATH'].to_s
-          request['Method'] = env['REQUEST_METHOD']
-          request['Query']  = env['QUERY_STRING'].to_s
-          request['body']   = env['rack.input'].read
-          
-          request['Sec-WebSocket-Draft']    = env['HTTP_SEC_WEBSOCKET_DRAFT']
-          request['Sec-WebSocket-Key1']     = env['HTTP_SEC_WEBSOCKET_KEY1']
-          request['Sec-WebSocket-Key2']     = env['HTTP_SEC_WEBSOCKET_KEY2']
-          request['Sec-WebSocket-Protocol'] = env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+          request['path']   = env['REQUEST_PATH'].to_s
+          request['method'] = env['REQUEST_METHOD']
+          request['query']  = env['QUERY_STRING'].to_s
+          request['Body']   = env['rack.input'].read
           
           env.each do |key, value|
             if key.match(/HTTP_(.+)/)
-              request[$1.capitalize.gsub('_','-')] ||= value
+              request[$1.downcase.gsub('_','-')] ||= value
             end
           end
           

data/lib/rack/websocket/version.rb

@@ -1,5 +1,5 @@
 module Rack
   module WebSocket
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/spec/thin_spec.rb

@@ -30,6 +30,7 @@ def stop_thin_server
   sleep 0.1
   @server.stop!
   @thread.kill
+  sleep 0.1
   raise "Reactor still running, wtf?" if EventMachine.reactor_running?
 end
 

data/websocket-rack.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.description = %q{Rack-based WebSocket server}
 
   s.add_dependency 'rack'
-  s.add_dependency 'em-websocket', '~> 0.2.1'
+  s.add_dependency 'em-websocket', '~> 0.3.0'
   s.add_dependency 'thin' # Temporary until we support more servers
   s.add_development_dependency 'rspec', '~> 2.4.0'
   s.add_development_dependency 'mocha'

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: websocket-rack
 version: !ruby/object:Gem::Version 
-  hash: 21
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Bernard Potocki
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-01 00:00:00 +02:00
+date: 2011-05-10 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,9 +21,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
@@ -40,12 +32,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 0
-        - 2
-        - 1
-        version: 0.2.1
+        version: 0.3.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,9 +43,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id003
@@ -70,11 +54,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 2
-        - 4
-        - 0
         version: 2.4.0
   type: :development
   version_requirements: *id004
@@ -86,9 +65,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id005
@@ -122,10 +98,9 @@ files:
 - lib/rack/websocket/extensions/thin/connection.rb
 - lib/rack/websocket/handler.rb
 - lib/rack/websocket/handler/base.rb
+- lib/rack/websocket/handler/base/connection.rb
 - lib/rack/websocket/handler/stub.rb
 - lib/rack/websocket/handler/thin.rb
-- lib/rack/websocket/handler/thin/connection.rb
-- lib/rack/websocket/handler/thin/handler_factory.rb
 - lib/rack/websocket/version.rb
 - spec/spec_helper.rb
 - spec/support/all_drafts.rb
@@ -147,23 +122,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: Rack-based WebSocket server

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

@@ -1,56 +0,0 @@
-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