bushido-faye 0.8.1

data/lib/faye/adapters/rack_adapter.rb

@@ -0,0 +1,209 @@
+module Faye
+  class RackAdapter
+    
+    include Logging
+
+    extend Forwardable
+    def_delegators "@server.engine", :bind, :unbind
+
+    ASYNC_RESPONSE = [-1, {}, []].freeze
+    
+    DEFAULT_ENDPOINT  = '/bayeux'
+    SCRIPT_PATH       = File.join(ROOT, 'faye-browser-min.js')
+    
+    TYPE_JSON   = {'Content-Type' => 'application/json'}
+    TYPE_SCRIPT = {'Content-Type' => 'text/javascript'}
+    TYPE_TEXT   = {'Content-Type' => 'text/plain'}
+    
+    # This header is passed by Rack::Proxy during testing. Rack::Proxy seems to
+    # set content-length for you, and setting it in here really slows the tests
+    # down. Better suggestions welcome.
+    HTTP_X_NO_CONTENT_LENGTH = 'HTTP_X_NO_CONTENT_LENGTH'
+    
+    def initialize(app = nil, options = nil)
+      @app      = app if app.respond_to?(:call)
+      @options  = [app, options].grep(Hash).first || {}
+      
+      @endpoint    = @options[:mount] || DEFAULT_ENDPOINT
+      @endpoint_re = Regexp.new('^' + @endpoint + '(/[^/]*)*(\\.js)?$')
+      @server      = Server.new(@options)
+      
+      return unless extensions = @options[:extensions]
+      [*extensions].each { |extension| add_extension(extension) }
+    end
+    
+    def add_extension(extension)
+      @server.add_extension(extension)
+    end
+    
+    def remove_extension(extension)
+      @server.remove_extension(extension)
+    end
+    
+    def get_client
+      @client ||= Client.new(@server)
+    end
+    
+    def listen(port, ssl_options = nil)
+      Faye::WebSocket.load_adapter('thin')
+      handler = Rack::Handler.get('thin')
+      handler.run(self, :Port => port) do |s|
+        if ssl_options
+          s.ssl = true
+          s.ssl_options = {
+            :private_key_file => ssl_options[:key],
+            :cert_chain_file  => ssl_options[:cert]
+          }
+        end
+        @thin_server = s
+      end
+    end
+    
+    def stop
+      return unless @thin_server
+      @thin_server.stop
+      @thin_server = nil
+    end
+    
+    def call(env)
+      Faye.ensure_reactor_running!
+      request = Rack::Request.new(env)
+      
+      unless request.path_info =~ @endpoint_re
+        env['faye.client'] = get_client
+        return @app ? @app.call(env) :
+                      [404, TYPE_TEXT, ["Sure you're not looking for #{@endpoint} ?"]]
+      end
+      
+      return serve_client_script(env) if request.path_info =~ /\.js$/
+      return handle_options(request)  if env['REQUEST_METHOD'] == 'OPTIONS'
+      return handle_websocket(env)    if Faye::WebSocket.websocket?(env)
+      return handle_eventsource(env)  if Faye::EventSource.eventsource?(env)
+      
+      handle_request(request)
+    end
+    
+  private
+    
+    def serve_client_script(env)
+      @client_script ||= File.read(SCRIPT_PATH)
+      @client_digest ||= Digest::SHA1.hexdigest(@client_script)
+      @client_mtime  ||= File.mtime(SCRIPT_PATH)
+      
+      headers = TYPE_SCRIPT.dup
+      ims     = env['HTTP_IF_MODIFIED_SINCE']
+      
+      headers['Content-Length'] = @client_script.bytesize.to_s unless env[HTTP_X_NO_CONTENT_LENGTH]
+      headers['ETag'] = @client_digest
+      headers['Last-Modified'] = @client_mtime.httpdate
+      
+      if env['HTTP_IF_NONE_MATCH'] == @client_digest
+        [304, headers, ['']]
+      elsif ims and @client_mtime <= Time.httpdate(ims)
+        [304, headers, ['']]
+      else
+        [200, headers, [@client_script]]
+      end
+    end
+    
+    def handle_request(request)
+      json_msg = message_from_request(request)
+      message  = Yajl::Parser.parse(json_msg)
+      jsonp    = request.params['jsonp'] || JSONP_CALLBACK
+      headers  = request.get? ? TYPE_SCRIPT.dup : TYPE_JSON.dup
+      origin   = request.env['HTTP_ORIGIN']
+      callback = request.env['async.callback']
+      
+      debug 'Received ?: ?', request.env['REQUEST_METHOD'], json_msg
+      @server.flush_connection(message) if request.get?
+      
+      headers['Access-Control-Allow-Origin'] = origin if origin
+      headers['Cache-Control'] = 'no-cache, no-store' if request.get?
+      
+      @server.process(message, false) do |replies|
+        response = Faye.to_json(replies)
+        response = "#{ jsonp }(#{ response });" if request.get?
+        headers['Content-Length'] = response.bytesize.to_s unless request.env[HTTP_X_NO_CONTENT_LENGTH]
+        debug 'Returning ?', response
+        callback.call [200, headers, [response]]
+      end
+      
+      ASYNC_RESPONSE
+    rescue => e
+      error "#{e.message}\nBacktrace:\n#{e.backtrace * "\n"}"
+      [400, TYPE_TEXT, ['Bad request']]
+    end
+    
+    def handle_websocket(env)
+      ws        = Faye::WebSocket.new(env, nil, :ping => @options[:ping])
+      client_id = nil
+      
+      ws.onmessage = lambda do |event|
+        begin
+          message   = Yajl::Parser.parse(event.data)
+          client_id = Faye.client_id_from_messages(message)
+          
+          debug "Received via WebSocket[#{ws.version}]: ?", message
+          @server.open_socket(client_id, ws)
+          
+          @server.process(message, false) do |replies|
+            ws.send(Faye.to_json(replies)) if ws
+          end
+        rescue => e
+          error "#{e.message}\nBacktrace:\n#{e.backtrace * "\n"}"
+        end
+      end
+      
+      ws.onclose = lambda do |event|
+        @server.close_socket(client_id)
+        ws = nil
+      end
+      
+      ws.rack_response
+    end
+    
+    def handle_eventsource(env)
+      es        = Faye::EventSource.new(env, :ping => @options[:ping])
+      client_id = es.url.split('/').pop
+      
+      debug 'Opened EventSource connection for ?', client_id
+      @server.open_socket(client_id, es)
+      
+      es.onclose = lambda do |event|
+        @server.close_socket(client_id)
+        es = nil
+      end
+      
+      es.rack_response
+    end
+    
+    def message_from_request(request)
+      message = request.params['message']
+      return message if message
+      
+      # Some clients do not send a content-type, e.g.
+      # Internet Explorer when using cross-origin-long-polling
+      # Some use application/xml when using CORS
+      content_type = request.env['CONTENT_TYPE'] || ''
+      
+      if content_type.split(';').first == 'application/json'
+        request.body.read
+      else
+        CGI.parse(request.body.read)['message'][0]
+      end
+    end
+    
+    def handle_options(request)
+      headers = {
+        'Access-Control-Allow-Origin'       => '*',
+        'Access-Control-Allow-Credentials'  => 'false',
+        'Access-Control-Max-Age'            => '86400',
+        'Access-Control-Allow-Methods'      => 'POST, GET, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers'      => 'Accept, Content-Type, X-Requested-With'
+      }
+      [200, headers, ['']]
+    end
+    
+  end
+end
+

data/lib/faye/engines/connection.rb

@@ -0,0 +1,60 @@
+module Faye
+  module Engine
+    
+    class Connection
+      include EventMachine::Deferrable
+      include Timeouts
+      
+      attr_accessor :socket
+      
+      def initialize(engine, id, options = {})
+        @engine  = engine
+        @id      = id
+        @options = options
+        @inbox   = Set.new
+      end
+      
+      def deliver(message)
+        return socket.send(Faye.to_json([message])) if socket
+        return unless @inbox.add?(message)
+        begin_delivery_timeout
+      end
+      
+      def connect(options, &block)
+        options = options || {}
+        timeout = options['timeout'] ? options['timeout'] / 1000.0 : @engine.timeout
+        
+        set_deferred_status(:deferred)
+        callback(&block)
+        
+        begin_delivery_timeout
+        begin_connection_timeout(timeout)
+      end
+      
+      def flush!(force = false)
+        release_connection!(force)
+        set_deferred_status(:succeeded, @inbox.entries)
+        @inbox = []
+      end
+      
+    private
+      
+      def release_connection!(force = false)
+        @engine.close_connection(@id) if force or socket.nil?
+        remove_timeout(:connection)
+        remove_timeout(:delivery)
+      end
+      
+      def begin_delivery_timeout
+        return if @inbox.empty?
+        add_timeout(:delivery, MAX_DELAY) { flush! }
+      end
+      
+      def begin_connection_timeout(timeout)
+        add_timeout(:connection, timeout) { flush! }
+      end
+    end
+    
+  end
+end
+

data/lib/faye/engines/memory.rb

@@ -0,0 +1,112 @@
+module Faye
+  module Engine
+    
+    class Memory
+      include Timeouts
+      
+      def self.create(server, options)
+        new(server, options)
+      end
+      
+      def initialize(server, options)
+        @server    = server
+        @options   = options
+        @namespace = Namespace.new
+        @clients   = {}
+        @channels  = {}
+        @messages  = {}
+      end
+      
+      def create_client(&callback)
+        client_id = @namespace.generate
+        @server.debug 'Created new client ?', client_id
+        ping(client_id)
+        @server.trigger(:handshake, client_id)
+        callback.call(client_id)
+      end
+      
+      def destroy_client(client_id, &callback)
+        return unless @namespace.exists?(client_id)
+        
+        if @clients.has_key?(client_id)
+          @clients[client_id].each { |channel| unsubscribe(client_id, channel) }
+        end
+        
+        remove_timeout(client_id)
+        @namespace.release(client_id)
+        @messages.delete(client_id)
+        @server.debug 'Destroyed client ?', client_id
+        @server.trigger(:disconnect, client_id)
+        callback.call if callback
+      end
+      
+      def client_exists(client_id, &callback)
+        callback.call(@namespace.exists?(client_id))
+      end
+      
+      def ping(client_id)
+        timeout = @server.timeout
+        return unless Numeric === timeout
+        @server.debug 'Ping ?, ?', client_id, timeout
+        remove_timeout(client_id)
+        add_timeout(client_id, 2 * timeout) { destroy_client(client_id) }
+      end
+      
+      def subscribe(client_id, channel, &callback)
+        @clients[client_id] ||= Set.new
+        should_trigger = @clients[client_id].add?(channel)
+        
+        @channels[channel] ||= Set.new
+        @channels[channel].add(client_id)
+        
+        @server.debug 'Subscribed client ? to channel ?', client_id, channel
+        @server.trigger(:subscribe, client_id, channel) if should_trigger
+        callback.call(true) if callback
+      end
+      
+      def unsubscribe(client_id, channel, &callback)
+        if @clients.has_key?(client_id)
+          should_trigger = @clients[client_id].delete?(channel)
+          @clients.delete(client_id) if @clients[client_id].empty?
+        end
+        
+        if @channels.has_key?(channel)
+          @channels[channel].delete(client_id)
+          @channels.delete(channel) if @channels[channel].empty?
+        end
+        
+        @server.debug 'Unsubscribed client ? from channel ?', client_id, channel
+        @server.trigger(:unsubscribe, client_id, channel) if should_trigger
+        callback.call(true) if callback
+      end
+      
+      def publish(message, channels)
+        @server.debug 'Publishing message ?', message
+        
+        clients = Set.new
+        
+        channels.each do |channel|
+          next unless subs = @channels[channel]
+          subs.each(&clients.method(:add))
+        end
+        
+        clients.each do |client_id|
+          @server.debug 'Queueing for client ?: ?', client_id, message
+          @messages[client_id] ||= []
+          @messages[client_id] << Faye.copy_object(message)
+          empty_queue(client_id)
+        end
+
+        @server.trigger(:publish, message['clientId'], message['channel'], message['data'])
+      end
+      
+      def empty_queue(client_id)
+        return unless @server.has_connection?(client_id)
+        @server.deliver(client_id, @messages[client_id])
+        @messages.delete(client_id)
+      end
+    end
+    
+  end
+end
+

data/lib/faye/engines/proxy.rb

@@ -0,0 +1,111 @@
+module Faye
+  module Engine
+    
+    METHODS   = %w[create_client client_exists destroy_client ping subscribe unsubscribe]
+    MAX_DELAY = 0.0
+    INTERVAL  = 0.0
+    TIMEOUT   = 60.0
+    ID_LENGTH = 128
+    
+    autoload :Connection, File.expand_path('../connection', __FILE__)
+    autoload :Memory,     File.expand_path('../memory', __FILE__)
+    
+    def self.ensure_reactor_running!
+      Thread.new { EM.run } unless EM.reactor_running?
+      Thread.pass until EM.reactor_running?
+    end
+    
+    def self.get(options)
+      Proxy.new(options)
+    end
+    
+    def self.random(bitlength = ID_LENGTH)
+      limit    = 2 ** bitlength - 1
+      max_size = limit.to_s(36).size
+      string   = rand(limit).to_s(36)
+      string = '0' + string while string.size < max_size
+      string
+    end
+    
+    class Proxy
+      include Publisher
+      include Logging
+      
+      attr_reader :interval, :timeout
+      
+      extend Forwardable
+      def_delegators :@engine, *METHODS
+      
+      def initialize(options)
+        @options     = options
+        @connections = {}
+        @interval    = @options[:interval] || INTERVAL
+        @timeout     = @options[:timeout]  || TIMEOUT
+        
+        engine_class = @options[:type] || Memory
+        @engine      = engine_class.create(self, @options)
+
+        debug 'Created new engine: ?', @options
+      end
+      
+      def connect(client_id, options = {}, &callback)
+        debug 'Accepting connection from ?', client_id
+        @engine.ping(client_id)
+        conn = connection(client_id, true)
+        conn.connect(options, &callback)
+        @engine.empty_queue(client_id)
+      end
+      
+      def has_connection?(client_id)
+        @connections.has_key?(client_id)
+      end
+      
+      def connection(client_id, create)
+        conn = @connections[client_id]
+        return conn if conn or not create
+        @connections[client_id] = Connection.new(self, client_id)
+      end
+      
+      def close_connection(client_id)
+        debug 'Closing connection for ?', client_id
+        @connections.delete(client_id)
+      end
+      
+      def open_socket(client_id, socket)
+        return unless client_id
+        conn = connection(client_id, true)
+        conn.socket = socket
+      end
+      
+      def deliver(client_id, messages)
+        return if !messages || messages.empty?
+        conn = connection(client_id, false)
+        return false unless conn
+        messages.each(&conn.method(:deliver))
+        true
+      end
+      
+      def generate_id
+        Engine.random
+      end
+      
+      def flush(client_id)
+        return unless client_id
+        debug 'Flushing connection for ?', client_id
+        conn = connection(client_id, false)
+        conn.flush!(true) if conn
+      end
+      
+      def disconnect
+        @engine.disconnect if @engine.respond_to?(:disconnect)
+      end
+      
+      def publish(message)
+        channels = Channel.expand(message['channel'])
+        @engine.publish(message, channels)
+      end
+    end
+    
+  end
+end
+