rails-threaded-proxy 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbc7f9b0318c1136497926119e07a245bacd9d017126add8a1da34e7426d79e0
-  data.tar.gz: 6506ac75b092ad1530ef54ceaf5d4c75775b3589cb1db2648afef0598e54c9de
+  metadata.gz: 2aae2ccc6678cd9afd9e3068a996bfe1d163f0569512a9e37b958c749aeb8096
+  data.tar.gz: 14079d5dfc8a7319c54469d859d2cb5e055ba4fae94d80cebda8cb9968bcd076
 SHA512:
-  metadata.gz: 38bfa986e8033530bdddcf28a201ce18648bb8d8b46cd7d6738c8addc736aee573f685fc355d45072f6dcd4b632f22e5280891a67d56f7ccb75d9391d92300bb
-  data.tar.gz: 5a03daa8831574b0dc693916f11a7ebc8bfe8f409578a45e1de82f0f849b60c76dab4c929bf7c91322030f74ce6060df0eb99fdbab28390641df81f195844959
+  metadata.gz: eb6a536989c9b554b79ce943ed143e65a1985b7d535dac729cc7b90f01961eda02325134201e6a027d34775cafde12aa084264cce5a9c59c4c88b9b9a31b147f
+  data.tar.gz: a4c6056afd3971cf18cd9d2ab5e2e3739b0c76a922c655024d1e34f00069b8cbe42f376c1611c040948798b767663e1a0eb7ad7ec6753af90b4e0fc3727808f9

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 James Hu
+Copyright (c) 2024 Michael Nutt
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -0,0 +1,46 @@
+# rails-threaded-proxy
+
+Asynchronous high throughput reverse proxy for rails
+
+*Warning: experimental. Use at your own risk.*
+
+## About
+
+Rails concurrency is often limited to running many processes, which can be memory-intensive. Even for servers that support threads, it can be difficult running dozens or hundreds of threads. But you may have backend services that are slow to respond, and/or return very large responses. It is useful to put these services behind rails for authentication, but slow responses can tie up your rails workers preventing them from serving other clients.
+
+`rails-threaded-proxy` disconnects the proxying from the rack request/response cycle, freeing up workers to serve other clients. It does this by running the origin request in a thread. But running in a thread is not enough: we need to be able to respond to the rails request, but rack owns the socket. So it hijacks the request: rack completes immediately but dissociates from the socket. Then we're free to manage the socket ourselves. Copying between sockets, we can achieve high throughput (100MB/s+) with minimal CPU and memory overhead.
+
+## Usage
+
+```ruby
+class MyController
+  include ThreadedProxy::Controller
+
+  def my_backend
+    proxy_fetch "http://backend.service/path/to/endpoint", method: :post do |config|
+      config.on_headers do |client_response|
+        # override some response headers coming from the backend
+        client_response['content-security-policy'] = "sandbox;"
+      end
+    end
+  end
+end
+```
+
+## Requirements
+
+Tested with Rails 7, but probably works in Rails 6+. Needs an application server that supports `rack.hijack`. (only tested on [https://puma.io/](Puma) so far)
+
+## Caveats
+
+* There isn't currently a way to limit concurrency. It is possible to run your server out of file descriptors, memory, etc.
+* Since the proxying happens in a thread, callbacks are also run inside of the thread. Don't do anything non-threadsafe in callbacks.
+* There is currently probably not sufficient error handling for edge cases. This is experimental.
+
+## Attribution
+
+Inspired by [https://github.com/axsuul/rails-reverse-proxy](rails-reverse-proxy), and tries to use similar API structure where possible. If you don't care about the specific benefits of `rails-threaded-proxy`, you should consider using `rails-reverse-proxy` instead.
+
+## License
+
+See LICENSE

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/threaded_proxy/client.rb

@@ -9,7 +9,7 @@ module ThreadedProxy
   class Client
     DISALLOWED_RESPONSE_HEADERS = %w[keep-alive].freeze
 
-    METHODS = {
+    HTTP_METHODS = {
       'get' => Net::HTTP::Get,
       'post' => Net::HTTP::Post,
       'put' => Net::HTTP::Put,
@@ -19,6 +19,20 @@ module ThreadedProxy
       'trace' => Net::HTTP::Trace
     }.freeze
 
+    CALLBACK_METHODS = %i[
+      on_response
+      on_headers
+      on_body
+      on_complete
+      on_error
+    ].freeze
+
+    CALLBACK_METHODS.each do |method_name|
+      define_method(method_name) do |&block|
+        @callbacks[method_name] = block
+      end
+    end
+
     DEFAULT_OPTIONS = {
       headers: {},
       debug: false,
@@ -28,6 +42,13 @@ module ThreadedProxy
     def initialize(origin_url, options = {})
       @origin_url = Addressable::URI.parse(origin_url)
       @options = DEFAULT_OPTIONS.merge(options)
+
+      @callbacks = {}
+      CALLBACK_METHODS.each do |method_name|
+        @callbacks[method_name] = proc {}
+      end
+
+      yield(self) if block_given?
     end
 
     def log(message)
@@ -38,7 +59,7 @@ module ThreadedProxy
       request_method = @options[:method].to_s.downcase
       request_headers = @options[:headers].merge('Connection' => 'close')
 
-      request_class = METHODS[request_method]
+      request_class = HTTP_METHODS[request_method]
       http_request = request_class.new(@origin_url, request_headers)
       if @options[:body].respond_to?(:read)
         http_request.body_stream = @options[:body]
@@ -55,21 +76,15 @@ module ThreadedProxy
 
         http.start do
           http.request(http_request) do |client_response|
-            # We don't support reusing connections once we have disconnected them from rack
-            client_response['connection'] = 'close'
+            @callbacks[:on_response].call(client_response, socket)
+            break if socket.closed?
 
-            yield client_response if block_given?
-
-            # start writing response
             log('Writing response status and headers')
-            socket.write "HTTP/1.1 #{client_response.code} #{client_response.message}\r\n"
-
-            client_response.each_header do |key, value|
-              socket.write "#{key}: #{value}\r\n" unless DISALLOWED_RESPONSE_HEADERS.include?(key.downcase)
-            end
+            write_headers(client_response, socket)
+            break if socket.closed?
 
-            # Done with headers
-            socket.write "\r\n"
+            @callbacks[:on_body].call(client_response, socket)
+            break if socket.closed?
 
             # There may have been some existing data in client_response's read buffer, flush it out
             # before we manually connect the raw sockets
@@ -79,11 +94,32 @@ module ThreadedProxy
             # Copy the rest of the client response to the socket
             log('Copying response body to client')
             http.copy_to(socket)
+
+            @callbacks[:on_complete].call(client_response)
           end
+        rescue StandardError => e
+          @callbacks[:on_error].call(e) or raise
         end
       end
     end
 
+    def write_headers(client_response, socket)
+      socket.write "HTTP/1.1 #{client_response.code} #{client_response.message}\r\n"
+
+      # We don't support reusing connections once we have disconnected them from rack
+      client_response['connection'] = 'close'
+
+      @callbacks[:on_headers].call(client_response, socket)
+      return if socket.closed?
+
+      client_response.each_header do |key, value|
+        socket.write "#{key}: #{value}\r\n" unless DISALLOWED_RESPONSE_HEADERS.include?(key.downcase)
+      end
+
+      # Done with headers
+      socket.write "\r\n"
+    end
+
     def default_port(uri)
       case uri.scheme
       when 'http'

data/lib/threaded_proxy/controller.rb

@@ -4,7 +4,7 @@ require_relative 'client'
 
 module ThreadedProxy
   module Controller
-    def proxy_fetch(origin_url, options = {})
+    def proxy_fetch(origin_url, options = {}, &block)
       # hijack the response so we can take it outside of the rack request/response cycle
       request.env['rack.hijack'].call
       socket = request.env['rack.hijack_io']
@@ -25,7 +25,7 @@ module ThreadedProxy
           options[:headers]['Content-Type'] = request.env['CONTENT_TYPE'] if request.env['CONTENT_TYPE']
         end
 
-        client = Client.new(origin_url, options)
+        client = Client.new(origin_url, options, &block)
         client.start(socket)
       rescue Errno::EPIPE
         # client disconnected before request finished; not an error

data/rails-threaded-proxy.gemspec

@@ -2,21 +2,22 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: rails-threaded-proxy 0.3.0 ruby lib
+# stub: rails-threaded-proxy 0.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-threaded-proxy".freeze
-  s.version = "0.3.0".freeze
+  s.version = "0.4.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Michael Nutt".freeze]
-  s.date = "2024-10-14"
+  s.date = "2024-10-15"
   s.description = "Threaded reverse proxy for Ruby on Rails".freeze
   s.email = "michael@nuttnet.net".freeze
   s.executables = ["bundle".freeze, "htmldiff".freeze, "jeweler".freeze, "ldiff".freeze, "nokogiri".freeze, "racc".freeze, "rackup".freeze, "rake".freeze, "rdoc".freeze, "ri".freeze, "rspec".freeze, "rubocop".freeze, "semver".freeze]
   s.extra_rdoc_files = [
-    "LICENSE"
+    "LICENSE",
+    "README.md"
   ]
   s.files = [
     ".bundle/config",
@@ -26,6 +27,7 @@ Gem::Specification.new do |s|
     "Gemfile",
     "Gemfile.lock",
     "LICENSE",
+    "README.md",
     "Rakefile",
     "VERSION",
     "bin/bundle",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-threaded-proxy
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Michael Nutt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-14 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -155,6 +155,7 @@ executables:
 extensions: []
 extra_rdoc_files:
 - LICENSE
+- README.md
 files:
 - ".bundle/config"
 - ".rspec"
@@ -163,6 +164,7 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE
+- README.md
 - Rakefile
 - VERSION
 - bin/bundle