zapp 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a636e3ae991f63f7f6f4ecc460d9c3c574e5019719c97e8398298de5e44376b
-  data.tar.gz: 616c8a2f3d3fb01a724b3b430880fe8e91d8f09d85101f4bf3d9c8e4755377a2
+  metadata.gz: '083c3deaea0cc22f0bd269afbccdd556bf66743771aca04f63f125809c934473'
+  data.tar.gz: cd3a771ca1d0e898ddaa99c71b741412e4be8370286ec484b2059317cb632802
 SHA512:
-  metadata.gz: 05a64fbadcff8a7466b052a5a87706ec2d036334a34a8729a18de1085de8f72ba5a5a2a4100cb9b6f7cc5474b439869452faff0a7606b7f23ee09ee893d20575
-  data.tar.gz: 06c68050d5b794402032c051492ad5e17a25f79e4ffe853d536713fe6b789cad31a4c44cbb1a59891c89f6d805a3fc92012c55fdee6de818f57a6101a69780af
+  metadata.gz: 227f3dc9ce4c2cac931c89f2a3bca81f90f91031a78998258befb02515ee5eb1af386741646bdecc14e82649cc5cc876f360cbfb8a01bf84e119b062ab3a0eea
+  data.tar.gz: ffa29c579b1621eca0093e2c3d9a4f02975aa3be6a81aa17348aff7a7f5f54cecf4ea8aeb7829c6a821d4691c2ac9a2cd2d0be33204f2a02b1fd163b5c6990e3

data/.rubocop.yml

@@ -11,6 +11,8 @@ Style/MissingElse:
   Enabled: false
 Style/StringLiterals:
   EnforcedStyle: double_quotes
+Style/InlineComments:
+  Enabled: false
 Style/Copyright:
   Enabled: false
 Style/ConstantVisibility:

data/Gemfile.lock

@@ -7,13 +7,14 @@ PATH
       rack (~> 2.2.3)
       rake (~> 13.0)
       rspec (~> 3.0)
+      webrick
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
     coderay (1.1.3)
-    concurrent-ruby (1.1.9)
+    concurrent-ruby (1.1.10)
     diff-lcs (1.4.4)
     docile (1.4.0)
     ffi (1.15.4)
@@ -53,7 +54,7 @@ GEM
       method_source (~> 1.0)
     puma (5.5.2)
       nio4r (~> 2.0)
-    rack (2.2.3)
+    rack (2.2.4)
     rainbow (3.0.0)
     rake (13.0.6)
     rb-fsevent (0.11.0)
@@ -95,6 +96,7 @@ GEM
     simplecov_json_formatter (0.1.3)
     thor (1.1.0)
     unicode-display_width (2.1.0)
+    webrick (1.7.0)
 
 PLATFORMS
   x86_64-linux

data/bin/zapp

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require("bundler/setup")
-require("zapp")
+require_relative("../lib/zapp")
 
 Zapp::CLI.new.run

data/examples/rails-app/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: ../..
   specs:
-    zapp (0.1.0)
+    zapp (0.1.1)
       concurrent-ruby (~> 1.1.9)
       puma (~> 5.5.2)
       rack (~> 2.2.3)
       rake (~> 13.0)
       rspec (~> 3.0)
+      webrick
 
 GEM
   remote: https://rubygems.org/
@@ -89,7 +90,7 @@ GEM
     childprocess (4.1.0)
     concurrent-ruby (1.1.9)
     crass (1.0.6)
-    diff-lcs (1.4.4)
+    diff-lcs (1.5.0)
     erubi (1.10.0)
     ffi (1.15.4)
     globalid (0.5.2)
@@ -158,19 +159,19 @@ GEM
       ffi (~> 1.0)
     regexp_parser (2.1.1)
     rexml (3.2.5)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.1)
-      rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.1)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.2)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-support (3.10.3)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
     rubyzip (2.3.2)
     sass-rails (6.0.0)
       sassc-rails (~> 2.1, >= 2.1.1)
@@ -217,6 +218,7 @@ GEM
       rack-proxy (>= 0.6.1)
       railties (>= 5.2)
       semantic_range (>= 2.3.0)
+    webrick (1.7.0)
     websocket-driver (0.7.5)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)

data/examples/rails-app/config/zapp.rb

@@ -6,5 +6,5 @@ class App
   end
 end
 
-parallelism(2)
+parallelism(4)
 app(App)

data/lib/rack/handler/{zap.rb → zapp.rb}

@@ -6,11 +6,12 @@ module Rack
   module Handler
     # Rack handler for the Zapp web server
     class Zapp
+      register(:zapp, Rack::Handler::Zapp)
+
       def self.run(app)
-        Zapp::Server.new(app: app).run
+        Zapp.config.app = app
+        Zapp::Server.new.run
       end
-
-      register(:zapp, Rack::Handler::Zapp)
     end
   end
 end

data/lib/zapp/configuration.rb

@@ -44,7 +44,7 @@ module Zapp
         {
           Rack::RACK_VERSION => Rack::VERSION,
           Rack::RACK_ERRORS => $stderr,
-          Rack::RACK_MULTITHREAD => false,
+          Rack::RACK_MULTITHREAD => true,
           Rack::RACK_MULTIPROCESS => true,
           Rack::RACK_RUNONCE => false,
           Rack::RACK_URL_SCHEME => %w[yes on 1].include?(ENV["HTTPS"]) ? "https" : "http"

data/lib/zapp/http_context/context.rb

@@ -1,31 +1,30 @@
 # frozen_string_literal: true
 
-require("zapp/http_context/request")
-require("zapp/http_context/response")
+require_relative("request")
+require_relative("response")
 
 module Zapp
   module HTTPContext
     # Context containing request and response
     class Context
-      attr_reader(:req, :res)
+      attr_reader(:req, :res, :socket)
 
-      def initialize(socket:)
+      def initialize(socket:, logger: Zapp::Logger)
         @socket = socket
         @req = Zapp::HTTPContext::Request.new(socket: socket)
         @res = Zapp::HTTPContext::Response.new(socket: socket)
+      rescue Puma::HttpParserError => e
+        res.write(data: "Invalid HTTP request", status: 400, headers: {})
+        logger.warn("Puma parser error: #{e}")
+        logger.debug("HTTP request raw: #{context.req.raw}")
       end
 
       def close
         @socket.close
       end
 
-      def dup
-        clone_context = super
-        clone_context.instance_variable_set(:@req, @req.dup)
-        clone_context.instance_variable_set(:@res, @res.dup)
-        clone_context.instance_variable_set(:@socket, @socket.dup)
-
-        clone_context
+      def client_closed?
+        req.data["HTTP_CONNECTION"] == "close"
       end
     end
   end

data/lib/zapp/http_context/request.rb

@@ -1,27 +1,31 @@
 # frozen_string_literal: true
 
+require("webrick")
+
 module Zapp
   module HTTPContext
     # Represents an HTTP Request to be processed by a worker
     class Request
       attr_reader(:raw, :data, :body)
 
-      def initialize(socket:)
-        raise(EOFError) if socket.eof?
+      # Request parsing is done threaded, but not in separate Ractors.
+      # So we allocate an HTTP parser per thread and assigns it to this hash key on Thread.current
+      PARSER_THREAD_HASH_KEY = "PUMA_PARSER_INSTANCE"
 
+      def initialize(socket:)
         # Max Request size of 8KB TODO: Make a config value for this setting
         @raw = socket.readpartial(8192)
         @data = {}
-      end
 
-      def parse!(parser: Puma::HttpParser.new)
         parser.execute(data, raw, 0)
-        @body = Zapp::InputStream.new(string: parser.body)
+
+        @body = Zapp::InputStream.new(string: "parser.body")
+
         parser.reset
       end
 
-      def parsed?
-        body.is_a?(Zapp::InputStream) && !data.nil? && data != {}
+      def parser
+        Thread.current[PARSER_THREAD_HASH_KEY] ||= Puma::HttpParser.new
       end
     end
   end

data/lib/zapp/http_context/response.rb

@@ -4,21 +4,26 @@ module Zapp
   module HTTPContext
     # Represents an HTTP response being sent back to a client
     class Response
+      attr_reader(:status, :data, :headers)
+
       def initialize(socket:)
         @socket = socket
       end
 
-      # TODO: Add headers argument
       def write(data:, status:, headers:)
-        response = "HTTP/1.1 #{status}\n"
+        @status = status
+        @data = data
+        @headers = headers
+
+        response = +"HTTP/1.1 #{status}\n"
 
-        response += "Content-Length: #{data.size}\n" unless headers["Content-Length"]
+        response << "Content-Length: #{data.size}\n" unless headers["Content-Length"]
 
         headers.each do |k, v|
-          response += "#{k}: #{v}\n"
+          response << "#{k}: #{v}\n"
         end
 
-        response += "\n#{data}\n"
+        response << "\n#{data}\n"
 
         @socket.write(response)
       end

data/lib/zapp/logger.rb

@@ -9,7 +9,14 @@ module Zapp
     module Base
       attr_writer(:level, :prefix)
 
-      LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }.freeze
+      LEVELS = { TRACE: 0, DEBUG: 1, INFO: 2, WARN: 3, ERROR: 4 }.freeze
+
+      FROZEN_ENV = ENV.map { |k, v| [k.freeze, v.freeze] }
+                      .to_h.freeze
+
+      def trace(msg)
+        log("TRACE", msg)
+      end
 
       def debug(msg)
         log("DEBUG", msg)
@@ -28,36 +35,40 @@ module Zapp
       end
 
       def level
-        @level ||= if ENV["ZAPP_LOG_LEVEL"] != "" && !ENV["ZAPP_LOG_LEVEL"].nil?
-                     if LEVELS[ENV["ZAPP_LOG_LEVEL"]].nil?
-                       raise(
-                         Zapp::ZappError,
-                         "Invalid log level '#{ENV['ZAP_LOG_LEVEL']}', must be one of [#{LEVELS.keys.join(', ')}]"
-                       )
-                     else
-                       LEVELS[ENV["ZAP_LOG_LEVEL"]]
-                     end
-                   else
-                     LEVELS[:DEBUG]
-                   end
-      end
+        @level ||= begin
+          log_level = FROZEN_ENV["LOG_LEVEL"]
 
-      private
+          if log_level == "" || log_level.nil?
+            LEVELS[:DEBUG]
+          else
+            resolved_level = LEVELS[log_level.upcase.to_sym]
 
-      def log(current_level, msg)
+            if resolved_level.nil?
+              raise(
+                Zapp::ZappError,
+                "Invalid log level '#{log_level.upcase}', must be one of [#{LEVELS.keys.join(', ')}]"
+              )
+            end
+
+            resolved_level
+          end
+        end
+      end
+
+      def log(current_level, msg, **_tags)
         puts("--- #{@prefix} [#{current_level}] #{msg}") if level <= LEVELS[current_level.to_sym]
       end
     end
     include(Zapp::Logger::Base)
 
     def initialize
-      @prefix = "Zap"
       yield(self) if block_given?
     end
 
     class << self
       include(Zapp::Logger::Base)
-      @prefix = "Zap"
     end
   end
 end
+
+Zapp::Logger.prefix = "Zapp"

data/lib/zapp/pipe.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zapp
+  # Light wrapper around a Ractor for piping messages CSP style
+  module Pipe
+    def self.new
+      Ractor.new do
+        loop do
+          Ractor.yield(Ractor.receive)
+        end
+      end
+    end
+  end
+end

data/lib/zapp/server.rb

@@ -3,40 +3,42 @@
 module Zapp
   # The Zap HTTP Server, listens on a TCP connection and processes incoming requests
   class Server
-    attr_reader(:tcp_connection, :worker_pool)
+    attr_reader(:worker_pool, :socket_pipe_receiver)
 
     def initialize
-      @tcp_connection = TCPServer.new(Zapp.config.host, Zapp.config.port)
-      @worker_pool = Zapp::WorkerPool.new(app: Zapp.config.app)
+      @socket_pipe = Zapp::Pipe.new
+      @context_pipe = Zapp::Pipe.new
+
+      @socket_pipe_receiver = Zapp::SocketPipe::Receiver.new(pipe: @socket_pipe)
+
+      @worker_pool = Zapp::WorkerPool.new(app: Zapp.config.app, socket_pipe: @socket_pipe, context_pipe: @context_pipe)
     end
 
     def run
-      parser = Puma::HttpParser.new
-
       log_start
 
       loop do
-        socket = tcp_connection.accept
-        next if socket.eof?
+        socket = socket_pipe_receiver.take
 
-        context = Zapp::HTTPContext::Context.new(socket: socket)
-
-        context.req.parse!(parser: parser)
+        next if socket.eof?
 
-        worker_pool.process(context: context)
+        parsing_thread_pool.post do
+          ctx = Zapp::HTTPContext::Context.new(socket: socket)
 
-      rescue Puma::HttpParserError => e
-        context.res.write(data: "Invalid HTTP request", status: 500, headers: {})
-        Zapp::Logger.warn("Puma parser error: #{e}")
+          worker_pool.process(context: ctx) unless ctx.client_closed? # Parsing failed
+        end
+      rescue Errno::ECONNRESET
+        next
       end
     rescue SignalException, IRB::Abort => e
       shutdown(e)
     end
 
     def shutdown(err = nil)
-      Zapp::Logger.info("Received signal #{err}") unless err.nil?
+      Zapp::Logger.info("Received signal #{err.class.name}") unless err.nil?
       Zapp::Logger.info("Gracefully shutting down workers, allowing request processing to finish")
 
+      socket_pipe_receiver.drain
       worker_pool.drain
 
       Zapp::Logger.info("Done. See you next time!")
@@ -45,11 +47,29 @@ module Zapp
     private
 
     def log_start
-      Zapp::Logger.info("Zap version: #{Zapp::VERSION}")
+      Zapp::Logger.info("
+        ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+        ⚡  ███████╗ █████╗ ██████╗ ██████╗   ⚡
+        ⚡  ╚══███╔╝██╔══██╗██╔══██╗██╔══██╗  ⚡
+        ⚡    ███╔╝ ███████║██████╔╝██████╔╝  ⚡
+        ⚡   ███╔╝  ██╔══██║██╔═══╝ ██╔═══╝   ⚡
+        ⚡  ███████╗██║  ██║██║     ██║       ⚡
+        ⚡  ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ⚡
+        ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+")
+      Zapp::Logger.info("Zapp version: #{Zapp::VERSION}")
       Zapp::Logger.info("Environment: #{Zapp.config.mode}")
       Zapp::Logger.info("Serving: #{Zapp.config.env[Rack::RACK_URL_SCHEME]}://#{Zapp.config.host}:#{Zapp.config.port}")
       Zapp::Logger.info("Parallel workers: #{Zapp.config.parallelism}")
       Zapp::Logger.info("Ready to accept requests")
     end
+
+    def parsing_thread_pool
+      @parsing_thread_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: Zapp.config.parallelism,
+        max_threads: Zapp.config.parallelism,
+        max_queue: Zapp.config.parallelism * 1_000
+      )
+    end
   end
 end

data/lib/zapp/socket_pipe/receiver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Zapp
+  module SocketPipe
+    class Receiver
+      attr_reader(:pipe, :raw_tcp_pipe)
+
+      def initialize(pipe:)
+        @pipe = pipe
+        @raw_tcp_pipe = Ractor.new(Zapp.config, name: "raw-tcp-pipe") do |config|
+          server = TCPServer.new(config.host, config.port)
+
+          loop do
+            Ractor.yield(server.accept)
+          end
+        end
+      end
+
+      def take
+        Ractor.select(pipe, raw_tcp_pipe)[1]
+      end
+
+      def drain
+        Thread.new do
+          loop do
+            take
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zapp/socket_pipe/sender.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Zapp
+  module SocketPipe
+    class Sender
+      attr_reader(:pipe)
+
+      def initialize(pipe:)
+        @pipe = pipe
+      end
+
+      def push(socket)
+        pipe.send(socket)
+      end
+    end
+  end
+end

data/lib/zapp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zapp
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

data/lib/zapp/worker/request_processor.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Zapp
+  class Worker < Ractor
+    # Processes HTTP requests
+    class RequestProcessor
+      attr_reader(:app, :config, :socket_pipe_sender, :context_pipe)
+
+      def initialize(context_pipe:, socket_pipe:, app:, config:)
+        @app = app
+        @config = config
+        @socket_pipe_sender = Zapp::SocketPipe::Sender.new(pipe: socket_pipe)
+        @context_pipe = context_pipe
+      end
+
+      def loop
+        while (context = context_pipe.take)
+          if context == Zapp::WorkerPool::SIGNALS[:EXIT]
+            logger.trace("Received exit signal, shutting down")
+            thread_pool.shutdown
+            break
+          end
+
+
+            process = lambda {
+              process(context: context)
+            }
+
+            if config.log_requests
+              log_request_time(context: context, &process)
+            else
+              process.call
+            end
+
+            # We send sockets that the client hasn't closed yet,
+            # back to the main ractor for HTTP request parsing again
+            socket_pipe_sender.push(context.socket) unless context.client_closed?
+
+        end
+      end
+
+      private
+
+      # Processes an HTTP request
+      def process(context:)
+        env = prepare_env(data: context.req.data, body: context.req.body, env: config.env.dup)
+
+        status, headers, response_body_stream = @app.call(env)
+
+        response_body = body_stream_to_string(response_body_stream)
+
+        context.res.write(data: response_body, status: status, headers: headers)
+      rescue StandardError => e
+        context.res.write(data: "An unexpected error occurred", status: 500, headers: {})
+        logger.error("#{e}\n\n#{e.backtrace&.join(",\n")}") if config.log_uncaught_errors
+      end
+
+      # Merges HTTP data and body into the env to be passed to the rack app
+      def prepare_env(data:, body:, env:)
+        data["QUERY_STRING"] = ""
+        data["SERVER_NAME"] = data["HTTP_HOST"] || ""
+        data["PATH_INFO"] = data["REQUEST_PATH"]
+        data["SCRIPT_NAME"] = ""
+
+        env.update(data)
+
+        env.update(Rack::RACK_INPUT => body)
+
+        env
+      end
+
+      def log_request_time(context:)
+        start = Time.now.to_f * 1000
+
+        yield
+
+        request_time = ((Time.now.to_f * 1000) - start).truncate(2)
+        method = context.req.data["REQUEST_METHOD"]
+        path = context.req.data["PATH_INFO"]
+        status = context.res.status
+
+        logger.info(
+          "#{method} #{path} - Completed in #{request_time}ms with status #{status}"
+        )
+      end
+
+      # Loops over a body stream and returns a single string
+      def body_stream_to_string(stream)
+        response_body = ""
+        stream.each do |s|
+          response_body += s
+        end
+
+        stream.close if stream.respond_to?(:close)
+
+        response_body
+      end
+
+      def thread_pool
+        @thread_pool ||= Concurrent::ThreadPoolExecutor.new(
+          min_threads: config.threads_per_worker,
+          max_threads: config.threads_per_worker,
+          max_queue: 1000,
+        )
+      end
+
+      def logger
+        @logger ||= config.logger_class.new do |l|
+          l.prefix = Ractor.current.name
+        end
+      end
+    end
+  end
+end

data/lib/zapp/worker.rb

@@ -1,87 +1,37 @@
 # frozen_string_literal: true
 
+require_relative("worker/request_processor")
+
 module Zapp
   # One worker processing requests in parallel
   class Worker < Ractor
     class << self
-      def new(pipe_:, app_:, index:)
-        # Logger with the name as prefix
-        logger_ = Zapp.config.logger_class.new do |logger|
-          logger.prefix = name(index)
-        end
-
-        super(pipe_, app_, logger_, Zapp.config.dup, name: name(index)) do |pipe, app, logger, config|
-          logger.level = 0
-          while (context, shutdown = pipe.take)
-            break if shutdown
-
-            if config.log_requests
-              Zapp::Worker.log_request_time(logger: logger) do
-                Zapp::Worker.process(context: context, app: app, logger: logger, config: config)
-              end
-            else
-              Zapp::Worker.process(context: context, app: app, logger: logger, config: config)
-            end
-          end
+      def new(context_pipe:, socket_pipe:, app:, index:)
+        super(
+          context_pipe,
+          socket_pipe,
+          app,
+          Zapp.config.dup,
+          name: name(index)
+        ) do |context_pipe, socket_pipe, app, config|
+          processor = Zapp::Worker::RequestProcessor.new(
+            socket_pipe: socket_pipe,
+            context_pipe: context_pipe,
+            app: app,
+            config: config
+          )
+
+          processor.loop
         end
       end
 
-      # Processes an HTTP request
-      def process(context:, app:, logger:, config:)
-        prepare_env(data: context.req.data, body: context.req.body, env: config.env)
-
-        status, headers, response_body_stream = app.call(config.env)
-
-        response_body = body_stream_to_string(response_body_stream)
-
-        context.res.write(data: response_body, status: status, headers: headers)
-      rescue StandardError => e
-        context.res.write(data: "An unexpected error occurred", status: 500, headers: {})
-        logger.error("#{e}\n\n#{e.backtrace&.join(",\n")}") if config.log_uncaught_errors
-      ensure
-        context.close
-      end
-
-      def log_request_time(logger:)
-        start = Time.now.to_f * 1000
-
-        yield
-      ensure
-        logger.info("Processed request in #{((Time.now.to_f * 1000) - start).truncate(2)}ms")
-      end
-
-      # Loops over a body stream and returns a single string
-      def body_stream_to_string(stream)
-        response_body = ""
-        stream.each do |s|
-          response_body += s
-        end
-
-        stream.close if stream.respond_to?(:close)
-
-        response_body
-      end
-
-      # Merges HTTP data and body into the env to be passed to the rack app
-      def prepare_env(data:, body:, env:)
-        data["QUERY_STRING"] = ""
-        data["SERVER_NAME"] = data["HTTP_HOST"] || ""
-        data["PATH_INFO"] = data["REQUEST_PATH"]
-        data["SCRIPT_NAME"] = ""
-
-        env.update(data)
-
-        env.update(Rack::RACK_INPUT => body)
-      end
-
       # Index based name of the worker
       def name(index)
-        "zap-http-#{index + 1}"
+        "zapp-http-#{index + 1}"
       end
     end
 
     def terminate
-      Zapp::Logger.debug("Terminating worker #{name}")
       take
     end
   end

data/lib/zapp/worker_pool.rb

@@ -3,38 +3,36 @@
 module Zapp
   # Manages and dispatches work to a pool of Zap::Worker's
   class WorkerPool
-    attr_reader(:pipe, :workers, :parallelism)
+    attr_reader(:context_pipe, :workers, :parallelism)
 
-    def initialize(app:)
-      @pipe = Ractor.new do
-        loop do
-          Ractor.yield(Ractor.receive)
-        end
-      end
+    SIGNALS = {
+      EXIT: :exit
+    }.freeze
 
+    def initialize(app:, context_pipe:, socket_pipe:)
+      @context_pipe = context_pipe
       @workers = []
       Zapp.config.parallelism.times do |i|
         @workers << Worker.new(
-          pipe_: pipe,
-          app_: app,
+          context_pipe: context_pipe,
+          socket_pipe: socket_pipe,
+          app: app,
           index: i
         )
       end
     end
 
-    # Sends data through the pipe to one of our workers,
-    # sends a tuple of [context, shutdown], if shutdown is true it breaks from its processing loop
-    # otherwise the worker processes the HTTP context
-    def process(context:, shutdown: false)
-      pipe.send([context.dup, shutdown], move: true)
+    # Sends a socket to one of our workers
+    def process(context:)
+      context_pipe.send(context)
     end
 
     # Finishes processing of all requests and shuts down workers
     def drain
-      Zapp.config.parallelism.times { process(context: nil, shutdown: true) }
+      Zapp.config.parallelism.times { process(context: SIGNALS[:EXIT]) }
       workers.map(&:terminate)
-    rescue Ractor::RemoteError
-      # Ignored
+    rescue Ractor::ClosedError
+      # Ractor has already exited
     end
   end
 end

data/lib/zapp.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # External dependencies are loaded here
+require("irb")
 require("socket")
 require("concurrent")
 require("puma")
@@ -23,12 +24,15 @@ module Zapp
   end
 end
 
-require("zapp/version")
-require("zapp/logger")
-require("zapp/configuration")
-require("zapp/input_stream")
-require("zapp/http_context/context")
-require("zapp/worker")
-require("zapp/worker_pool")
-require("zapp/server")
-require("zapp/cli")
+require_relative("zapp/version")
+require_relative("zapp/logger")
+require_relative("zapp/configuration")
+require_relative("zapp/input_stream")
+require_relative("zapp/http_context/context")
+require_relative("zapp/pipe")
+require_relative("zapp/socket_pipe/sender")
+require_relative("zapp/socket_pipe/receiver")
+require_relative("zapp/worker")
+require_relative("zapp/worker_pool")
+require_relative("zapp/server")
+require_relative("zapp/cli")

data/zapp.gemspec

@@ -31,6 +31,8 @@ Gem::Specification.new do |spec|
   # Use Puma's C-based HttpParser, it's fast as hell
   spec.add_dependency("puma", "~> 5.5.2")
 
+  spec.add_dependency("webrick")
+
   # Concurrent ruby for managing Thread pools
   spec.add_dependency("concurrent-ruby", "~> 1.1.9")
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zapp
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Mathias H Steffensen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-21 00:00:00.000000000 Z
+date: 2022-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.5.2
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -98,8 +112,6 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/console
-- bin/setup
 - bin/zapp
 - examples/rails-app/.browserslistrc
 - examples/rails-app/.gitattributes
@@ -195,7 +207,7 @@ files:
 - examples/rails-app/tmp/pids/.keep
 - examples/rails-app/vendor/.keep
 - examples/rails-app/yarn.lock
-- lib/rack/handler/zap.rb
+- lib/rack/handler/zapp.rb
 - lib/zapp.rb
 - lib/zapp/cli.rb
 - lib/zapp/configuration.rb
@@ -205,9 +217,13 @@ files:
 - lib/zapp/input_stream.rb
 - lib/zapp/logger.rb
 - lib/zapp/parser.rb
+- lib/zapp/pipe.rb
 - lib/zapp/server.rb
+- lib/zapp/socket_pipe/receiver.rb
+- lib/zapp/socket_pipe/sender.rb
 - lib/zapp/version.rb
 - lib/zapp/worker.rb
+- lib/zapp/worker/request_processor.rb
 - lib/zapp/worker_pool.rb
 - zapp.gemspec
 homepage: https://github.com/mathiashsteffensen/zapp
@@ -232,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: A Web Server based on Ractors, for Rack-based Ruby applications

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require("bundler/setup")
-require("zapp")
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require("irb")
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here