Package: zenoh
Version: 1.6.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.6.2), zenoh-plugin-storage-manager (=1.6.2), zenohd (=1.6.2)
Filename: 1.6.2/zenoh_1.6.2_armel.deb
Size: 12486
MD5sum: fefbaa294cd0bf129735835c8e318eab
SHA1: 4352c32c7be31660c559ac69ba522581581e5f40
SHA256: 55b6bf0dea5911805c89e1ca97e5650951216ade66984bd48783eeff158c5e2b
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.6.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.6.2), zenoh-plugin-storage-manager (=1.6.2), zenohd (=1.6.2)
Filename: 1.6.2/zenoh_1.6.2_arm64.deb
Size: 12490
MD5sum: 83f5df5af8f599321283946cbfab3cca
SHA1: e0d84b91348a0c871d0d614dc68686441cbc338c
SHA256: 49040fa4b54523844b74dcc6ee249c8244f1e0b6b5de703e88eb05225fe22c92
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.6.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.6.2), zenoh-plugin-storage-manager (=1.6.2), zenohd (=1.6.2)
Filename: 1.6.2/zenoh_1.6.2_armhf.deb
Size: 12490
MD5sum: eb16b4ab2c0b750f0e7c3032235c00b6
SHA1: 3461af8e658d16013bdff7a98e94f46feb0e8d99
SHA256: 792cd70dfc1535fb956a470c890d572ea8fccab4b8327871fea8edcda8615817
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.6.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 34
Depends: zenoh-plugin-rest (=1.6.2), zenoh-plugin-storage-manager (=1.6.2), zenohd (=1.6.2)
Filename: 1.6.2/zenoh_1.6.2_amd64.deb
Size: 12490
MD5sum: 97e91d9aca4a864cbb66cf8b2afbe1ae
SHA1: d0733a83a0d5b5d859edb248b8d86ab95d1547b3
SHA256: 99e5aa8814a85a503899b5bf8b4b5876e57d6ca739274dcc8c838f82753b5b10
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.6.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4316
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-rest_1.6.2_armhf.deb
Size: 1164614
MD5sum: 412848be2025fed809c31f6435f20dfc
SHA1: b875b83b01d7d8da6ae6088461af606d881c4a1e
SHA256: 55bdd9d8916b7b7ee28f8c6ab49c2b4b0ff2aa83f6752ec9383865e9b033a98c
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.6.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4390
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-rest_1.6.2_armel.deb
Size: 1171086
MD5sum: 9d72b83522fc4e4afa6743de70d43a70
SHA1: a21b50fdf1889071f3b9bd5c9b0322db4e249d24
SHA256: e1b3078dbc591eeb0ba6353aec89fec82a480be81beb3be2f368ef5c156cc6ee
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.6.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4617
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-rest_1.6.2_amd64.deb
Size: 1231158
MD5sum: 8d08aed2318eb1dcb5ffbe3e4c706c7b
SHA1: 31ebdb029eb5d276278054034ff69e24af6cf4fd
SHA256: 647abe837c7a4ee98cdb24900cb88396c5f47d69108331e5ad9cc02aac1d892e
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.6.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4675
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-rest_1.6.2_arm64.deb
Size: 1137614
MD5sum: c26d435d68b2feaf006d03e98d477a72
SHA1: e2220f82fce75a318d59e6ce7372f5141e557491
SHA256: 6f75e3ee1b0ee9c120928c4c7f9b4e1f2a8b00dccf54ffc02aa29b04268da535
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.6.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4486
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-storage-manager_1.6.2_arm64.deb
Size: 1085786
MD5sum: 6337720a6add05163be2ede51722534e
SHA1: 78df42b2e7a63b347ee2ab2ba5cbc728ac15f70a
SHA256: 90d58abf3ee1459a8ebb81e49e7488b7d26315348a8a7f74e30c1bdf6880d4b5
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.6.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4445
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-storage-manager_1.6.2_amd64.deb
Size: 1172774
MD5sum: 0f55b1ff1f83d861451456ee0a1ee2e0
SHA1: aa4b579c84995afa164255d08a90b6579f3102ae
SHA256: 3bc45e132674c3576c8e27ad633299f059d8c6f0c0b097f4461855abb5f69cb8
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.6.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4220
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-storage-manager_1.6.2_armel.deb
Size: 1134406
MD5sum: c451885310053554e50171ef9a8b84f1
SHA1: 3c534d0dedcc45b4af98fe7e95af05d2d677cd6a
SHA256: 07b2747712d04da73be30b2fe10e67eb301f377c30a49a377f6d6fa8069c571c
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.6.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 4127
Depends: zenohd (=1.6.2)
Filename: 1.6.2/zenoh-plugin-storage-manager_1.6.2_armhf.deb
Size: 1123422
MD5sum: 7ddd4f012900e977e161b0a55c7e437f
SHA1: 2ff2b138f89442a57856251bd1ee0e9cc0b9cfd6
SHA256: 480830ed6ec0ed96cab12befcc9ac6d5753f2344336d96223be67965636ba992
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.6.2
Architecture: armhf
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14009
Filename: 1.6.2/zenohd_1.6.2_armhf.deb
Size: 3809262
MD5sum: f0778a19b8c50760d11720eb298fa053
SHA1: 305e9df1f3dbef378ae4ea41dd485b7f49b9ff84
SHA256: e0d42c66bf2b96845014bffb0a385e5c559c74ed2d18c6fe1d717975ce8f1374
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.6.2
Architecture: armel
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 14277
Filename: 1.6.2/zenohd_1.6.2_armel.deb
Size: 3789138
MD5sum: 3b427bb2cb498b519200dd8bf886fc2a
SHA1: 8c86c72ad948f9c401b1255fb70ee5b5d07277bc
SHA256: 3e07b41f3b53ed8613c0e6f4e19292b78b289df25d8b5bf7784b91237d905c39
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.6.2
Architecture: amd64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 15197
Depends: libc6 (>= 2.34)
Filename: 1.6.2/zenohd_1.6.2_amd64.deb
Size: 4065162
MD5sum: 962593b3b1b1c632681e1e391c4ac424
SHA1: d6ef9e337dd2d8f71bc9c2355ccb8ce2aea9d250
SHA256: 58746088532e2ea8ab7da595f322bdc86f78af894d0966fb68c57e818af362a2
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.6.2
Architecture: arm64
Maintainer: zenoh-dev@eclipse.org
Installed-Size: 13649
Filename: 1.6.2/zenohd_1.6.2_arm64.deb
Size: 3617874
MD5sum: 809f935444dc3ca97e9a07557b869ef7
SHA1: 6f94ba17fc7499296653409c6724327b511abc9c
SHA256: 477b63aaed7b4efd280aee543f8a314cc7aa71199087ea29517920d6391efe5a
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