goshrine_bot 0.1.0

data/lib/goshrine_bot/faye/client.rb

@@ -0,0 +1,283 @@
+module Faye
+  class Client
+    include EventMachine::Deferrable
+    include Timeouts
+    
+    UNCONNECTED         = 1
+    CONNECTING          = 2
+    CONNECTED           = 3
+    DISCONNECTED        = 4
+    
+    HANDSHAKE           = 'handshake'
+    RETRY               = 'retry'
+    NONE                = 'none'
+    
+    CONNECTION_TIMEOUT  = 60.0
+    
+    attr_reader :endpoint, :namespace, :cookie
+    
+    def initialize(endpoint = nil, options = {})
+      @endpoint  = endpoint || RackAdapter::DEFAULT_ENDPOINT
+      @options   = options
+      @timeout   = @options[:timeout] || CONNECTION_TIMEOUT
+      @cookie    = @options[:cookie]
+      
+      @transport = Transport.get(self)
+      @state     = UNCONNECTED
+      @namespace = Namespace.new
+      @outbox    = []
+      @channels  = Channel::Tree.new
+      @current_id = 0
+      
+      @advice = {'reconnect' => RETRY, 'interval' => Connection::INTERVAL}
+    end
+    
+    # Request
+    # MUST include:  * channel
+    #                * version
+    #                * supportedConnectionTypes
+    # MAY include:   * minimumVersion
+    #                * ext
+    #                * id
+    # 
+    # Success Response                             Failed Response
+    # MUST include:  * channel                     MUST include:  * channel
+    #                * version                                    * successful
+    #                * supportedConnectionTypes                   * error
+    #                * clientId                    MAY include:   * supportedConnectionTypes
+    #                * successful                                 * advice
+    # MAY include:   * minimumVersion                             * version
+    #                * advice                                     * minimumVersion
+    #                * ext                                        * ext
+    #                * id                                         * id
+    #                * authSuccessful
+    def handshake(&block)
+      return if @advice['reconnect'] == NONE
+      return if @state != UNCONNECTED
+      
+      @state = CONNECTING
+      @transport.send({
+        'channel'     => Channel::HANDSHAKE,
+        'version'     => BAYEUX_VERSION,
+        'supportedConnectionTypes' => Transport.supported_connection_types
+        
+      }) do |response|
+        unless response['successful']
+          EventMachine.add_timer(@advice['interval'] / 1000.0) { handshake(&block) }
+          return @state = UNCONNECTED
+        end
+        
+        @state     = CONNECTED
+        @client_id = response['clientId']
+        @transport = Transport.get(self, response['supportedConnectionTypes'])
+        
+        block.call if block_given?
+      end
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * connectionType                     * clientId
+    # MAY include:   * ext                 MAY include:   * error
+    #                * id                                 * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def connect(&block)
+      
+      return if @advice['reconnect'] == NONE or
+                @state == DISCONNECTED
+      
+      if @advice['reconnect'] == HANDSHAKE or @state == UNCONNECTED
+        begin_reconnect_timeout
+        return handshake { connect(&block) }
+      end
+      
+      return callback(&block) if @state == CONNECTING
+      return unless @state == CONNECTED
+      
+      set_deferred_status(:succeeded)
+      set_deferred_status(:deferred)
+      block.call if block_given?
+      
+      return unless @connection_id.nil?
+      
+      @connection_id = @namespace.generate
+      @transport.send({
+        'channel'         => Channel::CONNECT,
+        'clientId'        => @client_id,
+        'connectionType'  => @transport.connection_type,
+        'id'              => @connection_id
+        
+      }, &verify_client_id { |response|
+        @namespace.release(@connection_id) if @connection_id
+        @connection_id = nil
+        remove_timeout(:reconnect)
+        EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
+      })
+      
+      begin_reconnect_timeout
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    # MAY include:   * ext                                * clientId
+    #                * id                  MAY include:   * error
+    #                                                     * ext
+    #                                                     * id
+    def disconnect
+      return unless @state == CONNECTED
+      @state = DISCONNECTED
+      
+      @transport.send({
+        'channel'   => Channel::DISCONNECT,
+        'clientId'  => @client_id
+      })
+      
+      @channels = Channel::Tree.new
+      remove_timeout(:reconnect)
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def subscribe(channels, &block)
+      connect {
+        channels = [channels].flatten
+        validate_channels(channels)
+        
+        @transport.send({
+          'channel'       => Channel::SUBSCRIBE,
+          'clientId'      => @client_id,
+          'subscription'  => channels
+          
+        }, &verify_client_id { |response|
+          if response['successful'] and block
+            channels = [response['subscription']].flatten
+            channels.each { |channel| @channels[channel] = block }
+          end
+        })
+      }
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def unsubscribe(channels, &block)
+      connect {
+        channels = [channels].flatten
+        validate_channels(channels)
+        
+        @transport.send({
+          'channel'       => Channel::UNSUBSCRIBE,
+          'clientId'      => @client_id,
+          'subscription'  => channels
+          
+        }, &verify_client_id { |response|
+          if response['successful']
+            channels = [response['subscription']].flatten
+            channels.each { |channel| @channels[channel] = nil }
+          end
+        })
+      }
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * data                               * successful
+    # MAY include:   * clientId            MAY include:   * id
+    #                * id                                 * error
+    #                * ext                                * ext
+    def publish(channel, data, id=nil)
+      connect {
+        validate_channels([channel])
+        
+        enqueue({
+          'id'        => (id || next_id),
+          'channel'   => channel,
+          'data'      => data,
+          'clientId'  => @client_id
+        })
+        
+        add_timeout(:publish, Connection::MAX_DELAY) { flush! }
+      }
+    end
+    
+    def handle_error(msg_id, error)
+      puts "Message #{msg_id} Error #{error}"
+    end
+    
+    def handle_advice(advice)
+      @advice.update(advice)
+      @client_id = nil if @advice['reconnect'] == HANDSHAKE
+    end
+    
+    def deliver_messages(messages)
+      messages.each do |message|
+        channels = @channels.glob(message['channel'])
+        channels.each { |callback| callback.call(message['data']) }
+      end
+    end
+    
+  private
+    
+    def begin_reconnect_timeout
+      add_timeout(:reconnect, @timeout) do
+        @namespace.release(@connection_id) if @connection_id
+        @connection_id = nil
+        @client_id = nil
+        @state = UNCONNECTED
+        subscribe(@channels.keys)
+      end
+    end
+    
+    def enqueue(message)
+      @outbox << message
+    end
+    
+    def flush!
+      @transport.send(@outbox)
+      @outbox = []
+    end
+    
+    def next_id
+      @current_id += 1
+    end
+    
+    def validate_channels(channels)
+      channels.each do |channel|
+        raise "'#{ channel }' is not a valid channel name" unless Channel.valid?(channel)
+        raise "Clients may not subscribe to channel '#{ channel }'" unless Channel.subscribable?(channel)
+      end
+    end
+    
+    def verify_client_id(&block)
+      lambda do |response|
+        if response['clientId'] != @client_id
+          false
+        else
+          block.call(response)
+          true
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/goshrine_bot/faye/connection.rb

@@ -0,0 +1,122 @@
+module Faye
+  class Connection
+    include EventMachine::Deferrable
+    include Observable
+    include Timeouts
+    
+    MAX_DELAY = 0.1
+    INTERVAL  = 0.4
+    TIMEOUT   = 60.0
+    
+    attr_reader :id
+    
+    def initialize(id, options = {})
+      @id        = id
+      @options   = options
+      @timeout   = @options[:timeout] || TIMEOUT
+      @channels  = Set.new
+      @inbox     = Set.new
+      @connected = false
+      @connection_listener = options[:connection_listener]
+      
+      # This is for clients that subscribe, but never re-connect to get messages
+      # (prevents a memory leak)
+      add_timeout(:deletion, 60 * INTERVAL) do
+        puts "Deleting orphaned connection: #{@id}"
+        delete
+      end
+      
+    end
+    
+    def update(message, event)
+      return unless message == :message
+      @inbox.add(event)
+      begin_delivery_timeout!
+    end
+    
+    def subscribe(channel)
+      if @channels.add?(channel)
+        channel.add_observer(self)
+        if @options[:subscription_listener]
+          @options[:subscription_listener].subscribed(self, channel)
+        end
+      end
+    end
+    
+    def unsubscribe(channel)
+      return @channels.each(&method(:unsubscribe)) if channel == :all
+      return unless @channels.member?(channel)
+      @channels.delete(channel)
+      channel.delete_observer(self)
+      if @options[:subscription_listener]
+        @options[:subscription_listener].unsubscribed(self, channel)
+      end
+    end
+    
+    def connect(transport_authentication, &block)
+      callback(&block)
+      return if @connected
+      
+      @connected = true
+      
+      if @connection_listener
+        @connection_listener.connected(id, transport_authentication)
+      end
+      
+      remove_timeout(:deletion)
+      
+      begin_delivery_timeout!
+      begin_connection_timeout!
+    end
+    
+    def flush!
+      return unless @connected
+      release_connection!
+      
+      events = @inbox.entries
+      @inbox = Set.new
+      
+      set_deferred_status(:succeeded, events)
+      set_deferred_status(:deferred)
+    end
+    
+    def disconnect!
+      unsubscribe(:all)
+      flush!
+    end
+    
+  private
+    
+    def begin_delivery_timeout!
+      if @delivery_timeout.nil? && @connected && (!@inbox.empty? || @channels.empty?)
+        add_timeout(:delivery, MAX_DELAY) { flush! }
+      end
+    end
+    
+    def begin_connection_timeout!
+      return unless @connection_timeout.nil? and @connected
+      add_timeout(:connection, @timeout) { flush! }
+    end
+    
+    def delete
+      unsubscribe(:all)
+      if @connection_listener
+        @connection_listener.disconnected(id)
+      end
+      changed(true)
+      notify_observers(:stale_client, self)
+    end
+    
+    def release_connection!
+      remove_timeout(:connection)
+      remove_timeout(:delivery)
+      @connected = false
+      
+      add_timeout(:deletion, 10 * INTERVAL) do
+        delete
+      end
+    end
+    
+  end
+end
+

data/lib/goshrine_bot/faye/error.rb

@@ -0,0 +1,44 @@
+module Faye
+  class Error
+    
+    def self.parse(string)
+      return nil unless Grammar::ERROR =~ string
+      parts = string.split(':')
+      args  = parts[1].split(',')
+      new(parts[0].to_i, args, parts[2])
+    end
+    
+    def self.method_missing(type, *args)
+      code = const_get(type.to_s.upcase)
+      new(code[0], args, code[1]).to_s
+    end
+    
+    attr_reader :code, :args, :message
+    
+    def initialize(code, args, message)
+      @code     = code
+      @args     = args
+      @message  = message
+    end
+    
+    def to_s
+      "#{ @code }:#{ @args * ',' }:#{ @message }"
+    end
+    
+    # http://code.google.com/p/cometd/wiki/BayeuxCodes
+    VERSION_MISMATCH    = [300, 'Version mismatch']
+    CONNTYPE_MISMATCH   = [301, 'Connection types not supported']
+    EXT_MISMATCH        = [302, 'Extension mismatch']
+    BAD_REQUEST         = [400, 'Bad request']
+    CLIENT_UNKNOWN      = [401, 'Unknown client']
+    PARAMETER_MISSING   = [402, 'Missing required parameter']
+    CHANNEL_FORBIDDEN   = [403, 'Forbidden channel']
+    CHANNEL_UNKNOWN     = [404, 'Unknown channel']
+    CHANNEL_INVALID     = [405, 'Invalid channel']
+    EXT_UNKNOWN         = [406, 'Unknown extension']
+    PUBLISH_FAILED      = [407, 'Failed to publish']
+    SERVER_ERROR        = [500, 'Internal server error']
+    
+  end
+end
+

data/lib/goshrine_bot/faye/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/goshrine_bot/faye/namespace.rb

@@ -0,0 +1,20 @@
+module Faye
+  class Namespace
+    
+    def initialize
+      @used = {}
+    end
+    
+    def generate
+      name = Faye.random
+      name = Faye.random while @used.has_key?(name)
+      @used[name] = name
+    end
+    
+    def release(name)
+      @used.delete(name)
+    end
+
+  end
+end
+

data/lib/goshrine_bot/faye/rack_adapter.rb

@@ -0,0 +1,115 @@
+require 'rubygems'
+require 'rack'
+require 'thin'
+require 'json'
+
+module Faye
+  class AlwaysEmptyHash
+    def initialize
+      @h = {}
+    end
+    
+    def method_missing(m, *args)
+      @h.send(m, *args)
+    end
+    
+    def []=(key,value)
+    end
+  end
+  
+  class RackAdapter
+    
+    # Only supported under Thin
+    ASYNC_RESPONSE = [-1, AlwaysEmptyHash.new, []].freeze
+    
+    DEFAULT_ENDPOINT  = '/bayeux'
+    SCRIPT_PATH       = File.join(ROOT, 'faye-client-min.js')
+    
+    TYPE_JSON   = {'Content-Type' => 'application/json'}
+    TYPE_SCRIPT = {'Content-Type' => 'text/javascript'}
+    TYPE_TEXT   = {'Content-Type' => 'text/plain'}
+    
+    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)
+    end
+    
+    def get_client
+      @client ||= Client.new(@server)
+    end
+    
+    def run(port)
+      handler = Rack::Handler.get('thin')
+      handler.run(self, :Port => port)
+    end
+    
+    def call(env)
+      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
+      
+      if request.path_info =~ /\.js$/
+        return [200, TYPE_SCRIPT, File.new(SCRIPT_PATH)]
+      end
+      
+      begin
+        json_msg = request.post? ? request.body.read : request.params['message']
+        message  = JSON.parse(json_msg)
+        jsonp    = request.params['jsonp'] || JSONP_CALLBACK
+        
+        @server.flush_connection(message) if request.get?
+        
+        on_response(env, message) do |replies|
+          response = JSON.unparse(replies)
+          response = "#{ jsonp }(#{ response });" if request.get?
+          response
+        end
+      rescue Exception => e
+        puts "Caught #{e.message}: " + e.backtrace.join("\n")
+        [400, TYPE_TEXT, 'Bad request']
+      end
+    end
+    
+  private
+    
+    def on_response(env, message, &block)
+      request  = Rack::Request.new(env)
+      type     = request.get? ? TYPE_SCRIPT : TYPE_JSON
+      callback = env['async.callback']
+      transport_authentication = env['faye.transport_authentication']
+      
+      if callback
+        body = DeferredBody.new
+        callback.call [200, type, body]
+        @server.process(message, transport_authentication, false) { |r| body.succeed block.call(r) }
+        return ASYNC_RESPONSE
+      end
+      
+      response = nil
+      @server.process(message, transport_authentication, false) { |r| response = block.call(r) }
+      sleep(0.1) while response.nil?
+      [200, type, [response]]
+    end
+    
+    def ensure_reactor_running!
+      Thread.new { EM.run } unless EM.reactor_running?
+      while not EM.reactor_running?; end
+    end
+    
+    class DeferredBody
+      include EventMachine::Deferrable
+      alias :each :callback
+    end
+    
+  end
+end
+