rackup 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8147a54f57ff6cc1143ffb8b1d56284e4a587ca63aeeb21e491d83348d9dfcd
+  data.tar.gz: 438c92e88aee281963b9a796c716feab222e6a16d34533f89278c42f8be1c34f
+SHA512:
+  metadata.gz: 918d8410462f54b58b63defeb39b95fae57ae7da05f19dfee0479718d0b4422909b13a00c1a9f3e19f7e5fb4328b4240db0f7bbbc89d77f0df5e2d8a8e8b94f4
+  data.tar.gz: c821f8a16afb6946aea5dee3bb0a9b070f782df68dfd979772c612dab61d5c983b3fceb32567ce24fac5aff4627157dfea35fee643170bf4ac75d92497308b52

data/bin/rackup

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/rackup"
+Rackup::Server.start

data/lib/rackup/handler/cgi.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rackup
+  module Handler
+    class CGI
+      include Rack
+
+      def self.run(app, **options)
+        $stdin.binmode
+        serve app
+      end
+
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
+
+        env.update(
+          RACK_INPUT        => $stdin,
+          RACK_ERRORS       => $stderr,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
+        )
+
+        env[QUERY_STRING] ||= ""
+        env[REQUEST_PATH] ||= "/"
+
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+
+      def self.send_headers(status, headers)
+        $stdout.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            $stdout.print "#{k}: #{v}\r\n"
+          }
+        }
+        $stdout.print "\r\n"
+        $stdout.flush
+      end
+
+      def self.send_body(body)
+        body.each { |part|
+          $stdout.print part
+          $stdout.flush
+        }
+      end
+    end
+
+    register :cgi, CGI
+  end
+end

data/lib/rackup/handler/webrick.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'stringio'
+
+require 'rack/constants'
+require_relative '../handler'
+require_relative '../version'
+
+# This monkey patch allows for applications to perform their own chunking
+# through WEBrick::HTTPResponse if rack is set to true.
+class WEBrick::HTTPResponse
+  attr_accessor :rack
+
+  alias _rack_setup_header setup_header
+  def setup_header
+    app_chunking = rack && @header['transfer-encoding'] == 'chunked'
+
+    @chunked = app_chunking if app_chunking
+
+    _rack_setup_header
+
+    @chunked = false if app_chunking
+  end
+end
+
+module Rackup
+  module Handler
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+      include Rack
+      
+      def self.run(app, **options)
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : nil
+
+        if !options[:BindAddress] || options[:Host]
+          options[:BindAddress] = options.delete(:Host) || default_host
+        end
+        options[:Port] ||= 8080
+        if options[:SSLEnable]
+          require 'webrick/https'
+        end
+
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount "/", Rackup::Handler::WEBrick, app
+        yield @server if block_given?
+        @server.start
+      end
+
+      def self.valid_options
+        environment  = ENV['RACK_ENV'] || 'development'
+        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+        {
+          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
+      def self.shutdown
+        if @server
+          @server.shutdown
+          @server = nil
+        end
+      end
+
+      def initialize(server, app)
+        super server
+        @app = app
+      end
+
+      def service(req, res)
+        res.rack = true
+        env = req.meta_vars
+        env.delete_if { |k, v| v.nil? }
+
+        rack_input = StringIO.new(req.body.to_s)
+        rack_input.set_encoding(Encoding::BINARY)
+
+        env.update(
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
+          RACK_IS_HIJACK    => true,
+        )
+
+        env[QUERY_STRING] ||= ""
+        unless env[PATH_INFO] == ""
+          path, n = req.request_uri.path, env[SCRIPT_NAME].length
+          env[PATH_INFO] = path[n, path.length - n]
+        end
+        env[REQUEST_PATH] ||= [env[SCRIPT_NAME], env[PATH_INFO]].join
+
+        status, headers, body = @app.call(env)
+        begin
+          res.status = status.to_i
+          io_lambda = nil
+          headers.each { |key, value|
+            if key == RACK_HIJACK
+              io_lambda = value
+            elsif key == "set-cookie"
+              res.cookies.concat(Array(value))
+            else
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[key] = Array(value).join(", ")
+            end
+          }
+
+          if io_lambda
+            rd, wr = IO.pipe
+            res.body = rd
+            res.chunked = true
+            io_lambda.call wr
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, 'rb')
+          else
+            body.each { |part|
+              res.body << part
+            }
+          end
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+    end
+
+    register :webrick, WEBrick
+  end
+end

data/lib/rackup/handler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'rack/handler'
+
+module Rackup
+  # *Handlers* connect web servers with Rack.
+  #
+  # Rackup includes Handlers for WEBrick and CGI.
+  #
+  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
+  # A second optional hash can be passed to include server-specific
+  # configuration.
+  module Handler
+    def self.[](name)
+      begin
+        Rack::Handler[name] || self.const_get(name, false)
+      rescue NameError
+        # Ignore.
+      end
+    end
+
+    def self.get(name)
+      return nil unless name
+
+      name = name.to_sym
+
+      if server = self[name]
+        return server
+      end
+
+      require_handler("rack/handler", name)
+
+      return self[name]
+    end
+
+    def self.register(name, klass)
+      name = name.to_sym
+
+      Rack::Handler.register(name, klass)
+    end
+
+    RACK_HANDLER = 'RACK_HANDLER'
+    RACKUP_HANDLER = 'RACKUP_HANDLER'
+
+    SERVER_NAMES = %i(puma falcon webrick).freeze
+    private_constant :SERVER_NAMES
+
+    # Select first available Rack handler given an `Array` of server names.
+    # Raises `LoadError` if no handler was found.
+    #
+    #   > pick ['puma', 'webrick']
+    #   => Rackup::Handler::WEBrick
+    def self.pick(server_names)
+      server_names = Array(server_names)
+
+      server_names.each do |server_name|
+        begin
+          server = self.get(server_name)
+         return server if server
+        rescue LoadError
+          # Ignore.
+        end
+      end
+
+      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
+    end
+
+    def self.default
+      if rack_handler = ENV[RACKUP_HANDLER]
+        self.get(rack_handler)
+      elsif rack_handler = ENV[RACK_HANDLER]
+        warn "RACK_HANDLER is deprecated, use RACKUP_HANDLER."
+        self.get(rack_handler)
+      else
+        pick SERVER_NAMES
+      end
+    end
+
+    # Transforms server-name constants to their canonical form as filenames,
+    # then tries to require them but silences the LoadError if not found
+    #
+    # Naming convention:
+    #
+    #   Foo # => 'foo'
+    #   FooBar # => 'foo_bar.rb'
+    #   FooBAR # => 'foobar.rb'
+    #   FOObar # => 'foobar.rb'
+    #   FOOBAR # => 'foobar.rb'
+    #   FooBarBaz # => 'foo_bar_baz.rb'
+    def self.require_handler(prefix, const_name)
+      file = const_name.to_s.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
+        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
+
+      require(::File.join(prefix, file))
+    end
+  end
+end

data/lib/rackup/lobster.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require 'rack/constants'
+require 'rack/request'
+require 'rack/response'
+
+module Rackup
+  # Paste has a Pony, Rack has a Lobster!
+  class Lobster
+    include Rack
+
+    LobsterString = Zlib::Inflate.inflate("eJx9kEEOwyAMBO99xd7MAcytUhPlJyj2
+    P6jy9i4k9EQyGAnBarEXeCBqSkntNXsi/ZCvC48zGQoZKikGrFMZvgS5ZHd+aGWVuWwhVF0
+    t1drVmiR42HcWNz5w3QanT+2gIvTVCiE1lm1Y0eU4JGmIIbaKwextKn8rvW+p5PIwFl8ZWJ
+    I8jyiTlhTcYXkekJAzTyYN6E08A+dk8voBkAVTJQ==".delete("\n ").unpack("m*")[0])
+
+    LambdaLobster = lambda { |env|
+      if env[QUERY_STRING].include?("flip")
+        lobster = LobsterString.split("\n").
+          map { |line| line.ljust(42).reverse }.
+          join("\n")
+        href = "?"
+      else
+        lobster = LobsterString
+        href = "?flip"
+      end
+
+      content = ["<title>Lobstericious!</title>",
+                 "<pre>", lobster, "</pre>",
+                 "<a href='#{href}'>flip!</a>"]
+      length = content.inject(0) { |a, e| a + e.size }.to_s
+      [200, { CONTENT_TYPE => "text/html", CONTENT_LENGTH => length }, content]
+    }
+
+    def call(env)
+      req = Request.new(env)
+      if req.GET["flip"] == "left"
+        lobster = LobsterString.split("\n").map do |line|
+          line.ljust(42).reverse.
+            gsub('\\', 'TEMP').
+            gsub('/', '\\').
+            gsub('TEMP', '/').
+            gsub('{', '}').
+            gsub('(', ')')
+        end.join("\n")
+        href = "?flip=right"
+      elsif req.GET["flip"] == "crash"
+        raise "Lobster crashed"
+      else
+        lobster = LobsterString
+        href = "?flip=left"
+      end
+
+      res = Response.new
+      res.write "<title>Lobstericious!</title>"
+      res.write "<pre>"
+      res.write lobster
+      res.write "</pre>"
+      res.write "<p><a href='#{href}'>flip!</a></p>"
+      res.write "<p><a href='?flip=crash'>crash!</a></p>"
+      res.finish
+    end
+
+  end
+end
+
+if $0 == __FILE__
+  # :nocov:
+  require_relative 'server'
+  require_relative 'show_exceptions'
+  require_relative 'lint'
+  Rackup::Server.start(
+    app: Rack::ShowExceptions.new(Rack::Lint.new(Rackup::Lobster.new)), Port: 9292
+  )
+  # :nocov:
+end

data/lib/rackup/server.rb

@@ -0,0 +1,459 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+
+require 'rack/builder'
+require 'rack/common_logger'
+require 'rack/content_length'
+require 'rack/show_exceptions'
+require 'rack/lint'
+require 'rack/tempfile_reaper'
+
+require 'rack/version'
+
+require_relative 'version'
+require_relative 'handler'
+
+module Rackup
+  class Server
+    class Options
+      def parse!(args)
+        options = {}
+        opt_parser = OptionParser.new("", 24, '  ') do |opts|
+          opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
+
+          opts.separator ""
+          opts.separator "Ruby options:"
+
+          lineno = 1
+          opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+            eval line, TOPLEVEL_BINDING, "-e", lineno
+            lineno += 1
+          }
+
+          opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+            options[:debug] = true
+          }
+          opts.on("-w", "--warn", "turn warnings on for your script") {
+            options[:warn] = true
+          }
+          opts.on("-q", "--quiet", "turn off logging") {
+            options[:quiet] = true
+          }
+
+          opts.on("-I", "--include PATH",
+                  "specify $LOAD_PATH (may be used more than once)") { |path|
+            (options[:include] ||= []).concat(path.split(":"))
+          }
+
+          opts.on("-r", "--require LIBRARY",
+                  "require the library, before executing your script") { |library|
+            (options[:require] ||= []) << library
+          }
+
+          opts.separator ""
+          opts.separator "Rack options:"
+          opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
+            options[:builder] = line
+          }
+
+          opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick)") { |s|
+            options[:server] = s
+          }
+
+          opts.on("-o", "--host HOST", "listen on HOST (default: localhost)") { |host|
+            options[:Host] = host
+          }
+
+          opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
+            options[:Port] = port
+          }
+
+          opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
+            name, value = name.split('=', 2)
+            value = true if value.nil?
+            options[name.to_sym] = value
+          }
+
+          opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
+            options[:environment] = e
+          }
+
+          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
+            options[:daemonize] ||= true
+          }
+
+          opts.on("--daemonize-noclose", "run daemonized in the background without closing stdout/stderr") {
+            options[:daemonize] = :noclose
+          }
+
+          opts.on("-P", "--pid FILE", "file to store PID") { |f|
+            options[:pid] = ::File.expand_path(f)
+          }
+
+          opts.separator ""
+          opts.separator "Profiling options:"
+
+          opts.on("--heap HEAPFILE", "Build the application, then dump the heap to HEAPFILE") do |e|
+            options[:heapfile] = e
+          end
+
+          opts.on("--profile PROFILE", "Dump CPU or Memory profile to PROFILE (defaults to a tempfile)") do |e|
+            options[:profile_file] = e
+          end
+
+          opts.on("--profile-mode MODE", "Profile mode (cpu|wall|object)") do |e|
+            unless %w[cpu wall object].include?(e)
+              raise OptionParser::InvalidOption, "unknown profile mode: #{e}"
+            end
+            options[:profile_mode] = e.to_sym
+          end
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          opts.on_tail("-h", "-?", "--help", "Show this message") do
+            puts opts
+            puts handler_opts(options)
+
+            exit
+          end
+
+          opts.on_tail("--version", "Show version") do
+            puts "Rack #{Rack::RELEASE}"
+            exit
+          end
+        end
+
+        begin
+          opt_parser.parse! args
+        rescue OptionParser::InvalidOption => e
+          warn e.message
+          abort opt_parser.to_s
+        end
+
+        options[:config] = args.last if args.last && !args.last.empty?
+        options
+      end
+
+      def handler_opts(options)
+        info = []
+        server = Rackup::Handler.get(options[:server]) || Rackup::Handler.default
+        if server && server.respond_to?(:valid_options)
+          info << ""
+          info << "Server-specific options for #{server.name}:"
+
+          has_options = false
+          server.valid_options.each do |name, description|
+            next if /^(Host|Port)[^a-zA-Z]/.match?(name.to_s) # ignore handler's host and port options, we do our own.
+            info << sprintf("  -O %-21s %s", name, description)
+            has_options = true
+          end
+          return "" if !has_options
+        end
+        info.join("\n")
+      rescue NameError, LoadError
+        return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
+      end
+    end
+
+    # Start a new rack server (like running rackup). This will parse ARGV and
+    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
+    #
+    # Providing an options hash will prevent ARGV parsing and will not include
+    # any default options.
+    #
+    # This method can be used to very easily launch a CGI application, for
+    # example:
+    #
+    #  Rack::Server.start(
+    #    :app => lambda do |e|
+    #      [200, {'content-type' => 'text/html'}, ['hello world']]
+    #    end,
+    #    :server => 'cgi'
+    #  )
+    #
+    # Further options available here are documented on Rack::Server#initialize
+    def self.start(options = nil)
+      new(options).start
+    end
+
+    attr_writer :options
+
+    # Options may include:
+    # * :app
+    #     a rack application to run (overrides :config and :builder)
+    # * :builder
+    #     a string to evaluate a Rack::Builder from
+    # * :config
+    #     a rackup configuration file path to load (.ru)
+    # * :environment
+    #     this selects the middleware that will be wrapped around
+    #     your application. Default options available are:
+    #       - development: CommonLogger, ShowExceptions, and Lint
+    #       - deployment: CommonLogger
+    #       - none: no extra middleware
+    #     note: when the server is a cgi server, CommonLogger is not included.
+    # * :server
+    #     choose a specific Rackup::Handler, e.g. cgi, fcgi, webrick
+    # * :daemonize
+    #     if truthy, the server will daemonize itself (fork, detach, etc)
+    #     if :noclose, the server will not close STDOUT/STDERR
+    # * :pid
+    #     path to write a pid file after daemonize
+    # * :Host
+    #     the host address to bind to (used by supporting Rackup::Handler)
+    # * :Port
+    #     the port to bind to (used by supporting Rackup::Handler)
+    # * :AccessLog
+    #     webrick access log options (or supporting Rackup::Handler)
+    # * :debug
+    #     turn on debug output ($DEBUG = true)
+    # * :warn
+    #     turn on warnings ($-w = true)
+    # * :include
+    #     add given paths to $LOAD_PATH
+    # * :require
+    #     require the given libraries
+    #
+    # Additional options for profiling app initialization include:
+    # * :heapfile
+    #     location for ObjectSpace.dump_all to write the output to
+    # * :profile_file
+    #     location for CPU/Memory (StackProf) profile output (defaults to a tempfile)
+    # * :profile_mode
+    #     StackProf profile mode (cpu|wall|object)
+    def initialize(options = nil)
+      @ignore_options = []
+
+      if options
+        @use_default_options = false
+        @options = options
+        @app = options[:app] if options[:app]
+      else
+        @use_default_options = true
+        @options = parse_options(ARGV)
+      end
+    end
+
+    def options
+      merged_options = @use_default_options ? default_options.merge(@options) : @options
+      merged_options.reject { |k, v| @ignore_options.include?(k) }
+    end
+
+    def default_options
+      environment  = ENV['RACK_ENV'] || 'development'
+      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+      {
+        environment: environment,
+        pid: nil,
+        Port: 9292,
+        Host: default_host,
+        AccessLog: [],
+        config: "config.ru"
+      }
+    end
+
+    def app
+      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
+    end
+
+    class << self
+      def logging_middleware
+        lambda { |server|
+          /CGI/.match?(server.server.name) || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
+        }
+      end
+
+      def default_middleware_by_environment
+        m = Hash.new {|h, k| h[k] = []}
+        m["deployment"] = [
+          [Rack::ContentLength],
+          logging_middleware,
+          [Rack::TempfileReaper]
+        ]
+        m["development"] = [
+          [Rack::ContentLength],
+          logging_middleware,
+          [Rack::ShowExceptions],
+          [Rack::Lint],
+          [Rack::TempfileReaper]
+        ]
+
+        m
+      end
+
+      def middleware
+        default_middleware_by_environment
+      end
+    end
+
+    def middleware
+      self.class.middleware
+    end
+
+    def start(&block)
+      if options[:warn]
+        $-w = true
+      end
+
+      if includes = options[:include]
+        $LOAD_PATH.unshift(*includes)
+      end
+
+      Array(options[:require]).each do |library|
+        require library
+      end
+
+      if options[:debug]
+        $DEBUG = true
+        require 'pp'
+        p options[:server]
+        pp wrapped_app
+        pp app
+      end
+
+      check_pid! if options[:pid]
+
+      # Touch the wrapped app, so that the config.ru is loaded before
+      # daemonization (i.e. before chdir, etc).
+      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
+        wrapped_app
+      end
+
+      daemonize_app if options[:daemonize]
+
+      write_pid if options[:pid]
+
+      trap(:INT) do
+        if server.respond_to?(:shutdown)
+          server.shutdown
+        else
+          exit
+        end
+      end
+
+      server.run(wrapped_app, **options, &block)
+    end
+
+    def server
+      @_server ||= Handler.get(options[:server]) || Handler.default
+    end
+
+    private
+      def build_app_and_options_from_config
+        if !::File.exist? options[:config]
+          abort "configuration #{options[:config]} not found"
+        end
+
+        return Rack::Builder.parse_file(self.options[:config])
+      end
+
+      def handle_profiling(heapfile, profile_mode, filename)
+        if heapfile
+          require "objspace"
+          ObjectSpace.trace_object_allocations_start
+          yield
+          GC.start
+          ::File.open(heapfile, "w") { |f| ObjectSpace.dump_all(output: f) }
+          exit
+        end
+
+        if profile_mode
+          require "stackprof"
+          require "tempfile"
+
+          make_profile_name(filename) do |filename|
+            ::File.open(filename, "w") do |f|
+              StackProf.run(mode: profile_mode, out: f) do
+                yield
+              end
+              puts "Profile written to: #{filename}"
+            end
+          end
+          exit
+        end
+
+        yield
+      end
+
+      def make_profile_name(filename)
+        if filename
+          yield filename
+        else
+          ::Dir::Tmpname.create("profile.dump") do |tmpname, _, _|
+            yield tmpname
+          end
+        end
+      end
+
+      def build_app_from_string
+        Rack::Builder.new_from_string(self.options[:builder])
+      end
+
+      def parse_options(args)
+        # Don't evaluate CGI ISINDEX parameters.
+        args.clear if ENV.include?(Rack::REQUEST_METHOD)
+
+        @options = opt_parser.parse!(args)
+        @options[:config] = ::File.expand_path(options[:config])
+        ENV["RACK_ENV"] = options[:environment]
+        @options
+      end
+
+      def opt_parser
+        Options.new
+      end
+
+      def build_app(app)
+        middleware[options[:environment]].reverse_each do |middleware|
+          middleware = middleware.call(self) if middleware.respond_to?(:call)
+          next unless middleware
+          klass, *args = middleware
+          app = klass.new(app, *args)
+        end
+        app
+      end
+
+      def wrapped_app
+        @wrapped_app ||= build_app app
+      end
+
+      def daemonize_app
+        # Cannot be covered as it forks
+        # :nocov:
+        Process.daemon(true, options[:daemonize] == :noclose)
+        # :nocov:
+      end
+
+      def write_pid
+        ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
+        at_exit { ::FileUtils.rm_f(options[:pid]) }
+      rescue Errno::EEXIST
+        check_pid!
+        retry
+      end
+
+      def check_pid!
+        return unless ::File.exist?(options[:pid])
+
+        pid = ::File.read(options[:pid]).to_i
+        raise Errno::ESRCH if pid == 0
+
+        Process.kill(0, pid)
+        exit_with_pid(pid)
+      rescue Errno::ESRCH
+        ::File.delete(options[:pid])
+      rescue Errno::EPERM
+        exit_with_pid(pid)
+      end
+
+      def exit_with_pid(pid)
+        $stderr.puts "A server is already running (pid: #{pid}, file: #{options[:pid]})."
+        exit(1)
+      end
+  end
+
+end

data/lib/rackup/version.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Copyright, 2022, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+module Rackup
+  VERSION = "0.1.0"
+end

data/lib/rackup.rb

@@ -0,0 +1,6 @@
+require_relative 'rackup/handler'
+require_relative 'rackup/server'
+require_relative 'rackup/version'
+
+require_relative 'rackup/handler/webrick'
+require_relative 'rackup/handler/cgi'

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: rackup
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rack Contributors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: 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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-sprint
+  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: minitest-global_expectations
+  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: bundler
+  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: rake
+  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'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rackup
+- lib/rackup.rb
+- lib/rackup/handler.rb
+- lib/rackup/handler/cgi.rb
+- lib/rackup/handler/webrick.rb
+- lib/rackup/lobster.rb
+- lib/rackup/server.rb
+- lib/rackup/version.rb
+homepage: https://github.com/rack/rackup
+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.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A general server command for Rack applications.
+test_files: []