goliath-rack_proxy 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 286f8e3a28f2ed207430e4107674e0d63c6fc402
-  data.tar.gz: 25876f371228c74715d45ff096825fa3b84c5294
+  metadata.gz: ca389756f31e83a5660faf6628a02cdc94c42431
+  data.tar.gz: 2b5c39cba40a5a989870b8e2acc2548b3e7c6bdc
 SHA512:
-  metadata.gz: 33c54b664d86d967ad1fd1bcf2fc8c5996ceae9c4586c791572731466137d3c401fd6b9fad7737232e74b8d0dc4b53e0a7336979ca69abd22d97b3a6b93ae6a2
-  data.tar.gz: '0957145d2940f2ea7a384082b40ffabec5c60cb6854d01f9e330036ccef634ac90487194b65a65ee481faa9d05b35994df4f4e6a442eca5d579d4376700090d7'
+  metadata.gz: 51840456dab796caa37a5390b58e85cf5b5a4be37c40cae3caaa094aae32a2c9514046425f27400654c2933af01fd532784873259432bb11888ec413bd732c67
+  data.tar.gz: 8c2fac7e1676038be1da9b58e38f5f27da879341324a6b5c810949ac8d18729d9c9f293b84cdba033b5ad61f472820fa3947c87bda1993372d91f0b552a170b9

data/README.md

@@ -57,14 +57,7 @@ Goliath server (see [list of available options][goliath server options]):
 $ ruby app.rb --port 3000 --stdout
 ```
 
-This will run a single EventMachine process, which by default uses a pool of
-20 threads. You can increase the number of threads EventMachine uses:
-
-```rb
-EventMachine.threadpool_size = 100
-```
-
-You can also spawn multiple EventMachine processes using [Einhorn]:
+You can scale Goliath applications into multiple processes using [Einhorn]:
 
 ```sh
 $ einhorn -n COUNT -b 127.0.0.1:3000 ruby app.rb --einhorn

data/goliath-rack_proxy.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name         = "goliath-rack_proxy"
-  gem.version      = "0.1.3"
+  gem.version      = "1.0.0"
 
   gem.required_ruby_version = ">= 2.1"
 
@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "*.gemspec"]
   gem.require_path = "lib"
 
-  gem.add_dependency "goliath", ">= 1.0.5", "< 2"
+  gem.add_dependency "goliath", ">= 1.0.6", "< 2"
 
   gem.add_development_dependency "rake", "~> 11.1"
   gem.add_development_dependency "minitest", "~> 5.8"

data/lib/goliath/rack_proxy.rb

@@ -2,6 +2,7 @@
 require "goliath/rack_proxy/rack_2_compatibility"
 require "goliath"
 require "tempfile"
+require "fiber"
 
 module Goliath
   class RackProxy < Goliath::API
@@ -22,151 +23,62 @@ module Goliath
 
     # Called when request headers were parsed.
     def on_headers(env, headers)
-      # assign a streaming input that acts as a bidirectional pipe
-      env["rack_proxy.input"] = RackInput.new(rewindable: self.class.rack_proxy_options.fetch(:rewindable_input, true))
-      rack_app = self.class.rack_proxy_options.fetch(:rack_app)
+      rack_app         = self.class.rack_proxy_options.fetch(:rack_app)
+      rewindable_input = self.class.rack_proxy_options.fetch(:rewindable_input, true)
 
-      # start the rack request asynchronously with the created rack input
-      async_rack_call rack_app, env.merge("rack.input" => env["rack_proxy.input"])
+      env["rack_proxy.call"] = RackCall.new(rack_app, env, rewindable_input: rewindable_input)
+      env["rack_proxy.call"].resume
     end
 
     # Called on each request body chunk received from the client.
     def on_body(env, data)
       # write data to the input, which will be read by the Rack app
-      env["rack_proxy.input"].write(data)
+      env["rack_proxy.call"].resume(data)
     end
 
     # Called at the end of the request (after #response) or on client disconnect.
     def on_close(env)
       # reading the request body has finished, so we close write end of the input
-      env["rack_proxy.input"].close_write
+      env["rack_proxy.call"].resume
     end
 
     # Called after all the data has been received from the client.
     def response(env)
-      # reading the request body has finished, so we close write end of the input
-      env["rack_proxy.input"].close_write
-
-      # prevent Goliath from sending a response, we will send it once the
-      # asynchronous request to the rack app finishes
-      nil
+      env["rack_proxy.call"].resume
     end
 
     private
 
-    # Spawns a thread and initiates the call to the Rack application, which
-    # will be reading from Rack input that is being written to in #on_body. Once
-    # the request has finished, we stream the response back to the client.
-    def async_rack_call(rack_app, env)
-      env["goliath.request"] = env["stream.start"].binding.receiver # https://github.com/postrank-labs/goliath/pull/341
+    class RackCall
+      def initialize(app, env, rewindable_input: true)
+        @fiber = Fiber.new do
+          rack_input = RackInput.new(rewindable: rewindable_input) { Fiber.yield }
+
+          result = app.call env.merge(
+            "rack.input"     => rack_input,
+            "async.callback" => nil, # prevent Roda/Sinatra from calling EventMachine while streaming the response
+          )
 
-      # spawn a thread for the request
-      EM.defer do
-        rack_response = make_request(rack_app, env)
+          rack_input.close
 
-        # wait for client to stop sending data before sending the response
-        env["goliath.request"].callback do
-          # spawn a thread for the response
-          EM.defer { send_response(rack_response, env) }
+          result
         end
       end
-    end
-
-    def make_request(rack_app, env)
-      # call the rack app with some patches
-      rack_app.call env.merge(
-        "rack.url_scheme" => env["options"][:ssl] ? "https" : "http", # https://github.com/postrank-labs/goliath/issues/210
-        "async.callback"  => nil, # prevent Roda/Sinatra from calling EventMachine while streaming the response
-      )
-    rescue Exception => exception
-      # log the exception that occurred
-      log_exception(exception, env)
-
-      # return a generic error message on production, or a more detailed one otherwise
-      body    = Goliath.env?(:production) ? ["An error occurred"] : [exception.inspect]
-      headers = {"Content-Length" => body[0].bytesize.to_s}
-
-      [500, headers, body]
-    ensure
-      # request has finished, so we close the read end of the rack input
-      env["rack.input"].close_read
-    end
 
-    # Streams the response to the client.
-    def send_response(rack_response, env)
-      request    = env["goliath.request"]
-      connection = request.conn
-      response   = request.response
-
-      response.status, response.headers, response.body = rack_response
-      response.each { |data| connection.send_data(data) }
-
-      connection.terminate_request(keep_alive?(env))
-    rescue Exception => exception
-      # log the exception that occurred
-      log_exception(exception, env)
-
-      # communicate that sending response failed and close the connection
-      connection.send_data("HTTP/1.1 500 Internal Server Error\r\n\r\n")
-      connection.terminate_request(false)
-    ensure
-      # log the response information
-      log_response(response, env)
-    end
-
-    # Returns whether the TCP connection should be kept alive.
-    def keep_alive?(env)
-      if env["HTTP_VERSION"] >= "1.1"
-        # HTTP 1.1: all requests are persistent requests, client must
-        # send a "Connection: close" header to indicate otherwise
-        env["HTTP_CONNECTION"].to_s.downcase != "close"
-      elsif env["HTTP_VERSION"] == "1.0"
-        # HTTP 1.0: all requests are non keep-alive, client must
-        # send a "Connection: Keep-Alive" to indicate otherwise
-        env["HTTP_CONNECTION"].to_s.downcase == "keep-alive"
+      def resume(data = nil)
+        @result = @fiber.resume(data) if @fiber.alive?
+        @result
       end
     end
 
-    # Logs the response in the Rack::CommonLogger format.
-    def log_response(response, env)
-      length = response.headers["Content-Length"]
-      length = nil if length.to_s == "0"
-
-      # log the response as Goliath would log it
-      env.logger.info '%s - %s [%s] "%s %s%s %s" %d %s %0.4f' % [
-        env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-        env["REQUEST_METHOD"],
-        env["PATH_INFO"],
-        env["QUERY_STRING"].empty? ? "" : "?#{env["QUERY_STRING"]}",
-        env["HTTP_VERSION"],
-        response.status,
-        length || "-",
-        Time.now.to_f - env[:start_time],
-      ]
-    end
-
-    # Logs the exception and adds it to the env hash.
-    def log_exception(exception, env)
-      # mimic how Ruby would display the error
-      stderr = "#{exception.backtrace[0]}: #{exception.message} (#{exception.class})\n".dup
-      exception.backtrace[1..-1].each do |line|
-        stderr << "    from #{line}\n"
-      end
-      env.logger.error(stderr)
-
-      # save the exception in the env hash
-      env["rack.exception"] = exception
-    end
-
     # IO-like object that acts as a bidirectional pipe, which returns the data
     # that has been written to it.
     class RackInput
-      def initialize(rewindable: true)
-        @data_queue = Queue.new
+      def initialize(rewindable: true, &next_chunk)
+        @next_chunk = next_chunk
         @cache      = Tempfile.new("goliath-rack_input") if rewindable
         @buffer     = nil
+        @eof        = false
       end
 
       # Pops chunks of data from the queue and implements
@@ -180,7 +92,7 @@ module Goliath
 
           break if remaining_length == 0
 
-          @buffer = @data_queue.pop or break if @buffer.nil?
+          @buffer = next_chunk or break if @buffer.nil?
 
           buffered_data = if remaining_length && remaining_length < @buffer.bytesize
                             @buffer.byteslice(0, remaining_length)
@@ -206,12 +118,6 @@ module Goliath
         data.to_s unless length && (data.nil? || data.empty?)
       end
 
-      # Pushes data to the queue, which is then popped in #read.
-      def write(data)
-        @data_queue.push(data) unless @data_queue.closed?
-      rescue ClosedQueueError
-      end
-
       # Rewinds the cache IO if it's configured, otherwise raises Errno::ESPIPE
       # exception, which mimics the behaviour of caling #rewind on
       # non-rewindable IOs such as pipes, sockets, and ttys.
@@ -220,21 +126,20 @@ module Goliath
         @cache.rewind
       end
 
-      # Closes the queue and deletes the cache IO.
-      def close_read
-        @data_queue.close
+      # Conforming to the Rack specification.
+      def close
         @cache.close! if @cache
       end
 
-      # Closes the queue, which prevents fruther pushing, but #read can still
-      # pop remaining chunks from it.
-      def close_write
-        @data_queue.close
-      end
+      private
 
-      # Conforming to the Rack specification.
-      def close
-        # no-op
+      # Retrieves the next chunk by calling the block, and marks EOF when nil
+      # was returned.
+      def next_chunk
+        return if @eof
+        chunk = @next_chunk.call
+        @eof = true if chunk.nil?
+        chunk
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goliath-rack_proxy
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-26 00:00:00.000000000 Z
+date: 2017-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: goliath
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.0.6
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.0.6
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'