itsi 0.1.19 → 0.1.20

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

@@ -3,7 +3,9 @@
 module Itsi
   class Server
     module Config
+      require_relative "config/typed_struct"
       require_relative "config/dsl"
+      require_relative "config/known_paths"
       require_relative "default_app/default_app"
 
       ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
@@ -33,7 +35,7 @@ module Itsi
       # 3. Default values.
       def self.build_config(args, config_file_path, builder_proc = nil)
         args.transform_keys!(&:to_sym)
-        itsifile_config = \
+        itsifile_config, errors = \
           if builder_proc
             DSL.evaluate(&builder_proc)
           elsif args[:static]
@@ -87,33 +89,77 @@ module Itsi
           Bundler.require(preload)
         end
 
-        {
-          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
-          worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
-          silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
-          shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
-          hooks: itsifile_config.fetch(:hooks, nil),
-          preload: !!preload,
-          request_timeout: itsifile_config.fetch(:request_timeout, nil),
-          notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
-          threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
-          scheduler_threads: args.fetch(:scheduler_threads) { itsifile_config.fetch(:scheduler_threads, nil) },
-          streamable_body: args.fetch(:streamable_body) { itsifile_config.fetch(:streamable_body, false) },
-          multithreaded_reactor: args.fetch(:multithreaded_reactor) do
-            itsifile_config.fetch(:multithreaded_reactor, nil)
-          end,
-          pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, true) },
-          scheduler_class: args.fetch(:scheduler_class) { itsifile_config.fetch(:scheduler_class, nil) },
-          oob_gc_responses_threshold: args.fetch(:oob_gc_responses_threshold) do
-            itsifile_config.fetch(:oob_gc_responses_threshold, nil)
-          end,
-          log_level: args.fetch(:log_level) { itsifile_config.fetch(:log_level, nil) },
-          log_format: args.fetch(:log_format) { itsifile_config.fetch(:log_format, nil) },
-          log_target: args.fetch(:log_target) { itsifile_config.fetch(:log_target, nil) },
-          binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
-          middleware_loader: middleware_loader,
-          listeners: args.fetch(:listeners) { nil }
-        }.transform_keys(&:to_s)
+        [
+          {
+            workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
+            worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
+            silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
+            shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
+            hooks: itsifile_config.fetch(:hooks, nil),
+            preload: !!preload,
+            request_timeout: itsifile_config.fetch(:request_timeout, nil),
+            header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
+            notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
+            threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
+            scheduler_threads: args.fetch(:scheduler_threads) { itsifile_config.fetch(:scheduler_threads, nil) },
+            streamable_body: args.fetch(:streamable_body) { itsifile_config.fetch(:streamable_body, false) },
+            multithreaded_reactor: args.fetch(:multithreaded_reactor) do
+              itsifile_config.fetch(:multithreaded_reactor, nil)
+            end,
+            pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, true) },
+            scheduler_class: args.fetch(:scheduler_class) { itsifile_config.fetch(:scheduler_class, nil) },
+            oob_gc_responses_threshold: args.fetch(:oob_gc_responses_threshold) do
+              itsifile_config.fetch(:oob_gc_responses_threshold, nil)
+            end,
+            log_level: args.fetch(:log_level) { itsifile_config.fetch(:log_level, nil) },
+            log_format: args.fetch(:log_format) { itsifile_config.fetch(:log_format, nil) },
+            log_target: args.fetch(:log_target) { itsifile_config.fetch(:log_target, nil) },
+            log_target_filters: args.fetch(:log_target_filters) { itsifile_config.fetch(:log_target_filters, nil) },
+            binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
+            middleware_loader: middleware_loader,
+            listeners: args.fetch(:listeners) { nil },
+            reuse_address: itsifile_config.fetch(:reuse_address, true),
+            reuse_port: itsifile_config.fetch(:reuse_port, true),
+            listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
+            nodelay: itsifile_config.fetch(:nodelay, true),
+            recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
+          }.transform_keys(&:to_s),
+
+          errors.flat_map do |(error, message)|
+            location =  message[/(.*?)\:in/,1]
+            file, lineno = location.split(":")
+            lineno = lineno.to_i
+            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
+            file_lines = IO.readlines(file)
+            info_lines = if error.kind_of?(SyntaxError)
+              []
+            else
+              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                [
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline].strip}",
+                  if currline == lineno-1
+                    "     | ^^^ "
+                  end
+                ].compact
+              end.flatten
+            end
+            [
+              err_message,
+              "   --> #{File.expand_path(file)}:#{lineno}",
+              *info_lines
+            ]
+          end
+        ]
+      end
+
+      def self.test!(cli_params)
+        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        if errors.any?
+          Itsi.log_error("Config file is invalid")
+          puts errors
+        else
+          Itsi.log_info("Config file is valid")
+        end
       end
 
       # Reloads the entire process
@@ -156,10 +202,58 @@ module Itsi
           return
         end
 
-        puts "Writing default configuration..."
+        default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
+
+        if File.exist?("./config.ru")
+          default_config << <<~RUBY
+          # You can mount several Ruby apps as either
+          # 1. rackup files
+          # 2. inline rack apps
+          # 3. inline Ruby endpoints
+          #
+          # 1. rackup_file
+          rackup_file "./config.ru"
+          #
+          # 2. inline rack app
+          # require 'rack'
+          # run(Rack::Builder.app do
+          #   use Rack::CommonLogger
+          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+          # end)
+          #
+          # 3. Endpoints
+          # endpoint "/" do |req|
+          #   req.ok "Hello from Itsi"
+          # end
+          RUBY
+        else
+          default_config << <<~RUBY
+            # You can mount several Ruby apps as either
+            # 1. rackup files
+            # 2. inline rack apps
+            # 3. inline Ruby endpoints
+            #
+            # 1. rackup_file
+            # Use `rackup_file` to specify the Rack app file name.
+            #
+            # 2. inline rack app
+            # require 'rack'
+            # run(Rack::Builder.app do
+            #   use Rack::CommonLogger
+            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+            # end)
+            #
+            # 3. Endpoint
+            endpoint "/" do |req|
+              req.ok "Hello from Itsi"
+            end
+          RUBY
+        end
+
         File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
-          file.write(IO.read("#{__dir__}/default_config/Itsi.rb"))
+          file.write(default_config)
         end
+
       end
     end
   end

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

@@ -10,13 +10,17 @@ module Itsi
     INTERCEPTED_SIGNALS = ["INT"].freeze
 
     def trap(signal, *args, &block)
-      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
+      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && server_running?
         return super(signal, *args, &block)
       end
 
       Itsi::Server.reset_signal_handlers
       nil
     end
+
+    def server_running?
+      Itsi::Server.respond_to?(:running) && Itsi::Server.running?
+    end
   end
 end
 

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

@@ -10,7 +10,7 @@ module Itsi
 
           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?
             proc_line -= 1
             first_line = source_lines[proc_line]

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

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

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

@@ -38,14 +38,22 @@ module Itsi
         server = new(cli_params, itsi_file, blk)
         previous_handler = Signal.trap(:INT, :DEFAULT)
         run = lambda do
-          write_pid
           @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
+
           server.start
-          @running = false
+          @running = nil
           Signal.trap(:INT, previous_handler)
           server
         end
         background ? Thread.new(&run) : run[]
+      rescue
       end
 
       def static(cli_params)
@@ -55,6 +63,15 @@ 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
@@ -66,19 +83,23 @@ module Itsi
         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
@@ -134,7 +155,7 @@ module Itsi
 
       def status
         return unless pid = get_pid
-
+        Itsi.log_info("Itsi running on #{pid}")
         Process.kill(:USR2, pid)
       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,60 @@ 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|
+          completion_item = Interface::CompletionItem.new(
+            label: middleware.middleware_name,
+            kind: Constant::CompletionItemKind::METHOD,
+            label_details: Interface::CompletionItemLabelDetails.new(
+              detail: middleware.detail,
+              description: middleware.documentation
+            ),
+            documentation: Interface::MarkupContent.new(
+              kind: Constant::MarkupKind::MARKDOWN,
+              value: middleware.documentation
+            ),
+            insert_text: middleware.insert_text,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              delegateCompletion: true
+            }
+          )
+          @response_builder << completion_item
+        end
       end
+
+
     end
   end
 end

data/gems/server/test/helpers/test_helper.rb

@@ -4,6 +4,10 @@ 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
 
@@ -14,18 +18,73 @@ def free_bind(protocol)
   "#{protocol}://0.0.0.0:#{port}"
 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, &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
+
+  Itsi::Server.start_in_background_thread(cli_params, &itsi_rb)
+  uri = URI(bind)
+  RequestContext.new(uri, self).instance_exec(uri, &blk)
+rescue StandardError => e
+  puts e
+  puts e.message
+  puts e.backtrace.join("\n")
 ensure
   Itsi::Server.stop_background_thread
 end
+
+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)
+    Net::HTTP.post(@uri+path, data)
+  end
+
+  def get(path)
+    Net::HTTP.get(@uri+path)
+  end
+
+  def get_resp(path)
+    Net::HTTP.get_response(@uri+path)
+  end
+
+  def head(path)
+    Net::HTTP.start(@uri.host, @uri.port) {|http|
+      http.head(path)
+    }
+  end
+
+  def options(path)
+    Net::HTTP.start(@uri.host, @uri.port) {|http|
+      http.options(path)
+    }
+  end
+
+  def put(path, data)
+    Net::HTTP.put(@uri+path, data)
+  end
+
+  def delete(path)
+    Net::HTTP.delete(@uri+path)
+  end
+
+  def patch(path, data)
+    Net::HTTP.patch(@uri+path, data)
+  end
+end

data/gems/server/test/middleware/test_log_requests.rb

@@ -0,0 +1,17 @@
+require_relative "../helpers/test_helper"
+
+class TestLogRequests < Minitest::Test
+
+  def test_it_supports_logging_before_requests
+
+  end
+
+  def test_it_supports_logging_after_requests
+
+  end
+
+  def test_it_supports_configuring_log_level
+
+  end
+
+end

data/gems/server/test/options/test_threads.rb

@@ -0,0 +1,15 @@
+require_relative "../helpers/test_helper"
+
+class TestThreads < Minitest::Test
+
+  def test_it_can_run_multiple_threads
+    thread_count = 4
+    server(
+      itsi_rb: lambda do
+        threads thread_count
+        get("/foo"){|r| r.ok Thread.current.object_id}
+      end) do
+        assert_equal thread_count, 30.times.map { |i| get("/foo") }.uniq.size
+    end
+  end
+end

data/gems/server/test/options/test_workers.rb

@@ -0,0 +1,18 @@
+require_relative "../helpers/test_helper"
+
+class TestWorkers < Minitest::Test
+
+  def test_it_can_run_multiple_workers
+    worker_count = 4
+
+    server(
+      itsi_rb: lambda do
+
+        workers worker_count
+        get("/foo"){|r| r.ok Process.pid}
+
+      end) do
+        assert_equal worker_count, 30.times.map { |i| get("/foo") }.uniq.size
+    end
+  end
+end