itsi-scheduler 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c057b5de1665276930d7c09f81ccc6e1b81419cf7cd9a4b3c04a08d3b6d0976d
-  data.tar.gz: 32fb526429c78f471eb248d3800dff138e7021aec6f95b13ee30ff4a4297a570
+  metadata.gz: 92a729e2814758244bb48ab697c3e6f2cc5d239414df2f5f106beb6356d46e02
+  data.tar.gz: 4104654365bb5ace7881d90ac9e49f849e899ee1ca2b17ae03a7f5bf9d16dac2
 SHA512:
-  metadata.gz: c2304a02521484da65165d2f08632d9b52be536246ccefb5993b1715e7adcbe6cbc42fda820dffcd1e10bb1082b93ca9317e7aec6205cdfb735b3a6c933a63d5
-  data.tar.gz: d1c3f48ba6ba4c71694a5e0ee3f72ebb2b4229bbf4fe4cde8756ec5d6ed4d1c971c6e1e791c36b1f3ee7816e2db0a712aa70704b9c77ad9d2695021829c769c8
+  metadata.gz: 3c8512c18fe4b5bde77b999ecf5f6772af2102d213bddfa8be2416178c2210b94787a8dc5531910cf85c815155ed2cf739999c08d6891342eb414a51bed5bc4f
+  data.tar.gz: 22914be4826e42af88929240d968ac493b8d9c82737807f33fe5aea0f979070eadac6de64104f912b0190dea2c3207e15199178f07c8c927ed5c5d0400936807

data/Cargo.lock

@@ -213,7 +213,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-scheduler"
-version = "0.2.11"
+version = "0.2.12"
 dependencies = [
  "bytes",
  "derive_more",

data/ext/itsi_error/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "itsi_error"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 thiserror = "2.0.11"

data/ext/itsi_rb_helpers/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "itsi_rb_helpers"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 cfg-if = "1.0.0"

data/ext/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.11"
+version = "0.2.12"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.2.11"
+version = "0.2.12"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/src/default_responses/mod.rs

@@ -9,3 +9,6 @@ pub static NOT_FOUND_RESPONSE: LazyLock<ErrorResponse> = LazyLock::new(ErrorResp
 
 pub static INTERNAL_SERVER_ERROR_RESPONSE: LazyLock<ErrorResponse> =
     LazyLock::new(ErrorResponse::internal_server_error);
+
+pub static SERVICE_UNAVAILABLE_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::service_unavailable);

data/ext/itsi_server/src/ruby_types/itsi_http_request.rs

@@ -22,6 +22,7 @@ use super::{
     itsi_http_response::ItsiHttpResponse,
 };
 use crate::{
+    default_responses::{INTERNAL_SERVER_ERROR_RESPONSE, SERVICE_UNAVAILABLE_RESPONSE},
     server::{
         byte_frame::ByteFrame,
         http_message_types::{HttpRequest, HttpResponse},
@@ -186,16 +187,20 @@ impl ItsiHttpRequest {
                 } else {
                     &context.sender
                 };
-                match sender
-                    .send(RequestJob::ProcessHttpRequest(request, app))
-                    .await
-                {
-                    Err(err) => {
-                        error!("Error occurred: {}", err);
-                        let mut response = Response::new(BoxBody::new(Empty::new()));
-                        *response.status_mut() = StatusCode::BAD_REQUEST;
-                        Ok(response)
-                    }
+                match sender.try_send(RequestJob::ProcessHttpRequest(request, app)) {
+                    Err(err) => match err {
+                        async_channel::TrySendError::Full(_) => {
+                            Ok(SERVICE_UNAVAILABLE_RESPONSE
+                                .to_http_response(context.accept.clone())
+                                .await)
+                        }
+                        async_channel::TrySendError::Closed(err) => {
+                            error!("Error occurred: {:?}", err);
+                            Ok(INTERNAL_SERVER_ERROR_RESPONSE
+                                .to_http_response(context.accept.clone())
+                                .await)
+                        }
+                    },
                     _ => match receiver.recv().await {
                         Some(first_frame) => Ok(response
                             .build(first_frame, receiver, shutdown_channel)

data/ext/itsi_server/src/ruby_types/itsi_http_response.rs

@@ -347,7 +347,7 @@ impl ItsiHttpResponse {
         })?;
         let header_value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
         if let Some(ref mut resp) = *self.data.response.write() {
-            resp.headers_mut().insert(header_name, header_value);
+            resp.headers_mut().append(header_name, header_value);
         }
         Ok(())
     }
@@ -364,7 +364,7 @@ impl ItsiHttpResponse {
                 })?;
                 for value in values {
                     let header_value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
-                    headers_mut.insert(&header_name, header_value);
+                    headers_mut.append(&header_name, header_value);
                 }
             }
         }

data/ext/itsi_server/src/ruby_types/itsi_server/itsi_server_config.rs

@@ -69,6 +69,7 @@ pub struct ServerParams {
     pub pin_worker_cores: bool,
     pub scheduler_class: Option<String>,
     pub oob_gc_responses_threshold: Option<u64>,
+    pub ruby_thread_request_backlog_size: Option<usize>,
     pub middleware_loader: HeapValue<Proc>,
     pub middleware: OnceLock<MiddlewareSet>,
     pub binds: Vec<Bind>,
@@ -222,6 +223,10 @@ impl ServerParams {
         let scheduler_class: Option<String> = rb_param_hash.fetch("scheduler_class")?;
         let oob_gc_responses_threshold: Option<u64> =
             rb_param_hash.fetch("oob_gc_responses_threshold")?;
+
+        let ruby_thread_request_backlog_size: Option<usize> =
+            rb_param_hash.fetch("ruby_thread_request_backlog_size")?;
+
         let middleware_loader: Proc = rb_param_hash.fetch("middleware_loader")?;
         let log_level: Option<String> = rb_param_hash.fetch("log_level")?;
         let log_target: Option<String> = rb_param_hash.fetch("log_target")?;
@@ -310,6 +315,7 @@ impl ServerParams {
             scheduler_threads,
             streamable_body,
             scheduler_class,
+            ruby_thread_request_backlog_size,
             oob_gc_responses_threshold,
             binds,
             itsi_server_token_preference,

data/ext/itsi_server/src/server/middleware_stack/middlewares/ruby_app.rs

@@ -18,6 +18,7 @@ use std::sync::Arc;
 pub struct RubyApp {
     app: Arc<HeapValue<Proc>>,
     request_type: RequestType,
+    script_name: Option<String>,
     sendfile: bool,
     nonblocking: bool,
     base_path: Regex,
@@ -53,6 +54,9 @@ impl RubyApp {
         let base_path_src = params
             .funcall::<_, _, String>(Symbol::new("[]"), ("base_path",))
             .unwrap_or("".to_owned());
+        let script_name = params
+            .funcall::<_, _, Option<String>>(Symbol::new("[]"), ("script_name",))
+            .unwrap_or(None);
         let base_path = Regex::new(&base_path_src).unwrap();
 
         let request_type: RequestType = params
@@ -65,6 +69,7 @@ impl RubyApp {
             app: Arc::new(app.into()),
             sendfile,
             nonblocking,
+            script_name,
             request_type,
             base_path,
         }))
@@ -82,13 +87,14 @@ impl MiddlewareLayer for RubyApp {
         match self.request_type {
             RequestType::Http => {
                 let uri = req.uri().path();
-                let script_name = self
-                    .base_path
-                    .captures(uri)
-                    .and_then(|caps| caps.name("base_path"))
-                    .map(|m| m.as_str())
-                    .unwrap_or("/")
-                    .to_owned();
+                let script_name = self.script_name.clone().unwrap_or_else(|| {
+                    self.base_path
+                        .captures(uri)
+                        .and_then(|caps| caps.name("base_path"))
+                        .map(|m| m.as_str())
+                        .unwrap_or("/")
+                        .to_owned()
+                });
                 ItsiHttpRequest::process_request(
                     self.app.clone(),
                     req,

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

@@ -65,9 +65,12 @@ type ThreadWorkerBuildResult = Result<(
 pub fn build_thread_workers(params: Arc<ServerParams>, pid: Pid) -> ThreadWorkerBuildResult {
     let blocking_thread_count = params.threads;
     let nonblocking_thread_count = params.scheduler_threads;
+    let ruby_thread_request_backlog_size: usize = params
+        .ruby_thread_request_backlog_size
+        .unwrap_or_else(|| (blocking_thread_count as u16 * 30) as usize);
 
     let (blocking_sender, blocking_receiver) =
-        async_channel::bounded((blocking_thread_count as u16 * 30) as usize);
+        async_channel::bounded(ruby_thread_request_backlog_size);
     let blocking_receiver_ref = Arc::new(blocking_receiver);
     let blocking_sender_ref = blocking_sender;
     let scheduler_class = load_scheduler_class(params.scheduler_class.clone())?;

data/lib/itsi/schedule_refinement.rb

@@ -0,0 +1,96 @@
+module Itsi
+  module ScheduleRefinement
+    # Useful helper functions for using cooperative multi-tasking in Ruby.
+    # Opt-in to usage by executing `using Itsi::ScheduleRefinement` in any places
+    # you intend to use it.
+    #
+    # After this you can do things like the following
+    #
+    # 1. Launch batch concurrent fire-and-forget jobs.
+    # * 100.times.schedule_each{ sleep 0.1 }
+    #
+    # 2. Launch batch concurrent transofmrs
+    # See how `schedule_map` retains ordering, despite sleeping for randomized amount of time.
+    #
+    # * 100.times.schedule_map{|i| sleep Random.rand(0.0..0.05); i }
+    #
+    # 3. Manually organize fibers to run concurrently.
+    #
+    # require "net/http"
+    # schedule do
+    #   req1, req2 = Queue.new, Queue.new
+    #   schedule do
+    #     puts "Making request 1"
+    #     req1 << Net::HTTP.get(URI("http://httpbin.org/get"))
+    #     puts "Finished request 1"
+    #   end
+    #
+    #   schedule do
+    #     puts "Making request 2"
+    #     req2 << Net::HTTP.get(URI("http://httpbin.org/get"))
+    #     puts "Finished request 2"
+    #   end
+    #
+    #   res1, res2 = [req1, req2].map(&:pop)
+    # end
+    refine Kernel do
+      private def schedule(&blk) # rubocop:disable Metrics/MethodLength
+        return unless blk
+
+        if Fiber.scheduler.nil?
+          result = nil
+          Thread.new do
+            Fiber.set_scheduler Itsi::Scheduler.new
+            Fiber.schedule { result = blk.call }
+          end.join
+          result
+        else
+          Fiber.schedule(&blk)
+        end
+      end
+    end
+
+    module EnumerableExtensions
+      using ScheduleRefinement
+      def schedule_each(&block)
+        enum = Enumerator.new do |y|
+          schedule do
+            each { |item| schedule{ y.yield(item) } }
+          end
+        end
+
+        block_given? ? enum.each(&block) : enum.each
+      end
+
+      def schedule_map(&block)
+        return Enumerator.new do |y|
+          schedule do
+            with_index.each_with_object([]) do |(item, index), agg|
+              schedule do
+                agg[index] = (y << item)
+              end
+            end
+          end
+        end.map unless block_given?
+        schedule do
+          with_index.each_with_object([]) do |(item, index), agg|
+            schedule do
+              agg[index] = block[item]
+            end
+          end
+        end
+      end
+    end
+
+
+    refine Enumerator do
+      define_method(:schedule_each, EnumerableExtensions.instance_method(:schedule_each))
+      define_method(:schedule_map, EnumerableExtensions.instance_method(:schedule_map))
+    end
+
+    refine Enumerable do
+      define_method(:schedule_each, EnumerableExtensions.instance_method(:schedule_each))
+      define_method(:schedule_map, EnumerableExtensions.instance_method(:schedule_map))
+    end
+  end
+end

data/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.11"
+    VERSION = "0.2.12"
   end
 end

data/lib/itsi/scheduler.rb

@@ -2,37 +2,10 @@
 
 require_relative "scheduler/version"
 require_relative "scheduler/itsi_scheduler"
+require_relative "schedule_refinement"
 
 module Itsi
-  module ScheduleUtils
-    def schedule(&block)
-      return to_enum(:schedule) unless block_given?
-
-      Object.schedule do
-        each { |item| Object.schedule { block.call(item) } }
-      end
-    end
-  end
-
   class Scheduler
-    def self.enable_schedule_keyword!
-      Object.define_method(:schedule) do |&blk|
-        result = nil
-        return result unless blk
-
-        if Fiber.scheduler.nil?
-          Thread.new do
-            Fiber.set_scheduler Itsi::Scheduler.new
-            Fiber.schedule { result = blk[] }
-          end.join
-        else
-          Fiber.schedule { result = blk[] }
-        end
-        result
-      end
-      Enumerable.include(ScheduleUtils)
-    end
-
     class Error < StandardError; end
 
     def self.resume_token

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -179,9 +179,9 @@ files:
 - ext/itsi_tracing/target/debug/incremental/itsi_tracing-2kk4qj9gn5dg2/s-h5113124kv-0enwon2.lock
 - ext/itsi_tracing/target/debug/incremental/itsi_tracing-2mwo0yas7dtw4/s-h510hfz1ha-1udgpei.lock
 - itsi-scheduler-100.png
+- lib/itsi/schedule_refinement.rb
 - lib/itsi/scheduler.rb
 - lib/itsi/scheduler/version.rb
-- sig/itsi_scheduler.rbs
 homepage: https://itsi.fyi
 licenses:
 - MIT

data/sig/itsi_scheduler.rbs

@@ -1,4 +0,0 @@
-module ItsiScheduler
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end