Package: zenoh
Version: 1.8.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.8.0), zenoh-plugin-storage-manager (=1.8.0), zenohd (=1.8.0)
Filename: 1.8.0/zenoh_1.8.0_armel.deb
Size: 12494
MD5sum: d4dd2c0d542fd2f814c21d023101a534
SHA1: 472f3bad848ebf76dd3b478aaa9becfa5528a98e
SHA256: 4656c598a6cc0117259efc2fceea0cd67ba0a1529875e38f8f6a6b482bd9901c
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.8.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.8.0), zenoh-plugin-storage-manager (=1.8.0), zenohd (=1.8.0)
Filename: 1.8.0/zenoh_1.8.0_arm64.deb
Size: 12494
MD5sum: 317d9f409678a7ee79f531bb5228bd7e
SHA1: 94ed52c3d38fec62f6a80cd2120974735649997d
SHA256: 0b37958cf7283950eaa5d5738e27bc1f435073fc0576d8f5ab311c81366313a1
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.8.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.8.0), zenoh-plugin-storage-manager (=1.8.0), zenohd (=1.8.0)
Filename: 1.8.0/zenoh_1.8.0_amd64.deb
Size: 12494
MD5sum: 54b90735a08517b47ccf0da868e16b7a
SHA1: 8454d4f05cb9cea48477a021e2a7ad28459d3f56
SHA256: 2dc34a55b6b2c163eca49f3c3b024c2db29e4ab35d90fd6cc5804e0cf94f907e
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.8.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.8.0), zenoh-plugin-storage-manager (=1.8.0), zenohd (=1.8.0)
Filename: 1.8.0/zenoh_1.8.0_armhf.deb
Size: 12494
MD5sum: de7c73021d96218aa132f0e84f215d91
SHA1: e86679cc66943a10fa1ebd75413d7c15ac38552b
SHA256: 7a02c7432758daf4076f3801ee264c37372eb9716f37cd993175ec4a235ee85a
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.8.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3721
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-rest_1.8.0_arm64.deb
Size: 1025714
MD5sum: e19e9c6ea52c2826cd57546a8ff008b8
SHA1: 3880cece031ee452b1ac350b7e6c772a2856e604
SHA256: 4da4ef790f73aabb0c68708ca1c9e199b9ee0c07d77863aee85b9c6fe55224ee
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.8.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3542
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-rest_1.8.0_amd64.deb
Size: 1079842
MD5sum: 14f08f08abc6e176573d2c3d6f5dd027
SHA1: 2a815ddefd04698dd54a6ca990b72489292f0900
SHA256: 10cdb100b80140a6a6221f0326163785e0a3d46f6299f5bab8dce356de8c3ed2
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.8.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3444
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-rest_1.8.0_armhf.deb
Size: 1027894
MD5sum: cd6d2375878c736fb3c773983edcf981
SHA1: 711ef9f2e6b94f3c1e8c515968a1dd5737ca0088
SHA256: 04308292b23f94ab45729bcdc6d654a7111713c7210519e95b7afadfae29e496
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.8.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3508
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-rest_1.8.0_armel.deb
Size: 1032202
MD5sum: 084747789ddac1c62e6501a08ab2b91f
SHA1: 3c3b3109189e537f7f84d2ab0098e112452ae3dc
SHA256: fd031ea670932452acbfb03c0b49e8b5f2aa3b5e98dda4f276d41ae80fd9f577
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.8.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3401
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-storage-manager_1.8.0_armel.deb
Size: 1005006
MD5sum: 703b532dbbab2e92dccfa11437da3171
SHA1: 444e3076e1e6d974b6a4ec3f6005028633678104
SHA256: 3a66a58521a2cef93e10d3a2b2c22176788feb4c6773c548e58944f135b8af81
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.8.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3325
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-storage-manager_1.8.0_armhf.deb
Size: 1000146
MD5sum: a25909e64b0a43138f1abdeac7910a8a
SHA1: 98f957121a454656081b1f21ce78e8873b441917
SHA256: 9aa91edd1e96d3c4999bf385a6b98d3643f12f1056348546521aff8041e3a220
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.8.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3459
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-storage-manager_1.8.0_amd64.deb
Size: 1036938
MD5sum: 509d4b90a75ce3f5b6a2b850e51bcd03
SHA1: 153ecff466e1ffd705f02b6217d26a174905d531
SHA256: 2dfebda0732a3a29499af77482561c0f268227ec3993423cbbab03c42bfa0add
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.8.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 3610
Depends: zenohd (=1.8.0)
Filename: 1.8.0/zenoh-plugin-storage-manager_1.8.0_arm64.deb
Size: 986746
MD5sum: c371a4f8ec2acae8ee67032820835731
SHA1: 8b6417224431c8700165a09ab894fa17f8516adf
SHA256: 99b1232ad491882aed03f43700756fdf4afd102c6ffca7778cb1c68aa4633d3a
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.8.0
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13969
Filename: 1.8.0/zenohd_1.8.0_arm64.deb
Size: 3868658
MD5sum: c35bbef7f3d79516d551510aba77275e
SHA1: 3f2b51143e9344b45879005b53209393987056b0
SHA256: f7184b631fb49c847539ac8348becd5dbc48ebca591bab7cbdc8e05cb35f74e6
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.8.0
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14786
Filename: 1.8.0/zenohd_1.8.0_armel.deb
Size: 3997826
MD5sum: 2dceae72f5a7fde4212d9a0f15f632bb
SHA1: 855c47945987fd0f8a09b357a6bc6881a87c2bb6
SHA256: a6ad5b670adba17636eb8311f8de95963f3f3a81fb5c927c211a895f98411e2a
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.8.0
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 15425
Depends: libc6 (>= 2.34)
Filename: 1.8.0/zenohd_1.8.0_amd64.deb
Size: 4342766
MD5sum: 88be3d3aa5f10709f2e74ccfd39ba3da
SHA1: b5b9b197948fac401b842544d665695fd9a9104b
SHA256: a53baa702796e447a05c638c6ba909613380f3e4d7e6aee5ae9a61d16994e096
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.8.0
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14511
Filename: 1.8.0/zenohd_1.8.0_armhf.deb
Size: 4025866
MD5sum: 7b226e130f8d07a3f1ad47c35ee5a8a3
SHA1: 1d9c0a0b0f3fae6c9b076183d7aaa4ca3cb466db
SHA256: 71687dac98dcf30667a469b40440a2069fb0440311f32a8894c9c8b6e337567d
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