faye 0.2.2 → 0.3.0

data/lib/faye/namespace.rb

@@ -0,0 +1,16 @@
+module Faye
+  class Namespace
+    
+    def initialize
+      @used = {}
+    end
+    
+    def generate
+      name = Faye.random
+      name = Faye.random while @used.has_key?(name)
+      @used[name] = name
+    end
+    
+  end
+end
+

data/lib/faye/rack_adapter.rb

@@ -9,6 +9,7 @@ module Faye
     ASYNC_RESPONSE = [-1, {}, []].freeze
     
     DEFAULT_ENDPOINT  = '/bayeux'
+    SCRIPT_PATH       = File.join(ROOT, 'faye-client-min.js')
     
     TYPE_JSON   = {'Content-Type' => 'text/json'}
     TYPE_SCRIPT = {'Content-Type' => 'text/javascript'}
@@ -23,6 +24,15 @@ module Faye
       @server   = Server.new(@options)
     end
     
+    def get_client
+      @client ||= Client.new(@server)
+    end
+    
+    def run(port)
+      handler = Rack::Handler.get('thin')
+      handler.run(self, :Port => port)
+    end
+    
     def call(env)
       request = Rack::Request.new(env)
       case request.path_info
@@ -40,11 +50,11 @@ module Faye
             response
           end
         rescue
-          [400, {'Content-Type' => 'text/plain'}, 'Bad request']
+          [400, TYPE_TEXT, 'Bad request']
         end
       
       when @script then
-        [200, TYPE_SCRIPT, File.new(CLIENT_SCRIPT)]
+        [200, TYPE_SCRIPT, File.new(SCRIPT_PATH)]
       
       else
         env['faye.server'] = @server

data/lib/faye/server.rb

@@ -1,9 +1,10 @@
 module Faye
   class Server
     def initialize(options = {})
-      @options  = options
-      @channels = Channel::Tree.new
-      @clients  = {}
+      @options   = options
+      @channels  = Channel::Tree.new
+      @clients   = {}
+      @namespace = Namespace.new
     end
     
     # Notifies the server of stale connections that should be deleted
@@ -39,12 +40,6 @@ module Faye
     
   private
     
-    def generate_id
-      id = Faye.random
-      id = Faye.random while @clients.has_key?(id)
-      connection(id).id
-    end
-    
     def connection(id)
       return @clients[id] if @clients.has_key?(id)
       client = Connection.new(id, @options)
@@ -62,6 +57,8 @@ module Faye
       client_id = message['clientId']
       channel   = message['channel']
       
+      @channels.glob(channel).each { |c| c << message }
+      
       if Channel.meta?(channel)
         response = __send__(Channel.parse(channel)[1], message, local)
         
@@ -82,8 +79,6 @@ module Faye
       
       return callback[[]] if message['clientId'].nil? or Channel.service?(channel)
       
-      @channels.glob(channel).each { |c| c << message }
-      
       callback[ { 'channel'     => channel,
                   'successful'  => true,
                   'id'          => message['id']  } ]
@@ -97,23 +92,27 @@ module Faye
     def handshake(message, local = false)
       response =  { 'channel' => Channel::HANDSHAKE,
                     'version' => BAYEUX_VERSION,
-                    'supportedConnectionTypes' => CONNECTION_TYPES,
                     'id'      => message['id'] }
       
       response['error'] = Error.parameter_missing('version') if message['version'].nil?
       
-      client_conns = message['supportedConnectionTypes']
-      if client_conns
-        common_conns = client_conns.select { |c| CONNECTION_TYPES.include?(c) }
-        response['error'] = Error.conntype_mismatch(*client_conns) if common_conns.empty?
-      else
-        response['error'] = Error.parameter_missing('supportedConnectionTypes')
+      unless local
+        response['supportedConnectionTypes'] = CONNECTION_TYPES
+        
+        client_conns = message['supportedConnectionTypes']
+        if client_conns
+          common_conns = client_conns.select { |c| CONNECTION_TYPES.include?(c) }
+          response['error'] = Error.conntype_mismatch(*client_conns) if common_conns.empty?
+        else
+          response['error'] = Error.parameter_missing('supportedConnectionTypes')
+        end
       end
       
       response['successful'] = response['error'].nil?
       return response unless response['successful']
       
-      response['clientId'] = generate_id
+      client_id = @namespace.generate
+      response['clientId'] = connection(client_id).id
       response
     end
     
@@ -184,7 +183,7 @@ module Faye
       
       subscription.each do |channel|
         next if response['error']
-        response['error'] = Error.channel_forbidden(channel) unless Channel.subscribable?(channel)
+        response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
         response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
         
         next if response['error']

data/lib/faye/transport.rb

@@ -0,0 +1,103 @@
+require 'em-http'
+require 'json'
+
+module Faye
+  
+  class Transport
+    def initialize(client, endpoint)
+      @client   = client
+      @endpoint = endpoint
+    end
+    
+    def connection_type
+      self.class.connection_type
+    end
+    
+    def send(message, &block)
+      if message.is_a?(Hash) and not message.has_key?('id')
+        message['id'] = @client.namespace.generate
+      end
+      
+      request(message) { |responses|
+        if block_given?
+          [responses].flatten.each do |response|
+            
+            if message.is_a?(Hash) and response['id'] == message['id']
+              block.call(response) 
+            end
+            
+            if response['advice']
+              @client.handle_advice(response['advice'])
+            end
+            
+            if response['data'] and response['channel']
+              @client.send_to_subscribers(response)
+            end
+            
+          end
+        end
+      }
+    end
+    
+    @transports = {}
+    
+    class << self
+      attr_accessor :connection_type
+      
+      def get(client, connection_types = nil)
+        endpoint = client.endpoint
+        connection_types ||= supported_connection_types
+        
+        candidate_class = @transports.find do |type, klass|
+          connection_types.include?(type) and
+          klass.usable?(endpoint)
+        end
+        
+        unless candidate_class
+          raise "Could not find a usable connection type for #{ endpoint }"
+        end
+        
+        candidate_class.last.new(client, endpoint)
+      end
+      
+      def register(type, klass)
+        @transports[type] = klass
+        klass.connection_type = type
+      end
+      
+      def supported_connection_types
+        @transports.keys
+      end
+    end
+  end
+  
+  class HttpTransport < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(String)
+    end
+    
+    def request(message, &block)
+      params  = {:message => JSON.unparse(message)}
+      request = EventMachine::HttpRequest.new(@endpoint).post(:body => params, :timeout => -1)
+      request.callback do
+        block.call(JSON.parse(request.response))
+      end
+    end
+  end
+  Transport.register 'long-polling', HttpTransport
+  
+  class LocalTransport < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(Server)
+    end
+    
+    def request(message, &block)
+      @endpoint.process(message, true) do |response|
+        block.call(response)
+      end
+    end
+  end
+  Transport.register 'in-process', LocalTransport
+  
+end
+

data/test/scenario.js

@@ -0,0 +1,99 @@
+var sys    = require('sys'),
+    path   = require('path'),
+    http   = require('http'),
+    assert = require('assert'),
+    faye   = require('../build/faye');
+
+Scenario = Faye.Class({
+  initialize: function(name, block) {
+    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);
+  },
+  
+  server: function(port) {
+    sys.puts('Starting server on port ' + port);
+    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);
+  },
+  
+  httpClient: function(name, channels) {
+    this._setupClient(new faye.Client(this._endpoint), name, channels);
+  },
+  
+  localClient: function(name, channels) {
+    this._setupClient(this._comet.getClient(), name, channels);
+  },
+  
+  _setupClient: function(client, name, channels) {
+    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] || [];
+        box[channel].push(message);
+      }, this);
+    }, this);
+    this._clients[name] = client;
+    this._inbox[name]   = {};
+    this._pool         += 1;
+  },
+  
+  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);
+  },
+  
+  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) {
+    sys.puts(JSON.stringify(this._inbox));
+    assert.deepEqual(this._inbox, expectedInbox);
+  }
+});
+
+Faye.extend(Scenario, {
+  _queue: [],
+  
+  enqueue: function(name, block) {
+    this._queue.push(new this(name, block));
+  },
+  
+  runNext: function() {
+    this.running = true;
+    var scenario = this._queue.shift();
+    if (!scenario) return;
+    scenario.run();
+  }
+});
+
+exports.run = function(name, block) {
+  Scenario.enqueue(name, block);
+  if (!Scenario.running) Scenario.runNext();
+};
+

data/test/test_channel.rb

@@ -16,19 +16,25 @@ class TestChannel < Test::Unit::TestCase
   end
   
   def test_globbing
-    globber = Channel::Tree.new
-    globber['/foo/bar']     = 1
-    globber['/foo/boo']     = 2
-    globber['/foo']         = 3
-    globber['/foobar']      = 4
-    globber['/foo/bar/boo'] = 5
-    globber['/foobar/boo']  = 6
-    globber['/foo/*']       = 7
-    globber['/foo/**']      = 8
+    tree = Channel::Tree.new
+    tree['/foo/bar']     = 1
+    tree['/foo/boo']     = 2
+    tree['/foo']         = 3
+    tree['/foobar']      = 4
+    tree['/foo/bar/boo'] = 5
+    tree['/foobar/boo']  = 6
+    tree['/foo/*']       = 7
+    tree['/foo/**']      = 8
+    
+    assert_equal  [1,2,7,8],    tree.glob('/foo/*').sort
+    assert_equal  [1,7,8],      tree.glob('/foo/bar').sort
+    assert_equal  [1,2,5,7,8],  tree.glob('/foo/**').sort
+    assert_equal  [5,8],        tree.glob('/foo/bar/boo').sort
+    
+    tree['/channels/hello'] = 'A'
+    tree['/channels/name'] = 'B'
+    tree['/channels/nested/hello'] = 'C'
     
-    assert_equal  [1,2,7,8],    globber.glob('/foo/*').sort
-    assert_equal  [1,7,8],      globber.glob('/foo/bar').sort
-    assert_equal  [1,2,5,7,8],  globber.glob('/foo/**').sort
-    assert_equal  [5,8],        globber.glob('/foo/bar/boo').sort
+    assert_equal %w[A B C],     tree.glob('/channels/**').sort
   end
 end

data/test/test_clients.js

@@ -0,0 +1,177 @@
+var Scenario = require('./scenario'),
+    faye     = require('../build/faye'),
+    assert   = require('assert');
+
+(function() {
+  var tree = new Faye.Channel.Tree();
+  var list = '/foo/bar /foo/boo /foo /foobar /foo/bar/boo /foobar/boo /foo/* /foo/**'.split(' ');
+  
+  Faye.each(list, function(c, i) { tree.set(c, i + 1) });
+  
+  assert.deepEqual(tree.glob('/foo/*').sort(),        [1,2,7,8]);
+  assert.deepEqual(tree.glob('/foo/bar').sort(),      [1,7,8]);
+  assert.deepEqual(tree.glob('/foo/**').sort(),       [1,2,5,7,8]);
+  assert.deepEqual(tree.glob('/foo/bar/boo').sort(),  [5,8]);
+  
+  tree.set('/channels/hello', 'A');
+  tree.set('/channels/name', 'B');
+  tree.set('/channels/nested/hello', 'C');
+  
+  assert.deepEqual(tree.glob('/channels/**').sort(), ['A','B','C']);
+})();
+
+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'});
+  checkInbox({
+      A: {},
+      B: {}
+  });
+}});
+
+Scenario.run("Two HTTP clients, single subscription",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/a']);
+  httpClient('B', []);
+  send('B', '/channels/a', {hello: 'world'});
+  checkInbox({
+      A: {
+        '/channels/a': [{hello: 'world'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Two HTTP clients, multiple subscriptions",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/a', '/channels/*']);
+  httpClient('B', []);
+  send('B', '/channels/a', {hello: 'world'});
+  checkInbox({
+      A: {
+        '/channels/a': [{hello: 'world'}],
+        '/channels/*': [{hello: 'world'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Three HTTP clients, single receiver",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/a']);
+  httpClient('B', []);
+  httpClient('C', ['/channels/c']);
+  send('B', '/channels/a', {chunky: 'bacon'});
+  checkInbox({
+      A: {
+        '/channels/a': [{chunky: 'bacon'}]
+      },
+      B: {},
+      C: {}
+  });
+}});
+
+Scenario.run("Three HTTP clients, multiple receivers",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/shared']);
+  httpClient('B', []);
+  httpClient('C', ['/channels/shared']);
+  send('B', '/channels/shared', {chunky: 'bacon'});
+  checkInbox({
+      A: {
+        '/channels/shared': [{chunky: 'bacon'}]
+      },
+      B: {},
+      C: {
+        '/channels/shared': [{chunky: 'bacon'}]
+      }
+  });
+}});
+
+Scenario.run("Two HTTP clients, single wildcard on receiver",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/*']);
+  httpClient('B', []);
+  send('B', '/channels/anything', {msg: 'hey'});
+  checkInbox({
+      A: {
+        '/channels/*': [{msg: 'hey'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Two HTTP clients, single wildcard on sender",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/name', '/channels/hello', '/channels/nested/hello']);
+  httpClient('B', []);
+  send('B', '/channels/*', {msg: 'hey'});
+  checkInbox({
+      A: {
+        '/channels/name': [{msg: 'hey'}],
+        '/channels/hello': [{msg: 'hey'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Two HTTP clients, single wildcard on both",
+function() { with(this) {
+  server(8000);
+  httpClient('A', ['/channels/*']);
+  httpClient('B', []);
+  send('B', '/channels/*', {msg: 'hey'});
+  checkInbox({
+      A: {
+        '/channels/*': [{msg: 'hey'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Two local clients, double wildcard on sender",
+function() { with(this) {
+  server(8000);
+  localClient('A', ['/channels/name', '/channels/hello', '/channels/nested/hello']);
+  localClient('B', []);
+  send('B', '/channels/**', {msg: 'hey'});
+  checkInbox({
+      A: {
+        '/channels/name': [{msg: 'hey'}],
+        '/channels/hello': [{msg: 'hey'}],
+        '/channels/nested/hello': [{msg: 'hey'}]
+      },
+      B: {}
+  });
+}});
+
+Scenario.run("Two local clients, one HTTP, double wildcard on sender and one subscription",
+function() { with(this) {
+  server(8000);
+  localClient('A', ['/channels/hello', '/channels/nested/hello']);
+  localClient('B', []);
+  httpClient('C', ['/channels/name', '/channels/foo/**']);
+  send('B', '/channels/**', {msg: 'hey'});
+  checkInbox({
+      A: {
+        '/channels/hello': [{msg: 'hey'}],
+        '/channels/nested/hello': [{msg: 'hey'}]
+      },
+      B: {},
+      C: {
+        '/channels/name': [{msg: 'hey'}],
+        '/channels/foo/**': [{msg: 'hey'}],
+        '/channels/name': [{msg: 'hey'}],
+      }
+  });
+}});
+