_bushido-faye 0.8.1

data/lib/faye/protocol/extensible.rb

@@ -0,0 +1,43 @@
+module Faye
+  module Extensible
+    include Logging
+    
+    def add_extension(extension)
+      @extensions ||= []
+      @extensions << extension
+      extension.added(self) if extension.respond_to?(:added)
+    end
+    
+    def remove_extension(extension)
+      return unless @extensions
+      @extensions.delete_if do |ext|
+        next false unless ext == extension
+        extension.removed(self) if extension.respond_to?(:removed)
+        true
+      end
+    end
+    
+    def pipe_through_extensions(stage, message, &callback)
+      debug 'Passing through ? extensions: ?', stage, message
+
+      return callback.call(message) unless @extensions
+      extensions = @extensions.dup
+      
+      pipe = lambda do |message|
+        next callback.call(message) unless message
+        
+        extension = extensions.shift
+        next callback.call(message) unless extension
+        
+        if extension.respond_to?(stage)
+          extension.__send__(stage, message, pipe)
+        else
+          pipe.call(message)
+        end
+      end
+      pipe.call(message)
+    end
+    
+  end
+end
+

data/lib/faye/protocol/grammar.rb

@@ -0,0 +1,58 @@
+module Faye
+  module Grammar
+    
+    def self.rule(&block)
+      source = instance_eval(&block)
+      %r{^#{string(source)}$}
+    end
+    
+    def self.choice(*list)
+      '(' + list.map(&method(:string)) * '|' + ')'
+    end
+    
+    def self.repeat(*pattern)
+      '(' + string(pattern) + ')*'
+    end
+    
+    def self.oneormore(*pattern)
+      '(' + string(pattern) + ')+'
+    end
+    
+    def self.string(item)
+      return item.map(&method(:string)) * '' if Array === item
+      String === item ? item : item.source.gsub(/^\^/, '').gsub(/\$$/, '')
+    end
+    
+    LOWALPHA          = rule {[ '[a-z]' ]}
+    UPALPHA           = rule {[ '[A-Z]' ]}
+    ALPHA             = rule {[ choice(LOWALPHA, UPALPHA) ]}
+    DIGIT             = rule {[ '[0-9]' ]}
+    ALPHANUM          = rule {[ choice(ALPHA, DIGIT) ]}
+    MARK              = rule {[ choice(*%w[\\- \\_ \\! \\~ \\( \\) \\$ \\@]) ]}
+    STRING            = rule {[ repeat(choice(ALPHANUM, MARK, ' ', '\\/', '\\*', '\\.')) ]}
+    TOKEN             = rule {[ oneormore(choice(ALPHANUM, MARK)) ]}
+    INTEGER           = rule {[ oneormore(DIGIT) ]}
+    
+    CHANNEL_SEGMENT   = rule {[ TOKEN ]}
+    CHANNEL_SEGMENTS  = rule {[ CHANNEL_SEGMENT, repeat('\\/', CHANNEL_SEGMENT) ]}
+    CHANNEL_NAME      = rule {[ '\\/', CHANNEL_SEGMENTS ]}
+    
+    WILD_CARD         = rule {[ '\\*{1,2}' ]}
+    CHANNEL_PATTERN   = rule {[ repeat('\\/', CHANNEL_SEGMENT), '\\/', WILD_CARD ]}
+    
+    VERSION_ELEMENT   = rule {[ ALPHANUM, repeat(choice(ALPHANUM, '\\-', '\\_')) ]}
+    VERSION           = rule {[ INTEGER, repeat('\\.', VERSION_ELEMENT) ]}
+    
+    CLIENT_ID         = rule {[ oneormore(ALPHANUM) ]}
+    
+    ID                = rule {[ oneormore(ALPHANUM) ]}
+    
+    ERROR_MESSAGE     = rule {[ STRING ]}
+    ERROR_ARGS        = rule {[ STRING, repeat(',', STRING) ]}
+    ERROR_CODE        = rule {[ DIGIT, DIGIT, DIGIT ]}
+    ERROR             = rule {[ choice(string([ERROR_CODE, ':', ERROR_ARGS, ':', ERROR_MESSAGE]),
+                                       string([ERROR_CODE, ':', ':', ERROR_MESSAGE])) ]}
+    
+  end
+end
+

data/lib/faye/protocol/publication.rb

@@ -0,0 +1,5 @@
+module Faye
+  class Publication
+    include EventMachine::Deferrable
+  end
+end

data/lib/faye/protocol/server.rb

@@ -0,0 +1,282 @@
+module Faye
+  class Server
+    
+    include Logging
+    include Extensible
+    
+    attr_reader :engine
+
+    def initialize(options = {})
+      @options    = options || {}
+      engine_opts = @options[:engine] || {}
+      engine_opts[:timeout] = @options[:timeout]
+      @engine     = Faye::Engine.get(engine_opts)
+
+      info 'Created new server: ?', @options
+    end
+    
+    def flush_connection(messages)
+      client_id = Faye.client_id_from_messages(messages)
+      info 'Flushing connection for ?', client_id
+      @engine.flush(client_id) if client_id
+    end
+    
+    def open_socket(client_id, socket)
+      @engine.open_socket(client_id, socket)
+    end
+    
+    def close_socket(client_id)
+      @engine.flush(client_id)
+    end
+    
+    def process(messages, local = false, &callback)
+      messages = [messages].flatten
+      info 'Processing messages: ? (local: ?)', messages, local
+
+      return callback.call([]) if messages.size == 0
+      processed, responses = 0, []
+      
+      gather_replies = lambda do |replies|
+        responses.concat(replies)
+        processed += 1
+        responses.compact!
+        info 'Returning replies: ?', responses
+        callback.call(responses) if processed == messages.size
+      end
+      
+      handle_reply = lambda do |replies|
+        extended, expected = 0, replies.size
+        gather_replies.call(replies) if expected == 0
+        
+        replies.each_with_index do |reply, i|
+          debug 'Processing reply: ?', reply
+          pipe_through_extensions(:outgoing, reply) do |message|
+            replies[i] = message
+            extended  += 1
+            gather_replies.call(replies) if extended == expected
+          end
+        end
+      end
+      
+      messages.each do |message|
+        pipe_through_extensions(:incoming, message) do |piped_message|
+          handle(piped_message, local, &handle_reply)
+        end
+      end
+    end
+    
+    def make_response(message)
+      response = {}
+      
+      response['id']       = message['id']       if message['id']
+      response['clientId'] = message['clientId'] if message['clientId']
+      response['channel']  = message['channel']  if message['channel']
+      response['error']    = message['error']    if message['error']
+      
+      response['successful'] = !response['error']
+      response
+    end
+    
+    def handle(message, local = false, &callback)
+      return callback.call([]) if !message
+      info 'Handling message: ? (local: ?)', message, local
+      
+      channel_name = message['channel']
+      error        = message['error']
+      
+      return handle_meta(message, local, &callback) if Channel.meta?(channel_name)
+      
+      if Grammar::CHANNEL_NAME !~ channel_name
+        error = Faye::Error.channel_invalid(channel_name)
+      end
+      
+      @engine.publish(message) unless error
+      
+      response = make_response(message)
+      response['error'] = error if error
+      response['successful'] = !response['error']
+      callback.call([response])
+    end
+    
+    def handle_meta(message, local, &callback)
+      method    = Channel.parse(message['channel'])[1]
+      client_id = message['clientId']
+      
+      __send__(method, message, local) do |responses|
+        responses = [responses].flatten
+        responses.each { |r| advize(r, message['connectionType']) }
+        callback.call(responses)
+      end
+    end
+    
+    def advize(response, connection_type)
+      return unless [Channel::HANDSHAKE, Channel::CONNECT].include?(response['channel'])
+      
+      if connection_type == 'eventsource'
+        interval = (@engine.timeout * 1000).floor
+        timeout  = 0
+      else
+        interval = (@engine.interval * 1000).floor
+        timeout  = (@engine.timeout * 1000).floor
+      end
+      
+      advice = response['advice'] ||= {}
+      if response['error']
+        advice['reconnect'] ||= 'handshake'
+      else
+        advice['reconnect'] ||= 'retry'
+        advice['interval']  ||= interval
+        advice['timeout']   ||= timeout
+      end
+    end
+    
+    # MUST contain  * version
+    #               * supportedConnectionTypes
+    # MAY contain   * minimumVersion
+    #               * ext
+    #               * id
+    def handshake(message, local = false, &callback)
+      response = make_response(message)
+      response['version'] = BAYEUX_VERSION
+      
+      response['error'] = Error.parameter_missing('version') if message['version'].nil?
+      
+      client_conns = message['supportedConnectionTypes']
+      
+      response['supportedConnectionTypes'] = CONNECTION_TYPES
+      
+      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
+      
+      response['successful'] = response['error'].nil?
+      return callback.call(response) unless response['successful']
+      
+      @engine.create_client do |client_id|
+        response['clientId'] = client_id
+        callback.call(response)
+      end
+    end
+    
+    # MUST contain  * clientId
+    #               * connectionType
+    # MAY contain   * ext
+    #               * id
+    def connect(message, local = false, &callback)
+      response        = make_response(message)
+      client_id       = message['clientId']
+      connection_type = message['connectionType']
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        
+        unless CONNECTION_TYPES.include?(connection_type)
+          response['error'] = Error.conntype_mismatch(connection_type)
+        end
+        
+        response['error'] = Error.parameter_missing('connectionType') if connection_type.nil?
+        
+        response['successful'] = response['error'].nil?
+        
+        if !response['successful']
+          response.delete('clientId')
+          next callback.call(response)
+        end
+        
+        if message['connectionType'] == 'eventsource'
+          message['advice'] ||= {}
+          message['advice']['timeout'] = 0
+        end
+        
+        @engine.connect(response['clientId'], message['advice']) do |events|
+          callback.call([response] + events)
+        end
+      end
+    end
+    
+    # MUST contain  * clientId
+    # MAY contain   * ext
+    #               * id
+    def disconnect(message, local = false, &callback)
+      response   = make_response(message)      
+      client_id  = message['clientId']
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        
+        response['successful'] = response['error'].nil?
+        response.delete('clientId') unless response['successful']
+        
+        @engine.destroy_client(client_id) if response['successful']
+        callback.call(response)
+      end
+    end
+    
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def subscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+        
+        response['subscription'] = message['subscription'] || []
+        
+        subscription.each do |channel|
+          next if response['error']
+          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']
+          @engine.subscribe(client_id, channel)
+        end
+        
+        response['successful'] = response['error'].nil?
+        callback.call(response)
+      end
+    end
+    
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def unsubscribe(message, local = false, &callback)
+      response     = make_response(message)
+      client_id    = message['clientId']
+      subscription = [message['subscription']].flatten
+      
+      @engine.client_exists(client_id) do |exists|
+        response['error'] = Error.client_unknown(client_id) unless exists
+        response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+        response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+        
+        response['subscription'] = message['subscription'] || []
+        
+        subscription.each do |channel|
+          next if response['error']
+          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']
+          @engine.unsubscribe(client_id, channel)
+        end
+        
+        response['successful'] = response['error'].nil?
+        callback.call(response)
+      end
+    end
+    
+  end
+end
+

data/lib/faye/protocol/subscription.rb

@@ -0,0 +1,24 @@
+module Faye
+  class Subscription
+    include EventMachine::Deferrable
+    
+    def initialize(client, channels, callback)
+      @client    = client
+      @channels  = channels
+      @callback  = callback
+      @cancelled = false
+    end
+    
+    def cancel
+      return if @cancelled
+      @client.unsubscribe(@channels, &@callback)
+      @cancelled = true
+    end
+    
+    def unsubscribe
+      cancel
+    end
+    
+  end
+end
+

data/lib/faye/transport/http.rb

@@ -0,0 +1,76 @@
+module Faye
+  
+  class Transport::Http < Transport
+    def self.usable?(endpoint, &callback)
+      callback.call(endpoint.is_a?(String))
+    end
+    
+    def request(message, timeout)
+      retry_block = retry_block(message, timeout)
+      
+      content = Faye.to_json(message)
+      cookies = @cookies.get_cookies(@endpoint)
+      params  = build_params(URI.parse(@endpoint), content, cookies)
+      request = create_request(params)
+      
+      request.callback do
+        handle_response(request.response, retry_block)
+        store_cookies([*request.response_header['SET_COOKIE']].compact)
+      end
+      request.errback do
+        retry_block.call
+        trigger(:down)
+      end
+    end
+    
+  private
+    
+    def build_params(uri, content, cookies)
+      {
+        :head => {
+          'Content-Length'  => content.bytesize,
+          'Content-Type'    => 'application/json',
+          'Cookie'          => cookies * '; ',
+          'Host'            => uri.host
+        }.merge(@headers),
+        
+        :body    => content,
+        :timeout => -1  # for em-http-request < 1.0
+      }
+    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, options)
+                else
+                  EventMachine::HttpRequest.new(@endpoint)
+                end
+      
+      client.post(params)
+    end
+    
+    def handle_response(response, retry_block)
+      message = Yajl::Parser.parse(response) rescue nil
+      if message
+        receive(message)
+        trigger(:up)
+      else
+        retry_block.call
+        trigger(:down)
+      end
+    end
+    
+    def store_cookies(cookies)
+      cookies.each do |cookie|
+        @cookies.set_cookie(@endpoint, cookie)
+      end
+    end
+  end
+  
+  Transport.register 'long-polling', Transport::Http
+  
+end