itsi 0.1.20 → 0.2.3

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

@@ -1,5 +1,7 @@
-require 'date'
-require 'time'
+# frozen_string_literal: true
+
+require "date"
+require "time"
 
 module Itsi
   class Server
@@ -10,18 +12,19 @@ module Itsi
 
         def self.new(defaults = nil, &defaults_blk)
           defaults = TypedStruct.module_eval(&defaults_blk) if defaults_blk
-          unless defaults.is_a?(Hash)
-            return defaults
-          end
+          return defaults unless defaults.is_a?(Hash)
+
           defaults.transform_values! { _1.is_a?(Validation) ? _1.default(nil) : _1 }
           Struct.new(*defaults.keys, keyword_init: true) do
             define_method(:initialize) do |*input, validate: true, **raw_input|
-              raw_input.transform_keys!{|k| k.to_s.downcase.to_sym }
-              raw_input.merge!(input.pop) if input.last.is_a?(Hash)
+              raise "─ Invalid input to #{self}: #{input.last}" if input.last && !input.last.is_a?(Hash)
+
+              raw_input.transform_keys! { |k| k.to_s.downcase.to_sym }
+              raw_input.merge!(input.pop.transform_keys! { |k| k.to_s.downcase.to_sym }) if input.last.is_a?(Hash)
 
               excess_keys = raw_input.keys - defaults.keys
 
-              raise "Unsupported keys #{excess_keys}" if excess_keys.any?
+              raise "─ Unsupported keys #{excess_keys}" if excess_keys.any?
 
               initial_values = defaults.each_with_object({}) do |(k, default_config), inputs|
                 value = raw_input.key?(k) ? raw_input[k] : default_config[VALUE].dup
@@ -30,7 +33,7 @@ module Itsi
                 begin
                   inputs[k] = default_config[VALIDATE].validate!(value)
                 rescue StandardError => e
-                  raise ArgumentError, e.message
+                  raise ArgumentError, "─ #{k}: #{e.message}"
                 end
               end
 
@@ -97,11 +100,9 @@ module Itsi
             "#{@name}"
           end
 
-          def +(other)
+          def &(other)
             tail = self
-            while tail.next
-              tail = tail.next
-            end
+            tail = tail.next while tail.next
             tail.next = other
             self
           end
@@ -115,40 +116,51 @@ module Itsi
             @validations.each do |validation|
               case validation
               when Proc
-                unless validation.call(value)
-                  raise ArgumentError,
-                        "─  `#{@name}` validation failed. Invalid value: #{value.inspect}"
-                end
+                validation.call(value)
               when Array
                 unless !value || validation.include?(value)
                   raise ArgumentError,
-                        "─  `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
                 end
               when Range
                 unless !value || validation.include?(value)
                   raise ArgumentError,
-                        "─  `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
                 end
               when Regexp
                 unless !value || validation.match?(value)
                   raise ArgumentError,
-                        "─  `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
                 end
+              when Validation
+                validation.validate!(value)
               when Class
-
                 if value && !value.is_a?(validation)
                   begin
                     value = \
                       if validation.eql?(Time) then Time.parse(value.to_s)
                       elsif validation.eql?(::Date) then Date.parse(value.to_s)
                       elsif validation.eql?(Float) then Float(value)
-                      elsif validation.eql?(String) then value.to_s
-                      elsif validation.eql?(Symbol) then value.is_a?(Symbol) ? value : value.to_s.to_sym
-                      else validation.new(value)
+                      elsif validation.eql?(Integer) then Integer(value)
+                      elsif validation.eql?(Proc)
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
+                      elsif validation.eql?(String) || validation.eql?(Symbol)
+                        unless value.is_a?(String) || value.is_a?(Symbol)
+                          raise ArgumentError,
+                                "Invalid #{validation} value: #{value.inspect}"
+                        end
+
+                        if validation.eql?(String)
+                          value.to_s
+                        elsif validation.eql?(Symbol)
+                          value.to_s.to_sym
+                        end
+                      else
+                        validation.new(value)
                       end
                   rescue StandardError => e
                     raise ArgumentError,
-                          "─ `#{@name}` Validation Failed. Invalid #{validation.to_s.split("::").last} value: #{value.inspect}. Failure reason: \n └#{e.message}"
+                          "─ `#{@name}` Validation Failed. Invalid #{validation.to_s.split("::").last} value: #{value.inspect}. Failure reason: \n  └─ #{e.message}"
                   end
                 end
               end
@@ -164,23 +176,47 @@ module Itsi
         {
           Bool: Validation.new(:Bool, [[true, false]]),
           Required: Validation.new(:Required, ->(value) { !value.nil? }),
-          Or: ->(validation_a, validation_b){
-            Validation.new(:Or, ->(v){
-              validation_a.validate!(v) || validation_b.validate!(v)
+          Or: lambda { |*validations|
+            Validation.new(:Or, lambda { |v|
+              return true if v.nil?
+
+              errs = []
+              validations.each do |validation|
+                v = validation.validate!(v)
+                return v
+              rescue StandardError => e
+                errs << e.message
+              end
+              raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
             })
           },
-          Range: ->(input_range) {
+          Range: lambda { |input_range|
             Validation.new(:Range, [input_range])
           },
           Length: lambda { |input_length|
             Validation.new(:Length, ->(value) { input_length === value.length })
           },
+          Hash: lambda { |key_type, value_type|
+            Validation.new(:Hash, lambda { |hash|
+              return true if hash.nil?
+              raise StandardError.new("Expected hash got #{hash.class}") unless hash.is_a?(Hash)
+
+              hash.map do |k, v|
+                [
+                  key_type.validate!(k),
+                  value_type.validate!(v)
+                ]
+              end.to_h
+            })
+          },
           Type: ->(input_type) { Validation.new(:Type, input_type) },
-          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map{|v| v.kind_of?(Symbol) ? v.to_s : v}]) },
+          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map { |v| v.is_a?(Symbol) ? v.to_s : v }]) },
           Array: lambda { |*value_validations|
             Validation.new(:Array, [::Array, lambda { |value|
               return true unless value
 
+              raise StandardError.new("Expected Array got #{value.class}") unless value.is_a?(Array)
+
               value&.map! do |v|
                 value_validations.all? { v = _1.validate!(v) }
                 v
@@ -193,8 +229,8 @@ module Itsi
             define_singleton_method(name.to_s.downcase, &factory)
           else
             const_set(name, factory)
-            define_singleton_method(name, -> { factory })
-            define_singleton_method(name.to_s.downcase, -> { factory })
+            define_singleton_method(name, -> { factory.dup })
+            define_singleton_method(name.to_s.downcase, -> { factory.dup })
           end
         end
       end

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

@@ -41,16 +41,18 @@ module Itsi
           elsif args[:static]
             DSL.evaluate do
               location "/" do
-                allow_list allowed_patterns: ['127.0.0.1']
-                rate_limit key: 'address', store_config: 'in_memory', requests: 2, seconds: 5
-                etag type: 'strong', algorithm: 'md5', min_body_size: 1024 * 1024
-                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip brotli deflate], mime_types: %w[all], compress_streams: true
-                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " }, after: { level: "INFO", format: "[{request_id}] └─ {status} in {response_time}" }
+                rate_limit key: "address", store_config: "in_memory", requests: 2, seconds: 5
+                etag type: "strong", algorithm: "md5", min_body_size: 1024 * 1024
+                compress min_size: 1024 * 1024, level: "fastest", algorithms: %w[zstd gzip br deflate],
+                         mime_types: %w[all], compress_streams: true
+                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " },
+                             after: { level: "INFO",
+                                      format: "[{request_id}] └─ {status} in {response_time}" }
                 static_assets \
                   relative_path: true,
                   allowed_extensions: [],
-                  root_dir: '.',
-                  not_found_behavior: {error: 'not_found'},
+                  root_dir: ".",
+                  not_found_behavior: { error: "not_found" },
                   auto_index: true,
                   try_html_extension: true,
                   max_file_size_in_memory: 1024 * 1024, # 1MB
@@ -58,7 +60,7 @@ module Itsi
                   file_check_interval: 1,
                   serve_hidden_files: false,
                   headers: {
-                    'X-Content-Type-Options' => 'nosniff'
+                    "X-Content-Type-Options" => "nosniff"
                   }
               end
             end
@@ -70,7 +72,7 @@ module Itsi
               rackup_file args.fetch(:rackup_file, "./config.ru")
             end
           else
-            DSL.evaluate{}
+            DSL.evaluate {}
           end
 
         itsifile_config.transform_keys!(&:to_sym)
@@ -82,78 +84,84 @@ module Itsi
         case preload
         # If we preload everything, then we'll load middleware and default rack app ahead of time
         when true
-          preloaded_middleware = middleware_loader.call
-          middleware_loader = -> { preloaded_middleware }
+          begin
+            Itsi.log_debug("Preloading middleware and default rack app")
+            preloaded_middleware = middleware_loader.call
+            middleware_loader = -> { preloaded_middleware }
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            errors << [e, e.backtrace[0]]
+          end
         # If we're just preloading a specific gem group, we'll do that here too
         when Symbol
+          Itsi.log_debug("Preloading gem group #{preload}")
           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),
-            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),
+        if itsifile_config[:daemonize] && !@daemonized
+          @daemonized = true
+          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)
+          Server.write_pid
+        end
 
-          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
-        ]
+        srv_config = {
+          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: if args[:hooks] && itsifile_config[:hooks]
+                   args[:hooks].merge(itsifile_config[:hooks])
+                 else
+                   itsifile_config.fetch(
+                     :hooks, args[:hooks]
+                   )
+                 end,
+          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)
+
+        [srv_config, errors_to_error_lines(errors)]
+      rescue StandardError
+        Itsi.log_error e.message
+        puts e.backtrace
       end
 
       def self.test!(cli_params)
-        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        config, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        unless errors.any?
+          begin
+            config["middleware_loader"][]
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            errors = [e]
+          end
+        end
+
         if errors.any?
           Itsi.log_error("Config file is invalid")
           puts errors
@@ -162,6 +170,42 @@ module Itsi
         end
       end
 
+      def self.errors_to_error_lines(errors)
+        return unless errors
+
+        errors.flat_map do |(error, message)|
+          location = message[/(.*?):in/, 1]
+          file, lineno = location.split(":")
+          lineno = lineno.to_i
+          err_message = error.is_a?(NoMethodError) ? error.detailed_message : error.message
+          file_lines = IO.readlines(file)
+          info_lines = \
+            if error.is_a?(SyntaxError)
+              []
+            else
+
+              ([lineno - 2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                if currline == lineno - 1
+                  line = file_lines[currline][0...-1]
+                  padding = line[/^\s+/]&.length || 0
+
+                  [
+                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
+                    "     | #{" " * padding}\e[33m^^^\e[0m "
+                  ]
+                else
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
+                end
+              end.flatten
+            end
+          [
+            err_message,
+            "   --> #{File.expand_path(file)}:#{lineno}",
+            *info_lines
+          ]
+        end
+      end
+
       # Reloads the entire process
       # using exec, passing in any active file descriptors
       # and previous invocation arguments
@@ -181,7 +225,7 @@ module Itsi
           elsif File.exist?("config/#{ITSI_DEFAULT_CONFIG_FILE}")
             "config/#{ITSI_DEFAULT_CONFIG_FILE}"
           end
-        # Options simply pass through unless we've specified a config file
+        # Options pass through unless we've specified a config file
         return unless File.exist?(config_file_path.to_s)
 
         config_file_path
@@ -204,56 +248,56 @@ module Itsi
 
         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
+        default_config << \
+          if File.exist?("./config.ru")
+            <<~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
+            <<~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(default_config)
         end
-
       end
     end
   end

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

@@ -11,7 +11,7 @@ DEFAULT_APP = lambda {
         [
           { "Content-Type" => "application/json" },
           [{ "message" => "You're running on Itsi!", "rack_env" => env,
-              "version" => Itsi::Server::VERSION }.to_json]
+             "version" => Itsi::Server::VERSION }.to_json]
         ]
       else
         [

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

@@ -73,7 +73,7 @@ worker_memory_limit 1024 * 1024 * 1024
 
 # You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
 # write metrics to disk etc. etc.)
-after_memory_threshold_reached do |pid|
+after_memory_limit_reached do |pid|
   puts "Worker #{pid} has reached its memory threshold and will restart"
 end
 
@@ -102,6 +102,6 @@ oob_gc_responses_threshold 512
 log_level :info
 
 # Log Format
-# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# Set this to be either :plain or :json. If you leave it blank Itsi will try
 # and auto-detect the format based on the TTY environment.
-log_format :auto
+log_format :plain

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

@@ -7,11 +7,11 @@ module Itsi
     attr_accessor :rpc_desc
 
     def input_stream?
-      @input_stream ||= @rpc_desc&.input&.is_a?(GRPC::RpcDesc::Stream) || false
+      @input_stream ||= @rpc_desc&.input.is_a?(GRPC::RpcDesc::Stream) || false
     end
 
     def output_stream?
-      @output_stream ||= @rpc_desc&.output&.is_a?(GRPC::RpcDesc::Stream) || false
+      @output_stream ||= @rpc_desc&.output.is_a?(GRPC::RpcDesc::Stream) || false
     end
 
     def input_type
@@ -64,7 +64,7 @@ module Itsi
       return nil if first_char.nil?
 
       # Step 2: Process objects until we hit the end of the JSON stream or array.
-      loop do
+      loop do # rubocop:disable Lint/UnreachableLoop,Metrics/BlockLength
         # Skip any whitespace or commas preceding an object.
         char = nil
         loop do
@@ -74,7 +74,6 @@ module Itsi
 
           break
         end
-
         # The next non-whitespace, non-comma character should be the start of an object.
         return nil unless char == "{"
 
@@ -120,7 +119,7 @@ module Itsi
     def remote_read
       if content_type == "application/json"
         if input_stream?
-          if next_item = parse_from_json_stream(reader)
+          if (next_item = parse_from_json_stream(reader))
             input_type.decode_json(next_item)
           end
         else

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

@@ -23,13 +23,13 @@ module Itsi
       def initialize(service)
         @service = service
         @service_class = service.class
-        @service_class.rpc_descs.transform_keys! do |k|
+        @rpc_descs = @service_class.rpc_descs.transform_keys do |k|
           k.to_s.gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase.to_sym
         end
       end
 
       def handle_request(active_call)
-        unless (active_call.rpc_desc = service_class.rpc_descs[active_call.method_name])
+        unless (active_call.rpc_desc = @rpc_descs[active_call.method_name])
           active_call.stream.write("\n")
           active_call.send_status(13, "Method not found")
           active_call.close
@@ -85,15 +85,21 @@ module Itsi
 
       def handle_server_streaming(active_call)
         message = active_call.remote_read
-        service.send(active_call.method_name, message, active_call) do |response|
+        result = service.send(active_call.method_name, message, active_call) do |response|
           active_call.remote_send(response)
         end
+        return unless result.is_a?(Enumerator)
+
+        result.each { |response| active_call.remote_send(response) }
       end
 
       def handle_bidi_streaming(active_call)
-        service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
+        result = service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
           active_call.remote_send(response)
         end
+        return unless result.is_a?(Enumerator)
+
+        result.each { |response| active_call.remote_send(response) }
       end
     end
   end

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

@@ -6,12 +6,11 @@ module Rack
       def self.run(app, options = {})
         host = options.fetch(:host, "127.0.0.1")
         port = options.fetch(:Port, 3001)
-        Itsi::Server.start(
+        ::Itsi::Server.start(
           {
             app: app,
             binds: ["http://#{host}:#{port}"]
-          },
-          Itsi::Server::Config.config_file_path
+          }
         )
       end
     end