itsi 0.1.19 → 0.2.2

data/gems/server/lib/itsi/server/typed_handlers/param_parser.rb

@@ -23,21 +23,21 @@ module Itsi
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           FalseClass => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           :Boolean  => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           Date      => ->(v){ Date.parse(v.to_s) },
@@ -45,17 +45,6 @@ module Itsi
           DateTime  => ->(v){ DateTime.parse(v.to_s) }
         }.compare_by_identity
 
-        # Extracts the expected type and required flag from a schema definition.
-        def extract_schema(schema_def)
-          if schema_def.is_a?(Hash) && schema_def.key?(:_type)
-            expected_type = schema_def[:_type]
-            required = schema_def.fetch(:required, true)
-            [expected_type, required]
-          else
-            [schema_def, true]
-          end
-        end
-
         # Preprocess the schema into fixed keys (as symbols) and regex keys.
         # Memoizes the result based on the schema.
         def processed_schema(schema)
@@ -63,8 +52,9 @@ module Itsi
           @@schema_cache[schema] ||= begin
             fixed = {}
             regex = []
+            required_params = schema[:_required] || []
             schema.each do |k, schema_def|
-              expected_type, required = extract_schema(schema_def)
+              expected_type, required = schema_def, required_params.include?(k)
               if k.is_a?(Regexp)
                 regex << [k, [expected_type, required]]
               else
@@ -179,16 +169,22 @@ module Itsi
           end
 
           # Process regex keys (only string keys not already handled as fixed keys).
-          params.keys.select { |k| k.is_a?(String) }.each do |key|
+          params.keys.each do |key|
+            if key == :_required
+              params.delete(key)
+              next
+            end
             next if fixed_schema.has_key?(key.to_sym) || fixed_schema.has_key?(key)
-            regex_schema.each do |regex, (expected_type, _required)|
+            unless regex_schema.find do |regex, (expected_type, _required)|
               if regex.match(key)
                 new_path = path + [key]
                 err = cast_value!(params, key, expected_type, new_path)
                 errors << err if err
-                break  # only use the first matching regex
+                true  # only use the first matching regex
               end
             end
+              params.delete(key)
+            end
           end
 
           raise ValidationError.new(errors) unless errors.empty?

data/gems/server/lib/itsi/server/typed_handlers/source_parser.rb

@@ -6,17 +6,18 @@ module Itsi
 
 
         def self.extract_expr_from_source_location(proc)
-          source_lines = IO.readlines(proc.source_location.first)
+          source_location = proc.source_location
+          source_lines = IO.readlines(source_location.first)
 
           proc_line = source_location.last - 1
           first_line = source_lines[proc_line]
-          binding.b
-          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*\|)/ || proc_line.zero?
+
+          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*|.*?\{.*?\|)/ || proc_line.zero?
             proc_line -= 1
             first_line = source_lines[proc_line]
           end
           lines = source_lines[proc_line..]
-          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s*\|).*/]
+          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s+|.*?\{.*?\|).*/]
           src_str = lines.first << "\n"
           intermediate = Prism.parse(src_str)
 
@@ -47,7 +48,7 @@ module Itsi
 
           [requireds.length, keywords]
         rescue
-          [ proc.parameters.first&.length || 0, {}]
+          [ proc.parameters.select{|p| p == :req }&.length || 0, {}]
         end
       end
     end

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

@@ -5,10 +5,18 @@ module Itsi
   class Server
     module TypedHandlers
       def self.handler_for(proc, input_schema)
-        input_schema = proc.binding.eval(input_schema) if input_schema
-        lambda do |req|
-          req.params(input_schema) do |params|
-            proc.call(req, params: params)
+        if input_schema
+          input_schema = proc.binding.eval(input_schema)
+          lambda do |req|
+            req.params(input_schema) do |params|
+              proc.call(req, params: params)
+            end
+          end
+        else
+          lambda do |req|
+            req.params do |params|
+              proc.call(req, params)
+            end
           end
         end
       end

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.19"
+    VERSION = "0.2.2"
   end
 end

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

@@ -17,6 +17,9 @@ require_relative "http_response"
 require_relative "passfile"
 require_relative "../shell_completions/completions"
 
+require "securerandom"
+require "fileutils"
+
 module Itsi
   class Server
     extend RackInterface
@@ -26,26 +29,42 @@ module Itsi
     class << self
 
       def running?
-        !!@running
+        @running && !@running.empty?
       end
 
       def start_in_background_thread(cli_params = {}, &blk)
-        @background_thread = start(cli_params, background: true, &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
-          @running = server
+
+          Itsi.log_info "Starting Itsi..."
           server.start
-          @running = false
+          @running.delete(server)
           Signal.trap(:INT, previous_handler)
           server
         end
-        background ? Thread.new(&run) : run[]
+        background ? [server, Thread.new(&run)] : run[]
+      rescue Exception => e
+        Itsi.log_error e.message
+        raise e
       end
 
       def static(cli_params)
@@ -55,30 +74,45 @@ module Itsi
       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_thread
-        @running&.stop
-        @background_thread&.join
+      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
+      def get_pid(warn=true)
         pid = File.read(Itsi::Server::Config.pid_file_path).to_i
         if Process.kill(0, pid)
           pid
         else
-          puts "No server running"
+          warn ? puts("No server running") : nil
           nil
         end
       rescue StandardError
-        puts "No server running"
+        warn ? puts("No server running") : nil
         nil
       end
 
+      def test
+        Itsi::Server::Config.test!(cli_params = {})
+      end
+
       def init
         Config.write_default
       end
@@ -97,7 +131,7 @@ module Itsi
 
       def passfile(options, subcmd)
         filename = options[:passfile]
-        unless filename
+        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)
@@ -120,6 +154,73 @@ module Itsi
         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
 
@@ -134,17 +235,21 @@ module Itsi
 
       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)
-        Config.build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file_path]))[
-          "middleware_loader"
-          ][]
+        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)
+      def test_route(cli_params, route_str)
         matched_route = load_route_middleware_stack(cli_params).find do |route|
           route["route"] =~ route_str
         end

data/gems/server/lib/ruby_lsp/itsi/addon.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/addon"
-puts "Here we go"
+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"
@@ -14,6 +20,7 @@ module RubyLsp
         "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
@@ -21,8 +28,7 @@ module RubyLsp
       end
 
       def create_hover_listener(response_builder, node_context, dispatcher)
-        hl =  dispatcher.listeners[:on_call_node_enter].find{|c| c.kind_of?(RubyLsp::Listeners::Hover)}
-
+        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
@@ -34,29 +40,21 @@ module RubyLsp
         @node_context = node_context
         @dispatcher = dispatcher
 
-        # Register for call nodes (you could also use other events if more appropriate)
+        @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)
-        # Check if this is the call for foo_bar; you might add additional logic if needed.
-        case node.message
-        when "log_level"
-          # Push a simple hover response.
-          @response_builder.push(
-            "Method **log_level**: A method that takes a single parameter `a`.",
-            category: :documentation
-          )
-        when "shutdown_timeout"
-          # Push a simple hover response.
+        if (matched_class = @options_by_name[node.message.to_sym])
           @response_builder.push(
-            "Method **shutdown_timeout**: Number of seconds to wait for a graceful shutdown before forcefully shutting down.",
+            matched_class.documentation,
             category: :documentation
           )
-        when "log"
-          # Push a simple hover response.
+        elsif (matched_class = @middlewares_by_name[node.message.to_sym])
           @response_builder.push(
-            "Method **log**: A method that takes a single parameter `a`.",
+            matched_class.documentation,
             category: :documentation
           )
         end
@@ -70,42 +68,62 @@ module RubyLsp
         @uri = uri
         @dispatcher = dispatcher
 
-        # Register for call nodes to handle method completions
+        # 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 (no arguments yet)
+        # Only handle method calls that are being typed (i.e. no arguments yet)
         return unless node.arguments.nil?
-        puts "Adding log level completion"
-        # Add our completion item
-        @response_builder << Interface::CompletionItem.new(
-          label: "log_level",
-          kind: Constant::CompletionItemKind::METHOD,
-          detail: "log_level a ",
-          documentation: "A method that takes a single parameter 'a'",
-          insert_text: "log_level ${1|:info,:debug,:warn,:error|}",
-          insert_text_format: Constant::InsertTextFormat::SNIPPET,
-        )
-
-        @response_builder << Interface::CompletionItem.new(
-          label: "bind",
-          kind: Constant::CompletionItemKind::METHOD,
-          detail: "Bind to an interface",
-          documentation: "A method that takes a single parameter 'a'",
-          insert_text: "bind ${1|'https://0.0.0.0','http://0.0.0.0','http://0.0.0.0:3000','https://0.0.0.0:3000','http://127.0.0.1','https://127.0.0.1'|}",
-          insert_text_format: Constant::InsertTextFormat::SNIPPET,
-        )
-
-        @response_builder << Interface::CompletionItem.new(
-          label: "log_format",
-          kind: Constant::CompletionItemKind::METHOD,
-          detail: "log_format",
-          documentation: "A method that takes a single parameter 'a'",
-          insert_text: "log_format ${1|:plain,:json,:auto|}",
-          insert_text_format: Constant::InsertTextFormat::SNIPPET,
-        )
+
+        ::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/gems/server/test/helpers/test_helper.rb

@@ -4,28 +4,147 @@ ENV["ITSI_LOG"] = "off"
 require "minitest/reporters"
 require "itsi/server"
 require "itsi/scheduler"
+require "socket"
+require "net/http"
+require "minitest/autorun"
+
 
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
-def free_bind(protocol)
-  server = TCPServer.new("0.0.0.0", 0)
-  port = server.addr[1]
-  server.close
-  "#{protocol}://0.0.0.0:#{port}"
+def free_bind(protocol="http", unix_socket: false)
+  if unix_socket
+    socket_path = "/tmp/itsi_socket_#{Process.pid}_#{rand(1000)}.sock"
+    UNIXServer.new(socket_path).close
+    protocol == 'https' ? "tls://#{socket_path}" : "unix://#{socket_path}"
+  else
+    server = TCPServer.new("0.0.0.0", 0)
+    port = server.addr[1]
+    server.close
+    "#{protocol}://0.0.0.0:#{port}"
+  end
 end
 
-def run_app(app, protocol: "http", bind: free_bind(protocol), scheduler_class: nil)
-  Itsi::Server.start_in_background_thread do
+
+def server(app: nil, protocol: "http", bind: free_bind(protocol), itsi_rb: nil, cleanup: true, timeout: 5, &blk)
+  itsi_rb ||= lambda do
     # Inline Itsi.rb
     bind bind
     workers 1
     threads 1
-    fiber_scheduler scheduler_class
     log_level :warn
-    run app
+    run app if app
   end
 
-  yield URI(bind)
+  cli_params = {}
+  cli_params[:binds] = [bind] if bind
+
+  sync = Queue.new
+  cli_params[:hooks] ||= {}
+  cli_params[:hooks]["after_start"] = lambda do
+    sync.push(true)
+  end
+
+  Itsi::Server.start_in_background_thread(cli_params, &itsi_rb)
+
+  sync.pop
+  uri = URI(bind)
+  # Timeout.timeout(timeout) do
+    RequestContext.new(uri, self).instance_exec(uri, &blk)
+  # end
+rescue StandardError => e
+  puts e
+  # puts e.message
+  # puts e.backtrace.join("\n")
+  raise
 ensure
-  Itsi::Server.stop_background_thread
+  Itsi::Server.stop_background_threads if cleanup
+end
+
+require 'net/http'
+require 'net_http_unix'
+require 'uri'
+
+class RequestContext
+  def initialize(uri, binding)
+    @uri = uri
+    @binding = binding
+  end
+
+  def method_missing(method_name, *args, &block)
+    @binding.send(method_name, *args, &block)
+  end
+
+  def post(path, data="", headers = {})
+    client.post(uri_for(path), data, headers)
+  end
+
+  def get(path, headers = {})
+    request = Net::HTTP::Get.new(uri_for(path))
+    headers.each { |k, v| request[k] = v }
+    client.request(request).body
+  end
+
+  def get_resp(path, headers = {})
+    request = Net::HTTP::Get.new(uri_for(path))
+    headers.each { |k, v| request[k] = v }
+    client.request(request)
+  end
+
+  def head(path)
+    request = Net::HTTP::Head.new(uri_for(path))
+    client.request(request)
+  end
+
+  def options(path, headers = {})
+    request = Net::HTTP::Options.new(uri_for(path))
+    headers.each { |k, v| request[k] = v }
+    client.request(request)
+  end
+
+  def put(path, data="", headers = {})
+    request = Net::HTTP::Put.new(uri_for(path))
+    request.body = data
+    headers.each { |k, v| request[k] = v }
+    client.request(request)
+  end
+
+  def delete(path, headers = {})
+    request = Net::HTTP::Delete.new(uri_for(path))
+    headers.each { |k, v| request[k] = v }
+    client.request(request)
+  end
+
+  def patch(path, data="", headers = {})
+    request = Net::HTTP::Patch.new(uri_for(path))
+    request.body = data
+    client.request(request)
+  end
+
+  private
+
+  def client
+    opts = {
+      read_timeout: 1,
+      open_timeout: 1
+    }
+    if @uri.scheme == 'unix'
+      NetX::HTTPUnix.new(
+        @uri.to_s,
+        **opts)
+    else
+      Net::HTTP.start(
+        @uri.host,
+        @uri.port,
+        use_ssl: @uri.scheme == 'https',
+        **opts)
+    end
+  end
+
+  def uri_for(path)
+    if @uri.scheme == 'unix'
+      URI::HTTP.build(path: path, host: "localhost")
+    else
+      URI.join(@uri.to_s, path)
+    end
+  end
 end