itsi 0.1.14 → 0.1.19

data/gems/server/exe/itsi

@@ -4,28 +4,48 @@
 require "itsi/server"
 require "optparse"
 
-Itsi::Server::Config.save_argv!
+
+COMMANDS = {
+  "init" => "Initialize a new Itsi.rb server configuration file",
+  "status" => "Show the status of the server",
+  "start" => "Start the Isti server",
+  "serve" => "Start the Isti server",
+  "stop" => "Stop the server",
+  "reload" => "Reload the server",
+  "restart" => "Restart the server",
+  "add_worker" => "Add a new worker to the server cluster",
+  "remove_worker" => "Remove a worker from the server cluster",
+  "routes" => "Print the routes of the server",
+  "passfile" => "Manage hashed users and passwords in a passfile (like .htpasswd). [add, remove, list]",
+  "test_route" => "Test which route a request will be routed to",
+  "static" => "Serve static assets in the given directory"
+}
+
+Itsi::Server::Config.prep_reexec!
 
 options = {}
 
-OptionParser.new do |opts|
-  opts.banner = "Usage: itsi [options]"
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: itsi [COMMAND] [options]"
 
   opts.on("-C", "--config CONFIG_FILE", String, "Itsi Configuration file to use (default: Itsi.rb)") do |config_file|
     options[:config_file] = config_file
   end
 
-  opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{Etc.nprocessors})") do |w|
+  opts.on("-w", "--workers WORKERS", Integer, "Number of workers") do |w|
     options[:workers] = w
   end
 
+  opts.on("-d", "--daemonize", "Run the process as a daemon") do
+    Process.daemon(true)
+  end
+
   opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: 1)") do |t|
     options[:threads] = t
   end
 
-  opts.on("-mtr", "--multithreaded-reactor true/false", String,
-          "Use a multithreaded reactor (default: true)") do |mtr|
-    options[:multithreaded_reactor] = mtr.to_s == "true"
+  opts.on("--[no-]multithreaded-reactor", "Use a multithreaded reactor") do |mtr|
+    options[:multithreaded_reactor] = mtr
   end
 
   opts.on("-r", "--rackup_file FILE", String, "Rackup file to use (default: config.ru)") do |rf|
@@ -97,9 +117,6 @@ OptionParser.new do |opts|
     options[:shutdown_timeout] = shutdown_timeout
   end
 
-  opts.on("--script_name SCRIPT_NAME", String, "Script name to inject into Rack ENV") do |script_name|
-    options[:script_name] = script_name
-  end
 
   opts.on("--stream-body", TrueClass, "Stream body frames (default: false for best compatibility)") do |stream_body|
     options[:stream_body] = stream_body
@@ -107,6 +124,10 @@ OptionParser.new do |opts|
 
   opts.on("-h", "--help", "Show this help message") do
     puts opts
+    puts "COMMAND: "
+    COMMANDS.each do |command, description|
+      puts "    #{command} - #{description}"
+    end
     exit
   end
 
@@ -117,17 +138,42 @@ OptionParser.new do |opts|
   opts.on("--listeners LISTENERS", String, "Listeners for reexec") do |listeners|
     options[:listeners] = listeners
   end
-end.parse!
 
+  opts.on("--passfile PASSFILE", String, "Passfile") do |passfile|
+    options[:passfile] = passfile
+  end
+
+  opts.on("--algorithm ALGORITHM", String, "Algorithm for password hashing") do |algorithm|
+    options[:algorithm] = algorithm
+  end
+end
+
+if ENV['COMP_LINE'] || ARGV.include?('--completion')
+  puts COMMANDS.keys
+  exit
+end
 
-case (command = ARGV.pop)
-when "init"
-  Itsi::Server::Config.write_default
-  exit(0)
-when "reload", "restart", "down", "up", "add_worker", "remove_worker", "status"
-  Itsi::Server.send(command)
-when nil, "start", "serve"
+parser.parse!
+
+case (command = ARGV.shift)
+when *COMMANDS.keys
+  required_arity = Itsi::Server.method(command).parameters&.select{|c| c.first == :req }&.length&.succ || 2
+  case required_arity
+  when 1 then Itsi::Server.send(command)
+  when 2 then Itsi::Server.send(command, options)
+  else
+    if ARGV.length != required_arity - 2
+      puts "Command #{command} requires #{required_arity - 2} subcommands. "
+      exit(0)
+    end
+    Itsi::Server.send(command, options, *ARGV)
+  end
+when nil
   Itsi::Server.start(options)
 else
-  puts "Invalid command #{command}"
+  puts "Invalid command #{command}.\n"
+  puts "COMMAND: "
+  COMMANDS.each do |command, description|
+    puts "    #{command} - #{description}"
+  end
 end

data/gems/server/itsi-server.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
       (f == gemspec) ||
         f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
     end
-  end + Dir["../../crates/**/*.{toml,rs,lock}"].map do |ext_file|
+  end + Dir["../../crates/**/*.{toml,rs,lock,html,json}"].map do |ext_file|
     "ext/#{ext_file[%r{.*crates/(.*?)$}, 1]}"
   end.compact
 
@@ -36,10 +36,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/itsi_server/extconf.rb"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
   spec.add_dependency "rack", ">= 1.6"
+  spec.add_dependency "json", '~> 2'
   spec.add_dependency "rb_sys", "~> 0.9.91"
+
+  spec.add_development_dependency "ruby-lsp"
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/gems/server/lib/itsi/http_request/response_status_shortcodes.rb

@@ -0,0 +1,74 @@
+module Itsi
+  class HttpRequest
+    module ResponseStatusShortcodes
+
+      HTTP_STATUS_CODES = {
+        100 => :continue,
+        101 => :switching_protocols,
+        102 => :processing,
+        200 => :ok,
+        201 => :created,
+        202 => :accepted,
+        203 => :non_authoritative_information,
+        204 => :no_content,
+        205 => :reset_content,
+        206 => :partial_content,
+        207 => :multi_status,
+        208 => :already_reported,
+        226 => :im_used,
+        300 => :multiple_choices,
+        301 => :moved_permanently,
+        302 => :found,
+        303 => :see_other,
+        304 => :not_modified,
+        305 => :use_proxy,
+        307 => :temporary_redirect,
+        308 => :permanent_redirect,
+        400 => :bad_request,
+        401 => :unauthorized,
+        402 => :payment_required,
+        403 => :forbidden,
+        404 => :not_found,
+        405 => :method_not_allowed,
+        406 => :not_acceptable,
+        407 => :proxy_authentication_required,
+        408 => :request_timeout,
+        409 => :conflict,
+        410 => :gone,
+        411 => :length_required,
+        412 => :precondition_failed,
+        413 => :payload_too_large,
+        414 => :uri_too_long,
+        415 => :unsupported_media_type,
+        416 => :range_not_satisfiable,
+        417 => :expectation_failed,
+        418 => :im_a_teapot,
+        421 => :misdirected_request,
+        422 => :unprocessable_entity,
+        423 => :locked,
+        424 => :failed_dependency,
+        425 => :too_early,
+        426 => :upgrade_required,
+        428 => :precondition_required,
+        429 => :too_many_requests,
+        431 => :request_header_fields_too_large,
+        451 => :unavailable_for_legal_reasons,
+        500 => :internal_server_error,
+        501 => :not_implemented,
+        502 => :bad_gateway,
+        503 => :service_unavailable,
+        504 => :gateway_timeout,
+        505 => :http_version_not_supported,
+        506 => :variant_also_negotiates,
+        507 => :insufficient_storage,
+        508 => :loop_detected,
+        510 => :not_extended,
+        511 => :network_authentication_required
+      }.freeze
+
+      HTTP_STATUS_CODES.each do |code, name|
+        define_method(name) {|*args, **kwargs| respond(*args, **kwargs, status: code) }
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/http_request.rb

@@ -2,12 +2,16 @@
 
 require "stringio"
 require "socket"
+require "uri"
+require_relative 'http_request/response_status_shortcodes'
 
 module Itsi
   class HttpRequest
+    include Server::TypedHandlers::ParamParser
+    include ResponseStatusShortcodes
     attr_accessor :hijacked
 
-    EMPTY_IO = StringIO.new("").freeze
+    EMPTY_IO = StringIO.new("")
     RACK_HEADER_MAP = StandardHeaders::ALL.map do |header|
       rack_form = if header == "content-type"
                     "CONTENT_TYPE"
@@ -25,10 +29,11 @@ module Itsi
       path = self.path
       host = self.host
       version = self.version
+
       {
         "SERVER_SOFTWARE" => "Itsi",
         "SCRIPT_NAME" => script_name,
-        "REQUEST_METHOD" => method,
+        "REQUEST_METHOD" => request_method,
         "PATH_INFO" => path,
         "REQUEST_PATH" => path,
         "QUERY_STRING" => query_string,
@@ -49,39 +54,134 @@ module Itsi
         "rack.run_once" => false,
         "rack.hijack?" => true,
         "rack.multipart.buffer_size" => 16_384,
-        "rack.hijack" => build_hijack_proc
+        "rack.hijack" => method(:hijack)
       }.tap do |r|
         headers.each do |(k, v)|
-          r[RACK_HEADER_MAP[k]] = v
+          r[case k
+            when "content-type" then "CONTENT_TYPE"
+            when "content-length" then "CONTENT_LENGTH"
+            when "accept" then "HTTP_ACCEPT"
+            when "accept-encoding" then "HTTP_ACCEPT_ENCODING"
+            when "accept-language" then "HTTP_ACCEPT_LANGUAGE"
+            when "user-agent" then "HTTP_USER_AGENT"
+            when "referer" then "HTTP_REFERER"
+            when "origin" then "HTTP_ORIGIN"
+            when "cookie" then "HTTP_COOKIE"
+            when "authorization" then "HTTP_AUTHORIZATION"
+            when "x-forwarded-for" then "HTTP_X_FORWARDED_FOR"
+            when "x-forwarded-proto" then "HTTP_X_FORWARDED_PROTO"
+            else RACK_HEADER_MAP[k]
+            end
+          ] = v
         end
       end
     end
 
-    def respond(_body = nil, _status = 200, _header = nil, status: _status, headers: _header, body: _body,
-                hijack: false, &blk)
+    def respond(
+      _body = nil, _status = 200, _headers = nil,
+      json: nil,
+      html: nil,
+      text: nil,
+      xml: nil,
+      hijack: false,
+      as: nil,
+      status: _status,
+      headers: _headers,
+      body: _body,
+      &blk
+    )
+
+      if json
+        validate!(json, as: as) if as
+        body = json.to_json
+        headers ||= {}
+        headers["Content-Type"] ||= "application/json"
+      elsif html
+        body = html
+        headers ||= {}
+        headers["Content-Type"] ||= "text/html"
+      elsif xml
+        body = xml
+        headers ||= {}
+        headers["Content-Type"] ||= "application/xml"
+      elsif text
+        body = text
+        headers ||= {}
+        headers["Content-Type"] ||= "text/plain"
+      end
+
       response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
     end
 
-    def build_hijack_proc
-      lambda do
-        self.hijacked = true
-        UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
-          server_sock.autoclose = false
-          response.hijack(server_sock.fileno)
-          server_sock.sync = true
-          app_sock.sync = true
-          app_sock
-        end
+    def hijack
+      self.hijacked = true
+      UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+        server_sock.autoclose = false
+        self.response.hijack(server_sock.fileno)
+        server_sock.sync = true
+        app_sock.sync = true
+        app_sock
       end
     end
 
     def build_input_io
       case body
-      when nil then StringIO.new("")
+      when nil then EMPTY_IO
       when String then StringIO.new(body)
       when Array then File.open(body.first, "rb")
       else body
       end
     end
+
+    def validate!(params, as: nil)
+      as ? apply_schema!(params, as) : params
+    end
+
+    def params(schema=nil)
+      params = case
+      when url_encoded? then URI.decode_www_form(build_input_io.read).to_h
+      when json? then JSON.parse(build_input_io.read)
+      when multipart?
+        Rack::Multipart::Parser.parse(
+          build_input_io,
+          content_length,
+          content_type,
+          Rack::Multipart::Parser::TEMPFILE_FACTORY,
+          Rack::Multipart::Parser::BUFSIZE,
+          Rack::Utils.default_query_parser
+        ).params
+      else
+        {}
+      end
+
+      params.merge!(query_params).merge!(url_params)
+
+      yield schema ? apply_schema!(params, schema) : params
+
+    rescue StandardError => e
+      if response.json?
+        respond(json: {error: e.message}, status: 400)
+      else
+        respond(e.message, 400)
+      end
+    ensure
+      clean_temp_files(params)
+    end
+
+    def clean_temp_files(params)
+      case params
+      when Hash
+        if params.key?(:tempfile)
+          params[:tempfile].unlink
+        else
+        params.each_value { |v| clean_temp_files(v) }
+        end
+      when Array then params.each { |v| clean_temp_files(v) }
+      end
+    end
+
+    def query_params
+      URI.decode_www_form(query_string).to_h
+    end
   end
 end

data/gems/server/lib/itsi/http_response.rb

@@ -10,6 +10,8 @@ module Itsi
     def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
       self.status = status
 
+      body = body.to_s unless body.is_a?(String)
+
       if headers
         headers.each do |key, value|
           if value.is_a?(Array)

data/gems/server/lib/itsi/passfile.rb

@@ -0,0 +1,109 @@
+module Itsi
+  class Server
+
+    module Passfile
+      require 'io/console'
+
+      module_function
+
+      def load(filename)
+        if filename.nil? || filename.strip.empty?
+          puts "Error: a valid filename is required."
+          return nil
+        end
+
+        creds = {}
+        if File.exist?(filename)
+          File.foreach(filename) do |line|
+            line.chomp!
+            next if line.empty?
+
+            user, pass = line.split(':', 2)
+            creds[user] = pass
+          end
+        end
+        creds
+      end
+
+      def save(creds, filename)
+        File.open(filename, 'w', 0o600) do |f|
+          creds.each do |u, p|
+            f.puts "#{u}:#{p}"
+          end
+        end
+      end
+
+      def echo(filename, algorithm)
+        return unless (creds = load(filename))
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        puts "#{username}:#{Itsi.create_password_hash(password, algorithm)}"
+      end
+
+      def add(filename, algorithm)
+        return unless (creds = load(filename))
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        creds[username] = Itsi.create_password_hash(password, algorithm)
+
+        save(creds, filename)
+
+        puts "User '#{username}' added."
+      end
+
+      def remove(filename)
+        return unless (creds = load(filename))
+
+        print "Enter username to remove: "
+        username = $stdin.gets.chomp
+
+        if creds.key?(username)
+          creds.delete(username)
+          save(creds, filename)
+          puts "User '#{username}' removed."
+        else
+          puts "Warning: User '#{username}' not found."
+        end
+      end
+
+      def list(filename)
+        puts "Current credentials in '#{filename}':"
+        return unless (creds = load(filename))
+        creds.each do |u, p|
+          puts "#{u}:#{p}"
+        end
+      end
+
+    end
+  end
+end