itsi 0.1.9 → 0.1.12

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

@@ -0,0 +1,213 @@
+module Itsi
+  class Server
+    class GrpcActiveCall
+      attr_reader :stream, :method_rpc, :output_metadata, :method_name
+
+      def initialize(stream, method_rpc, service_class, method_name)
+        @stream = stream
+        @method_rpc = method_rpc
+        @service_class = service_class
+        @output_metadata = {}
+        @method_name = method_name
+      end
+    end
+
+    class GrpcInterface
+      def self.for(services)
+        interface = new(services)
+        lambda do |request|
+          interface.handle_request(request)
+        end
+      end
+
+      def initialize(services = [])
+        @services = {}
+        register_services(services)
+      end
+
+      def register_services(services)
+        services.each do |service|
+          service_class = service.class
+          @services[service_class.service_name] = {
+            implementation: service,
+            class: service_class
+          }
+        end
+      end
+
+      def handle_request(request)
+        service_info = @services[request.service_name]
+        raise "Unknown service: #{request.service_name}" unless service_info
+
+        service_impl = service_info[:implementation]
+        service_class = service_info[:class]
+
+        method_rpc = RpcDescWrapper.new(service_class, request.content_type, request.method_name)
+
+        active_call = GrpcActiveCall.new(request.stream, method_rpc, service_class, request.method_name)
+
+        if method_rpc.bidi_streamer?
+          puts "Calling bidirectional streaming handler"
+          handle_bidi_streaming(active_call, service_impl)
+        elsif method_rpc.client_streamer?
+          puts "Calling client streaming handler"
+          handle_client_streaming(active_call, service_impl)
+        elsif method_rpc.server_streamer?
+          puts "Calling server streaming handler"
+          handle_server_streaming(active_call, service_impl)
+        elsif method_rpc.request_response?
+          handle_unary(active_call, service_impl)
+        end
+        active_call.stream.send_trailers({ "grpc-status" => "0" })
+      rescue StandardError => e
+        active_call.stream.send_trailers({ "grpc-status" => "13", "grpc-message" => e.message })
+      end
+
+      private
+
+      # Read a framed message from the stream
+      def read_message(stream)
+        # Read the gRPC frame header (5 bytes)
+        header = stream.read(5)
+        return nil if header.nil? || header.bytesize < 5
+
+        compressed = header.bytes[0] == 1
+        length = header[1..4].unpack1("N")
+
+        # Read the message body
+        stream.read(length)
+      end
+
+      # Send a response
+      def send_response(active_call, response)
+        response_data = active_call.method_rpc.marshal_response(response)
+        send_framed_message(active_call.stream, response_data)
+      end
+
+      # Send a framed message
+      def send_framed_message(stream, message_data, compressed = false)
+        compressed_flag = compressed ? 1 : 0
+        header = [compressed_flag, message_data.bytesize].pack("CN")
+
+        stream.write(header)
+        stream.write(message_data)
+        stream.flush
+      end
+
+      # Create an enumerator for client streaming requests
+      def create_request_enum(active_call)
+        Enumerator.new do |yielder|
+          loop do
+            message_data = read_message(active_call.stream)
+            break if message_data.nil?
+
+            request = active_call.method_rpc.unmarshal_request(message_data)
+            yielder << request
+          end
+        end
+      end
+
+      # Handlers for different RPC types
+
+      def handle_unary(active_call, service)
+        # Read the request message
+        message_data = read_message(active_call.stream)
+        request = active_call.method_rpc.unmarshal_request(message_data)
+
+        # Call the service implementation
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        response = service.send(underscore_method, request, active_call)
+
+        # Send response
+        send_response(active_call, response)
+      end
+
+      def handle_client_streaming(active_call, service)
+        # Create an enumerable to read the incoming stream
+        request_enum = create_request_enum(active_call)
+
+        # Call the service implementation
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        response = service.send(underscore_method, request_enum, active_call)
+
+        # Send response
+        send_response(active_call, response)
+      end
+
+      def handle_server_streaming(active_call, service)
+        # Read the request message
+        message_data = read_message(active_call.stream)
+        request = active_call.method_rpc.unmarshal_request(message_data)
+
+        # Call the service implementation with a block to handle streaming
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        service.send(underscore_method, request, active_call) do |response|
+          send_response(active_call, response)
+        end
+      end
+
+      def handle_bidi_streaming(active_call, service)
+        # Create an enumerable to read the incoming stream
+        request_enum = create_request_enum(active_call)
+
+        # Call the service implementation with a block
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        service.send(underscore_method, request_enum, active_call) do |response|
+          send_response(active_call, response)
+        end
+      end
+    end
+
+    class RpcDescWrapper
+      def initialize(service_class, content_type, method_name)
+        rpc_descs = service_class.rpc_descs
+        @rpc_desc = rpc_descs[method_name.to_sym]
+        raise "Method not found: #{method_name}" unless @rpc_desc
+
+        @input_type = @rpc_desc.input
+        @content_type = content_type
+        @input_is_stream = @input_type.is_a?(GRPC::RpcDesc::Stream)
+        @input_type = @input_type.type if @input_is_stream
+
+        @output_type = @rpc_desc.output
+        @output_is_stream = @output_type.is_a?(GRPC::RpcDesc::Stream)
+        @output_type = @output_type.type if @output_is_stream
+
+        @client_streamer = @input_is_stream
+        @server_streamer = @output_is_stream
+      end
+
+      def client_streamer?
+        @client_streamer
+      end
+
+      def server_streamer?
+        @server_streamer
+      end
+
+      def bidi_streamer?
+        @client_streamer && @server_streamer
+      end
+
+      def request_response?
+        !@client_streamer && !@server_streamer
+      end
+
+      def unmarshal_request(data)
+        if @content_type == "application/json"
+          @input_type.decode_json(data)
+        else
+          @input_type.decode(data)
+        end
+      end
+
+      def marshal_response(response)
+        if @content_type == "application/json"
+          response.to_json
+        else
+          response.to_proto
+        end
+      end
+    end
+  end
+end

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

@@ -4,12 +4,15 @@ module Rack
   module Handler
     module Itsi
       def self.run(app, options = {})
-        ::Itsi::Server.new(
-          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)
-        ).start
+        host = options.fetch(:host, "127.0.0.1")
+        port = options.fetch(:Port, 3001)
+        Itsi::Server.start(
+          {
+            app: app,
+            binds: ["http://#{host}:#{port}"]
+          },
+          Itsi::Server::Config.config_file_path
+        )
       end
     end
   end

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

@@ -1,6 +1,22 @@
 module Itsi
   class Server
     module RackInterface
+
+      # Builds a handler proc that is compatible with Rack applications.
+      def self.for(app)
+        require "rack"
+        if app.is_a?(String)
+          dir = File.expand_path(File.dirname(app))
+          Dir.chdir(dir) do
+            loaded_app = ::Rack::Builder.parse_file(app)
+            app = loaded_app.is_a?(Array) ? loaded_app.first : loaded_app
+          end
+        end
+        lambda do |request|
+          Server.respond(request, app.call(request.to_rack_env))
+        end
+      end
+
       # 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.
@@ -25,10 +41,13 @@ module Itsi
         # 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)
+          unless value.is_a?(Array)
+            response[key] = value
+            next
+          end
 
           value.each do |v|
-            response.add_header(key, v)
+            response[key] = v
           end
         end
 
@@ -40,7 +59,7 @@ module Itsi
         # stream this response.
 
         if body_streamer
-          body_streamer.call(StreamIO.new(response))
+          body_streamer.call(response)
 
         # If we're enumerable with more than one chunk
         # also stream, otherwise write in a single chunk
@@ -53,15 +72,11 @@ module Itsi
           # 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
+            response << buffer.to_s if buffer
             buffer = part
           end
 
-          begin
-            response.send_and_close(buffer.to_s)
-          rescue StandardError
-            binding.b
-          end
+          response.send_and_close(buffer.to_s)
         else
           response.send_and_close(body.to_s)
         end

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

@@ -13,7 +13,7 @@ module Itsi
       # each request is wrapped in a Fiber.
       def schedule(app, request)
         Fiber.schedule do
-          call(app, request)
+          app.call(request)
         end
       end
     end

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

@@ -1,3 +1,7 @@
+# Running with a Fiber scheduler enabled but with an ActiveSupport isolation_level set to Thread
+# can be dangerous. A thread isolation level means that all fibers sharing a thread can content
+# for the same resources, which can lead to race conditions.
+# This hook should *only* be disabled if you know there are no such shared resources.
 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. "\

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

@@ -1,6 +1,11 @@
 module Itsi
+  # This trap is necessary for debuggers and similar which intercept certain signals
+  # then attempt to restore these to the previous signal when finished.
+  # If the previous signal handler was registered in native code, this restoration doesn't
+  # work as expected and the native signal handler is lost.
+  # We intercept restored signals here and reinstate the Itsi server signal handlers
+  # (if the server is still running).
   module SignalTrap
-
     DEFAULT_SIGNALS = ["DEFAULT", "", nil].freeze
     INTERCEPTED_SIGNALS = ["INT"].freeze
 

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

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

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

@@ -3,45 +3,14 @@
 require_relative "server/version"
 require_relative "server/itsi_server"
 require_relative "server/rack_interface"
-require_relative "server/signal_trap"
+require_relative "server/grpc_interface"
 require_relative "server/scheduler_interface"
+require_relative "server/signal_trap"
 require_relative "server/rack/handler/itsi"
-require_relative "request"
-require_relative "stream_io"
-
-# 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
-}
+require_relative "server/config"
+require_relative "standard_headers"
+require_relative "http_request"
+require_relative "http_response"
 
 module Itsi
   class Server
@@ -53,34 +22,80 @@ module Itsi
         !!@running
       end
 
-      def build(
-        app: DEFAULT_APP[],
-        binds: DEFAULT_BINDS,
-        **opts
-      )
-        new(app: -> { app }, binds: binds, **opts)
+      def start_in_background_thread(cli_params={}, itsi_file = Itsi::Server::Config.config_file_path, &blk)
+        @background_thread = start(cli_params, itsi_file, background: true, &blk)
+      end
+
+      def start(cli_params, itsi_file = Itsi::Server::Config.config_file_path, background: false, &blk)
+        server = new(cli_params, itsi_file, blk)
+        previous_handler = Signal.trap(:INT, :DEFAULT)
+        run = lambda do
+          write_pid
+          @running = server
+          server.start
+          Signal.trap(:INT, previous_handler)
+          server
+        end
+        background ? Thread.new(&run) : run[]
+      end
+
+      def stop_background_thread
+        @running&.stop
+        @running = nil
+        @background_thread&.join
       end
 
-      def start_in_background_thread(silence: true, **opts)
-        start(background: true, silence: silence, **opts)
+      def write_pid
+        File.write(Itsi::Server::Config.pid_file_path, Process.pid)
       end
 
-      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
+      def get_pid
+        pid = File.read(Itsi::Server::Config.pid_file_path).to_i
+        if Process.kill(0, pid)
+          pid
+        else
+          nil
         end
+      rescue StandardError
+        nil
+      end
+
+      def reload
+        return unless pid = get_pid
+
+        Process.kill(:USR2, pid)
+      end
+
+      def restart
+        return unless pid = get_pid
+
+        Process.kill(:USR1, pid)
+      end
+
+      def down
+        puts :down
+      end
+
+      def up
+        puts :up
+      end
+
+      def add_worker
+        return unless pid = get_pid
+
+        Process.kill(:TTIN, pid)
+      end
+
+      def remove_worker
+        return unless pid = get_pid
+
+        Process.kill(:TTOU, pid)
+      end
+
+      def status
+        return unless pid = get_pid
+
+        Process.kill(:INFO, pid)
       end
     end
   end

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

@@ -0,0 +1,86 @@
+module Itsi
+  module StandardHeaders
+    ALL = [
+      ACCEPT = "accept",
+      ACCEPT_CHARSET = "accept-charset",
+      ACCEPT_ENCODING = "accept-encoding",
+      ACCEPT_LANGUAGE = "accept-language",
+      ACCEPT_RANGES = "accept-ranges",
+      ACCESS_CONTROL_ALLOW_CREDENTIALS = "access-control-allow-credentials",
+      ACCESS_CONTROL_ALLOW_HEADERS = "access-control-allow-headers",
+      ACCESS_CONTROL_ALLOW_METHODS = "access-control-allow-methods",
+      ACCESS_CONTROL_ALLOW_ORIGIN = "access-control-allow-origin",
+      ACCESS_CONTROL_EXPOSE_HEADERS = "access-control-expose-headers",
+      ACCESS_CONTROL_MAX_AGE = "access-control-max-age",
+      ACCESS_CONTROL_REQUEST_HEADERS = "access-control-request-headers",
+      ACCESS_CONTROL_REQUEST_METHOD = "access-control-request-method",
+      AGE = "age",
+      ALLOW = "allow",
+      ALT_SVC = "alt-svc",
+      AUTHORIZATION = "authorization",
+      CACHE_CONTROL = "cache-control",
+      CACHE_STATUS = "cache-status",
+      CDN_CACHE_CONTROL = "cdn-cache-control",
+      CONNECTION = "connection",
+      CONTENT_DISPOSITION = "content-disposition",
+      CONTENT_ENCODING = "content-encoding",
+      CONTENT_LANGUAGE = "content-language",
+      CONTENT_LENGTH = "content-length",
+      CONTENT_LOCATION = "content-location",
+      CONTENT_RANGE = "content-range",
+      CONTENT_SECURITY_POLICY_REPORT_ONLY = "content-security-policy-report-only",
+      CONTENT_TYPE = "content-type",
+      COOKIE = "cookie",
+      DNT = "dnt",
+      DATE = "date",
+      ETAG = "etag",
+      EXPECT = "expect",
+      EXPIRES = "expires",
+      FORWARDED = "forwarded",
+      FROM = "from",
+      HOST = "host",
+      IF_MATCH = "if-match",
+      IF_MODIFIED_SINCE = "if-modified-since",
+      IF_NONE_MATCH = "if-none-match",
+      IF_RANGE = "if-range",
+      IF_UNMODIFIED_SINCE = "if-unmodified-since",
+      LAST_MODIFIED = "last-modified",
+      LINK = "link",
+      LOCATION = "location",
+      MAX_FORWARDS = "max-forwards",
+      ORIGIN = "origin",
+      PRAGMA = "pragma",
+      PROXY_AUTHENTICATE = "proxy-authenticate",
+      PROXY_AUTHORIZATION = "proxy-authorization",
+      PUBLIC_KEY_PINS = "public-key-pins",
+      PUBLIC_KEY_PINS_REPORT_ONLY = "public-key-pins-report-only",
+      RANGE = "range",
+      REFERER = "referer",
+      REFERRER_POLICY = "referrer-policy",
+      REFRESH = "refresh",
+      RETRY_AFTER = "retry-after",
+      SEC_WEBSOCKET_ACCEPT = "sec-websocket-accept",
+      SEC_WEBSOCKET_EXTENSIONS = "sec-websocket-extensions",
+      SEC_WEBSOCKET_KEY = "sec-websocket-key",
+      SEC_WEBSOCKET_PROTOCOL = "sec-websocket-protocol",
+      SEC_WEBSOCKET_VERSION = "sec-websocket-version",
+      SERVER = "server",
+      SET_COOKIE = "set-cookie",
+      STRICT_TRANSPORT_SECURITY = "strict-transport-security",
+      TE = "te",
+      TRAILER = "trailer",
+      TRANSFER_ENCODING = "transfer-encoding",
+      USER_AGENT = "user-agent",
+      UPGRADE = "upgrade",
+      UPGRADE_INSECURE_REQUESTS = "upgrade-insecure-requests",
+      VARY = "vary",
+      VIA = "via",
+      WARNING = "warning",
+      WWW_AUTHENTICATE = "www-authenticate",
+      X_CONTENT_TYPE_OPTIONS = "x-content-type-options",
+      X_DNS_PREFETCH_CONTROL = "x-dns-prefetch-control",
+      X_FRAME_OPTIONS = "x-frame-options",
+      X_XSS_PROTECTION = "x-xss-protection",
+    ]
+  end
+end

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

@@ -6,23 +6,25 @@ require "itsi/scheduler"
 
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
-def free_bind
+def free_bind(protocol)
   server = TCPServer.new("0.0.0.0", 0)
   port = server.addr[1]
   server.close
-  "http://0.0.0.0:#{port}"
+  "#{protocol}://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
-  )
+def run_app(app, protocol: "http", bind: free_bind(protocol), scheduler_class: nil)
+  Itsi::Server.start_in_background_thread do
+    # Inline Itsi.rb
+    bind bind
+    workers 1
+    threads 1
+    fiber_scheduler scheduler_class
+    log_level :error
+    run app
+  end
 
-  sleep 0.1
-  yield URI(bind), server
+  yield URI(bind)
 ensure
-  server&.stop
+  Itsi::Server.stop_background_thread
 end

data/gems/server/test/test_itsi_server.rb

@@ -80,14 +80,20 @@ class TestItsiServer < Minitest::Test
     run_app(
       lambda do |env|
         sleep 0.25
-        [200, { "Content-Type" => "text/plain" }, "Hello, World!"]
+        [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
-          assert_equal "Hello, World!", Net::HTTP.get(uri)
+          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
@@ -278,4 +284,17 @@ class TestItsiServer < Minitest::Test
       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.9'
+  VERSION = '0.1.12'
 end

data/sandbox/itsi_file/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# gem "rails"
+
+gem 'itsi-scheduler', path: '../../gems/scheduler'
+gem 'itsi-server', path: '../../gems/server'
+
+gem 'debug'
+gem 'grpc'