itsi-scheduler 0.2.26 → 0.2.27

data/ext/itsi_server/src/services/itsi_http_service.rs

@@ -1,16 +1,17 @@
 use crate::default_responses::{NOT_FOUND_RESPONSE, TIMEOUT_RESPONSE};
 use crate::ruby_types::itsi_server::itsi_server_config::ItsiServerTokenPreference;
 use crate::server::http_message_types::{
-    ConversionExt, HttpRequest, HttpResponse, RequestExt, ResponseFormat,
+    ConversionExt, HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat,
 };
 use crate::server::lifecycle_event::LifecycleEvent;
 use crate::server::middleware_stack::MiddlewareLayer;
 use crate::server::serve_strategy::acceptor::AcceptorArgs;
 use crate::server::signal::{send_lifecycle_event, SHUTDOWN_REQUESTED};
+use bytes::Bytes;
 use chrono::{self, DateTime, Local};
 use either::Either;
 use http::header::ACCEPT_ENCODING;
-use http::{HeaderValue, Request};
+use http::{HeaderValue, Request, StatusCode};
 use hyper::body::Incoming;
 use regex::Regex;
 use smallvec::SmallVec;
@@ -174,6 +175,7 @@ impl HttpRequestContext {
 const SERVER_TOKEN_VERSION: HeaderValue =
     HeaderValue::from_static(concat!("Itsi/", env!("CARGO_PKG_VERSION")));
 const SERVER_TOKEN_NAME: HeaderValue = HeaderValue::from_static("Itsi");
+const TEXT_PLAIN_UTF8: HeaderValue = HeaderValue::from_static("text/plain; charset=utf-8");
 
 impl ItsiHttpService {
     pub async fn handle_request(&self, req: Request<Incoming>) -> itsi_error::Result<HttpResponse> {
@@ -188,14 +190,15 @@ impl ItsiHttpService {
         let token_preference = self.server_params.itsi_server_token_preference;
 
         let service_future = async move {
-            let middleware_stack = self
-                .server_params
-                .middleware
-                .get()
-                .unwrap()
-                .stack_for(&req)
-                .unwrap();
-            let (stack, matching_pattern) = middleware_stack;
+            if let Some(acme_response) = self.acme_http01_response(&req) {
+                return Ok(acme_response);
+            }
+
+            let Some((stack, matching_pattern)) =
+                self.server_params.middleware.get().unwrap().stack_for(&req)
+            else {
+                return Ok(NOT_FOUND_RESPONSE.to_http_response(accept).await);
+            };
             let mut resp: Option<HttpResponse> = None;
 
             let mut context =
@@ -267,4 +270,42 @@ impl ItsiHttpService {
             service_future.await
         }
     }
+
+    fn acme_http01_response(&self, req: &HttpRequest) -> Option<HttpResponse> {
+        let host = normalize_host_header(req.header("host")?)?;
+        let managers = self.server_params.acme_managers.read();
+        let key_authorization = managers
+            .iter()
+            .find_map(|(_, manager)| manager.http01_response(host, req.uri().path()))?;
+
+        let mut builder = http::Response::builder()
+            .status(StatusCode::OK)
+            .header(http::header::CONTENT_TYPE, TEXT_PLAIN_UTF8);
+
+        if req.method() == http::Method::HEAD {
+            builder = builder.header(http::header::CONTENT_LENGTH, "0");
+            return builder.body(HttpBody::empty()).ok();
+        }
+
+        builder
+            .header(
+                http::header::CONTENT_LENGTH,
+                key_authorization.len().to_string(),
+            )
+            .body(HttpBody::full(Bytes::from(key_authorization)))
+            .ok()
+    }
+}
+
+fn normalize_host_header(host: &str) -> Option<&str> {
+    let host = host.trim();
+    if host.is_empty() {
+        return None;
+    }
+
+    if let Some(stripped) = host.strip_prefix('[') {
+        return stripped.split(']').next();
+    }
+
+    Some(host.split(':').next().unwrap_or(host))
 }

data/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.26"
+    VERSION = "0.2.27"
   end
 end

data/lib/itsi/scheduler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "etc"
+
 require_relative "scheduler/version"
 require_relative "scheduler/native_extension"
 require_relative "schedule_refinement"
@@ -7,6 +9,7 @@ require_relative "schedule_refinement"
 module Itsi
   class Scheduler
     class Error < StandardError; end
+    WorkRequest = Struct.new(:fiber, :work, :result, :error, keyword_init: true)
 
     def self.resume_token
       @resume_token ||= 0
@@ -17,12 +20,14 @@ module Itsi
       @join_waiters = {}.compare_by_identity
       @token_map = {}.compare_by_identity
       @resume_tokens = {}.compare_by_identity
+      @timeout_requests = {}
       @unblocked = [[], []]
       @unblock_idx = 0
       @unblocked_mux = Mutex.new
       @resume_fiber = method(:resume_fiber).to_proc
       @resume_fiber_with_readiness = method(:resume_fiber_with_readiness).to_proc
       @resume_blocked = method(:resume_blocked).to_proc
+      setup_worker_pool
     end
 
     def block(_, timeout, fiber = Fiber.current, token = Scheduler.resume_token)
@@ -33,6 +38,7 @@ module Itsi
       @token_map[fiber] = token
       Fiber.yield
     ensure
+      cancel_wait(token)
       @resume_tokens.delete(token)
       @token_map.delete(fiber)
       @join_waiters.delete(fiber)
@@ -61,6 +67,60 @@ module Itsi
       block nil, duration
     end
 
+    def timeout_after(duration, klass = Timeout::Error, message = "execution expired")
+      fiber = Fiber.current
+      token = Scheduler.resume_token
+      exception = klass.is_a?(Class) ? klass.new(message) : klass
+      @timeout_requests[token] = [fiber, exception]
+      start_timer(duration, token)
+      yield duration
+    ensure
+      clear_timer(token) if token
+      @timeout_requests.delete(token) if token
+    end
+
+    def fiber_interrupt(fiber, exception)
+      cancel_wait(@token_map[fiber]) if @token_map.key?(fiber)
+      fiber.raise(exception)
+      true
+    rescue FiberError
+      false
+    end
+
+    def blocking_operation_wait(work)
+      request = WorkRequest.new(fiber: Fiber.current, work: work)
+      @worker_queue << request
+      block(nil, nil, request.fiber)
+      raise request.error if request.error
+
+      request.result
+    end
+
+    def io_select(readables, writables, exceptables, timeout)
+      readables = Array(readables).compact
+      writables = Array(writables).compact
+      exceptables = Array(exceptables).compact
+      ios = (readables + writables + exceptables).uniq
+
+      if ios.length == 1
+        io = ios.first
+        events = 0
+        events |= IO::READABLE if readables.include?(io)
+        events |= IO::WRITABLE if writables.include?(io)
+        events |= IO::PRIORITY if exceptables.include?(io)
+        readiness = io_wait(io, events, timeout)
+        return nil unless readiness
+
+        return [
+          (readiness & IO::READABLE).zero? ? [] : readables.select { |entry| entry == io },
+          (readiness & IO::WRITABLE).zero? ? [] : writables.select { |entry| entry == io },
+          (readiness & IO::PRIORITY).zero? ? [] : exceptables.select { |entry| entry == io }
+        ]
+      end
+
+      blocking_operation_wait(-> { IO.select(readables, writables, exceptables, timeout) })
+    end
+
     def tick
       events = fetch_due_events
       timers = fetch_due_timers
@@ -72,6 +132,12 @@ module Itsi
     end
 
     def resume_fiber(token)
+      if (request = @timeout_requests.delete(token))
+        fiber, exception = request
+        fiber_interrupt(fiber, exception)
+        return
+      end
+
       if (fiber = @resume_tokens.delete(token))
         fiber.resume
       end
@@ -126,6 +192,7 @@ module Itsi
     def close
       run
     ensure
+      shutdown_worker_pool
       @closed ||= true
       freeze
     end
@@ -133,12 +200,17 @@ module Itsi
     # Need to defer to Process::Status rather than our extension
     # as we don't have a means of creating our own Process::Status.
     def process_wait(pid, flags)
-      result = nil
-      thread = Thread.new do
-        result = Process::Status.wait(pid, flags)
-      end
-      thread.join
-      result
+      blocking_operation_wait(-> { Process::Status.wait(pid, flags) })
+    end
+
+    def address_resolve(hostname)
+      blocking_operation_wait(-> { native_address_resolve(hostname) })
+    end
+
+    def process_fork
+      shutdown_worker_pool
+      setup_worker_pool
+      nil
     end
 
     def closed?
@@ -149,5 +221,48 @@ module Itsi
     def fiber(&blk)
       Fiber.new(blocking: false, &blk).tap(&:resume)
     end
+
+    private
+
+    def setup_worker_pool
+      @worker_stop_token = Object.new
+      @worker_queue = Queue.new
+      @worker_threads = Array.new(worker_pool_size) { start_worker_thread }
+    end
+
+    def start_worker_thread
+      Thread.new do
+        Thread.current.report_on_exception = false
+        Thread.current.thread_variable_set(:fork_safe, true)
+
+        loop do
+          request = @worker_queue.pop
+          break if request.equal?(@worker_stop_token)
+
+          begin
+            request.result = request.work.call
+          rescue Exception => exception
+            request.error = exception
+          ensure
+            unblock(nil, request.fiber)
+          end
+        end
+      end
+    end
+
+    def shutdown_worker_pool
+      return unless @worker_threads
+
+      @worker_threads.size.times { @worker_queue << @worker_stop_token }
+      @worker_threads.each(&:join)
+      @worker_threads.clear
+    end
+
+    def worker_pool_size
+      size = ENV.fetch("ITSI_WORKER_POOL_SIZE", Etc.nprocessors.to_s).to_i
+      size.positive? ? size : 1
+    rescue StandardError
+      1
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.2.26
+  version: 0.2.27
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -53,6 +53,7 @@ files:
 - ext/itsi_acme/src/caches/no.rs
 - ext/itsi_acme/src/caches/test.rs
 - ext/itsi_acme/src/config.rs
+- ext/itsi_acme/src/http_challenge.rs
 - ext/itsi_acme/src/https_helper.rs
 - ext/itsi_acme/src/incoming.rs
 - ext/itsi_acme/src/jose.rs