Zenoh

https://docs.rs/zenoh/latest/
Admin
Zenoh is a stack that unifies data in motion, data at rest, and computations, blending traditional...
Tokens:1,165,771
Snippets:9,747
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### CancellationToken Example

Source: https://docs.rs/zenoh/latest/src/zenoh/api/cancellation.rs.html

Demonstrates how to create and use a CancellationToken to potentially interrupt a get query. This example shows basic setup for a query with a callback.

```rust
/// A synchronization primitive that can be used to interrupt a get query.
///
/// # Examples
/// ```
/// # #[tokio::main]
/// # async fn main() {
///
/// let session = zenoh::open(zenoh::Config::default()).await.unwrap();
/// let mut n = 0;
/// let cancellation_token = zenoh::cancellation::CancellationToken::default();
/// let queryable = session
///     .get("key/expression")
///     .callback_mut(move |reply| {n += 1;})
///
```

--------------------------------

### Declare and Query with Callback

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/querier.rs.html

Demonstrates how to declare a querier, send a GET request, and process replies using a callback function. This example also shows how to set query targets and consolidation modes.

```rust
use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let _ = querier
    .get()
    .callback(|reply| {println!("Received {:?}", reply.result());})
    .await
    .unwrap();
```

--------------------------------

### Start Peer Configuration and Initialization

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html

Retrieves configuration for starting a peer, including listeners, direct peers, scouting settings, and connection parameters. Binds listeners and connects to specified peers before potentially starting multicast scouting.

```rust
async fn start_peer(&self) -> ZResult<()> {
        let (listeners, peers, scouting, wait_scouting, listen, autoconnect, addr, ifaces, delay) = {
            let guard = &self.state.config.lock();
            (
                guard.listen().endpoints().peer().unwrap_or(&vec![]).clone(),
                guard
                    .connect()
                    .endpoints()
                    .peer()
                    .unwrap_or(&vec![])
                    .clone(),
                unwrap_or_default!(guard.scouting().multicast().enabled()),
                unwrap_or_default!(guard.open().return_conditions().connect_scouted()),
                *unwrap_or_default!(guard.scouting().multicast().listen().peer()),
                AutoConnect::multicast(guard, WhatAmI::Peer, self.zid().into()),
                unwrap_or_default!(guard.scouting().multicast().address()),
                unwrap_or_default!(guard.scouting().multicast().interface()),
                Duration::from_millis(unwrap_or_default!(guard.scouting().delay())),
            )
        };

        self.bind_listeners(&listeners).await?;

        self.connect_peers(&peers, false).await?;

        if scouting {
            self.start_scout(listen, autoconnect, addr, ifaces).await?;
        }

        if wait_scouting
            && (scouting || !peers.is_empty())
            && tokio::time::timeout(delay, self.state.start_conditions.notified())
                .await
                .is_err()
            && !peers.is_empty()
        {
            tracing::warn!("Scouting delay elapsed before start conditions are met.");
        }
        Ok(())
    }
```

--------------------------------

### Explicit RingChannel Setup

Source: https://docs.rs/zenoh/latest/zenoh/handlers/index.html

Demonstrates the explicit setup of a `RingChannel` and its handler, then uses the `with` method to associate it with a subscriber. This approach provides more control over the channel creation.

```rust
use zenoh::handlers::IntoHandler;
let (callback, mut ring_channel_handler)
   = zenoh::handlers::RingChannel::new(10).into_handler();
let subscriber = session.declare_subscriber("key/expression")
   .with((callback, ())) // or simply .callback(callback)
  .await.unwrap();
while let Ok(sample) = ring_channel_handler.recv_async().await {
   println!("Received: {:?}", sample);
}
```

--------------------------------

### Explicitly Create Subscriber with Callback and Handler

Source: https://docs.rs/zenoh/latest/src/zenoh/lib.rs.html

This example demonstrates the explicit creation of a callback and a RingChannel handler, which are then used to configure a subscriber. This approach provides more control over the handler setup compared to the `with` method.

```rust
# #[tokio::main]
# async fn main() {
# let session = zenoh::open(zenoh::Config::default()).await.unwrap();
use zenoh::handlers::IntoHandler;
let (callback, mut ring_channel_handler)
   = zenoh::handlers::RingChannel::new(10).into_handler();
let subscriber = session.declare_subscriber("key/expression")
   .with((callback, ())) // or simply .callback(callback)
  .await.unwrap();
# }

```

--------------------------------

### Example: Using SessionGetBuilder for a GET operation

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/query.rs.html

Demonstrates how to use the SessionGetBuilder to perform a GET operation on a key expression, specifying the target, consolidation mode, and processing the received replies.

```rust
use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session
    .get("key/expression?value>1")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result())
}
```

--------------------------------

### Start Peer Runtime

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html?search=

Initializes a peer node by binding listeners, connecting to peers, and optionally starting multicast scouting.

```rust
async fn start_peer(&self) -> ZResult<()> {
        let (listeners, peers, scouting, wait_scouting, listen, autoconnect, addr, ifaces, delay) = {
            let guard = &self.state.config.lock();
            (
                guard.listen().endpoints().peer().unwrap_or(&vec![]).clone(),
                guard
                    .connect()
                    .endpoints()
                    .peer()
                    .unwrap_or(&vec![])
                    .clone(),
                unwrap_or_default!(guard.scouting().multicast().enabled()),
                unwrap_or_default!(guard.open().return_conditions().connect_scouted()),
                *unwrap_or_default!(guard.scouting().multicast().listen().peer()),
                AutoConnect::multicast(guard, WhatAmI::Peer, self.zid().into()),
                unwrap_or_default!(guard.scouting().multicast().address()),
                unwrap_or_default!(guard.scouting().multicast().interface()),
                Duration::from_millis(unwrap_or_default!(guard.scouting().delay())),
            )
        };

        self.bind_listeners(&listeners).await?;

        self.connect_peers(&peers, false).await?;

        if scouting {
            self.start_scout(listen, autoconnect, addr, ifaces).await?;
        }

        if wait_scouting
            && (scouting || !peers.is_empty())
            && tokio::time::timeout(delay, self.state.start_conditions.notified())
                .await
                .is_err()
            && !peers.is_empty()
        {
            tracing::warn!("Scouting delay elapsed before start conditions are met.");
        }
        Ok(())
    }
```

--------------------------------

### Example of getting liveliness tokens

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/liveliness.rs.html

Demonstrates how to open a Zenoh session, query for liveliness tokens using a key expression, and process the received tokens asynchronously.

```rust
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let tokens = session
    .liveliness()
    .get("key/expression")
    .await
    .unwrap();
while let Ok(token) = tokens.recv_async().await {
    match token.result() {
        Ok(sample) => println!("Alive token ('{}')", sample.key_expr().as_str()),
        Err(err) => println!("Received (ERROR: '{:?}')", err.payload()),
    }
}
```

--------------------------------

### Start Router Configuration and Initialization

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html

Retrieves configuration for starting a router, including listeners, direct peers, and scouting settings. This snippet focuses on fetching the configuration values needed for router initialization.

```rust
async fn start_router(&self) -> ZResult<()> {
        let (listeners, peers, scouting, listen, autoconnect, addr, ifaces, delay) = {
            let guard = &self.state.config.lock();
            (
                guard
                    .listen()
                    .endpoints()
                    .router()
                    .unwrap_or(&vec![])
                    .clone(),
```

--------------------------------

### Load and Start Plugin

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/adminspace.rs.html

Handles loading and starting a plugin, with checks for already loaded or started plugins. Logs warnings if a plugin is already loaded or started, or if plugin loading is disabled.

```rust
        let mut loaded = if let Some(loaded) = declared.loaded_mut() {
            tracing::warn!(
                "Plugin `{}` was already loaded from {}",
                loaded.id(),
                loaded.path()
            );
            loaded
        } else {
            match declared.load()? {
                Some(loaded) => loaded,
                None => {
                    tracing::warn!(
                        "Plugin `{}` will not be loaded as plugin loading is disabled",
                        config.name
                    );
                    return Ok(())
                }
            }
        };

        if let Some(started) = loaded.started_mut() {
            tracing::warn!("Plugin `{}` was already started", started.id());
        } else {
            let started = loaded.start(start_args)?;
            tracing::info!(
                "Successfully started plugin `{}` from {}",
                started.id(),
                started.path()
            );
        };

        Ok(())
    }
```

--------------------------------

### Configure and execute a Zenoh GET operation

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/querier.rs.html?search=u32+-%3E+bool

Demonstrates how to declare a querier with specific consolidation and target settings, then perform a GET operation with parameters.

```rust
use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let replies = querier
    .get()
    .parameters("value>1")
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result())
}
```

--------------------------------

### Perform a basic GET operation

Source: https://docs.rs/zenoh/latest/zenoh/session/struct.SessionGetBuilder.html

Demonstrates a standard get request with consolidation and target configuration.

```rust
use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session
    .get("key/expression?value>1")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result())
}
```

--------------------------------

### Start Zenoh Runtime Based on Role

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html

Determines the role of the Zenoh instance (Client, Peer, or Router) and calls the appropriate startup function. This is the main entry point for starting the runtime.

```rust
    pub async fn start(&mut self) -> ZResult<()> {
        match self.whatami() {
            WhatAmI::Client => self.start_client().await,
            WhatAmI::Peer => self.start_peer().await,
            WhatAmI::Router => self.start_router().await,
        }
    }
```

--------------------------------

### Basic Sorting Example

Source: https://docs.rs/zenoh/latest/zenoh/shm/struct.ZShmMut.html?search=std%3A%3Avec

Demonstrates sorting a slice in ascending order.

```rust
v.sort();
assert_eq!(v, [-5, -3, 1, 2, 4]);
```

--------------------------------

### Examples of opening a zenoh session

Source: https://docs.rs/zenoh/latest/zenoh/fn.open.html?search=std%3A%3Avec

Demonstrates initializing a session with default settings or a custom configuration including specific endpoints and a ZenohId.

```rust
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
```

```rust
use std::str::FromStr;
use zenoh::session::ZenohId;

let mut config = zenoh::Config::default();
config.set_id(Some(ZenohId::from_str("221b72df20924c15b8794c6bdb471150").unwrap()));
config.connect.endpoints.set(
    ["tcp/10.10.10.10:7447", "tcp/11.11.11.11:7447"].iter().map(|s|s.parse().unwrap()).collect());

let session = zenoh::open(config).await.unwrap();
```

--------------------------------

### Trim Start Matches Examples

Source: https://docs.rs/zenoh/latest/zenoh/key_expr/struct.OwnedKeyExpr.html?search=

Examples of removing repeated prefixes matching a pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Trim start matches example

Source: https://docs.rs/zenoh/latest/zenoh/key_expr/struct.OwnedNonWildKeyExpr.html?search=std%3A%3Avec

Demonstrates trimming characters from the start of a string slice.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Configure Admin Space and Plugins

Source: https://docs.rs/zenoh/latest/zenoh/struct.Config.html?search=

Example configuration for enabling the admin space and setting up plugin loading paths and specific plugin settings.

```json5
  /// Configure the Admin Space
  /// Unstable: this configuration part works as advertised, but may change in a future release
  adminspace: {
    /// Enables the admin space
    enabled: false,
    /// read and/or write permissions on the admin space
    permissions: {
      read: true,
      write: false,
    },
  },

  //  ///
  //  /// Plugins configurations
  //  ///
  //  plugins_loading: {
  //    /// Enable plugins loading.
  //    enabled: false,
  //    /// Directories where plugins configured by name should be looked for. Plugins configured by __path__ are not subject to lookup.
  //    /// Directories are specified as object with fields `kind` and `value` is accepted.
  //    ///   1. If `kind` is `current_exe_parent`, then the parent of the current executable's directory is searched and `value` should be `null`.
  //    ///      In Bash notation, `{ "kind": "current_exe_parent" }` equals `$(dirname $(which zenohd))` while `"."` equals `$PWD`.
  //    ///   2. If `kind` is `path`, then `value` is interpreted as a filesystem path. Simply supplying a string instead of a object is equivalent to this.
  //    /// If `enabled: true` and `search_dirs` is not specified then `search_dirs` falls back to the default value:
  //    search_dirs: [{ "kind": "current_exe_parent" }, ".", "~/.zenoh/lib", "/opt/homebrew/lib", "/usr/local/lib", "/usr/lib"],
  //  },
  //  /// Plugins are only loaded if `plugins_loading: { enabled: true }` and present in the configuration when starting.
  //  /// Once loaded, they may react to changes in the configuration made through the zenoh instance's adminspace.
  //  plugins: {
  //    /// If no `__path__` is given to a plugin, zenohd will automatically search for a shared library matching the plugin's name (here, `libzenoh_plugin_rest.so` would be searched for on linux)
  //
  //    /// Plugin settings may contain field `__config__`
  //    /// - If `__config__` is specified, it's content is merged into plugin configuration
  //    /// - Properties loaded from `__config__` file overrides existing properties
  //    /// - If json objects in loaded file contains `__config__` properties, they are processed recursively
  //    ///   This is used in the 'storage_manager' which supports subplugins, each with it's own config
  //    ///
  //    /// See below example of plugin configuration using `__config__` property
  //
  //    /// Configure the REST API plugin
  //    rest: {
  //      /// Setting this option to true allows zenohd to panic should it detect issues with this plugin. Setting it to false politely asks the plugin not to panic.
  //      __required__: true, // defaults to false
  //      /// load configuration from the file
  //      __config__: "./plugins/zenoh-plugin-rest/config.json5",
  //      /// http port to answer to rest requests
  //      http_port: 8000,
  //      /// The number of worker thread in TOKIO runtime (default: 2)
  //      /// The configuration only takes effect if running as a dynamic plugin, which can not reuse the current runtime.
  //      work_thread_num: 2,
  //      /// The number of blocking thread in TOKIO runtime (default: 50)
  //      /// The configuration only takes effect if running as a dynamic plugin, which can not reuse the current runtime.
  //      max_block_thread_num: 50,
  //    },
  //
  //    /// Configure the storage manager plugin
  //    storage_manager: {
  //      /// When a path is present, automatic search is disabled, and zenohd will instead select the first path which manages to load.
  //      __path__: [
  //        "./target/release/libzenoh_plugin_storage_manager.so",
  //        "./target/release/libzenoh_plugin_storage_manager.dylib",
  //      ],
  //      /// Directories where plugins configured by name should be looked for. Plugins configured by __path__ are not subject to lookup
  //      backend_search_dirs: [],
  //      /// The "memory" volume is always available, but you may create other volumes here, with various backends to support the actual storing.
  //      volumes: {
  //        /// An influxdb backend is also available at https://github.com/eclipse-zenoh/zenoh-backend-influxdb
  //        influxdb: {
  //          url: "https://myinfluxdb.example",
  //          /// Some plugins may need passwords in their configuration.
  //          /// To avoid leaking them through the adminspace, they may be masked behind a privacy barrier.
  //          /// any value held at the key "private" will not be shown in the adminspace.
  //          private: {
  //            username: "user1",
  //            password: "pw1",
  //          },
  //        },
  //        influxdb2: {
  //          /// A second backend of the same type can be spawned using `__path__`, for examples when different DBs are needed.
  //          backend: "influxdb",
  //          private: {
  //            username: "user2",
```

--------------------------------

### Execute GET Operation

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/querier.rs.html?search=std%3A%3Avec

Example of using QuerierGetBuilder to perform a GET operation and process replies.

```rust
# #[tokio::main]
# async fn main() {
use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let replies = querier
    .get()
    .parameters("value>1")
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result())
}
# }
```

--------------------------------

### Client Startup Logic

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html?search=u32+-%3E+bool

Handles the initialization of a Zenoh client, including multicast scouting and peer connection management.

```rust
140                    .client()
141                    .unwrap_or(&vec![])
142                    .clone(),
143                guard
144                    .connect()
145                    .endpoints()
146                    .client()
147                    .unwrap_or(&vec![])
148                    .clone(),
149                unwrap_or_default!(guard.scouting().multicast().enabled()),
150                *unwrap_or_default!(guard.scouting().multicast().listen().client()),
151                *unwrap_or_default!(guard.scouting().multicast().autoconnect().client()),
152                unwrap_or_default!(guard.scouting().multicast().address()),
153                unwrap_or_default!(guard.scouting().multicast().interface()),
154                std::time::Duration::from_millis(unwrap_or_default!(guard.scouting().timeout())),
155                unwrap_or_default!(guard.scouting().multicast().ttl()),
156            )
157        };
158
159        self.bind_listeners(&listeners).await?;
160
161        if scouting {
162            if listen || peers.is_empty() {
163                let ifaces = Runtime::get_interfaces(&ifaces);
164                let mcast_socket = if listen {
165                    Some(Runtime::bind_mcast_port(&addr, &ifaces, multicast_ttl).await?)
166                } else {
167                    None
168                };
169                if ifaces.is_empty() {
170                    bail!("Unable to find multicast interface!")
171                } else {
172                    let sockets: Vec<UdpSocket> = ifaces
173                        .into_iter()
174                        .filter_map(|iface| Runtime::bind_ucast_port(iface, multicast_ttl).ok())
175                        .collect();
176                    if sockets.is_empty() {
177                        bail!("Unable to bind UDP port to any multicast interface!")
178                    } else {
179                        if peers.is_empty() {
180                            self.connect_first(&sockets, autoconnect, &addr, timeout)
181                                .await?
182                        }
183                        if let Some(mcast_socket) = mcast_socket {
184                            let this = self.clone();
185                            self.spawn_abortable(async move {
186                                this.responder(&mcast_socket, &sockets).await;
187                            });
188                        }
189                    }
190                }
191            }
192            if !peers.is_empty() {
193                self.connect_peers(&peers, true).await
194            } else {
195                Ok(())
196            }
197        } else if peers.is_empty() {
198            bail!("No peer specified and multicast scouting deactivated!")
199        } else {
200            self.connect_peers(&peers, true).await
201        }
202    }
```

--------------------------------

### Zenoh Configuration File Example

Source: https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html?search=u32+-%3E+bool

A template demonstrating the JSON5 structure for configuring Zenoh nodes, including connection endpoints and retry logic.

```json
/// This file attempts to list and document available configuration elements.
/// For a more complete view of the configuration's structure, check out `zenoh/src/config.rs`'s `Config` structure.
/// Note that the values here are correctly typed, but may not be sensible, so copying this file to change only the parts that matter to you is not good practice.
{
  /// The identifier (as unsigned 128bit integer in hexadecimal lowercase - leading zeros are not accepted)
  /// that zenoh runtime will use.
  /// If not set, a random unsigned 128bit integer will be used.
  /// WARNING: this id must be unique in your zenoh network.
  // id: "1234567890abcdef",

  /// The node's mode (router, peer or client)
  mode: "peer",

  /// The node's metadata (name, location, DNS name, etc.) Arbitrary JSON data not interpreted by zenoh and available in admin space @/<zid>/router, @/<zid>/peer or @/<zid>/client
  metadata: {
    name: "strawberry",
    location: "Penny Lane",
  },

  /// Which endpoints to connect to. E.g. tcp/localhost:7447.
  /// By configuring the endpoints, it is possible to tell zenoh which router/peer to connect to at startup.
  ///
  /// For TCP/UDP on Linux, it is possible additionally specify the interface to be connected to:
  /// E.g. tcp/192.168.0.1:7447#iface=eth0, for connect only if the IP address is reachable via the interface eth0
  ///
  /// It is also possible to specify a priority range and/or a reliability setting to be used on the link.
  /// For example `tcp/localhost?prio=6-7;rel=0` assigns priorities "data_low" and "background" to the established link.
  ///
  /// For TCP and TLS links, it is possible to specify the TCP buffer sizes:
  /// E.g. tcp/192.168.0.1:7447#so_sndbuf=65000;so_rcvbuf=65000
  /// For TCP, UDP, Quic and TLS links, it is possible to specify a `bind` address for the local socket:
  /// E.g. tcp/192.168.0.1:7447#bind=192.168.0.1:0
  ///  Note!: Currently it is unsupported to specify both `bind` and `iface`.
  ///
  /// For TCP/UDP links, it's possible to specify the DSCP field of the IP header:
  /// E.g. tcp/192.168.0.1:7447#dscp=0x08
  connect: {
    /// timeout waiting for all endpoints connected (0: no retry, -1: infinite timeout)
    /// Accepts a single value (e.g. timeout_ms: 0)
    /// or different values for router, peer and client (e.g. timeout_ms: { router: -1, peer: -1, client: 0 }).
    timeout_ms: { router: -1, peer: -1, client: 0 },

    /// The list of endpoints to connect to.
    /// Accepts a single list (e.g. endpoints: ["tcp/10.10.10.10:7447", "tcp/11.11.11.11:7447"])
    /// or different lists for router, peer and client (e.g. endpoints: { router: ["tcp/10.10.10.10:7447"], peer: ["tcp/11.11.11.11:7447"] }).
    ///
    /// See https://docs.rs/zenoh/latest/zenoh/config/struct.EndPoint.html
    endpoints: [
      // "<proto>/<address>"
    ],

    /// Global connect configuration,
    /// Accepts a single value or different values for router, peer and client.
    /// The configuration can also be specified for the separate endpoint
    /// it will override the global one
    /// E.g. tcp/192.168.0.1:7447#retry_period_init_ms=20000;retry_period_max_ms=10000"

    /// exit from application, if timeout exceed
    exit_on_failure: { router: false, peer: false, client: true },
    /// connect establishing retry configuration
    retry: {
      /// initial wait timeout until next connect try
      period_init_ms: 1000,
      /// maximum wait timeout until next connect try
      period_max_ms: 4000,
      /// increase factor for the next timeout until nexti connect try
      period_increase_factor: 2,
    },
  },
}
```

--------------------------------

### Execute a GET Operation with QuerierGetBuilder

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/querier.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to declare a querier and perform a GET operation with specific parameters.

```rust
#[tokio::main]
async fn main() {
    use zenoh::{query::{ConsolidationMode, QueryTarget}};

    let session = zenoh::open(zenoh::Config::default()).await.unwrap();
    let querier = session.declare_querier("key/expression")
        .target(QueryTarget::All)
        .consolidation(ConsolidationMode::None)
        .await
        .unwrap();
    let replies = querier
        .get()
        .parameters("value>1")
        .await
        .unwrap();
    while let Ok(reply) = replies.recv_async().await {
        println!("Received {:?}", reply.result())
    }
}
```

--------------------------------

### Zenoh Configuration File Example

Source: https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html

A template demonstrating the JSON structure for configuring Zenoh nodes, including mode, metadata, and connection settings.

```json
/// This file attempts to list and document available configuration elements.
/// For a more complete view of the configuration's structure, check out `zenoh/src/config.rs`'s `Config` structure.
/// Note that the values here are correctly typed, but may not be sensible, so copying this file to change only the parts that matter to you is not good practice.
{
  /// The identifier (as unsigned 128bit integer in hexadecimal lowercase - leading zeros are not accepted)
  /// that zenoh runtime will use.
  /// If not set, a random unsigned 128bit integer will be used.
  /// WARNING: this id must be unique in your zenoh network.
  // id: "1234567890abcdef",

  /// The node's mode (router, peer or client)
  mode: "peer",

  /// The node's metadata (name, location, DNS name, etc.) Arbitrary JSON data not interpreted by zenoh and available in admin space @/<zid>/router, @/<zid>/peer or @/<zid>/client
  metadata: {
    name: "strawberry",
    location: "Penny Lane",
  },

  /// Which endpoints to connect to. E.g. tcp/localhost:7447.
  /// By configuring the endpoints, it is possible to tell zenoh which router/peer to connect to at startup.
  ///
  /// For TCP/UDP on Linux, it is possible additionally specify the interface to be connected to:
  /// E.g. tcp/192.168.0.1:7447#iface=eth0, for connect only if the IP address is reachable via the interface eth0
  ///
  /// It is also possible to specify a priority range and/or a reliability setting to be used on the link.
  /// For example `tcp/localhost?prio=6-7;rel=0` assigns priorities "data_low" and "background" to the established link.
  ///
  /// For TCP and TLS links, it is possible to specify the TCP buffer sizes:
  /// E.g. tcp/192.168.0.1:7447#so_sndbuf=65000;so_rcvbuf=65000
  /// For TCP, UDP, Quic and TLS links, it is possible to specify a `bind` address for the local socket:
  /// E.g. tcp/192.168.0.1:7447#bind=192.168.0.1:0
  ///  Note!: Currently it is unsupported to specify both `bind` and `iface`.
  ///
  /// For TCP/UDP links, it's possible to specify the DSCP field of the IP header:
  /// E.g. tcp/192.168.0.1:7447#dscp=0x08
  connect: {
    /// timeout waiting for all endpoints connected (0: no retry, -1: infinite timeout)
    /// Accepts a single value (e.g. timeout_ms: 0)
    /// or different values for router, peer and client (e.g. timeout_ms: { router: -1, peer: -1, client: 0 }).
    timeout_ms: { router: -1, peer: -1, client: 0 },

    /// The list of endpoints to connect to.
    /// Accepts a single list (e.g. endpoints: ["tcp/10.10.10.10:7447", "tcp/11.11.11.11:7447"])
    /// or different lists for router, peer and client (e.g. endpoints: { router: ["tcp/10.10.10.10:7447"], peer: ["tcp/11.11.11.11:7447"] }).
    ///
    /// See https://docs.rs/zenoh/latest/zenoh/config/struct.EndPoint.html
    endpoints: [
      // "<proto>/<address>"
    ],

    /// Global connect configuration,
    /// Accepts a single value or different values for router, peer and client.
    /// The configuration can also be specified for the separate endpoint
    /// it will override the global one
    /// E.g. tcp/192.168.0.1:7447#retry_period_init_ms=20000;retry_period_max_ms=10000"

    /// exit from application, if timeout exceed
    exit_on_failure: { router: false, peer: false, client: true },
    /// connect establishing retry configuration
    retry: {
      /// initial wait timeout until next connect try
      period_init_ms: 1000,
      /// maximum wait timeout until next connect try
      period_max_ms: 4000,
      /// increase factor for the next timeout until nexti connect try
      period_increase_factor: 2,
    },
  },
```

--------------------------------

### Trim start matches usage

Source: https://docs.rs/zenoh/latest/zenoh/key_expr/struct.OwnedNonWildKeyExpr.html?search=

Examples of removing prefixes that match a specific pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

--------------------------------

### Router Startup Configuration

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html?search=u32+-%3E+bool

Partial configuration block for starting a Zenoh router.

```rust
245    async fn start_router(&self) -> ZResult<()> {
246        let (listeners, peers, scouting, listen, autoconnect, addr, ifaces, delay) = {
247            let guard = &self.state.config.lock();
248            (
249                guard
250                    .listen()
251                    .endpoints()
252                    .router()
```

--------------------------------

### Trim start example

Source: https://docs.rs/zenoh/latest/zenoh/key_expr/struct.OwnedNonWildKeyExpr.html?search=

Demonstrates trimming leading whitespace from a string containing Hebrew characters.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### Get mutable reference to first element

Source: https://docs.rs/zenoh/latest/zenoh/shm/struct.ZShmMut.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of retrieving a mutable reference to the first element.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

--------------------------------

### Initialize Router Runtime

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Partial implementation for starting a Zenoh router, focusing on configuration extraction.

```rust
async fn start_router(&self) -> ZResult<()> {
246        let (listeners, peers, scouting, listen, autoconnect, addr, ifaces, delay) = {
247            let guard = &self.state.config.lock();
248            (
249                guard
250                    .listen()
251                    .endpoints()
252                    .router()
```

--------------------------------

### Execute GET Operation and Receive Replies

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/querier.rs.html

Configures and executes a GET operation using a querier, returning a handler that yields replies. This example demonstrates setting query parameters and iterating through received replies.

```rust
# #[tokio::main]
# async fn main() {
# use zenoh::{query::{ConsolidationMode, QueryTarget}};
# 
# let session = zenoh::open(zenoh::Config::default()).await.unwrap();
# let querier = session.declare_querier("key/expression")
#     .target(QueryTarget::All)
#     .consolidation(ConsolidationMode::None)
#     .await
#     .unwrap();
# let replies = querier
#     .get()
#     .parameters("value>1")
#     .await
#     .unwrap();
# while let Ok(reply) = replies.recv_async().await {
#     println!("Received {:?}", reply.result())
# }
# }

```

--------------------------------

### Publishing and Subscribing with Zenoh

Source: https://docs.rs/zenoh/latest/zenoh/index.html?search=

Demonstrates how to initialize a Zenoh session to put data onto a key expression and how to declare a subscriber to receive data.

```rust
#[tokio::main]
async fn main() {
    let session = zenoh::open(zenoh::Config::default()).await.unwrap();
    session.put("key/expression", "value").await.unwrap();
    session.close().await.unwrap();
}
```

```rust
use futures::prelude::*;

#[tokio::main]
async fn main() {
    let session = zenoh::open(zenoh::Config::default()).await.unwrap();
    let subscriber = session.declare_subscriber("key/expression").await.unwrap();
    while let Ok(sample) = subscriber.recv_async().await {
        println!("Received: {:?}", sample);
    };
}
```

--------------------------------

### Trim ASCII Whitespace

Source: https://docs.rs/zenoh/latest/zenoh/shm/struct.ZShm.html

Examples of trimming ASCII whitespace from the start, end, or both sides of a byte slice.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

```rust
assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
assert_eq!(b"  ".trim_ascii_end(), b"");
assert_eq!(b"".trim_ascii_end(), b"");
```

```rust
assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
assert_eq!(b"  ".trim_ascii(), b"");
assert_eq!(b"".trim_ascii(), b"");
```

--------------------------------

### Open a Zenoh Session and Put Data

Source: https://docs.rs/zenoh/latest/src/zenoh/api/session.rs.html

Demonstrates how to open a Zenoh session with default configuration and then put a key-value pair. This is a common starting point for many Zenoh applications.

```rust
# #[tokio::main]
# async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
session.put("key/expression", "value").await.unwrap();
# }

```

--------------------------------

### Scout with Receiver

Source: https://docs.rs/zenoh/latest/src/zenoh/api/scouting.rs.html

This example shows how to create a scout that uses a receiver (e.g., from `flume`) to get 'Hello' messages.

```APIDOC
## scout with receiver

### Description
Creates a scout that sends 'Hello' messages and provides a receiver to retrieve incoming 'Hello' messages.

### Method Signature
`zenoh::scout(what: WhatAmIMatcher, config: Config) -> ScoutBuilder<Receiver>`

### Parameters
- `what` (WhatAmIMatcher): Specifies the types of entities to scout for (e.g., `WhatAmI::Peer | WhatAmI::Router`).
- `config` (Config): Zenoh configuration settings.

### Returns
A `ScoutBuilder` that can be configured with a receiver channel.

### Example
```rust
# #[tokio::main]
# async fn main() {
use zenoh::config::WhatAmI;

let receiver = zenoh::scout(WhatAmI::Peer | WhatAmI::Router, zenoh::Config::default())
    .with(flume::bounded(32))
    .await
    .unwrap();
while let Ok(hello) = receiver.recv_async().await {
    println!("{}", hello);
}
# }
```
```

--------------------------------

### Peer Startup Logic

Source: https://docs.rs/zenoh/latest/src/zenoh/net/runtime/orchestrator.rs.html?search=u32+-%3E+bool

Initializes a Zenoh peer, binding listeners and managing scouting delays.

```rust
204    async fn start_peer(&self) -> ZResult<()> {
205        let (listeners, peers, scouting, wait_scouting, listen, autoconnect, addr, ifaces, delay) = {
206            let guard = &self.state.config.lock();
207            (
208                guard.listen().endpoints().peer().unwrap_or(&vec![]).clone(),
209                guard
210                    .connect()
211                    .endpoints()
212                    .peer()
213                    .unwrap_or(&vec![])
214                    .clone(),
215                unwrap_or_default!(guard.scouting().multicast().enabled()),
216                unwrap_or_default!(guard.open().return_conditions().connect_scouted()),
217                *unwrap_or_default!(guard.scouting().multicast().listen().peer()),
218                AutoConnect::multicast(guard, WhatAmI::Peer, self.zid().into()),
219                unwrap_or_default!(guard.scouting().multicast().address()),
220                unwrap_or_default!(guard.scouting().multicast().interface()),
221                Duration::from_millis(unwrap_or_default!(guard.scouting().delay())),
222            )
223        };
224
225        self.bind_listeners(&listeners).await?;
226
227        self.connect_peers(&peers, false).await?;
228
229        if scouting {
230            self.start_scout(listen, autoconnect, addr, ifaces).await?;
231        }
232
233        if wait_scouting
234            && (scouting || !peers.is_empty())
235            && tokio::time::timeout(delay, self.state.start_conditions.notified())
236                .await
237                .is_err()
238            && !peers.is_empty()
239        {
240            tracing::warn!("Scouting delay elapsed before start conditions are met.");
241        }
242        Ok(())
243    }
```

--------------------------------

### Retrieve match indices in string slices

Source: https://docs.rs/zenoh/latest/zenoh/key_expr/struct.OwnedNonWildKeyExpr.html?search=

Use match_indices to get an iterator of disjoint matches along with their starting byte indices.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### Example of Joining KeyExprs

Source: https://docs.rs/zenoh/latest/src/zenoh/api/key_expr.rs.html

Demonstrates how to join two KeyExpr instances using the `join` method, resulting in a new KeyExpr with a '/' separator.

```rust
let prefix = KeyExpr::try_from("some/prefix").unwrap();
let suffix = KeyExpr::try_from("some/suffix").unwrap();
let join = prefix.join(&suffix).unwrap();
assert_eq!(join.as_str(), "some/prefix/some/suffix");
```

--------------------------------

### Get Listening Locators

Source: https://docs.rs/zenoh/latest/src/zenoh/api/info.rs.html

Retrieve the locators on which the current zenoh Session is listening. This example prints the list of locators, typically showing the address and port.

```rust
# #[tokio::main]
# async fn main() {

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
println!("{:?}", session.info().locators().await);
// print ["tcp/127.0.0.1:7447"]
# }

```

--------------------------------

### QoS Configuration

Source: https://docs.rs/zenoh/latest/zenoh/qos/index.html?search=std%3A%3Avec

Example of configuring QoS parameters when declaring a publisher in Zenoh.

```APIDOC
## QoS Configuration

### Description
Configures the Quality of Service settings for a Zenoh publisher using builder methods.

### Usage
```rust
let publisher = session.declare_publisher("key/expression")
  .reliability(zenoh::qos::Reliability::Reliable)
  .priority(zenoh::qos::Priority::InteractiveHigh)
  .congestion_control(zenoh::qos::CongestionControl::Block)
  .await.unwrap();
```
```

--------------------------------

### Get Suffix of Resource Expression

Source: https://docs.rs/zenoh/latest/src/zenoh/net/routing/dispatcher/resource.rs.html

Returns the suffix part of the resource's expression string. The suffix is determined by the `suffix` field, which indicates the starting index of the suffix within the `expr` string.

```rust
pub fn suffix(&self) -> &str {
        &self.expr[self.suffix..]
    }
```

--------------------------------

### init_log_from_env_or

Source: https://docs.rs/zenoh/latest/zenoh/index.html?search=

Utility function to initialize the tracing formatting subscriber based on environment variables.

```APIDOC
## Function: init_log_from_env_or

### Description
A utility function to enable the tracing formatting subscriber.
```

--------------------------------

### Initialize link events listener

Source: https://docs.rs/zenoh/latest/src/zenoh/api/builders/info_links.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of setting up a listener for link lifecycle events.

```rust
#[tokio::main]
async fn main() {
use zenoh::sample::SampleKind;

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let listener = session.info()
    .link_events_listener()
    .history(true)
```

--------------------------------

### SampleBuilder Configuration Methods

Source: https://docs.rs/zenoh/latest/zenoh/sample/struct.SampleBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for configuring payload, key expressions, and metadata for a Sample.

```rust
pub fn payload<IntoZBytes>(self, payload: IntoZBytes) -> Self
where IntoZBytes: Into<ZBytes>,
```

```rust
pub fn keyexpr<IntoKeyExpr>(self, key_expr: IntoKeyExpr) -> Self
where IntoKeyExpr: Into<KeyExpr<'static>>,
```

```rust
pub fn reliability(self, reliability: Reliability) -> Self
```

```rust
pub fn timestamp<U: Into<Option<Timestamp>>>(self, timestamp: U) -> Self
```

```rust
pub fn source_info<S: Into<Option<SourceInfo>>>(self, source_info: S) -> Self
```

```rust
pub fn attachment<U: Into<OptionZBytes>>(self, attachment: U) -> Self
```

```rust
pub fn congestion_control(self, congestion_control: CongestionControl) -> Self
```

```rust
pub fn priority(self, priority: Priority) -> Self
```

```rust
pub fn express(self, is_express: bool) -> Self
```

```rust
pub fn encoding<T: Into<Encoding>>(self, encoding: T) -> Self
```
Tokens:
Raw