faye 1.0.3 → 1.4.0

data/lib/faye/protocol/dispatcher.rb

@@ -0,0 +1,170 @@
+module Faye
+  class Dispatcher
+
+    class Envelope < Struct.new(:message, :scheduler, :request, :timer)
+    end
+
+    MAX_REQUEST_SIZE = 2048
+    DEFAULT_RETRY    = 5.0
+
+    UP   = 1
+    DOWN = 2
+
+    include Publisher
+    include Logging
+    extend Forwardable
+    def_delegators :@transport, :connection_type
+
+    attr_accessor :client_id, :timeout
+    attr_reader   :endpoint, :tls, :headers, :cookies, :proxy, :retry
+    attr_reader   :max_request_size, :transports, :ws_extensions
+
+    def initialize(client, endpoint, options)
+      super()
+
+      @client     = client
+      @endpoint   = String === endpoint ? URI(endpoint) : endpoint
+      @alternates = options[:endpoints] || {}
+
+      @cookies       = CookieJar::Jar.new
+      @disabled      = []
+      @envelopes     = {}
+      @headers       = {}
+      @retry         = options[:retry] || DEFAULT_RETRY
+      @scheduler     = options[:scheduler] || Faye::Scheduler
+      @state         = 0
+      @transports    = {}
+      @ws_extensions = []
+
+      @proxy = options[:proxy] || {}
+      @proxy = { :origin => @proxy } if String === @proxy
+
+      [*options[:websocket_extensions]].each do |extension|
+        add_websocket_extension(extension)
+      end
+
+      @tls = { :verify_peer => true }.merge(options[:tls] || {})
+
+      @alternates.each do |type, url|
+        @alternates[type] = URI(url)
+      end
+
+      @max_request_size = MAX_REQUEST_SIZE
+    end
+
+    def endpoint_for(connection_type)
+      @alternates[connection_type] || @endpoint
+    end
+
+    def add_websocket_extension(extension)
+      @ws_extensions << extension
+    end
+
+    def disable(feature)
+      @disabled << feature
+    end
+
+    def set_header(name, value)
+      @headers[name.to_s] = value.to_s
+    end
+
+    def close
+      transport = @transport
+      @transport = nil
+      transport.close if transport
+    end
+
+    def connection_types
+      Transport.connection_types
+    end
+
+    def select_transport(transport_types)
+      Transport.get(self, transport_types, @disabled) do |transport|
+        debug('Selected ? transport for ?', transport.connection_type, transport.endpoint)
+
+        next if transport == @transport
+        @transport.close if @transport
+
+        @transport = transport
+      end
+    end
+
+    def send_message(message, timeout, options = {})
+      id       = message['id']
+      attempts = options[:attempts]
+      deadline = options[:deadline] && Time.now.to_f + options[:deadline]
+      envelope = @envelopes[id]
+
+      unless envelope
+        scheduler = @scheduler.new(message, :timeout => timeout, :interval => @retry, :attempts => attempts, :deadline => deadline)
+        envelope  = @envelopes[id] = Envelope.new(message, scheduler, nil, nil)
+      end
+
+      send_envelope(envelope)
+    end
+
+    def send_envelope(envelope)
+      return unless @transport
+      return if envelope.request or envelope.timer
+
+      message   = envelope.message
+      scheduler = envelope.scheduler
+
+      unless scheduler.deliverable?
+        scheduler.abort!
+        @envelopes.delete(message['id'])
+        return
+      end
+
+      envelope.timer = EventMachine.add_timer(scheduler.timeout) do
+        handle_error(message)
+      end
+
+      scheduler.send!
+      envelope.request = @transport.send_message(message)
+    end
+    private :send_envelope
+
+    def handle_response(reply)
+      if reply.has_key?('successful') and envelope = @envelopes.delete(reply['id'])
+        envelope.scheduler.succeed!
+        EventMachine.cancel_timer(envelope.timer) if envelope.timer
+      end
+
+      trigger(:message, reply)
+
+      return if @state == UP
+      @state = UP
+      @client.trigger('transport:up')
+    end
+
+    def handle_error(message, immediate = false)
+      return unless envelope = @envelopes[message['id']]
+      return unless request = envelope.request
+
+      request.callback do |req|
+        req.close if req.respond_to?(:close)
+      end
+
+      scheduler = envelope.scheduler
+      scheduler.fail!
+
+      EventMachine.cancel_timer(envelope.timer)
+      envelope.request = envelope.timer = nil
+
+      if immediate
+        send_envelope(envelope)
+      else
+        envelope.timer = EventMachine.add_timer(scheduler.interval) do
+          envelope.timer = nil
+          send_envelope(envelope)
+        end
+      end
+
+      return if @state == DOWN
+      @state = DOWN
+      @client.trigger('transport:down')
+    end
+
+  end
+end

data/lib/faye/protocol/extensible.rb

@@ -18,7 +18,7 @@ module Faye
     end
 
     def pipe_through_extensions(stage, message, env, &callback)
-      debug 'Passing through ? extensions: ?', stage, message
+      debug('Passing through ? extensions: ?', stage, message)
 
       return callback.call(message) unless @extensions
       extensions = @extensions.dup
@@ -43,4 +43,3 @@ module Faye
 
   end
 end
-

data/lib/faye/protocol/grammar.rb

@@ -55,4 +55,3 @@ module Faye
 
   end
 end
-

data/lib/faye/protocol/scheduler.rb

@@ -0,0 +1,43 @@
+module Faye
+  class Scheduler
+
+    def initialize(message, options)
+      @message  = message
+      @options  = options
+      @attempts = 0
+    end
+
+    def interval
+      @options[:interval]
+    end
+
+    def timeout
+      @options[:timeout]
+    end
+
+    def deliverable?
+      attempts = @options[:attempts]
+      deadline = @options[:deadline]
+      now      = Time.now.to_f
+
+      return false if attempts and @attempts >= attempts
+      return false if deadline and now > deadline
+
+      true
+    end
+
+    def send!
+      @attempts += 1
+    end
+
+    def succeed!
+    end
+
+    def fail!
+    end
+
+    def abort!
+    end
+
+  end
+end

data/lib/faye/protocol/server.rb

@@ -6,8 +6,6 @@ module Faye
     include Logging
     include Extensible
 
-    META_METHODS = %w[handshake connect disconnect subscribe unsubscribe]
-
     attr_reader :engine
 
     def initialize(options = {})
@@ -16,7 +14,7 @@ module Faye
       engine_opts[:timeout] = @options[:timeout]
       @engine     = Faye::Engine.get(engine_opts)
 
-      info 'Created new server: ?', @options
+      info('Created new server: ?', @options)
     end
 
     def close
@@ -28,14 +26,14 @@ module Faye
       @engine.open_socket(client_id, Socket.new(self, socket, env))
     end
 
-    def close_socket(client_id)
-      @engine.flush(client_id)
+    def close_socket(client_id, close = true)
+      @engine.flush_connection(client_id, close)
     end
 
     def process(messages, env, &callback)
       local    = env.nil?
       messages = [messages].flatten
-      info 'Processing messages: ? (local: ?)', messages, local
+      info('Processing messages: ? (local: ?)', messages, local)
 
       return callback.call([]) if messages.size == 0
       processed, responses = 0, []
@@ -44,7 +42,7 @@ module Faye
         responses.concat(replies)
         processed += 1
         responses.compact!
-        info 'Returning replies: ?', responses
+        info('Returning replies: ?', responses)
         callback.call(responses) if processed == messages.size
       end
 
@@ -53,7 +51,7 @@ module Faye
         gather_replies.call(replies) if expected == 0
 
         replies.each_with_index do |reply, i|
-          debug 'Processing reply: ?', reply
+          debug('Processing reply: ?', reply)
           pipe_through_extensions(:outgoing, reply, env) do |message|
             replies[i] = message
             extended  += 1
@@ -83,7 +81,7 @@ module Faye
 
     def handle(message, local = false, &callback)
       return callback.call([]) if !message
-      info 'Handling message: ? (local: ?)', message, local
+      info('Handling message: ? (local: ?)', message, local)
 
       channel_name = message['channel']
       error        = message['error']
@@ -94,7 +92,10 @@ module Faye
         error = Faye::Error.channel_invalid(channel_name)
       end
 
-      message.delete('clientId')
+      if message['data'].nil?
+        error = Faye::Error.parameter_missing('data')
+      end
+
       @engine.publish(message) unless error
 
       response = make_response(message)
@@ -104,10 +105,9 @@ module Faye
     end
 
     def handle_meta(message, local, &callback)
-      method    = Channel.parse(message['channel'])[1]
-      client_id = message['clientId']
+      method = method_for(message)
 
-      unless META_METHODS.include?(method)
+      unless method
         response = make_response(message)
         response['error'] = Faye::Error.channel_forbidden(message['channel'])
         response['successful'] = false
@@ -121,6 +121,16 @@ module Faye
       end
     end
 
+    def method_for(message)
+      case message['channel']
+      when Channel::HANDSHAKE   then :handshake
+      when Channel::CONNECT     then :connect
+      when Channel::SUBSCRIBE   then :subscribe
+      when Channel::UNSUBSCRIBE then :unsubscribe
+      when Channel::DISCONNECT  then :disconnect
+      end
+    end
+
     def advize(response, connection_type)
       return unless [Channel::HANDSHAKE, Channel::CONNECT].include?(response['channel'])
 
@@ -291,4 +301,3 @@ module Faye
 
   end
 end
-

data/lib/faye/protocol/socket.rb

@@ -22,4 +22,3 @@ module Faye
 
   end
 end
-

data/lib/faye/protocol/subscription.rb

@@ -9,9 +9,25 @@ module Faye
       @cancelled = false
     end
 
+    def with_channel(&callback)
+      @with_channel = callback
+      self
+    end
+
+    def call(*args)
+      message = args.first
+
+      @callback.call(message['data']) if @callback
+      @with_channel.call(message['channel'], message['data']) if @with_channel
+    end
+
+    def to_proc
+      @to_proc ||= lambda { |*a| call(*a) }
+    end
+
     def cancel
       return if @cancelled
-      @client.unsubscribe(@channels, &@callback)
+      @client.unsubscribe(@channels, self)
       @cancelled = true
     end
 
@@ -21,4 +37,3 @@ module Faye
 
   end
 end
-

data/lib/faye/transport/http.rb

@@ -1,65 +1,75 @@
 module Faye
 
   class Transport::Http < Transport
-    def self.usable?(client, endpoint, &callback)
+    def self.usable?(dispatcher, endpoint, &callback)
       callback.call(URI === endpoint)
     end
 
-    def encode(envelopes)
-      Faye.to_json(envelopes.map { |e| e.message })
+    def encode(messages)
+      Faye.to_json(messages)
     end
 
-    def request(envelopes)
-      content = encode(envelopes)
-      params  = build_params(@endpoint, content)
+    def request(messages)
+      content = encode(messages)
+      params  = build_params(content)
       request = create_request(params)
 
       request.callback do
-        handle_response(request.response, envelopes)
+        handle_response(messages, request.response)
         store_cookies(request.response_header['SET_COOKIE'])
       end
 
       request.errback do
-        handle_error(envelopes)
+        handle_error(messages)
       end
+
+      request
     end
 
   private
 
-    def build_params(uri, content)
-      {
-        :head => {
-          'Content-Length'  => content.bytesize,
-          'Content-Type'    => 'application/json',
-          'Cookie'          => get_cookies,
-          'Host'            => uri.host
-        }.merge(@client.headers),
-
-        :body    => content,
-        :timeout => -1  # for em-http-request < 1.0
+    def build_params(content)
+      headers = {
+        'Content-Length' => content.bytesize,
+        'Content-Type'   => 'application/json',
+        'Host'           => @endpoint.host + (@endpoint.port ? ":#{ @endpoint.port }" : '')
+      }
+
+      params = {
+        :head => headers.merge(@dispatcher.headers),
+        :body => content
       }
+
+      cookie = get_cookies
+      params[:head]['Cookie'] = cookie unless cookie == ''
+
+      params
     end
 
     def create_request(params)
-      version = EventMachine::HttpRequest::VERSION.split('.')[0].to_i
-      client  = if version >= 1
-                  options = {                 # for em-http-request >= 1.0
-                    :inactivity_timeout => 0  # connection inactivity (post-setup) timeout (0 = disable timeout)
-                  }
-                  EventMachine::HttpRequest.new(@endpoint.to_s, options)
-                else
-                  EventMachine::HttpRequest.new(@endpoint.to_s)
-                end
+      options = {
+        :inactivity_timeout => 0,
+        :tls => @dispatcher.tls
+      }
+
+      if @proxy[:origin]
+        uri = URI(@proxy[:origin])
+        options[:proxy] = { :host => uri.host, :port => uri.port }
+        if uri.user
+          options[:proxy][:authorization] = [uri.user, uri.password]
+        end
+      end
 
+      client = EventMachine::HttpRequest.new(@endpoint.to_s, options)
       client.post(params)
     end
 
-    def handle_response(response, envelopes)
-      message = MultiJson.load(response) rescue nil
-      if message
-        receive(envelopes, message)
+    def handle_response(messages, response)
+      replies = MultiJson.load(response) rescue nil
+      if replies
+        receive(replies)
       else
-        handle_error(envelopes)
+        handle_error(messages)
       end
     end
   end