itsi 0.1.7 → 0.1.9

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

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
+require "stringio"
+require "socket"
+
 module Itsi
   class Request
-    require "stringio"
-    require "socket"
-
     attr_accessor :hijacked
 
-    def to_env
+    def to_rack_env
       path = self.path
       host = self.host
       version = self.version
-      body = self.body
       {
         "SERVER_SOFTWARE" => "Itsi",
         "SCRIPT_NAME" => script_name,
@@ -25,31 +24,40 @@ module Itsi
         "HTTP_HOST" => host,
         "SERVER_PROTOCOL" => version,
         "HTTP_VERSION" => version,
+        "itsi.request" => self,
+        "itsi.response" => response,
         "rack.version" => [version],
         "rack.url_scheme" => scheme,
-        "rack.input" => \
-          case body
-          when Array then File.open(body.first, "rb")
-          when String then StringIO.new(body)
-          else body
-          end,
+        "rack.input" => build_input_io,
         "rack.errors" => $stderr,
         "rack.multithread" => true,
         "rack.multiprocess" => true,
         "rack.run_once" => false,
         "rack.hijack?" => true,
         "rack.multipart.buffer_size" => 16_384,
-        "rack.hijack" => lambda do
-          self.hijacked = true
-          UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
-            response.hijack(server_sock.fileno)
-            server_sock.sync = true
-            app_sock.sync = true
-            app_sock.instance_variable_set("@server_sock", server_sock)
-            app_sock
-          end
-        end
+        "rack.hijack" => build_hijack_proc
       }.tap { |r| headers.each { |(k, v)| r[k] = v } }
     end
+
+    def build_hijack_proc
+      lambda do
+        self.hijacked = true
+        UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+          response.hijack(server_sock.fileno)
+          server_sock.sync = true
+          app_sock.sync = true
+          app_sock.instance_variable_set("@server_sock", server_sock)
+          app_sock
+        end
+      end
+    end
+
+    def build_input_io
+      case body
+      when Array then File.open(body.first, "rb")
+      when String then StringIO.new(body)
+      else body
+      end
+    end
   end
 end

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

@@ -3,13 +3,12 @@ return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
 module Rack
   module Handler
     module Itsi
-
       def self.run(app, options = {})
         ::Itsi::Server.new(
-          app: ->{ app },
-          binds: ["#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
+          app: -> { app },
+          binds: ["http://#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
           workers: options.fetch(:workers, 1),
-          threads: options.fetch(:threads, 1),
+          threads: options.fetch(:threads, 1)
         ).start
       end
     end

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

@@ -0,0 +1,79 @@
+module Itsi
+  class Server
+    module RackInterface
+      # Interface to Rack applications.
+      # Here we build the env, and invoke the Rack app's call method.
+      # We then turn the Rack response into something Itsi server understands.
+      def call(app, request)
+        respond request, app.call(request.to_rack_env)
+      end
+
+      # Itsi responses are asynchronous and can be streamed.
+      # Response chunks are sent using response.send_frame
+      # and the response is finished using response.close_write.
+      # If only a single chunk is written, you can use the #send_and_close method.
+      def respond(request, (status, headers, body))
+        response = request.response
+
+        # Don't try and respond if we've been hijacked.
+        # The hijacker is now responsible for this.
+        return if request.hijacked
+
+        # 1. Set Status
+        response.status = status
+
+        # 2. Set Headers
+        body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
+        headers.each do |key, value|
+          next response.add_header(key, value) unless value.is_a?(Array)
+
+          value.each do |v|
+            response.add_header(key, v)
+          end
+        end
+
+        # 3. Set Body
+        # As soon as we start setting the response
+        # the server will begin to stream it to the client.
+
+        # If we're partially hijacked or returned a streaming body,
+        # stream this response.
+
+        if body_streamer
+          body_streamer.call(StreamIO.new(response))
+
+        # If we're enumerable with more than one chunk
+        # also stream, otherwise write in a single chunk
+        elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
+          unless body.respond_to?(:each)
+            body = body.to_ary
+            raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
+          end
+          # We offset this iteration intentionally,
+          # to optimize for the case where there's only one chunk.
+          buffer = nil
+          body.each do |part|
+            response.send_frame(buffer.to_s) if buffer
+            buffer = part
+          end
+
+          begin
+            response.send_and_close(buffer.to_s)
+          rescue StandardError
+            binding.b
+          end
+        else
+          response.send_and_close(body.to_s)
+        end
+      ensure
+        response.close_write
+        body.close if body.respond_to?(:close)
+      end
+
+      # A streaming body is one that responds to #call and not #each.
+      def streaming_body?(body)
+        body.respond_to?(:call) && !body.respond_to?(:each)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Itsi
+  class Server
+    module SchedulerInterface
+      # Simple wrapper to instantiate a scheduler, start it,
+      # and immediate have it invoke a scheduler proc
+      def start_scheduler_loop(scheduler_class, scheduler_task)
+        scheduler = scheduler_class.new
+        Fiber.set_scheduler(scheduler)
+        [scheduler, Fiber.schedule(&scheduler_task)]
+      end
+
+      # When running in scheduler mode,
+      # each request is wrapped in a Fiber.
+      def schedule(app, request)
+        Fiber.schedule do
+          call(app, request)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 if defined?(ActiveSupport::IsolatedExecutionState) && !ENV["ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL"]
   Itsi.log_info \
     "ActiveSupport Isolated Execution state detected. Automatically switching to :fiber mode. "\
-    "Use ENV['ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL'] to disable this behavior"
+    "Set ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL to disable this behavior"
   ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
 end

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

@@ -0,0 +1,24 @@
+module Itsi
+  module SignalTrap
+
+    DEFAULT_SIGNALS = ["DEFAULT", "", nil].freeze
+    INTERCEPTED_SIGNALS = ["INT"].freeze
+
+    def trap(signal, *args, &block)
+      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
+        return super(signal, *args, &block)
+      end
+
+      Itsi::Server.reset_signal_handlers
+      nil
+    end
+  end
+end
+
+[Kernel, Signal].each do |receiver|
+  receiver.singleton_class.prepend(Itsi::SignalTrap)
+end
+
+[Object].each do |receiver|
+  receiver.include(Itsi::SignalTrap)
+end

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.7"
+    VERSION = "0.1.9"
   end
 end

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

@@ -2,99 +2,85 @@
 
 require_relative "server/version"
 require_relative "server/itsi_server"
-require_relative "signals"
+require_relative "server/rack_interface"
+require_relative "server/signal_trap"
+require_relative "server/scheduler_interface"
+require_relative "server/rack/handler/itsi"
 require_relative "request"
 require_relative "stream_io"
-require_relative "server/rack/handler/itsi"
+
+# When you Run Itsi without a Rack app,
+# we start a tiny
+DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
+DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
+DEFAULT_APP = lambda {
+  require "json"
+  lambda do |env|
+    headers, body = \
+      if env["itsi.response"].json?
+        [
+          { "Content-Type" => "application/json" },
+          [{ "message" => "You're running on Itsi!", "rack_env" => env,
+             "version" => Itsi::Server::VERSION }.to_json]
+        ]
+      else
+        [
+          { "Content-Type" => "text/html" },
+          [
+            format(
+              DEFAULT_INDEX,
+              REQUEST_METHOD: env["REQUEST_METHOD"],
+              PATH_INFO: env["PATH_INFO"],
+              SERVER_NAME: env["SERVER_NAME"],
+              SERVER_PORT: env["SERVER_PORT"],
+              REMOTE_ADDR: env["REMOTE_ADDR"],
+              HTTP_USER_AGENT: env["HTTP_USER_AGENT"]
+            )
+          ]
+        ]
+      end
+    [200, headers, body]
+  end
+}
 
 module Itsi
   class Server
+    extend RackInterface
+    extend SchedulerInterface
 
-    def self.running?
-      @running ||= false
-    end
-
-    def self.start(app:, **opts)
-      server = new(app: ->{app}, **opts)
-      @running = true
-      Signal.trap('INT', 'DEFAULT')
-      server.start
-    ensure
-      @running = false
-    end
-
-    def self.call(app, request)
-      respond request, app.call(request.to_env)
-    end
-
-    def self.streaming_body?(body)
-      body.respond_to?(:call) && !body.respond_to?(:each)
-    end
-
-    def self.respond(request, (status, headers, body))
-      response = request.response
-
-      # Don't try and respond if we've been hijacked.
-      # The hijacker is now responsible for this.
-      return if request.hijacked
-
-      # 1. Set Status
-      response.status = status
-
-      # 2. Set Headers
-      headers.each do |key, value|
-        next response.add_header(key, value) unless value.is_a?(Array)
-
-        value.each do |v|
-          response.add_header(key, v)
-        end
+    class << self
+      def running?
+        !!@running
       end
 
-      # 3. Set Body
-      # As soon as we start setting the response
-      # the server will begin to stream it to the client.
-
-      # If we're partially hijacked or returned a streaming body,
-      # stream this response.
-
-      if (body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack"))
-        body_streamer.call(StreamIO.new(response))
-
-      # If we're enumerable with more than one chunk
-      # also stream, otherwise write in a single chunk
-      elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
-        unless body.respond_to?(:each)
-          body = body.to_ary
-          raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
-        end
-        # We offset this iteration intentionally,
-        # to optimize for the case where there's only one chunk.
-        buffer = nil
-        body.each do |part|
-          response.send_frame(buffer.to_s) if buffer
-          buffer = part
-        end
-
-        response.send_and_close(buffer.to_s)
-      else
-        response.send_and_close(body.to_s)
+      def build(
+        app: DEFAULT_APP[],
+        binds: DEFAULT_BINDS,
+        **opts
+      )
+        new(app: -> { app }, binds: binds, **opts)
       end
-    ensure
-      response.close_write
-      body.close if body.respond_to?(:close)
-    end
 
-    def self.start_scheduler_loop(scheduler_class, scheduler_task)
-      scheduler = scheduler_class.new
-      Fiber.set_scheduler(scheduler)
-      [scheduler, Fiber.schedule(&scheduler_task)]
-    end
+      def start_in_background_thread(silence: true, **opts)
+        start(background: true, silence: silence, **opts)
+      end
 
-    # If scheduler is enabled
-    # Each request is wrapped in a Fiber.
-    def self.schedule(app, request)
-      Fiber.schedule do
-        call(app, request)
+      def start(background: false, **opts)
+        build(**opts).tap do |server|
+          previous_handler = Signal.trap("INT", "DEFAULT")
+          @running = true
+          if background
+            Thread.new do
+              server.start
+              @running = false
+              Signal.trap("INT", previous_handler)
+            end
+          else
+            server.start
+            @running = false
+            Signal.trap("INT", previous_handler)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "minitest/reporters"
+require "itsi/server"
+require "itsi/scheduler"
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+def free_bind
+  server = TCPServer.new("0.0.0.0", 0)
+  port = server.addr[1]
+  server.close
+  "http://0.0.0.0:#{port}"
+end
+
+def run_app(app, **opts)
+  bind = free_bind
+  server = Itsi::Server.start_in_background_thread(
+    app: app,
+    binds: [bind],
+    **opts
+  )
+
+  sleep 0.1
+  yield URI(bind), server
+ensure
+  server&.stop
+end