Package: zenoh
Version: 1.9.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.9.0), zenoh-plugin-storage-manager (=1.9.0), zenohd (=1.9.0)
Filename: 1.9.0/zenoh_1.9.0_armhf.deb
Size: 12486
MD5sum: 768226a15d060c73a65f481aa61773d4
SHA1: 784855678521f860ac27a31379deb37e8f63d996
SHA256: cac735b21a2a31fdf6153aca3390577e4da3760cb2f68b29bd110d6dc857c097
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.9.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.9.0), zenoh-plugin-storage-manager (=1.9.0), zenohd (=1.9.0)
Filename: 1.9.0/zenoh_1.9.0_arm64.deb
Size: 12486
MD5sum: 553317fb0871a4d06b25b8fc08b0500e
SHA1: a2cfbdbd8f08f21b899ea7754236e7171cdaa39d
SHA256: 5e704fb9ae2b424bbcf7a2988ff4bba5d46e0cd13019b787791c1a11df63d935
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.9.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.9.0), zenoh-plugin-storage-manager (=1.9.0), zenohd (=1.9.0)
Filename: 1.9.0/zenoh_1.9.0_armel.deb
Size: 12486
MD5sum: 7b86fe3bf10bdc536e16060595d2d5fb
SHA1: ec031bc8a32f0c848834da14d1ff2b61fed5d068
SHA256: a160dc973650958d2f61d1c5f1ae73365fc29f6f7be0a9051ec1908ef5502a3e
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.9.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.9.0), zenoh-plugin-storage-manager (=1.9.0), zenohd (=1.9.0)
Filename: 1.9.0/zenoh_1.9.0_amd64.deb
Size: 12490
MD5sum: 4d0d227d1898ed4163f4e68901d254b8
SHA1: 30eccf7c992f0dcbd8e9d0678edf496a816e78fc
SHA256: d662f38552a9d26fc9e29eed93844356b6f159d88d4e7eda5e51a959836f7130
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.9.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3533
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-rest_1.9.0_armel.deb
Size: 1037294
MD5sum: a4df53d730de043bda566dba110cc719
SHA1: f2d0404afaff2948d472449884ecb5d86a486895
SHA256: 5f428bfdda9efbb6650a3ceb6136c0a89fd175d6dc7fcd0ecd2ec2cbe6d5899d
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.9.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3905
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-rest_1.9.0_arm64.deb
Size: 1046122
MD5sum: de649b476555ab2b53459c860d4dafb1
SHA1: 20bd8eef4c9cbadccbc7714974a3f310a6c715a3
SHA256: 2e060628298318604c2f771916f5ec94a29a80a189320091a9462ce2c9e56ec7
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.9.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3572
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-rest_1.9.0_amd64.deb
Size: 1085706
MD5sum: 05daad20cbc6d2da3426be63627c27e2
SHA1: 7eb4bae98ec2249e3fdcea6b07e07daae6d670eb
SHA256: 19d17fed33209b6fdfce36850018bea765e531559769130a2ee6a18d6561d2fb
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.9.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3468
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-rest_1.9.0_armhf.deb
Size: 1032310
MD5sum: 9628f631a3c6f76609c17c9a82c938bd
SHA1: ec0b03c389fe305768144521ff4e9c12ba47a6f1
SHA256: fbbef7785457e26d9bf588759da69d59c0d32a2039691f4ea124fc567bf612d4
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.9.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3760
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-storage-manager_1.9.0_arm64.deb
Size: 1004866
MD5sum: c7197ff8ed111259bea2d9c58d4424dc
SHA1: 7bfe5861fa9e3916a7449a26ffd96dda87111228
SHA256: f63910bf7e713635d22610fb3180c4265e88ca3281cd0b4232e84706dd33ad50
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.9.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3479
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-storage-manager_1.9.0_amd64.deb
Size: 1042646
MD5sum: d1b5edfdbcd90f3bf573b7657273f957
SHA1: dde2b80c2701d3f61f420ef7dfcd01cf27d0992e
SHA256: d0e862d449e4f254c920a7127b9aee5a67b1ed82b6ac768c3d633c9d07144e63
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.9.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3418
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-storage-manager_1.9.0_armel.deb
Size: 1010574
MD5sum: 583a94743328af35b037cb86a4c3d665
SHA1: b52fdd4feddf022faf100ed75f7048ab631c2984
SHA256: 44150be374a87a53c2031526c4c21c65ac221ec1be0c9ecf57f70ae342c88154
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.9.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3341
Depends: zenohd (=1.9.0)
Filename: 1.9.0/zenoh-plugin-storage-manager_1.9.0_armhf.deb
Size: 1004730
MD5sum: 1d1089dce855053c68ba27b7997863d0
SHA1: 0fc62ceac37a15eaecdeada22c972130393ffedf
SHA256: fcc4d22375bdce5b26de5d2badafbdee645cf6533a2319d3f7ff99e8feb84989
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.9.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 15422
Filename: 1.9.0/zenohd_1.9.0_arm64.deb
Size: 4136398
MD5sum: 4fd03b0ddea78c79bafb8f3c6e62f77f
SHA1: d07ee81c91842dc66036ecdcacabab186ea28886
SHA256: 6eec92e835c1ba1987e80385156e877d0543321374c3d66d337a115c2fcc425a
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.9.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 16000
Filename: 1.9.0/zenohd_1.9.0_armhf.deb
Size: 4320086
MD5sum: 7b20fc8b973032aa5fc6801f8fc94c7f
SHA1: e351fab1c9e15e18ebf09490c91a27eac9904b11
SHA256: e296faef07a6716d27f1200d3edd4eb5a7bc7cb7efe01bd14b5e00e4e20906cd
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.9.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 16300
Filename: 1.9.0/zenohd_1.9.0_armel.deb
Size: 4281958
MD5sum: 5dc37e911575e16fde0a63b950e13755
SHA1: b6eaafc43385f92553b005f8c8f73aa221d049e7
SHA256: 31e1c63a84d27dd3bf9f724abae848f6c03f300f177da13a973c3467b1f25923
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.9.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 17014
Depends: libc6 (>= 2.34)
Filename: 1.9.0/zenohd_1.9.0_amd64.deb
Size: 4650226
MD5sum: a7be2aaee65b3afc7ffe88ee4b38639e
SHA1: 268e54070691ccfcbba8e5e895cac201e9b5f4c9
SHA256: 30c30d86e203d36d7516585de0066de47bd6acd53df2134e43df7d17364fa197
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