rails-threaded-proxy 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 627edadeb8a4d381699398dcd596285b425994116b21393d5a1c4b61f91bf195
-  data.tar.gz: '0066744825548c505bf61585302e20a011761f7198f12cdb34fa9f79607317c4'
+  metadata.gz: 8d77c14092a49dc2e231f233da21a934600a5159aabbc6bbb40294404c8e49d7
+  data.tar.gz: 8590d4359939c617098a036435c340623de538fcb5a65bbd15fe1b72726be86b
 SHA512:
-  metadata.gz: 52d909c71d9657f8e0f5f601bb4478979dfb4971bbf93230067172cd0077fbfc77601b9a1bc76f27b94f01185f83e07c08540eacbea70c612e66211d0cca4bb3
-  data.tar.gz: 108158c59c1b87c72e6559cb7fdb535d1c05819a581f321feff8679ea4213491a37c7dd204fc55357dbdf9bfc6a3e7724fa4223c488036b53a20594c235a7d56
+  metadata.gz: 7704567ef587afce79dbf21ce20f67add2e04c87cbc1efb7fbb3491cc7a95e01e05a8b7881917a64073caca7f4769c07814d22038f06fce045aa80b07f00b501
+  data.tar.gz: 025e8d6eda736b0ffa5c8f8e97d47941f64b06081b4a3a2164c6288a337b50d7325d64971c89fab35622f9c383dad0941584f1e1e4bf80d2a9c99bc4be20501b

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/lib/threaded_proxy/client.rb

@@ -2,10 +2,15 @@
 
 require 'addressable/uri'
 require 'active_support/notifications'
+require 'action_dispatch'
 require 'net/http'
+
 require_relative 'http'
+require_relative 'socket_responder'
 
 module ThreadedProxy
+  class ResponseBodyAlreadyConsumedError < StandardError; end
+
   class Client
     DISALLOWED_RESPONSE_HEADERS = %w[keep-alive].freeze
 
@@ -22,7 +27,6 @@ module ThreadedProxy
     CALLBACK_METHODS = %i[
       on_response
       on_headers
-      on_body
       on_complete
       on_error
     ].freeze
@@ -42,11 +46,13 @@ module ThreadedProxy
     def initialize(origin_url, options = {})
       @origin_url = Addressable::URI.parse(origin_url)
       @options = DEFAULT_OPTIONS.merge(options)
+      @wrote_headers = false
 
       @callbacks = {}
-      CALLBACK_METHODS.each do |method_name|
+      (CALLBACK_METHODS - [:on_error]).each do |method_name|
         @callbacks[method_name] = proc {}
       end
+      @callbacks[:on_error] = proc { |e| raise e }
 
       yield(self) if block_given?
     end
@@ -67,6 +73,8 @@ module ThreadedProxy
         http_request.body = @options[:body]
       end
 
+      socket_responder = SocketResponder.new(socket)
+
       ActiveSupport::Notifications.instrument('threaded_proxy.fetch', method: request_method, url: @origin_url.to_s,
                                                                       headers: request_headers) do
         http = HTTP.new(@origin_url.host, @origin_url.port || default_port(@origin_url))
@@ -76,15 +84,14 @@ module ThreadedProxy
 
         http.start do
           http.request(http_request) do |client_response|
-            @callbacks[:on_response].call(client_response, socket)
+            @callbacks[:on_response].call(client_response, socket_responder)
             break if socket.closed?
 
             log('Writing response status and headers')
             write_headers(client_response, socket)
             break if socket.closed?
 
-            @callbacks[:on_body].call(client_response, socket)
-            break if socket.closed?
+            raise ResponseBodyAlreadyConsumedError if client_response.read?
 
             # There may have been some existing data in client_response's read buffer, flush it out
             # before we manually connect the raw sockets
@@ -97,9 +104,13 @@ module ThreadedProxy
 
             @callbacks[:on_complete].call(client_response)
           end
-        rescue StandardError => e
-          @callbacks[:on_error].call(e) or raise
         end
+      rescue StandardError => e
+        @callbacks[:on_error].call(e, socket_responder)
+        # Default to 500 if the error callback didn't write a response
+        socket_responder.render(status: 500, text: 'Internal Server Error') unless socket.closed? || @wrote_headers
+
+        socket.close unless socket.closed?
       end
     end
 
@@ -118,6 +129,7 @@ module ThreadedProxy
 
       # Done with headers
       socket.write "\r\n"
+      @wrote_headers = true
     end
 
     def default_port(uri)

data/lib/threaded_proxy/controller.rb

@@ -4,36 +4,58 @@ require_relative 'client'
 
 module ThreadedProxy
   module Controller
+    # Proxies a fetch request to the specified origin URL, allowing for hijacking
+    # the controller response outside of the Rack request/response cycle.
+    #
+    # @param origin_url [String] The URL to which the request will be proxied.
+    # @param options [Hash] Optional parameters for the request.
+    # @option options [Symbol] :body The body of the request. If set to :rack, the request body stream will be used.
+    # @option options [Hash] :headers Additional headers to include in the request.
+    # @yield [Client] Optional block to configure the client.
+    #
+    # @raise [RuntimeError] If a non-chunked POST request is made without a content-length header.
+    #
+    # @return [void]
+    #
+    # @example
+    #   proxy_fetch('http://example.com', body: :rack, headers: { 'Custom-Header' => 'value' }) do |client|
+    #     client.on_headers { |client_response| client_response['x-foo'] = 'bar' }
+    #     client.on_error { |e| Rails.logger.error(e) }
+    #   end
     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']
 
-      Thread.new do
-        if options[:body] == :rack
-          options[:headers] ||= {}
-          options[:body] = request.body_stream
-
-          if request.env['HTTP_TRANSFER_ENCODING'] == 'chunked'
-            options[:headers]['Transfer-Encoding'] = 'chunked'
-          elsif request.env['CONTENT_LENGTH']
-            options[:headers]['content-length'] = request.env['CONTENT_LENGTH'].to_s
-          else
-            raise 'Cannot proxy a non-chunked POST request without content-length'
-          end
-
-          options[:headers]['Content-Type'] = request.env['CONTENT_TYPE'] if request.env['CONTENT_TYPE']
-        end
+      options.deep_merge!(proxy_options_from_request) if options[:body] == :rack
 
+      Thread.new do
         client = Client.new(origin_url, options, &block)
         client.start(socket)
-      rescue Errno::EPIPE
-        # client disconnected before request finished; not an error
       ensure
         socket.close unless socket.closed?
       end
 
       head :ok
     end
+
+    protected
+
+    def proxy_options_from_request
+      options = {}
+      options[:headers] ||= {}
+      options[:body] = request.body_stream
+
+      if request.env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+        options[:headers]['Transfer-Encoding'] = 'chunked'
+      elsif request.env['CONTENT_LENGTH']
+        options[:headers]['content-length'] = request.env['CONTENT_LENGTH'].to_s
+      else
+        raise 'Cannot proxy a non-chunked POST request without content-length'
+      end
+
+      options[:headers]['Content-Type'] = request.env['CONTENT_TYPE'] if request.env['CONTENT_TYPE']
+      options
+    end
   end
 end

data/lib/threaded_proxy/http.rb

@@ -20,7 +20,14 @@ module ThreadedProxy
 
     def request(*args)
       if block_given?
-        super { |res| yield hijack_response(res) }
+        super do |res|
+          access_read(res)
+          yield(res).tap do
+            # In the block case, the response is hijacked _after_ the block is called
+            # to allow the block to read the response body if it wants
+            hijack_response(res)
+          end
+        end
       else
         hijack_response(super)
       end
@@ -30,8 +37,19 @@ module ThreadedProxy
 
     # We read the response ourselves; don't need net/http to try to read it again
     def hijack_response(res)
-      res.instance_variable_set('@read', true)
+      access_read(res) unless res.respond_to?(:read?)
+      res.read = true
       res
     end
+
+    def access_read(res)
+      res.singleton_class.class_eval do
+        attr_writer :read
+
+        def read?
+          @read
+        end
+      end
+    end
   end
 end

data/lib/threaded_proxy/socket_responder.rb

@@ -0,0 +1,65 @@
+module ThreadedProxy
+  class SocketResponder
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def render(options = {})
+      return false if @socket.closed?
+
+      status  = options[:status] || 200
+      headers = options[:headers] || {}
+      body    = options[:body]
+      json    = options[:json]
+      text    = options[:text]
+
+      if json
+        body = json.to_json
+        headers['Content-Type'] ||= 'application/json; charset=utf-8'
+      elsif text
+        body = text
+        headers['Content-Type'] ||= 'text/plain; charset=utf-8'
+      else
+        body ||= ''
+      end
+
+      response = ActionDispatch::Response.new(status, headers, [])
+      response.prepare!
+
+      # Build the HTTP response
+      response_str = "HTTP/1.1 #{response.status} #{response.message}\r\n"
+      response.headers.each do |key, value|
+        Array(value).each do |v|
+          response_str += "#{key}: #{v}\r\n"
+        end
+      end
+      response_str += "\r\n"
+
+      write(response_str)
+
+      if body.respond_to?(:read)
+        IO.copy_stream(body, @socket)
+      else
+        write(body)
+      end
+
+      close
+    end
+
+    def redirect_to(url)
+      render(status: 302, headers: { 'Location' => url })
+    end
+
+    def write(data)
+      @socket.write(data) unless @socket.closed?
+    end
+
+    def close
+      @socket.close unless @socket.closed?
+    end
+
+    def closed?
+      @socket.closed?
+    end
+  end
+end

data/rails-threaded-proxy.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: rails-threaded-proxy 0.4.1 ruby lib
+# stub: rails-threaded-proxy 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-threaded-proxy".freeze
-  s.version = "0.4.1".freeze
+  s.version = "0.5.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-17"
+  s.date = "2024-10-18"
   s.description = "Threaded reverse proxy for Ruby on Rails".freeze
   s.email = "michael@nuttnet.net".freeze
   s.extra_rdoc_files = [
@@ -35,9 +35,11 @@ Gem::Specification.new do |s|
     "lib/threaded_proxy/client.rb",
     "lib/threaded_proxy/controller.rb",
     "lib/threaded_proxy/http.rb",
+    "lib/threaded_proxy/socket_responder.rb",
     "rails-threaded-proxy.gemspec",
     "spec/spec_helper.rb",
-    "spec/threaded_proxy/client_spec.rb"
+    "spec/threaded_proxy/client_spec.rb",
+    "spec/threaded_proxy/controller_spec.rb"
   ]
   s.homepage = "http://github.com/mnutt/rails-threaded-proxy".freeze
   s.licenses = ["MIT".freeze]

data/spec/threaded_proxy/client_spec.rb

@@ -5,6 +5,15 @@ require 'json'
 
 BACKEND_STUB_PORT = 38_293
 
+def parse_raw_response(raw_response)
+  status, rest = raw_response.split("\r\n", 2)
+  headers, body = rest.split("\r\n\r\n", 2)
+
+  parsed_headers = headers.split("\r\n").map { |h| h.split(': ', 2) }.to_h
+
+  [status, parsed_headers, body]
+end
+
 RSpec.describe ThreadedProxy::Client do
   before(:all) do
     @backend_server = WEBrick::HTTPServer.new(Port: BACKEND_STUB_PORT,
@@ -50,15 +59,199 @@ RSpec.describe ThreadedProxy::Client do
                                        body: 'hello world')
     client.start(socket)
 
-    status, rest = socket.string.split("\r\n", 2)
-    headers, body = rest.split("\r\n\r\n", 2)
+    status, headers, body = parse_raw_response(socket.string)
 
     parsed_body = JSON.parse(body)
-    parsed_headers = headers.split("\r\n").map { |h| h.split(': ', 2) }.to_h
 
     expect(status).to eq('HTTP/1.1 200 OK')
-    expect(parsed_headers['content-type']).to eq('application/json')
+    expect(headers['content-type']).to eq('application/json')
     expect(parsed_body['path']).to eq('/post')
     expect(parsed_body['headers']['content-length']).to eq(['11'])
   end
+
+  describe 'callbacks' do
+    describe 'on_headers' do
+      it 'proxies a request and modifies the response headers' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_headers do |response|
+            response['X-Test'] = 'test'
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['x-test']).to eq('test')
+        expect(headers['connection']).to eq('close')
+        expect(body).to eq('Received request: /get')
+      end
+    end
+
+    describe 'on_complete' do
+      it 'fires when the request is successful' do
+        socket = StringIO.new
+        received_client_response = nil
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_complete do |client_response|
+            received_client_response = client_response
+          end
+        end
+        client.start(socket)
+
+        expect(received_client_response.code).to eq('200')
+      end
+    end
+
+    describe 'on_error' do
+      it 'fires when the request is unsuccessful' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new('http://localhost:9999') do |config|
+          config.on_error do |e|
+            received_error = e
+          end
+        end
+        client.start(socket)
+
+        expect(received_error).to be_a_kind_of(Errno::ECONNREFUSED)
+
+        status, headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 500 Internal Server Error')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Internal Server Error')
+      end
+
+      it 'returns custom response on error' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new('http://localhost:9999') do |config|
+          config.on_error do |e, response|
+            response.render status: 404, text: 'Custom error'
+            received_error = e
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 404 Not Found')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Custom error')
+        expect(received_error).to be_a_kind_of(Errno::ECONNREFUSED)
+      end
+    end
+
+    describe 'on_response' do
+      it 'proxies a request and lets caller send response' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |client_response, response|
+            response.render status: 200, json: { body: client_response.body }, headers: { 'x-passed': 'yes' }
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        parsed_body = JSON.parse(body)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['Content-Type']).to eq('application/json; charset=utf-8')
+        expect(headers['x-passed']).to eq('yes')
+        expect(parsed_body['body']).to eq('Received request: /get')
+      end
+
+      it 'accepts IO objects as the body' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.render status: 200, body: StringIO.new('this is IO')
+          end
+        end
+        client.start(socket)
+
+        status, _headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(body).to eq('this is IO')
+      end
+
+      it 'accepts json body' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.render status: 200, json: { key: 'value' }
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        parsed_body = JSON.parse(body)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['Content-Type']).to eq('application/json; charset=utf-8')
+        expect(parsed_body['key']).to eq('value')
+      end
+
+      it 'redirects to a URL' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.redirect_to('http://example.com')
+          end
+        end
+        client.start(socket)
+
+        status, headers, _body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 302 Found')
+        expect(headers['Location']).to eq('http://example.com')
+      end
+
+      it 'handles errors in on_response' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, _response|
+            raise 'error in on_response'
+          end
+
+          config.on_error do |e|
+            received_error = e
+          end
+        end
+
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 500 Internal Server Error')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Internal Server Error')
+        expect(received_error.message).to eq('error in on_response')
+      end
+
+      it 'errors if on_response reads the body but does not render a response' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |client_response, _response|
+            client_response.body
+          end
+        end
+
+        expect { client.start(socket) }.to raise_error(ThreadedProxy::ResponseBodyAlreadyConsumedError)
+      end
+    end
+  end
 end

data/spec/threaded_proxy/controller_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails-threaded-proxy'
+
+class TestController
+  include ThreadedProxy::Controller
+
+  attr_accessor :request
+end
+
+RSpec.describe ThreadedProxy::Controller do
+  let(:request) { double(env: {}) }
+  let(:controller) do
+    TestController.new.tap do |controller|
+      controller.request = request
+    end
+  end
+
+  describe '#proxy_options_from_request' do
+    subject { controller.send(:proxy_options_from_request) }
+    let(:body_stream) { StringIO.new('HELLO') }
+
+    describe 'when the request is chunked' do
+      let(:request) { double(body_stream:, env: { 'HTTP_TRANSFER_ENCODING' => 'chunked' }) }
+
+      it 'sets the Transfer-Encoding header' do
+        expect(subject).to include(headers: { 'Transfer-Encoding' => 'chunked' },
+                                   body: body_stream)
+      end
+    end
+
+    describe 'when the request is not chunked' do
+      let(:request) { double(body_stream:, env: { 'CONTENT_LENGTH' => '5', 'CONTENT_TYPE' => 'application/json' }) }
+
+      it 'sets the Content-Length header' do
+        expect(subject).to include(headers: { 'content-length' => '5',
+                                              'Content-Type' => 'application/json' },
+                                   body: body_stream)
+      end
+    end
+
+    describe 'when the request is not chunked and has no content-length' do
+      let(:request) { double(body_stream:, env: {}) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error('Cannot proxy a non-chunked POST request without content-length')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-threaded-proxy
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Michael Nutt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-17 00:00:00.000000000 Z
+date: 2024-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -160,9 +160,11 @@ files:
 - lib/threaded_proxy/client.rb
 - lib/threaded_proxy/controller.rb
 - lib/threaded_proxy/http.rb
+- lib/threaded_proxy/socket_responder.rb
 - rails-threaded-proxy.gemspec
 - spec/spec_helper.rb
 - spec/threaded_proxy/client_spec.rb
+- spec/threaded_proxy/controller_spec.rb
 homepage: http://github.com/mnutt/rails-threaded-proxy
 licenses:
 - MIT