websocket-rack-noodles 0.4.0

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

@@ -0,0 +1,68 @@
+module Rack
+  module WebSocket
+    module Handler
+      class Base
+                
+        autoload :Connection, "#{ROOT_PATH}/websocket/handler/base/connection"
+
+        def on_open
+          set_env_instance_variable
+          @parent.on_open(@env)
+        end # Fired when a client is connected.
+
+        def on_message(msg)
+          set_env_instance_variable
+          @parent.on_message(@env, msg)
+        end # Fired when a message from a client is received.
+
+        def on_close
+          set_env_instance_variable
+          @parent.on_close(@env)
+        end # Fired when a client is disconnected.
+
+        def on_error(error)
+          set_env_instance_variable
+          @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
+
+        def set_env_instance_variable
+          @parent.instance_variable_set("@env", @env)
+        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
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,58 @@
+require 'thin'
+
+module Rack
+  module WebSocket
+    module Handler
+      class Thin < Base
+
+        # Build request from Rack env
+        def call(env)
+          @env = env
+          socket = env['async.connection']
+          request = request_from_env(env)
+          @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 @connection
+            @connection.send data
+          else
+            raise WebSocketError, "WebSocket not opened"
+          end
+        end
+
+        # Forward close_websocket to server
+        def 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_URI'].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.downcase.gsub('_','-')] ||= value
+            end
+          end
+          
+          request
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/websocket/handler.rb

@@ -0,0 +1,21 @@
+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)
+          Thin
+        else
+          Stub
+        end
+      end
+      
+    end
+  end
+end

data/lib/rack/websocket/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module WebSocket
+    VERSION = "0.4.0"
+  end
+end

data/lib/rack/websocket.rb

@@ -0,0 +1,14 @@
+require 'rack'
+require 'em-websocket'
+
+module Rack
+  module WebSocket
+    ROOT_PATH = ::File.expand_path(::File.dirname(__FILE__))
+
+    autoload :Application, "#{ROOT_PATH}/websocket/application"
+    autoload :Extensions,  "#{ROOT_PATH}/websocket/extensions"
+    autoload :Handler,    "#{ROOT_PATH}/websocket/handler"
+  end
+end
+
+Rack::WebSocket::Extensions.apply!

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'rspec'
+
+require 'rack/websocket'
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+class TestApp < Rack::WebSocket::Application
+end
+
+TEST_PORT = 8081
+
+def new_server_connection
+  TCPSocket.new('localhost', TEST_PORT)
+end

data/spec/support/all_drafts.rb

@@ -0,0 +1,44 @@
+require 'timeout'
+shared_examples_for 'all drafts' do
+  it "should accept incoming connection" do
+    conn = new_server_connection
+    conn.write(handshake_request)
+    timeout(1) { conn.read(handshake_response.length).should eql(handshake_response) }
+  end
+  it "should call 'on_open' on new connection" do
+    TestApp.any_instance.expects(:on_open)
+    conn = new_server_connection
+    conn.write(handshake_request)
+  end
+  it "should call 'on_open' on new connection with proper env" do
+    TestApp.any_instance.expects(:on_open).once.with { |env| env.class == Hash && !env.keys.empty? }
+    conn = new_server_connection
+    conn.write(handshake_request)
+  end
+  it "should call 'on_close' on connection close" do
+    TestApp.any_instance.expects(:on_close)
+    conn = new_server_connection
+    conn.write(handshake_request)
+    conn.close
+  end
+  it "should call 'on_close' on connection close with proper env" do
+    TestApp.any_instance.expects(:on_close).once.with { |env| env.class == Hash && !env.keys.empty? }
+    conn = new_server_connection
+    conn.write(handshake_request)
+    conn.close
+  end
+  it "should call 'on_message' on connection sending data" do
+    TestApp.any_instance.expects(:on_message)
+    conn = new_server_connection
+    conn.write(handshake_request)
+    timeout(1) { conn.read(handshake_response.length) }
+    conn.write(message)
+  end
+  it "should call 'on_message' on connection sending data with proper env and message" do
+    TestApp.any_instance.expects(:on_message).once.with { |env, message| env.class == Hash && !env.keys.empty? && message == 'Hello' }
+    conn = new_server_connection
+    conn.write(handshake_request)
+    timeout(1) { conn.read(handshake_response.length) }
+    conn.write(message)
+  end
+end

data/spec/support/all_handlers.rb

@@ -0,0 +1,80 @@
+shared_examples_for 'all handlers' do
+  it "should return flash policy file" do
+    conn = new_server_connection
+    conn.write(flash_policy_request)
+    conn.read(flash_policy_response.length).should eql(flash_policy_response)
+  end
+
+  context 'for draft75' do
+    let(:handshake_request)  { spec75_handshake_request }
+    let(:handshake_response) { spec75_handshake_response }
+    let(:message)            { spec75_message }
+
+    it_should_behave_like 'all drafts'
+  end
+
+  # Also draft00
+  context 'for draft76' do
+    let(:handshake_request)  { spec76_handshake_request }
+    let(:handshake_response) { spec76_handshake_response }
+    let(:message)            { spec76_message }
+
+    it_should_behave_like 'all drafts'
+  end
+
+  # Drafts 01, 02 and 03 are pretty the same so one test for all
+  context 'for draft03' do
+    let(:handshake_request)  { spec03_handshake_request }
+    let(:handshake_response) { spec03_handshake_response }
+    let(:message)            { spec03_message }
+
+    it_should_behave_like 'all drafts'
+  end
+
+  context 'for draft05' do
+    let(:handshake_request)  { spec05_handshake_request }
+    let(:handshake_response) { spec05_handshake_response }
+    let(:message)            { spec05_message }
+
+    it_should_behave_like 'all drafts'
+  end
+
+  context 'for draft06' do
+    let(:handshake_request)  { spec06_handshake_request }
+    let(:handshake_response) { spec06_handshake_response }
+    let(:message)            { spec06_message }
+
+    it_should_behave_like 'all drafts'
+  end
+
+  context 'for draft07' do
+    let(:handshake_request)  { spec07_handshake_request }
+    let(:handshake_response) { spec07_handshake_response }
+    let(:message)            { spec07_unmasked_message }
+    let(:masked_message)     { spec07_masked_message }
+
+    it_should_behave_like 'all drafts'
+    it_should_behave_like 'draft with masked messages'
+  end
+
+  context 'for draft08' do
+    let(:handshake_request)  { spec08_handshake_request }
+    let(:handshake_response) { spec08_handshake_response }
+    let(:message)            { spec08_unmasked_message }
+    let(:masked_message)     { spec08_masked_message }
+
+    it_should_behave_like 'all drafts'
+    it_should_behave_like 'draft with masked messages'
+  end
+
+  # Drafts 09, 10, 11, 12 and 13 are pretty the same so one test for all
+  context 'for draft13' do
+    let(:handshake_request)  { spec13_handshake_request }
+    let(:handshake_response) { spec13_handshake_response }
+    let(:message)            { spec13_unmasked_message }
+    let(:masked_message)     { spec13_masked_message }
+
+    it_should_behave_like 'all drafts'
+    it_should_behave_like 'draft with masked messages'
+  end
+end

data/spec/support/masked_messages.rb

@@ -0,0 +1,9 @@
+shared_examples_for 'draft with masked messages' do
+  it "should call 'on_message' on connection sending masked data with proper env and message" do
+    TestApp.any_instance.expects(:on_message).once.with { |env, message| env.class == Hash && !env.keys.empty? && message == 'Hello' }
+    conn = new_server_connection
+    conn.write(handshake_request)
+    timeout(1) { conn.read(handshake_response.length) }
+    conn.write(masked_message)
+  end
+end

data/spec/support/requests.rb

@@ -0,0 +1,249 @@
+def flash_policy_request
+  "<policy-file-request/>\000"
+end
+
+def flash_policy_response
+  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+end
+
+def spec75_handshake_request
+  <<-EOF
+GET /demo HTTP/1.1\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Host: localhost:#{TEST_PORT}\r
+Origin: http://localhost:#{TEST_PORT}\r
+\r
+EOF
+end
+
+def spec75_handshake_response
+  <<-EOF
+HTTP/1.1 101 Web Socket Protocol Handshake\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+WebSocket-Location: ws://localhost:#{TEST_PORT}/demo\r
+\r
+EOF
+end
+
+def spec75_message
+  "\x00Hello\xff"
+end
+
+def spec76_handshake_request
+  request = <<-EOF
+GET /demo HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Connection: Upgrade\r
+Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r
+Sec-WebSocket-Protocol: sample\r
+Upgrade: WebSocket\r
+Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r
+Origin: http://localhost:#{TEST_PORT}\r
+\r
+^n:ds[4U
+EOF
+  request.rstrip
+end
+
+def spec76_handshake_response
+  response = <<-EOF
+HTTP/1.1 101 WebSocket Protocol Handshake\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Location: ws://localhost:#{TEST_PORT}/demo\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: sample\r
+\r
+8jKS'y:G*Co,Wxa-
+EOF
+  response.rstrip
+end
+
+def spec76_message
+  "\x00Hello\xff"
+end
+
+def spec03_handshake_request
+  request = <<-EOF
+GET /demo HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Connection: Upgrade\r
+Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r
+Sec-WebSocket-Protocol: sample\r
+Upgrade: WebSocket\r
+Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r
+Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Draft: 3\r
+\r
+^n:ds[4U
+EOF
+  request.rstrip
+end
+
+def spec03_handshake_response
+  response = <<-EOF
+HTTP/1.1 101 WebSocket Protocol Handshake\r
+Upgrade: WebSocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Location: ws://localhost:#{TEST_PORT}/demo\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: sample\r
+\r
+8jKS'y:G*Co,Wxa-
+EOF
+  response.rstrip
+end
+
+def spec03_message
+  "\x04\x05Hello"
+end
+
+def spec05_handshake_request
+  <<-EOF
+GET /chat HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: chat, superchat\r
+Sec-WebSocket-Version: 5\r
+\r
+EOF
+end
+
+def spec05_handshake_response
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+EOF
+end
+
+def spec05_message
+  "\x00\x00\x01\x00\x84\x05Ielln"
+end
+
+def spec06_handshake_request
+  <<-EOF
+GET /chat HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: chat, superchat\r
+Sec-WebSocket-Version: 6\r
+\r
+EOF
+end
+
+def spec06_handshake_response
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+EOF
+end
+
+def spec06_message
+  "\x00\x00\x01\x00\x84\x05Ielln"
+end
+
+def spec07_handshake_request
+  <<-EOF
+GET /chat HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: chat, superchat\r
+Sec-WebSocket-Version: 7\r
+\r
+EOF
+end
+
+def spec07_handshake_response
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+EOF
+end
+
+def spec07_unmasked_message
+  "\x81\x05\x48\x65\x6c\x6c\x6f"
+end
+
+def spec07_masked_message
+  "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58"
+end
+
+def spec08_handshake_request
+  <<-EOF
+GET /chat HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Sec-WebSocket-Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: chat, superchat\r
+Sec-WebSocket-Version: 8\r
+\r
+EOF
+end
+
+def spec08_handshake_response
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+EOF
+end
+
+def spec08_unmasked_message
+  "\x81\x05\x48\x65\x6c\x6c\x6f"
+end
+
+def spec08_masked_message
+  "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58"
+end
+
+def spec13_handshake_request
+  <<-EOF
+GET /chat HTTP/1.1\r
+Host: localhost:#{TEST_PORT}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Origin: http://localhost:#{TEST_PORT}\r
+Sec-WebSocket-Protocol: chat, superchat\r
+Sec-WebSocket-Version: 13\r
+\r
+EOF
+end
+
+def spec13_handshake_response
+  <<-EOF
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+EOF
+end
+
+def spec13_unmasked_message
+  "\x81\x05\x48\x65\x6c\x6c\x6f"
+end
+
+def spec13_masked_message
+  "\x81\x85\x37\xfa\x21\x3d\x7f\x9f\x4d\x51\x58"
+end

data/spec/thin_spec.rb

@@ -0,0 +1,48 @@
+require 'thin'
+require 'spec_helper'
+
+describe 'Thin handler' do
+  let(:app) { TestApp.new }
+  
+  before(:all) { silent_thin }
+  before { start_thin_server(app) }
+  after  { stop_thin_server }
+  
+  it "should include extensions" do
+    ::Thin::Connection.include?(::Rack::WebSocket::Extensions::Common).should be_true
+    ::Thin::Connection.include?(::Rack::WebSocket::Extensions::Thin::Connection).should be_true
+  end
+  
+  it_should_behave_like 'all handlers'
+end
+
+def start_thin_server(app, options = {})
+  @server = Thin::Server.new('0.0.0.0', TEST_PORT, options, app)
+  @server.ssl = options[:ssl]
+  # @server.threaded = options[:threaded]
+  # @server.timeout = 3
+
+  @thread = Thread.new { @server.start }
+  sleep 1 until @server.running?
+end
+
+def stop_thin_server
+  sleep 0.1
+  @server.stop!
+  sleep 0.1
+  @thread.kill
+  sleep 0.1
+  raise "Reactor still running, wtf?" if EventMachine.reactor_running?
+end
+
+def silent_thin
+  ::Thin::Logging.silent = true
+  if EM::VERSION < "1.0.0"
+    begin
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      ::Thin::Server.const_set 'DEFAULT_TIMEOUT', 0
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/websocket-rack.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack/websocket/version"
+
+Gem::Specification.new do |s|
+  s.name        = "websocket-rack-noodles"
+  s.version     = Rack::WebSocket::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernard Potocki"]
+  s.email       = ["bernard.potocki@imanel.org"]
+  s.homepage    = "http://github.com/DamirSvrtan/websocket-rack"
+  s.summary     = %q{Rack-based WebSocket server for Noodles Web Framework}
+  s.description = %q{Rack-based WebSocket server for Noodles Web Framework. An fork from http://github.com/imanel/websocket-rack}
+
+  s.add_dependency 'rack'
+  s.add_dependency 'em-websocket', '~> 0.3.8'
+  s.add_dependency 'eventmachine', '~> 1.0.0'
+  s.add_dependency 'thin' # Temporary until we support more servers
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end