itsi 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c0be7500e24ba264247f8ea8a8d2e0e7ce1d69caf449cd194e3ac1c849cffb6
-  data.tar.gz: 5dd34736783a2f8fe81f3ce3bd7626285ff8f364407248f0bbc5b74ba6c708dc
+  metadata.gz: 9069ae3d194e76dc4c4451d6506594a2a3e3789541b546a31dd3703a172f4e32
+  data.tar.gz: 6aacbd0351095bbde2e6db7c943bcd2444715519b079af2880c93cd5f623572f
 SHA512:
-  metadata.gz: 619d63e46c4286bf336cca1fad51e51dadf9eac57e106a1fd0493b00a838be36bbea16e6a96a5003870752afbba5c11123d9a42e02c43ee2994175f4273811cc
-  data.tar.gz: 264db7920c1c628ad0c65827dd63d5aeae3ce7c1ccba7a8940ebfc478000b9d728e804cd14c5700bd831fcd7f906bed6db85d4dc298119119eeb65249ec2bb96
+  metadata.gz: 36dcaf525c6852659d11c98f2d7813e4f01f86d934508a2ed45f071004f50fe6faee7a921ff9395bbc02198b10e8dc68887415781de3ae53aa3e90019a62f60e
+  data.tar.gz: ac990a66a605e5da8bec5f8bf26f51859ab50a1e4d8f50d95c9c4bf7c2ce6aefa0a882db1e7ef06593ab97ea4210e0faebe98f2a5d5001d9431fda8b1cf06c51

data/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-scheduler"
-version = "0.2.10"
+version = "0.2.12"
 dependencies = [
  "bytes",
  "derive_more",
@@ -1662,7 +1662,7 @@ dependencies = [
 
 [[package]]
 name = "itsi-server"
-version = "0.2.10"
+version = "0.2.12"
 dependencies = [
  "argon2",
  "async-channel",

data/LICENSE.txt

@@ -19,9 +19,178 @@ Please contact: commercial@itsi.fyi
 --------------------------------------------------------------------------------
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 3, 29 June 2007
+--------------------------------------------------------------------------------
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+
 --------------------------------------------------------------------------------
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
+--------------------------------------------------------------------------------
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies

data/README.md

@@ -104,3 +104,11 @@ You can also run gem-specific variants of the above. E.g.
 * `rake server:test` or `rake scheduler:test`
 * `rake server:compile` or `rake scheduler:compile`
 * `rake server:build` or `rake scheduler:build`
+
+
+### Contributing
+Developer Certificate of Origin
+
+By submitting a pull-request you certify that:
+1. The contribution is your original work or you have the right to submit it;
+2. You have read and understood the [Developer Certificate of Origin](https://developercertificate.org/) and you accept it.

data/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/crates/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/docs/content/features/_index.md

@@ -273,9 +273,9 @@ Note that despite the header being named `X-Sendfile`, Itsi does not use the Sen
 {{% /details %}}
 
 {{% details title="Graceful Memory Limits" closed="true" %}}
-* Itsi allows you to specify memory limits for Ruby processes. When the limit is reached, Itsi gracefully terminates the process and also invokes a dedicated `after_memory_threshold_reached` callback,
+* Itsi allows you to specify memory limits for Ruby processes. When the limit is reached, Itsi gracefully terminates the process and also invokes a dedicated `after_memory_limit_reached` callback,
 so that you can log the event for further analysis.
-* See <a target="_blank" href="/options/worker_memory_limit">worker_memory_limit</a> and  <a target="_blank" href="/options/after_memory_threshold_reached">after_memory_threshold_reached</a>.
+* See <a target="_blank" href="/options/worker_memory_limit">worker_memory_limit</a> and  <a target="_blank" href="/options/after_memory_limit_reached">after_memory_limit_reached</a>.
 {{% /details %}}
 
 {{% details title="OOB GC" closed="true" %}}

data/docs/content/itsi_scheduler/_index.md

@@ -101,6 +101,36 @@ end.value
 
 puts results.map(&:inspect)
 ```
-
 to run many blocking operations simultaneously all while occupying only a single Ruby thread!
+
+### 3 (Optional) - Enable Scheduler Refinements
+You can opt-in to a tiny set of Ruby refinements provided by the `Itsi::Scheduler` to make usage even more ergonomic.
+By opting in to this refinement (using `using Itsi::Scheduler`) you gain access to the top-level #schedule(&block) method, as well
+as enumerable methods #schedule_each, and #schedule_map.
+
+```ruby
+
+using Itsi::Scheduler
+
+# Fire-and-forget: 100 HTTP calls in parallel
+100.times.schedule_each do |i|
+  Net::HTTP.get(URI("https://example.com/#{i}"))
+end
+
+# Concurrent transform that keeps the original order
+squares = (1..20).schedule_map { |n| n * n }
+puts squares.inspect
+# => [1, 4, 9, 16, … 400]
+
+# Manual orchestration — still one thread
+schedule do
+  a, b = Queue.new, Queue.new
+
+  schedule { a << Net::HTTP.get(URI("https://httpbin.org/get")) }
+  schedule { b << Net::HTTP.get(URI("https://httpbin.org/uuid")) }
+
+  puts a.pop
+  puts b.pop
+end
+```
 {{% /steps %}}

data/examples/hybrid_scheduler_mode/Itsi.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Before running this test, go to the ./slow_service directory, and start the slow running service
+# on port 3005, by running `itsi`.
+
+# Single thread for blocking test.
+threads 1
+
+# Single thread for non-blocking test.
+scheduler_threads 1
+
+shutdown_timeout 1.0 # Shutdown Timeout in Seconds
+
+# Small backlogs for test purposes
+ruby_thread_request_backlog_size 100
+
+# Enable Itsi's fiber scheduler.
+fiber_scheduler true
+
+# Send requests to http://localhost:3000/nonblocking.
+# The app at config.ru runs a slow endpoint (takes 3+ seconds).
+# When using this endpoint you can have a very large number of simultaneous inflight requests.
+#
+#
+# Example benchmark:
+# Non-blocking mode. 100 requests at a time, service takes 2s to respond. Throughput of ~50rps expected.
+#  ❯ wrk  http://0.0.0.0:3000/nonblocking -c 100 -d 10
+# Running 10s test @ http://0.0.0.0:3000/nonblocking
+#   2 threads and 100 connections
+#   Thread Stats   Avg      Stdev     Max   +/- Stdev
+#     Latency     0.00us    0.00us   0.00us     nan%
+#     Req/Sec    65.00    109.41   316.00     84.62%
+#   500 requests in 10.10s, 69.34KB read
+#   Socket errors: connect 0, read 0, write 0, timeout 500
+# Requests/sec:     49.50
+# Transfer/sec:      6.86KB
+
+location 'nonblocking' do
+  rackup_file 'config.ru', nonblocking: true, script_name: ''
+end
+
+
+# Send requests to http://localhost:3000/blocking.
+# The app at config.ru runs a slow endpoint (takes 3+ seconds).
+# When using this endpoint, concurrency is limited by the number of blocking threads available.
+#
+# Blocking mode. Requests are executed sequentially , service takes 2s to respond. Throughput of ~0.5rps expected.
+#  ❯ wrk  http://0.0.0.0:3000/nonblocking -c 100 -d 10
+# Running 10s test @ http://0.0.0.0:3000/blocking
+#   2 threads and 100 connections
+#   Thread Stats   Avg      Stdev     Max   +/- Stdev
+#     Latency     0.00us    0.00us   0.00us     nan%
+#     Req/Sec     0.00      0.00     0.00    100.00%
+#   5 requests in 10.10s, 710.00B read
+#   Socket errors: connect 0, read 0, write 0, timeout 5
+# Requests/sec:      0.49
+
+location 'blocking' do
+  rackup_file 'config.ru', script_name: ''
+end

data/examples/hybrid_scheduler_mode/config.ru

@@ -0,0 +1,9 @@
+require 'net/http'
+
+# This could be any Rack app, a Rails app, a Sinatra app, etc.
+# We're going to use a simple inline rack handler for now.
+
+run ->(_) do
+  result = Net::HTTP.new('127.0.0.1', 3005).get('/?sleep=2')
+  [result.code.to_i, {'content-type' => 'text/html'}, [result.body]]
+end

data/examples/hybrid_scheduler_mode/slow_service/Itsi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+threads 1
+fiber_scheduler true
+
+bind "http://0.0.0.0:3005"
+
+endpoint do |req|
+  sleep_length = req.query_params.fetch("sleep", 3).to_i
+  sleep sleep_length
+  req.ok "It's been #{sleep_length} seconds!"
+end

data/gems/scheduler/Cargo.lock

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