volt-sockjs 0.3.4.4

data/lib/sockjs/servers/request.rb

@@ -0,0 +1,137 @@
+# 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
+      return "*" if self.headers["origin"] == "null"
+      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

data/lib/sockjs/servers/response.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+require 'sockjs/delayed-response-body'
+
+module SockJS
+  #Adapter for Thin Rack responses.  It's a TODO feature to support other
+  #webservers and compatibility layers
+  class Response
+    extend Forwardable
+    attr_reader :request, :status, :headers, :body
+    attr_writer :status
+
+    def initialize(request, status = nil, headers = nil, &block)
+      # request.env["async.close"]
+      # ["rack.input"].closed? # it's a stream
+      @request, @status, @headers = request, status, headers || {}
+
+      if request.http_1_0?
+        SockJS.debug "Request is in HTTP/1.0, responding with HTTP/1.0"
+        @body = DelayedResponseBody.new
+      else
+        @body = DelayedResponseChunkedBody.new
+      end
+
+      @body.callback do
+        @request.succeed
+      end
+
+      @body.errback do
+        @request.fail
+      end
+
+      block.call(self) if block
+
+      set_connection_keep_alive_if_requested
+    end
+
+    def session=(session)
+      @body.session = session
+    end
+
+    def turn_chunking_on(headers)
+      headers["Transfer-Encoding"] = "chunked"
+    end
+
+
+    def write_head(status = nil, headers = nil)
+      @status  = status  || @status  || raise("Please set the status!")
+      @headers = headers || @headers
+
+      if @headers["Content-Length"]
+        raise "You can't use Content-Length with chunking!"
+      end
+
+      unless @request.http_1_0? || @status == 204
+        turn_chunking_on(@headers)
+      end
+
+      SockJS.debug "Writing headers: #{@status.inspect}/#{@headers.inspect}"
+      @request.async_callback.call([@status, @headers, @body])
+
+      @head_written = true
+    end
+
+    def head_written?
+      !! @head_written
+    end
+
+    def write(data)
+      self.write_head unless self.head_written?
+
+      @last_written_at = Time.now.to_i
+
+      @body.write(data)
+    end
+
+    def finish(data = nil, &block)
+      if data
+        self.write(data)
+      else
+        self.write_head unless self.head_written?
+      end
+
+      @body.finish
+    end
+
+    def async?
+      true
+    end
+
+    # Time.now.to_i shows time in seconds.
+    def due_for_alive_check
+      Time.now.to_i != @last_written_at
+    end
+
+    def set_status(status)
+      @status = status
+    end
+
+    def set_header(key, value)
+      @headers[key] = value
+    end
+
+    def set_session_id(session_id)
+      self.headers["Set-Cookie"] = "JSESSIONID=#{session_id}; path=/"
+    end
+
+    # === Helpers === #
+    def set_access_control(origin)
+      self.set_header("Access-Control-Allow-Origin", origin)
+      self.set_header("Access-Control-Allow-Credentials", "true")
+      self.set_header("Access-Control-Allow-Headers", "Content-Type Origin Accept X-Requested-With X-CSRF-Token If-Modified-Since If-None-Match Auth-User-Token Authorization Connection Cookie User-Agent")
+    end
+
+    def set_cache_control
+      year = 31536000
+      time = Time.now + year
+
+      self.set_header("Cache-Control", "public, max-age=#{year}")
+      self.set_header("Expires", time.gmtime.to_s)
+      self.set_header("Access-Control-Max-Age", "1000001")
+    end
+
+    def set_allow_options_post
+      self.set_header("Allow", "OPTIONS, POST")
+      self.set_header("Access-Control-Allow-Methods", "OPTIONS, POST")
+    end
+
+    def set_allow_options_get
+      self.set_header("Allow", "OPTIONS, GET")
+      self.set_header("Access-Control-Allow-Methods", "OPTIONS, GET")
+    end
+
+    def set_no_cache
+      self.set_header("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
+    end
+
+    CONTENT_TYPES ||= {
+      plain: "text/plain; charset=UTF-8",
+      html: "text/html; charset=UTF-8",
+      javascript: "application/javascript; charset=UTF-8",
+      json: "application/json; charset=UTF-8",
+      event_stream: "text/event-stream; charset=UTF-8"
+    }
+
+    def set_content_length(body)
+      if body && body.respond_to?(:bytesize)
+        self.headers["Content-Length"] = body.bytesize.to_s
+      end
+    end
+
+    def set_content_type(symbol)
+      if string = CONTENT_TYPES[symbol]
+        self.set_header("Content-Type", string)
+      else
+        raise "No such content type: #{symbol}"
+      end
+    end
+
+    def set_connection_keep_alive_if_requested
+      if @request.env["HTTP_CONNECTION"] && @request.env["HTTP_CONNECTION"].downcase == "keep-alive"
+        if @request.http_1_0?
+          self.set_header("Connection", "Close")
+        else
+          self.set_header("Connection", "Keep-Alive")
+        end
+      end
+    end
+  end
+end

data/lib/sockjs/session.rb

@@ -0,0 +1,492 @@
+# encoding: utf-8
+#
+require 'meta-state'
+require 'sockjs/protocol'
+
+module SockJS
+  class Session < MetaState::Machine
+    class Consumer
+      def initialize(response, transport)
+        @response = response
+        @transport = transport
+        @total_sent_length = 0
+      end
+      attr_reader :response, :transport, :total_sent_length
+
+      #Close the *response* not the *session*
+      def disconnect
+        #WEBSCOKET shouldn't have limit of data - faye will send closing frame after 1GB
+        if @transport.kind_of?(SockJS::Transports::WebSocket)
+          @total_sent_length = 0
+          return
+        end
+        @response.finish if @response.respond_to?(:finish)
+      end
+
+      def heartbeat
+        transport.heartbeat_frame(response)
+      end
+
+      def messages(items)
+        unless items.empty?
+          @total_sent_length += transport.messages_frame(response, items)
+        end
+      end
+
+      def closing(status, message)
+        transport.closing_frame(response, status, message)
+      end
+
+      #XXX Still not sure what this is *FOR*
+      def check_alive
+        if !@response.body.closed?
+          if @response.due_for_alive_check
+            SockJS.debug "Checking if still alive"
+            @response.write(@transport.empty_string)
+          else
+            puts "~ [TODO] Not checking if still alive, why?"
+            puts "Status: #{@status} (response.body.closed: #{@response.body.closed?})\nSession class: #{self.class}\nTransport class: #{@transport.class}\nResponse: #{@response.to_s}\n\n"
+          end
+        end
+      end
+    end
+
+    state :Detached do
+      def on_enter
+        @consumer = nil
+        clear_all_timers
+        set_disconnect_timer
+      end
+
+      def attach_consumer(response, transport)
+        @consumer = Consumer.new(response, transport)
+        activate
+        transition_to :attached
+        after_consumer_attached
+      end
+
+      def detach_consumer
+        #XXX Not sure if this is the right behavior
+        close(1002,"Connection interrupted")
+      end
+
+      def activate
+      end
+
+      def suspended
+      end
+
+      def send(*messages)
+        @outbox += messages
+      end
+
+      def close(status = nil, message = nil)
+        @close_status = status
+        @close_message = message
+        transition_to(:closed)
+      end
+    end
+
+    state :Attached do
+      def on_enter
+        @consumer.messages(@outbox)
+        @outbox.clear
+        clear_all_timers
+        check_content_length
+        set_heartbeat_timer
+      end
+
+      def attach_consumer(response, transport)
+        SockJS.debug "Session#attach_consumer: another connection still open"
+        transport.closing_frame(response, 2010, "Another connection still open")
+        close(1002, "Connection interrupted")
+      end
+
+      def detach_consumer
+        transition_to :detached
+        after_consumer_detached
+      end
+
+      def send(*messages)
+        @consumer.messages(messages)
+        check_content_length
+      end
+
+      def send_heartbeat
+        @consumer.heartbeat
+      end
+
+      def suspend
+        transition_to :suspended
+      end
+
+      def activate
+      end
+
+      def close(status = 1002, message = "Connection interrupted")
+        @close_status = status
+        @close_message = message
+        @consumer.closing(@close_status, @close_message)
+        @consumer = nil
+        transition_to(:closed)
+      end
+    end
+
+    state :Suspended do
+      def on_enter
+        SockJS.debug "Session suspended - it is on hold"
+        suspended
+      end
+
+      def attach_consumer(response, transport)
+        SockJS.debug "Session#attach_consumer: another connection still open"
+        transport.closing_frame(response, 2010, "Another connection still open")
+        close(1002, "Connection interrupted")
+      end
+
+      def detach_consumer
+        transition_to :detached
+        after_consumer_detached
+      end
+
+      def send(*messages)
+        @outbox += messages
+      end
+
+      def send_heartbeat
+        @consumer.heartbeat
+      end
+
+      def suspend
+      end
+
+      def activate
+        SockJS.debug "Session activated - is not on hold anymore!"
+        transition_to :attached
+        activated
+      end
+
+      def close(status = 1002, message = "Connection interrupted")
+        @close_status = status
+        @close_message = message
+        @consumer.closing(@close_status, @close_message)
+        @consumer = nil
+        transition_to(:closed)
+      end
+    end
+
+    state :Closed do
+      def on_enter
+        @close_status ||= 3000
+        @close_message ||= "Go away!"
+        clear_all_timers
+        set_close_timer
+        closed
+      end
+
+      def suspend
+        SockJS.debug "Session#suspend: connection closed!"
+      end
+
+      def activate
+        SockJS.debug "Session#activate: connection closed!"
+      end
+
+      def attach_consumer(response, transport)
+        transport.closing_frame(response, @close_status, @close_message)
+      end
+
+      def close(status=nil, message=nil)
+        #can be called from faye onclose hook
+      end
+    end
+
+
+    #### Client Code interface
+
+    # All incoming data is treated as incoming messages,
+    # either single json-encoded messages or an array
+    # of json-encoded messages, depending on transport.
+    def receive_message(data)
+      clear_timer(:disconnect)
+      activate
+
+      SockJS.debug "Session receiving message: #{data.inspect}"
+      messages = parse_json(data)
+      SockJS.debug "Message parsed as: #{messages.inspect}"
+      unless messages.empty?
+        @received_messages.push(*messages)
+      end
+
+      EM.next_tick do
+        run_user_app
+      end
+
+      set_disconnect_timer
+    end
+
+    def suspended?
+      current_state == SockJS::Session::Suspended
+    end
+
+    def check_content_length
+      if @consumer.total_sent_length >= max_permitted_content_length
+        SockJS.debug "Maximum content length exceeded, closing the connection."
+        #shouldn't be restarting connection?
+        @consumer.disconnect
+      else
+        SockJS.debug "Permitted content length: #{@consumer.total_sent_length} of #{max_permitted_content_length}"
+      end
+    end
+
+    def run_user_app
+      unless @received_messages.empty?
+        reset_heartbeat_timer #XXX Only one point which can set hearbeat while state is closed
+
+        SockJS.debug "Executing user's SockJS app"
+
+        raise @error if @error
+
+        @received_messages.each do |message|
+          SockJS.debug "Executing app with message #{message.inspect}"
+          process_message(message)
+        end
+        @received_messages.clear
+
+        after_app_run
+
+        SockJS.debug "User's SockJS app finished"
+      end
+    rescue SockJS::CloseError => error
+      Protocol::ClosingFrame.new(error.status, error.message)
+    end
+
+    def process_message(message)
+    end
+
+    def opened
+    end
+
+    def after_app_run
+    end
+
+    def closed
+    end
+
+    def activated
+    end
+
+    def suspended
+    end
+
+    def after_consumer_attached
+    end
+
+    def after_consumer_detached
+    end
+
+    attr_accessor :disconnect_delay, :interval
+    attr_reader :transport, :response, :outbox, :closing_frame, :data
+
+    def initialize(connection)
+      super()
+
+      debug_with do |msg|
+        SockJS::debug(msg)
+      end
+
+      @connection = connection
+      @disconnect_delay = 5 # TODO: make this configurable.
+      @received_messages = []
+      @outbox = []
+      @total_sent_content_length = 0
+      @interval = 0.1
+      @closing_frame = nil
+      @data = {}
+      @alive = true
+      @timers = {}
+    end
+
+    def alive?
+      !!@alive
+    end
+
+    #XXX This is probably important - need to examine this case
+    def on_close
+      SockJS.debug "The connection has been closed on the client side (current status: #{@status})."
+      close_session(1002, "Connection interrupted")
+    end
+
+    def max_permitted_content_length
+      @max_permitted_content_length ||= ($DEBUG ? 4096 : 128_000)
+    end
+
+    def parse_json(data)
+      if data.empty?
+        return []
+      end
+
+      JSON.parse("[#{data}]")[0]
+    rescue JSON::ParserError => error
+      raise SockJS::InvalidJSON.new(500, "Broken JSON encoding.")
+    end
+
+    #Timers:
+    #"alive_checker" - need to check spec.  Appears to check that response is
+    #live.  Premature?
+    #
+    #"disconnect" - expires and closes the session - time without a consumer
+    #
+    #"close" - duration between closed and removed from management
+    #
+    #"heartbeat" - periodic for hb frame
+
+    #Timer actions:
+
+    def disconnect_expired
+      SockJS.debug "#{@disconnect_delay} has passed, firing @disconnect_timer"
+      close
+      #XXX Shouldn't destroy the session?
+    end
+
+    def check_response_alive
+      if @consumer
+        begin
+          @consumer.check_alive
+        rescue Exception => error
+          puts "==> #{error.message}"
+          SockJS.debug error
+          puts "==> #{error.message}"
+          on_close
+          @alive_checker.cancel
+        end
+      else
+        puts "~ [TODO] Not checking if still alive, why?"
+      end
+    end
+
+    def heartbeat_triggered
+      # It's better as we know for sure that
+      # clearing the buffer won't change it.
+      SockJS.debug "Sending heartbeat frame."
+      begin
+        send_heartbeat
+      rescue Exception => error
+        # Nah these exceptions are OK ... let's figure out when they occur
+        # and let's just not set the timer for such cases in the first place.
+        SockJS.debug "Exception when sending heartbeat frame: #{error.inspect}"
+      end
+    end
+
+    #Timer machinery
+
+    def set_timer(name, type, delay, &action)
+      @timers[name] ||=
+        begin
+          SockJS.debug "Setting timer: #{name} to expire after #{delay}"
+          type.new(delay, &action)
+        end
+    end
+
+    def clear_timer(name)
+      @timers[name].cancel unless @timers[name].nil?
+      @timers.delete(name)
+    end
+
+    def clear_all_timers
+      @timers.values.each do |timer|
+        timer.cancel
+      end
+      @timers.clear
+    end
+
+
+    def set_alive_timer
+      set_timer(:alive_check, EM::PeriodicTimer, 1) do
+        check_response_alive
+      end
+    end
+
+    def reset_alive_timer
+      clear_timer(:alive_check)
+      set_alive_timer
+    end
+
+    def set_heartbeat_timer
+      if current_state == SockJS::Session::Closed
+        SockJS.debug "trying to setup heartbeat on closed session!"
+        return
+      end
+      clear_timer(:disconnect)
+      clear_timer(:alive)
+      set_timer(:heartbeat, EM::PeriodicTimer, 25) do
+        heartbeat_triggered
+      end
+    end
+
+    def reset_heartbeat_timer
+      clear_timer(:heartbeat)
+      if current_state == SockJS::Session::Closed
+        SockJS.debug "trying to setup heartbeat on closed session!"
+      else
+        set_heartbeat_timer
+      end
+    end
+
+    def set_disconnect_timer
+      set_timer(:disconnect, EM::Timer, @disconnect_delay) do
+        disconnect_expired
+      end
+    end
+
+    def reset_disconnect_timer
+      clear_timer(:disconnect)
+      set_disconnect_timer
+    end
+
+    def set_close_timer
+      set_timer(:close, EM::Timer, @disconnect_delay) do
+        @alive = false
+      end
+    end
+
+    def reset_close_timer
+      clear_timer(:close)
+      set_close_timer
+    end
+  end
+
+  class WebSocketSession < Session
+    attr_accessor :ws
+    undef :response
+
+    def send_data(frame)
+      if frame.nil?
+        raise TypeError.new("Frame must not be nil!")
+      end
+
+      unless frame.empty?
+        SockJS.debug "@ws.send(#{frame.inspect})"
+        @ws.send(frame)
+      end
+    end
+
+    def after_app_run
+      return super unless self.closing?
+
+      after_close
+    end
+
+    def after_close
+      SockJS.debug "after_close: calling #finish"
+      finish
+
+      SockJS.debug "after_close: closing @ws and clearing @transport."
+      @ws.close
+      @transport = nil
+    end
+
+    def set_alive_checker
+    end
+  end
+end