itsi-scheduler 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06da68bc85607dea16257e5043d45b1a9ea6f376c9ef8d41e2bda7f4a89a0dcb
-  data.tar.gz: 2932d32895a5bef79abd2156248bd2eb089944d19810389c1ee1086c0406bf5f
+  metadata.gz: 92a729e2814758244bb48ab697c3e6f2cc5d239414df2f5f106beb6356d46e02
+  data.tar.gz: 4104654365bb5ace7881d90ac9e49f849e899ee1ca2b17ae03a7f5bf9d16dac2
 SHA512:
-  metadata.gz: 7419b864b913c1f80a50e8d3a7d061343382064bab38204e662a8e8eb4c3f5b31cbf26e473e74c7480c50bbfe04f792091c6960e903bbc3a7cfbb774a7f82e9e
-  data.tar.gz: c94af7791e8da99fb1f174662587358a6994305650943372ba36635140eecd0b7b00c83bea33c4e1178f5d2e760acbb01ac7dd82c38b4de03ac1087df4656dc7
+  metadata.gz: 3c8512c18fe4b5bde77b999ecf5f6772af2102d213bddfa8be2416178c2210b94787a8dc5531910cf85c815155ed2cf739999c08d6891342eb414a51bed5bc4f
+  data.tar.gz: 22914be4826e42af88929240d968ac493b8d9c82737807f33fe5aea0f979070eadac6de64104f912b0190dea2c3207e15199178f07c8c927ed5c5d0400936807

data/Cargo.lock

@@ -213,7 +213,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-scheduler"
-version = "0.2.10"
+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.10"
+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.10"
+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/lib.rs

@@ -86,6 +86,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
     response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
     response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
+    response.define_method("flush", method!(ItsiHttpResponse::flush, 0))?;
+    response.define_method("closed?", method!(ItsiHttpResponse::is_closed, 0))?;
     response.define_method(
         "send_and_close",
         method!(ItsiHttpResponse::send_and_close, 1),

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

@@ -272,6 +272,14 @@ impl ItsiHttpResponse {
         // not implemented
     }
 
+    pub fn flush(&self) {
+        // no-op
+    }
+
+    pub fn is_closed(&self) -> bool {
+        self.data.response_writer.write().is_none()
+    }
+
     pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<()> {
         let result = self.send_frame_into(ByteFrame::End(frame), &self.data.response_writer);
         self.data.response_writer.write().take();
@@ -339,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(())
     }
@@ -356,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.10"
+    VERSION = "0.2.12"
   end
 end

data/lib/itsi/scheduler.rb

@@ -2,6 +2,7 @@
 
 require_relative "scheduler/version"
 require_relative "scheduler/itsi_scheduler"
+require_relative "schedule_refinement"
 
 module Itsi
   class Scheduler

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.12
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -35,7 +35,6 @@ files:
 - ".rubocop.yml"
 - Cargo.lock
 - Cargo.toml
-- README.md
 - Rakefile
 - ext/itsi_acme/Cargo.toml
 - ext/itsi_acme/examples/high_level.rs
@@ -180,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/README.md

@@ -1,76 +0,0 @@
----
-title: Itsi Scheduler
-type: docs
-weight: 4
-sidebar:
-  exclude: true
----
-<img src="itsi-scheduler-100.png"  width="80px" style="display: block; margin-left: auto; margin-right: auto;">
-
-`Itsi Scheduler` is an implementation of a Ruby [Fiber Scheduler](https://docs.ruby-lang.org/en/3.2/Fiber/Scheduler.html).
-
-When combined with Itsi Server, you can write endpoints that look just like regular synchronous Ruby code. Behind the scenes, the scheduler will transparently pause and resume fibers to prevent threads from blocking, greatly increasing throughput for I/O-heavy workloads
-
-If you're purely after a lightweight, yet efficient Ruby scheduler,
-you can use Itsi Scheduler as a standalone scheduler for any Ruby application.
-
-Just use `Fiber.set_scheduler` to set an instance `Itsi::Scheduler` as a scheduler to opt in to this IO weaving behavior
-*automatically* for all blocking IO.
-
-### Primer on Fiber Schedulers
-
-Fiber schedulers are a way to automatically manage the execution of non-blocking fibers in Ruby. A scheduler is responsible for the automatic pausing and resumption of Fibers based
-on whether or not they are awaiting IO operations.
-Ruby's Fiber scheduler implementation automatically invokes the current Fiber scheduler (if it exists) for each blocking operation, allowing it to seamlessly drive the execution of huge numbers of simultaneous non-blocking fibers
-while ensuring the main thread is never blocked on IO.
-
-This behind the scenes magic allows Ruby to provide async IO (just like we find in languages with `async/await` like `Rust`, `C#`, `JavaScript`) *but* with the added beauty
-that synchronous and asynchronous code is identical! (I.e. Ruby's functions are [colorless](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/))
-
-## Getting Started
-To install and use Itsi Scheduler follow the instructions below:
-
-
-### 1 - Install Itsi Scheduler
-
-**Prerequisites**
-
-You'll need at least `build-essential` and `libclang-dev` installed to build Itsi on Linux.
-E.g.
-```bash
-apt-get install build-essential libclang-dev
-```
-
-Then use `gem` to install the Itsi package. This will in turn install both the
-`itsi-server` gem, and the `itsi-scheduler` gem.
-
-
-```bash
-gem install itsi-scheduler
-```
-
-
-### 2 - Use Itsi Scheduler
-
-Great! You now have Itsi Scheduler installed.
-Now you can run code like this:
-
-```ruby
-require 'itsi/scheduler'
-require 'socket'
-results = Thread.new do
-  Fiber.set_scheduler Itsi::Scheduler.new
-  results = []
-  Fiber.schedule do
-    results << Addrinfo.getaddrinfo("www.ruby-lang.org", 80, nil, :STREAM)
-  end
-  Fiber.schedule do
-    results << Addrinfo.getaddrinfo("www.google.com", 80, nil, :STREAM)
-  end
-  results
-end.value
-
-puts results.map(&:inspect)
-```
-
-to run many blocking operations simultaneously all while occupying only a single Ruby thread!

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