Package: zenoh
Version: 1.7.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.0), zenoh-plugin-storage-manager (=1.7.0), zenohd (=1.7.0)
Filename: 1.7.0/zenoh_1.7.0_armel.deb
Size: 12490
MD5sum: 423ffe72d60f778eb6cfe1b8c5ec58f8
SHA1: 06958bb46334614d2f7fecfc5ee563b284e513bc
SHA256: 577f6c682b77322f31c161c43c27af80e44eaa63d00fac8b06b3487cea36944e
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.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.0), zenoh-plugin-storage-manager (=1.7.0), zenohd (=1.7.0)
Filename: 1.7.0/zenoh_1.7.0_amd64.deb
Size: 12490
MD5sum: ab76bc764e9391630ada295aa7754df3
SHA1: 589a5da1149b8f3f8b7b0bc9cc62fdb3b96de279
SHA256: b2ad17f0d3b5c19454a7c0dad32177ce5aada60075a7c364a94b5c27a992160f
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.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.0), zenoh-plugin-storage-manager (=1.7.0), zenohd (=1.7.0)
Filename: 1.7.0/zenoh_1.7.0_arm64.deb
Size: 12490
MD5sum: b5f38baa2fac63b3f2b92ae1b1321b19
SHA1: e417746ea77a18a5e510e609f4e97838024fa487
SHA256: 3a19b78290bf54ed2917282a2e8571b866b2bb5504c9ee9a1c194087b9fa46e6
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.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.7.0), zenoh-plugin-storage-manager (=1.7.0), zenohd (=1.7.0)
Filename: 1.7.0/zenoh_1.7.0_armhf.deb
Size: 12490
MD5sum: 8c0b66f6acf8997805f0b0d1e6f8356d
SHA1: 4386ddfd53ba3351393c4e1e349d02070d57ba31
SHA256: 75e418586ccacb2386a9ac3f90fbecc076bd43f1bfe729de9626cf2e770363bb
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.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3593
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-rest_1.7.0_armel.deb
Size: 1055018
MD5sum: ffc7118e86300190bfc35b2154a09402
SHA1: c36bfb84292f485d9907b944ce5585ab1ae80a8f
SHA256: ab699ef5000dfebe59df87597ce8557dc0a7f591feafe93b1967ee272901fb04
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.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3599
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-rest_1.7.0_arm64.deb
Size: 1007842
MD5sum: d1442dd94b14b891e874fb1467203ccd
SHA1: 7b936a0166d8b0c056bcb32b93372a079ea334c4
SHA256: ea611b1c0fb05a7bd5cebf32f675a5dc453966583f3e1bfe60512fea4c371596
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.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3572
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-rest_1.7.0_amd64.deb
Size: 1096722
MD5sum: 5fcc6bbffc77655215ae94b832cbd13f
SHA1: 53840f8552f6054494686525c2997af9ff23bb5f
SHA256: a374d49e7c0e86c40690c10a21dfd56286b3ade4cd8a046c780a92727c72719c
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.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3520
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-rest_1.7.0_armhf.deb
Size: 1045574
MD5sum: 7a9c352678948e25d712f22925ae6746
SHA1: 865bac192986f39cf5b4bb57214239091067c6da
SHA256: d16be77e4231e2bd5c866409f22a8458b95b042183afff85bded1dcf5e1c20b5
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.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3473
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-storage-manager_1.7.0_amd64.deb
Size: 1055030
MD5sum: c149f1b248b525c4139a88c9482560fb
SHA1: cad02993a0c629cdeb2e98a4d4b42ba87ea5f8d3
SHA256: b558dd8dec96bd68b9ce8b4933e4410566abf1dd0cc3b06575083372dbc0c9b7
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.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3408
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-storage-manager_1.7.0_armhf.deb
Size: 1021002
MD5sum: f226c668291b62453d6893e6bdbf7e01
SHA1: 6069394b8fbe4b95199b3e3e0d577e719777e39a
SHA256: 0d1960e7d7783acbc8effc96d17f4c0c918e22eb9a848c2931a5bc090ba7652e
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.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3497
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-storage-manager_1.7.0_armel.deb
Size: 1030594
MD5sum: 78d5ce68fccbc495c7155451f9b387cf
SHA1: b5bc73522f101115bb68e9cebbddfc24528783b7
SHA256: 94d3937d48d3eb8ad041403d55e31fc2256c94c46ccaea728b2b7116298c7572
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.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3478
Depends: zenohd (=1.7.0)
Filename: 1.7.0/zenoh-plugin-storage-manager_1.7.0_arm64.deb
Size: 970658
MD5sum: ab9b80f6bdac7d4d618e7d01e6ec6b1c
SHA1: 006438bcd181db9264d7023a7ce517e441638062
SHA256: 02eded1e82eb17ce1866198768375dde6bff02955ae1677032c653c2b2a7ca71
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.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13472
Filename: 1.7.0/zenohd_1.7.0_armhf.deb
Size: 3766734
MD5sum: cb9d1f65e2d509a3e914512ff78fa466
SHA1: f9063f3048d83266615b4ecbd427e3594d9aa042
SHA256: 58cb58e98289672f5c4529caf696f8404319257111782aa130a126581e0956f0
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.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 12847
Filename: 1.7.0/zenohd_1.7.0_arm64.deb
Size: 3576418
MD5sum: 488b290cdebe8ce0ad49722ac892eeaa
SHA1: a60afe7a981b09f92118850677eea93a489aa4a3
SHA256: 1c93e1f86b244b094bb089b966cd94c8d52a8544fb03ff6c678aef0bf29664ca
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.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14399
Depends: libc6 (>= 2.34)
Filename: 1.7.0/zenohd_1.7.0_amd64.deb
Size: 4017166
MD5sum: 488c167076a5b2f54c54cc5d527d88f6
SHA1: 21fd546f7996cd480f32267aa9184f80af909ce0
SHA256: 207b47a8d3c4eee9ca8852b6f5f618c322c145e818d88bf99b2d69f0c1890350
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.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13756
Filename: 1.7.0/zenohd_1.7.0_armel.deb
Size: 3751406
MD5sum: 3d990a972b12db8dd9d4bdbc9e5e67ee
SHA1: 6e7047e493f020d5300c2f5223628acd479b99a0
SHA256: 654bff16920e81bad1a52ce45a2943f922bef5c9c48e9303784a051729ded2bb
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