faye-ouvrages 1.1.2

data/lib/faye.rb

@@ -0,0 +1,128 @@
+require 'cgi'
+require 'cookiejar'
+require 'digest/sha1'
+require 'em-http'
+require 'em-http/version'
+require 'eventmachine'
+require 'faye/websocket'
+require 'forwardable'
+require 'multi_json'
+require 'rack'
+require 'securerandom'
+require 'set'
+require 'time'
+require 'uri'
+
+module Faye
+  VERSION = '1.1.2'
+
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  autoload :Deferrable,   File.join(ROOT, 'faye', 'mixins', 'deferrable')
+  autoload :Logging,      File.join(ROOT, 'faye', 'mixins', 'logging')
+  autoload :Publisher,    File.join(ROOT, 'faye', 'mixins', 'publisher')
+  autoload :Timeouts,     File.join(ROOT, 'faye', 'mixins', 'timeouts')
+
+  autoload :Namespace,    File.join(ROOT, 'faye', 'util', 'namespace')
+
+  autoload :Engine,       File.join(ROOT, 'faye', 'engines', 'proxy')
+
+  autoload :Channel,      File.join(ROOT, 'faye', 'protocol', 'channel')
+  autoload :Client,       File.join(ROOT, 'faye', 'protocol', 'client')
+  autoload :Dispatcher,   File.join(ROOT, 'faye', 'protocol', 'dispatcher')
+  autoload :Scheduler,    File.join(ROOT, 'faye', 'protocol', 'scheduler')
+  autoload :Extensible,   File.join(ROOT, 'faye', 'protocol', 'extensible')
+  autoload :Grammar,      File.join(ROOT, 'faye', 'protocol', 'grammar')
+  autoload :Publication,  File.join(ROOT, 'faye', 'protocol', 'publication')
+  autoload :Server,       File.join(ROOT, 'faye', 'protocol', 'server')
+  autoload :Subscription, File.join(ROOT, 'faye', 'protocol', 'subscription')
+
+  autoload :Error,        File.join(ROOT, 'faye', 'error')
+  autoload :Transport,    File.join(ROOT, 'faye', 'transport', 'transport')
+
+  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
+
+  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.find { |m| m['channel'] == '/meta/connect' }
+    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.parse_url(url)
+    String === url ? URI.parse(url) : url
+  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,260 @@
+module Faye
+  class RackAdapter
+
+    include Logging
+
+    extend Forwardable
+    def_delegators '@server.engine', *Faye::Publisher.instance_methods
+
+    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'}
+
+    VALID_JSONP_CALLBACK = /^[a-z_\$][a-z0-9_\$]*(\.[a-z_\$][a-z0-9_\$]*)*$/i
+
+    # 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, &block)
+      @app     = app if app.respond_to?(:call)
+      @options = [app, options].grep(Hash).first || {}
+
+      ::WebSocket::Driver.validate_options(@options, [:engine, :mount, :ping, :timeout, :extensions, :websocket_extensions])
+
+      @endpoint    = @options[:mount] || DEFAULT_ENDPOINT
+      @extensions  = []
+      @endpoint_re = Regexp.new('^' + @endpoint.gsub(/\/$/, '') + '(/[^/]*)*(\\.[^\\.]+)?$')
+      @server      = Server.new(@options)
+
+      @static = StaticServer.new(File.join(ROOT, 'client'), /\.(?:js|map)$/)
+      @static.map(File.basename(@endpoint) + '.js', SCRIPT_PATH)
+      @static.map('client.js', SCRIPT_PATH)
+
+      if extensions = @options[:extensions]
+        [*extensions].each { |extension| add_extension(extension) }
+      end
+
+      if websocket_extensions = @options[:websocket_extensions]
+        [*websocket_extensions].each { |ext| add_websocket_extension(ext) }
+      end
+
+      block.call(self) if block
+    end
+
+    def listen(*args)
+      raise 'The listen() method is deprecated - see https://github.com/faye/faye-websocket-ruby#running-your-socket-application for information on running your Faye server'
+    end
+
+    def add_extension(extension)
+      @server.add_extension(extension)
+    end
+
+    def remove_extension(extension)
+      @server.remove_extension(extension)
+    end
+
+    def add_websocket_extension(extension)
+      @extensions << extension
+    end
+
+    def close
+      @server.close
+    end
+
+    def get_client
+      @client ||= Client.new(@server)
+    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 @static.call(env) if @static =~ request.path_info
+
+      # 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
+      end
+
+      return handle_websocket(request)   if Faye::WebSocket.websocket?(env)
+      return handle_eventsource(request) 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
+
+      unless json_msg.force_encoding('UTF-8').valid_encoding?
+        error 'Received request with invalid encoding: ?', 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']
+
+      if jsonp !~ VALID_JSONP_CALLBACK
+        error 'Invalid JSON-P callback: ?', jsonp
+        return [400, TYPE_TEXT, ['Bad request']]
+      end
+
+      headers['Access-Control-Allow-Origin'] = origin if origin
+      headers['Cache-Control'] = 'no-cache, no-store'
+      headers['X-Content-Type-Options'] = 'nosniff'
+
+      request.env['rack.hijack'].call if request.env['rack.hijack']
+      hijack = request.env['rack.hijack_io']
+
+      EventMachine.next_tick do
+        @server.process(message, request) do |replies|
+          response = Faye.to_json(replies)
+
+          if request.get?
+            response = "/**/#{ jsonp }(#{ jsonp_escape(response) });"
+            headers['Content-Disposition'] = 'attachment; filename=f.txt'
+          end
+
+          headers['Content-Length'] = response.bytesize.to_s unless request.env[HTTP_X_NO_CONTENT_LENGTH]
+          headers['Connection'] = 'close'
+          debug('HTTP response: ?', response)
+          send_response([200, headers, [response]], hijack, callback)
+        end
+      end
+
+      ASYNC_RESPONSE
+    rescue => e
+      error "#{e.message}\nBacktrace:\n#{e.backtrace * "\n"}"
+      [400, TYPE_TEXT, ['Bad request']]
+    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 jsonp_escape(json)
+      json.gsub(/\u2028/, '\u2028').gsub(/\u2029/, '\u2029')
+    end
+
+    def send_response(response, hijack, callback)
+      return callback.call(response) if callback
+
+      buffer = "HTTP/1.1 #{response[0]} OK\r\n"
+      response[1].each do |name, value|
+        buffer << "#{name}: #{value}\r\n"
+      end
+      buffer << "\r\n"
+      response[2].each do |chunk|
+        buffer << chunk
+      end
+
+      hijack.write(buffer)
+      hijack.flush
+      hijack.close_write
+    end
+
+    def handle_websocket(request)
+      options   = {:extensions => @extensions, :ping => @options[:ping]}
+      ws        = Faye::WebSocket.new(request.env, [], options)
+      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, false) if client_id and cid and cid != client_id
+          @server.open_socket(cid, ws, request)
+          client_id = cid if cid
+
+          @server.process(message, request) 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(request)
+      es        = Faye::EventSource.new(request.env, :ping => @options[:ping])
+      client_id = es.url.split('/').pop
+
+      debug('Opened EventSource connection for ?', client_id)
+      @server.open_socket(client_id, es, request)
+
+      es.onclose = lambda do |event|
+        @server.close_socket(client_id)
+        es = nil
+      end
+
+      es.rack_response
+    end
+
+    def handle_options
+      headers = {
+        'Access-Control-Allow-Credentials' => 'false',
+        'Access-Control-Allow-Headers'     => 'Accept, Authorization, Content-Type, Pragma, X-Requested-With',
+        'Access-Control-Allow-Methods'     => 'POST, GET',
+        'Access-Control-Allow-Origin'      => '*',
+        'Access-Control-Max-Age'           => '86400'
+      }
+      [200, headers, []]
+    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
+
+  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,58 @@
+module Faye
+  module Engine
+
+    class Connection
+      include Deferrable
+      include Timeouts
+
+      attr_accessor :socket
+
+      def initialize(engine, id, options = {})
+        @engine  = engine
+        @id      = id
+        @options = options
+        @inbox   = Set.new
+      end
+
+      def deliver(message)
+        message.delete('clientId')
+        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(:unknown)
+        callback(&block)
+
+        begin_delivery_timeout
+        begin_connection_timeout(timeout)
+      end
+
+      def flush
+        remove_timeout(:connection)
+        remove_timeout(:delivery)
+
+        set_deferred_status(:succeeded, @inbox.entries)
+        @inbox = []
+
+        @engine.close_connection(@id) unless @socket
+      end
+
+    private
+
+      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