faye-tls1-websocket 0.8.0

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.socket_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
+    return '' if async and status == 101
+    thin_head
+  end
+end
+

data/lib/faye/eventsource.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../websocket', __FILE__) unless defined?(Faye::WebSocket)
+
+module Faye
+  class EventSource
+
+    include WebSocket::API::EventTarget
+    attr_reader :env, :url, :ready_state
+
+    DEFAULT_RETRY = 5
+
+    def self.eventsource?(env)
+      return false unless env['REQUEST_METHOD'] == 'GET'
+      accept = (env['HTTP_ACCEPT'] || '').split(/\s*,\s*/)
+      accept.include?('text/event-stream')
+    end
+
+    def self.determine_url(env)
+      scheme = WebSocket.secure_request?(env) ? 'https:' : 'http:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+    end
+
+    def initialize(env, options = {})
+      WebSocket.ensure_reactor_running
+      super()
+
+      @env    = env
+      @ping   = options[:ping]
+      @retry  = (options[:retry] || DEFAULT_RETRY).to_f
+      @url    = EventSource.determine_url(env)
+      @stream = Stream.new(self)
+
+      @ready_state = WebSocket::API::CONNECTING
+
+      headers = ::WebSocket::Driver::Headers.new
+      if options[:headers]
+        options[:headers].each { |k,v| headers[k] = v }
+      end
+
+      if callback = @env['async.callback']
+        callback.call([101, {}, @stream])
+      end
+
+      @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" +
+                    headers.to_s +
+                    "\r\n" +
+                    "retry: #{ (@retry * 1000).floor }\r\n\r\n")
+
+      EventMachine.next_tick { 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
+
+  private
+    
+    def open
+      return unless @ready_state == WebSocket::API::CONNECTING
+
+      @ready_state = WebSocket::API::OPEN
+
+      event = WebSocket::API::Event.new('open')
+      event.init_event('open', false, false)
+      dispatch_event(event)
+    end
+
+  public
+
+    def send(message, options = {})
+      return false if @ready_state > WebSocket::API::OPEN
+
+      message = ::WebSocket::Driver.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)
+      return false if @ready_state > WebSocket::API::OPEN
+      @stream.write(":\r\n\r\n")
+      true
+    end
+
+    def close
+      return if [WebSocket::API::CLOSING, WebSocket::API::CLOSED].include?(@ready_state)
+
+      @ready_state = WebSocket::API::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
+
+    class Stream < RackStream
+      def fail
+        @socket_object.close
+      end
+    end
+
+  end
+end
+

data/lib/faye/rack_stream.rb

@@ -0,0 +1,70 @@
+module Faye
+  class RackStream
+
+    include EventMachine::Deferrable
+
+    module Reader
+      attr_accessor :stream
+
+      def receive_data(data)
+        stream.receive(data)
+      end
+
+      def unbind
+        stream.fail
+      end
+    end
+
+    def initialize(socket_object)
+      @socket_object = socket_object
+      @connection    = socket_object.env['em.connection']
+      @stream_send   = socket_object.env['stream.send']
+
+      if socket_object.env['rack.hijack']
+        socket_object.env['rack.hijack'].call
+        @rack_hijack_io = socket_object.env['rack.hijack_io']
+        EventMachine.attach(@rack_hijack_io, Reader) do |reader|
+          @rack_hijack_io_reader = reader
+          reader.stream = self
+        end
+      end
+
+      @connection.socket_stream = self if @connection.respond_to?(:socket_stream)
+    end
+
+    def clean_rack_hijack
+      return unless @rack_hijack_io
+      @rack_hijack_io_reader.close_connection_after_writing
+      @rack_hijack_io = @rack_hijack_io_reader = nil
+    end
+
+    def close_connection
+      clean_rack_hijack
+      @connection.close_connection if @connection
+    end
+
+    def close_connection_after_writing
+      clean_rack_hijack
+      @connection.close_connection_after_writing if @connection
+    end
+
+    def each(&callback)
+      @stream_send ||= callback
+    end
+
+    def fail
+    end
+
+    def receive(data)
+    end
+
+    def write(data)
+      return @rack_hijack_io.write(data) if @rack_hijack_io
+      return @stream_send.call(data) if @stream_send
+    rescue => e
+      fail if EOFError === e
+    end
+
+  end
+end
+

data/lib/faye/websocket.rb

@@ -0,0 +1,100 @@
+# API 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
+
+require 'forwardable'
+require 'stringio'
+require 'uri'
+require 'eventmachine-le'
+require 'websocket/driver'
+
+module Faye
+  autoload :EventSource, File.expand_path('../eventsource', __FILE__)
+  autoload :RackStream,  File.expand_path('../rack_stream', __FILE__)
+
+  class WebSocket
+    root = File.expand_path('../websocket', __FILE__)
+
+    autoload :Adapter, root + '/adapter'
+    autoload :API,     root + '/api'
+    autoload :Client,  root + '/client'
+
+    ADAPTERS = {
+      'goliath'  => :Goliath,
+      'rainbows' => :Rainbows,
+      'thin'     => :Thin
+    }
+
+    def self.determine_url(env)
+      scheme = secure_request?(env) ? 'wss:' : 'ws:'
+      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+    end
+
+    def self.ensure_reactor_running
+      Thread.new { EventMachine.run } unless EventMachine.reactor_running?
+      Thread.pass until EventMachine.reactor_running?
+    end
+
+    def self.load_adapter(backend)
+      const = Kernel.const_get(ADAPTERS[backend]) rescue nil
+      require(backend) unless const
+      path = File.expand_path("../adapters/#{backend}.rb", __FILE__)
+      require(path) if File.file?(path)
+    end
+
+    def self.secure_request?(env)
+      return true if env['HTTPS'] == 'on'
+      return true if env['HTTP_X_FORWARDED_SSL'] == 'on'
+      return true if env['HTTP_X_FORWARDED_SCHEME'] == 'https'
+      return true if env['HTTP_X_FORWARDED_PROTO'] == 'https'
+      return true if env['rack.url_scheme'] == 'https'
+
+      return false
+    end
+
+    def self.websocket?(env)
+      ::WebSocket::Driver.websocket?(env)
+    end
+
+    attr_reader :env
+    include API
+
+    def initialize(env, protocols = nil, options = {})
+      WebSocket.ensure_reactor_running
+
+      @env    = env
+      @url    = WebSocket.determine_url(@env)
+      @driver = ::WebSocket::Driver.rack(self, :max_length => options[:max_length], :protocols => protocols)
+      @stream = Stream.new(self)
+
+      if callback = @env['async.callback']
+        callback.call([101, {}, @stream])
+      end
+
+      super(options)
+      @driver.start
+    end
+
+    def write(data)
+      @stream.write(data)
+    end
+
+    def rack_response
+      [ -1, {}, [] ]
+    end
+
+    class Stream < RackStream
+      def fail
+        @socket_object.__send__(:finalize, '', 1006)
+      end
+
+      def receive(data)
+        @socket_object.__send__(:parse, data)
+      end
+    end
+
+  end
+end
+

data/lib/faye/websocket/adapter.rb

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

data/lib/faye/websocket/api.rb

@@ -0,0 +1,115 @@
+require File.expand_path('../api/event_target', __FILE__)
+require File.expand_path('../api/event', __FILE__)
+
+module Faye
+  class WebSocket
+
+    module API
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
+
+      include EventTarget
+
+      extend Forwardable
+      def_delegators :@driver, :version
+
+      attr_reader :url, :ready_state, :buffered_amount
+
+      def initialize(options = {})
+        super()
+
+        if headers = options[:headers]
+          headers.each { |name, value| @driver.set_header(name, value) }
+        end
+
+        @ping            = options[:ping]
+        @ping_id         = 0
+        @ready_state     = CONNECTING
+        @buffered_amount = 0
+
+        @driver.on(:open)    { |e| open }
+        @driver.on(:message) { |e| receive_message(e.data) }
+        @driver.on(:close)   { |e| finalize(e.reason, e.code) }
+
+        @driver.on(:error) do |error|
+          event = Event.new('error', :message => error.message)
+          event.init_event('error', false, false)
+          dispatch_event(event)
+        end
+
+        if @ping
+          @ping_timer = EventMachine.add_periodic_timer(@ping) do
+            @ping_id += 1
+            ping(@ping_id.to_s)
+          end
+        end
+      end
+
+    private
+
+      def open
+        return unless @ready_state == CONNECTING
+        @ready_state = OPEN
+        event = Event.new('open')
+        event.init_event('open', false, false)
+        dispatch_event(event)
+      end
+
+      def receive_message(data)
+        return unless @ready_state == OPEN
+        event = Event.new('message')
+        event.init_event('message', false, false)
+        event.data = data
+        dispatch_event(event)
+      end
+
+      def finalize(reason = nil, code = nil)
+        return if @ready_state == CLOSED
+        @ready_state = CLOSED
+        EventMachine.cancel_timer(@ping_timer) if @ping_timer
+        @stream.close_connection_after_writing if @stream
+        event = Event.new('close', :code => code || 1000, :reason => reason || '')
+        event.init_event('close', false, false)
+        dispatch_event(event)
+      end
+
+      def parse(data)
+        @driver.parse(data)
+      end
+
+    public
+
+      def write(data)
+        @stream.write(data)
+      end
+
+      def send(message)
+        return false if @ready_state > OPEN
+        case message
+          when Numeric then @driver.text(message.to_s)
+          when String  then @driver.text(message)
+          when Array   then @driver.binary(message)
+          else false
+        end
+      end
+
+      def ping(message = '', &callback)
+        return false if @ready_state > OPEN
+        @driver.ping(message, &callback)
+      end
+
+      def close
+        @ready_state = CLOSING if @ready_state == OPEN
+        @driver.close
+      end
+
+      def protocol
+        @driver.protocol || ''
+      end
+    end
+
+  end
+end
+