goshrine_bot 0.1.1 → 0.1.5

data/lib/goshrine_bot/faye/rack_adapter.rb

@@ -1,115 +0,0 @@
-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
-

data/lib/goshrine_bot/faye/server.rb

@@ -1,266 +0,0 @@
-module Faye
-  class Server
-    def initialize(options = {})
-      @options   = options
-      @channels  = Channel::Tree.new
-      @clients   = {}
-      @namespace = Namespace.new
-      @security_policy = options[:security_policy]
-    end
-    
-    # Notifies the server of stale connections that should be deleted
-    def update(message, client)
-      return unless message == :stale_client
-      destroy_client(client)
-    end
-    
-    def client_ids
-      @clients.keys
-    end
-    
-    def process(messages, transport_authentication = nil, local = false, &callback)
-      messages = [messages].flatten
-      processed, responses = 0, []
-      
-      messages.each do |message|
-        handle(message, transport_authentication, local) do |reply|
-          reply = [reply].flatten
-          responses.concat(reply)
-          processed += 1
-          callback[responses] if processed == messages.size
-        end
-      end
-    end
-    
-    def flush_connection(messages)
-      [messages].flatten.each do |message|
-        client = @clients[message['clientId']]
-        client.flush! if client
-      end
-    end
-    
-  private
-    
-    def connection(id)
-      return @clients[id] if @clients.has_key?(id)
-      client = Connection.new(id, @options)
-      client.add_observer(self)
-      @clients[id] = client
-    end
-    
-    def destroy_client(client)
-      client.disconnect!
-      client.delete_observer(self)
-      @namespace.release(client.id)
-      @clients.delete(client.id)
-    end
-    
-    def handle(message, transport_authentication = nil, local = false, &callback)
-      client_id = message['clientId']
-      channel   = message['channel']
-      
-      allowed_to_publish = local || @security_policy.nil? || Channel.meta?(channel) || @security_policy.can_publish(transport_authentication, channel, message)
-      
-      if !allowed_to_publish
-        response =  { 'channel'    => channel,
-                      'version'    => BAYEUX_VERSION,
-                      'id'         => message['id'],
-                      'error'      => Error.channel_forbidden(channel),
-                      'successful' => false }
-        return callback[response]
-      end
-            
-      @channels.glob(channel).each do |c| 
-        c << message 
-      end
-      
-      if Channel.meta?(channel)
-        response = __send__(Channel.parse(channel)[1], message, transport_authentication, local)
-        
-        client_id = response['clientId']
-        response['advice'] ||= {}
-        response['advice']['reconnect'] ||= @clients.has_key?(client_id) ? 'retry' : 'handshake'
-        response['advice']['interval']  ||= (Connection::INTERVAL * 1000).floor
-        
-        return callback[response] unless response['channel'] == Channel::CONNECT and
-                                         response['successful'] == true
-        
-        return connection(response['clientId']).connect(transport_authentication) do |events|
-          callback[[response] + events]
-        end
-      end
-      
-      return callback[[]] if message['clientId'].nil? or Channel.service?(channel)
-      
-      response = make_response(message)
-      response['successful'] = true
-      callback[response]
-    end
-    
-    def make_response(message)
-      response = {}
-      %w[id clientId channel].each do |field|
-        if message[field]
-          response[field] = message[field]
-        end
-      end
-      response
-    end
-    
-    # MUST contain  * version
-    #               * supportedConnectionTypes
-    # MAY contain   * minimumVersion
-    #               * ext
-    #               * id
-    def handshake(message, transport_authentication, local = false)
-      response = make_response(message)
-      response['version'] = BAYEUX_VERSION
-      
-      response['error'] = Error.parameter_missing('version') if message['version'].nil?
-      
-      unless local
-        response['supportedConnectionTypes'] = CONNECTION_TYPES
-        
-        client_conns = message['supportedConnectionTypes']
-
-        # This is a fix for the (non-spec following) cometd.js client
-        client_conns = client_conns.values if client_conns.is_a?(Hash)
- 
-        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
-      end
-      
-      response['successful'] = response['error'].nil?
-      return response unless response['successful']
-      
-      client_id = @namespace.generate
-      response['clientId'] = connection(client_id).id
-      connection_listener = @options[:connection_listener]
-      if connection_listener
-        connection_listener.connected(client_id, transport_authentication)
-      end
-      response
-    end
-    
-    # MUST contain  * clientId
-    #               * connectionType
-    # MAY contain   * ext
-    #               * id
-    def connect(message, transport_authentication, local = false)
-      response  = make_response(message)
-      
-      client_id = message['clientId']
-      client    = client_id ? @clients[client_id] : nil
-      
-      response['error'] = Error.client_unknown(client_id) if client.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('connectionType') if message['connectionType'].nil?
-      
-      response['successful'] = response['error'].nil?
-      response.delete('clientId') unless response['successful']
-      return response unless response['successful']
-      
-      response['clientId'] = client.id
-      response
-    end
-    
-    # MUST contain  * clientId
-    # MAY contain   * ext
-    #               * id
-    def disconnect(message, transport_authentication, local = false)
-      response  = make_response(message)
-      
-      client_id = message['clientId']
-      client    = client_id ? @clients[client_id] : nil
-      
-      response['error'] = Error.client_unknown(client_id) if client.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      
-      response['successful'] = response['error'].nil?
-      response.delete('clientId') unless response['successful']
-      return response unless response['successful']
-      
-      destroy_client(client)
-      
-      response['clientId'] = client_id
-      response
-    end
-    
-    # MUST contain  * clientId
-    #               * subscription
-    # MAY contain   * ext
-    #               * id
-    def subscribe(message, transport_authentication, local = false)
-      response      = make_response(message)
-      
-      client_id     = message['clientId']
-      client        = client_id ? @clients[client_id] : nil
-      
-      subscription  = message['subscription']
-      subscription  = [subscription].flatten
-      
-      response['error'] = Error.client_unknown(client_id) if client.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
-        
-      response['subscription'] = subscription.compact
-      
-      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)
-        if @security_policy
-          response['error'] = Error.channel_forbidden(channel) unless @security_policy.can_subscribe(transport_authentication, channel, message)
-        end
-        
-        next if response['error']
-        channel = @channels[channel] ||= Channel.new(channel)
-        client.subscribe(channel)
-      end
-      
-      response['successful'] = response['error'].nil?
-      response
-    end
-    
-    # MUST contain  * clientId
-    #               * subscription
-    # MAY contain   * ext
-    #               * id
-    def unsubscribe(message, transport_authentication, local = false)
-      response      = make_response(message)
-      
-      client_id     = message['clientId']
-      client        = client_id ? @clients[client_id] : nil
-      
-      subscription  = message['subscription']
-      subscription  = [subscription].flatten
-      
-      response['error'] = Error.client_unknown(client_id) if client.nil?
-      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
-      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
-      
-      response['subscription'] = subscription.compact
-      
-      subscription.each do |channel|
-        next if response['error']
-        
-        if not Channel.valid?(channel)
-          response['error'] = Error.channel_invalid(channel)
-          next
-        end
-        
-        channel = @channels[channel]
-        client.unsubscribe(channel) if channel
-      end
-      
-      response['successful'] = response['error'].nil?
-      response
-    end
-    
-  end
-end
-

data/lib/goshrine_bot/faye/timeouts.rb

@@ -1,21 +0,0 @@
-module Faye
-  module Timeouts
-    def add_timeout(name, delay, &block)
-      @timeouts ||= {}
-      return if @timeouts.has_key?(name)
-      @timeouts[name] = EventMachine.add_timer(delay) do
-        @timeouts.delete(name)
-        block.call
-      end
-    end
-    
-    def remove_timeout(name)
-      @timeouts ||= {}
-      timeout = @timeouts[name]
-      return if timeout.nil?
-      EventMachine.cancel_timer(timeout)
-      @timeouts.delete(name)
-    end
-  end
-end
-

data/lib/goshrine_bot/faye/transport.rb

@@ -1,123 +0,0 @@
-#require 'em-http'
-require 'json'
-require 'uri'
-
-module Faye
-  
-  class Transport
-    def initialize(client, endpoint, cookie = nil)
-      @client   = client
-      @endpoint = endpoint
-      @cookie = cookie
-    end
-    
-    def connection_type
-      self.class.connection_type
-    end
-    
-    def send(message, &block)
-      if message.is_a?(Hash) and not message.has_key?('id')
-        message['id'] = @client.namespace.generate
-      end
-      
-      request(message) { |responses|
-        if block_given?
-          messages, deliverable = [], true
-          [responses].flatten.each do |response|
-            
-            if message.is_a?(Hash) and response['id'] == message['id']
-              deliverable = false if block.call(response) == false
-            end
-            
-            if response['advice']
-              @client.handle_advice(response['advice'])
-            end
-            
-            if response['data'] and response['channel']
-              messages << response
-            end
-            
-          end
-          
-          @client.deliver_messages(messages) if deliverable
-        end
-      }
-    end
-    
-    @transports = {}
-    
-    class << self
-      attr_accessor :connection_type
-
-      def get(client, connection_types = nil)
-        endpoint = client.endpoint
-        connection_types ||= supported_connection_types
-
-        candidate_class = @transports.find do |type, klass|
-          connection_types.include?(type) and
-          klass.usable?(endpoint)
-        end
-
-        unless candidate_class
-          raise "Could not find a usable connection type for #{ endpoint }"
-        end
-
-        candidate_class.last.new(client, endpoint, client.cookie)
-      end
-      
-      def register(type, klass)
-        @transports[type] = klass
-        klass.connection_type = type
-      end
-      
-      def supported_connection_types
-        @transports.keys
-      end
-    end
-  end
-  
-  class HttpTransport < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(String)
-    end
-    
-    def request(message, &block)
-      content = JSON.unparse(message)
-      
-      url = URI.parse(@endpoint)
-      headers = {'Accept' => 'application/json', :host => url.host, :cookie => @cookie}
-      request = GoshrineBot::HttpClient.request(
-        :host => url.host,
-        :port => url.port,
-        :contenttype => 'application/json',
-        :request => url.path,
-        :verb => 'POST',
-        :content => content,
-        :custom_headers => headers)
-      
-      request.callback do |response|
-        begin
-          block.call(JSON.parse(response[:content]))
-        rescue JSON::ParserError => e
-          puts "Bad JSON: #{response[:content].inspect}"
-        end
-      end
-    end
-  end
-  Transport.register 'long-polling', HttpTransport
-  
-  class LocalTransport < Transport
-    def self.usable?(endpoint)
-      endpoint.is_a?(Server)
-    end
-    
-    def request(message, &block)
-      @endpoint.process(message, nil, true) do |response|
-        block.call(response)
-      end
-    end
-  end
-  Transport.register 'in-process', LocalTransport
-  
-end
-

data/lib/goshrine_bot/faye.rb

@@ -1,36 +0,0 @@
-# This is a hacked up (and old) version of jcoglan's excellent Faye library.
-# Hacks include adding cookie support (so we can use the cookies from a rails login),
-# and avoiding use of em-http-request
-
-require 'forwardable'
-require 'observer'
-require 'set'
-require 'rubygems'
-require 'eventmachine'
-
-module Faye
-  VERSION = '0.3.2'
-  
-  ROOT = File.expand_path(File.dirname(__FILE__))
-  
-  BAYEUX_VERSION   = '1.0'
-  ID_LENGTH        = 128
-  JSONP_CALLBACK   = 'jsonpcallback'
-  CONNECTION_TYPES = %w[long-polling callback-polling]
-  
-  %w[ timeouts grammar namespace
-      server channel connection
-      error client transport
-  ].each do |lib|
-    require File.join(ROOT, 'faye', lib)
-  end
-  
-  autoload :RackAdapter, File.join(ROOT, 'faye', 'rack_adapter')
-  
-  def self.random(bitlength = ID_LENGTH)
-    field  = 2 ** bitlength
-    strlen = bitlength / 4
-    ("%0#{strlen}s" % rand(field).to_s(16)).gsub(' ', '0')
-  end
-end
-