Package: zenoh
Version: 1.7.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.2), zenoh-plugin-storage-manager (=1.7.2), zenohd (=1.7.2)
Filename: 1.7.2/zenoh_1.7.2_amd64.deb
Size: 12498
MD5sum: 3b7276c55ee866863cd5db3f7ca4648e
SHA1: 453be39206970242e20fdecb62af995a21196991
SHA256: b78d9d29861a686ba6c960d829ff546e8d9cef2f514bc99353934319e3d02125
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/)
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh Rust API
.
The crate `zenoh` provides the main implementation of the Zenoh network
protocol in Rust and the [API](https://docs.rs/zenoh/latest/zenoh/) to use it.
.
The primary features of Zenoh are
.
* Arbitrary network topology support
* Publish-subscribe and query-reply paradigms
* Support for a great variety of underlying network protocols
* Hierarchical keys with glob support (key expressions)
* Zero-copy data buffers
* Scouting for nodes in the network
* Monitor data availability (liveliness)
* Monitor the interest to published data (matching)
* Shared memory support
* Compact and efficient platform-independent data serialization and
deserialization (in [zenoh-ext](../zenoh-ext))
* Components for reliable data publishing with retransmissions
(AdvancedSubscriber in [zenoh-ext](../zenoh-ext))
.
# Usage Examples
.
## Publish and subscribe
.
Publishing 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();
}
```
.
Subscribing to data:
.
```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);
};
}
```
.
## Query and reply
.
Declare a queryable:
.
```rust
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session.declare_queryable("key/expression").await.unwrap();
while let Ok(query) = queryable.recv_async().await {
query.reply("key/expression", "value").await.unwrap();
}
}
```
.
Request data:
.
```rust
use futures::prelude::*;
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session.get("key/expression").await.unwrap();
while let Ok(reply) = replies.recv_async().await {
println!(">> Received {:?}", reply.result());
}
}
```
.
# Rust 1.75 support
.
The crate `zenoh` can be compiled with Rust 1.75.0, but some of its
dependencies may require higher Rust versions.
To compile `zenoh` with Rust 1.75, add a dependency on the crate
[zenoh-pinned-deps-1-75](http://crates.io/crates/zenoh-pinned-deps-1-75) to
your `Cargo.toml`:
.
```toml
zenoh = "1.5.1"
zenoh-pinned-deps-1-75 = "1.5.1"
```
.
# Documentation and examples
.
For more information, see its documentation:
and some examples of usage in
Package: zenoh
Version: 1.7.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.2), zenoh-plugin-storage-manager (=1.7.2), zenohd (=1.7.2)
Filename: 1.7.2/zenoh_1.7.2_armel.deb
Size: 12498
MD5sum: e898afd3770cb2a64add179dd39ecdb3
SHA1: 1f2f2d48a4367935d62abff697ac1c5c9ad3a81b
SHA256: 8400f3313e2606a240fe91e0341f699d8a279b1fef40413fa6d59ac21c2d20ad
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/)
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh Rust API
.
The crate `zenoh` provides the main implementation of the Zenoh network
protocol in Rust and the [API](https://docs.rs/zenoh/latest/zenoh/) to use it.
.
The primary features of Zenoh are
.
* Arbitrary network topology support
* Publish-subscribe and query-reply paradigms
* Support for a great variety of underlying network protocols
* Hierarchical keys with glob support (key expressions)
* Zero-copy data buffers
* Scouting for nodes in the network
* Monitor data availability (liveliness)
* Monitor the interest to published data (matching)
* Shared memory support
* Compact and efficient platform-independent data serialization and
deserialization (in [zenoh-ext](../zenoh-ext))
* Components for reliable data publishing with retransmissions
(AdvancedSubscriber in [zenoh-ext](../zenoh-ext))
.
# Usage Examples
.
## Publish and subscribe
.
Publishing 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();
}
```
.
Subscribing to data:
.
```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);
};
}
```
.
## Query and reply
.
Declare a queryable:
.
```rust
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session.declare_queryable("key/expression").await.unwrap();
while let Ok(query) = queryable.recv_async().await {
query.reply("key/expression", "value").await.unwrap();
}
}
```
.
Request data:
.
```rust
use futures::prelude::*;
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session.get("key/expression").await.unwrap();
while let Ok(reply) = replies.recv_async().await {
println!(">> Received {:?}", reply.result());
}
}
```
.
# Rust 1.75 support
.
The crate `zenoh` can be compiled with Rust 1.75.0, but some of its
dependencies may require higher Rust versions.
To compile `zenoh` with Rust 1.75, add a dependency on the crate
[zenoh-pinned-deps-1-75](http://crates.io/crates/zenoh-pinned-deps-1-75) to
your `Cargo.toml`:
.
```toml
zenoh = "1.5.1"
zenoh-pinned-deps-1-75 = "1.5.1"
```
.
# Documentation and examples
.
For more information, see its documentation:
and some examples of usage in
Package: zenoh
Version: 1.7.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.2), zenoh-plugin-storage-manager (=1.7.2), zenohd (=1.7.2)
Filename: 1.7.2/zenoh_1.7.2_armhf.deb
Size: 12498
MD5sum: 36243491f67e399a136e245fc8f4fbcc
SHA1: eebbc8315573a8a360c937979360d8537e0bdc7f
SHA256: 756f74034465e23cdf5970f031c832a4447bf64369d239ab02591c6185b96b05
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/)
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh Rust API
.
The crate `zenoh` provides the main implementation of the Zenoh network
protocol in Rust and the [API](https://docs.rs/zenoh/latest/zenoh/) to use it.
.
The primary features of Zenoh are
.
* Arbitrary network topology support
* Publish-subscribe and query-reply paradigms
* Support for a great variety of underlying network protocols
* Hierarchical keys with glob support (key expressions)
* Zero-copy data buffers
* Scouting for nodes in the network
* Monitor data availability (liveliness)
* Monitor the interest to published data (matching)
* Shared memory support
* Compact and efficient platform-independent data serialization and
deserialization (in [zenoh-ext](../zenoh-ext))
* Components for reliable data publishing with retransmissions
(AdvancedSubscriber in [zenoh-ext](../zenoh-ext))
.
# Usage Examples
.
## Publish and subscribe
.
Publishing 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();
}
```
.
Subscribing to data:
.
```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);
};
}
```
.
## Query and reply
.
Declare a queryable:
.
```rust
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session.declare_queryable("key/expression").await.unwrap();
while let Ok(query) = queryable.recv_async().await {
query.reply("key/expression", "value").await.unwrap();
}
}
```
.
Request data:
.
```rust
use futures::prelude::*;
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session.get("key/expression").await.unwrap();
while let Ok(reply) = replies.recv_async().await {
println!(">> Received {:?}", reply.result());
}
}
```
.
# Rust 1.75 support
.
The crate `zenoh` can be compiled with Rust 1.75.0, but some of its
dependencies may require higher Rust versions.
To compile `zenoh` with Rust 1.75, add a dependency on the crate
[zenoh-pinned-deps-1-75](http://crates.io/crates/zenoh-pinned-deps-1-75) to
your `Cargo.toml`:
.
```toml
zenoh = "1.5.1"
zenoh-pinned-deps-1-75 = "1.5.1"
```
.
# Documentation and examples
.
For more information, see its documentation:
and some examples of usage in
Package: zenoh
Version: 1.7.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.2), zenoh-plugin-storage-manager (=1.7.2), zenohd (=1.7.2)
Filename: 1.7.2/zenoh_1.7.2_arm64.deb
Size: 12498
MD5sum: 66043d3d117fd7d665c98f11e53778c3
SHA1: 1824a00d1adc7d26ac2d26fc4cd24c3c866f3165
SHA256: 2495d421463831dad7c67ecf3aaf4e7fb0c9472fd03a23043ab79a74e8ae89ec
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/)
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh Rust API
.
The crate `zenoh` provides the main implementation of the Zenoh network
protocol in Rust and the [API](https://docs.rs/zenoh/latest/zenoh/) to use it.
.
The primary features of Zenoh are
.
* Arbitrary network topology support
* Publish-subscribe and query-reply paradigms
* Support for a great variety of underlying network protocols
* Hierarchical keys with glob support (key expressions)
* Zero-copy data buffers
* Scouting for nodes in the network
* Monitor data availability (liveliness)
* Monitor the interest to published data (matching)
* Shared memory support
* Compact and efficient platform-independent data serialization and
deserialization (in [zenoh-ext](../zenoh-ext))
* Components for reliable data publishing with retransmissions
(AdvancedSubscriber in [zenoh-ext](../zenoh-ext))
.
# Usage Examples
.
## Publish and subscribe
.
Publishing 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();
}
```
.
Subscribing to data:
.
```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);
};
}
```
.
## Query and reply
.
Declare a queryable:
.
```rust
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session.declare_queryable("key/expression").await.unwrap();
while let Ok(query) = queryable.recv_async().await {
query.reply("key/expression", "value").await.unwrap();
}
}
```
.
Request data:
.
```rust
use futures::prelude::*;
#[tokio::main]
async fn main() {
let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let replies = session.get("key/expression").await.unwrap();
while let Ok(reply) = replies.recv_async().await {
println!(">> Received {:?}", reply.result());
}
}
```
.
# Rust 1.75 support
.
The crate `zenoh` can be compiled with Rust 1.75.0, but some of its
dependencies may require higher Rust versions.
To compile `zenoh` with Rust 1.75, add a dependency on the crate
[zenoh-pinned-deps-1-75](http://crates.io/crates/zenoh-pinned-deps-1-75) to
your `Cargo.toml`:
.
```toml
zenoh = "1.5.1"
zenoh-pinned-deps-1-75 = "1.5.1"
```
.
# Documentation and examples
.
For more information, see its documentation:
and some examples of usage in
Package: zenoh-plugin-rest
Version: 1.7.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3599
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-rest_1.7.2_arm64.deb
Size: 997602
MD5sum: dc559eb2e938904aad1b0564ee9bc51b
SHA1: 0828c9778a497cb1cd6d049e944cc695761cd6a9
SHA256: 4838815fd489d79d2936c7a82aa009437cdc8b9c67461e1f5ef0e1f8c154fa5d
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh REST plugin
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
The Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# REST Plugin for `zenohd` router
.
The plugin exposes a [REST API](https://zenoh.io/docs/apis/rest/) in
[zenohd](https://crates.io/crates/zenohd).
The `zenohd` links this plugin statically, it's not necessary to install it. To
activate the REST plugin
the CLI argument `--rest-http-port=` should be passed to `zenohd`.
.
The port can also be configured in the plugin configuration in the `plugins`
section
of the [config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
```json
"plugins": {
"rest": {
"http_port": 8000,
}
}
```
.
This plugin translates `PUT` and `DELETE` REST operations into the pub/sub API
and `GET` operations to the query/reply API.
.
For example:
.
```bash
cargo run -- --config DEFAULT_CONFIG.json5 --rest-http-port 8000
```
.
```bash
cargo run --example z_sub -- -k foo/bar
```
.
```bash
curl -X PUT -d '"Hello World!"' http://localhost:8080/foo/bar
```
.
The subscriber in `z_sub` example prints
.
```bash
>> [Subscriber] Received PUT ('foo/bar': '"Hello World!"')
```
.
```bash
cargo run --example z_queryable -- -k foo/bar
```
.
```bash
curl http://localhost:8080/foo/bar
```
.
The queryable `z_get` prints
.
```bash
>> [Queryable ] Received Query 'foo/bar'
>> [Queryable ] Responding ('foo/bar': 'Queryable from Rust!')
```
.
and `curl` prints
.
```bash
[{"key":"foo/bar","value":"UXVlcnlhYmxlIGZyb20gUnVzdCE=","encoding":"zenoh/bytes","timestamp":null}]
```
.
See also examples of using REST API for storages in the
[zenoh-plugin-storage-manager](https://crates.io/crates/zenoh-plugin-storage-manager).
Package: zenoh-plugin-rest
Version: 1.7.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3586
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-rest_1.7.2_armel.deb
Size: 1045418
MD5sum: caf2e43c1c4ff4b75bfaa0a5a623e061
SHA1: 78082e2f38954eca5172077393d0518f4cb89e05
SHA256: 34667efd378f6b766db9a02573ad7dbc9a38af7c666a508237f038e5e191ccf6
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh REST plugin
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
The Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# REST Plugin for `zenohd` router
.
The plugin exposes a [REST API](https://zenoh.io/docs/apis/rest/) in
[zenohd](https://crates.io/crates/zenohd).
The `zenohd` links this plugin statically, it's not necessary to install it. To
activate the REST plugin
the CLI argument `--rest-http-port=` should be passed to `zenohd`.
.
The port can also be configured in the plugin configuration in the `plugins`
section
of the [config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
```json
"plugins": {
"rest": {
"http_port": 8000,
}
}
```
.
This plugin translates `PUT` and `DELETE` REST operations into the pub/sub API
and `GET` operations to the query/reply API.
.
For example:
.
```bash
cargo run -- --config DEFAULT_CONFIG.json5 --rest-http-port 8000
```
.
```bash
cargo run --example z_sub -- -k foo/bar
```
.
```bash
curl -X PUT -d '"Hello World!"' http://localhost:8080/foo/bar
```
.
The subscriber in `z_sub` example prints
.
```bash
>> [Subscriber] Received PUT ('foo/bar': '"Hello World!"')
```
.
```bash
cargo run --example z_queryable -- -k foo/bar
```
.
```bash
curl http://localhost:8080/foo/bar
```
.
The queryable `z_get` prints
.
```bash
>> [Queryable ] Received Query 'foo/bar'
>> [Queryable ] Responding ('foo/bar': 'Queryable from Rust!')
```
.
and `curl` prints
.
```bash
[{"key":"foo/bar","value":"UXVlcnlhYmxlIGZyb20gUnVzdCE=","encoding":"zenoh/bytes","timestamp":null}]
```
.
See also examples of using REST API for storages in the
[zenoh-plugin-storage-manager](https://crates.io/crates/zenoh-plugin-storage-manager).
Package: zenoh-plugin-rest
Version: 1.7.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3514
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-rest_1.7.2_armhf.deb
Size: 1036718
MD5sum: 391b5201cef78f1b49888e4481368af1
SHA1: f427e1bb8a3f7127a174cad8ced945cc2fcfc55a
SHA256: cdbc5cea540dfe8e4c5b96cc4afd16d9bf2132efdcf053ea6415edd82a8271b8
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh REST plugin
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
The Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# REST Plugin for `zenohd` router
.
The plugin exposes a [REST API](https://zenoh.io/docs/apis/rest/) in
[zenohd](https://crates.io/crates/zenohd).
The `zenohd` links this plugin statically, it's not necessary to install it. To
activate the REST plugin
the CLI argument `--rest-http-port=` should be passed to `zenohd`.
.
The port can also be configured in the plugin configuration in the `plugins`
section
of the [config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
```json
"plugins": {
"rest": {
"http_port": 8000,
}
}
```
.
This plugin translates `PUT` and `DELETE` REST operations into the pub/sub API
and `GET` operations to the query/reply API.
.
For example:
.
```bash
cargo run -- --config DEFAULT_CONFIG.json5 --rest-http-port 8000
```
.
```bash
cargo run --example z_sub -- -k foo/bar
```
.
```bash
curl -X PUT -d '"Hello World!"' http://localhost:8080/foo/bar
```
.
The subscriber in `z_sub` example prints
.
```bash
>> [Subscriber] Received PUT ('foo/bar': '"Hello World!"')
```
.
```bash
cargo run --example z_queryable -- -k foo/bar
```
.
```bash
curl http://localhost:8080/foo/bar
```
.
The queryable `z_get` prints
.
```bash
>> [Queryable ] Received Query 'foo/bar'
>> [Queryable ] Responding ('foo/bar': 'Queryable from Rust!')
```
.
and `curl` prints
.
```bash
[{"key":"foo/bar","value":"UXVlcnlhYmxlIGZyb20gUnVzdCE=","encoding":"zenoh/bytes","timestamp":null}]
```
.
See also examples of using REST API for storages in the
[zenoh-plugin-storage-manager](https://crates.io/crates/zenoh-plugin-storage-manager).
Package: zenoh-plugin-rest
Version: 1.7.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3561
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-rest_1.7.2_amd64.deb
Size: 1085738
MD5sum: 9d2a1b1b7fd41a6baf860e0aa5125d9e
SHA1: b001aeedaaae7b2449ccf46f32dfd53410fc6e3c
SHA256: e461648ac5a83e92aabebc98cfbca5ccbf36c7e402ab1e484ba798899b1956b0
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh REST plugin
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
The Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# REST Plugin for `zenohd` router
.
The plugin exposes a [REST API](https://zenoh.io/docs/apis/rest/) in
[zenohd](https://crates.io/crates/zenohd).
The `zenohd` links this plugin statically, it's not necessary to install it. To
activate the REST plugin
the CLI argument `--rest-http-port=` should be passed to `zenohd`.
.
The port can also be configured in the plugin configuration in the `plugins`
section
of the [config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
```json
"plugins": {
"rest": {
"http_port": 8000,
}
}
```
.
This plugin translates `PUT` and `DELETE` REST operations into the pub/sub API
and `GET` operations to the query/reply API.
.
For example:
.
```bash
cargo run -- --config DEFAULT_CONFIG.json5 --rest-http-port 8000
```
.
```bash
cargo run --example z_sub -- -k foo/bar
```
.
```bash
curl -X PUT -d '"Hello World!"' http://localhost:8080/foo/bar
```
.
The subscriber in `z_sub` example prints
.
```bash
>> [Subscriber] Received PUT ('foo/bar': '"Hello World!"')
```
.
```bash
cargo run --example z_queryable -- -k foo/bar
```
.
```bash
curl http://localhost:8080/foo/bar
```
.
The queryable `z_get` prints
.
```bash
>> [Queryable ] Received Query 'foo/bar'
>> [Queryable ] Responding ('foo/bar': 'Queryable from Rust!')
```
.
and `curl` prints
.
```bash
[{"key":"foo/bar","value":"UXVlcnlhYmxlIGZyb20gUnVzdCE=","encoding":"zenoh/bytes","timestamp":null}]
```
.
See also examples of using REST API for storages in the
[zenoh-plugin-storage-manager](https://crates.io/crates/zenoh-plugin-storage-manager).
Package: zenoh-plugin-storage-manager
Version: 1.7.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3486
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-storage-manager_1.7.2_armel.deb
Size: 1023994
MD5sum: fb3b482423cdbedce5bf913651817cec
SHA1: 74c3fbde9c7b4dd8267414dae8a876b835334a21
SHA256: 76896b9286b6c5b4e89abd84e269e03756703ae85bf4ee29cebff4e0c4d2bdba
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh storages plugin.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounced _/zeno/_) unifies data in motion, data at rest, and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries, and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Storage manager plugin for `zenohd` router
.
A plugin that allows connecting `zenohd` to different storages (e.g.,
databases). This plugin is a plugin manager
itself that loads its own plugins - `backends` - specific for the external
storage API.
.
## Backends available
.
- `memory` backend
.
Stores data in a hashmap in memory, statically linked to the storage
manager.
.
-
[zenoh-backend-filesystem](https://github.com/eclipse-zenoh/zenoh-backend-filesystem/)
.
This backend relies on the host's file system to implement the storages.
.
- [zenoh-backend-s3](https://github.com/eclipse-zenoh/zenoh-backend-s3/)
.
This backend relies on [Amazon S3](https://aws.amazon.com/s3/?nc1=h_ls) to
implement the storages. It is also compatible with [MinIO](https://min.io/)
object storage.
.
-
[zenoh-backend-rocksdb](https://github.com/eclipse-zenoh/zenoh-backend-rocksdb/)
.
This backend relies on [RocksDB](https://rocksdb.org/) to implement the
storages.
.
-
[zenoh-backend-influxdb](https://github.com/eclipse-zenoh/zenoh-backend-influxdb/)
.
This backend relies on
[InfluxDB](https://www.influxdata.com/products/influxdb/) server
to implement the storages.
.
## Configuring storages
.
The storages are configured in the storage manager plugin configuration in the
`plugins` section of the
[config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
There are two concepts in the storage manager: "volumes" and "storages".
.
The "volume" is a specific database backend plugin (memory, s3, rocksdb, etc.)
plus
a concrete backend configuration (database name, username, password, etc.).
.
The "storage" is a mapping from a glob key expression to a volume, defining
where data
for each path is stored.
.
Here is a simple example config that sets up two storages. The `__path__`
explicitly
sets up paths to dynamic plugins for different platforms.
.
```json
"plugins": {
"storage_manager": {
"volumes": {
"example": {
"__path__":
["target/debug/libzenoh_backend_example.so","target/debug/libzenoh_backend_example.dylib"],
}
},
"storages": {
"memory": {
"volume": "memory",
"key_expr": "demo/memory/**"
},
"example": {
"volume": "example",
"key_expr": "demo/example/**"
}
}
}
}
```
.
## Usage of storages
.
Assume that we are in the root of the
[zenoh](https://github.com/eclipse-zenoh/zenoh) repository.
Uncomment the following part in the `DEFAULT_CONFIG.json5` which demonstrates
using
external plugin config files.
.
```json
"plugins|": {
"rest": {
"__config__": "./plugins/zenoh-plugin-rest/config.json5",
},
"storage_manager": {
"__config__": "./plugins/zenoh-plugin-storage-manager/config.json5",
}
},
```
.
Also either change option `timestamping -> enabled -> peer` to `true` or change
the `mode` to `router` to enable message
timestamping which is required by storage manager.
.
Run the `zenohd` router with adminspace write permissions enabled:
.
```bash
RUST_LOG=info cargo run -- --config DEFAULT_CONFIG.json5
--adminspace-permissions rw
```
.
The `RUST_LOG=info` is important to enable logging from
`zenoh_plugin_storage_manager` itself. Otherwise, the logs from plugins are
suppressed.
.
The adminspace write permissions allow you to manage storages dynamically at
runtime via the admin space REST API. See the example at the end.
.
Verify that the plugin loaded successfully: the output should contain lines
like:
.
```sh
2025-10-02T13:33:38.279758Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "rest"
2025-10-02T13:33:38.530621Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "storage_manager"
2025-10-02T13:33:38.787932Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "rest"
2025-10-02T13:33:38.795413Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin rest from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_rest.dylib"
2025-10-02T13:33:38.795433Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
2025-10-02T13:33:38.795441Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "storage_manager"
2025-10-02T13:33:38.801661Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'memory' with backend 'memory'
2025-10-02T13:33:38.802118Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'example' with backend 'example'
2025-10-02T13:33:38.925730Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'example' from volume 'example' with backend 'example'
2025-10-02T13:33:38.926759Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'memory' from volume 'memory' with backend 'memory'
2025-10-02T13:33:38.926833Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin storage_manager from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_storage_manager.dylib"
2025-10-02T13:33:38.926860Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
```
.
Now we can store and retrieve data. This can be done by zenoh `put` and `get`
operations as well as using [REST](https://crates.io/crates/zenoh-plugin-rest)
API.
.
### Store and retrieve data
.
#### Using zenoh operations
.
Store some data using put:
.
```bash
cargo run --example z_put -- -k demo/memory/test -p 'Hello from zenoh put'
```
.
Then query the stored data:
.
```bash
cargo run --example z_get -- -s "demo/memory/test"
```
.
Expected output with the stored data
.
```console
>> Received ('demo/memory/test': 'Hello from zenoh put')
```
.
Notice that this would not work without storage enabled. The `put` operation
belongs to the publish/subscribe API, while the `get` is part of the
query/reply API.
It's the storage that runs a subscriber and querier for its key expression. In
other words, storages link pub/sub and query/reply APIs together in
the Zenoh network.
.
#### Using REST API
.
Store data via REST PUT:
.
```bash
curl -X PUT -d '"Hello from REST"' -H "Content-Type: application/json"
http://localhost:8080/demo/memory/test
```
.
Retrieve data via REST GET:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output:
.
```json
[{"key":"demo/memory/test","value":"Hello from
REST","encoding":"application/json","timestamp":"7556630592622444272/d3f8913b8af0c842078d30652a04bd8f"}]
```
.
**Note**: Use the `application/json` content type and quoted value in `PUT` to
get data as a string value in `GET` json output. Otherwise, the value is
base-64 encoded to
ensure correctness of the json format.
.
Delete stored data with REST DELETE:
.
```bash
curl -X DELETE http://localhost:8080/demo/memory/test
```
.
You can verify the deletion by querying the key again:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output (empty array, indicating no data found):
.
```json
[]
```
.
### Using the admin space to manage storages
.
You can manage storages dynamically via the admin space - the predefined key
expression starting with `@/`.
.
To view current storages:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
.
Expected output (showing active storages):
.
```json
[
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/memory",
"value": {
"key_expr": "demo/memory/**",
"volume": "memory"
},
"encoding": "application/json",
"timestamp": null
},
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/example",
"value": null,
"encoding": "application/json",
"timestamp": null
}
]
```
.
Add another memory storage dynamically:
.
```bash
curl -X PUT -H 'content-type:application/json' \
-d '{"key_expr":"demo/sensors/**","volume":"memory"}' \
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/sensors
```
.
Delete example storage dynamically:
.
```bash
curl -X DELETE
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/example
```
.
Verify the new memory storage is created and the example storage is deleted:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
Package: zenoh-plugin-storage-manager
Version: 1.7.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3396
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-storage-manager_1.7.2_armhf.deb
Size: 1011230
MD5sum: b594e42e97f714dcb6d9ea0133adc45a
SHA1: 9ba0d339671a280e2ee030de817939646d3eaa91
SHA256: 82ede72d48860d6c01fa0ad922035b18b7dc7ad4351291b76934e716e22cbf91
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh storages plugin.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounced _/zeno/_) unifies data in motion, data at rest, and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries, and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Storage manager plugin for `zenohd` router
.
A plugin that allows connecting `zenohd` to different storages (e.g.,
databases). This plugin is a plugin manager
itself that loads its own plugins - `backends` - specific for the external
storage API.
.
## Backends available
.
- `memory` backend
.
Stores data in a hashmap in memory, statically linked to the storage
manager.
.
-
[zenoh-backend-filesystem](https://github.com/eclipse-zenoh/zenoh-backend-filesystem/)
.
This backend relies on the host's file system to implement the storages.
.
- [zenoh-backend-s3](https://github.com/eclipse-zenoh/zenoh-backend-s3/)
.
This backend relies on [Amazon S3](https://aws.amazon.com/s3/?nc1=h_ls) to
implement the storages. It is also compatible with [MinIO](https://min.io/)
object storage.
.
-
[zenoh-backend-rocksdb](https://github.com/eclipse-zenoh/zenoh-backend-rocksdb/)
.
This backend relies on [RocksDB](https://rocksdb.org/) to implement the
storages.
.
-
[zenoh-backend-influxdb](https://github.com/eclipse-zenoh/zenoh-backend-influxdb/)
.
This backend relies on
[InfluxDB](https://www.influxdata.com/products/influxdb/) server
to implement the storages.
.
## Configuring storages
.
The storages are configured in the storage manager plugin configuration in the
`plugins` section of the
[config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
There are two concepts in the storage manager: "volumes" and "storages".
.
The "volume" is a specific database backend plugin (memory, s3, rocksdb, etc.)
plus
a concrete backend configuration (database name, username, password, etc.).
.
The "storage" is a mapping from a glob key expression to a volume, defining
where data
for each path is stored.
.
Here is a simple example config that sets up two storages. The `__path__`
explicitly
sets up paths to dynamic plugins for different platforms.
.
```json
"plugins": {
"storage_manager": {
"volumes": {
"example": {
"__path__":
["target/debug/libzenoh_backend_example.so","target/debug/libzenoh_backend_example.dylib"],
}
},
"storages": {
"memory": {
"volume": "memory",
"key_expr": "demo/memory/**"
},
"example": {
"volume": "example",
"key_expr": "demo/example/**"
}
}
}
}
```
.
## Usage of storages
.
Assume that we are in the root of the
[zenoh](https://github.com/eclipse-zenoh/zenoh) repository.
Uncomment the following part in the `DEFAULT_CONFIG.json5` which demonstrates
using
external plugin config files.
.
```json
"plugins|": {
"rest": {
"__config__": "./plugins/zenoh-plugin-rest/config.json5",
},
"storage_manager": {
"__config__": "./plugins/zenoh-plugin-storage-manager/config.json5",
}
},
```
.
Also either change option `timestamping -> enabled -> peer` to `true` or change
the `mode` to `router` to enable message
timestamping which is required by storage manager.
.
Run the `zenohd` router with adminspace write permissions enabled:
.
```bash
RUST_LOG=info cargo run -- --config DEFAULT_CONFIG.json5
--adminspace-permissions rw
```
.
The `RUST_LOG=info` is important to enable logging from
`zenoh_plugin_storage_manager` itself. Otherwise, the logs from plugins are
suppressed.
.
The adminspace write permissions allow you to manage storages dynamically at
runtime via the admin space REST API. See the example at the end.
.
Verify that the plugin loaded successfully: the output should contain lines
like:
.
```sh
2025-10-02T13:33:38.279758Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "rest"
2025-10-02T13:33:38.530621Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "storage_manager"
2025-10-02T13:33:38.787932Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "rest"
2025-10-02T13:33:38.795413Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin rest from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_rest.dylib"
2025-10-02T13:33:38.795433Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
2025-10-02T13:33:38.795441Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "storage_manager"
2025-10-02T13:33:38.801661Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'memory' with backend 'memory'
2025-10-02T13:33:38.802118Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'example' with backend 'example'
2025-10-02T13:33:38.925730Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'example' from volume 'example' with backend 'example'
2025-10-02T13:33:38.926759Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'memory' from volume 'memory' with backend 'memory'
2025-10-02T13:33:38.926833Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin storage_manager from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_storage_manager.dylib"
2025-10-02T13:33:38.926860Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
```
.
Now we can store and retrieve data. This can be done by zenoh `put` and `get`
operations as well as using [REST](https://crates.io/crates/zenoh-plugin-rest)
API.
.
### Store and retrieve data
.
#### Using zenoh operations
.
Store some data using put:
.
```bash
cargo run --example z_put -- -k demo/memory/test -p 'Hello from zenoh put'
```
.
Then query the stored data:
.
```bash
cargo run --example z_get -- -s "demo/memory/test"
```
.
Expected output with the stored data
.
```console
>> Received ('demo/memory/test': 'Hello from zenoh put')
```
.
Notice that this would not work without storage enabled. The `put` operation
belongs to the publish/subscribe API, while the `get` is part of the
query/reply API.
It's the storage that runs a subscriber and querier for its key expression. In
other words, storages link pub/sub and query/reply APIs together in
the Zenoh network.
.
#### Using REST API
.
Store data via REST PUT:
.
```bash
curl -X PUT -d '"Hello from REST"' -H "Content-Type: application/json"
http://localhost:8080/demo/memory/test
```
.
Retrieve data via REST GET:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output:
.
```json
[{"key":"demo/memory/test","value":"Hello from
REST","encoding":"application/json","timestamp":"7556630592622444272/d3f8913b8af0c842078d30652a04bd8f"}]
```
.
**Note**: Use the `application/json` content type and quoted value in `PUT` to
get data as a string value in `GET` json output. Otherwise, the value is
base-64 encoded to
ensure correctness of the json format.
.
Delete stored data with REST DELETE:
.
```bash
curl -X DELETE http://localhost:8080/demo/memory/test
```
.
You can verify the deletion by querying the key again:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output (empty array, indicating no data found):
.
```json
[]
```
.
### Using the admin space to manage storages
.
You can manage storages dynamically via the admin space - the predefined key
expression starting with `@/`.
.
To view current storages:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
.
Expected output (showing active storages):
.
```json
[
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/memory",
"value": {
"key_expr": "demo/memory/**",
"volume": "memory"
},
"encoding": "application/json",
"timestamp": null
},
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/example",
"value": null,
"encoding": "application/json",
"timestamp": null
}
]
```
.
Add another memory storage dynamically:
.
```bash
curl -X PUT -H 'content-type:application/json' \
-d '{"key_expr":"demo/sensors/**","volume":"memory"}' \
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/sensors
```
.
Delete example storage dynamically:
.
```bash
curl -X DELETE
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/example
```
.
Verify the new memory storage is created and the example storage is deleted:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
Package: zenoh-plugin-storage-manager
Version: 1.7.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3458
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-storage-manager_1.7.2_amd64.deb
Size: 1043150
MD5sum: 07c209c0fe8983d4c7cf83d553070c79
SHA1: 275df4461a9ee7b6b7f9ef052c6a70bea68306e8
SHA256: 8c9ed3a95cadc1bed558c8440a7e66a9368858a449247dd9f28e09b4546193b1
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh storages plugin.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounced _/zeno/_) unifies data in motion, data at rest, and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries, and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Storage manager plugin for `zenohd` router
.
A plugin that allows connecting `zenohd` to different storages (e.g.,
databases). This plugin is a plugin manager
itself that loads its own plugins - `backends` - specific for the external
storage API.
.
## Backends available
.
- `memory` backend
.
Stores data in a hashmap in memory, statically linked to the storage
manager.
.
-
[zenoh-backend-filesystem](https://github.com/eclipse-zenoh/zenoh-backend-filesystem/)
.
This backend relies on the host's file system to implement the storages.
.
- [zenoh-backend-s3](https://github.com/eclipse-zenoh/zenoh-backend-s3/)
.
This backend relies on [Amazon S3](https://aws.amazon.com/s3/?nc1=h_ls) to
implement the storages. It is also compatible with [MinIO](https://min.io/)
object storage.
.
-
[zenoh-backend-rocksdb](https://github.com/eclipse-zenoh/zenoh-backend-rocksdb/)
.
This backend relies on [RocksDB](https://rocksdb.org/) to implement the
storages.
.
-
[zenoh-backend-influxdb](https://github.com/eclipse-zenoh/zenoh-backend-influxdb/)
.
This backend relies on
[InfluxDB](https://www.influxdata.com/products/influxdb/) server
to implement the storages.
.
## Configuring storages
.
The storages are configured in the storage manager plugin configuration in the
`plugins` section of the
[config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
There are two concepts in the storage manager: "volumes" and "storages".
.
The "volume" is a specific database backend plugin (memory, s3, rocksdb, etc.)
plus
a concrete backend configuration (database name, username, password, etc.).
.
The "storage" is a mapping from a glob key expression to a volume, defining
where data
for each path is stored.
.
Here is a simple example config that sets up two storages. The `__path__`
explicitly
sets up paths to dynamic plugins for different platforms.
.
```json
"plugins": {
"storage_manager": {
"volumes": {
"example": {
"__path__":
["target/debug/libzenoh_backend_example.so","target/debug/libzenoh_backend_example.dylib"],
}
},
"storages": {
"memory": {
"volume": "memory",
"key_expr": "demo/memory/**"
},
"example": {
"volume": "example",
"key_expr": "demo/example/**"
}
}
}
}
```
.
## Usage of storages
.
Assume that we are in the root of the
[zenoh](https://github.com/eclipse-zenoh/zenoh) repository.
Uncomment the following part in the `DEFAULT_CONFIG.json5` which demonstrates
using
external plugin config files.
.
```json
"plugins|": {
"rest": {
"__config__": "./plugins/zenoh-plugin-rest/config.json5",
},
"storage_manager": {
"__config__": "./plugins/zenoh-plugin-storage-manager/config.json5",
}
},
```
.
Also either change option `timestamping -> enabled -> peer` to `true` or change
the `mode` to `router` to enable message
timestamping which is required by storage manager.
.
Run the `zenohd` router with adminspace write permissions enabled:
.
```bash
RUST_LOG=info cargo run -- --config DEFAULT_CONFIG.json5
--adminspace-permissions rw
```
.
The `RUST_LOG=info` is important to enable logging from
`zenoh_plugin_storage_manager` itself. Otherwise, the logs from plugins are
suppressed.
.
The adminspace write permissions allow you to manage storages dynamically at
runtime via the admin space REST API. See the example at the end.
.
Verify that the plugin loaded successfully: the output should contain lines
like:
.
```sh
2025-10-02T13:33:38.279758Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "rest"
2025-10-02T13:33:38.530621Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "storage_manager"
2025-10-02T13:33:38.787932Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "rest"
2025-10-02T13:33:38.795413Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin rest from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_rest.dylib"
2025-10-02T13:33:38.795433Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
2025-10-02T13:33:38.795441Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "storage_manager"
2025-10-02T13:33:38.801661Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'memory' with backend 'memory'
2025-10-02T13:33:38.802118Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'example' with backend 'example'
2025-10-02T13:33:38.925730Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'example' from volume 'example' with backend 'example'
2025-10-02T13:33:38.926759Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'memory' from volume 'memory' with backend 'memory'
2025-10-02T13:33:38.926833Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin storage_manager from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_storage_manager.dylib"
2025-10-02T13:33:38.926860Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
```
.
Now we can store and retrieve data. This can be done by zenoh `put` and `get`
operations as well as using [REST](https://crates.io/crates/zenoh-plugin-rest)
API.
.
### Store and retrieve data
.
#### Using zenoh operations
.
Store some data using put:
.
```bash
cargo run --example z_put -- -k demo/memory/test -p 'Hello from zenoh put'
```
.
Then query the stored data:
.
```bash
cargo run --example z_get -- -s "demo/memory/test"
```
.
Expected output with the stored data
.
```console
>> Received ('demo/memory/test': 'Hello from zenoh put')
```
.
Notice that this would not work without storage enabled. The `put` operation
belongs to the publish/subscribe API, while the `get` is part of the
query/reply API.
It's the storage that runs a subscriber and querier for its key expression. In
other words, storages link pub/sub and query/reply APIs together in
the Zenoh network.
.
#### Using REST API
.
Store data via REST PUT:
.
```bash
curl -X PUT -d '"Hello from REST"' -H "Content-Type: application/json"
http://localhost:8080/demo/memory/test
```
.
Retrieve data via REST GET:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output:
.
```json
[{"key":"demo/memory/test","value":"Hello from
REST","encoding":"application/json","timestamp":"7556630592622444272/d3f8913b8af0c842078d30652a04bd8f"}]
```
.
**Note**: Use the `application/json` content type and quoted value in `PUT` to
get data as a string value in `GET` json output. Otherwise, the value is
base-64 encoded to
ensure correctness of the json format.
.
Delete stored data with REST DELETE:
.
```bash
curl -X DELETE http://localhost:8080/demo/memory/test
```
.
You can verify the deletion by querying the key again:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output (empty array, indicating no data found):
.
```json
[]
```
.
### Using the admin space to manage storages
.
You can manage storages dynamically via the admin space - the predefined key
expression starting with `@/`.
.
To view current storages:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
.
Expected output (showing active storages):
.
```json
[
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/memory",
"value": {
"key_expr": "demo/memory/**",
"volume": "memory"
},
"encoding": "application/json",
"timestamp": null
},
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/example",
"value": null,
"encoding": "application/json",
"timestamp": null
}
]
```
.
Add another memory storage dynamically:
.
```bash
curl -X PUT -H 'content-type:application/json' \
-d '{"key_expr":"demo/sensors/**","volume":"memory"}' \
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/sensors
```
.
Delete example storage dynamically:
.
```bash
curl -X DELETE
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/example
```
.
Verify the new memory storage is created and the example storage is deleted:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
Package: zenoh-plugin-storage-manager
Version: 1.7.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3466
Depends: zenohd (=1.7.2)
Filename: 1.7.2/zenoh-plugin-storage-manager_1.7.2_arm64.deb
Size: 960010
MD5sum: 1f08ec28979d721c0caa4161984f0c11
SHA1: 3a1062f771bb0e1b76f9634b12016b23df1b9a9c
SHA256: 6e31f692818e280af2dd3caeb3a43e1e339119eaea1078a082188ace07c359a0
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: The zenoh storages plugin.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounced _/zeno/_) unifies data in motion, data at rest, and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries, and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Storage manager plugin for `zenohd` router
.
A plugin that allows connecting `zenohd` to different storages (e.g.,
databases). This plugin is a plugin manager
itself that loads its own plugins - `backends` - specific for the external
storage API.
.
## Backends available
.
- `memory` backend
.
Stores data in a hashmap in memory, statically linked to the storage
manager.
.
-
[zenoh-backend-filesystem](https://github.com/eclipse-zenoh/zenoh-backend-filesystem/)
.
This backend relies on the host's file system to implement the storages.
.
- [zenoh-backend-s3](https://github.com/eclipse-zenoh/zenoh-backend-s3/)
.
This backend relies on [Amazon S3](https://aws.amazon.com/s3/?nc1=h_ls) to
implement the storages. It is also compatible with [MinIO](https://min.io/)
object storage.
.
-
[zenoh-backend-rocksdb](https://github.com/eclipse-zenoh/zenoh-backend-rocksdb/)
.
This backend relies on [RocksDB](https://rocksdb.org/) to implement the
storages.
.
-
[zenoh-backend-influxdb](https://github.com/eclipse-zenoh/zenoh-backend-influxdb/)
.
This backend relies on
[InfluxDB](https://www.influxdata.com/products/influxdb/) server
to implement the storages.
.
## Configuring storages
.
The storages are configured in the storage manager plugin configuration in the
`plugins` section of the
[config.json](https://docs.rs/zenoh/latest/zenoh/struct.Config.html).
.
There are two concepts in the storage manager: "volumes" and "storages".
.
The "volume" is a specific database backend plugin (memory, s3, rocksdb, etc.)
plus
a concrete backend configuration (database name, username, password, etc.).
.
The "storage" is a mapping from a glob key expression to a volume, defining
where data
for each path is stored.
.
Here is a simple example config that sets up two storages. The `__path__`
explicitly
sets up paths to dynamic plugins for different platforms.
.
```json
"plugins": {
"storage_manager": {
"volumes": {
"example": {
"__path__":
["target/debug/libzenoh_backend_example.so","target/debug/libzenoh_backend_example.dylib"],
}
},
"storages": {
"memory": {
"volume": "memory",
"key_expr": "demo/memory/**"
},
"example": {
"volume": "example",
"key_expr": "demo/example/**"
}
}
}
}
```
.
## Usage of storages
.
Assume that we are in the root of the
[zenoh](https://github.com/eclipse-zenoh/zenoh) repository.
Uncomment the following part in the `DEFAULT_CONFIG.json5` which demonstrates
using
external plugin config files.
.
```json
"plugins|": {
"rest": {
"__config__": "./plugins/zenoh-plugin-rest/config.json5",
},
"storage_manager": {
"__config__": "./plugins/zenoh-plugin-storage-manager/config.json5",
}
},
```
.
Also either change option `timestamping -> enabled -> peer` to `true` or change
the `mode` to `router` to enable message
timestamping which is required by storage manager.
.
Run the `zenohd` router with adminspace write permissions enabled:
.
```bash
RUST_LOG=info cargo run -- --config DEFAULT_CONFIG.json5
--adminspace-permissions rw
```
.
The `RUST_LOG=info` is important to enable logging from
`zenoh_plugin_storage_manager` itself. Otherwise, the logs from plugins are
suppressed.
.
The adminspace write permissions allow you to manage storages dynamically at
runtime via the admin space REST API. See the example at the end.
.
Verify that the plugin loaded successfully: the output should contain lines
like:
.
```sh
2025-10-02T13:33:38.279758Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "rest"
2025-10-02T13:33:38.530621Z INFO main ThreadId(01) zenoh::api::loader: Loading
plugin "storage_manager"
2025-10-02T13:33:38.787932Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "rest"
2025-10-02T13:33:38.795413Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin rest from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_rest.dylib"
2025-10-02T13:33:38.795433Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
2025-10-02T13:33:38.795441Z INFO main ThreadId(01) zenoh::api::loader:
Starting plugin "storage_manager"
2025-10-02T13:33:38.801661Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'memory' with backend 'memory'
2025-10-02T13:33:38.802118Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning volume 'example' with backend 'example'
2025-10-02T13:33:38.925730Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'example' from volume 'example' with backend 'example'
2025-10-02T13:33:38.926759Z INFO ThreadId(01) zenoh_plugin_storage_manager:
Spawning storage 'memory' from volume 'memory' with backend 'memory'
2025-10-02T13:33:38.926833Z INFO main ThreadId(01) zenoh::api::loader:
Successfully started plugin storage_manager from
"/Users/milyin/ZS/zenoh/target/debug/libzenoh_plugin_storage_manager.dylib"
2025-10-02T13:33:38.926860Z INFO main ThreadId(01) zenoh::api::loader:
Finished loading plugins
```
.
Now we can store and retrieve data. This can be done by zenoh `put` and `get`
operations as well as using [REST](https://crates.io/crates/zenoh-plugin-rest)
API.
.
### Store and retrieve data
.
#### Using zenoh operations
.
Store some data using put:
.
```bash
cargo run --example z_put -- -k demo/memory/test -p 'Hello from zenoh put'
```
.
Then query the stored data:
.
```bash
cargo run --example z_get -- -s "demo/memory/test"
```
.
Expected output with the stored data
.
```console
>> Received ('demo/memory/test': 'Hello from zenoh put')
```
.
Notice that this would not work without storage enabled. The `put` operation
belongs to the publish/subscribe API, while the `get` is part of the
query/reply API.
It's the storage that runs a subscriber and querier for its key expression. In
other words, storages link pub/sub and query/reply APIs together in
the Zenoh network.
.
#### Using REST API
.
Store data via REST PUT:
.
```bash
curl -X PUT -d '"Hello from REST"' -H "Content-Type: application/json"
http://localhost:8080/demo/memory/test
```
.
Retrieve data via REST GET:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output:
.
```json
[{"key":"demo/memory/test","value":"Hello from
REST","encoding":"application/json","timestamp":"7556630592622444272/d3f8913b8af0c842078d30652a04bd8f"}]
```
.
**Note**: Use the `application/json` content type and quoted value in `PUT` to
get data as a string value in `GET` json output. Otherwise, the value is
base-64 encoded to
ensure correctness of the json format.
.
Delete stored data with REST DELETE:
.
```bash
curl -X DELETE http://localhost:8080/demo/memory/test
```
.
You can verify the deletion by querying the key again:
.
```bash
curl http://localhost:8080/demo/memory/test
```
.
Expected output (empty array, indicating no data found):
.
```json
[]
```
.
### Using the admin space to manage storages
.
You can manage storages dynamically via the admin space - the predefined key
expression starting with `@/`.
.
To view current storages:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
.
Expected output (showing active storages):
.
```json
[
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/memory",
"value": {
"key_expr": "demo/memory/**",
"volume": "memory"
},
"encoding": "application/json",
"timestamp": null
},
{
"key":
"@/d3f8913b8af0c842078d30652a04bd8f/router/status/plugins/storage_manager/storages/example",
"value": null,
"encoding": "application/json",
"timestamp": null
}
]
```
.
Add another memory storage dynamically:
.
```bash
curl -X PUT -H 'content-type:application/json' \
-d '{"key_expr":"demo/sensors/**","volume":"memory"}' \
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/sensors
```
.
Delete example storage dynamically:
.
```bash
curl -X DELETE
http://localhost:8080/@/local/router/config/plugins/storage_manager/storages/example
```
.
Verify the new memory storage is created and the example storage is deleted:
.
```bash
curl -s 'http://localhost:8080/@/local/router/**/storages/*' | jq
```
Package: zenohd
Version: 1.7.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14384
Depends: libc6 (>= 2.34)
Filename: 1.7.2/zenohd_1.7.2_amd64.deb
Size: 4004610
MD5sum: bf1778328bf014a857e4027f0419e540
SHA1: 95dfdf125e8afd23866a09834fe9c8207e5fd820
SHA256: f5817ebaf741c3d29960accbdfe77ce4b7cf2ed54d0711cf293e6fac12ca5215
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh router
.
`zenohd` is a daemon router whose purpose is to build Zenoh infrastructure.
Technically, `zenohd` is the Zenoh runtime with a plugin manager.
.
## Command Line Arguments
.
### Core Options
.
- **`-c, --config `**
The configuration file. Currently, this file must be a valid JSON5 or YAML
file.
.
The commented example configuration file for `zenohd` is in the
[documentation](https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html).
.
- **`-l, --listen `**
Locators on which this router will listen for incoming sessions. Repeat this
option to open several listeners.
.
- **`-e, --connect `**
A peer locator this router will try to connect to. Repeat this option to
connect to several peers.
.
- **`-i, --id `**
The identifier (as a hexadecimal string, with an odd number of chars - e.g.:
A0B23...) that zenohd must use. If not set, a random unsigned 128-bit integer
will be used. WARNING: this identifier must be unique in the system and must be
16 bytes maximum (32 chars)!
.
### Plugin Management
.
- **`-P, --plugin `**
A plugin that MUST be loaded. You can give just the name of the plugin;
zenohd will search for a library named `libzenoh_plugin_.so` (exact name
depending on the OS). Alternatively, you can provide a string in this format:
`:`. Repeat this option to load several plugins. If
loading fails, zenohd will exit.
.
- **`--plugin-search-dir `**
Directory in which to search for plugin libraries to load. Repeat this option
to specify several search directories.
.
- **`--rest-http-port `**
Enables REST API plugin and configures HTTP interface for it. Accepted
values:
- a port number
- a string with format `:` (to bind the HTTP server to
a specific interface)
.
### Behavioral Options
.
- **`--no-timestamp`**
By default, zenohd adds a HLC-generated Timestamp to each routed Data if
there isn't already one. This option disables this feature.
.
- **`--no-multicast-scouting`**
By default, zenohd replies to multicast scouting messages to be discovered by
peers and clients. This option disables this feature.
.
### Advanced Configuration
.
- **`--cfg `**
Allows arbitrary configuration changes as colon-separated KEY:VALUE pairs,
where the empty key is used to represent the entire configuration:
- KEY must be a valid config path, or an empty string if the whole
configuration is defined
- VALUE must be a valid JSON5 string that can be deserialized to the expected
type for the KEY field
.
Examples:
- `--cfg='startup/subscribe:["demo/**"]'`
-
`--cfg='plugins/storage_manager/storages/demo:{key_expr:"demo/example/**",volume:"memory"}'`
- `--cfg=':{metadata:{name:"My
App"},adminspace:{enabled:true,permissions:{read:true,write:true}}'`
.
- **`--adminspace-permissions <[r|w|rw|none]>`**
Configure the read and/or write permissions on the admin space. Default is
read only.
.
### Help & Version
.
- **`-h, --help`**
Print help (see a summary with '-h').
.
- **`-V, --version`**
Print version.
.
## Plugins
.
> [!WARNING]
> As Rust doesn't have a stable ABI, plugins should be built with the exact
same Rust version as `zenohd`, and should use the same version (or commit
number) of the `zenoh` dependency as `zenohd` with the same set of features. A
plugin compiled with a different Rust version or with a different set of
`zenoh` crate features will be rejected when `zenohd` attempts to load it.
Otherwise, incompatibilities in memory mapping of structures shared between
`zenohd` and the library could lead to a `"SIGSEGV"` crash.
.
The Zenoh router is delivered with two statically linked plugins:
.
- [zenoh-plugin-rest](../plugins/zenoh-plugin-rest) is the plugin exposing a
[REST API](https://zenoh.io/docs/apis/rest/)
.
- [zenoh-plugin-storage-manager](../plugins/zenoh-plugin-storage-manager) is
the plugin that manages
[backends and
storages](https://zenoh.io/docs/manual/plugin-storage-manager/#backends-and-volumes)
.
There are other plugins in independent repositories:
.
- [zenoh-plugin-dds](https://github.com/eclipse-zenoh/zenoh-plugin-dds/)
.
Bridges [DDS](https://www.dds-foundation.org/) with Zenoh.
.
-
[zenoh-plugin-ros2dds](https://github.com/eclipse-zenoh/zenoh-plugin-ros2dds/)
.
Bridges all [ROS 2](https://ros.org/) communications using
[DDS](https://www.dds-foundation.org/) over Zenoh.
.
-
[zenoh-plugin-webserver](https://github.com/eclipse-zenoh/zenoh-plugin-webserver/)
.
Implements an HTTP server mapping URLs to zenoh keys.
.
- [zenoh-plugin-remote-api](https://github.com/eclipse-zenoh/zenoh-ts/)
.
The WebSocket server supporting TypeScript API
Package: zenohd
Version: 1.7.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13743
Filename: 1.7.2/zenohd_1.7.2_armel.deb
Size: 3737854
MD5sum: f6e64f2cb40564bf2b0c488d8e540c23
SHA1: e1093629b66b61af18d490d2aca5039be16ca892
SHA256: c3d82fe4cd0930c65a21128a50f173977df013f22fe2f0479dc89890585dff0c
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh router
.
`zenohd` is a daemon router whose purpose is to build Zenoh infrastructure.
Technically, `zenohd` is the Zenoh runtime with a plugin manager.
.
## Command Line Arguments
.
### Core Options
.
- **`-c, --config `**
The configuration file. Currently, this file must be a valid JSON5 or YAML
file.
.
The commented example configuration file for `zenohd` is in the
[documentation](https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html).
.
- **`-l, --listen `**
Locators on which this router will listen for incoming sessions. Repeat this
option to open several listeners.
.
- **`-e, --connect `**
A peer locator this router will try to connect to. Repeat this option to
connect to several peers.
.
- **`-i, --id `**
The identifier (as a hexadecimal string, with an odd number of chars - e.g.:
A0B23...) that zenohd must use. If not set, a random unsigned 128-bit integer
will be used. WARNING: this identifier must be unique in the system and must be
16 bytes maximum (32 chars)!
.
### Plugin Management
.
- **`-P, --plugin `**
A plugin that MUST be loaded. You can give just the name of the plugin;
zenohd will search for a library named `libzenoh_plugin_.so` (exact name
depending on the OS). Alternatively, you can provide a string in this format:
`:`. Repeat this option to load several plugins. If
loading fails, zenohd will exit.
.
- **`--plugin-search-dir `**
Directory in which to search for plugin libraries to load. Repeat this option
to specify several search directories.
.
- **`--rest-http-port `**
Enables REST API plugin and configures HTTP interface for it. Accepted
values:
- a port number
- a string with format `:` (to bind the HTTP server to
a specific interface)
.
### Behavioral Options
.
- **`--no-timestamp`**
By default, zenohd adds a HLC-generated Timestamp to each routed Data if
there isn't already one. This option disables this feature.
.
- **`--no-multicast-scouting`**
By default, zenohd replies to multicast scouting messages to be discovered by
peers and clients. This option disables this feature.
.
### Advanced Configuration
.
- **`--cfg `**
Allows arbitrary configuration changes as colon-separated KEY:VALUE pairs,
where the empty key is used to represent the entire configuration:
- KEY must be a valid config path, or an empty string if the whole
configuration is defined
- VALUE must be a valid JSON5 string that can be deserialized to the expected
type for the KEY field
.
Examples:
- `--cfg='startup/subscribe:["demo/**"]'`
-
`--cfg='plugins/storage_manager/storages/demo:{key_expr:"demo/example/**",volume:"memory"}'`
- `--cfg=':{metadata:{name:"My
App"},adminspace:{enabled:true,permissions:{read:true,write:true}}'`
.
- **`--adminspace-permissions <[r|w|rw|none]>`**
Configure the read and/or write permissions on the admin space. Default is
read only.
.
### Help & Version
.
- **`-h, --help`**
Print help (see a summary with '-h').
.
- **`-V, --version`**
Print version.
.
## Plugins
.
> [!WARNING]
> As Rust doesn't have a stable ABI, plugins should be built with the exact
same Rust version as `zenohd`, and should use the same version (or commit
number) of the `zenoh` dependency as `zenohd` with the same set of features. A
plugin compiled with a different Rust version or with a different set of
`zenoh` crate features will be rejected when `zenohd` attempts to load it.
Otherwise, incompatibilities in memory mapping of structures shared between
`zenohd` and the library could lead to a `"SIGSEGV"` crash.
.
The Zenoh router is delivered with two statically linked plugins:
.
- [zenoh-plugin-rest](../plugins/zenoh-plugin-rest) is the plugin exposing a
[REST API](https://zenoh.io/docs/apis/rest/)
.
- [zenoh-plugin-storage-manager](../plugins/zenoh-plugin-storage-manager) is
the plugin that manages
[backends and
storages](https://zenoh.io/docs/manual/plugin-storage-manager/#backends-and-volumes)
.
There are other plugins in independent repositories:
.
- [zenoh-plugin-dds](https://github.com/eclipse-zenoh/zenoh-plugin-dds/)
.
Bridges [DDS](https://www.dds-foundation.org/) with Zenoh.
.
-
[zenoh-plugin-ros2dds](https://github.com/eclipse-zenoh/zenoh-plugin-ros2dds/)
.
Bridges all [ROS 2](https://ros.org/) communications using
[DDS](https://www.dds-foundation.org/) over Zenoh.
.
-
[zenoh-plugin-webserver](https://github.com/eclipse-zenoh/zenoh-plugin-webserver/)
.
Implements an HTTP server mapping URLs to zenoh keys.
.
- [zenoh-plugin-remote-api](https://github.com/eclipse-zenoh/zenoh-ts/)
.
The WebSocket server supporting TypeScript API
Package: zenohd
Version: 1.7.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13461
Filename: 1.7.2/zenohd_1.7.2_armhf.deb
Size: 3757762
MD5sum: 45bf583d00f73a1629c15e082ef53f3b
SHA1: 67fc00874a1dec054de664c378a2b972ea34f8c2
SHA256: 0c7c7cead9e6560861410cf3836f39d8d60b336383e92afdf751e27562bdce7a
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh router
.
`zenohd` is a daemon router whose purpose is to build Zenoh infrastructure.
Technically, `zenohd` is the Zenoh runtime with a plugin manager.
.
## Command Line Arguments
.
### Core Options
.
- **`-c, --config `**
The configuration file. Currently, this file must be a valid JSON5 or YAML
file.
.
The commented example configuration file for `zenohd` is in the
[documentation](https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html).
.
- **`-l, --listen `**
Locators on which this router will listen for incoming sessions. Repeat this
option to open several listeners.
.
- **`-e, --connect `**
A peer locator this router will try to connect to. Repeat this option to
connect to several peers.
.
- **`-i, --id `**
The identifier (as a hexadecimal string, with an odd number of chars - e.g.:
A0B23...) that zenohd must use. If not set, a random unsigned 128-bit integer
will be used. WARNING: this identifier must be unique in the system and must be
16 bytes maximum (32 chars)!
.
### Plugin Management
.
- **`-P, --plugin `**
A plugin that MUST be loaded. You can give just the name of the plugin;
zenohd will search for a library named `libzenoh_plugin_.so` (exact name
depending on the OS). Alternatively, you can provide a string in this format:
`:`. Repeat this option to load several plugins. If
loading fails, zenohd will exit.
.
- **`--plugin-search-dir `**
Directory in which to search for plugin libraries to load. Repeat this option
to specify several search directories.
.
- **`--rest-http-port `**
Enables REST API plugin and configures HTTP interface for it. Accepted
values:
- a port number
- a string with format `:` (to bind the HTTP server to
a specific interface)
.
### Behavioral Options
.
- **`--no-timestamp`**
By default, zenohd adds a HLC-generated Timestamp to each routed Data if
there isn't already one. This option disables this feature.
.
- **`--no-multicast-scouting`**
By default, zenohd replies to multicast scouting messages to be discovered by
peers and clients. This option disables this feature.
.
### Advanced Configuration
.
- **`--cfg `**
Allows arbitrary configuration changes as colon-separated KEY:VALUE pairs,
where the empty key is used to represent the entire configuration:
- KEY must be a valid config path, or an empty string if the whole
configuration is defined
- VALUE must be a valid JSON5 string that can be deserialized to the expected
type for the KEY field
.
Examples:
- `--cfg='startup/subscribe:["demo/**"]'`
-
`--cfg='plugins/storage_manager/storages/demo:{key_expr:"demo/example/**",volume:"memory"}'`
- `--cfg=':{metadata:{name:"My
App"},adminspace:{enabled:true,permissions:{read:true,write:true}}'`
.
- **`--adminspace-permissions <[r|w|rw|none]>`**
Configure the read and/or write permissions on the admin space. Default is
read only.
.
### Help & Version
.
- **`-h, --help`**
Print help (see a summary with '-h').
.
- **`-V, --version`**
Print version.
.
## Plugins
.
> [!WARNING]
> As Rust doesn't have a stable ABI, plugins should be built with the exact
same Rust version as `zenohd`, and should use the same version (or commit
number) of the `zenoh` dependency as `zenohd` with the same set of features. A
plugin compiled with a different Rust version or with a different set of
`zenoh` crate features will be rejected when `zenohd` attempts to load it.
Otherwise, incompatibilities in memory mapping of structures shared between
`zenohd` and the library could lead to a `"SIGSEGV"` crash.
.
The Zenoh router is delivered with two statically linked plugins:
.
- [zenoh-plugin-rest](../plugins/zenoh-plugin-rest) is the plugin exposing a
[REST API](https://zenoh.io/docs/apis/rest/)
.
- [zenoh-plugin-storage-manager](../plugins/zenoh-plugin-storage-manager) is
the plugin that manages
[backends and
storages](https://zenoh.io/docs/manual/plugin-storage-manager/#backends-and-volumes)
.
There are other plugins in independent repositories:
.
- [zenoh-plugin-dds](https://github.com/eclipse-zenoh/zenoh-plugin-dds/)
.
Bridges [DDS](https://www.dds-foundation.org/) with Zenoh.
.
-
[zenoh-plugin-ros2dds](https://github.com/eclipse-zenoh/zenoh-plugin-ros2dds/)
.
Bridges all [ROS 2](https://ros.org/) communications using
[DDS](https://www.dds-foundation.org/) over Zenoh.
.
-
[zenoh-plugin-webserver](https://github.com/eclipse-zenoh/zenoh-plugin-webserver/)
.
Implements an HTTP server mapping URLs to zenoh keys.
.
- [zenoh-plugin-remote-api](https://github.com/eclipse-zenoh/zenoh-ts/)
.
The WebSocket server supporting TypeScript API
Package: zenohd
Version: 1.7.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 12840
Filename: 1.7.2/zenohd_1.7.2_arm64.deb
Size: 3563126
MD5sum: 4d420a33bcf254773b0a013e5f95705d
SHA1: 6179e82f633e8f0e9d60cc6c2e99bd9fbd2410cb
SHA256: 5b5714e1f339d3c13a5f830f6a7672eb45fd6b57cc77d7bf4c44a41f427deaea
Section: net
Priority: optional
Homepage: http://zenoh.io
Description: Zenoh: The Zero Overhead Pub/Sub/Query Protocol.
.
[](https://github.com/eclipse-zenoh/zenoh/actions?query=workflow%3ACI+branch%3Amain++)
[](https://zenoh-rust.readthedocs.io/en/latest/?badge=latest)
[](https://codecov.io/github/eclipse-zenoh/zenoh)
[](https://github.com/eclipse-zenoh/roadmap/discussions)
[](https://discord.gg/2GJ958VuHs)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://opensource.org/licenses/Apache-2.0)
.
# Eclipse Zenoh
.
Eclipse Zenoh: Zero Overhead Pub/Sub, Store/Query and Compute.
.
Zenoh (pronounce _/zeno/_) unifies data in motion, data at rest and
computations. It carefully blends traditional pub/sub with geo-distributed
storages, queries and computations, while retaining a level of time and space
efficiency that is well beyond any of the mainstream stacks.
.
Check the website [zenoh.io](http://zenoh.io) for more information and
[installation
instructions](https://zenoh.io/docs/getting-started/installation/).
.
See also the [roadmap](https://github.com/eclipse-zenoh/roadmap) for more
detailed technical information.
.
# Zenoh router
.
`zenohd` is a daemon router whose purpose is to build Zenoh infrastructure.
Technically, `zenohd` is the Zenoh runtime with a plugin manager.
.
## Command Line Arguments
.
### Core Options
.
- **`-c, --config `**
The configuration file. Currently, this file must be a valid JSON5 or YAML
file.
.
The commented example configuration file for `zenohd` is in the
[documentation](https://docs.rs/zenoh/latest/zenoh/config/struct.Config.html).
.
- **`-l, --listen `**
Locators on which this router will listen for incoming sessions. Repeat this
option to open several listeners.
.
- **`-e, --connect `**
A peer locator this router will try to connect to. Repeat this option to
connect to several peers.
.
- **`-i, --id `**
The identifier (as a hexadecimal string, with an odd number of chars - e.g.:
A0B23...) that zenohd must use. If not set, a random unsigned 128-bit integer
will be used. WARNING: this identifier must be unique in the system and must be
16 bytes maximum (32 chars)!
.
### Plugin Management
.
- **`-P, --plugin `**
A plugin that MUST be loaded. You can give just the name of the plugin;
zenohd will search for a library named `libzenoh_plugin_.so` (exact name
depending on the OS). Alternatively, you can provide a string in this format:
`:`. Repeat this option to load several plugins. If
loading fails, zenohd will exit.
.
- **`--plugin-search-dir `**
Directory in which to search for plugin libraries to load. Repeat this option
to specify several search directories.
.
- **`--rest-http-port `**
Enables REST API plugin and configures HTTP interface for it. Accepted
values:
- a port number
- a string with format `:` (to bind the HTTP server to
a specific interface)
.
### Behavioral Options
.
- **`--no-timestamp`**
By default, zenohd adds a HLC-generated Timestamp to each routed Data if
there isn't already one. This option disables this feature.
.
- **`--no-multicast-scouting`**
By default, zenohd replies to multicast scouting messages to be discovered by
peers and clients. This option disables this feature.
.
### Advanced Configuration
.
- **`--cfg `**
Allows arbitrary configuration changes as colon-separated KEY:VALUE pairs,
where the empty key is used to represent the entire configuration:
- KEY must be a valid config path, or an empty string if the whole
configuration is defined
- VALUE must be a valid JSON5 string that can be deserialized to the expected
type for the KEY field
.
Examples:
- `--cfg='startup/subscribe:["demo/**"]'`
-
`--cfg='plugins/storage_manager/storages/demo:{key_expr:"demo/example/**",volume:"memory"}'`
- `--cfg=':{metadata:{name:"My
App"},adminspace:{enabled:true,permissions:{read:true,write:true}}'`
.
- **`--adminspace-permissions <[r|w|rw|none]>`**
Configure the read and/or write permissions on the admin space. Default is
read only.
.
### Help & Version
.
- **`-h, --help`**
Print help (see a summary with '-h').
.
- **`-V, --version`**
Print version.
.
## Plugins
.
> [!WARNING]
> As Rust doesn't have a stable ABI, plugins should be built with the exact
same Rust version as `zenohd`, and should use the same version (or commit
number) of the `zenoh` dependency as `zenohd` with the same set of features. A
plugin compiled with a different Rust version or with a different set of
`zenoh` crate features will be rejected when `zenohd` attempts to load it.
Otherwise, incompatibilities in memory mapping of structures shared between
`zenohd` and the library could lead to a `"SIGSEGV"` crash.
.
The Zenoh router is delivered with two statically linked plugins:
.
- [zenoh-plugin-rest](../plugins/zenoh-plugin-rest) is the plugin exposing a
[REST API](https://zenoh.io/docs/apis/rest/)
.
- [zenoh-plugin-storage-manager](../plugins/zenoh-plugin-storage-manager) is
the plugin that manages
[backends and
storages](https://zenoh.io/docs/manual/plugin-storage-manager/#backends-and-volumes)
.
There are other plugins in independent repositories:
.
- [zenoh-plugin-dds](https://github.com/eclipse-zenoh/zenoh-plugin-dds/)
.
Bridges [DDS](https://www.dds-foundation.org/) with Zenoh.
.
-
[zenoh-plugin-ros2dds](https://github.com/eclipse-zenoh/zenoh-plugin-ros2dds/)
.
Bridges all [ROS 2](https://ros.org/) communications using
[DDS](https://www.dds-foundation.org/) over Zenoh.
.
-
[zenoh-plugin-webserver](https://github.com/eclipse-zenoh/zenoh-plugin-webserver/)
.
Implements an HTTP server mapping URLs to zenoh keys.
.
- [zenoh-plugin-remote-api](https://github.com/eclipse-zenoh/zenoh-ts/)
.
The WebSocket server supporting TypeScript API