RubyGems - volt-sockjs - Versions diffs - 0.3.4.4 - Mend

volt-sockjs 0.3.4.4

Files changed (42) hide show

checksums.yaml +7 -0
data/LICENCE +19 -0
data/README.textile +118 -0
data/lib/meta-state.rb +151 -0
data/lib/rack/sockjs.rb +173 -0
data/lib/sockjs.rb +59 -0
data/lib/sockjs/callbacks.rb +19 -0
data/lib/sockjs/connection.rb +45 -0
data/lib/sockjs/delayed-response-body.rb +99 -0
data/lib/sockjs/duck-punch-rack-mount.rb +12 -0
data/lib/sockjs/duck-punch-thin-response.rb +15 -0
data/lib/sockjs/examples/protocol_conformance_test.rb +73 -0
data/lib/sockjs/faye.rb +18 -0
data/lib/sockjs/protocol.rb +97 -0
data/lib/sockjs/servers/request.rb +137 -0
data/lib/sockjs/servers/response.rb +170 -0
data/lib/sockjs/session.rb +492 -0
data/lib/sockjs/transport.rb +357 -0
data/lib/sockjs/transports/eventsource.rb +30 -0
data/lib/sockjs/transports/htmlfile.rb +73 -0
data/lib/sockjs/transports/iframe.rb +68 -0
data/lib/sockjs/transports/info.rb +48 -0
data/lib/sockjs/transports/jsonp.rb +84 -0
data/lib/sockjs/transports/websocket.rb +198 -0
data/lib/sockjs/transports/welcome_screen.rb +17 -0
data/lib/sockjs/transports/xhr.rb +75 -0
data/lib/sockjs/version.rb +13 -0
data/spec/sockjs/protocol_spec.rb +49 -0
data/spec/sockjs/session_spec.rb +51 -0
data/spec/sockjs/transport_spec.rb +73 -0
data/spec/sockjs/transports/eventsource_spec.rb +56 -0
data/spec/sockjs/transports/htmlfile_spec.rb +72 -0
data/spec/sockjs/transports/iframe_spec.rb +66 -0
data/spec/sockjs/transports/jsonp_spec.rb +252 -0
data/spec/sockjs/transports/websocket_spec.rb +101 -0
data/spec/sockjs/transports/welcome_screen_spec.rb +36 -0
data/spec/sockjs/transports/xhr_spec.rb +314 -0
data/spec/sockjs/version_spec.rb +18 -0
data/spec/sockjs_spec.rb +8 -0
data/spec/spec_helper.rb +121 -0
data/spec/support/async-test.rb +42 -0
metadata +154 -0

data/lib/sockjs/transports/iframe.rb ADDED Viewed

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require "digest/md5"
+require "sockjs/transport"
+module SockJS
+  module Transports
+    class IFrame < Endpoint
+      register 'GET', %r{/iframe[^/]*[.]html}
+      BODY = <<-EOB.freeze
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  <script>
+    document.domain = document.domain;
+    _sockjs_onload = function(){SockJS.bootstrap_iframe();};
+  </script>
+  <script src="{{ sockjs_url }}"></script>
+</head>
+<body>
+  <h2>Don't panic!</h2>
+  <p>This is a SockJS hidden iframe. It's used for cross domain magic.</p>
+</body>
+</html>
+      EOB
+      def setup_response(request, response)
+        SockJS.debug("body: #{@body.inspect}")
+        response.status = 200
+        response.set_header("ETag", self.etag)
+        response.set_cache_control
+        response
+      end
+      def body
+        @body ||= BODY.gsub("{{ sockjs_url }}", options[:sockjs_url])
+      end
+      def digest
+        @digest ||= Digest::MD5.new
+      end
+      def etag
+        '"' + digest.hexdigest(body) + '"'
+      end
+      # Handler.
+      def handle_request(request)
+        if request.fresh?(etag)
+          response = build_response(request)
+          response.status = 304
+          response.finish
+          return response
+        else
+          SockJS.debug "Deferring to Transport"
+          response = build_response(request)
+          response.set_content_type(:html)
+          response.write(body)
+          response.finish
+          return response
+        end
+      end
+    end
+  end
+end

data/lib/sockjs/transports/info.rb ADDED Viewed

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require "sockjs/transport"
+module SockJS
+  module Transports
+    class Info
+      class Get < Endpoint
+        register 'GET', "info"
+        # Handler.
+        def setup_response(request, response)
+          response.status = 200
+          response.set_content_type(:json)
+          response.set_access_control(request.origin)
+          response.set_allow_options_post
+          response.set_no_cache
+          response.write(self.info.to_json)
+        end
+        def info
+          {
+            websocket: @options[:websocket],
+            origins: ["*:*"], # As specified by the spec, currently ignored.
+            cookie_needed: @options[:cookie_needed],
+            entropy: self.entropy
+          }
+        end
+        def entropy
+          rand(1 << 32)
+        end
+      end
+      class Options < Endpoint
+        register 'OPTIONS', 'info'
+        def setup_response(request, response)
+          response.status = 204
+          response.set_allow_options_get
+          response.set_cache_control
+          response.set_access_control(request.origin)
+          response.set_session_id(request.session_id)
+          response.write_head
+        end
+      end
+    end
+  end
+end

data/lib/sockjs/transports/jsonp.rb ADDED Viewed

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require "sockjs/transport"
+module SockJS
+  module Transports
+    class JSONP < PollingConsumingTransport
+      register 'GET', 'jsonp'
+      def error_content_type
+        :html
+      end
+      def setup_response(request, response)
+        response.status = 200
+        response.set_content_type(:javascript)
+        response.set_access_control(request.origin)
+        response.set_no_cache
+        response.set_session_id(request.session_id)
+        return response
+      end
+      def get_session(response)
+        if response.request.callback
+          super
+        else
+          raise HttpError.new(500, '"callback" parameter required')
+        end
+      end
+      def format_frame(response, payload)
+        raise TypeError.new("Payload must not be nil!") if payload.nil?
+        # Yes, JSONed twice, there isn't a better way, we must pass
+        # a string back, and the script, will be evaled() by the browser.
+        "#{response.request.callback}(#{super.chomp.to_json});\r\n"
+      end
+    end
+    class JSONPSend < DeliveryTransport
+      register 'POST', 'jsonp_send'
+      # Handler.
+      def extract_message(request)
+        if request.content_type == "application/x-www-form-urlencoded"
+          raw_data = request.data.read || empty_payload
+          begin
+            data = Hash[URI.decode_www_form(raw_data)]
+            data = data.fetch("d")
+          rescue KeyError
+            empty_payload
+          end
+        else
+          data = request.data.read
+        end
+        if data.nil? or data.empty?
+          empty_payload
+        end
+        data
+      end
+      def setup_response(request, response)
+        response.status = 200
+        response.set_content_type(:plain)
+        response.set_session_id(request.session_id)
+      end
+      def successful_response(response)
+        response.write("ok")
+        response.finish
+      end
+      def error_content_type
+        :html
+      end
+      def empty_payload
+        raise SockJS::HttpError.new(500, "Payload expected.")
+      end
+    end
+  end
+end

data/lib/sockjs/transports/websocket.rb ADDED Viewed

@@ -0,0 +1,198 @@
+def activate
+end# encoding: utf-8
+require "forwardable"
+require "sockjs/faye"
+require "sockjs/transport"
+# Raw WebSocket url: /websocket
+# -------------------------------
+#
+# SockJS protocol defines a bit of higher level framing. This is okay
+# when the browser using SockJS-client establishes the connection, but
+# it's not really appropriate when the connection is being established
+# from another program. Although SockJS focuses on server-browser
+# communication, it should be straightforward to connect to SockJS
+# from command line or some any programming language.
+#
+# In order to make writing command-line clients easier, we define this
+# `/websocket` entry point. This entry point is special and doesn't
+# use any additional custom framing, no open frame, no
+# heartbeats. Only raw WebSocket protocol.
+module SockJS
+  module Transports
+    module WSDebuggingMixin
+      def send_data(*args)
+        if args.length == 1
+          data = args.first
+        else
+          data = fix_buggy_input(*args)
+        end
+        SockJS.debug "WS#send #{data.inspect}"
+        super(data)
+      end
+      def fix_buggy_input(*args)
+        data = 'c[3000,"Go away!"]'
+        SockJS.debug "[ERROR] Incorrect input: #{args.inspect}, changing to #{data} for now"
+        return data
+      end
+      def close(*args)
+        SockJS.debug "WS#close(#{args.inspect[1..-2]})"
+        super(*args)
+      end
+    end
+    class WebSocket < ConsumingTransport
+      register 'GET', 'websocket'
+      def disabled?
+        !options[:websocket]
+      end
+      def session_key(ws)
+        ws.object_id.to_s
+      end
+      def handle_request(request)
+        if not @options[:websocket]
+          raise HttpError.new(404, "WebSockets Are Disabled")
+        elsif request.env["HTTP_UPGRADE"].to_s.downcase != "websocket"
+          SockJS.debug("Worng headers! HTTP_UPGRADE = #{request.env["HTTP_UPGRADE"].to_s}")
+          raise HttpError.new(400, 'Can "Upgrade" only to "WebSocket".')
+        elsif not ["Upgrade", "keep-alive, Upgrade"].include?(request.env["HTTP_CONNECTION"])
+          SockJS.debug("Worng headers! HTTP_CONNECTION = #{request.env["HTTP_CONNECTION"].to_s}")
+          raise HttpError.new(400, '"Connection" must be "Upgrade".')
+        end
+        super
+      end
+      def build_response(request)
+        SockJS.debug "Upgrading to WebSockets ..."
+        web_socket = Faye::WebSocket.new(request.env)
+        web_socket.extend(WSDebuggingMixin)
+        return web_socket
+      end
+      def build_error_response(request)
+        response = response_class.new(request)
+      end
+      def process_session(session, web_socket)
+        #XXX Facade around websocket?
+        @session = session
+        web_socket.on :open do |event|
+          begin
+            SockJS.debug "Attaching consumer"
+            session.attach_consumer(web_socket, self)
+          rescue Object => ex
+            SockJS::debug "Error opening (#{event.inspect[0..40]}) websocket: #{ex.inspect}"
+          end
+        end
+        web_socket.on :message do |event|
+          begin
+            session.receive_message(extract_message(event))
+          rescue Object => ex
+            SockJS::debug "Error receiving message on websocket (#{event.inspect[0..40]}): #{ex.inspect}"
+            web_socket.close
+          end
+        end
+        web_socket.on :close do |event|
+          begin
+            session.close(1000, "Session finished")
+          rescue Object => ex
+            SockJS::debug "Error closing websocket (#{event.inspect[0..40]}): #{ex.inspect} \n#{ex.message} \n#{ex.backtrace.join("\n")}"
+          end
+        end
+      end
+      def format_frame(response, frame)
+        frame.to_s
+      end
+      def send_data(web_socket, data)
+        web_socket.send(data)
+        return data.length
+      end
+      def finish_response(web_socket)
+        SockJS.debug "Finishing response"
+        web_socket.close
+      end
+      def extract_message(event)
+        SockJS.debug "Received message event: #{event.data.inspect}"
+        event.data
+      end
+      def heartbeat_frame(web_socket)
+        @pong = true if @pong.nil?
+        #no replay from last connection - susspend session
+        if !@pong
+          @session.suspend if @session
+        end
+        @pong = false
+        web_socket.ping("ping") do
+          SockJS.debug "pong"
+          @pong = true
+          @session.activate
+        end
+        super
+      end
+    end
+    class RawWebSocket < WebSocket
+      register 'GET', 'websocket'
+      def handle_request(request)
+        ver = request.env["sec-websocket-version"] || ""
+        unless ['8', '13'].include?(ver)
+          raise HttpError.new(400, 'Only supported WebSocket protocol is RFC 6455.')
+        end
+        super
+      end
+      def self.routing_prefix
+        "/" + self.prefix
+      end
+      def opening_frame(response)
+      end
+      def heartbeat_frame(response)
+      end
+      def extract_message(event)
+        SockJS.debug "Received message event: #{event.data.inspect}"
+        event.data.to_json
+      end
+      def messages_frame(websocket, messages)
+        messages.inject(0) do |sent_count, data|
+          send_data(websocket, data)
+          sent_count + data.length
+        end
+      rescue Object => ex
+        SockJS::debug "Error delivering messages to raw websocket: #{messages.inspect} #{ex.inspect}"
+      end
+      def closing_frame(response, status, message)
+        finish_response(response)
+      end
+    end
+  end
+end

data/lib/sockjs/transports/welcome_screen.rb ADDED Viewed

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require "sockjs/transport"
+module SockJS
+  module Transports
+    class WelcomeScreen < Endpoint
+      register 'GET', ''
+      def setup_response(request, response)
+        response.set_content_type(:plain)
+        response.status = 200
+        response.write("Welcome to SockJS!\n")
+      end
+    end
+  end
+end

data/lib/sockjs/transports/xhr.rb ADDED Viewed

@@ -0,0 +1,75 @@
+# encoding: utf-8
+require "sockjs/transport"
+module SockJS
+  module Transports
+    class XHROptions < SessionEndpoint
+      register 'OPTIONS', 'xhr'
+      def setup_response(request, response)
+        response.status = 204
+        response.set_allow_options_post
+        response.set_cache_control
+        response.set_access_control(request.origin)
+        response.set_session_id(request.session_id)
+      end
+    end
+    class XHRSendOptions < XHROptions
+      register 'OPTIONS', 'xhr_send'
+    end
+    class XHRStreamingOptions < XHROptions
+      register 'OPTIONS', 'xhr_streaming'
+    end
+    class XHRSendPost < DeliveryTransport
+      register 'POST', 'xhr_send'
+      def setup_response(request, response)
+        response.status = 204
+        response.set_content_type(:plain)
+        response.set_access_control(request.origin)
+        response.set_session_id(request.session_id)
+        response
+      end
+    end
+    class XHRPost < PollingConsumingTransport
+      register 'POST', 'xhr'
+      def setup_response(request, response)
+        response.status = 200
+        response.set_content_type(:javascript)
+        response.set_access_control(request.origin)
+        response.set_session_id(request.session_id)
+        response
+      end
+    end
+    class XHRStreamingPost < ConsumingTransport
+      PREAMBLE ||= "h" * 2048 + "\n"
+      register 'POST', 'xhr_streaming'
+      def setup_response(request, response)
+        response.status = 200
+        response.set_content_type(:javascript)
+        response.set_access_control(request.origin)
+        response.set_session_id(request.session_id)
+      end
+      def response_beginning(response)
+        response.write_head
+        response.write(PREAMBLE)
+      end
+      def handle_session_unavailable(error, response)
+        response.write(PREAMBLE)
+        super(error, response)
+      end
+    end
+  end
+end