faye 0.3.4 → 0.5.0

data/lib/thin_extensions.rb

@@ -0,0 +1,86 @@
+# WebSocket extensions for Thin
+# Taken from the Cramp project
+# http://github.com/lifo/cramp
+
+# Copyright (c) 2009-2010 Pratik Naik
+# 
+# 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.
+
+class Thin::Connection
+  def receive_data(data)
+    trace { data }
+
+    case @serving
+    when :websocket
+      callback = @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK]
+      callback.call(data) if callback
+    else
+      if @request.parse(data)
+        if @request.websocket?
+          @response.persistent!
+          @response.websocket_upgrade_data = @request.websocket_upgrade_data
+          @serving = :websocket
+        end
+
+        process
+      end
+    end
+  rescue Thin::InvalidRequest => e
+    log "!! Invalid request"
+    log_error e
+    close_connection
+  end
+end
+
+class Thin::Request
+  WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
+
+  def websocket?
+    @env['HTTP_CONNECTION'] == 'Upgrade' && @env['HTTP_UPGRADE'] == 'WebSocket'
+  end
+
+  def websocket_url
+    @env['websocket.url'] = "ws://#{@env['HTTP_HOST']}#{@env['REQUEST_PATH']}"
+  end
+
+  def websocket_upgrade_data
+    upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+    upgrade << "Upgrade: WebSocket\r\n"
+    upgrade << "Connection: Upgrade\r\n"
+    upgrade << "WebSocket-Origin: #{@env['HTTP_ORIGIN']}\r\n"
+    upgrade << "WebSocket-Location: #{websocket_url}\r\n\r\n"
+    upgrade
+  end
+end
+
+class Thin::Response
+  # Headers for sending Websocket upgrade
+  attr_accessor :websocket_upgrade_data
+
+  def each
+    websocket_upgrade_data ? yield(websocket_upgrade_data) : yield(head)
+    if @body.is_a?(String)
+      yield @body
+    else
+      @body.each { |chunk| yield chunk }
+    end
+  end
+end
+

data/test/scenario.rb

@@ -59,18 +59,28 @@ module Scenario
     def initialize
       @clients = {}
       @inbox   = {}
+      @errors  = {}
       @pool    = 0
     end
+    
+    def wait(time, &block)
+      EM.add_timer(time, &block)
+    end
   
     def check_inbox(expected_inbox, &block)
       assert_equal expected_inbox, @inbox
-      block.call
+      EM.next_tick(&block)
+    end
+    
+    def check_errors(name, expected_errors, &block)
+      assert_equal expected_errors, @errors[name]
+      EM.next_tick(&block)
     end
     
     def server(port, &block)
-      @endpoint = "http://0.0.0.0:#{port}/comet"
-      @comet = Faye::RackAdapter.new(:mount => '/comet', :timeout => 30)
-      Rack::Handler.get('thin').run(@comet, :Port => port) do |server|
+      @endpoint = "http://0.0.0.0:#{port}/bayeux"
+      @bayeux = Faye::RackAdapter.new(:mount => '/bayeux', :timeout => 30)
+      Rack::Handler.get('thin').run(@bayeux, :Port => port) do |server|
         @server = server
         EM.next_tick(&block)
       end
@@ -81,25 +91,69 @@ module Scenario
     end
     
     def local_client(name, channels, &block)
-      setup_client(@comet.get_client, name, channels, &block)
+      setup_client(@bayeux.get_client, name, channels, &block)
     end
     
-    def setup_client(client, name, channels, &block)
-      channels.each do |channel|
-        client.subscribe(channel) do |message|
-          box = @inbox[name]
-          box[channel] ||= []
-          box[channel] << message
-        end
+    def extend_server(stage, extension, &block)
+      object = Object.new
+      def object.added
+        @active = true
+      end
+      (class << object; self; end).send(:define_method, stage) do |*args|
+        extension.call(*args) if @active
       end
+      @bayeux.add_extension(object)
+      block.call
+    end
+    
+    def extend_client(name, stage, extension, &block)
+      object = Object.new
+      (class << object; self; end).send(:define_method, stage, &extension)
+      @clients[name].add_extension(object)
+      block.call
+    end
+    
+    def listen_for_errors(name, &block)
+      @errors[name] = []
+      errors = @errors
+      
+      extend_client(name, :incoming, lambda { |message, callback|
+        if message['successful'] == false
+          errors[name] << message['error']
+        end
+        callback.call(message)
+      }, &block)
+    end
+    
+    def setup_client(client, name, channels, &block)
       @clients[name] = client
       @inbox[name]   = {}
       @pool         += 1
+      
+      channels.each { |channel| subscribe(name, channel) }
       EM.add_timer(0.5 * channels.size, &block)
     end
     
-    def publish(from, channel, message, &block)
-      @clients[from].publish(channel, message)
+    def subscribe(name, channel, &block)
+      client = @clients[name]
+      
+      @last_sub = client.subscribe(channel) do |message|
+        box = @inbox[name]
+        box[channel] ||= []
+        box[channel] << message
+      end
+      
+      EM.add_timer(0.5, &block)
+    end
+    
+    def cancel_last_subscription(&block)
+      @last_sub.cancel
+      EM.add_timer(0.5, &block)
+    end
+    
+    def publish(from, channel, messages, &block)
+      messages = [messages].flatten
+      messages.each { |msg| @clients[from].publish(channel, msg) }
       EM.add_timer(2, &block)
     end
     

data/test/test_clients.rb

@@ -6,6 +6,157 @@ class TestClients < Test::Unit::TestCase
   include Faye
   include Scenario
   
+  scenario "Client modifies incoming messages" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, ['/channels/b']
+    
+    extend_client :A, :incoming, lambda { |message, callback|
+      if message['data']
+        message['data']['modified'] = 'hi'
+      end
+      callback.call(message)
+    }
+    
+    publish :B, '/channels/a', 'welcome' => 'message'
+    check_inbox(
+        :A => {
+          '/channels/a' => ['welcome' => 'message', 'modified' => 'hi']
+        },
+        :B => {}
+    )
+  end
+  
+  scenario "Client blocks incoming messages" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, ['/channels/b']
+    
+    extend_client :A, :incoming, lambda { |message, callback|
+      callback.call(nil)
+    }
+    
+    publish :B, '/channels/a', 'welcome' => 'message'
+    check_inbox( :A => {}, :B => {} )
+  end
+  
+  scenario "Server requires authentication" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, ['/channels/b']
+    
+    extend_server :incoming, lambda { |message, callback|
+      if message['ext'] and message['ext']['password']
+        callback.call(message)
+      end
+    }
+    
+    extend_client :B, :outgoing, lambda { |message, callback|
+      message['ext'] = {'password' => true}
+      callback.call(message)
+    }
+    
+    publish :A, '/channels/b', 'message_for' => 'B'
+    check_inbox( :A => {}, :B => {} )
+    
+    publish :B, '/channels/a', 'message_for' => 'A'
+    check_inbox(
+        :A => {
+          '/channels/a' => ['message_for' => 'A']
+        },
+        :B => {}
+    )
+  end
+  
+  scenario "Server blocks a message by setting an error" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, ['/channels/b']
+    
+    extend_server :incoming, lambda { |message, callback|
+      if message['data']
+        message['error'] = Faye::Error.ext_mismatch
+      end
+      callback.call(message)
+    }
+    
+    listen_for_errors :A
+    
+    publish :A, '/channels/b', 'message_for' => 'B'
+    check_inbox( :A => {}, :B => {} )
+    check_errors :A, ['302::Extension mismatch']
+  end
+  
+  scenario "Server modifies outgoing message" do
+    server 8000
+    http_client :A, []
+    http_client :B, ['/channels/b']
+    
+    extend_server :outgoing, lambda { |message, callback|
+      message['data']['addition'] = 56 if message['data']
+      callback.call(message)
+    }
+    
+    publish :A, '/channels/b', 'message_for' => 'B'
+    check_inbox(
+        :A => {},
+        :B => {
+          '/channels/b' => ['message_for' => 'B', 'addition' => 56]
+        }
+    )
+  end
+  
+  [:incoming, :outgoing].each do |direction|
+    scenario "Server delays #{ direction } message" do
+      server 8000
+      http_client :A, []
+      http_client :B, ['/channels/b']
+      
+      extend_server direction, lambda { |message, callback|
+        timeout = message['data'] ? 5 : 0
+        EM.add_timer(timeout) { callback.call(message) }
+      }
+      
+      publish :A, '/channels/b', 'message_for' => 'B'
+      check_inbox( :A => {}, :B => {} )
+      
+      wait 3
+      check_inbox( :A => {}, :B => {} )
+      
+      wait 1
+      
+      check_inbox(
+          :A => {},
+          :B => {
+            '/channels/b' => ['message_for' => 'B']
+          }
+      )
+    end
+  end
+  
+  scenario "Server blocks outgoing message" do
+    server 8000
+    http_client :A, []
+    http_client :B, ['/channels/b']
+    
+    extend_server :outgoing, lambda { |message, callback|
+      if !message['data'] or message['data']['deliver'] == 'yes'
+        callback.call(message)
+      else
+        callback.call(nil)
+      end
+    }
+    
+    publish :A, '/channels/b', [{'deliver' => 'no'}, {'deliver' => 'yes'}]
+    
+    check_inbox(
+        :A => {},
+        :B => {
+          '/channels/b' => ['deliver' => 'yes']
+        }
+    )
+  end
+  
   scenario "Two HTTP clients, no messages delivered" do
     server 8000
     http_client :A, ['/channels/a']
@@ -29,6 +180,40 @@ class TestClients < Test::Unit::TestCase
         :B => {}
     )
   end
+  
+  scenario "Two HTTP clients, two identical messages sent together" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, []
+    publish :B, '/channels/a', [{'hello' => 'world'}, {'hello' => 'world'}]
+    check_inbox(
+        :A => {
+          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
+        },
+        :B => {}
+    )
+  end
+  
+  scenario "Two HTTP clients, two message deliveries" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, []
+    publish :B, '/channels/a', 'hello' => 'world'
+    check_inbox(
+        :A => {
+          '/channels/a' => ['hello' => 'world']
+        },
+        :B => {}
+    )
+    wait 1
+    publish :B, '/channels/a', 'hello' => 'world'
+    check_inbox(
+        :A => {
+          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
+        },
+        :B => {}
+    )
+  end
 
   scenario "Two HTTP clients, multiple subscriptions" do
     server 8000
@@ -44,6 +229,35 @@ class TestClients < Test::Unit::TestCase
     )
   end
 
+  scenario "Two HTTP clients, two subscriptions on the same channel" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, []
+    subscribe :A, '/channels/a'
+    publish :B, '/channels/a', 'hello' => 'world'
+    check_inbox(
+        :A => {
+          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
+        },
+        :B => {}
+    )
+  end
+
+  scenario "Two HTTP clients, two subscriptions and one unsubscription" do
+    server 8000
+    http_client :A, ['/channels/a']
+    http_client :B, []
+    subscribe :A, '/channels/a'
+    cancel_last_subscription
+    publish :B, '/channels/a', 'another' => 'message'
+    check_inbox(
+        :A => {
+          '/channels/a' => [{'another' => 'message'}]
+        },
+        :B => {}
+    )
+  end
+
   scenario "Three HTTP clients, single receiver" do
     server 8000
     http_client :A, ['/channels/a']
@@ -145,8 +359,7 @@ class TestClients < Test::Unit::TestCase
         :B => {},
         :C => {
           '/channels/name' => ['msg' => 'hey'],
-          '/channels/foo/**' => ['msg' => 'hey'],
-          '/channels/name' => ['msg' => 'hey'],
+          '/channels/foo/**' => ['msg' => 'hey']
         }
     )
   end

data/test/test_server.rb

@@ -30,7 +30,7 @@ class TestServer < Test::Unit::TestCase
     # MUST
     assert_equal  '/meta/handshake',                  @r['channel']
     assert_not_equal  nil,                            @r['version']
-    assert_equal  %w[long-polling callback-polling],  @r['supportedConnectionTypes']
+    assert_equal  %w[long-polling callback-polling websocket], @r['supportedConnectionTypes']
     assert_match( /[a-z0-9]+/,                        @r['clientId'] )
     assert_equal  true,                               @r['successful']
     # MAY
@@ -62,7 +62,7 @@ class TestServer < Test::Unit::TestCase
     assert_equal  '402:version:Missing required parameter', @r['error']
     # MAY
     assert_not_equal  nil,                            @r['version']
-    assert_equal  %w[long-polling callback-polling],  @r['supportedConnectionTypes']
+    assert_equal  %w[long-polling callback-polling websocket], @r['supportedConnectionTypes']
     # MAY include advice, minimumVersion, ext, id
     
     #================================================================
@@ -73,7 +73,7 @@ class TestServer < Test::Unit::TestCase
     assert_equal  false,                  @r['successful']
     assert_equal  '301:iframe,flash:Connection types not supported', @r['error']
     # MAY
-    assert_equal  %w[long-polling callback-polling],  @r['supportedConnectionTypes']
+    assert_equal  %w[long-polling callback-polling websocket], @r['supportedConnectionTypes']
     assert_equal  nil,                    @r['id']
     
     #================================================================
@@ -84,7 +84,7 @@ class TestServer < Test::Unit::TestCase
     assert_equal  false,                  @r['successful']
     assert_equal  '402:supportedConnectionTypes:Missing required parameter', @r['error']
     # MAY
-    assert_equal  %w[long-polling callback-polling],  @r['supportedConnectionTypes']
+    assert_equal  %w[long-polling callback-polling websocket], @r['supportedConnectionTypes']
     assert_equal  'foo',                  @r['id']
     
     #================================================================
@@ -448,16 +448,16 @@ class TestServer < Test::Unit::TestCase
   
   def test_advice
     @server.send :handle, 'channel' => '/meta/subscribe', 'subscription' => '/foo', 'clientId' => 'fake' do |r|
-      assert_equal  '401:fake:Unknown client', r['error']
-      assert_equal  'handshake',      r['advice']['reconnect']
-      assert_equal  1000,             r['advice']['interval']
+      assert_equal  '401:fake:Unknown client', r.first['error']
+      assert_equal  'handshake',      r.first['advice']['reconnect']
     end
     
     id = get_client_id
     @server.send :handle, 'channel' => '/meta/subscribe', 'subscription' => '/foo', 'clientId' => id do |r|
-      assert_equal  true,             r['successful']
-      assert_equal  'retry',          r['advice']['reconnect']
-      assert_equal  1000,             r['advice']['interval']
+      assert_equal  true,             r.first['successful']
+      assert_equal  'retry',          r.first['advice']['reconnect']
+      assert_equal  0,                r.first['advice']['interval']
+      assert_equal  60000,            r.first['advice']['timeout']
     end
   end
 end