htttee 0.5.0 → 0.6.0

data/lib/htttee/server/chunked_body.rb

@@ -1,21 +1,19 @@
-module EY
-  module Tea
-    module Server
-      class ChunkedBody < Thin::DeferrableBody
-        def call(body)
-          body.each do |fragment|
-            @body_callback.call(chunk(fragment))
-          end
+module HTTTee
+  module Server
+    class ChunkedBody < Thin::DeferrableBody
+      def call(body)
+        body.each do |fragment|
+          @body_callback.call(chunk(fragment))
         end
+      end
 
-        def succeed(*a)
-          @body_callback.call("0\r\n\r\n")
-          super
-        end
+      def succeed(*a)
+        @body_callback.call("0\r\n\r\n")
+        super
+      end
 
-        def chunk(fragment)
-          "#{fragment.size.to_s(16)}\r\n#{fragment}\r\n"
-        end
+      def chunk(fragment)
+        "#{fragment.size.to_s(16)}\r\n#{fragment}\r\n"
       end
     end
   end

data/lib/htttee/server/middleware/async_fixer.rb

@@ -1,20 +1,17 @@
+module HTTTee
+  module Server
+    class AsyncFixer
+      def initialize(app)
+        @app = app
+      end
 
-module EY
-  module Tea
-    module Server
-      class AsyncFixer
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          tuple = @app.call(env)
+      def call(env)
+        tuple = @app.call(env)
 
-          if tuple.first == -1
-            Thin::Connection::AsyncResponse
-          else
-            tuple
-          end
+        if tuple.first == -1
+          Thin::Connection::AsyncResponse
+        else
+          tuple
         end
       end
     end

data/lib/htttee/server/middleware/dechunker.rb

@@ -1,59 +1,58 @@
-module EY
-  module Tea
-    module Server
-      class Dechunker
-        def initialize(app)
-          @app = app
-        end
+module HTTTee
+  module Server
+    class Dechunker
+      def initialize(app)
+        @app = app
+      end
 
-        def call(env)
-          env['rack.input'] = ChunkedBody.new(env['rack.input']) if chunked?(env)
+      def call(env)
+        env['rack.input'] = ChunkedBody.new(env['rack.input']) if chunked?(env)
 
-          @app.call(env)
-        end
+        @app.call(env)
+      end
 
-        def chunked?(env)
-          env['HTTP_TRANSFER_ENCODING'] == 'chunked'
-        end
+      def chunked?(env)
+        env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+      end
 
-        class ChunkedBody
-          extend Forwardable
+      class ChunkedBody
+        extend Forwardable
 
-          CRLF = "\r\n"
+        CRLF = "\r\n"
 
-          attr_reader :input
+        attr_reader :input
 
-          def_delegators :input, :callback, :errback
+        def_delegators :input, :callback, :errback
 
-          def initialize(input)
-            @input, @buffer = input, ''
-          end
+        def initialize(input)
+          @input, @buffer = input, ''
+        end
 
-          def each(&blk)
-            @input.each do |chunk|
-              dechunk(chunk, &blk)
-            end
+        def each(&blk)
+          @input.each do |chunk|
+            dechunk(chunk, &blk)
           end
+        end
+
+        def dechunk(chunk, &blk)
+          @buffer << chunk
+
+          loop do
+            return unless @buffer[CRLF]
+
+            string_length, remainder = @buffer.split(CRLF, 2)
+            length = string_length.to_i(16)
+
+            if length == 0
+              @buffer = ''
+              @input.succeed
+              return
+            elsif remainder.size >= length + 2 # length + CRLF
+              data, @buffer = remainder[0...length], remainder[(length+2)..-1]
 
-          def dechunk(chunk, &blk)
-            @buffer << chunk
-
-            loop do
-              return unless @buffer[CRLF]
-
-              string_length, remainder = @buffer.split(CRLF, 2)
-              length = string_length.to_i(16)
-
-              if length == 0
-                @buffer = ''
-                @input.succeed
-                return
-              elsif remainder.size >= length + 2 # length + CRLF
-                data, @buffer = remainder.split(CRLF, 2)
-                blk.call(data)
-              else
-                return
-              end
+              blk.call(data)
+            else
+              return
             end
           end
         end

data/lib/htttee/server/middleware/rechunker.rb

@@ -0,0 +1,15 @@
+module HTTTee
+  module Server
+    class Rechunker
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env['rack.response_body'] = ChunkedBody.new
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/htttee/server/mock.rb

@@ -1,66 +1,64 @@
 require 'rack/mux'
 
-module EY
-  module Tea
-    module Server
-      module Mock
+module HTTTee
+  module Server
+    module Mock
 
-        def self.boot_forking_server
-          o,i = IO.pipe
+      def self.boot_forking_server
+        o,i = IO.pipe
 
-          if pid = fork
-            at_exit { Process.kill(:SIGTERM, pid) }
+        if pid = fork
+          at_exit { Process.kill(:SIGTERM, pid) }
 
-            i.close
-            URI.parse(o.read)
-          else
-            o.close
-            process_child(i)
-          end
+          i.close
+          URI.parse(o.read)
+        else
+          o.close
+          process_child(i)
         end
+      end
 
-        def self.process_child(i)
-          EM.run do
-            client = Rack::Client.new { run EY::Tea::Server.mock_app }
-
-            uri = client.get("/mux-uri").body
-            i << uri
-            i.close
-          end
+      def self.process_child(i)
+        EM.run do
+          client = Rack::Client.new { run HTTTee::Server.mock_app }
 
-          exit
+          uri = client.get("/mux-uri").body
+          i << uri
+          i.close
         end
 
-        class ThinMuxer
-          def initialize(app)
-            @app = Rack::Mux.new(async_safe(app), thin_options)
-          end
+        exit
+      end
 
-          def call(env)
-            @app.call(env)
-          end
+      class ThinMuxer
+        def initialize(app)
+          @app = Rack::Mux.new(async_safe(app), thin_options)
+        end
 
-          def async_safe(app)
-            AsyncFixer.new(app)
-          end
+        def call(env)
+          @app.call(env)
+        end
 
-          def thin_options
-            { :server => Thin, :environment => 'none' }
-          end
+        def async_safe(app)
+          AsyncFixer.new(app)
+        end
+
+        def thin_options
+          { :server => Thin, :environment => 'none' }
         end
+      end
 
-        class EchoUri
+      class EchoUri
 
-          def initialize(app)
-            @app = app
-          end
+        def initialize(app)
+          @app = app
+        end
 
-          def call(env)
-            if env['PATH_INFO'] == '/mux-uri'
-              [200, {'Content-Type' => 'text/plain'}, [env['X-Mux-Uri']]]
-            else
-              @app.call(env)
-            end
+        def call(env)
+          if env['PATH_INFO'] == '/mux-uri'
+            [200, {'Content-Type' => 'text/plain'}, [env['X-Mux-Uri']]]
+          else
+            @app.call(env)
           end
         end
       end

data/lib/htttee/server/pubsub_redis.rb

@@ -73,6 +73,10 @@ module EventMachine
         # These commands should be first
         auth_and_select_db
       end
+
+      def unbind
+        @logger.debug { "Disconnected" }  if @logger
+      end
     end
   end
 end

data/lib/htttee/server/sse/body.rb

@@ -0,0 +1,71 @@
+module HTTTee
+  module Server
+    module SSE
+      class Body
+        include EventMachine::Deferrable
+
+        MESSAGE = 'message'
+        CTRL    = 'ctrl'
+        EOF     = 'eof'
+
+        CTRL_TABLE = {
+          "\n"    => 'newline',
+          "\r"    => 'carriage-return',
+          "\r \n" => 'crlf',
+        }
+
+        def initialize(body)
+          @body = body
+        end
+
+        def call(chunks)
+          chunks.each do |chunk|
+            send_chunk(chunk)
+          end
+        end
+
+        def send_chunk(chunk)
+          data, ctrl, remaining = chunk.partition(%r{\r \n|\n|\r})
+
+          send_data(data)             unless data.empty?
+          send_ctrl(CTRL_TABLE[ctrl]) unless ctrl.empty?
+          send_chunk(remaining)       unless remaining.empty?
+        end
+
+        def send_data(data)
+          send_event(MESSAGE)
+
+          send_message(data)
+        end
+
+        def send_ctrl(type)
+          send_event(CTRL)
+
+          send_message(type)
+        end
+
+        def send_message(data)
+          send "data", data, "\n\n"
+        end
+
+        def send_event(event)
+          send "event", event, "\n"
+        end
+
+        def send(type, data, term)
+          @body.call(["#{type}: #{data}#{term}"])
+        end
+
+        def succeed
+          send_ctrl(EOF)
+
+          @body.succeed
+        end
+
+        def each(&blk)
+          @body.each(&blk)
+        end
+      end
+    end
+  end
+end

data/lib/htttee/server/sse/middleware.rb

@@ -0,0 +1,96 @@
+module HTTTee
+  module Server
+    module SSE
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          if sse_request?(env)
+            wrap(env)
+          elsif sse_supported?(env)
+            return sse_shell
+          end
+
+          @app.call(env)
+        end
+
+        def wrap(env)
+          env['rack.response_body'] = SSE::Body.new(env['rack.response_body'])
+
+          cb = env['async.callback']
+
+          env['async.callback'] = lambda do |(status, headers, body)|
+            cb.call([status, headers.merge('Content-Type' => 'text/event-stream', 'Connection' => 'Keep-Alive'), body])
+          end
+        end
+
+        def sse_request?(env)
+          env['HTTP_ACCEPT'] == 'text/event-stream'
+        end
+
+        def sse_supported?(env)
+          env['HTTP_USER_AGENT'].to_s =~ /WebKit/ &&
+            env['HTTP_ACCEPT'] =~ %r{text/html}
+        end
+
+        def sse_shell
+          [200, {'Content-Type' => 'text/html'}, [<<-HTML]]
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.1/jquery.min.js"></script>
+</head>
+<body><pre><code></code></pre>
+  <script>
+    var source = new EventSource(window.location.pathname);
+    var body = $("html,body");
+    var cursor = $("pre code")[0];
+    var resetLine = false;
+
+    function append(data) {
+      if(resetLine == true) {
+        cursor.innerHTML = data;
+      } else {
+        cursor.innerHTML += data;
+      }
+
+      resetLine = false;
+    }
+
+    source.onmessage = function(e) {
+      append(e.data);
+    };
+
+    source.onerror = function(e) {
+      console.log(e);
+    };
+
+    source.addEventListener('ctrl', function(e) {
+      if(e.data == 'newline') {
+        append("\\n");
+        cursor = $("<code></code>").insertAfter(cursor)[0];
+      } else if(e.data == 'crlf' || e.data == 'carriage-return') {
+        resetLine = true;
+      } else if(e.data == 'eof') {
+        source.close();
+      } else {
+        console.log(e);
+      }
+    }, false);
+
+    window.setInterval(function(){
+      window.scrollTo(0, document.body.scrollHeight);
+    }, 100);
+
+  </script>
+</body>
+</html>
+          HTML
+        end
+      end
+    end
+  end
+end