Merge remote-tracking branch 'upstream/main' into feature/endpoint-auto-update

Author: Hugo Laloge

.github/workflows/ci.yml

@@ -116,6 +116,9 @@ jobs:
       - name: Clippy zenoh
         run: cargo +stable clippy -p zenoh --all-targets -- --deny warnings
 
+      - name: Clippy zenoh internal_config
+        run: cargo +stable clippy -p zenoh --all-targets --features internal_config -- --deny warnings
+
       - name: Clippy zenoh unstable
         run: cargo +stable clippy -p zenoh --all-targets --features unstable -- --deny warnings
 
@@ -189,7 +192,10 @@ jobs:
       - name: Install latest nextest
         uses: taiki-e/install-action@nextest
 
-      - name: Run tests
+      - name: Run tests stable
+        run: cargo nextest run -p zenoh -F internal_config
+
+      - name: Run tests with unstable
         run: cargo nextest run -F test -F internal_config --exclude zenoh-examples --exclude zenoh-plugin-example --workspace
 
       - name: Rename junit test report

Cargo.lock

@@ -94,6 +94,8 @@ const_format = "0.2.33"
 criterion = "0.5"
 crossbeam-utils = "0.8.20"
 crossbeam-queue = "0.3.12"
+crossbeam-channel = "0.5"
+static_assertions = "1.1.0"
 derive_more = { version = "1.0.0", features = ["as_ref"] }
 derive-new = "0.7.0"
 tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
@@ -107,7 +109,7 @@ getrandom = { version = "0.2" }
 hashbrown = "0.14"
 hex = { version = "0.4.3", default-features = false } # Default features are disabled due to usage in no_std crates
 hmac = { version = "0.12.1", features = ["std"] }
-home = "=0.5.9"
+home = "0.5.9"
 http-types = "2.12.0"
 humantime = "2.1.0"
 itertools = "0.13.0"
@@ -196,6 +198,7 @@ z-serial = "0.3.1"
 either = "1.13.0"
 prost = "0.13.2"
 tls-listener = { version = "0.11.0", features = ["rustls-ring"] }
+windows-sys = { version = "0.59.0", features = ["Win32_Foundation", "Win32_Networking_WinSock", "Win32_System_IO"] }
 zenoh-ext = { version = "=1.4.0", path = "zenoh-ext", default-features = false }
 zenoh-shm = { version = "=1.4.0", path = "commons/zenoh-shm" }
 zenoh-result = { version = "=1.4.0", path = "commons/zenoh-result", default-features = false }

Cargo.toml

@@ -357,7 +357,8 @@ validated_struct::validator! {
     #[doc(hidden)]
     Config {
         /// The Zenoh ID of the instance. This ID MUST be unique throughout your Zenoh infrastructure and cannot exceed 16 bytes of length. If left unset, a random u128 will be generated.
-        id: ZenohId,
+        /// If not specified a random Zenoh ID will be generated upon session creation.
+        id: Option<ZenohId>,
         /// The metadata of the instance. Arbitrary json data available from the admin space
         metadata: Value,
         /// The node's mode ("router" (default value in `zenohd`), "peer" or "client").

commons/zenoh-config/src/lib.rs

@@ -46,6 +46,8 @@ num_cpus = { workspace = true, optional = true }
 thread-priority = { workspace = true }
 stabby = { workspace = true }
 crossbeam-queue = { workspace = true }
+crossbeam-channel = { workspace = true }
+static_assertions = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 advisory-lock = { workspace = true }

commons/zenoh-shm/Cargo.toml

@@ -12,7 +12,20 @@
 //   ZettaScale Zenoh Team, <[email protected]>
 //
 
-use std::ops::{Deref, DerefMut};
+use std::{
+    num::NonZeroUsize,
+    ops::{Deref, DerefMut},
+};
+
+use crate::api::provider::types::MemoryLayout;
+
+/// Errors for buffer relayouting operation.
+#[zenoh_macros::unstable_doc]
+#[derive(Debug)]
+pub enum BufferRelayoutError {
+    IncompatibleAlignment,
+    SizeTooBig,
+}
 
 #[zenoh_macros::unstable_doc]
 pub trait ShmBuf: Deref<Target = [u8]> + AsRef<[u8]> {
@@ -22,3 +35,12 @@ pub trait ShmBuf: Deref<Target = [u8]> + AsRef<[u8]> {
 
 #[zenoh_macros::unstable_doc]
 pub trait ShmBufMut: ShmBuf + DerefMut + AsMut<[u8]> {}
+
+#[zenoh_macros::unstable_doc]
+pub trait OwnedShmBuf: ShmBuf {
+    #[zenoh_macros::unstable_doc]
+    fn try_resize(&mut self, new_size: NonZeroUsize) -> Option<()>;
+
+    #[zenoh_macros::unstable_doc]
+    fn try_relayout(&mut self, new_layout: MemoryLayout) -> Result<(), BufferRelayoutError>;
+}

commons/zenoh-shm/src/api/buffer/traits.rs

@@ -15,13 +15,16 @@
 use core::ops::Deref;
 use std::{
     borrow::{Borrow, BorrowMut},
-    ops::DerefMut,
+    num::NonZeroUsize,
 };
 
 use zenoh_buffers::{ZBuf, ZSlice};
 
-use super::{traits::ShmBuf, zshmmut::zshmmut};
-use crate::ShmBufInner;
+use super::{
+    traits::{BufferRelayoutError, OwnedShmBuf, ShmBuf},
+    zshmmut::{zshmmut, ZShmMut},
+};
+use crate::{api::provider::types::MemoryLayout, ShmBufInner};
 
 /// An immutable SHM buffer
 #[zenoh_macros::unstable_doc]
@@ -35,9 +38,23 @@ impl ShmBuf for ZShm {
     }
 }
 
+impl OwnedShmBuf for ZShm {
+    fn try_resize(&mut self, new_size: NonZeroUsize) -> Option<()> {
+        // Safety: this is safe because ZShm is an owned representation of SHM buffer and thus
+        // is guaranteed not to be wrapped into ZSlice (see ShmBufInner::try_resize comment)
+        unsafe { self.0.try_resize(new_size) }
+    }
+
+    fn try_relayout(&mut self, new_layout: MemoryLayout) -> Result<(), BufferRelayoutError> {
+        // Safety: this is safe because ZShm is an owned representation of SHM buffer and thus
+        // is guaranteed not to be wrapped into ZSlice (see ShmBufInner::try_relayout comment)
+        unsafe { self.0.try_relayout(new_layout) }
+    }
+}
+
 impl PartialEq<&zshm> for ZShm {
     fn eq(&self, other: &&zshm) -> bool {
-        self.0 == other.0 .0
+        self.0 == other.0
     }
 }
 
@@ -71,12 +88,6 @@ impl AsRef<[u8]> for ZShm {
     }
 }
 
-impl From<ShmBufInner> for ZShm {
-    fn from(value: ShmBufInner) -> Self {
-        Self(value)
-    }
-}
-
 impl From<ZShm> for ZSlice {
     fn from(value: ZShm) -> Self {
         value.0.into()
@@ -89,6 +100,17 @@ impl From<ZShm> for ZBuf {
     }
 }
 
+impl TryFrom<ZShm> for ZShmMut {
+    type Error = ZShm;
+
+    fn try_from(value: ZShm) -> Result<Self, Self::Error> {
+        match value.0.is_unique() && value.0.is_valid() {
+            true => Ok(Self(value.0)),
+            false => Err(value),
+        }
+    }
+}
+
 impl TryFrom<&mut ZShm> for &mut zshmmut {
     type Error = ();
 
@@ -109,57 +131,47 @@ impl TryFrom<&mut ZShm> for &mut zshmmut {
 #[derive(Debug, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
 #[repr(transparent)]
-pub struct zshm(ZShm);
-
-impl ToOwned for zshm {
-    type Owned = ZShm;
+pub struct zshm(ShmBufInner);
 
-    fn to_owned(&self) -> Self::Owned {
-        self.0.clone()
-    }
-}
-
-impl PartialEq<ZShm> for &zshm {
-    fn eq(&self, other: &ZShm) -> bool {
-        self.0 .0 == other.0
+impl ShmBuf for zshm {
+    fn is_valid(&self) -> bool {
+        self.0.is_valid()
     }
 }
 
 impl Deref for zshm {
-    type Target = ZShm;
+    type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        self.0.as_ref()
     }
 }
 
-impl DerefMut for zshm {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+impl AsRef<[u8]> for zshm {
+    fn as_ref(&self) -> &[u8] {
+        self
     }
 }
 
-impl From<&ShmBufInner> for &zshm {
-    fn from(value: &ShmBufInner) -> Self {
-        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
-        // to ShmBufInner type, so it is safe to transmute them in any direction
-        unsafe { core::mem::transmute(value) }
+impl ToOwned for zshm {
+    type Owned = ZShm;
+
+    fn to_owned(&self) -> Self::Owned {
+        self.0.clone().into()
     }
 }
 
-impl From<&mut ShmBufInner> for &mut zshm {
-    fn from(value: &mut ShmBufInner) -> Self {
-        // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
-        // to ShmBufInner type, so it is safe to transmute them in any direction
-        unsafe { core::mem::transmute(value) }
+impl PartialEq<ZShm> for &zshm {
+    fn eq(&self, other: &ZShm) -> bool {
+        self.0 == other.0
     }
 }
 
 impl TryFrom<&mut zshm> for &mut zshmmut {
     type Error = ();
 
     fn try_from(value: &mut zshm) -> Result<Self, Self::Error> {
-        match value.0 .0.is_unique() && value.0 .0.is_valid() {
+        match value.0.is_unique() && value.0.is_valid() {
             true => {
                 // SAFETY: ZShm, ZShmMut, zshm and zshmmut are #[repr(transparent)]
                 // to ShmBufInner type, so it is safe to transmute them in any direction