zapp 0.1.0

data/lib/rack/handler/zap.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require("rack/handler")
+
+module Rack
+  module Handler
+    # Rack handler for the Zapp web server
+    class Zapp
+      def self.run(app)
+        Zapp::Server.new(app: app).run
+      end
+
+      register(:zapp, Rack::Handler::Zapp)
+    end
+  end
+end

data/lib/zapp/cli.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require("optionparser")
+
+module Zapp
+  # Provides the CLI utility for easily running Ruby 3.0.0+ applications with Zap
+  class CLI
+    def run
+      parse_options
+
+      Zapp::Server.new.run
+    end
+
+    private
+
+    def parse_options
+      begin
+        parse_config_file(location: "./config/zapp.rb")
+      rescue StandardError
+        # Ignored
+      end
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: bundle exec zapp [options]"
+
+        opts.on("-c", "--config-file=FILE", "Config file to use") do |file|
+          parse_config_file(location: file)
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          puts(opts)
+          exit
+        end
+      end.parse!
+    end
+
+    def parse_config_file(location:)
+      config = File.read(
+        File.absolute_path(location)
+      )
+
+      Zapp.config.instance_eval(config)
+    end
+  end
+end

data/lib/zapp/configuration.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require("etc")
+require("singleton")
+require("ostruct")
+
+module Zapp
+  # Class holding the configuration values used by Zap
+  class Configuration
+    attr_writer(
+      :rackup_file,
+      :parallelism,
+      :threads_per_worker,
+      :logger_class,
+      :log_requests,
+      :log_uncaught_errors,
+      :host,
+      :port,
+      :app
+    )
+
+    attr_accessor(:env, :mode)
+
+    DEFAULT_OPTIONS = {
+      # Rack up file to use
+      rackup_file: "config.ru",
+
+      # Default to number of CPUs available
+      # This is the amount of workers to run processing requests
+      parallelism: Etc.nprocessors,
+      # Number of Thread's to run within each worker
+      threads_per_worker: 5,
+
+      # Default logging behavior
+      logger_class: Zapp::Logger,
+      log_requests: true,
+      log_uncaught_errors: true,
+
+      host: "localhost",
+      port: 3000,
+
+      mode: ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development",
+      env: ENV.to_hash.merge(
+        {
+          Rack::RACK_VERSION => Rack::VERSION,
+          Rack::RACK_ERRORS => $stderr,
+          Rack::RACK_MULTITHREAD => false,
+          Rack::RACK_MULTIPROCESS => true,
+          Rack::RACK_RUNONCE => false,
+          Rack::RACK_URL_SCHEME => %w[yes on 1].include?(ENV["HTTPS"]) ? "https" : "http"
+        }
+      )
+    }.freeze
+
+    def initialize
+      DEFAULT_OPTIONS.each_key do |key|
+        public_send("#{key}=", DEFAULT_OPTIONS[key])
+      end
+    end
+
+    def rack_builder
+      @rack_builder ||= begin
+        require("rack")
+        require("rack/builder")
+        Rack::Builder
+      rescue LoadError => e
+        Zapp::Logger.error("Failed to load Rack #{e}")
+      end
+    end
+
+    def app(new = nil)
+      @app = new unless new.nil?
+
+      @app ||= begin
+        raise(Zapp::ZapError, "Missing rackup file '#{rackup_file}'") unless File.exist?(rackup_file)
+
+        rack_app, = rack_builder.parse_file(rackup_file)
+
+        rack_app
+      end
+    end
+
+    def parallelism(new = nil)
+      return @parallelism if new.nil?
+
+      @parallelism = new
+    end
+
+    def threads_per_worker(new = nil)
+      return @threads_per_worker if new.nil?
+
+      @threads_per_worker = new
+    end
+
+    def logger_class(new = nil)
+      return @logger_class if new.nil?
+
+      @logger_class = new
+    end
+
+    def log_requests(new = nil)
+      return @log_requests if new.nil?
+
+      @log_requests = new
+    end
+
+    def log_uncaught_errors(new = nil)
+      return @log_uncaught_errors if new.nil?
+
+      @log_uncaught_errors = new
+    end
+
+    def host(new = nil)
+      return @host if new.nil?
+
+      @host = new
+    end
+
+    def port(new = nil)
+      return @port if new.nil?
+
+      @port = new
+    end
+
+    def rackup_file(new = nil)
+      return @rackup_file if new.nil?
+
+      @rackup_file = new
+    end
+  end
+end

data/lib/zapp/http_context/context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require("zapp/http_context/request")
+require("zapp/http_context/response")
+
+module Zapp
+  module HTTPContext
+    # Context containing request and response
+    class Context
+      attr_reader(:req, :res)
+
+      def initialize(socket:)
+        @socket = socket
+        @req = Zapp::HTTPContext::Request.new(socket: socket)
+        @res = Zapp::HTTPContext::Response.new(socket: socket)
+      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
+      end
+    end
+  end
+end

data/lib/zapp/http_context/request.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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?
+
+        # 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)
+        parser.reset
+      end
+
+      def parsed?
+        body.is_a?(Zapp::InputStream) && !data.nil? && data != {}
+      end
+    end
+  end
+end

data/lib/zapp/http_context/response.rb

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

data/lib/zapp/input_stream.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Zapp
+  # Represents an input stream with the HTTP data passed to rack.input
+  # Read the Input Stream part of the Rack Specification here https://github.com/rack/rack/blob/master/SPEC.rdoc#label-The+Input+Stream
+  class InputStream
+    def initialize(string:)
+      @string = string
+      @next_index_to_read = 0
+    end
+
+    def read(length = nil, buffer = nil)
+      returning = if length.nil?
+                    raw_read
+                  else
+                    string = raw_read(end_index: @next_index_to_read + length)
+                    string == "" ? nil : string
+                  end
+
+      if buffer.nil?
+        returning
+      else
+        buffer << returning
+      end
+    end
+
+    def each(&block)
+      [read].each(&block)
+    end
+
+    def gets
+      return unless @next_index_to_read < @string.length
+
+      read
+    end
+
+    def rewind
+      @next_index_to_read = 0
+    end
+
+    private
+
+    def raw_read(end_index: @string.length)
+      returning = @string.slice(@next_index_to_read...end_index)
+
+      @next_index_to_read = end_index
+
+      returning
+    end
+  end
+end

data/lib/zapp/logger.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Zapp
+  # The default logger for zap
+  class Logger
+    # Base contains all the logging functionality and is included both as class and instance methods of Zap::Logger
+    # This allows logging without creating new instances,
+    # while allowing Ractors to create their own instances for thread safety
+    module Base
+      attr_writer(:level, :prefix)
+
+      LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }.freeze
+
+      def debug(msg)
+        log("DEBUG", msg)
+      end
+
+      def info(msg)
+        log("INFO", msg)
+      end
+
+      def warn(msg)
+        log("WARN", msg)
+      end
+
+      def error(msg)
+        log("ERROR", msg)
+      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
+
+      private
+
+      def log(current_level, msg)
+        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

data/lib/zapp/parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zapp
+  # Parses HTTP Requests
+  class Parser
+    def initialize
+      @parser = Puma::HttpParser.new
+    end
+
+    def execute!(data, raw)
+      @parser.execute(data, raw, 0)
+    end
+  end
+end

data/lib/zapp/server.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Zapp
+  # The Zap HTTP Server, listens on a TCP connection and processes incoming requests
+  class Server
+    attr_reader(:tcp_connection, :worker_pool)
+
+    def initialize
+      @tcp_connection = TCPServer.new(Zapp.config.host, Zapp.config.port)
+      @worker_pool = Zapp::WorkerPool.new(app: Zapp.config.app)
+    end
+
+    def run
+      parser = Puma::HttpParser.new
+
+      log_start
+
+      loop do
+        socket = tcp_connection.accept
+        next if socket.eof?
+
+        context = Zapp::HTTPContext::Context.new(socket: socket)
+
+        context.req.parse!(parser: parser)
+
+        worker_pool.process(context: context)
+
+      rescue Puma::HttpParserError => e
+        context.res.write(data: "Invalid HTTP request", status: 500, headers: {})
+        Zapp::Logger.warn("Puma parser error: #{e}")
+      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("Gracefully shutting down workers, allowing request processing to finish")
+
+      worker_pool.drain
+
+      Zapp::Logger.info("Done. See you next time!")
+    end
+
+    private
+
+    def log_start
+      Zapp::Logger.info("Zap 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
+  end
+end

data/lib/zapp/version.rb

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

data/lib/zapp/worker.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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
+        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}"
+      end
+    end
+
+    def terminate
+      Zapp::Logger.debug("Terminating worker #{name}")
+      take
+    end
+  end
+end

data/lib/zapp/worker_pool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Zapp
+  # Manages and dispatches work to a pool of Zap::Worker's
+  class WorkerPool
+    attr_reader(:pipe, :workers, :parallelism)
+
+    def initialize(app:)
+      @pipe = Ractor.new do
+        loop do
+          Ractor.yield(Ractor.receive)
+        end
+      end
+
+      @workers = []
+      Zapp.config.parallelism.times do |i|
+        @workers << Worker.new(
+          pipe_: 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)
+    end
+
+    # Finishes processing of all requests and shuts down workers
+    def drain
+      Zapp.config.parallelism.times { process(context: nil, shutdown: true) }
+      workers.map(&:terminate)
+    rescue Ractor::RemoteError
+      # Ignored
+    end
+  end
+end

data/lib/zapp.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# External dependencies are loaded here
+require("socket")
+require("concurrent")
+require("puma")
+require("rack")
+
+# Zapp is a web server for Rack-based Ruby 3.0.0+ applications
+module Zapp
+  class ZappError < StandardError; end
+
+  class << self
+    def config(reset: false)
+      @config = Zapp::Configuration.new if reset
+
+      @config ||= Zapp::Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+  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")

data/zapp.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative("lib/zapp/version")
+
+Gem::Specification.new do |spec|
+  spec.name          = "zapp"
+  spec.version       = Zapp::VERSION
+  spec.authors       = ["Mathias H Steffensen"]
+  spec.email         = ["mathiashsteffensen@protonmail.com"]
+
+  spec.summary       = "A Web Server based on Ractors, for Rack-based Ruby applications"
+  spec.homepage      = "https://github.com/mathiashsteffensen/zapp"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/mathiashsteffensen/zapp"
+  spec.metadata["changelog_uri"] = "https://github.com/mathiashsteffensen/zapp/blob/master/CHANGELOG.md"
+
+  # Which files should be added to the gem when it is released.
+  spec.files =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:spec|example)/}) }
+    end
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+
+  # This is of course a web server for Rack applications
+  spec.add_dependency("rack", "~> 2.2.3")
+
+  # Use Puma's C-based HttpParser, it's fast as hell
+  spec.add_dependency("puma", "~> 5.5.2")
+
+  # Concurrent ruby for managing Thread pools
+  spec.add_dependency("concurrent-ruby", "~> 1.1.9")
+
+  # Rake for task running
+  spec.add_dependency("rake", "~> 13.0")
+
+  # RSpec for testing
+  spec.add_dependency("rspec", "~> 3.0")
+end