itsi 0.1.19 → 0.2.2

data/gems/server/test/{test_itsi_server.rb → rack/test_rack_server.rb}

@@ -1,32 +1,30 @@
-require "socket"
-require "net/http"
-require "minitest/autorun"
+require_relative "../helpers/test_helper"
 
-class TestItsiServer < Minitest::Test
+class TestRackServer < 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|
+    server(app: lambda do |env|
       [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
-    end) do |uri|
-      assert_equal "Hello, World!", Net::HTTP.get(uri)
+    end) do
+      assert_equal "Hello, World!", get("/")
     end
   end
 
   def test_post
-    run_app(lambda do |env|
+    server(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) do
+      assert_equal "Hello, World!", post("/", "data").body
     end
   end
 
   def test_full_hijack
-    run_app(lambda do |env|
+    server(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")
@@ -38,99 +36,95 @@ class TestItsiServer < Minitest::Test
       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) do
+      assert_equal "Hello, World!", get("/")
     end
   end
 
   def test_streaming_body
-    run_app(lambda do |env|
+    server(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) do
+      assert_equal "Hello, World!", get("/")
     end
   end
 
   def test_partial_hijack
-    run_app(lambda do |env|
+    server(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) do
+      assert_equal "Hello, World!", get("/")
     end
   end
 
   def test_enumerable_body
-    run_app(lambda do |env|
+    server(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) do
+      assert_equal "one\ntwo\nthree\n", get("/")
     end
   end
 
   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|
+    server(
+      itsi_rb: lambda do
+        fiber_scheduler "Itsi::Scheduler"
+        run(lambda do |env|
+          sleep 0.25
+          [200, { "Content-Type" => "text/plain" }, "Response: #{env["PATH_INFO"][1..-1]}"]
+        end)
+      end
+    ) do
       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
+          response = get_resp("/#{payload}")
           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|
+    server(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) do
+      assert_equal "foo=bar&baz=qux", get("/?foo=bar&baz=qux")
     end
   end
 
   def test_put_request
-    run_app(lambda do |env|
+    server(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 = Net::HTTP::Put.new(uri)
       req.body = "put data"
-      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      response = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
       assert_equal "put data", response.body
     end
   end
 
   def test_custom_headers
-    run_app(lambda do |env|
+    server(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 = Net::HTTP::Get.new(uri)
       req["X-Custom"] = "custom-value"
-      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      response = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
       assert_equal "custom-value", response.body
     end
   end
@@ -138,48 +132,44 @@ class TestItsiServer < Minitest::Test
   def test_error_response
     response = nil
     capture_subprocess_io do
-      run_app(lambda do |env|
+      server(app: lambda do |env|
         raise "Intentional error for testing"
-      end) do |uri|
-        response = Net::HTTP.get_response(uri)
+      end) do
+        response = get_resp("/")
       end
     end
     assert_equal "500", response.code
   end
 
   def test_redirect
-    run_app(lambda do |env|
+    server(app: lambda do |env|
       [302, { "Location" => "http://example.com" }, []]
-    end) do |uri|
-      response = Net::HTTP.get_response(uri)
+    end) do
+      response = get_resp("/")
       assert_equal "302", response.code
       assert_equal "http://example.com", response["location"]
     end
   end
 
   def test_not_found
-    run_app(lambda do |env|
+    server(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)
+    end) do
+      response = get_resp("/nonexistent")
       assert_equal "404", response.code
       assert_equal "Not Found", response.body
     end
   end
 
   def test_head_request
-    run_app(lambda do |env|
+    server(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
+    end) do
+      response = head("/")
       assert_equal "200", response.code
       assert_empty response.body.to_s
       assert_equal "13", response["content-length"]
@@ -187,12 +177,10 @@ class TestItsiServer < Minitest::Test
   end
 
   def test_options_request
-    run_app(lambda do |env|
+    server(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) }
+    end) do
+      response = options("/")
       assert_equal "200", response.code
       assert_equal "GET,POST,OPTIONS", response["allow"]
       assert_equal "Options Response", response.body
@@ -200,10 +188,10 @@ class TestItsiServer < Minitest::Test
   end
 
   def test_cookie_handling
-    run_app(lambda do |env|
+    server(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)
+    end) do
+      response = get_resp('/')
       assert_equal "200", response.code
       assert_match(/session=abc123/, response["set-cookie"])
       assert_equal "Cookie Test", response.body
@@ -211,10 +199,10 @@ class TestItsiServer < Minitest::Test
   end
 
   def test_multiple_headers
-    run_app(lambda do |env|
+    server(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)
+    end) do
+      response = get_resp("/")
       assert_equal "200", response.code
       assert_equal "one, two, three", response["x-example"]
       assert_equal "Multiple Headers", response.body
@@ -223,30 +211,30 @@ class TestItsiServer < Minitest::Test
 
   def test_large_body
     large_text = "A" * 10_000
-    run_app(lambda do |env|
+    server(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)
+    end) do
+      response = get_resp("/")
       assert_equal "200", response.code
       assert_equal large_text, response.body
     end
   end
 
   def test_custom_status_code
-    run_app(lambda do |env|
+    server(app: lambda do |env|
       [201, { "Content-Type" => "text/plain" }, ["Created"]]
-    end) do |uri|
-      response = Net::HTTP.get_response(uri)
+    end) do
+      response = get_resp("/")
       assert_equal "201", response.code
       assert_equal "Created", response.body
     end
   end
 
   def test_empty_body
-    run_app(lambda do |env|
+    server(app: lambda do |env|
       [204, { "Content-Type" => "text/plain" }, []]
-    end) do |uri|
-      response = Net::HTTP.get_response(uri)
+    end) do
+      response = get_resp("/")
       assert_equal "204", response.code
       assert_nil response.body
     end
@@ -254,44 +242,43 @@ class TestItsiServer < Minitest::Test
 
   def test_utf8_response
     utf8_text = "こんにちは世界"
-    run_app(lambda do |env|
+    server(app: lambda do |env|
       [200, { "Content-Type" => "text/plain; charset=utf-8" }, [utf8_text]]
-    end) do |uri|
-      response = Net::HTTP.get_response(uri)
+    end) do
+      response = get_resp("/")
       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|
+    server(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 = Net::HTTP::Get.new(uri)
       req["X-My-Header"] = "test-header"
-      response = Net::HTTP.start(uri_obj.hostname, uri_obj.port) { |http| http.request(req) }
+      response = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
       assert_equal "test-header", response.body
     end
   end
 
   def test_url_encoded_query_params
-    run_app(lambda do |env|
+    server(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) do
+      assert_equal "param=%C3%A9", get("/?param=%C3%A9")
     end
   end
 
   def test_https
-    run_app(lambda do |env|
+    server(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))
+        http.request(Net::HTTP::Get.new("/"))
       end
       assert_equal "200", response.code
       assert_equal "Hello, HTTPS!", response.body

data/grpc_test/Itsi.rb

@@ -0,0 +1,11 @@
+require "grpc"
+require_relative 'echo_service_impl'
+
+bind "http://localhost:3000"
+
+grpc EchoServiceImpl.new,
+      nonblocking: false,
+      compression: 'gzip' do
+  # Nested middleware still works:
+  response_headers additions: { 'X-Service' => ['Echo'] }
+end

data/grpc_test/echo.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+package echo;
+
+service EchoService {
+  rpc Echo(EchoRequest) returns (EchoResponse);
+}
+
+message EchoRequest {
+  string message = 1;
+}
+
+message EchoResponse {
+  string message = 1;
+}

data/grpc_test/echo_pb.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: echo.proto
+
+require 'google/protobuf'
+
+
+descriptor_data = "\n\necho.proto\x12\x04\x65\x63ho\"\x1e\n\x0b\x45\x63hoRequest\x12\x0f\n\x07message\x18\x01 \x01(\t\"\x1f\n\x0c\x45\x63hoResponse\x12\x0f\n\x07message\x18\x01 \x01(\t2<\n\x0b\x45\x63hoService\x12-\n\x04\x45\x63ho\x12\x11.echo.EchoRequest\x1a\x12.echo.EchoResponseb\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Echo
+  EchoRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("echo.EchoRequest").msgclass
+  EchoResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("echo.EchoResponse").msgclass
+end

data/grpc_test/echo_service_impl.rb

@@ -0,0 +1,8 @@
+require_relative 'echo_services_pb'
+
+class EchoServiceImpl < Echo::EchoService::Service
+  # Unary RPC implementation
+  def echo(req, _unused_call)
+    Echo::EchoResponse.new(message: req.message)
+  end
+end

data/{sandbox/itsi_file/echo_service_nonitsi → grpc_test}/echo_services_pb.rb

@@ -14,14 +14,7 @@ module Echo
       self.unmarshal_class_method = :decode
       self.service_name = 'echo.EchoService'
 
-      # Simple unary method
       rpc :Echo, ::Echo::EchoRequest, ::Echo::EchoResponse
-      # Server streaming method
-      rpc :EchoStream, ::Echo::EchoRequest, stream(::Echo::EchoResponse)
-      # Client streaming method
-      rpc :EchoCollect, stream(::Echo::EchoRequest), ::Echo::EchoResponse
-      # Bidirectional streaming method
-      rpc :EchoBidirectional, stream(::Echo::EchoRequest), stream(::Echo::EchoResponse)
     end
 
     Stub = Service.rpc_stub_class

data/lib/itsi/version.rb

@@ -1,3 +1,3 @@
 module Itsi
-  VERSION = "0.1.19"
+  VERSION = "0.2.2"
 end

data/tasks.txt

@@ -1,72 +1,23 @@
--- Stretch goals:
-  - Single acceptor
-  - H3
-  - OpenAPI gen
-
-Feature complete. Polish and Release (At Lake):
-- Establish pattern for separate files for dsl feature, accumulated errors, ruby-dsl and "Did you mean" function.
-- Always do dry-run before reloading app.
-- More elegant route printing (middleware)
-- Fix default config (make sane choices)
-
--- Feature breakdown. For each feature make sure we have
---- Clean Code
---- Ultra robust config, with sane and safe defaults.
---- Complete Documentation (Readme + Blog)
---- Tests.
---- Debug Logging
---- Parameters for everything
---- No unwrap
---- Beautiful LSP and did you mean integration
-
-- Feature List:
--- HTTP
--- HTTP2
--- TLS
--- Websockets
--- Headers (Replace is equal to remove plus append)
--- Hijack
--- Callable
--- Streaming Bodies
--- Rate Limiter
--- Auth JWT/Basic/API
--- gRPC
--- File Watcher
--- Allow/Deny
--- Cache control
--- compression
--- CORS
--- etag
--- Intrusion Protection
--- Proxy
--- Header changes (also support append, replace, remove)
--- Endpoint
--- Rackup
--- Rack inline
--- Static assets
--- Redirect (HTTP to HTTPS!)
--- Logging
--- Cluster
--- Single
--- Restart
--- Stream body
--- Thread high/low
--- Unix Sockets
--- Uneven request distribution (Retry central acceptor, core affinity)
--- Mini apps, one-file sites.
--- Lsp and Did you mean
--- Author Final default Itsi-file
--- Add notes on: PGGSSENCMODE="disable" and OBJC_DISABLE_INITIALIZE_FORK_SAFETY=
-
-Later:
+Tasks:
+- Static ruby build
+- Add way to opt non Itsi.rb files into LSP
 - OTel
 - Even faster Hash creation for Rack
 - Image resizer
 - First class Rackless Websockets
-- Implement better Request timeouts (non-fiber mode. Kill stuck threads. Default to nil)
 - Print out warning if we can detect that a location block will never be hit.
 - Built in obs Dashboard + Stats
-- Support UDP
-- Support unix socket proxy
--- WASM pluggable middleware
--- gRPC proxying
+- WASM pluggable middleware
+- Support UDP Proxy
+- Support Unix Socket Proxy
+- gRPC proxying
+- HTTP-01 Autocert
+- H3
+- OpenAPI gen
+- Finish Single acceptor mode (Optional)
+  - Introduce Option
+  - Finish Unix implementation
+  - Very single worker shutdown (impact)
+  - Clean shutdown and restart while in single acceptor mode
+  - Fix Hang
+  - Introduce Socket Options