htttee 0.5.0

data/lib/htttee/server/chunked_body.rb

@@ -0,0 +1,22 @@
+module EY
+  module Tea
+    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 chunk(fragment)
+          "#{fragment.size.to_s(16)}\r\n#{fragment}\r\n"
+        end
+      end
+    end
+  end
+end

data/lib/htttee/server/ext/em-redis.rb

@@ -0,0 +1,49 @@
+module EventMachine
+  module Protocols
+    module Redis
+
+      def pipeline(*commands, &blk)
+        command = ''
+
+        commands.each do |argv|
+          command << "*#{argv.size}\r\n"
+          argv.each do |a|
+            a = a.to_s
+            command << "$#{get_size(a)}\r\n"
+            command << a
+            command << "\r\n"
+          end
+        end
+
+        maybe_lock do
+          commands.map {|c| c.first }.each do |command_name|
+            @redis_callbacks << [REPLY_PROCESSOR[command_name], blk]
+          end
+          send_data command
+        end
+      end
+
+      def multi(*command_groups, &blk)
+
+        command = "*1\r\n$5\r\nMULTI\r\n"
+
+        command_groups.each do |argv|
+          command << "*#{argv.size}\r\n"
+          argv.each do |a|
+            a = a.to_s
+            command << "$#{get_size(a)}\r\n"
+            command << a
+            command << "\r\n"
+          end
+        end
+
+        command << "*1\r\n$4\r\nEXEC\r\n"
+
+        maybe_lock do
+          @redis_callbacks << [REPLY_PROCESSOR['multi'], blk]
+          send_data command
+        end
+      end
+    end
+  end
+end

data/lib/htttee/server/ext/thin.rb

@@ -0,0 +1,4 @@
+require 'htttee/server/ext/thin/connection'
+require 'htttee/server/ext/thin/deferrable_body'
+require 'htttee/server/ext/thin/deferred_request'
+require 'htttee/server/ext/thin/deferred_response'

data/lib/htttee/server/ext/thin/connection.rb

@@ -0,0 +1,8 @@
+module Thin
+  class Connection
+    def post_init
+      @request  = DeferredRequest.new
+      @response = DeferredResponse.new
+    end
+  end
+end

data/lib/htttee/server/ext/thin/deferrable_body.rb

@@ -0,0 +1,24 @@
+module Thin
+  class DeferrableBody
+    include EventMachine::Deferrable
+
+    def initialize(initial_body = '')
+      @initial_body = initial_body.to_s
+    end
+
+    def call(body)
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+    end
+
+    def <<(*chunks)
+      call(chunks)
+    end
+
+    def each(&blk)
+      blk.call(@initial_body) unless @initial_body.empty?
+      @body_callback = blk
+    end
+  end
+end

data/lib/htttee/server/ext/thin/deferred_request.rb

@@ -0,0 +1,31 @@
+module Thin
+  class DeferredRequest < Request
+    def parse(data)
+      if @parser.finished?  # Header finished, can only be some more body
+        body << data
+      else                  # Parse more header using the super parser
+        @data << data
+        raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER
+
+        @nparsed = @parser.execute(@env, @data, @nparsed)
+
+        if @parser.finished?
+          return super(data) unless @env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+
+          _, initial_body = @data.split("\r\n\r\n")
+          initial_body ||= ''
+
+          @body = DeferrableBody.new(initial_body)
+
+          return true # trigger the rack call chain
+        end
+      end
+
+      return false  # only trigger the rack call chain once, just after the headers are parsed
+    end
+
+    def env
+      super.merge(RACK_INPUT => body)
+    end
+  end
+end

data/lib/htttee/server/ext/thin/deferred_response.rb

@@ -0,0 +1,4 @@
+module Thin
+  class DeferredResponse < Response
+  end
+end

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

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

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

@@ -0,0 +1,63 @@
+module EY
+  module Tea
+    module Server
+      class Dechunker
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env['rack.input'] = ChunkedBody.new(env['rack.input']) if chunked?(env)
+
+          @app.call(env)
+        end
+
+        def chunked?(env)
+          env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+        end
+
+        class ChunkedBody
+          extend Forwardable
+
+          CRLF = "\r\n"
+
+          attr_reader :input
+
+          def_delegators :input, :callback, :errback
+
+          def initialize(input)
+            @input, @buffer = input, ''
+          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.split(CRLF, 2)
+                blk.call(data)
+              else
+                return
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/htttee/server/mock.rb

@@ -0,0 +1,69 @@
+require 'rack/mux'
+
+module EY
+  module Tea
+    module Server
+      module Mock
+
+        def self.boot_forking_server
+          o,i = IO.pipe
+
+          if pid = fork
+            at_exit { Process.kill(:SIGTERM, pid) }
+
+            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
+
+          exit
+        end
+
+        class ThinMuxer
+          def initialize(app)
+            @app = Rack::Mux.new(async_safe(app), thin_options)
+          end
+
+          def call(env)
+            @app.call(env)
+          end
+
+          def async_safe(app)
+            AsyncFixer.new(app)
+          end
+
+          def thin_options
+            { :server => Thin, :environment => 'none' }
+          end
+        end
+
+        class EchoUri
+
+          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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/htttee/server/pubsub_redis.rb

@@ -0,0 +1,78 @@
+module EventMachine
+  module Protocols
+    class PubSubRedis < EventMachine::Connection
+      include Redis
+
+      def subscribe(channel, &block)
+        @pubsub_callback = block
+
+        call_command(['subscribe', channel])
+      end
+
+      def unsubscribe(channel)
+        @pubsub_callback = lambda do |*args|
+          close_connection
+        end
+
+        call_command(['unsubscribe', channel])
+      end
+
+      def dispatch_response(value)
+        if @multibulk_n
+          @multibulk_values << value
+          @multibulk_n -= 1
+
+          if @multibulk_n == 0
+            value = @multibulk_values
+            @multibulk_n,@multibulk_values = @previous_multibulks.pop
+            if @multibulk_n
+              dispatch_response(value)
+              return
+            end
+          else
+            return
+          end
+        end
+
+        @pubsub_callback.call(value)
+      end
+
+      def self.connect(*args)
+        case args.length
+        when 0
+          options = {}
+        when 1
+          arg = args.shift
+          case arg
+          when Hash then options = arg
+          when String then options = {:host => arg}
+          else raise ArgumentError, 'first argument must be Hash or String'
+          end
+        when 2
+          options = {:host => args[0], :port => args[1]}
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+        options[:host] ||= '127.0.0.1'
+        options[:port]   = (options[:port] || 6379).to_i
+        EM.connect options[:host], options[:port], self, options
+      end
+
+      def initialize(options = {})
+        @host           = options[:host]
+        @port           = options[:port]
+        @db             = (options[:db] || 0).to_i
+        @password       = options[:password]
+        @logger         = options[:logger]
+        @error_callback = lambda do |code|
+          err = RedisError.new
+          err.code = code
+          raise err, "Redis server returned error code: #{code}"
+        end
+
+        # These commands should be first
+        auth_and_select_db
+      end
+    end
+  end
+end

data/lib/htttee/version.rb

@@ -0,0 +1,5 @@
+module EY
+  module Tea
+    VERSION = '0.0.0'
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe EY::Tea::Client do
+  subject { @client }
+
+  def new_client
+    EY::Tea::Client.new(:endpoint => EY::Tea::Server.mock_uri.to_s)
+  end
+
+  def run(thread)
+    thread.join(0.1) if thread.alive?
+  end
+
+  it "can stream an IO" do
+    uuid = rand(10_000).to_s
+    o,i = IO.pipe
+    i << "Hello, World!"
+    i.close
+
+    new_client.up(o, uuid)
+
+    body = ''
+    new_client.down(uuid) do |chunk|
+      body << chunk
+    end
+    body.should == 'Hello, World!'
+  end
+
+  it "can stream out before the incoming stream has finished." do
+    scheduler = Thread.current
+    uuid = rand(10_000).to_s
+    o, i = IO.pipe
+    i << 'Hello, '
+
+    up_thread = Thread.new(new_client, o) do |client, reader|
+      run scheduler
+      client.up(reader, uuid)
+    end
+
+    down_thread = Thread.new(new_client, i, scheduler) do |client, writer|
+      run scheduler
+      client.down(uuid) do |chunk|
+        if chunk == 'Hello, '
+          writer << 'World!'
+          writer.close
+          run scheduler
+        end
+      end
+    end
+
+    run up_thread
+    run down_thread
+    run up_thread
+    run down_thread
+  end
+
+  it "streams already recieved data on an open stream to peers." do
+    scheduler = Thread.current
+    uuid = rand(10_000).to_s
+    o, i = IO.pipe
+
+    i << 'Existing Data'
+
+    up_thread = Thread.new(subject, o) do |client, reader|
+      run scheduler
+      client.up(reader, uuid)
+    end
+
+    down_thread = Thread.new(new_client) do |client|
+      run scheduler
+      Thread.current[:data] = ''
+
+      client.down(uuid) do |chunk|
+        Thread.current[:data] << chunk
+        run scheduler
+      end
+    end
+
+    run up_thread
+    run down_thread
+
+    down_thread[:data] == 'Existing Data'
+  end
+
+  it "streams the same data to all peers." do
+    scheduler = Thread.current
+    uuid = rand(10_000).to_s
+    o, i = IO.pipe
+
+    up_thread = Thread.new(new_client, o) do |client, reader|
+      client.up(reader, uuid)
+    end
+
+    run up_thread
+
+    down_threads = Array.new(5, new_client).map do |c|
+      Thread.new(c) do |client|
+        Thread.current[:chunks] = []
+        run scheduler
+
+        client.down(uuid) do |chunk|
+          Thread.current[:chunks] << chunk
+          run scheduler
+        end
+      end
+    end
+
+    i << "First Part"
+
+    down_threads.each {|t| run t }
+    down_threads.each {|t| t[:chunks].should == ['First Part'] }
+
+    i << "Second Part"
+
+    down_threads.each {|t| run t }
+    down_threads.each {|t| t[:chunks].should == ['First Part', 'Second Part'] }
+
+    i << "Third Part"
+
+    down_threads.each {|t| run t }
+    down_threads.each {|t| t[:chunks].should == ['First Part', 'Second Part', 'Third Part'] }
+
+    i.close
+  end
+
+end