face-faye 0.8.9

data/lib/faye.rb

@@ -0,0 +1,122 @@
+require 'cgi'
+require 'cookiejar'
+require 'digest/sha1'
+require 'em-http'
+require 'em-http/version'
+require 'eventmachine'
+require 'faye/websocket'
+require 'forwardable'
+require 'rack'
+require 'set'
+require 'time'
+require 'uri'
+require 'multi_json'
+
+module Faye
+  VERSION = '0.8.9'
+
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  autoload :Publisher,    File.join(ROOT, 'faye', 'mixins', 'publisher')
+  autoload :Timeouts,     File.join(ROOT, 'faye', 'mixins', 'timeouts')
+  autoload :Logging,      File.join(ROOT, 'faye', 'mixins', 'logging')
+
+  autoload :Namespace,    File.join(ROOT, 'faye', 'util', 'namespace')
+
+  autoload :Engine,       File.join(ROOT, 'faye', 'engines', 'proxy')
+
+  autoload :Grammar,      File.join(ROOT, 'faye', 'protocol', 'grammar')
+  autoload :Extensible,   File.join(ROOT, 'faye', 'protocol', 'extensible')
+  autoload :Channel,      File.join(ROOT, 'faye', 'protocol', 'channel')
+  autoload :Subscription, File.join(ROOT, 'faye', 'protocol', 'subscription')
+  autoload :Publication,  File.join(ROOT, 'faye', 'protocol', 'publication')
+  autoload :Client,       File.join(ROOT, 'faye', 'protocol', 'client')
+  autoload :Server,       File.join(ROOT, 'faye', 'protocol', 'server')
+
+  autoload :Transport,    File.join(ROOT, 'faye', 'transport', 'transport')
+  autoload :Error,        File.join(ROOT, 'faye', 'error')
+
+  autoload :RackAdapter,  File.join(ROOT, 'faye', 'adapters', 'rack_adapter')
+  autoload :StaticServer, File.join(ROOT, 'faye', 'adapters', 'static_server')
+
+  BAYEUX_VERSION   = '1.0'
+  JSONP_CALLBACK   = 'jsonpcallback'
+  CONNECTION_TYPES = %w[long-polling cross-origin-long-polling callback-polling websocket eventsource in-process]
+
+  MANDATORY_CONNECTION_TYPES = %w[long-polling callback-polling in-process]
+
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = method(:puts)
+
+  def self.ensure_reactor_running!
+    Engine.ensure_reactor_running!
+  end
+
+  def self.random(*args)
+    Engine.random(*args)
+  end
+
+  def self.client_id_from_messages(messages)
+    first = [messages].flatten.first
+    first && first['clientId']
+  end
+
+  def self.copy_object(object)
+    case object
+    when Hash
+      clone = {}
+      object.each { |k,v| clone[k] = copy_object(v) }
+      clone
+    when Array
+      clone = []
+      object.each { |v| clone << copy_object(v) }
+      clone
+    else
+      object
+    end
+  end
+
+  def self.to_json(value)
+    case value
+      when Hash, Array then MultiJson.dump(value)
+      when String, NilClass then value.inspect
+      else value.to_s
+    end
+  end
+
+  def self.async_each(list, iterator, callback)
+    n       = list.size
+    i       = -1
+    calls   = 0
+    looping = false
+
+    loop, resume = nil, nil
+
+    iterate = lambda do
+      calls -= 1
+      i += 1
+      if i == n
+        callback.call if callback
+      else
+        iterator.call(list[i], resume)
+      end
+    end
+
+    loop = lambda do
+      unless looping
+        looping = true
+        iterate.call while calls > 0
+        looping = false
+      end
+    end
+
+    resume = lambda do
+      calls += 1
+      loop.call
+    end
+    resume.call
+  end
+end
+

data/lib/faye/adapters/rack_adapter.rb

@@ -0,0 +1,216 @@
+module Faye
+  class RackAdapter
+
+    include Logging
+
+    extend Forwardable
+    def_delegators "@server.engine", :bind, :unbind
+
+    ASYNC_RESPONSE = [-1, {}, []].freeze
+
+    DEFAULT_ENDPOINT  = '/bayeux'
+    SCRIPT_PATH       = 'faye-browser-min.js'
+
+    TYPE_JSON   = {'Content-Type' => 'application/json; charset=utf-8'}
+    TYPE_SCRIPT = {'Content-Type' => 'text/javascript; charset=utf-8'}
+    TYPE_TEXT   = {'Content-Type' => 'text/plain; charset=utf-8'}
+
+    # 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.gsub(/\/$/, '') + '(/[^/]+)*(\\.[^\\.]+)?$')
+      @server      = Server.new(@options)
+
+      @static = StaticServer.new(ROOT, /\.(?:js|map)$/)
+      @static.map(File.basename(@endpoint) + '.js', SCRIPT_PATH)
+      @static.map('client.js', SCRIPT_PATH)
+
+      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
+
+      # http://groups.google.com/group/faye-users/browse_thread/thread/4a01bb7d25d3636a
+      if env['REQUEST_METHOD'] == 'OPTIONS' or env['HTTP_ACCESS_CONTROL_REQUEST_METHOD'] == 'POST'
+        return handle_options(request)
+      end
+
+      return @static.call(env)        if @static =~ request.path_info
+      return handle_websocket(env)    if Faye::WebSocket.websocket?(env)
+      return handle_eventsource(env)  if Faye::EventSource.eventsource?(env)
+
+      handle_request(request)
+    end
+
+  private
+
+    def handle_request(request)
+      unless json_msg = message_from_request(request)
+        error 'Received request with no message: ?', format_request(request)
+        return [400, TYPE_TEXT, ['Bad request']]
+      end
+
+      debug "Received message via HTTP #{request.request_method}: ?", json_msg
+
+      message  = MultiJson.load(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']
+
+      @server.flush_connection(message) if request.get?
+
+      headers['Access-Control-Allow-Origin'] = origin if origin
+      headers['Cache-Control'] = 'no-cache, no-store'
+
+      @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]
+        headers['Connection'] = 'close'
+        debug 'HTTP response: ?', 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
+          debug "Received message via WebSocket[#{ws.version}]: ?", event.data
+
+          message = MultiJson.load(event.data)
+          cid     = Faye.client_id_from_messages(message)
+
+          @server.close_socket(client_id) if client_id and cid != client_id
+          @server.open_socket(cid, ws)
+          client_id = cid
+
+          @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 format_request(request)
+      request.body.rewind
+      string = "curl -X #{request.request_method.upcase}"
+      string << " '#{request.url}'"
+      if request.post?
+        string << " -H 'Content-Type: #{request.env['CONTENT_TYPE']}'"
+        string << " -d '#{request.body.read}'"
+      end
+      string
+    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, Pragma, X-Requested-With'
+      }
+      [200, headers, ['']]
+    end
+
+  end
+end
+

data/lib/faye/adapters/static_server.rb

@@ -0,0 +1,56 @@
+module Faye
+  class StaticServer
+
+    def initialize(directory, path_regex)
+      @directory  = directory
+      @path_regex = path_regex
+      @path_map   = {}
+      @index      = {}
+    end
+
+    def map(request_path, filename)
+      @path_map[request_path] = filename
+    end
+
+    def =~(pathname)
+      @path_regex =~ pathname
+    end
+
+    def call(env)
+      filename = File.basename(env['PATH_INFO'])
+      filename = @path_map[filename] || filename
+
+      cache = @index[filename] ||= {}
+      fullpath = File.join(@directory, filename)
+
+      begin
+        cache[:content] ||= File.read(fullpath)
+        cache[:digest]  ||= Digest::SHA1.hexdigest(cache[:content])
+        cache[:mtime]   ||= File.mtime(fullpath)
+      rescue
+        return [404, {}, []]
+      end
+
+      type = /\.js$/ =~ fullpath ? RackAdapter::TYPE_SCRIPT : RackAdapter::TYPE_JSON
+      ims  = env['HTTP_IF_MODIFIED_SINCE']
+
+      no_content_length = env[RackAdapter::HTTP_X_NO_CONTENT_LENGTH]
+
+      headers = {
+        'ETag'          => cache[:digest],
+        'Last-Modified' => cache[:mtime].httpdate
+      }
+
+      if env['HTTP_IF_NONE_MATCH'] == cache[:digest]
+        [304, headers, ['']]
+      elsif ims and cache[:mtime] <= Time.httpdate(ims)
+        [304, headers, ['']]
+      else
+        headers['Content-Length'] = cache[:content].bytesize.to_s unless no_content_length
+        headers.update(type)
+        [200, headers, [cache[:content]]]
+      end
+    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(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
+