itsi 0.1.8 → 0.1.11

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

@@ -0,0 +1,75 @@
+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
+
+          response.send_and_close(buffer.to_s)
+        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/signal_trap.rb

@@ -0,0 +1,23 @@
+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.8"
+    VERSION = "0.1.11"
   end
 end

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

@@ -2,119 +2,89 @@
 
 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 "server/config"
 require_relative "request"
 require_relative "stream_io"
-require_relative "server/rack/handler/itsi"
-require 'erb'
 
-DEFAULT_INDEX = IO.read(__dir__ + '/index.html.erb')
+# When you Run Itsi without a Rack app,
+# we start a tiny little echo server, just so you can see it in action.
+DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
+DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
+DEFAULT_APP = lambda {
+  require "json"
+  require "itsi/scheduler"
+  Itsi.log_warn "No config.ru or Itsi.rb app detected. Running default app."
+  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: ->(env){
-        [env['CONTENT_TYPE'], env['HTTP_ACCEPT']].include?('application/json') ?
-          [200, {"Content-Type" => "application/json"}, ["{\"message\": \"You're running on Itsi!\"}"]] :
-          [200, {"Content-Type" => "text/html"}, [
-            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']
-            }
-          ]]
-      },
-      binds: ['http://0.0.0.0:3000'],
-      **opts
-    )
-      server = new(app: ->{app}, binds: binds, **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[],
+        loader: nil,
+        binds: DEFAULT_BINDS,
+        **opts
+      )
+        new(app: loader || -> { 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, silence: 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,30 @@
+# frozen_string_literal: true
+
+require "minitest/reporters"
+
+ENV['ITSI_LOG'] = 'off'
+
+require "itsi/server"
+require "itsi/scheduler"
+
+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}"
+end
+
+def run_app(app, protocol: "http", bind: free_bind(protocol), **opts)
+  server = Itsi::Server.start_in_background_thread(
+    app: app,
+    binds: [bind],
+    **opts
+  )
+
+  sleep 0.005
+  yield URI(bind), server
+ensure
+  server&.stop
+end

data/gems/server/test/test_itsi_server.rb

@@ -1,9 +1,300 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
+require "socket"
+require "net/http"
+require "minitest/autorun"
 
 class TestItsiServer < Minitest::Test
   def test_that_it_has_a_version_number
     refute_nil ::Itsi::Server::VERSION
   end
+
+  def test_hello_world
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    end) do |uri|
+      assert_equal "Hello, World!", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_post
+    run_app(lambda do |env|
+      assert_equal env["REQUEST_METHOD"], "POST"
+      assert_equal "data", env["rack.input"].read
+      [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    end) do |uri|
+      assert_equal "Hello, World!", Net::HTTP.post(uri, "data").body
+    end
+  end
+
+  def test_full_hijack
+    run_app(lambda do |env|
+      io = env["rack.hijack"].call
+      io.write("HTTP/1.1 200 Ok\r\n")
+      io.write("Content-Type: text/plain\r\n")
+      io.write("Transfer-Encoding: chunked\r\n")
+      io.write("\r\n")
+      io.write("7\r\n")
+      io.write("Hello, \r\n")
+      io.write("6\r\n")
+      io.write("World!\r\n")
+      io.write("0\r\n\r\n")
+      io.close
+    end) do |uri|
+      assert_equal "Hello, World!", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_streaming_body
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, lambda { |stream|
+        stream.write("Hello")
+        stream.write(", World!")
+        stream.close
+      }]
+    end) do |uri|
+      assert_equal "Hello, World!", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_partial_hijack
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain", "rack.hijack" => lambda { |stream|
+        stream.write("Hello")
+        stream.write(", World!")
+        stream.close
+      } }, []]
+    end) do |uri|
+      assert_equal "Hello, World!", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_enumerable_body
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "application/json" },
+       %W[one\n two\n three\n]]
+    end) do |uri|
+      assert_equal "one\ntwo\nthree\n", Net::HTTP.get(uri)
+    end
+  end
+
+    require 'debug'
+  def test_scheduler_non_blocking
+    run_app(
+      lambda do |env|
+        sleep 0.25
+        [200, { "Content-Type" => "text/plain" }, "Response: #{env["PATH_INFO"][1..-1]}"]
+      end,
+      scheduler_class: "Itsi::Scheduler"
+    ) do |uri|
+      start_time = Time.now
+      20.times.map do
+        Thread.new do
+          payload = SecureRandom.hex(16)
+          local_uri = uri.dup
+          local_uri.path = "/#{payload}"
+          response = Net::HTTP.start(local_uri.hostname, local_uri.port) do |http|
+            http.request(Net::HTTP::Get.new(local_uri))
+          end
+          assert_equal "Response: #{payload}", response.body
+        end
+      end.each(&:join)
+      assert_in_delta 0.25, Time.now - start_time, 0.5
+    end
+  end
+
+  def test_query_params
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, [env["QUERY_STRING"]]]
+    end) do |uri|
+      uri.query = "foo=bar&baz=qux"
+      assert_equal "foo=bar&baz=qux", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_put_request
+    run_app(lambda do |env|
+      body = env["rack.input"].read
+      [200, { "Content-Type" => "text/plain" }, [body]]
+    end) do |uri|
+      uri_obj = URI(uri)
+      req = Net::HTTP::Put.new(uri_obj)
+      req.body = "put data"
+      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      assert_equal "put data", response.body
+    end
+  end
+
+  def test_custom_headers
+    run_app(lambda do |env|
+      header = env["HTTP_X_CUSTOM"] || ""
+      [200, { "Content-Type" => "text/plain" }, [header]]
+    end) do |uri|
+      uri_obj = URI(uri)
+      req = Net::HTTP::Get.new(uri_obj)
+      req["X-Custom"] = "custom-value"
+      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      assert_equal "custom-value", response.body
+    end
+  end
+
+  def test_error_response
+    response = nil
+    capture_subprocess_io do
+      run_app(lambda do |env|
+        raise "Intentional error for testing"
+      end) do |uri|
+        response = Net::HTTP.get_response(uri)
+      end
+    end
+    assert_equal "500", response.code
+  end
+
+  def test_redirect
+    run_app(lambda do |env|
+      [302, { "Location" => "http://example.com" }, []]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "302", response.code
+      assert_equal "http://example.com", response["location"]
+    end
+  end
+
+  def test_not_found
+    run_app(lambda do |env|
+      if env["PATH_INFO"] == "/"
+        [200, { "Content-Type" => "text/plain" }, ["Home"]]
+      else
+        [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
+      end
+    end) do |uri|
+      uri.path = "/nonexistent"
+      response = Net::HTTP.get_response(uri)
+      assert_equal "404", response.code
+      assert_equal "Not Found", response.body
+    end
+  end
+
+  def test_head_request
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain", "Content-Length" => "13" }, ["Hello, World!"]]
+    end) do |uri|
+      uri_obj = URI(uri)
+      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) do |http|
+        http.head("/")
+      end
+      assert_equal "200", response.code
+      assert_empty response.body.to_s
+      assert_equal "13", response["content-length"]
+    end
+  end
+
+  def test_options_request
+    run_app(lambda do |env|
+      [200, { "Allow" => "GET,POST,OPTIONS", "Content-Type" => "text/plain" }, ["Options Response"]]
+    end) do |uri|
+      uri_obj = URI(uri)
+      req = Net::HTTP::Options.new(uri_obj)
+      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      assert_equal "200", response.code
+      assert_equal "GET,POST,OPTIONS", response["allow"]
+      assert_equal "Options Response", response.body
+    end
+  end
+
+  def test_cookie_handling
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain", "Set-Cookie" => "session=abc123; Path=/" }, ["Cookie Test"]]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "200", response.code
+      assert_match(/session=abc123/, response["set-cookie"])
+      assert_equal "Cookie Test", response.body
+    end
+  end
+
+  def test_multiple_headers
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain", "X-Example" => "one, two, three" }, ["Multiple Headers"]]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "200", response.code
+      assert_equal "one, two, three", response["x-example"]
+      assert_equal "Multiple Headers", response.body
+    end
+  end
+
+  def test_large_body
+    large_text = "A" * 10_000
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain", "Content-Length" => large_text.bytesize.to_s }, [large_text]]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "200", response.code
+      assert_equal large_text, response.body
+    end
+  end
+
+  def test_custom_status_code
+    run_app(lambda do |env|
+      [201, { "Content-Type" => "text/plain" }, ["Created"]]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "201", response.code
+      assert_equal "Created", response.body
+    end
+  end
+
+  def test_empty_body
+    run_app(lambda do |env|
+      [204, { "Content-Type" => "text/plain" }, []]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "204", response.code
+      assert_nil response.body
+    end
+  end
+
+  def test_utf8_response
+    utf8_text = "こんにちは世界"
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain; charset=utf-8" }, [utf8_text]]
+    end) do |uri|
+      response = Net::HTTP.get_response(uri)
+      assert_equal "200", response.code
+      assert_equal utf8_text, response.body.force_encoding("UTF-8")
+    end
+  end
+
+  def test_custom_request_header
+    run_app(lambda do |env|
+      header_value = env["HTTP_X_MY_HEADER"] || ""
+      [200, { "Content-Type" => "text/plain" }, [header_value]]
+    end) do |uri|
+      uri_obj = URI(uri)
+      req = Net::HTTP::Get.new(uri_obj)
+      req["X-My-Header"] = "test-header"
+      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      assert_equal "test-header", response.body
+    end
+  end
+
+  def test_url_encoded_query_params
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, [env["QUERY_STRING"]]]
+    end) do |uri|
+      uri.query = "param=%C3%A9" # %C3%A9 represents 'é'
+      assert_equal "param=%C3%A9", Net::HTTP.get(uri)
+    end
+  end
+
+  def test_https
+    run_app(lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, HTTPS!"]]
+    end, protocol: "https") do |uri|
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+        http.request(Net::HTTP::Get.new(uri))
+      end
+      assert_equal "200", response.code
+      assert_equal "Hello, HTTPS!", response.body
+    end
+  end
 end

data/lib/itsi/version.rb

@@ -1,3 +1,3 @@
 module Itsi
-  VERSION = "0.1.8"
+  VERSION = '0.1.11'
 end