sockjs 0.2.1

data/lib/sockjs.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require "eventmachine"
+require "forwardable"
+require 'sockjs/callbacks'
+require "sockjs/version"
+require 'sockjs/connection'
+
+def Time.timer(&block)
+  - (Time.now.tap { yield } - Time.now)
+end
+
+module SockJS
+  def self.debug!
+    @debug = true
+  end
+
+  def self.no_debug!
+    @debug = false
+  end
+
+  def self.debug?
+    @debug
+  end
+
+  def self.puts(message)
+    if self.debug?
+      STDERR.puts(message)
+    end
+  end
+
+  def self.debug(message)
+    self.puts("~ #{message}")
+  end
+
+  def self.debug_exception(exception)
+    self.debug(([exception.class.name, exception.message].join(": ") + exception.backtrace).join("\n"))
+  end
+
+  class CloseError < StandardError
+    attr_reader :status, :message
+    def initialize(status, message)
+      @status, @message = status, message
+    end
+  end
+
+  class HttpError < StandardError
+    attr_reader :status, :message
+
+    def initialize(status, message, &block)
+      @message = message
+      @status = status
+      raise "Block passed to HttpError" unless block.nil?
+    end
+  end
+
+  class InvalidJSON < HttpError
+  end
+end

data/lib/sockjs/callbacks.rb

@@ -0,0 +1,19 @@
+module SockJS
+  module CallbackMixin
+    attr_accessor :status
+
+    def callbacks
+      @callbacks ||= Hash.new { |hash, key| hash[key] = Array.new }
+    end
+
+    def execute_callback(name, *args)
+      if self.callbacks.has_key?(name)
+        self.callbacks[name].each do |callback|
+          callback.call(*args)
+        end
+      else
+        raise ArgumentError.new("There's no callback #{name.inspect}. Available callbacks: #{self.callbacks.keys.inspect}")
+      end
+    end
+  end
+end

data/lib/sockjs/connection.rb

@@ -0,0 +1,45 @@
+require 'sockjs'
+require 'sockjs/callbacks'
+
+module SockJS
+  class Connection
+    def initialize(session_class, options)
+      self.status = :not_connected
+      @session_class = session_class
+      @options = options
+    end
+    attr_accessor :status, :options
+
+    #XXX TODO: remove dead sessions as they're get_session'd, along with a
+    #recurring clearout
+    def sessions
+      SockJS.debug "Refreshing sessions"
+
+      if @sessions
+        @sessions.delete_if do |_, session|
+          unless session.alive?
+            SockJS.debug "Removing closed session #{_}"
+          end
+
+          !session.alive?
+        end
+      else
+        @sessions = {}
+      end
+    end
+
+    def get_session(session_key)
+      SockJS.debug "Looking up session at #{session_key.inspect}"
+      sessions.fetch(session_key)
+    end
+
+    def create_session(session_key)
+      SockJS.debug "Creating session at #{session_key.inspect}"
+      raise "Session already exists for #{session_key.inspect}" if sessions.has_key?(session_key)
+      session = @session_class.new(self)
+      sessions[session_key] = session
+      session.opened
+      session
+    end
+  end
+end

data/lib/sockjs/delayed-response-body.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'eventmachine'
+
+module SockJS
+  class DelayedResponseBody
+    include EventMachine::Deferrable
+
+    attr_accessor :session
+
+    def initialize
+      @status = :created
+    end
+
+    def call(body)
+      body.each do |chunk|
+        self.write(chunk)
+      end
+    end
+
+    def write(chunk)
+      unless @status == :open
+        raise "Body isn't open (status: #{@status}, trying to write #{chunk.inspect})"
+      end
+
+      unless chunk.respond_to?(:bytesize)
+        raise "Chunk is supposed to respond to #bytesize, but it doesn't.\nChunk: #{chunk.inspect} (#{chunk.class})"
+      end
+
+      SockJS.debug "body#write #{chunk.inspect}"
+
+      self.write_chunk(chunk)
+    end
+
+    def each(&block)
+      SockJS.debug "Opening the response."
+      @status = :open
+      @body_callback = block
+    end
+
+    def succeed(from_server = true)
+      SockJS.debug "Closing the response."
+      if $DEBUG and false
+        SockJS.debug caller[0..-8].map { |item| item.sub(Dir.pwd + "/lib/", "") }.inspect
+      end
+
+      @status = :closed
+      super
+    end
+
+    def finish(data = nil)
+      if @status == :closed
+        raise "Body is already closed!"
+      end
+
+      self.write(data) if data
+
+      self.succeed(true)
+    end
+
+    def closed?
+      @status == :closed
+    end
+
+    protected
+    def write_chunk(chunk)
+      self.__write__(chunk)
+    end
+
+    def __write__(data)
+      SockJS.debug "Data to client %% #{data.inspect}"
+      @body_callback.call(data)
+    end
+  end
+
+
+  # https://github.com/rack/rack/blob/master/lib/rack/chunked.rb
+  class DelayedResponseChunkedBody < DelayedResponseBody
+    TERM ||= "\r\n"
+    TAIL ||= "0#{TERM}#{TERM}"
+
+    def finish(data = nil)
+      if @status == :closed
+        raise "Body is already closed!"
+      end
+
+      self.write(data) if data
+      self.__write__(TAIL)
+
+      self.succeed(true)
+    end
+
+    protected
+    def write_chunk(chunk)
+      data = [chunk.bytesize.to_s(16), TERM, chunk, TERM].join
+      self.__write__(data)
+    end
+  end
+end

data/lib/sockjs/duck-punch-rack-mount.rb

@@ -0,0 +1,12 @@
+require 'rack/mount/utils'
+
+module Rack::Mount::Utils
+  def normalize_path(path)
+    path = "/#{path}" unless path[0] = ?/
+    path = '/' if path == ''
+    path
+
+    return path
+  end
+  module_function :normalize_path
+end

data/lib/sockjs/duck-punch-thin-response.rb

@@ -0,0 +1,15 @@
+require 'thin/response'
+module Thin
+  class Response
+    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+    def persistent?
+      return true if PERSISTENT_STATUSES.include?(@status)
+      return false unless @persistent
+      return true if @headers.has_key?(CONTENT_LENGTH)
+      if @headers.has_key?(TRANSFER_ENCODING)
+        header_string ||= @headers.to_s
+        return true if /transfer-encoding: identity/i !~ header_string
+      end
+    end
+  end
+end

data/lib/sockjs/examples/protocol_conformance_test.rb

@@ -0,0 +1,73 @@
+require 'thin'
+require 'rack/sockjs'
+require 'rack/builder'
+
+module SockJS
+  module Examples
+    class ProtocolConformanceTest
+      class MyHelloWorld
+        BODY = [<<-HTML].freeze
+<html>
+  <head>
+    <title>Hello World!</title>
+  </head>
+
+  <body>
+    <h1>Hello World!</h1>
+    <p>
+      This is the app, not SockJS.
+    </p>
+  </body>
+</html>
+        HTML
+
+        def call(env)
+          [200, {"Content-Type" => "text/html; charset=UTF-8", "Content-Length" => BODY.join("").bytesize.to_s}, BODY]
+        end
+      end
+
+      def self.build_app(*args)
+        self.new(*args).to_app
+      end
+
+      def initialize(options = nil)
+        @options = options || {}
+      end
+
+      attr_accessor :options
+
+      class EchoSession < Session
+        def process_message(message)
+          SockJS.debug "\033[0;31;40m[Echo]\033[0m message: #{message.inspect}, session: #{self.object_id}"
+          send(message)
+        end
+      end
+
+      class CloseSession < Session
+        def opened
+          SockJS.debug "\033[0;31;40m[Close]\033[0m closing the session ..."
+          close(3000, "Go away!")
+        end
+      end
+
+      def to_app
+        options = self.options
+        ::Rack::Builder.new do
+          map '/echo' do
+            run ::Rack::SockJS.new(EchoSession, options)
+          end
+
+          map '/disabled_websocket_echo' do
+            run ::Rack::SockJS.new(EchoSession, options.merge(:websocket => false))
+          end
+
+          map '/close' do
+            run ::Rack::SockJS.new(CloseSession, options)
+          end
+
+          run MyHelloWorld.new
+        end.to_app
+      end
+    end
+  end
+end

data/lib/sockjs/faye.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require "faye/websocket"
+
+class Thin::Request
+  WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
+  GET = 'GET'.freeze
+
+  def websocket?
+    @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
+end

data/lib/sockjs/protocol.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require "json"
+
+module SockJS
+  module Protocol
+    CHARS_TO_BE_ESCAPED ||= /[\x00-\x1f\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufff0-\uffff]/
+
+    class Frame
+      # JSON Unicode Encoding
+      # =====================
+      #
+      # SockJS takes the responsibility of encoding Unicode strings for
+      # the user. The idea is that SockJS should properly deliver any
+      # valid string from the browser to the server and back. This is
+      # actually quite hard, as browsers do some magical character
+      # translations. Additionally there are some valid characters from
+      # JavaScript point of view that are not valid Unicode, called
+      # surrogates (JavaScript uses UCS-2, which is not really Unicode).
+      #
+      # Dealing with unicode surrogates (0xD800-0xDFFF) is quite special.
+      # If possible we should make sure that server does escape decode
+      # them. This makes sense for SockJS servers that support UCS-2
+      # (SockJS-node), but can't really work for servers supporting unicode
+      # properly (Python).
+      #
+      # The server can't send Unicode surrogates over Websockets, also various
+      # \u2xxxx chars get mangled. Additionally, if the server is capable of
+      # handling UCS-2 (ie: 16 bit character size), it should be able to deal
+      # with Unicode surrogates 0xD800-0xDFFF:
+      # http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Surrogates
+      def escape(string)
+        string.gsub(CHARS_TO_BE_ESCAPED) do |match|
+          '\u%04x' % (match.ord)
+        end
+      end
+
+      def validate(desired_class, object)
+        unless object.is_a?(desired_class)
+          raise TypeError.new("#{desired_class} object expected, but object is an instance of #{object.class} (object: #{object.inspect}).")
+        end
+      end
+    end
+
+    class HeartbeatFrame < Frame
+      def initialize
+      end
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def to_s
+        "h"
+      end
+    end
+
+    class OpeningFrame < Frame
+      def initialize
+      end
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def to_s
+        "o"
+      end
+    end
+
+    class ArrayFrame < Frame
+      def initialize(array)
+        @array = array
+        validate Array, array
+      end
+      attr_reader :array
+
+      def to_s
+        "a#{escape(array.to_json)}"
+      end
+    end
+
+
+    class ClosingFrame < Frame
+      def initialize(status, message)
+        validate Integer, status
+        validate String, message
+
+        @status, @message = status, message
+      end
+
+      def to_s
+        "c[#{@status},#{escape(@message.inspect)}]"
+      end
+    end
+  end
+end

data/lib/sockjs/servers/request.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+require "uri"
+
+module SockJS
+  #This is the SockJS wrapper for a Rack env hash-like.  Currently it requires
+  #that we're running under Thin - someday we may break this out such that can
+  #adapt to other webservers or compatiblity layers.  For now: do your SockJS
+  #stuff in Thin.
+  #
+  class Request
+    attr_reader :env
+    def initialize(env)
+      @env = env
+    end
+
+    # request.path_info
+    # => /echo/abc
+    def path_info
+      env["PATH_INFO"]
+    end
+
+    # request.http_method
+    # => "GET"
+    def http_method
+      env["REQUEST_METHOD"]
+    end
+
+    def async_callback
+      env["async.callback"]
+    end
+
+    def async_close
+      env["async.close"]
+    end
+
+    def on_close(&block)
+      async_close.callback( &block)
+      async_close.errback(  &block)
+    end
+
+    def succeed
+      async_close.succeed
+    end
+
+    def fail
+      async_close.fail
+    end
+
+    #Somehow, default inspect pulls in the whole app...
+    def inspect
+      position = data.pos
+      data.rewind
+      body = data.read
+      "<<#{self.class.name}: #{http_method}/#{path_info} #{body.inspect}>>"
+    ensure
+      data.pos = position
+    end
+
+    # request.headers["origin"]
+    # => http://foo.bar
+    def headers
+      @headers ||=
+        begin
+          permitted_keys = /^(CONTENT_(LENGTH|TYPE))$/
+
+          @env.reduce(Hash.new) do |headers, (key, value)|
+            if key.match(/^HTTP_(.+)$/) || key.match(permitted_keys)
+              headers[$1.downcase.tr("_", "-")] = value
+            end
+
+            headers
+          end
+        end
+    end
+
+    # request.query_string["callback"]
+    # => "myFn"
+    def query_string
+      @query_string ||=
+        begin
+          @env["QUERY_STRING"].split("=").each_slice(2).each_with_object({}) do |pair, buffer|
+            buffer[pair.first] = pair.last
+          end
+        end
+    end
+
+
+    # request.cookies["JSESSIONID"]
+    # => "123sd"
+    def cookies
+      @cookies ||=
+        begin
+          ::Rack::Request.new(@env).cookies
+        end
+    end
+
+
+    # request.data.read
+    # => "message"
+    def data
+      @env["rack.input"]
+    end
+    HTTP_1_0     ||= "HTTP/1.0"
+    HTTP_VERSION ||= "version"
+
+    def http_1_0?
+      self.headers[HTTP_VERSION] == HTTP_1_0
+    end
+
+    def origin
+      self.headers["origin"] || "*"
+    end
+
+    def content_type
+      self.headers["content-type"]
+    end
+
+    def callback
+      callback = self.query_string["callback"] || self.query_string["c"]
+      URI.unescape(callback) if callback
+    end
+
+    def keep_alive?
+      headers["connection"].downcase == "keep-alive"
+    end
+
+    def session_id
+      self.cookies["JSESSIONID"] || "dummy"
+    end
+
+    def fresh?(etag)
+      self.headers["if-none-match"] == etag
+    end
+  end
+end