rustorb 0.1.0__tar.gz → 0.1.1__tar.gz

{rustorb-0.1.0 → rustorb-0.1.1}/Cargo.lock

@@ -438,11 +438,11 @@ dependencies = [
 
 [[package]]
 name = "rustorb-cdr"
-version = "0.1.0"
+version = "0.1.1"
 
 [[package]]
 name = "rustorb-codegen"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "rustorb-core",
  "tokio",
@@ -450,7 +450,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-core"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "criterion",
  "libc",
@@ -464,7 +464,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-ffi"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "rustorb-cdr",
  "rustorb-core",
@@ -472,7 +472,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-giop"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "rustorb-cdr",
  "serde_json",
@@ -480,7 +480,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-interop"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "rustorb-core",
  "rustorb-naming",
@@ -488,14 +488,14 @@ dependencies = [
 
 [[package]]
 name = "rustorb-naming"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "rustorb-core",
 ]
 
 [[package]]
 name = "rustorb-python"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "pyo3",
  "pyo3-build-config",

{rustorb-0.1.0 → rustorb-0.1.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/rustorb-cdr", "crates/rustorb-giop", "crates/rustorb-core", "crates/rustorb-python"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 rust-version = "1.85"
 license = "MIT OR Apache-2.0"
@@ -13,10 +13,10 @@ keywords = ["corba", "giop", "iiop", "orb", "rpc"]
 categories = ["network-programming"]
 
 [workspace.dependencies]
-rustorb-cdr = { path = "crates/rustorb-cdr", version = "0.1.0" }
-rustorb-giop = { path = "crates/rustorb-giop", version = "0.1.0" }
-rustorb-core = { path = "crates/rustorb-core", version = "0.1.0" }
-rustorb-naming = { path = "crates/rustorb-naming", version = "0.1.0" }
+rustorb-cdr = { path = "crates/rustorb-cdr", version = "0.1.1" }
+rustorb-giop = { path = "crates/rustorb-giop", version = "0.1.1" }
+rustorb-core = { path = "crates/rustorb-core", version = "0.1.1" }
+rustorb-naming = { path = "crates/rustorb-naming", version = "0.1.1" }
 tokio = { version = "1", default-features = false }
 
 [workspace.lints.rust]

{rustorb-0.1.0 → rustorb-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustorb
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: System :: Networking
 Classifier: Topic :: Software Development :: Object Brokering

{rustorb-0.1.0 → rustorb-0.1.1}/crates/rustorb-core/src/orb.rs

@@ -68,6 +68,15 @@ pub struct OrbOptions {
     /// How long an upcall thread beyond `min_server_threads` waits for work
     /// before it ends.
     pub server_thread_idle_timeout: Duration,
+    /// How long an upcall thread that answered a request waits for the
+    /// next request of the same connection, to read and run it itself
+    /// (`-ORBfollowLinger US`, in microseconds; docs/read-ownership.md).
+    /// Zero turns this off: the I/O task reads every request.
+    pub follow_linger: Duration,
+    /// How many requests of one connection an upcall thread reads in a
+    /// row before it lets the I/O task read again (`-ORBfollowLimit N`).
+    /// Zero turns this off.
+    pub follow_limit: usize,
     /// Requests of one connection that may wait or run at once. Beyond
     /// that the connection is not read until one completes.
     pub max_requests_per_connection: usize,
@@ -203,6 +212,8 @@ impl Default for OrbOptions {
             min_server_threads: 4,
             max_server_threads: 100,
             server_thread_idle_timeout: Duration::from_secs(60),
+            follow_linger: Duration::from_millis(1),
+            follow_limit: 64,
             max_requests_per_connection: 256,
             socket_send_buffer: None,
             socket_receive_buffer: None,
@@ -228,6 +239,8 @@ impl OrbOptions {
     /// | `-ORBendPoint giop:tcp:HOST:PORT` | [`endpoints`](OrbOptions::endpoints) (repeatable) |
     /// | `-ORBendPointPublish giop:tcp:HOST:PORT` | [`endpoint_publish`](OrbOptions::endpoint_publish) (`all(addr)` for the default) |
     /// | `-ORBmaxServerThreadPoolSize N` | [`max_server_threads`](OrbOptions::max_server_threads) |
+    /// | `-ORBfollowLinger US` | [`follow_linger`](OrbOptions::follow_linger), in microseconds |
+    /// | `-ORBfollowLimit N` | [`follow_limit`](OrbOptions::follow_limit) |
     /// | `-ORBendPoint giop:ssl:HOST:PORT` | [`tls_endpoints`](OrbOptions::tls_endpoints) (repeatable) |
     /// | `-ORBendPointPublish giop:ssl:HOST:PORT` | [`tls_endpoint_publish`](OrbOptions::tls_endpoint_publish) |
     /// | `-ORBsslCAFile PATH` | [`TlsOptions::ca_file`] |
@@ -255,6 +268,8 @@ impl OrbOptions {
                             | "clientCallTimeOutPeriod"
                             | "supportPerThreadTimeOut"
                             | "maxServerThreadPoolSize"
+                            | "followLinger"
+                            | "followLimit"
                             | "sslCAFile"
                             | "sslCertFile"
                             | "sslKeyFile"
@@ -277,6 +292,8 @@ impl OrbOptions {
                     | "endPoint"
                     | "endPointPublish"
                     | "maxServerThreadPoolSize"
+                    | "followLinger"
+                    | "followLimit"
                     | "sslCAFile"
                     | "sslCertFile"
                     | "sslKeyFile"
@@ -339,6 +356,13 @@ impl OrbOptions {
                     }
                     self.max_server_threads = n;
                 }
+                "followLinger" => {
+                    let us: u64 = value.parse().map_err(|_| bad_option())?;
+                    self.follow_linger = Duration::from_micros(us);
+                }
+                "followLimit" => {
+                    self.follow_limit = value.parse().map_err(|_| bad_option())?;
+                }
                 "sslCAFile" => self.tls.ca_file = Some(value.into()),
                 "sslCertFile" => self.tls.cert_file = Some(value.into()),
                 "sslKeyFile" => self.tls.key_file = Some(value.into()),

{rustorb-0.1.0 → rustorb-0.1.1}/crates/rustorb-core/src/server.rs

@@ -74,6 +74,9 @@ pub(crate) struct Server {
     order: ByteOrder,
     max_message_size: usize,
     max_requests: usize,
+    /// [`crate::OrbOptions::follow_linger`] and [`crate::OrbOptions::follow_limit`].
+    follow_linger: Duration,
+    follow_limit: usize,
     root: OnceLock<Arc<PoaInner>>,
     /// Simple object keys registered with `Orb::register_object_key`, and
     /// the POA keys they stand for.
@@ -234,6 +237,12 @@ impl Server {
             order: options.byte_order,
             max_message_size: options.max_message_size,
             max_requests: options.max_requests_per_connection.max(1),
+            follow_linger: options.follow_linger,
+            follow_limit: if options.follow_linger.is_zero() {
+                0
+            } else {
+                options.follow_limit
+            },
             root: OnceLock::new(),
             simple_keys: Mutex::new(HashMap::new()),
             pool: Mutex::new(Some(Pool::new(
@@ -574,12 +583,13 @@ impl Server {
     /// Leader / follower: an upcall thread that answered a request of
     /// `conn` reads the connection's next request itself and runs it, so
     /// that the request needs no hand-over from the I/O task to the pool.
-    /// The thread waits [`FOLLOW_LINGER`] at most for a request, and stops
-    /// when the pool has queued work (which other connections wait for),
-    /// after [`FOLLOW_LIMIT`] requests, or when the I/O task reads the
-    /// connection. See docs/read-ownership.md.
+    /// The thread waits [`crate::OrbOptions::follow_linger`] at most for a
+    /// request, and stops when the pool has queued work (which other
+    /// connections wait for), after [`crate::OrbOptions::follow_limit`] requests,
+    /// or when the I/O task reads the connection. See
+    /// docs/read-ownership.md.
     fn follow(self: &Arc<Self>, conn: &Arc<ServerConn>) {
-        for _ in 0..FOLLOW_LIMIT {
+        for _ in 0..self.follow_limit {
             if self.is_shutting_down() || self.pool_has_queued() {
                 break;
             }
@@ -589,11 +599,13 @@ impl Server {
             if !conn.inbound.claim() {
                 return;
             }
-            let (version, message) =
-                match conn.inbound.read_here(Some(Instant::now() + FOLLOW_LINGER)) {
-                    Here::Message(version, message) => (version, message),
-                    Here::TimedOut | Here::HandedBack => return,
-                };
+            let (version, message) = match conn
+                .inbound
+                .read_here(Some(Instant::now() + self.follow_linger))
+            {
+                Here::Message(version, message) => (version, message),
+                Here::TimedOut | Here::HandedBack => return,
+            };
             let keep = match message {
                 Message::Request { header, body } => {
                     let keep = conn.inbound.busy();
@@ -1057,15 +1069,6 @@ impl Server {
 /// `IOV_MAX` is 1024).
 const MAX_SLICES: usize = 64;
 
-/// How long an upcall thread waits for the next request of the connection
-/// it answered (see [`Server::follow`]). A client calling one request after
-/// another sends the next within a round trip.
-const FOLLOW_LINGER: Duration = Duration::from_millis(1);
-
-/// How many requests of one connection an upcall thread reads in a row
-/// before it lets the I/O task read again.
-const FOLLOW_LIMIT: usize = 64;
-
 /// A request that [`Server::route_here`] runs on its own thread if the
 /// manager lets it run before `dispatch` returns.
 struct RunHere {

{rustorb-0.1.0 → rustorb-0.1.1}/crates/rustorb-core/tests/server.rs

@@ -873,6 +873,18 @@ fn endpoint_options() {
     assert!(args.is_empty());
     assert_eq!(options.endpoint_publish, None);
 
+    // The leader / follower settings (docs/read-ownership.md).
+    let mut args: Vec<String> = ["-ORBfollowLinger=250", "-ORBfollowLimit", "8"]
+        .iter()
+        .map(|s| (*s).to_owned())
+        .collect();
+    options.parse_args(&mut args).unwrap();
+    assert!(args.is_empty());
+    assert_eq!(options.follow_linger, std::time::Duration::from_micros(250));
+    assert_eq!(options.follow_limit, 8);
+    let mut args = vec!["-ORBfollowLimit".to_owned(), "many".to_owned()];
+    assert!(options.parse_args(&mut args).is_err());
+
     assert_eq!(
         EndpointAddr::parse("giop:tcp::"),
         Some(EndpointAddr {

{rustorb-0.1.0 → rustorb-0.1.1}/crates/rustorb-core/tests/stress.rs

@@ -307,7 +307,22 @@ fn many_clients_each_on_its_own_connection() {
 /// up as `TIMEOUT`.
 #[test]
 fn back_to_back_calls_hand_the_reading_over() {
-    let server = Orb::with_options(server_options(0)).unwrap();
+    back_to_back(server_options(0), "");
+}
+
+/// The same, with the server's upcall threads never reading
+/// (`follow_linger` zero): the I/O task reads every request.
+#[test]
+fn back_to_back_calls_without_follow() {
+    let options = OrbOptions {
+        follow_linger: Duration::ZERO,
+        ..server_options(0)
+    };
+    back_to_back(options, " (no follow)");
+}
+
+fn back_to_back(server_options: OrbOptions, label: &str) {
+    let server = Orb::with_options(server_options).unwrap();
     let servant = Arc::new(LoadServant::default());
     let obj = serve(&server, servant.clone());
     let ior = server.object_to_string(Some(&obj)).unwrap();
@@ -333,7 +348,7 @@ fn back_to_back_calls_hand_the_reading_over() {
         t.join().unwrap();
     }
     eprintln!(
-        "{clients} connections back to back: {}",
+        "{clients} connections back to back{label}: {}",
         rate(clients * calls, start.elapsed())
     );
     assert_eq!(servant.calls.load(Ordering::Relaxed), clients * calls);

{rustorb-0.1.0 → rustorb-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rustorb"
-version = "0.1.0"
+version = "0.1.1"
 description = "CORBA ORB with its core in Rust: the Python binding"
 readme = "README.md"
 license = { text = "MIT OR Apache-2.0" }