ci: add checks for zenoh crate alone

.github/workflows/ci.yml

@@ -51,15 +51,27 @@ jobs:
       - name: Code format check
         run: cargo fmt --check -- --config "unstable_features=true,imports_granularity=Crate,group_imports=StdExternalCrate"
 
-      - name: Clippy
+      - name: Clippy zenoh no-default-features
+        run: cargo +stable clippy -p zenoh --all-targets --no-default-features -- --deny warnings
+
+      - name: Clippy zenoh
+        run: cargo +stable clippy -p zenoh --all-targets -- --deny warnings
+
+      - name: Clippy zenoh unstable
+        run: cargo +stable clippy -p zenoh --all-targets --features unstable -- --deny warnings
+
+      - name: Clippy zenoh internal
+        run: cargo +stable clippy -p zenoh --all-targets --features unstable,internal -- --deny warnings
+
+      - name: Clippy zenoh shared-memory
+        run: cargo +stable clippy -p zenoh --all-targets --features unstable,shared-memory -- --deny warnings
+
+      - name: Clippy workspace
         run: cargo +stable clippy --all-targets -- --deny warnings
 
-      - name: Clippy unstable targets
+      - name: Clippy workspace unstable
         run: cargo +stable clippy --all-targets --features unstable -- --deny warnings
 
-      - name: Clippy shared memory without unstable
-        run: cargo +stable clippy --all-targets --features shared-memory -- --deny warnings
-
       - name: Clippy all features
         if: ${{ matrix.os == 'ubuntu-latest' || matrix.os == 'macOS-latest' }}
         run: cargo +stable clippy --all-targets --all-features -- --deny warnings

ci/valgrind-check/Cargo.toml

@@ -22,10 +22,10 @@ categories = ["network-programming"]
 description = "Internal crate for zenoh."
 
 [dependencies]
-tokio = { version = "1.35.1",  features = ["rt-multi-thread", "time", "io-std"] }
+tokio = { version = "1.35.1", features = ["rt-multi-thread", "time", "io-std"] }
 tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
 futures = "0.3.25"
-zenoh = { path = "../../zenoh/", features = ["unstable"] }
+zenoh = { path = "../../zenoh/" }
 zenoh-runtime = { path = "../../commons/zenoh-runtime/" }
 zenoh-util = { path = "../../commons/zenoh-util/", features = ["test"] }
 

ci/valgrind-check/src/queryable_get/bin/z_queryable_get.rs

@@ -34,7 +34,7 @@ async fn main() {
             let queryable_key_expr = queryable_key_expr.clone();
             zenoh_runtime::ZRuntime::Application.block_in_place(async move {
                 query
-                    .reply(queryable_key_expr, query.value().unwrap().payload().clone())
+                    .reply(queryable_key_expr, query.payload().unwrap().clone())
                     .await
                     .unwrap();
             });
@@ -51,7 +51,7 @@ async fn main() {
         println!("Sending Query '{get_selector}'...");
         let replies = get_session
             .get(&get_selector)
-            .value(idx)
+            .payload(idx)
             .target(QueryTarget::All)
             .await
             .unwrap();

zenoh/src/api/builders/publisher.rs

@@ -293,6 +293,7 @@ impl<'a, 'b> PublisherBuilder<'a, 'b> {
             priority: self.priority,
             is_express: self.is_express,
             destination: self.destination,
+            #[cfg(feature = "unstable")]
             matching_listeners: Default::default(),
             undeclare_on_drop: true,
         })
@@ -346,6 +347,7 @@ impl<'a, 'b> Wait for PublisherBuilder<'a, 'b> {
                 priority: self.priority,
                 is_express: self.is_express,
                 destination: self.destination,
+                #[cfg(feature = "unstable")]
                 matching_listeners: Default::default(),
                 undeclare_on_drop: true,
             })

zenoh/src/api/publisher.rs

@@ -13,29 +13,32 @@
 //
 
 use std::{
-    collections::HashSet,
     convert::TryFrom,
     fmt,
     future::{IntoFuture, Ready},
     pin::Pin,
-    sync::{Arc, Mutex},
     task::{Context, Poll},
 };
 
 use futures::Sink;
-#[zenoh_macros::unstable]
-use zenoh_config::wrappers::EntityGlobalId;
 use zenoh_core::{zread, Resolvable, Resolve, Wait};
 use zenoh_protocol::{
     core::CongestionControl,
     network::{push::ext, Push},
     zenoh::{Del, PushBody, Put},
 };
 use zenoh_result::{Error, ZResult};
-#[zenoh_macros::unstable]
+#[cfg(feature = "unstable")]
 use {
-    crate::api::handlers::{Callback, DefaultHandler, IntoHandler},
-    crate::api::sample::SourceInfo,
+    crate::api::{
+        handlers::{Callback, DefaultHandler, IntoHandler},
+        sample::SourceInfo,
+    },
+    std::{
+        collections::HashSet,
+        sync::{Arc, Mutex},
+    },
+    zenoh_config::wrappers::EntityGlobalId,
     zenoh_protocol::core::EntityGlobalIdProto,
 };
 
@@ -137,6 +140,7 @@ pub struct Publisher<'a> {
     pub(crate) priority: Priority,
     pub(crate) is_express: bool,
     pub(crate) destination: Locality,
+    #[cfg(feature = "unstable")]
     pub(crate) matching_listeners: Arc<Mutex<HashSet<Id>>>,
     pub(crate) undeclare_on_drop: bool,
 }
@@ -350,6 +354,7 @@ impl<'a> Publisher<'a> {
         Undeclarable::undeclare_inner(self, ())
     }
 
+    #[cfg(feature = "unstable")]
     fn undeclare_matching_listeners(&self) -> ZResult<()> {
         let ids: Vec<Id> = zlock!(self.matching_listeners).drain().collect();
         for id in ids {
@@ -479,6 +484,7 @@ impl Wait for PublisherUndeclaration<'_> {
     fn wait(mut self) -> <Self as Resolvable>::To {
         // set the flag first to avoid double panic if this function panic
         self.publisher.undeclare_on_drop = false;
+        #[cfg(feature = "unstable")]
         self.publisher.undeclare_matching_listeners()?;
         self.publisher
             .session
@@ -498,6 +504,7 @@ impl IntoFuture for PublisherUndeclaration<'_> {
 impl Drop for Publisher<'_> {
     fn drop(&mut self) {
         if self.undeclare_on_drop {
+            #[cfg(feature = "unstable")]
             let _ = self.undeclare_matching_listeners();
             let _ = self.session.undeclare_publisher_inner(self.id);
         }
@@ -1102,6 +1109,7 @@ mod tests {
 
     use crate::api::{sample::SampleKind, session::SessionDeclarations};
 
+    #[cfg(feature = "internal")]
     #[test]
     fn priority_from() {
         use std::convert::TryInto;

zenoh/src/api/selector.rs

@@ -333,6 +333,7 @@ impl<'a> From<KeyExpr<'a>> for Selector<'a> {
     }
 }
 
+#[cfg(feature = "unstable")]
 #[test]
 fn selector_accessors() {
     use crate::api::query::_REPLY_KEY_EXPR_ANY_SEL_PARAM as ANYKE;

zenoh/src/api/session.rs

@@ -1665,13 +1665,11 @@ impl Session {
         tracing::trace!("get({}, {:?}, {:?})", selector, target, consolidation);
         let mut state = zwrite!(self.state);
         let consolidation = match consolidation.mode {
-            ConsolidationMode::Auto => {
-                if selector.parameters().contains_key(TIME_RANGE_KEY) {
-                    ConsolidationMode::None
-                } else {
-                    ConsolidationMode::Latest
-                }
+            #[cfg(feature = "unstable")]
+            ConsolidationMode::Auto if selector.parameters().contains_key(TIME_RANGE_KEY) => {
+                ConsolidationMode::None
             }
+            ConsolidationMode::Auto => ConsolidationMode::Latest,
             mode => mode,
         };
         let qid = state.qid_counter.fetch_add(1, Ordering::SeqCst);

zenoh/src/net/routing/hat/client/pubsub.rs

@@ -527,6 +527,7 @@ impl HatPubSubTrait for HatCode {
         get_routes_entries()
     }
 
+    #[zenoh_macros::unstable]
     fn get_matching_subscriptions(
         &self,
         tables: &Tables,

zenoh/src/net/routing/hat/linkstate_peer/pubsub.rs

@@ -34,19 +34,18 @@ use super::{
     face_hat, face_hat_mut, get_peer, get_routes_entries, hat, hat_mut, network::Network, res_hat,
     res_hat_mut, HatCode, HatContext, HatFace, HatTables,
 };
-use crate::{
-    key_expr::KeyExpr,
-    net::routing::{
-        dispatcher::{
-            face::FaceState,
-            pubsub::*,
-            resource::{NodeId, Resource, SessionContext},
-            tables::{Route, RoutingExpr, Tables},
-        },
-        hat::{CurrentFutureTrait, HatPubSubTrait, Sources},
-        router::RoutesIndexes,
-        RoutingContext, PREFIX_LIVELINESS,
+#[cfg(feature = "unstable")]
+use crate::key_expr::KeyExpr;
+use crate::net::routing::{
+    dispatcher::{
+        face::FaceState,
+        pubsub::*,
+        resource::{NodeId, Resource, SessionContext},
+        tables::{Route, RoutingExpr, Tables},
     },
+    hat::{CurrentFutureTrait, HatPubSubTrait, Sources},
+    router::RoutesIndexes,
+    RoutingContext, PREFIX_LIVELINESS,
 };
 
 #[inline]
@@ -913,6 +912,7 @@ impl HatPubSubTrait for HatCode {
         get_routes_entries(tables)
     }
 
+    #[zenoh_macros::unstable]
     fn get_matching_subscriptions(
         &self,
         tables: &Tables,

zenoh/src/net/routing/hat/mod.rs

@@ -17,7 +17,7 @@
 //! This module is intended for Zenoh's internal use.
 //!
 //! [Click here for Zenoh's documentation](../zenoh/index.html)
-use std::{any::Any, collections::HashMap, sync::Arc};
+use std::{any::Any, sync::Arc};
 
 use zenoh_buffers::ZBuf;
 use zenoh_config::{unwrap_or_default, Config, WhatAmI};
@@ -34,6 +34,8 @@ use zenoh_protocol::{
 };
 use zenoh_result::ZResult;
 use zenoh_transport::unicast::TransportUnicast;
+#[cfg(feature = "unstable")]
+use {crate::key_expr::KeyExpr, std::collections::HashMap};
 
 use super::{
     dispatcher::{
@@ -42,7 +44,7 @@ use super::{
     },
     router::RoutesIndexes,
 };
-use crate::{key_expr::KeyExpr, net::runtime::Runtime};
+use crate::net::runtime::Runtime;
 
 mod client;
 mod linkstate_peer;
@@ -180,6 +182,7 @@ pub(crate) trait HatPubSubTrait {
 
     fn get_data_routes_entries(&self, tables: &Tables) -> RoutesIndexes;
 
+    #[zenoh_macros::unstable]
     fn get_matching_subscriptions(
         &self,
         tables: &Tables,

zenoh/src/net/routing/hat/p2p_peer/pubsub.rs

@@ -652,6 +652,7 @@ impl HatPubSubTrait for HatCode {
         get_routes_entries()
     }
 
+    #[zenoh_macros::unstable]
     fn get_matching_subscriptions(
         &self,
         tables: &Tables,

zenoh/src/net/routing/hat/router/pubsub.rs

@@ -34,19 +34,18 @@ use super::{
     face_hat, face_hat_mut, get_peer, get_router, get_routes_entries, hat, hat_mut,
     network::Network, res_hat, res_hat_mut, HatCode, HatContext, HatFace, HatTables,
 };
-use crate::{
-    key_expr::KeyExpr,
-    net::routing::{
-        dispatcher::{
-            face::FaceState,
-            pubsub::*,
-            resource::{NodeId, Resource, SessionContext},
-            tables::{Route, RoutingExpr, Tables},
-        },
-        hat::{CurrentFutureTrait, HatPubSubTrait, Sources},
-        router::RoutesIndexes,
-        RoutingContext, PREFIX_LIVELINESS,
+#[cfg(feature = "unstable")]
+use crate::key_expr::KeyExpr;
+use crate::net::routing::{
+    dispatcher::{
+        face::FaceState,
+        pubsub::*,
+        resource::{NodeId, Resource, SessionContext},
+        tables::{Route, RoutingExpr, Tables},
     },
+    hat::{CurrentFutureTrait, HatPubSubTrait, Sources},
+    router::RoutesIndexes,
+    RoutingContext, PREFIX_LIVELINESS,
 };
 
 #[inline]
@@ -1252,6 +1251,7 @@ impl HatPubSubTrait for HatCode {
         get_routes_entries(tables)
     }
 
+    #[zenoh_macros::unstable]
     fn get_matching_subscriptions(
         &self,
         tables: &Tables,

zenoh/tests/acl.rs

@@ -22,10 +22,10 @@ mod test {
     use zenoh::{
         config,
         config::{EndPoint, WhatAmI},
-        internal::{zlock, ztimeout},
         prelude::*,
         Config, Session,
     };
+    use zenoh_core::{zlock, ztimeout};
 
     const TIMEOUT: Duration = Duration::from_secs(60);
     const SLEEP: Duration = Duration::from_secs(1);

zenoh/tests/events.rs

@@ -13,7 +13,8 @@
 //
 use std::time::Duration;
 
-use zenoh::{config, internal::ztimeout, prelude::*, query::Reply, sample::SampleKind, Session};
+use zenoh::{config, query::Reply, sample::SampleKind, Session};
+use zenoh_core::ztimeout;
 
 const TIMEOUT: Duration = Duration::from_secs(10);
 
@@ -39,6 +40,7 @@ async fn close_session(session: Session) {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn zenoh_events() {
+    use zenoh::prelude::SessionDeclarations;
     let session = open_session(&["tcp/127.0.0.1:18447"], &[]).await;
     let zid = session.zid();
     let sub1 =

zenoh/tests/formatters.rs

@@ -11,6 +11,7 @@
 // Contributors:
 //   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
 //
+#![cfg(feature = "unstable")]
 use zenoh::key_expr::format::{kedefine, keformat};
 
 #[test]

zenoh/tests/liveliness.rs

@@ -16,10 +16,10 @@ use std::time::Duration;
 
 use zenoh::{
     config,
-    internal::ztimeout,
     prelude::*,
     sample::{Sample, SampleKind},
 };
+use zenoh_core::ztimeout;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn zenoh_liveliness() {

zenoh/tests/matching.rs

@@ -15,7 +15,8 @@
 use std::{str::FromStr, time::Duration};
 
 use flume::RecvTimeoutError;
-use zenoh::{config, config::Locator, internal::ztimeout, prelude::*, sample::Locality, Session};
+use zenoh::{config, config::Locator, prelude::*, sample::Locality, Session};
+use zenoh_core::ztimeout;
 
 const TIMEOUT: Duration = Duration::from_secs(60);
 const RECV_TIMEOUT: Duration = Duration::from_secs(1);

zenoh/tests/open_time.rs

@@ -11,6 +11,7 @@
 // Contributors:
 //   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
 //
+#![allow(unused)]
 use std::{
     future::IntoFuture,
     time::{Duration, Instant},

zenoh/tests/qos.rs

@@ -13,7 +13,8 @@
 //
 use std::time::Duration;
 
-use zenoh::{core::Priority, internal::ztimeout, prelude::*, publisher::CongestionControl};
+use zenoh::{core::Priority, prelude::*, publisher::CongestionControl};
+use zenoh_core::ztimeout;
 
 const TIMEOUT: Duration = Duration::from_secs(60);
 const SLEEP: Duration = Duration::from_secs(1);