itsi-server 0.1.1 → 0.2.2

data/lib/itsi/server.rb

@@ -2,20 +2,276 @@
 
 require_relative "server/version"
 require_relative "server/itsi_server"
+require_relative "server/rack_interface"
+require_relative "server/grpc/grpc_interface"
+require_relative "server/grpc/grpc_call"
+require_relative "server/scheduler_interface"
+require_relative "server/signal_trap"
+require_relative "server/route_tester"
+require_relative "server/rack/handler/itsi"
+require_relative "server/config"
+require_relative "server/typed_handlers"
+require_relative "standard_headers"
+require_relative "http_request"
+require_relative "http_response"
+require_relative "passfile"
+require_relative "../shell_completions/completions"
+
+require "securerandom"
+require "fileutils"
 
 module Itsi
   class Server
-    # Call our Rack app with our request ENV.
-    def self.call(app, request)
-      app.call(request.to_env)
-    end
+    extend RackInterface
+    extend SchedulerInterface
+    extend RouteTester
+
+    class << self
+
+      def running?
+        @running && !@running.empty?
+      end
+
+      def start_in_background_thread(cli_params = {}, &blk)
+        @background_threads ||= []
+        server, background_thread = start(cli_params, background: true, &blk)
+        @background_threads << background_thread
+        server
+      end
+
+      def start(cli_params, background: false, &blk)
+        itsi_file = Itsi::Server::Config.config_file_path(cli_params[:config_file])
+        Itsi.log_debug "Constructing server #{cli_params}: #{itsi_file}"
+        server = new(cli_params, itsi_file, blk)
+        previous_handler = Signal.trap(:INT, :DEFAULT)
+        run = lambda do
+          @running ||= []
+          @running << server
+
+          if cli_params[:daemonize]
+            Itsi.log_info("Itsi is running in the background. Writing pid to #{Itsi::Server::Config.pid_file_path}")
+            Itsi.log_info("To stop Itsi, run 'itsi stop' from this directory.")
+            Process.daemon(true, false)
+          end
+          write_pid
+
+          Itsi.log_info "Starting Itsi..."
+          server.start
+          @running.delete(server)
+          Signal.trap(:INT, previous_handler)
+          server
+        end
+        background ? [server, Thread.new(&run)] : run[]
+      rescue Exception => e
+        Itsi.log_error e.message
+        raise e
+      end
+
+      def static(cli_params)
+        start(cli_params.merge(static: true))
+      end
+
+      def stop
+        return unless pid = get_pid
+        Process.kill(:INT, pid)
+        i = 0
+        while i < 10
+          sleep 0.25
+          unless get_pid(false)
+            puts "Itsi stopped"
+            break
+          end
+          i += 1
+        end
+      end
+
+      def stop_background_threads
+        @running && @running.each(&:stop)
+        @background_threads&.each(&:join)
+        @background_threads = []
+        @running = []
+      end
+
+      def write_pid
+        File.write(Itsi::Server::Config.pid_file_path, Process.pid)
+      end
+
+      def get_pid(warn=true)
+        pid = File.read(Itsi::Server::Config.pid_file_path).to_i
+        if Process.kill(0, pid)
+          pid
+        else
+          warn ? puts("No server running") : nil
+          nil
+        end
+      rescue StandardError
+        warn ? puts("No server running") : nil
+        nil
+      end
+
+      def test
+        Itsi::Server::Config.test!(cli_params = {})
+      end
+
+      def init
+        Config.write_default
+      end
+
+      def reload
+        return unless pid = get_pid
+
+        Process.kill(:HUP, pid)
+      end
+
+      def restart
+        return unless pid = get_pid
+
+        Process.kill(:USR1, pid)
+      end
 
-    # If scheduler is enabled
-    # Each request is wrapped in a Fiber.
-    def self.schedule(app, request)
-      Fiber.schedule do
-        call(app, request)
+      def passfile(options, subcmd)
+        filename = options[:passfile]
+        unless filename || subcmd == 'echo'
+          puts "Error: passfile not set. Use --passfile option to provide a path to a file containing hashed credentials."
+          puts "This file contains hashed credentials and should not be included in source control without additional protection."
+          exit(1)
+        end
+        algorithm = options.fetch(:algorithm, 'sha256')
+
+        unless %w[sha256 sha512 bcrypt argon2 none].include?(algorithm)
+          puts "Invalid algorithm"
+          exit(1)
+        end
+
+        case subcmd
+        when 'add', 'echo'
+          Passfile.send(subcmd, filename, algorithm)
+        when 'remove', 'list'
+          Passfile.send(subcmd, filename)
+        else
+          puts "Valid subcommands are: add | remove | list"
+          exit(0)
+        end
+      end
+
+      def unique_path(dir, filename)
+        base = File.basename(filename, ".*")
+        ext  = File.extname(filename)
+        candidate = File.join(dir, filename)
+        return candidate unless File.exist?(candidate)
+
+        i = 1
+        loop do
+          new_name = "#{base}_#{i}#{ext}"
+          candidate = File.join(dir, new_name)
+          return candidate unless File.exist?(candidate)
+          i += 1
+        end
+      end
+
+      def save_or_print(filename, content, options)
+        if options[:save_dir]
+          FileUtils.mkdir_p(options[:save_dir])
+          path = unique_path(options[:save_dir], filename)
+          File.write(path, content)
+          puts "Written to #{path}"
+        else
+          puts content
+        end
+      end
+
+      def secret(options)
+        require "openssl"
+        require "base64"
+
+        puts "Enter algorithm (one of: HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384):"
+        alg = $stdin.gets.chomp.upcase
+
+        case alg
+        when /^HS(\d+)$/
+          bits = $1.to_i
+          bytes = bits / 8
+          key = SecureRandom.random_bytes(bytes)
+          pem = Base64.strict_encode64(key)
+          content =  "=== HMAC #{bits}-bit Secret (base64) ===\n#{pem}\n"
+          save_or_print("hmac_#{bits}_secret.txt", content, options)
+
+        when /^RS/, /^PS/
+          rsa = OpenSSL::PKey::RSA.new(2048)
+          priv = rsa.to_pem
+          pub  = rsa.public_key.to_pem
+          save_or_print("rsa_private.pem", "=== RSA Private Key ===\n#{priv}", options)
+          save_or_print("rsa_public.pem",  "=== RSA Public Key ===\n#{pub}", options)
+
+        when "ES256", "ES384"
+          curve = (alg == "ES256" ? "prime256v1" : "secp384r1")
+          ec = OpenSSL::PKey::EC.new(curve)
+          ec.generate_key
+          priv = ec.to_pem
+          pub_ec = ec.dup
+          pub_ec.private_key = nil
+          pub = pub_ec.to_pem
+          save_or_print("ecdsa_private.pem", "=== ECDSA Private Key ===\n#{priv}", options)
+          save_or_print("ecdsa_public.pem",  "=== ECDSA Public Key ===\n#{pub}", options)
+
+        else
+          STDERR.puts "Unsupported algorithm: #{alg}"
+          exit 1
+        end
       end
+
+
+      def add_worker
+        return unless pid = get_pid
+
+        Process.kill(:TTIN, pid)
+      end
+
+      def remove_worker
+        return unless pid = get_pid
+
+        Process.kill(:TTOU, pid)
+      end
+
+      def status
+        return unless pid = get_pid
+        Itsi.log_info("Itsi running on #{pid}")
+        Process.kill(:USR2, pid)
+      end
+
+      def load_route_middleware_stack(cli_params)
+        middleware, errors = Config.build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file_path]))
+        if errors.any?
+          puts errors
+          []
+        else
+          middleware["middleware_loader"][]
+        end
+      end
+
+      def test_route(cli_params, route_str)
+        matched_route = load_route_middleware_stack(cli_params).find do |route|
+          route["route"] =~ route_str
+        end
+        if matched_route
+          print_route(route_str, matched_route)
+        else
+          puts "No matching route found"
+        end
+      end
+
+      def routes(cli_params = {})
+        load_route_middleware_stack(cli_params).each do |stack|
+          routes = explode_route_pattern(stack["route"].source)
+          routes.each do |route|
+            print_route(route, stack)
+          end
+        end
+        puts "─" * 76
+      end
+
+      alias serve start
+
     end
   end
 end

data/lib/itsi/standard_headers.rb

@@ -0,0 +1,86 @@
+module Itsi
+  module StandardHeaders
+    ALL = [
+      ACCEPT = "accept",
+      ACCEPT_CHARSET = "accept-charset",
+      ACCEPT_ENCODING = "accept-encoding",
+      ACCEPT_LANGUAGE = "accept-language",
+      ACCEPT_RANGES = "accept-ranges",
+      ACCESS_CONTROL_ALLOW_CREDENTIALS = "access-control-allow-credentials",
+      ACCESS_CONTROL_ALLOW_HEADERS = "access-control-allow-headers",
+      ACCESS_CONTROL_ALLOW_METHODS = "access-control-allow-methods",
+      ACCESS_CONTROL_ALLOW_ORIGIN = "access-control-allow-origin",
+      ACCESS_CONTROL_EXPOSE_HEADERS = "access-control-expose-headers",
+      ACCESS_CONTROL_MAX_AGE = "access-control-max-age",
+      ACCESS_CONTROL_REQUEST_HEADERS = "access-control-request-headers",
+      ACCESS_CONTROL_REQUEST_METHOD = "access-control-request-method",
+      AGE = "age",
+      ALLOW = "allow",
+      ALT_SVC = "alt-svc",
+      AUTHORIZATION = "authorization",
+      CACHE_CONTROL = "cache-control",
+      CACHE_STATUS = "cache-status",
+      CDN_CACHE_CONTROL = "cdn-cache-control",
+      CONNECTION = "connection",
+      CONTENT_DISPOSITION = "content-disposition",
+      CONTENT_ENCODING = "content-encoding",
+      CONTENT_LANGUAGE = "content-language",
+      CONTENT_LENGTH = "content-length",
+      CONTENT_LOCATION = "content-location",
+      CONTENT_RANGE = "content-range",
+      CONTENT_SECURITY_POLICY_REPORT_ONLY = "content-security-policy-report-only",
+      CONTENT_TYPE = "content-type",
+      COOKIE = "cookie",
+      DNT = "dnt",
+      DATE = "date",
+      ETAG = "etag",
+      EXPECT = "expect",
+      EXPIRES = "expires",
+      FORWARDED = "forwarded",
+      FROM = "from",
+      HOST = "host",
+      IF_MATCH = "if-match",
+      IF_MODIFIED_SINCE = "if-modified-since",
+      IF_NONE_MATCH = "if-none-match",
+      IF_RANGE = "if-range",
+      IF_UNMODIFIED_SINCE = "if-unmodified-since",
+      LAST_MODIFIED = "last-modified",
+      LINK = "link",
+      LOCATION = "location",
+      MAX_FORWARDS = "max-forwards",
+      ORIGIN = "origin",
+      PRAGMA = "pragma",
+      PROXY_AUTHENTICATE = "proxy-authenticate",
+      PROXY_AUTHORIZATION = "proxy-authorization",
+      PUBLIC_KEY_PINS = "public-key-pins",
+      PUBLIC_KEY_PINS_REPORT_ONLY = "public-key-pins-report-only",
+      RANGE = "range",
+      REFERER = "referer",
+      REFERRER_POLICY = "referrer-policy",
+      REFRESH = "refresh",
+      RETRY_AFTER = "retry-after",
+      SEC_WEBSOCKET_ACCEPT = "sec-websocket-accept",
+      SEC_WEBSOCKET_EXTENSIONS = "sec-websocket-extensions",
+      SEC_WEBSOCKET_KEY = "sec-websocket-key",
+      SEC_WEBSOCKET_PROTOCOL = "sec-websocket-protocol",
+      SEC_WEBSOCKET_VERSION = "sec-websocket-version",
+      SERVER = "server",
+      SET_COOKIE = "set-cookie",
+      STRICT_TRANSPORT_SECURITY = "strict-transport-security",
+      TE = "te",
+      TRAILER = "trailer",
+      TRANSFER_ENCODING = "transfer-encoding",
+      USER_AGENT = "user-agent",
+      UPGRADE = "upgrade",
+      UPGRADE_INSECURE_REQUESTS = "upgrade-insecure-requests",
+      VARY = "vary",
+      VIA = "via",
+      WARNING = "warning",
+      WWW_AUTHENTICATE = "www-authenticate",
+      X_CONTENT_TYPE_OPTIONS = "x-content-type-options",
+      X_DNS_PREFETCH_CONTROL = "x-dns-prefetch-control",
+      X_FRAME_OPTIONS = "x-frame-options",
+      X_XSS_PROTECTION = "x-xss-protection",
+    ]
+  end
+end

data/lib/ruby_lsp/itsi/addon.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+require "itsi/server"
+
+module RubyLsp
+  module Itsi
+    class Addon < ::RubyLsp::Addon
+      def activate(global_state, message_queue)
+        @message_queue = message_queue
+      end
+
+      def deactivate; end
+
+      def name
+        "Ruby LSP Itsi"
+      end
+
+      def version
+        "0.1.0"
+      end
+
+
+      def create_completion_listener(response_builder, node_context, dispatcher, uri)
+        return unless uri.to_s.end_with?("Itsi.rb")
+        @in_itsi_file = true
+        CompletionListener.new(response_builder, node_context, dispatcher, uri)
+      end
+
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        hl = dispatcher.listeners[:on_call_node_enter].find { |c| c.is_a?(RubyLsp::Listeners::Hover) }
+        return unless hl.instance_variable_get("@path").to_s.end_with?("Itsi.rb")
+        HoverListener.new(response_builder, node_context, dispatcher)
+      end
+    end
+
+    class HoverListener
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @dispatcher = dispatcher
+
+        @options_by_name = ::Itsi::Server::Config::Option.subclasses.group_by(&:option_name).map{|k,v| [k,v.first]}.to_h
+        @middlewares_by_name = ::Itsi::Server::Config::Middleware.subclasses.group_by(&:middleware_name).map{|k,v| [k,v.first]}.to_h
+        # Register for call nodes for hover events
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        if (matched_class = @options_by_name[node.message.to_sym])
+          @response_builder.push(
+            matched_class.documentation,
+            category: :documentation
+          )
+        elsif (matched_class = @middlewares_by_name[node.message.to_sym])
+          @response_builder.push(
+            matched_class.documentation,
+            category: :documentation
+          )
+        end
+      end
+    end
+
+    class CompletionListener
+      def initialize(response_builder, node_context, dispatcher, uri)
+        @response_builder = response_builder
+        @node_context = node_context
+        @uri = uri
+        @dispatcher = dispatcher
+
+        # Register for method call completions
+        dispatcher.register(self, :on_call_node_enter)
+        # Also register for completion item resolution requests
+        dispatcher.register(self, :completion_item_resolve)
+      end
+
+      def on_call_node_enter(node)
+        # Only handle method calls that are being typed (i.e. no arguments yet)
+        return unless node.arguments.nil?
+
+        ::Itsi::Server::Config::Option.subclasses.each do |option|
+          completion_item = Interface::CompletionItem.new(
+            label: option.option_name,
+            kind: Constant::CompletionItemKind::METHOD,
+            label_details: Interface::CompletionItemLabelDetails.new(
+              detail: option.detail,
+              description: option.documentation
+            ),
+            documentation: Interface::MarkupContent.new(
+              kind: Constant::MarkupKind::MARKDOWN,
+              value: option.documentation
+            ),
+            insert_text: option.insert_text,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              delegateCompletion: true
+            }
+          )
+          @response_builder << completion_item
+        end
+
+        ::Itsi::Server::Config::Middleware.subclasses.each do |middleware|
+          Array(middleware.insert_text).zip(Array(middleware.detail)).each do |insert_text, detail|
+            completion_item = Interface::CompletionItem.new(
+              label: middleware.middleware_name,
+              kind: Constant::CompletionItemKind::METHOD,
+              label_details: Interface::CompletionItemLabelDetails.new(
+                detail: detail,
+                description: middleware.documentation
+              ),
+              documentation: Interface::MarkupContent.new(
+                kind: Constant::MarkupKind::MARKDOWN,
+                value: middleware.documentation
+              ),
+              insert_text: insert_text,
+              insert_text_format: Constant::InsertTextFormat::SNIPPET,
+              data: {
+                delegateCompletion: true
+              }
+            )
+            @response_builder << completion_item
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/shell_completions/completions.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+if ARGV.include?('--install-completions')
+  # Try to get the next argument as the shell name.
+  shell = ARGV[ARGV.index('--install-completions') + 1] rescue nil
+  # Fallback: use the basename of the SHELL environment variable
+  shell ||= File.basename(ENV['SHELL'] || '')
+
+  case shell.downcase
+  when 'bash'
+    # Bash completion script
+    puts 'complete -W "$(itsi --completion)" itsi'
+  when 'zsh'
+    puts <<~ZSH
+      _itsi() {
+        local completions
+        completions=("${(@f)$(itsi --completion)}")
+        compadd -- $completions
+      }
+      compdef _itsi itsi
+    ZSH
+  else
+    warn "Unsupported shell: #{shell}. Please specify 'bash' or 'zsh'."
+  end
+  exit
+end