itsi 0.1.8 → 0.1.9

data/gems/server/ext/itsi_server/src/server/signal.rs

@@ -10,6 +10,13 @@ pub static SIGNAL_HANDLER_CHANNEL: LazyLock<(
     broadcast::Receiver<LifecycleEvent>,
 )> = LazyLock::new(|| sync::broadcast::channel(5));
 
+pub fn send_shutdown_event() {
+    SIGNAL_HANDLER_CHANNEL
+        .0
+        .send(LifecycleEvent::Shutdown)
+        .expect("Failed to send shutdown event");
+}
+
 pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);
 fn receive_signal(signum: i32, _: sighandler_t) {
     SIGINT_COUNT.fetch_add(-1, std::sync::atomic::Ordering::SeqCst);

data/gems/server/ext/itsi_server/src/server/thread_worker.rs

@@ -1,7 +1,7 @@
 use super::itsi_server::RequestJob;
 use crate::{request::itsi_request::ItsiRequest, ITSI_SERVER};
 use itsi_rb_helpers::{
-    call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapValue,
+    call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapVal, HeapValue,
 };
 use itsi_tracing::{debug, error, info, warn};
 use magnus::{
@@ -52,7 +52,7 @@ pub struct TerminateWakerSignal(bool);
 pub fn build_thread_workers(
     pid: Pid,
     threads: NonZeroU8,
-    app: Opaque<Value>,
+    app: HeapVal,
     scheduler_class: Option<String>,
 ) -> Result<(Arc<Vec<ThreadWorker>>, async_channel::Sender<RequestJob>)> {
     let (sender, receiver) = async_channel::bounded(20);
@@ -79,11 +79,10 @@ pub fn build_thread_workers(
 }
 
 pub fn load_app(
-    app: Opaque<Value>,
+    app: HeapVal,
     scheduler_class: Option<String>,
 ) -> Result<(Opaque<Value>, Option<Opaque<Value>>)> {
     call_with_gvl(|ruby| {
-        let app = app.get_inner_with(&ruby);
         let app = Opaque::from(
             app.funcall::<_, _, Value>(*ID_CALL, ())
                 .expect("Couldn't load app"),

data/gems/server/ext/itsi_server/src/server/tls.rs

@@ -48,23 +48,26 @@ pub fn configure_tls(
 ) -> Result<ItsiTlsAcceptor> {
     let domains = query_params
         .get("domains")
-        .map(|v| v.split(',').map(String::from).collect::<Vec<_>>());
+        .map(|v| v.split(',').map(String::from).collect::<Vec<_>>())
+        .or_else(|| query_params.get("domain").map(|v| vec![v.to_string()]));
 
-    if query_params.get("cert").is_some_and(|c| c == "auto") {
+    if query_params.get("cert").is_some_and(|c| c == "acme") {
         if let Some(domains) = domains {
             let directory_url = &*ITSI_ACME_DIRECTORY_URL;
             info!(
                 domains = format!("{:?}", domains),
                 directory_url, "Requesting acme cert"
             );
+            let acme_contact_email = query_params
+                .get("acme_email")
+                .map(|s| s.to_string())
+                .or_else(|| (*ITSI_ACME_CONTACT_EMAIL).as_ref().ok().map(|s| s.to_string()))
+                .ok_or_else(|| itsi_error::ItsiError::ArgumentError(
+                    "acme_cert query param or ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate let's encrypt certificates".to_string(),
+                ))?;
 
             let acme_config = AcmeConfig::new(domains)
-                .contact([format!("mailto:{}", (*ITSI_ACME_CONTACT_EMAIL).as_ref().map_err(|_| {
-                    itsi_error::ItsiError::ArgumentError(
-                      "ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate production certificates"
-                          .to_string(),
-                  )
-                })?)])
+                .contact([format!("mailto:{}", acme_contact_email)])
                 .cache(LockedDirCache::new(&*ITSI_ACME_CACHE_DIR))
                 .directory(directory_url);
 

data/gems/server/ext/itsi_tracing/src/lib.rs

@@ -1,11 +1,13 @@
 use std::env;
 
 use atty::{Stream, is};
+use tracing::level_filters::LevelFilter;
 pub use tracing::{debug, error, info, trace, warn};
 pub use tracing_attributes::instrument; // Explicitly export from tracing-attributes
 use tracing_subscriber::{
-    EnvFilter,
+    EnvFilter, Layer,
     fmt::{self, format},
+    layer::SubscriberExt,
 };
 
 #[instrument]
@@ -39,3 +41,18 @@ pub fn init() {
             .init();
     }
 }
+
+pub fn run_silently<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Build a minimal subscriber that filters *everything* out
+    let no_op_subscriber =
+        tracing_subscriber::registry().with(fmt::layer().with_filter(LevelFilter::OFF));
+
+    // Turn that subscriber into a `Dispatch`
+    let no_op_dispatch = tracing::dispatcher::Dispatch::new(no_op_subscriber);
+
+    // Temporarily set `no_op_dispatch` as the *default* within this closure
+    tracing::dispatcher::with_default(&no_op_dispatch, f)
+}

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/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.8"
+    VERSION = "0.1.9"
   end
 end

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

@@ -2,119 +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"
-require 'erb'
 
-DEFAULT_INDEX = IO.read(__dir__ + '/index.html.erb')
+# 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: ->(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[],
+        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