goliath-rack_proxy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe3f590845b04b15e9d4c493890f3abb0128dbd4
+  data.tar.gz: 732ca21c6467a237ff05d39fb22e9fced483b051
+SHA512:
+  metadata.gz: 4dd788993d89ccf180919686374de9436c2623a2638def3b132bbdf7e885b7c79d261afb5ef7f9f2e90d25937289fc6a11b12f5eae1f0e6b0b74565408996ced
+  data.tar.gz: b48dd539d8afb09d0ff4e3966e5e73eac27f29d952408fc9429b1abb3d748c260352c32f8825010a16a75e11a357a8bb732c1ebc16bec9cc2177edc979aeec76

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Janko Marohnić
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# Goliath::RackProxy
+
+Allows you to use [Goliath] as a web server for your Rack app, giving you streaming requests and responses.
+
+## Motivation
+
+While developing [tus-ruby-server], a Rack application that handles large
+uploads and large downloads, I wanted to find an appropriate web server to
+recommend. I needed a web server that supports **streaming uploads**, allowing
+the Rack application to start processing the request while the request body is
+still being received, and that way giving it the ability to save whatever data
+it received before possible request interruptions. I also needed support for
+**streaming downloads**, sending response body in chunks back to the client.
+
+The only web server I found that supported all of this was [Unicorn]. However,
+Unicorn needs to spawn a whole process for serving each concurrent request,
+which isn't the most efficent use of server resources.
+
+Then I found [Goliath], which I found to provide the most flexibility in
+handling requests. It's built on top of [EventMachine], so it uses threads for
+serving requests, but it can also be run in hybrid mode. However, Goliath is
+more meant to be used standalone than in tandem with another Rack app.
+
+So I created a `Goliath::API` subclass that proxies incoming requests to the
+specified Rack app in a streaming fashion, making it act like a web server for
+the app.
+
+## Installation
+
+```rb
+gem "goliath-rack_proxy"
+```
+
+## Usage
+
+Create a file where you will initialize the Goliath Rack proxy:
+
+```rb
+# app.rb
+require "goliath/rack_proxy"
+
+class MyGoliathApp < Goliath::RackProxy
+  rack_app MyRackApp # provide your #call-able Rack application
+end
+```
+
+You can then run the server by running that Ruby file:
+
+```sh
+$ ruby app.rb
+```
+
+Any command-line arguments passed after the file will be forwarded to the
+Goliath server (see [list of available options][goliath server options]):
+
+```sh
+$ 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]:
+
+```sh
+$ einhorn -n COUNT -b 127.0.0.1:3000 ruby app.rb --einhorn
+```
+
+By default `Goliath::RackProxy` will use a rewindable `rack.input`, which means
+the data received from the client will be cached onto disk for the duration of
+the request. If you don't need the `rack.input` to be rewindable and want to
+save on disk I/O, you can disable caching:
+
+```rb
+class MyGoliathApp < Goliath::RackProxy
+  rack_app MyRackApp
+  rewindable_input false
+end
+```
+
+If you want to report any exceptions that might occur with the Rack app, you can
+override `Goliath::RackProxy#log_exception`:
+
+```rb
+class MyGoliathApp < Goliath::RackProxy
+  rack_app MyRackApp
+
+  def log_exception(exception, env)
+    super
+    Airbrake.notify(exception)
+  end
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[Goliath]: https://github.com/postrank-labs/goliath
+[EventMachine]: https://github.com/eventmachine/eventmachine
+[tus-ruby-server]: https://github.com/janko-m/tus-ruby-server
+[Unicorn]: https://github.com/defunkt/unicorn
+[goliath server options]: https://github.com/postrank-labs/goliath/wiki/Server
+[Einhorn]: https://github.com/stripe/einhorn

data/goliath-rack_proxy.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |gem|
+  gem.name         = "goliath-rack_proxy"
+  gem.version      = "0.1.0"
+
+  gem.required_ruby_version = ">= 2.1"
+
+  gem.summary      = "Allows you to use Goliath as a web server for your Rack app, giving you streaming requests and responses."
+
+  gem.homepage     = "https://github.com/janko-m/goliath-rack_proxy"
+  gem.authors      = ["Janko Marohnić"]
+  gem.email        = ["janko.marohnic@gmail.com"]
+  gem.license      = "MIT"
+
+  gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "*.gemspec"]
+  gem.require_path = "lib"
+
+  gem.add_dependency "goliath", ">= 1.0.5", "< 2"
+
+  gem.add_development_dependency "rake", "~> 11.1"
+  gem.add_development_dependency "minitest", "~> 5.8"
+  gem.add_development_dependency "http"
+  gem.add_development_dependency "rack", "~> 2.0"
+end

data/lib/goliath/rack_proxy.rb

@@ -0,0 +1,240 @@
+# frozen-string-literal: true
+require "goliath/rack_proxy/rack_2_compatibility"
+require "goliath"
+require "tempfile"
+
+module Goliath
+  class RackProxy < Goliath::API
+    # Rack app to proxy the incoming requests to.
+    def self.rack_app(app)
+      rack_proxy_options[:rack_app] = app
+    end
+
+    # Whether the input should be rewindable, i.e. cached onto disk.
+    def self.rewindable_input(value)
+      rack_proxy_options[:rewindable_input] = value
+    end
+
+    # Custom user-defined options.
+    def self.rack_proxy_options
+      @rack_proxy_options ||= {}
+    end
+
+    # 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)
+
+      # start the rack request asynchronously with the created rack input
+      async_rack_call rack_app, env.merge("rack.input" => env["rack_proxy.input"])
+    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)
+    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
+    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
+    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
+
+      # spawn a thread for the request
+      EM.defer do
+        rack_response = make_request(rack_app, env)
+
+        # 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) }
+        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"
+      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
+        @cache      = Tempfile.new("goliath-rack_input") if rewindable
+        @buffer     = nil
+      end
+
+      # Pops chunks of data from the queue and implements
+      # `IO#read(length = nil, outbuf = nil)` semantics.
+      def read(length = nil, outbuf = nil)
+        data = outbuf.clear if outbuf
+        data = @cache.read(length, outbuf) if @cache && !@cache.eof?
+
+        loop do
+          remaining_length = length - data.bytesize if data && length
+
+          break if remaining_length == 0
+
+          @buffer = @data_queue.pop or break if @buffer.nil?
+
+          buffered_data = if remaining_length && remaining_length < @buffer.bytesize
+                            @buffer.byteslice(0, remaining_length)
+                          else
+                            @buffer
+                          end
+
+          if data
+            data << buffered_data
+          else
+            data = buffered_data
+          end
+
+          @cache.write(buffered_data) if @cache
+
+          if buffered_data.bytesize < @buffer.bytesize
+            @buffer = @buffer.byteslice(buffered_data.bytesize..-1)
+          else
+            @buffer = nil
+          end
+        end
+
+        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?
+      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.
+      def rewind
+        raise Errno::ESPIPE if @cache.nil? # raised by other non-rewindable IOs
+        @cache.rewind
+      end
+
+      # Closes the queue and deletes the cache IO.
+      def close_read
+        @data_queue.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
+
+      # Conforming to the Rack specification.
+      def close
+        # no-op
+      end
+    end
+  end
+end

data/lib/goliath/rack_proxy/rack_2_compatibility.rb

@@ -0,0 +1,19 @@
+require "rack"
+
+# Async-rack attempts to require files that exist only in Rack 1.x even on Rack
+# 2.x, so we patch that behaviour to allow users to use this gem with Rack 2.x apps.
+module Kernel
+  if Rack.release >= "2.0.0"
+    alias original_rubygems_require require
+
+    def require(file)
+      case file
+      when "rack/commonlogger"   then original_rubygems_require("rack/common_logger")
+      when "rack/conditionalget" then original_rubygems_require("rack/conditional_get")
+      when "rack/showstatus"     then original_rubygems_require("rack/show_status")
+      else
+        original_rubygems_require(file)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: goliath-rack_proxy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: goliath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 
+email:
+- janko.marohnic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- goliath-rack_proxy.gemspec
+- lib/goliath/rack_proxy.rb
+- lib/goliath/rack_proxy/rack_2_compatibility.rb
+homepage: https://github.com/janko-m/goliath-rack_proxy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Allows you to use Goliath as a web server for your Rack app, giving you streaming
+  requests and responses.
+test_files: []