faye 0.3.1 → 0.3.2

data/lib/faye/timeouts.rb

@@ -0,0 +1,21 @@
+module Faye
+  module Timeouts
+    def add_timeout(name, delay, &block)
+      @timeouts ||= {}
+      return if @timeouts.has_key?(name)
+      @timeouts[name] = EventMachine.add_timer(delay) do
+        @timeouts.delete(name)
+        block.call
+      end
+    end
+    
+    def remove_timeout(name)
+      @timeouts ||= {}
+      timeout = @timeouts[name]
+      return if timeout.nil?
+      EventMachine.cancel_timer(timeout)
+      @timeouts.delete(name)
+    end
+  end
+end
+

data/lib/faye/transport.rb

@@ -1,5 +1,6 @@
 require 'em-http'
 require 'json'
+require 'uri'
 
 module Faye
   
@@ -20,10 +21,11 @@ module Faye
       
       request(message) { |responses|
         if block_given?
+          messages, deliverable = [], true
           [responses].flatten.each do |response|
             
             if message.is_a?(Hash) and response['id'] == message['id']
-              block.call(response) 
+              deliverable = false if block.call(response) == false
             end
             
             if response['advice']
@@ -31,10 +33,12 @@ module Faye
             end
             
             if response['data'] and response['channel']
-              @client.send_to_subscribers(response)
+              messages << response
             end
             
           end
+          
+          @client.deliver_messages(messages) if deliverable
         end
       }
     end
@@ -77,8 +81,17 @@ module Faye
     end
     
     def request(message, &block)
-      params  = {:message => JSON.unparse(message)}
-      request = EventMachine::HttpRequest.new(@endpoint).post(:body => params, :timeout => -1)
+      content = JSON.unparse(message)
+      params = {
+        :head => {
+          'Content-Type'    => 'application/json',
+          'host'            => URI.parse(@endpoint).host,
+          'Content-Length'  => content.length
+        },
+        :body    => content,
+        :timeout => -1
+      }
+      request = EventMachine::HttpRequest.new(@endpoint).post(params)
       request.callback do
         block.call(JSON.parse(request.response))
       end

data/test/scenario.js

@@ -4,42 +4,46 @@ var sys    = require('sys'),
     assert = require('assert'),
     faye   = require('../build/faye');
 
-Scenario = Faye.Class({
-  initialize: function(name, block) {
+Faye.Logging.logLevel = 'info';
+
+AsyncScenario = Faye.Class({
+  initialize: function(name) {
     this._name    = name;
-    this._block   = block;
     this._clients = {};
     this._inbox   = {};
     this._pool    = 0;
   },
   
-  run: function() {
-    sys.puts('\n' + this._name);
-    sys.puts('----------------------------------------------------------------');
-    this._block.call(this);
+  wait: function(time, Continue) {
+    setTimeout(Continue, 1000 * time);
   },
   
-  server: function(port) {
-    sys.puts('Starting server on port ' + port);
+  server: function(port, Continue) {
     this._endpoint = 'http://0.0.0.0:' + port + '/comet';
     var comet = this._comet  = new faye.NodeAdapter({mount: '/comet', timeout: 30});
     this._server = http.createServer(function(request, response) {
       comet.call(request, response);
     });
     this._server.listen(port);
+    Continue();
+  },
+  
+  killServer: function(Continue) {
+    if (this._server) this._server.close();
+    this._server = undefined;
+    setTimeout(Continue, 500);
   },
   
-  httpClient: function(name, channels) {
-    this._setupClient(new faye.Client(this._endpoint), name, channels);
+  httpClient: function(name, channels, Continue) {
+    this._setupClient(new faye.Client(this._endpoint, {timeout: 5}), name, channels, Continue);
   },
   
-  localClient: function(name, channels) {
-    this._setupClient(this._comet.getClient(), name, channels);
+  localClient: function(name, channels, Continue) {
+    this._setupClient(this._comet.getClient(), name, channels, Continue);
   },
   
-  _setupClient: function(client, name, channels) {
+  _setupClient: function(client, name, channels, Continue) {
     Faye.each(channels, function(channel) {
-      sys.puts('Client ' + name + ' subscribing to ' + channel);
       client.subscribe(channel, function(message) {
         var box = this._inbox[name];
         box[channel] = box[channel] || [];
@@ -49,35 +53,67 @@ Scenario = Faye.Class({
     this._clients[name] = client;
     this._inbox[name]   = {};
     this._pool         += 1;
+    setTimeout(Continue, 500 * channels.length);
   },
   
-  send: function(from, channel, message) {
-    var self = this;
-    setTimeout(function() {
-      var displayMessage = JSON.stringify(message);
-      sys.puts('Client ' + from + ' publishing ' + displayMessage + ' to ' + channel);
-      self._clients[from].publish(channel, message);
-    }, 500);
+  publish: function(from, channel, message, Continue) {
+    this._clients[from].publish(channel, message);
+    setTimeout(Continue, 500);
   },
   
-  checkInbox: function(expectedInbox) {
-    var self = this;
-    setTimeout(function() {
-      self._checkInbox(expectedInbox);
-      sys.puts('Shutting down server\n');
-      Faye.each(this._clients, function(name, client) { client.disconnect() });
-      self._server.close();
-      Scenario.runNext();
-    }, 1000);
+  checkInbox: function(expectedInbox, Continue) {
+    assert.deepEqual(this._inbox, expectedInbox);
+    Continue();
   },
   
-  _checkInbox: function(expectedInbox) {
-    sys.puts(JSON.stringify(this._inbox));
-    assert.deepEqual(this._inbox, expectedInbox);
+  finish: function(Continue) {
+    Faye.each(this._clients, function(name, client) { client.disconnect() });
+    this._server.close();
+    Continue();
+  },
+});
+
+SyncScenario = Faye.Class({
+  initialize: function(name, block) {
+    this._name = name;
+    this._commands = [];
+    this._scenario = new AsyncScenario();
+    block.call(this);
+  },
+  
+  run: function() {
+    sys.puts('\n' + this._name);
+    sys.puts('----------------------------------------------------------------');
+    this._runNextCommand();
+  },
+  
+  _runNextCommand: function() {
+    if (this._commands.length === 0) return this._finish();
+    
+    var command = this._commands.shift(),
+        method  = command[0],
+        args    = Array.prototype.slice.call(command[1]),
+        self = this;
+    
+    this._scenario[method].apply(this._scenario, args.concat(function() {
+      self._runNextCommand();
+    }));
+  },
+  
+  _finish: function() {
+    sys.puts('No errors; Shutting down server\n');
+    this._scenario.finish(function() { SyncScenario.runNext() });
+  }
+});
+
+['wait', 'server', 'killServer', 'httpClient', 'localClient', 'publish', 'checkInbox'].
+forEach(function(method) {
+  SyncScenario.prototype[method] = function() {
+    this._commands.push([method, arguments]);
   }
 });
 
-Faye.extend(Scenario, {
+Faye.extend(SyncScenario, {
   _queue: [],
   
   enqueue: function(name, block) {
@@ -93,7 +129,7 @@ Faye.extend(Scenario, {
 });
 
 exports.run = function(name, block) {
-  Scenario.enqueue(name, block);
-  if (!Scenario.running) Scenario.runNext();
+  SyncScenario.enqueue(name, block);
+  if (!SyncScenario.running) SyncScenario.runNext();
 };
 

data/test/scenario.rb

@@ -0,0 +1,104 @@
+$VERBOSE = false
+
+module Scenario
+  module ClassMethods
+    def scenario(name, &block)
+      define_method("test: #{name}", &block)
+    end
+  end
+  
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  def setup
+    Thread.new { EM.run }
+    while not EM.reactor_running?; end
+    @scenario = AsyncScenario.new
+    @commands = []
+    @started = false
+  end
+  
+  def teardown
+    while EM.reactor_running?; end
+  end
+  
+  def run(runner)
+    @runner = runner
+    super
+  end
+  
+  def method_missing(sym, *args)
+    @commands << [sym, args]
+    EM.next_tick { run_next_command unless @started }
+  end
+  
+  def run_next_command
+    @started = true
+    command = @commands.shift
+    return EM.stop if command.nil?
+    begin
+      @scenario.__send__(command.first, *command.last) do
+        run_next_command
+      end
+    rescue Object => e
+      @passed = false
+      add_failure(e.message, e.backtrace)
+      @runner.puke(self.class, self.name, e) if @runner.respond_to?(:puke)
+      block.call
+    end
+  end
+  
+  class AsyncScenario
+    include Test::Unit::Assertions
+    
+    def initialize
+      @clients = {}
+      @inbox   = {}
+      @pool    = 0
+    end
+  
+    def check_inbox(expected_inbox, &block)
+      assert_equal expected_inbox, @inbox
+      block.call
+    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|
+        @server = server
+        EM.next_tick(&block)
+      end
+    end
+    
+    def http_client(name, channels, &block)
+      setup_client(Faye::Client.new(@endpoint), name, channels, &block)
+    end
+    
+    def local_client(name, channels, &block)
+      setup_client(@comet.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
+      end
+      @clients[name] = client
+      @inbox[name]   = {}
+      @pool         += 1
+      EM.add_timer(0.5 * channels.size, &block)
+    end
+    
+    def publish(from, channel, message, &block)
+      @clients[from].publish(channel, message)
+      EM.add_timer(2, &block)
+    end
+  end
+  
+end
+

data/test/test_channel.rb

@@ -1,5 +1,5 @@
 require "test/unit"
-require "faye"
+require File.dirname(__FILE__) + "/../lib/faye"
 
 class TestChannel < Test::Unit::TestCase
   include Faye
@@ -15,6 +15,12 @@ class TestChannel < Test::Unit::TestCase
     assert_equal 3,   tree['/va()$$lid/name']
   end
   
+  def test_keys
+    tree = Channel::Tree.new
+    tree['/foo'] = tree['/bar'] = tree['/foo/bar'] = true
+    assert_equal %w[/bar /foo /foo/bar], tree.keys.sort
+  end
+  
   def test_globbing
     tree = Channel::Tree.new
     tree['/foo/bar']     = 1

data/test/test_clients.js

@@ -20,12 +20,30 @@ var Scenario = require('./scenario'),
   assert.deepEqual(tree.glob('/channels/**').sort(), ['A','B','C']);
 })();
 
+Scenario.run("Server goes away, subscriptions should be revived",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/a']);
+  httpClient('B', []);
+  killServer();
+  wait(6);
+  server(8000);
+  wait(22);
+  publish('B', '/channels/a', {hello: 'world'});
+  checkInbox({
+      A: {
+        '/channels/a': [{hello: 'world'}]
+      },
+      B: {}
+  });
+}});
+
 Scenario.run("Two HTTP clients, no messages delivered",
 function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/a']);
   httpClient('B', []);
-  send('B', '/channels/b', {hello: 'world'});
+  publish('B', '/channels/b', {hello: 'world'});
   checkInbox({
       A: {},
       B: {}
@@ -37,7 +55,7 @@ function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/a']);
   httpClient('B', []);
-  send('B', '/channels/a', {hello: 'world'});
+  publish('B', '/channels/a', {hello: 'world'});
   checkInbox({
       A: {
         '/channels/a': [{hello: 'world'}]
@@ -51,7 +69,7 @@ function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/a', '/channels/*']);
   httpClient('B', []);
-  send('B', '/channels/a', {hello: 'world'});
+  publish('B', '/channels/a', {hello: 'world'});
   checkInbox({
       A: {
         '/channels/a': [{hello: 'world'}],
@@ -67,7 +85,7 @@ function() { with(this) {
   httpClient('A', ['/channels/a']);
   httpClient('B', []);
   httpClient('C', ['/channels/c']);
-  send('B', '/channels/a', {chunky: 'bacon'});
+  publish('B', '/channels/a', {chunky: 'bacon'});
   checkInbox({
       A: {
         '/channels/a': [{chunky: 'bacon'}]
@@ -83,7 +101,7 @@ function() { with(this) {
   httpClient('A', ['/channels/shared']);
   httpClient('B', []);
   httpClient('C', ['/channels/shared']);
-  send('B', '/channels/shared', {chunky: 'bacon'});
+  publish('B', '/channels/shared', {chunky: 'bacon'});
   checkInbox({
       A: {
         '/channels/shared': [{chunky: 'bacon'}]
@@ -100,7 +118,7 @@ function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/*']);
   httpClient('B', []);
-  send('B', '/channels/anything', {msg: 'hey'});
+  publish('B', '/channels/anything', {msg: 'hey'});
   checkInbox({
       A: {
         '/channels/*': [{msg: 'hey'}]
@@ -114,7 +132,7 @@ function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/name', '/channels/hello', '/channels/nested/hello']);
   httpClient('B', []);
-  send('B', '/channels/*', {msg: 'hey'});
+  publish('B', '/channels/*', {msg: 'hey'});
   checkInbox({
       A: {
         '/channels/name': [{msg: 'hey'}],
@@ -129,7 +147,7 @@ function() { with(this) {
   server(8000);
   httpClient('A', ['/channels/*']);
   httpClient('B', []);
-  send('B', '/channels/*', {msg: 'hey'});
+  publish('B', '/channels/*', {msg: 'hey'});
   checkInbox({
       A: {
         '/channels/*': [{msg: 'hey'}]
@@ -143,7 +161,7 @@ function() { with(this) {
   server(8000);
   localClient('A', ['/channels/name', '/channels/hello', '/channels/nested/hello']);
   localClient('B', []);
-  send('B', '/channels/**', {msg: 'hey'});
+  publish('B', '/channels/**', {msg: 'hey'});
   checkInbox({
       A: {
         '/channels/name': [{msg: 'hey'}],
@@ -160,7 +178,7 @@ function() { with(this) {
   localClient('A', ['/channels/hello', '/channels/nested/hello']);
   localClient('B', []);
   httpClient('C', ['/channels/name', '/channels/foo/**']);
-  send('B', '/channels/**', {msg: 'hey'});
+  publish('B', '/channels/**', {msg: 'hey'});
   checkInbox({
       A: {
         '/channels/hello': [{msg: 'hey'}],