faye 0.7.2 → 0.8.0

data/lib/faye/engines/base.rb

@@ -1,66 +0,0 @@
-module Faye
-  module Engine
-    
-    MAX_DELAY = 0.0
-    INTERVAL  = 0.0
-    TIMEOUT   = 60.0
-    
-    def self.register(type, klass)
-      @backends ||= {}
-      @backends[type] = klass
-    end
-    
-    def self.get(options)
-      options ||= {}
-      klass = @backends[options[:type]] || Memory
-      klass.new(options)
-    end
-    
-    class Base
-      include Publisher
-      include Logging
-      
-      attr_reader :interval, :timeout
-      
-      def initialize(options)
-        @options     = options
-        @connections = {}
-        @interval    = @options[:interval] || INTERVAL
-        @timeout     = @options[:timeout]  || TIMEOUT
-
-        debug 'Created new engine: ?', @options
-      end
-      
-      def connect(client_id, options = {}, &callback)
-        debug 'Accepting connection from ?', client_id
-        ping(client_id)
-        conn = connection(client_id, true)
-        conn.connect(options, &callback)
-        empty_queue(client_id)
-      end
-      
-      def connection(client_id, create)
-        conn = @connections[client_id]
-        return conn if conn or not create
-        @connections[client_id] = Connection.new(self, client_id)
-      end
-      
-      def close_connection(client_id)
-        debug 'Closing connection for ?', client_id
-        @connections.delete(client_id)
-      end
-      
-      def flush(client_id)
-        debug 'Flushing message queue for ?', client_id
-        conn = @connections[client_id]
-        conn.flush! if conn
-      end
-    end
-    
-    %w[connection memory redis].each do |type|
-      require File.join(ROOT, 'faye', 'engines', type)
-    end
-    
-  end
-end
-

data/lib/faye/engines/redis.rb

@@ -1,225 +0,0 @@
-module Faye
-  module Engine
-
-    class Redis < Base
-      DEFAULT_HOST     = 'localhost'
-      DEFAULT_PORT     = 6379
-      DEFAULT_DATABASE = 0
-      DEFAULT_GC       = 60
-      LOCK_TIMEOUT     = 120
-      
-      def init
-        return if @redis
-        require 'em-hiredis'
-        
-        host   = @options[:host]      || DEFAULT_HOST
-        port   = @options[:port]      || DEFAULT_PORT
-        db     = @options[:database]  || 0
-        auth   = @options[:password]
-        gc     = @options[:gc]        || DEFAULT_GC
-        @ns    = @options[:namespace] || ''
-        socket = @options[:socket]
-        
-        if socket
-          @redis      = EventMachine::Hiredis::Client.connect(socket, nil)
-          @subscriber = EventMachine::Hiredis::Client.connect(socket, nil)
-        else
-          @redis      = EventMachine::Hiredis::Client.connect(host, port)
-          @subscriber = EventMachine::Hiredis::Client.connect(host, port)
-        end
-        
-        if auth
-          @redis.auth(auth)
-          @subscriber.auth(auth)
-        end
-        @redis.select(db)
-        @subscriber.select(db)
-        
-        @subscriber.subscribe(@ns + '/notifications')
-        @subscriber.on(:message) do |topic, message|
-          empty_queue(message) if topic == @ns + '/notifications'
-        end
-        
-        @gc = EventMachine.add_periodic_timer(gc, &method(:gc))
-      end
-      
-      def disconnect
-        @subscriber.unsubscribe(@ns + '/notifications')
-        EventMachine.cancel_timer(@gc)
-      end
-      
-      def create_client(&callback)
-        init
-        client_id = Faye.random
-        @redis.zadd(@ns + '/clients', 0, client_id) do |added|
-          if added == 0
-            create_client(&callback)
-          else
-            debug 'Created new client ?', client_id
-            ping(client_id)
-            callback.call(client_id)
-            trigger(:handshake, client_id)
-          end
-        end
-      end
-      
-      def destroy_client(client_id, &callback)
-        init
-        @redis.zrem(@ns + '/clients', client_id)
-        @redis.del(@ns + "/clients/#{client_id}/messages")
-        
-        @redis.smembers(@ns + "/clients/#{client_id}/channels") do |channels|
-          n, i = channels.size, 0
-          if n == 0
-            debug 'Destroyed client ?', client_id
-            callback.call if callback
-            trigger(:disconnect, client_id)
-          else
-            channels.each do |channel|
-              unsubscribe(client_id, channel) do
-                i += 1
-                if i == n
-                  debug 'Destroyed client ?', client_id
-                  callback.call if callback
-                  trigger(:disconnect, client_id)
-                end
-              end
-            end
-          end
-        end
-      end
-      
-      def client_exists(client_id, &callback)
-        init
-        @redis.zscore(@ns + '/clients', client_id) do |score|
-          callback.call(score != nil)
-        end
-      end
-      
-      def ping(client_id)
-        init
-        return unless Numeric === @timeout
-        
-        time = get_current_time
-        debug 'Ping ?, ?', client_id, time
-        @redis.zadd(@ns + '/clients', time, client_id)
-      end
-      
-      def subscribe(client_id, channel, &callback)
-        init
-        @redis.sadd(@ns + "/clients/#{client_id}/channels", channel) do |added|
-          trigger(:subscribe, client_id, channel) if added == 1
-        end
-        @redis.sadd(@ns + "/channels#{channel}", client_id) do
-          debug 'Subscribed client ? to channel ?', client_id, channel
-          callback.call if callback
-        end
-      end
-      
-      def unsubscribe(client_id, channel, &callback)
-        init
-        @redis.srem(@ns + "/clients/#{client_id}/channels", channel) do |removed|
-          trigger(:unsubscribe, client_id, channel) if removed == 1
-        end
-        @redis.srem(@ns + "/channels#{channel}", client_id) do
-          debug 'Unsubscribed client ? from channel ?', client_id, channel
-          callback.call if callback
-        end
-      end
-      
-      def publish(message)
-        init
-        debug 'Publishing message ?', message
-        
-        json_message = JSON.dump(message)
-        channels     = Channel.expand(message['channel'])
-        keys         = channels.map { |c| @ns + "/channels#{c}" }
-        
-        @redis.sunion(*keys) do |clients|
-          clients.each do |client_id|
-            debug 'Queueing for client ?: ?', client_id, message
-            @redis.rpush(@ns + "/clients/#{client_id}/messages", json_message)
-            @redis.publish(@ns + '/notifications', client_id)
-          end
-        end
-        
-        trigger(:publish, message['clientId'], message['channel'], message['data'])
-      end
-      
-    private
-      
-      def get_current_time
-        (Time.now.to_f * 1000).to_i
-      end
-      
-      def empty_queue(client_id)
-        return unless conn = connection(client_id, false)
-        init
-        
-        key = @ns + "/clients/#{client_id}/messages"
-        
-        @redis.multi
-        @redis.lrange(key, 0, -1)
-        @redis.del(key)
-        @redis.exec.callback  do |json_messages, deleted|
-          json_messages.each do |json_message|
-            conn.deliver(JSON.parse(json_message))
-          end
-        end
-      end
-      
-      def gc
-        return unless Numeric === @timeout
-        with_lock 'gc' do |release_lock|
-          cutoff = get_current_time - 1000 * 2 * @timeout
-          @redis.zrangebyscore(@ns + '/clients', 0, cutoff) do |clients|
-            i, n = 0, clients.size
-            if i == n
-              release_lock.call
-            else
-              clients.each do |client_id|
-                destroy_client(client_id) do
-                  i += 1
-                  release_lock.call if i == n
-                end
-              end
-            end
-          end
-        end
-      end
-      
-      def with_lock(lock_name, &block)
-        lock_key     = @ns + '/locks/' + lock_name
-        current_time = get_current_time
-        expiry       = current_time + LOCK_TIMEOUT * 1000 + 1
-        
-        release_lock = lambda do
-          @redis.del(lock_key) if get_current_time < expiry
-        end
-        
-        @redis.setnx(lock_key, expiry) do |set|
-          if set == 1
-            block.call(release_lock)
-          else
-            
-            @redis.get(lock_key) do |timeout|
-              if timeout
-                lock_timeout = timeout.to_i(10)
-                if lock_timeout < current_time
-                  @redis.getset(lock_key, expiry) do |old_value|
-                    block.call(release_lock) if old_value == timeout
-                  end
-                end
-              end
-            end
-            
-          end
-        end
-      end
-      
-    end
-    
-    register 'redis', Redis
-    
-  end
-end

data/lib/faye/thin_extensions.rb

@@ -1,75 +0,0 @@
-# WebSocket extensions for Thin
-# Based on code from the Cramp project
-# http://github.com/lifo/cramp
-
-# Copyright (c) 2009-2011 Pratik Naik
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-class Thin::Connection
-  def receive_data(data)
-    trace { data }
-
-    case @serving
-    when :websocket
-      callback = @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK]
-      callback.call(data) if callback
-    else
-      if @request.parse(data)
-        if @request.websocket?
-          @request.env['em.connection'] = self
-          @response.persistent!
-          @response.websocket = true
-          @serving = :websocket
-        end
-
-        process
-      end
-    end
-  rescue Thin::InvalidRequest => e
-    log "!! Invalid request"
-    log_error e
-    close_connection
-  end
-end
-
-class Thin::Request
-  WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
-  def websocket?
-    @env['HTTP_CONNECTION'] and
-    @env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
-    ['WebSocket', 'websocket'].include?(@env['HTTP_UPGRADE'])
-  end
-end
-
-class Thin::Response
-  # Headers for sending Websocket upgrade
-  attr_accessor :websocket
-
-  def each
-    yield(head) unless websocket
-    if @body.is_a?(String)
-      yield @body
-    else
-      @body.each { |chunk| yield chunk }
-    end
-  end
-end
-

data/lib/faye/util/web_socket.rb

@@ -1,89 +0,0 @@
-module Faye
-  class WebSocket
-    
-    root = File.expand_path('..', __FILE__) + '/web_socket'
-    
-    autoload :API,             root + '/api'
-    autoload :Client,          root + '/client'
-    autoload :Draft75Parser,   root + '/draft75_parser'
-    autoload :Draft76Parser,   root + '/draft76_parser'
-    autoload :Protocol8Parser, root + '/protocol8_parser'
-    
-    attr_reader :env
-    include API
-    
-    extend Forwardable
-    def_delegators :@parser, :version
-    
-    def self.parser(env)
-      if env['HTTP_SEC_WEBSOCKET_VERSION']
-        Protocol8Parser
-      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
-        Draft76Parser
-      else
-        Draft75Parser
-      end
-    end
-    
-    def initialize(env)
-      @env      = env
-      @callback = @env['async.callback']
-      @stream   = Stream.new(self, @env['em.connection'])
-      @callback.call [200, RackAdapter::TYPE_JSON, @stream]
-      
-      @url = determine_url
-      @ready_state = CONNECTING
-      @buffered_amount = 0
-      
-      @parser = WebSocket.parser(@env).new(self)
-      @stream.write(@parser.handshake_response)
-      
-      @ready_state = OPEN
-      
-      event = Event.new('open')
-      event.init_event('open', false, false)
-      dispatch_event(event)
-      
-      @env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK] = @parser.method(:parse)
-    end
-    
-  private
-    
-    def determine_url
-      secure = if @env.has_key?('HTTP_X_FORWARDED_PROTO')
-                 @env['HTTP_X_FORWARDED_PROTO'] == 'https'
-               else
-                 @env['HTTP_ORIGIN'] =~ /^https:/i
-               end
-      
-      scheme = secure ? 'wss:' : 'ws:'
-      "#{ scheme }//#{ @env['HTTP_HOST'] }#{ @env['REQUEST_URI'] }"
-    end
-  end
-  
-  class WebSocket::Stream
-    include EventMachine::Deferrable
-    
-    extend Forwardable
-    def_delegators :@connection, :close_connection, :close_connection_after_writing
-    
-    def initialize(web_socket, connection)
-      @web_socket = web_socket
-      @connection = connection
-    end
-    
-    def each(&callback)
-      @data_callback = callback
-    end
-    
-    def fail
-      @web_socket.close(1006, '', false)
-    end
-    
-    def write(data)
-      return unless @data_callback
-      @data_callback.call(data)
-    end
-  end
-  
-end