_bushido-faye-websocket 0.4.4

data/lib/faye/adapters/thin.rb

@@ -0,0 +1,62 @@
+# 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
+  attr_accessor :socket_stream
+  
+  alias :thin_process      :process
+  alias :thin_receive_data :receive_data
+  
+  def process
+    if @serving != :websocket and @request.websocket?
+      @serving = :websocket
+    end
+    if @request.async_connection?
+      @request.env['em.connection'] = self
+      @response.persistent!
+      @response.async = true
+    end
+    thin_process
+  end
+  
+  def receive_data(data)
+    return thin_receive_data(data) unless @serving == :websocket
+    socket_stream.receive(data) if socket_stream
+  end
+end
+
+class Thin::Request
+  include Faye::WebSocket::Adapter
+end
+
+class Thin::Response
+  attr_accessor :async
+  alias :thin_head :head
+  
+  def head
+    async ? '' : thin_head
+  end
+end
+

data/lib/faye/eventsource.rb

@@ -0,0 +1,124 @@
+require File.expand_path('../websocket', __FILE__) unless defined?(Faye::WebSocket)
+
+module Faye
+  class EventSource
+    DEFAULT_RETRY = 5
+    
+    include WebSocket::API
+    attr_reader :env, :url, :ready_state
+    
+    def self.eventsource?(env)
+      accept = (env['HTTP_ACCEPT'] || '').split(/\s*,\s*/)
+      accept.include?('text/event-stream')
+    end
+    
+    def self.determine_url(env)
+      secure = if env.has_key?('HTTP_X_FORWARDED_PROTO')
+                 env['HTTP_X_FORWARDED_PROTO'] == 'https'
+               else
+                 env['HTTP_ORIGIN'] =~ /^https:/i
+               end
+      
+      scheme = secure ? 'https:' : 'http:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+    end
+    
+    def initialize(env, options = {})
+      @env    = env
+      @ping   = options[:ping]
+      @retry  = (options[:retry] || DEFAULT_RETRY).to_f
+      @url    = EventSource.determine_url(env)
+      @stream = Stream.new(self)
+      
+      @ready_state = CONNECTING
+      @send_buffer = []
+      EventMachine.next_tick { open }
+      
+      callback = @env['async.callback']
+      callback.call([101, {}, @stream])
+      
+      @stream.write("HTTP/1.1 200 OK\r\n" +
+                    "Content-Type: text/event-stream\r\n" +
+                    "Cache-Control: no-cache, no-store\r\n" +
+                    "Connection: close\r\n" +
+                    "\r\n\r\n" +
+                    "retry: #{ (@retry * 1000).floor }\r\n\r\n")
+      
+      @ready_state = OPEN
+      
+      if @ping
+        @ping_timer = EventMachine.add_periodic_timer(@ping) { ping }
+      end
+    end
+    
+    def last_event_id
+      @env['HTTP_LAST_EVENT_ID'] || ''
+    end
+    
+    def rack_response
+      [ -1, {}, [] ]
+    end
+    
+    def send(message, options = {})
+      return false unless @ready_state == OPEN
+      
+      message = WebSocket.encode(message.to_s).
+                gsub(/(\r\n|\r|\n)/, '\1data: ')
+      
+      frame  = ""
+      frame << "event: #{options[:event]}\r\n" if options[:event]
+      frame << "id: #{options[:id]}\r\n" if options[:id]
+      frame << "data: #{message}\r\n\r\n"
+      
+      @stream.write(frame)
+      true
+    end
+    
+    def ping(message = nil)
+      @stream.write(":\r\n\r\n")
+      true
+    end
+    
+    def close
+      return if [CLOSING, CLOSED].include?(@ready_state)
+      @ready_state = CLOSED
+      EventMachine.cancel_timer(@ping_timer)
+      @stream.close_connection_after_writing
+      event = WebSocket::API::Event.new('close')
+      event.init_event('close', false, false)
+      dispatch_event(event)
+    end
+  end
+  
+  class EventSource::Stream
+    include EventMachine::Deferrable
+    
+    extend Forwardable
+    def_delegators :@connection, :close_connection, :close_connection_after_writing
+    
+    def initialize(event_source)
+      @event_source = event_source
+      @connection   = event_source.env['em.connection']
+      @stream_send  = event_source.env['stream.send']
+      
+      @connection.socket_stream = self if @connection.respond_to?(:socket_stream)
+    end
+    
+    def each(&callback)
+      @stream_send ||= callback
+    end
+    
+    def fail
+      @event_source.close
+    end
+    
+    def receive(data)
+    end
+    
+    def write(data)
+      return unless @stream_send
+      @stream_send.call(data) rescue nil
+    end
+  end
+end
+

data/lib/faye/websocket.rb

@@ -0,0 +1,216 @@
+# API and protocol references:
+# 
+# * http://dev.w3.org/html5/websockets/
+# * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
+# * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'forwardable'
+require 'net/http'
+require 'stringio'
+require 'uri'
+require 'eventmachine'
+
+module Faye
+  autoload :EventSource, File.expand_path('../eventsource', __FILE__)
+  
+  class WebSocket
+    root = File.expand_path('../websocket', __FILE__)
+    require root + '/../../faye_websocket_mask'
+    
+    def self.jruby?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    end
+    
+    def self.rbx?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    end
+    
+    if jruby?
+      require 'jruby'
+      com.jcoglan.faye.FayeWebsocketMaskService.new.basicLoad(JRuby.runtime)
+    end
+    
+    unless WebSocketMask.respond_to?(:mask)
+      def WebSocketMask.mask(payload, mask)
+        @instance ||= new
+        @instance.mask(payload, mask)
+      end
+    end
+    
+    unless String.instance_methods.include?(:force_encoding)
+      require root + '/utf8_match'
+    end
+    
+    autoload :Adapter,         root + '/adapter'
+    autoload :API,             root + '/api'
+    autoload :Client,          root + '/client'
+    autoload :Draft75Parser,   root + '/draft75_parser'
+    autoload :Draft76Parser,   root + '/draft76_parser'
+    autoload :HybiParser,      root + '/hybi_parser'
+    
+    ADAPTERS = {
+      'thin'     => :Thin,
+      'rainbows' => :Rainbows,
+      'goliath'  => :Goliath
+    }
+    
+    def self.load_adapter(backend)
+      const = Kernel.const_get(ADAPTERS[backend]) rescue nil
+      require(backend) unless const
+      require File.expand_path("../adapters/#{backend}", __FILE__)
+    end
+    
+    def self.utf8_string(string)
+      string = string.pack('C*') if Array === string
+      string.respond_to?(:force_encoding) ?
+          string.force_encoding('UTF-8') :
+          string
+    end
+    
+    def self.encode(string, validate_encoding = false)
+      if Array === string
+        string = utf8_string(string)
+        return nil if validate_encoding and !valid_utf8?(string)
+      end
+      utf8_string(string)
+    end
+    
+    def self.valid_utf8?(byte_array)
+      string = utf8_string(byte_array)
+      if defined?(UTF8_MATCH)
+        UTF8_MATCH =~ string ? true : false
+      else
+        string.valid_encoding?
+      end
+    end
+    
+    def self.websocket?(env)
+      env['REQUEST_METHOD'] == 'GET' and
+      env['HTTP_CONNECTION'] and
+      env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
+      ['WebSocket', 'websocket'].include?(env['HTTP_UPGRADE'])
+    end
+    
+    def self.parser(env)
+      if env['HTTP_SEC_WEBSOCKET_VERSION']
+        HybiParser
+      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
+        Draft76Parser
+      else
+        Draft75Parser
+      end
+    end
+    
+    def self.determine_url(env)
+      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
+    
+    extend Forwardable
+    def_delegators :@parser, :version
+    
+    attr_reader :env
+    include API
+    
+    def initialize(env, supported_protos = nil, options = {})
+      @env     = env
+      @stream  = Stream.new(self)
+      @ping    = options[:ping]
+      @ping_id = 0
+      
+      @url = WebSocket.determine_url(@env)
+      @ready_state = CONNECTING
+      @buffered_amount = 0
+      
+      @parser = WebSocket.parser(@env).new(self, :protocols => supported_protos)
+      
+      @send_buffer = []
+      EventMachine.next_tick { open }
+      
+      @callback = @env['async.callback']
+      @callback.call([101, {}, @stream])
+      @stream.write(@parser.handshake_response)
+      
+      @ready_state = OPEN if @parser.open?
+      
+      if @ping
+        @ping_timer = EventMachine.add_periodic_timer(@ping) do
+          @ping_id += 1
+          ping(@ping_id.to_s)
+        end
+      end
+    end
+    
+    def ping(message = '', &callback)
+      return false unless @parser.respond_to?(:ping)
+      @parser.ping(message, &callback)
+    end
+    
+    def protocol
+      @parser.protocol || ''
+    end
+    
+    def rack_response
+      [ -1, {}, [] ]
+    end
+    
+  private
+    
+    def parse(data)
+      response = @parser.parse(data)
+      return unless response
+      @stream.write(response)
+      open
+    end
+  end
+  
+  class WebSocket::Stream
+    include EventMachine::Deferrable
+    
+    extend Forwardable
+    def_delegators :@connection, :close_connection, :close_connection_after_writing
+    
+    def initialize(web_socket)
+      @web_socket  = web_socket
+      @connection  = web_socket.env['em.connection']
+      @stream_send = web_socket.env['stream.send']
+      
+      @connection.socket_stream = self if @connection.respond_to?(:socket_stream)
+    end
+    
+    def each(&callback)
+      @stream_send ||= callback
+    end
+    
+    def fail
+      @web_socket.close(1006, '', false)
+    end
+    
+    def receive(data)
+      @web_socket.__send__(:parse, data)
+    end
+    
+    def write(data)
+      return unless @stream_send
+      @stream_send.call(data) rescue nil
+    end
+  end
+end
+
+Faye::WebSocket::ADAPTERS.each do |name, const|
+  klass = Kernel.const_get(const) rescue nil
+  Faye::WebSocket.load_adapter(name) if klass
+end
+

data/lib/faye/websocket/adapter.rb

@@ -0,0 +1,21 @@
+module Faye
+  class WebSocket
+    
+    module Adapter
+      def websocket?
+        e = defined?(@env) ? @env : env
+        WebSocket.websocket?(e)
+      end
+      
+      def eventsource?
+        e = defined?(@env) ? @env : env
+        EventSource.eventsource?(e)
+      end
+      
+      def async_connection?
+        websocket? or eventsource?
+      end
+    end
+    
+  end
+end

data/lib/faye/websocket/api.rb

@@ -0,0 +1,96 @@
+module Faye
+  class WebSocket
+    
+    module API
+      module ReadyStates
+        CONNECTING = 0
+        OPEN       = 1
+        CLOSING    = 2
+        CLOSED     = 3
+      end
+      
+      class IllegalStateError < StandardError
+      end
+      
+      require File.expand_path('../api/event_target', __FILE__)
+      require File.expand_path('../api/event', __FILE__)
+      include EventTarget
+      include ReadyStates
+      
+      attr_reader :url, :ready_state, :buffered_amount
+      
+    private
+      
+      def open
+        return if @parser and not @parser.open?
+        @ready_state = OPEN
+        
+        buffer = @send_buffer || []
+        while message = buffer.shift
+          send(*message)
+        end
+        
+        event = Event.new('open')
+        event.init_event('open', false, false)
+        dispatch_event(event)
+      end
+      
+    public
+      
+      def receive(data)
+        return false unless @ready_state == OPEN
+        event = Event.new('message')
+        event.init_event('message', false, false)
+        event.data = data
+        dispatch_event(event)
+      end
+      
+      def send(data, type = nil, error_type = nil)
+        if @ready_state == CONNECTING
+          if @send_buffer
+            @send_buffer << [data, type, error_type]
+            return true
+          else
+            raise IllegalStateError, 'Cannot call send(), socket is not open yet'
+          end
+        end
+        
+        return false if @ready_state == CLOSED
+        
+        data = data.to_s unless Array === data
+        
+        data = WebSocket.encode(data) if String === data
+        frame = @parser.frame(data, type, error_type)
+        @stream.write(frame) if frame
+      end
+      
+      def close(code = nil, reason = nil, ack = true)
+        return if [CLOSING, CLOSED].include?(@ready_state)
+        
+        @ready_state = CLOSING
+        
+        close = lambda do
+          @ready_state = CLOSED
+          EventMachine.cancel_timer(@ping_timer) if @ping_timer
+          @stream.close_connection_after_writing
+          event = Event.new('close', :code => code || 1000, :reason => reason || '')
+          event.init_event('close', false, false)
+          dispatch_event(event)
+        end
+        
+        if ack
+          if @parser.respond_to?(:close)
+            @parser.close(code, reason, &close)
+          else
+            close.call
+          end
+        else
+          @parser.close(code, reason) if @parser.respond_to?(:close)
+          close.call
+        end
+      end
+    end
+    
+  end
+end
+