Upload 490 files

CONTRIBUTING.md

@@ -0,0 +1,44 @@
+# How to contribute to `dora-rs`
+
+We welcome bug reports, feature requests, and pull requests!
+
+Please discuss non-trivial changes in a Github issue or on Discord first before implementing them.
+This way, we can avoid unnecessary work on both sides.
+
+## Building
+
+The `dora` project is set up as a [cargo workspace](https://doc.rust-lang.org/cargo/reference/workspaces.html).
+You can use the standard `cargo check`, `cargo build`, `cargo run`, and `cargo test` commands.
+To run a command for a specific package only, pass e.g. `--package dora-daemon`.
+Running a command for the whole workspace is possible by passing `--workspace`.
+
+## Continuous Integration (CI)
+
+We're using [GitHub Actions](https://github.com/features/actions) to run automated checks on all commits and pull requests.
+These checks ensure that our `main` branch always builds successfully and that it passes all tests.
+Please ensure that your pull request passes all checks.
+You don't need to fix warnings that are unrelated to your changes.
+Feel free to ask for help if you're unsure about a check failure.
+
+We're currently running the following kind of checks:
+
+- **CI / Test:** Ensures that the project builds and that all unit tests pass. This check is run on Linux, Windows, and macOS.
+- **CI / Examples:** Builds and runs the Rust, C, and C++ dataflows from the `examples` subdirectory. This check is run on Linux, Windows, and macOS.
+- **CI-python / Python Examples:** Builds and runs the Python dataflows from the `examples` subdirectory. This check is run on Linux only.
+- **github pages / deploy:** Generates our website from the `docs` subfolder.
+- **CI / CLI Test:** Runs some basic tests of the `dora` command-line application. This check is run on Linux, Windows, and macOS.
+- **CI / Clippy:** Runs the additional checks of the [`clippy`](https://github.com/rust-lang/rust-clippy) project.
+- **CI / Formatting:** Ensures that the code is formatted using `rustfmt` (see [below](#style))
+- **CI / License Checks:** Scans the dependency tree and tries to detect possible license incompatibilities.
+
+## Style
+
+We use [`rustfmt`](https://github.com/rust-lang/rustfmt) with its default settings to format our code.
+Please run `cargo fmt --all` on your code before submitting a pull request.
+Our CI will run an automatic formatting check of your code.
+
+## Publishing new Versions
+
+The maintainers are responsible for publishing new versions of the `dora` crates.
+Please don't open unsolicited pull requests to create new releases.
+Instead, request a new version by opening an issue or by leaving a comment on a merged PR.

Cargo.toml

@@ -0,0 +1,151 @@
+[workspace]
+members = [
+    "apis/c/node",
+    "apis/c/operator",
+    "apis/c++/node",
+    "apis/c++/operator",
+    "apis/python/node",
+    "apis/python/operator",
+    "apis/rust/*",
+    "apis/rust/operator/macros",
+    "apis/rust/operator/types",
+    "binaries/cli",
+    "binaries/coordinator",
+    "binaries/daemon",
+    "binaries/runtime",
+    "examples/rust-dataflow/node",
+    "examples/rust-dataflow/status-node",
+    "examples/rust-dataflow/sink",
+    "examples/rust-ros2-dataflow/node",
+    "examples/benchmark/node",
+    "examples/benchmark/sink",
+    "examples/multiple-daemons/node",
+    "examples/multiple-daemons/operator",
+    "examples/multiple-daemons/sink",
+    "libraries/arrow-convert",
+    "libraries/communication-layer/*",
+    "libraries/core",
+    "libraries/message",
+    "libraries/shared-memory-server",
+    "libraries/extensions/download",
+    "libraries/extensions/telemetry/*",
+    "tool_nodes/dora-record",
+    "tool_nodes/dora-rerun",
+    "libraries/extensions/ros2-bridge",
+    "libraries/extensions/ros2-bridge/msg-gen",
+    "libraries/extensions/ros2-bridge/python",
+]
+
+[workspace.package]
+# Make sure to also bump `apis/node/python/__init__.py` version.
+version = "0.3.4"
+description = "`dora` goal is to be a low latency, composable, and distributed data flow."
+documentation = "https://dora.carsmos.ai"
+license = "Apache-2.0"
+
+[workspace.dependencies]
+dora-node-api = { version = "0.3.4", path = "apis/rust/node", default-features = false }
+dora-node-api-python = { version = "0.3.4", path = "apis/python/node", default-features = false }
+dora-operator-api = { version = "0.3.4", path = "apis/rust/operator", default-features = false }
+dora-operator-api-macros = { version = "0.3.4", path = "apis/rust/operator/macros" }
+dora-operator-api-types = { version = "0.3.4", path = "apis/rust/operator/types" }
+dora-operator-api-python = { version = "0.3.4", path = "apis/python/operator" }
+dora-operator-api-c = { version = "0.3.4", path = "apis/c/operator" }
+dora-node-api-c = { version = "0.3.4", path = "apis/c/node" }
+dora-core = { version = "0.3.4", path = "libraries/core" }
+dora-arrow-convert = { version = "0.3.4", path = "libraries/arrow-convert" }
+dora-tracing = { version = "0.3.4", path = "libraries/extensions/telemetry/tracing" }
+dora-metrics = { version = "0.3.4", path = "libraries/extensions/telemetry/metrics" }
+dora-download = { version = "0.3.4", path = "libraries/extensions/download" }
+shared-memory-server = { version = "0.3.4", path = "libraries/shared-memory-server" }
+communication-layer-request-reply = { version = "0.3.4", path = "libraries/communication-layer/request-reply" }
+dora-message = { version = "0.3.4", path = "libraries/message" }
+dora-runtime = { version = "0.3.4", path = "binaries/runtime" }
+dora-daemon = { version = "0.3.4", path = "binaries/daemon" }
+dora-coordinator = { version = "0.3.4", path = "binaries/coordinator" }
+dora-ros2-bridge = { path = "libraries/extensions/ros2-bridge" }
+dora-ros2-bridge-msg-gen = { path = "libraries/extensions/ros2-bridge/msg-gen" }
+dora-ros2-bridge-python = { path = "libraries/extensions/ros2-bridge/python" }
+arrow = { version = "52" }
+arrow-schema = { version = "52" }
+arrow-data = { version = "52" }
+arrow-array = { version = "52" }
+pyo3 = "0.21"
+pythonize = "0.21"
+
+[package]
+name = "dora-examples"
+version = "0.0.0"
+edition = "2021"
+license = "Apache-2.0"
+
+
+[features]
+# enables examples that depend on a sourced ROS2 installation
+ros2-examples = []
+
+[dev-dependencies]
+eyre = "0.6.8"
+tokio = "1.24.2"
+dora-coordinator = { workspace = true }
+dora-core = { workspace = true }
+dora-tracing = { workspace = true }
+dora-download = { workspace = true }
+dunce = "1.0.2"
+serde_yaml = "0.8.23"
+uuid = { version = "1.7", features = ["v7", "serde"] }
+tracing = "0.1.36"
+futures = "0.3.25"
+tokio-stream = "0.1.11"
+
+[[example]]
+name = "c-dataflow"
+path = "examples/c-dataflow/run.rs"
+
+[[example]]
+name = "rust-dataflow"
+path = "examples/rust-dataflow/run.rs"
+
+[[example]]
+name = "rust-ros2-dataflow"
+path = "examples/rust-ros2-dataflow/run.rs"
+required-features = ["ros2-examples"]
+
+# TODO: Fix example #192
+[[example]]
+name = "rust-dataflow-url"
+path = "examples/rust-dataflow-url/run.rs"
+
+[[example]]
+name = "cxx-dataflow"
+path = "examples/c++-dataflow/run.rs"
+
+[[example]]
+name = "python-dataflow"
+path = "examples/python-dataflow/run.rs"
+
+[[example]]
+name = "python-ros2-dataflow"
+path = "examples/python-ros2-dataflow/run.rs"
+required-features = ["ros2-examples"]
+
+[[example]]
+name = "python-operator-dataflow"
+path = "examples/python-operator-dataflow/run.rs"
+
+[[example]]
+name = "benchmark"
+path = "examples/benchmark/run.rs"
+
+[[example]]
+name = "multiple-daemons"
+path = "examples/multiple-daemons/run.rs"
+
+[[example]]
+name = "cmake-dataflow"
+path = "examples/cmake-dataflow/run.rs"
+
+[[example]]
+name = "cxx-ros2-dataflow"
+path = "examples/c++-ros2-dataflow/run.rs"
+required-features = ["ros2-examples"]

Changelog.md

@@ -0,0 +1,334 @@
+# Changelog
+
+## v0.3.4 (2024-05-17)
+
+## What's Changed
+
+- Remove `cxx_build` call, which is no longer used by @phil-opp in https://github.com/dora-rs/dora/pull/470
+- Update `ros2-client` to latest version by @phil-opp in https://github.com/dora-rs/dora/pull/457
+- Configurable bind addrs by @Michael-J-Ward in https://github.com/dora-rs/dora/pull/471
+- Simple warning fixes by @Michael-J-Ward in https://github.com/dora-rs/dora/pull/477
+- Adding `dora-rerun` as a visualization tool by @haixuanTao in https://github.com/dora-rs/dora/pull/479
+- Fix Clippy and RERUN_MEMORY_LIMIT env variable default by @haixuanTao in https://github.com/dora-rs/dora/pull/490
+- Fix CI build errors by @phil-opp in https://github.com/dora-rs/dora/pull/491
+- Use `resolver = 2` for in workspace in Rust template by @phil-opp in https://github.com/dora-rs/dora/pull/492
+- Add grace duration and kill process by @haixuanTao in https://github.com/dora-rs/dora/pull/487
+- Simplify parsing of `AMENT_PREFIX_PATH` by @haixuanTao in https://github.com/dora-rs/dora/pull/489
+- Convert rust example to node by @Michael-J-Ward in https://github.com/dora-rs/dora/pull/494
+- Adding python IDE typing by @haixuanTao in https://github.com/dora-rs/dora/pull/493
+- Fix: Wait until dora daemon is connected to coordinator on `dora up` by @phil-opp in https://github.com/dora-rs/dora/pull/496
+
+## New Contributors
+
+- @Michael-J-Ward made their first contribution in https://github.com/dora-rs/dora/pull/471
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.3.3...v0.3.4
+
+## v0.3.3 (2024-04-08)
+
+## What's Changed
+
+- Metrics refactoring by @haixuanTao in https://github.com/dora-rs/dora/pull/423
+- Add ROS2 bridge support for C++ nodes by @phil-opp in https://github.com/dora-rs/dora/pull/425
+- Provide function to create empty `CombinedEvents` stream by @phil-opp in https://github.com/dora-rs/dora/pull/432
+- Expose ROS2 constants in generated bindings (Rust and C++) by @phil-opp in https://github.com/dora-rs/dora/pull/428
+- Add option to send `stdout` as node/operator output by @haixuanTao in https://github.com/dora-rs/dora/pull/388
+- Fix warning about `#pragma once` in main file by @phil-opp in https://github.com/dora-rs/dora/pull/433
+- Send runs artefacts into a dedicated `out` folder by @haixuanTao in https://github.com/dora-rs/dora/pull/429
+- Create README.md for cxx-ros2-example by @bobd988 in https://github.com/dora-rs/dora/pull/431
+- Use Async Parquet Writer for `dora-record` by @haixuanTao in https://github.com/dora-rs/dora/pull/434
+- Update mio to fix security vulnerability by @phil-opp in https://github.com/dora-rs/dora/pull/440
+- Add initial support for calling ROS2 services from Rust nodes by @phil-opp in https://github.com/dora-rs/dora/pull/439
+- Enable ROS2 service calls from C++ nodes by @phil-opp in https://github.com/dora-rs/dora/pull/441
+- Use `Debug` formatting for eyre errors when returning to C++ by @phil-opp in https://github.com/dora-rs/dora/pull/450
+- Fix out-of-tree builds in cmake example by @phil-opp in https://github.com/dora-rs/dora/pull/453
+- Fix broken link in README by @mshr-h in https://github.com/dora-rs/dora/pull/462
+- fix cargo run --example cmake-dataflow compile bugs by @XxChang in https://github.com/dora-rs/dora/pull/460
+- Llm example by @haixuanTao in https://github.com/dora-rs/dora/pull/451
+- Fix meter conflict by @haixuanTao in https://github.com/dora-rs/dora/pull/461
+- Update README.md by @bobd988 in https://github.com/dora-rs/dora/pull/458
+- Refactor `README` by @haixuanTao in https://github.com/dora-rs/dora/pull/463
+- Specify conda env for Python Operators by @haixuanTao in https://github.com/dora-rs/dora/pull/468
+
+## Minor
+
+- Bump h2 from 0.3.24 to 0.3.26 by @dependabot in https://github.com/dora-rs/dora/pull/456
+- Update `bat` dependency to v0.24 by @phil-opp in https://github.com/dora-rs/dora/pull/424
+
+## New Contributors
+
+- @bobd988 made their first contribution in https://github.com/dora-rs/dora/pull/431
+
+* @mshr-h made their first contribution in https://github.com/dora-rs/dora/pull/462
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.3.2...v0.3.3
+
+## v0.3.2 (2024-01-26)
+
+## Features
+
+- Wait until `DestroyResult` is sent before exiting dora-daemon by @phil-opp in https://github.com/dora-rs/dora/pull/413
+- Reduce dora-rs to a single binary by @haixuanTao in https://github.com/dora-rs/dora/pull/410
+- Rework python ROS2 (de)serialization using parsed ROS2 messages directly by @phil-opp in https://github.com/dora-rs/dora/pull/415
+- Fix ros2 array bug by @haixuanTao in https://github.com/dora-rs/dora/pull/412
+- Test ros2 type info by @haixuanTao in https://github.com/dora-rs/dora/pull/418
+- Use forward slash as it is default way of defining ros2 topic by @haixuanTao in https://github.com/dora-rs/dora/pull/419
+
+## Minor
+
+- Bump h2 from 0.3.21 to 0.3.24 by @dependabot in https://github.com/dora-rs/dora/pull/414
+
+## v0.3.1 (2024-01-09)
+
+## Features
+
+- Support legacy python by @haixuanTao in https://github.com/dora-rs/dora/pull/382
+- Add an error catch in python `on_event` when using hot-reloading by @haixuanTao in https://github.com/dora-rs/dora/pull/372
+- add cmake example by @XxChang in https://github.com/dora-rs/dora/pull/381
+- Bump opentelemetry metrics to 0.21 by @haixuanTao in https://github.com/dora-rs/dora/pull/383
+- Trace send_output as it can be a big source of overhead for large messages by @haixuanTao in https://github.com/dora-rs/dora/pull/384
+- Adding a timeout method to not block indefinitely next event by @haixuanTao in https://github.com/dora-rs/dora/pull/386
+- Adding `Vec<u8>` conversion by @haixuanTao in https://github.com/dora-rs/dora/pull/387
+- Dora cli renaming by @haixuanTao in https://github.com/dora-rs/dora/pull/399
+- Update `ros2-client` and `rustdds` dependencies to latest fork version by @phil-opp in https://github.com/dora-rs/dora/pull/397
+
+## Fix
+
+- Fix window path error by @haixuanTao in https://github.com/dora-rs/dora/pull/398
+- Fix read error in C++ node input by @haixuanTao in https://github.com/dora-rs/dora/pull/406
+- Bump unsafe-libyaml from 0.2.9 to 0.2.10 by @dependabot in https://github.com/dora-rs/dora/pull/400
+
+## New Contributors
+
+- @XxChang made their first contribution in https://github.com/dora-rs/dora/pull/381
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.3.0...v0.3.1
+
+## v0.3.0 (2023-11-01)
+
+## Features
+
+- Rust node API typed using arrow by @phil-opp in https://github.com/dora-rs/dora/pull/353
+- Dora record by @haixuanTao in https://github.com/dora-rs/dora/pull/365
+- beautify graph visualisation by @haixuanTao in https://github.com/dora-rs/dora/pull/370
+- Remove `Ros2Value` encapsulation of `ArrayData` by @haixuanTao in https://github.com/dora-rs/dora/pull/359
+- Refactor python typing by @haixuanTao in https://github.com/dora-rs/dora/pull/369
+- Update README discord link by @Felixhuangsiling in https://github.com/dora-rs/dora/pull/361
+
+### Other
+
+- Update `rustix` v0.38 dependency by @phil-opp in https://github.com/dora-rs/dora/pull/366
+- Bump rustix from 0.37.24 to 0.37.25 by @dependabot in https://github.com/dora-rs/dora/pull/364
+- Bump quinn-proto from 0.9.3 to 0.9.5 by @dependabot in https://github.com/dora-rs/dora/pull/357
+- Bump webpki from 0.22.1 to 0.22.2 by @dependabot in https://github.com/dora-rs/dora/pull/358
+- Update README discord link by @Felixhuangsiling in https://github.com/dora-rs/dora/pull/361
+
+## New Contributors
+
+- @Felixhuangsiling made their first contribution in https://github.com/dora-rs/dora/pull/361
+
+## v0.2.6 (2023-09-14)
+
+- Update dependencies to fix some security advisories by @phil-opp in https://github.com/dora-rs/dora/pull/354
+  - Fixes `cargo install dora-daemon`
+
+## v0.2.5 (2023-09-06)
+
+### Features
+
+- Use cargo instead of git in Rust `Cargo.toml` template by @haixuanTao in https://github.com/dora-rs/dora/pull/326
+- Use read_line instead of next_line in stderr by @haixuanTao in https://github.com/dora-rs/dora/pull/325
+- Add a `rust-ros2-dataflow` example using the dora-ros2-bridge by @phil-opp in https://github.com/dora-rs/dora/pull/324
+- Removing patchelf by @haixuanTao in https://github.com/dora-rs/dora/pull/333
+- Improving python example readability by @haixuanTao in https://github.com/dora-rs/dora/pull/334
+- Use `serde_bytes` to serialize `Vec<u8>` by @haixuanTao in https://github.com/dora-rs/dora/pull/336
+- Adding support for `Arrow List(*)` for Python by @haixuanTao in https://github.com/dora-rs/dora/pull/337
+- Bump rustls-webpki from 0.100.1 to 0.100.2 by @dependabot in https://github.com/dora-rs/dora/pull/340
+- Add support for event stream merging for Python node API by @phil-opp in https://github.com/dora-rs/dora/pull/339
+- Merge `dora-ros2-bridge` by @phil-opp in https://github.com/dora-rs/dora/pull/341
+- Update dependencies by @phil-opp in https://github.com/dora-rs/dora/pull/345
+- Add support for arbitrary Arrow types in Python API by @phil-opp in https://github.com/dora-rs/dora/pull/343
+- Use typed inputs in Python ROS2 example by @phil-opp in https://github.com/dora-rs/dora/pull/346
+- Use struct type instead of array for ros2 messages by @haixuanTao in https://github.com/dora-rs/dora/pull/349
+
+### Other
+
+- Add Discord :speech_balloon: by @haixuanTao in https://github.com/dora-rs/dora/pull/348
+- Small refactoring by @haixuanTao in https://github.com/dora-rs/dora/pull/342
+
+## v0.2.4 (2023-07-18)
+
+### Features
+
+- Return dataflow result to CLI on `dora stop` by @phil-opp in https://github.com/dora-rs/dora/pull/300
+- Make dataflow descriptor available to Python nodes and operators by @phil-opp in https://github.com/dora-rs/dora/pull/301
+- Create a `CONTRIBUTING.md` guide by @phil-opp in https://github.com/dora-rs/dora/pull/307
+- Distribute prebuilt arm macos dora-rs by @haixuanTao in https://github.com/dora-rs/dora/pull/308
+
+### Other
+
+- Fix the typos and add dora code branch by @meua in https://github.com/dora-rs/dora/pull/290
+- For consistency with other examples, modify python -> python3 by @meua in https://github.com/dora-rs/dora/pull/299
+- Add timestamps generated by hybrid logical clocks to all sent events by @phil-opp in https://github.com/dora-rs/dora/pull/302
+- Don't recompile the `dora-operator-api-c` crate on every build/run by @phil-opp in https://github.com/dora-rs/dora/pull/304
+- Remove deprecated `proc_macros` feature from `safer-ffi` dependency by @phil-opp in https://github.com/dora-rs/dora/pull/305
+- Update to Rust v1.70 by @phil-opp in https://github.com/dora-rs/dora/pull/303
+- Fix issue with not finding a custom nodes path by @haixuanTao in https://github.com/dora-rs/dora/pull/315
+- Implement `Stream` for `EventStream` by @phil-opp in https://github.com/dora-rs/dora/pull/309
+- Replace unmaintained `atty` crate with `std::io::IsTerminal` by @phil-opp in https://github.com/dora-rs/dora/pull/318
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.2.3...v0.2.4
+
+## v0.2.3 (2023-05-24)
+
+## What's Changed
+
+- Check that coordinator, daemon, and node versions match by @phil-opp in https://github.com/dora-rs/dora/pull/245
+- Share events to Python without copying via `arrow` crate by @phil-opp in https://github.com/dora-rs/dora/pull/228
+- Upgrading the operator example to use `dora-arrow` by @haixuanTao in https://github.com/dora-rs/dora/pull/251
+- [Python] Show node name in process and put Traceback before the actual Error for more natural error by @haixuanTao in https://github.com/dora-rs/dora/pull/255
+- CLI: Improve error messages when coordinator is not running by @phil-opp in https://github.com/dora-rs/dora/pull/254
+- Integrate `dora-runtime` into `dora-daemon` by @phil-opp in https://github.com/dora-rs/dora/pull/257
+- Filter default log level at `warn` for `tokio::tracing` by @haixuanTao in https://github.com/dora-rs/dora/pull/269
+- Make log level filtering be `WARN` or below by @haixuanTao in https://github.com/dora-rs/dora/pull/274
+- Add support for distributed deployments with multiple daemons by @phil-opp in https://github.com/dora-rs/dora/pull/256
+- Provide a way to access logs through the CLI by @haixuanTao in https://github.com/dora-rs/dora/pull/259
+- Handle node errors during initialization phase by @phil-opp in https://github.com/dora-rs/dora/pull/275
+- Replace watchdog by asynchronous heartbeat messages by @phil-opp in https://github.com/dora-rs/dora/pull/278
+- Remove pyo3 in runtime and daemon as it generates `libpython` depende… by @haixuanTao in https://github.com/dora-rs/dora/pull/281
+- Release v0.2.3 with aarch64 support by @haixuanTao in https://github.com/dora-rs/dora/pull/279
+
+## Fix
+
+- Fix yolov5 dependency issue by @haixuanTao in https://github.com/dora-rs/dora/pull/291
+- To solve this bug https://github.com/dora-rs/dora/issues/283, unify t… by @meua in https://github.com/dora-rs/dora/pull/285
+- Fix: Don't try to create two global tracing subscribers when using bundled runtime by @phil-opp in https://github.com/dora-rs/dora/pull/277
+- CI: Increase timeout for 'build CLI and binaries' step by @phil-opp in https://github.com/dora-rs/dora/pull/282
+
+## Other
+
+- Update `pyo3` to `v0.18` by @phil-opp in https://github.com/dora-rs/dora/pull/246
+- Bump h2 from 0.3.13 to 0.3.17 by @dependabot in https://github.com/dora-rs/dora/pull/249
+- Add automatic issue labeler to organize opened issues by @haixuanTao in https://github.com/dora-rs/dora/pull/265
+- Allow the issue labeler to write issues by @phil-opp in https://github.com/dora-rs/dora/pull/272
+- Add a support matrix with planned feature to clarify dora status by @haixuanTao in https://github.com/dora-rs/dora/pull/264
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.2.2...v0.2.3
+
+## v0.2.2 (2023-04-01)
+
+### Features
+
+- Make queue length configurable through the dataflow file by @phil-opp in https://github.com/dora-rs/dora/pull/231
+- Hot reloading Python Operator by @haixuanTao in https://github.com/dora-rs/dora/pull/239
+- Synchronize node and operator start by @phil-opp in https://github.com/dora-rs/dora/pull/236
+- Add opentelemetry capability at runtime instead of compile time by @haixuanTao in https://github.com/dora-rs/dora/pull/234
+
+### Others
+
+- Wait on events and messages simultaneously to prevent queue buildup by @phil-opp in https://github.com/dora-rs/dora/pull/235
+- Fix looping in daemon listener loop by @phil-opp in https://github.com/dora-rs/dora/pull/244
+- Validate shell command as source and url source by @haixuanTao in https://github.com/dora-rs/dora/pull/243
+- Push error into the `init_done` channel for debugging context by @haixuanTao in https://github.com/dora-rs/dora/pull/238
+- Option communication config by @haixuanTao in https://github.com/dora-rs/dora/pull/241
+- Validate yaml when reading by @haixuanTao in https://github.com/dora-rs/dora/pull/237
+
+**Full Changelog**: https://github.com/dora-rs/dora/compare/v0.2.1...v0.2.2
+
+## v0.2.1 (2023-03-22)
+
+### Features
+
+- [Make dora-rs publishable on crates.io](https://github.com/dora-rs/dora/pull/211)
+
+### Fixes
+
+- [Avoid blocking the daemon main loop by using unbounded queue](https://github.com/dora-rs/dora/pull/230)
+- [Inject YAML declared env variable into the runtime](https://github.com/dora-rs/dora/pull/227)
+- [Use rustls instead of system SSL implementation](https://github.com/dora-rs/dora/pull/216)
+
+### Other
+
+- [Refactor python error](https://github.com/dora-rs/dora/pull/229)
+- [The first letter of rust should be lowercase in the command](https://github.com/dora-rs/dora/pull/226)
+- [Add documentation to the cli within the helper mode](https://github.com/dora-rs/dora/pull/225)
+- [Update to safer-ffi v0.1.0-rc1](https://github.com/dora-rs/dora/pull/218)
+- [remove unused variable: data_bytes](https://github.com/dora-rs/dora/pull/215)
+- [Clean up: Remove workspace path](https://github.com/dora-rs/dora/pull/210)
+- [Decouple opentelemetry from tracing](https://github.com/dora-rs/dora/pull/222)
+- [Remove zenoh dependency from dora node API to speed up build](https://github.com/dora-rs/dora/pull/220)
+- [Update to Rust v1.68](https://github.com/dora-rs/dora/pull/221)
+- [Deny unknown fields to avoid typos](https://github.com/dora-rs/dora/pull/223)
+- [Add an internal cli argument to create template with path dependencies](https://github.com/dora-rs/dora/pull/212)
+
+## v0.2.0 (2023-03-14)
+
+### Breaking
+
+- [Redesign: Create a `dora-daemon` as a communication broker](https://github.com/dora-rs/dora/pull/162)
+  - New `dora-daemon` executable that acts as a communication hub for all local nodes
+  - Large messages are passed through shared memory without any copying
+  - [Replaces the previous `iceoryx` communication layer](https://github.com/dora-rs/dora/pull/201)
+  - Small API change: Nodes and operators now receive _events_ instead of just inputs
+    - Inputs are one type of event
+    - Other supported events: `InputClosed` when an input stream is closed and `Stop` when the user stops the dataflow (e.g. through the CLI)
+
+### Features
+
+- Better Error handling when operator fails
+- [Send small messages directly without shared memory](https://github.com/dora-rs/dora/pull/193)
+- [Send all queued incoming events at once on `NextEvent` request](https://github.com/dora-rs/dora/pull/194)
+- [Don't send replies for `SendMessage` requests when using TCP](https://github.com/dora-rs/dora/pull/195)
+- [Allocate shared memory in nodes to improve throughput](https://github.com/dora-rs/dora/pull/200)
+
+### Fixes
+
+- [Manage node failure: Await all nodes to finish before marking dataflow as finished](https://github.com/dora-rs/dora/pull/183)
+
+### Other
+
+- [Use `DoraStatus` from dora library in template](https://github.com/dora-rs/dora/pull/182)
+- [Simplify: Replace `library_filename` function with `format!` call](https://github.com/dora-rs/dora/pull/191)
+- [Refactor Rust node API implementation](https://github.com/dora-rs/dora/pull/196)
+- [Remove code duplicate for tracing subscriber and use env variable to manage log level.](https://github.com/dora-rs/dora/pull/197)
+- [Add daemon to the release archive](https://github.com/dora-rs/dora/pull/199)
+- [Remove `remove_dir_all` from `Cargo.lock`as it is vulnerable to a race condition according to dependabot](https://github.com/dora-rs/dora/pull/202)
+- [Update the documentation to the new daemon format](https://github.com/dora-rs/dora/pull/198)
+- [Removing legacy `libacl` which was required by Iceoryx](https://github.com/dora-rs/dora/pull/205)
+- [Remove unimplemented CLI arguments for now](https://github.com/dora-rs/dora/pull/207)
+- [Update zenoh to remove git dependencies](https://github.com/dora-rs/dora/pull/203)
+- [Fix cli template to new daemon API](https://github.com/dora-rs/dora/pull/204)
+- [Cleanup warnings](https://github.com/dora-rs/dora/pull/208)
+- Dependency updates
+
+## v0.1.3 (2023-01-18)
+
+- Package `DoraStatus` into dora python package: https://github.com/dora-rs/dora/pull/172
+- Force removal of Pyo3 Object to avoid memory leak: https://github.com/dora-rs/dora/pull/168
+- Bump tokio from 1.21.2 to 1.23.1: https://github.com/dora-rs/dora/pull/171
+- Create a changelog file: https://github.com/dora-rs/dora/pull/174
+
+## v0.1.2 (2022-12-15)
+
+- Fix infinite loop in the coordinator: https://github.com/dora-rs/dora/pull/155
+- Simplify the release process: https://github.com/dora-rs/dora/pull/157
+- Use generic linux distribution: https://github.com/dora-rs/dora/pull/159
+
+## v0.1.1 (2022-12-05)
+
+This release contains fixes for:
+
+- Python linking using pypi release but also a redesigned python thread model within the runtime to avoid deadlock of the `GIL`. This also fix an issue with `patchelf`.
+- A deployment separation for `ubuntu` as the `20.04` version of `dora` and `22.04` version of dora are non-compatible.
+- A better tagging of api for `dora` Rust API.
+
+## v0.1.0 (2022-11-15)
+
+This is our first release of `dora-rs`!
+
+The current release includes:
+
+- `dora-cli` which enables creating, starting and stopping dataflow.
+- `dora-coordinator` which is our control plane.
+- `dora-runtime` which is manage the runtime of operators.
+- `custom-nodes` API which enables bridges from different languages.

NOTICE.md

@@ -0,0 +1,7 @@
+## Copyright
+
+All content is the property of the respective authors or their employers. For more information regarding authorship of content, please consult the listed source code repository logs.
+
+## License
+
+This project is licensed under the Apache License, Version 2.0 ([LICENSE](LICENSE) or <http://www.apache.org/licenses/LICENSE-2.0>). Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.

apis/c++/node/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "dora-node-api-cxx"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["staticlib"]
+
+[features]
+default = ["tracing"]
+tracing = ["dora-node-api/tracing"]
+ros2-bridge = [
+    "dep:dora-ros2-bridge",
+    "dep:dora-ros2-bridge-msg-gen",
+    "dep:rust-format",
+    "dep:prettyplease",
+    "dep:serde",
+    "dep:serde-big-array",
+]
+
+[dependencies]
+cxx = "1.0.73"
+dora-node-api = { workspace = true }
+eyre = "0.6.8"
+dora-ros2-bridge = { workspace = true, optional = true }
+futures-lite = { version = "2.2" }
+serde = { version = "1.0.164", features = ["derive"], optional = true }
+serde-big-array = { version = "0.5.1", optional = true }
+
+[build-dependencies]
+cxx-build = "1.0.73"
+dora-ros2-bridge-msg-gen = { workspace = true, optional = true }
+rust-format = { version = "0.3.4", features = [
+    "pretty_please",
+], optional = true }
+prettyplease = { version = "0.1", features = ["verbatim"], optional = true }

apis/c++/node/README.md

@@ -0,0 +1,321 @@
+# Dora Node API for C++
+
+Dora supports nodes written in C++ through this API crate.
+
+## Build
+
+- Clone the `dora` repository:
+  ```bash
+  > git clone https://github.com/dora-rs/dora.git
+  > cd dora
+  ```
+- Build the `dora-node-api-cxx` package:
+  ```bash
+  cargo build --package dora-node-api-cxx
+  ```
+  - This will result in `dora-node-api.h` and `dora-node-api.cc` files in the `target/cxxbridge/dora-node-api-cxx` directory.
+- Include the `dora-node-api.h` header file in your source file.
+- Add the `dora-node-api.cc` file to your compile and link steps.
+
+### Build with ROS2 Bridge
+
+Dora features an experimental ROS2 Bridge that enables dora nodes to publish and subscribe to ROS2 topics.
+To enable the bridge, use these steps:
+
+- Clone the `dora` repository (see above).
+- Source the ROS2 setup files (see [ROS2 docs](https://docs.ros.org/en/rolling/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.html#source-the-setup-files))
+- Optional: Source package-specific ROS2 setup files if you want to use custom package-specific ROS2 messages in the bridge (see [ROS2 docs](https://docs.ros.org/en/rolling/Tutorials/Beginner-Client-Libraries/Creating-Your-First-ROS2-Package.html#source-the-setup-file))
+- Build the `dora-node-api-cxx` package **with the `ros2-bridge` feature enabled**:
+  ```bash
+  cargo build --package dora-node-api-cxx --features ros2-bridge
+  ```
+  - In addition to the `dora-node-api.h` and `dora-node-api.cc` files, this will place a `dora-ros2-bindings.h` and a `dora-ros2-bindings.cc` file in the `target/cxxbridge/dora-node-api-cxx` directory.
+- Include both the `dora-node-api.h` and the `dora-ros2-bindings.h` header files in your source file.
+- Add the `dora-node-api.cc` and `dora-ros2-bindings.cc` files to your compile and link steps.
+
+## Usage
+
+The `dora-node-api.h` header provides various functions to interact with Dora.
+
+### Init Dora Node
+
+All nodes need to register themselves with Dora at startup.
+To do that, call the `init_dora_node()` function.
+The function returns a `DoraNode` instance, which gives access to dora events and enables sending Dora outputs.
+
+```c++
+auto dora_node = init_dora_node();
+```
+
+### Receiving Events
+
+The `dora_node.events` field is a stream of incoming events.
+To wait for the next incoming event, call `dora_node.events->next()`:
+
+```c++
+auto event = dora_node.events->next();
+```
+
+The `next` function returns an opaque `DoraEvent` type, which cannot be inspected from C++ directly.
+Instead, use the following functions to read and destructure the event:
+
+- `event_type(event)` returns a `DoraEventType`, which describes the kind of event. For example, an event could be an input or a stop instruction.
+  - when receiving a `DoraEventType::AllInputsClosed`, the node should exit and not call `next` anymore
+- Events of type `DoraEventType::Input` can be downcasted using `event_as_input`:
+  ```c++
+  auto input = event_as_input(std::move(event));
+  ```
+  The function returns a `DoraInput` instance, which has an `id` and `data` field.
+  - The input `id` can be converted to a C++ string through `std::string(input.id)`.
+  - The `data` of inputs is currently of type [`rust::Vec<uint8_t>`](https://cxx.rs/binding/vec.html). Use the provided methods for reading or converting the data.
+    - **Note:** In the future, we plan to change the data type to the [Apache Arrow](https://arrow.apache.org/) data format to support typed inputs.
+
+### Sending Outputs
+
+Nodes can send outputs using the `send_output` output function and the `dora_node.send_output` field.
+Note that all outputs need to be listed in the dataflow YAML declaration file, otherwise an error will occur.
+
+**Example:**
+
+```c++
+// the data you want to send (NOTE: only byte vectors are supported right now)
+std::vector<uint8_t> out_vec{42};
+// create a Rust slice from the output vector
+rust::Slice<const uint8_t> out_slice{out_vec.data(), out_vec.size()};
+// send the slice as output
+auto result = send_output(dora_node.send_output, "output_id", out_slice);
+
+// check for errors
+auto error = std::string(result.error);
+if (!error.empty())
+{
+    std::cerr << "Error: " << error << std::endl;
+    return -1;
+}
+```
+
+## Using the ROS2 Bridge
+
+The `dora-ros2-bindings.h` contains function and struct definitions that allow interacting with ROS2 nodes.
+Currently, the bridge supports publishing and subscribing to ROS2 topics.
+In the future, we plan to support ROS2 services and ROS2 actions as well.
+
+### Initializing the ROS2 Context
+
+The first step is to initialize a ROS2 context:
+
+```c++
+auto ros2_context = init_ros2_context();
+```
+
+### Creating Nodes
+
+After initializing a ROS2 context, you can use it to create ROS2 nodes:
+
+```c++
+auto node = ros2_context->new_node("/ros2_demo", "turtle_teleop");
+```
+
+The first argument is the namespace of the node and the second argument is its name.
+
+### Creating Topics
+
+After creating a node, you can use one of the `create_topic_<TYPE>` functions to create a topic on it.
+The `<TYPE>` describes the message type that will be sent on the topic.
+The Dora ROS2 bridge automatically creates `create_topic_<TYPE>` functions for all messages types found in the sourced ROS2 environment.
+
+```c++
+auto vel_topic = node->create_topic_geometry_msgs_Twist("/turtle1", "cmd_vel", qos_default());
+```
+
+The first argument is the namespace of the topic and the second argument is its name.
+The third argument is the QoS (quality of service) setting for the topic.
+It can be adjusted as desired, for example:
+
+```c++
+auto qos = qos_default();
+qos.durability = Ros2Durability::Volatile;
+qos.liveliness = Ros2Liveliness::Automatic;
+auto vel_topic = node->create_topic_geometry_msgs_Twist("/turtle1", "cmd_vel", qos);
+```
+
+### Publish
+
+After creating a topic, it is possible to publish messages on it.
+First, create a publisher:
+
+```c++
+auto vel_publisher = node->create_publisher(vel_topic, qos);
+```
+
+The returned publisher is typed by the chosen topic.
+It will only accept messages of the topic's type, otherwise a compile error will occur.
+
+After creating a publisher, you can use the `publish` function to publish one or more messages.
+For example:
+
+```c++
+geometry_msgs::Twist twist = {
+    .linear = {.x = 1, .y = 0, .z = 0},
+    .angular = {.x = 0, .y = 0, .z = 0.5}
+};
+vel_publisher->publish(twist);
+```
+
+The `geometry_msgs::Twist` struct is automatically generated from the sourced ROS2 environment.
+Since the publisher is typed, its `publish` method only accepts `geometry_msgs::Twist` messages.
+
+
+### Subscriptions
+
+Subscribing to a topic is possible through the `create_subscription` function on nodes:
+
+```c++
+auto pose_topic = node->create_topic_turtlesim_Pose("/turtle1", "pose", qos_default());
+auto pose_subscription = node->create_subscription(pose_topic, qos_default(), event_stream);
+```
+
+The `topic` is the topic you want to subscribe to, created using a `create_topic_<TYPE>` function.
+The second argument is the quality of service setting, which can be customized as described above.
+
+The third parameter is the event stream that the received messages should be merged into.
+Multiple subscriptions can be merged into the same event stream.
+
+#### Combined Event Streams
+
+Combined event streams enable the merging of multiple event streams into one.
+The combined stream will then deliver messages from all sources, in order of arrival.
+
+You can create such a event stream from Dora's event stream using the `dora_events_into_combined` function:
+
+```c++
+auto event_stream = dora_events_into_combined(std::move(dora_node.events));
+```
+
+Alternatively, if you don't want to use Dora, you can also create an empty event stream:
+
+```c++
+auto event_stream = empty_combined_events();
+```
+
+**Note:** You should only use `empty_combined_events` if you're running your executable independent of Dora.
+Ignoring the events from the `dora_node.events` channel can result in unintended behavior.
+
+#### Receiving Messages from Combined Event Stream
+
+The merged event stream will receive all incoming events of the node, including Dora events and ROS2 messages.
+To wait for the next incoming event, use its `next` method:
+
+```c++
+auto event = event_stream.next();
+```
+
+This returns a `event` instance of type `CombinedEvent`, which can be downcasted to Dora events or ROS2 messages.
+To handle an event, you should check it's type and then downcast it:
+
+- To check for a Dora event, you can use the `is_dora()` function. If it returns `true`, you can downcast the combined event to a Dora event using the `downcast_dora` function.
+- ROS2 subscriptions support a `matches` function to check whether a combined event is an instance of the respective ROS2 subscription. If it returns true, you can downcast the event to the respective ROS2 message struct using the subscription's `downcast` function.
+
+**Example:**
+
+```c++
+if (event.is_dora())
+{
+    auto dora_event = downcast_dora(std::move(event));
+    // handle dora_event as described above
+    auto ty = event_type(dora_event);
+    if (ty == DoraEventType::Input)
+    {
+        auto input = event_as_input(std::move(dora_event));
+        // etc
+    }
+    // .. else if
+}
+else if (pose_subscription->matches(event))
+{
+    auto pose = pose_subscription->downcast(std::move(event));
+    std::cout << "Received pose x:" << pose.x << ", y:" << pose.y << std::endl;
+}
+else
+{
+    std::cout << "received unexpected event" << std::endl;
+}
+```
+
+### Constants
+
+Some ROS2 message definitions define constants, e.g. to specify the values of an enum-like integer field.
+The Dora ROS2 bridge exposes these constants in the generated bindings as functions.
+
+For example, the `STATUS_NO_FIX` constant of the [`NavSatStatus` message](https://docs.ros.org/en/jade/api/sensor_msgs/html/msg/NavSatStatus.html) can be accessed as follows:
+
+```c++
+assert((sensor_msgs::const_NavSatStatus_STATUS_NO_FIX() == -1));
+```
+
+(Note: Exposing them as C++ constants is not possible because it's [not supported by `cxx` yet](https://github.com/dtolnay/cxx/issues/1051).)
+
+### Service Clients
+
+To create a service client, use one of the `create_client_<TYPE>` functions.
+The `<TYPE>` describes the service type, which specifies the request and response types.
+The Dora ROS2 bridge automatically creates `create_client_<TYPE>` functions for all service types found in the sourced ROS2 environment.
+
+```c++
+auto add_two_ints = node->create_client_example_interfaces_AddTwoInts(
+  "/",
+  "add_two_ints",
+  qos,
+  merged_events
+);
+```
+
+- The first argument is the namespace of the service and the second argument is its name.
+- The third argument is the QoS (quality of service) setting for the service.
+  It can be set to `qos_default()` or adjusted as desired, for example:
+  ```c++
+  auto qos = qos_default();
+  qos.reliable = true;
+  qos.max_blocking_time = 0.1;
+  qos.keep_last = 1;
+  ```
+- The last argument is the [combined event stream](#combined-event-streams) that the received service responses should be merged into.
+
+#### Waiting for the Service
+
+In order to achieve reliable service communication, it is recommended to wait until the service is available before sending requests.
+Use the `wait_for_service()` method for that, e.g.:
+
+```c++
+add_two_ints->wait_for_service(node)
+```
+
+The given `node` must be the node on which the service was created.
+
+#### Sending Requests
+
+To send a request, use the `send_request` method:
+
+```c++
+add_two_ints->send_request(request);
+```
+
+The method sends the request asynchronously without waiting for a response.
+When the response is received, it is automatically sent to the [combined event stream](#combined-event-streams) that was given on client creation.
+
+#### Receiving Responses
+
+See the [_"Receiving Messages from Combined Event Stream"_](#receiving-messages-from-combined-event-stream) section for how to receive events from the combined event stream.
+To check if a received event is a service response, use the `matches` method.
+If it returns `true`, you can use the `downcast` method to convert the event to the correct service response type.
+
+Example:
+
+```c++
+if (add_two_ints->matches(event))
+{
+    auto response = add_two_ints->downcast(std::move(event));
+    std::cout << "Received sum response with value " << response.sum << std::endl;
+    ...
+}
+```

apis/c++/node/build.rs

@@ -0,0 +1,159 @@
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let mut bridge_files = vec![PathBuf::from("src/lib.rs")];
+    #[cfg(feature = "ros2-bridge")]
+    bridge_files.push(ros2::generate());
+
+    let _build = cxx_build::bridges(&bridge_files);
+    println!("cargo:rerun-if-changed=src/lib.rs");
+
+    // rename header files
+    let src_dir = target_dir()
+        .join("cxxbridge")
+        .join("dora-node-api-cxx")
+        .join("src");
+    let target_dir = src_dir.parent().unwrap();
+    std::fs::copy(src_dir.join("lib.rs.h"), target_dir.join("dora-node-api.h")).unwrap();
+    std::fs::copy(
+        src_dir.join("lib.rs.cc"),
+        target_dir.join("dora-node-api.cc"),
+    )
+    .unwrap();
+
+    #[cfg(feature = "ros2-bridge")]
+    ros2::generate_ros2_message_header(bridge_files.last().unwrap());
+
+    // to avoid unnecessary `mut` warning
+    bridge_files.clear();
+}
+
+fn target_dir() -> PathBuf {
+    std::env::var("CARGO_TARGET_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+                .ancestors()
+                .nth(3)
+                .unwrap();
+            root.join("target")
+        })
+}
+
+#[cfg(feature = "ros2-bridge")]
+mod ros2 {
+    use super::target_dir;
+    use std::{
+        io::{BufRead, BufReader},
+        path::{Component, Path, PathBuf},
+    };
+
+    pub fn generate() -> PathBuf {
+        use rust_format::Formatter;
+        let paths = ament_prefix_paths();
+        let generated = dora_ros2_bridge_msg_gen::gen(paths.as_slice(), true);
+        let generated_string = rust_format::PrettyPlease::default()
+            .format_tokens(generated)
+            .unwrap();
+        let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+        let target_file = out_dir.join("ros2_bindings.rs");
+        std::fs::write(&target_file, generated_string).unwrap();
+        println!(
+            "cargo:rustc-env=ROS2_BINDINGS_PATH={}",
+            target_file.display()
+        );
+
+        target_file
+    }
+
+    fn ament_prefix_paths() -> Vec<PathBuf> {
+        let ament_prefix_path: String = match std::env::var("AMENT_PREFIX_PATH") {
+            Ok(path) => path,
+            Err(std::env::VarError::NotPresent) => {
+                println!("cargo:warning='AMENT_PREFIX_PATH not set'");
+                String::new()
+            }
+            Err(std::env::VarError::NotUnicode(s)) => {
+                panic!(
+                    "AMENT_PREFIX_PATH is not valid unicode: `{}`",
+                    s.to_string_lossy()
+                );
+            }
+        };
+        println!("cargo:rerun-if-env-changed=AMENT_PREFIX_PATH");
+
+        let paths: Vec<_> = ament_prefix_path.split(':').map(PathBuf::from).collect();
+        for path in &paths {
+            println!("cargo:rerun-if-changed={}", path.display());
+        }
+
+        paths
+    }
+
+    pub fn generate_ros2_message_header(source_file: &Path) {
+        use std::io::Write as _;
+
+        let out_dir = source_file.parent().unwrap();
+        let relative_path = local_relative_path(&source_file)
+            .ancestors()
+            .nth(2)
+            .unwrap()
+            .join("out");
+        let header_path = out_dir
+            .join("cxxbridge")
+            .join("include")
+            .join("dora-node-api-cxx")
+            .join(&relative_path)
+            .join("ros2_bindings.rs.h");
+        let code_path = out_dir
+            .join("cxxbridge")
+            .join("sources")
+            .join("dora-node-api-cxx")
+            .join(&relative_path)
+            .join("ros2_bindings.rs.cc");
+
+        // copy message files to target directory
+        let target_path = target_dir()
+            .join("cxxbridge")
+            .join("dora-node-api-cxx")
+            .join("dora-ros2-bindings.h");
+
+        std::fs::copy(&header_path, &target_path).unwrap();
+        println!("cargo:rerun-if-changed={}", header_path.display());
+
+        let node_header =
+            std::fs::File::open(target_path.with_file_name("dora-node-api.h")).unwrap();
+        let mut code_file = std::fs::File::open(&code_path).unwrap();
+        println!("cargo:rerun-if-changed={}", code_path.display());
+        let mut code_target_file =
+            std::fs::File::create(target_path.with_file_name("dora-ros2-bindings.cc")).unwrap();
+
+        // copy both the node header and the code file to prevent import errors
+        let mut header_reader = {
+            let mut reader = BufReader::new(node_header);
+
+            // read first line to skip `#pragma once`, which is not allowed in main files
+            let mut first_line = String::new();
+            reader.read_line(&mut first_line).unwrap();
+            assert_eq!(first_line.trim(), "#pragma once");
+
+            reader
+        };
+        std::io::copy(&mut header_reader, &mut code_target_file).unwrap();
+        std::io::copy(&mut code_file, &mut code_target_file).unwrap();
+        code_target_file.flush().unwrap();
+    }
+
+    // copy from cxx-build source
+    fn local_relative_path(path: &Path) -> PathBuf {
+        let mut rel_path = PathBuf::new();
+        for component in path.components() {
+            match component {
+                Component::Prefix(_) | Component::RootDir | Component::CurDir => {}
+                Component::ParentDir => drop(rel_path.pop()), // noop if empty
+                Component::Normal(name) => rel_path.push(name),
+            }
+        }
+        rel_path
+    }
+}

apis/c++/node/src/lib.rs

@@ -0,0 +1,225 @@
+use std::any::Any;
+
+use dora_node_api::{
+    self,
+    arrow::array::{AsArray, BinaryArray},
+    merged::{MergeExternal, MergedEvent},
+    Event, EventStream,
+};
+use eyre::bail;
+
+#[cfg(feature = "ros2-bridge")]
+use dora_ros2_bridge::{_core, ros2_client};
+use futures_lite::{stream, Stream, StreamExt};
+
+#[cxx::bridge]
+#[allow(clippy::needless_lifetimes)]
+mod ffi {
+    struct DoraNode {
+        events: Box<Events>,
+        send_output: Box<OutputSender>,
+    }
+
+    pub enum DoraEventType {
+        Stop,
+        Input,
+        InputClosed,
+        Error,
+        Unknown,
+        AllInputsClosed,
+    }
+
+    struct DoraInput {
+        id: String,
+        data: Vec<u8>,
+    }
+
+    struct DoraResult {
+        error: String,
+    }
+
+    pub struct CombinedEvents {
+        events: Box<MergedEvents>,
+    }
+
+    pub struct CombinedEvent {
+        event: Box<MergedDoraEvent>,
+    }
+
+    extern "Rust" {
+        type Events;
+        type OutputSender;
+        type DoraEvent;
+        type MergedEvents;
+        type MergedDoraEvent;
+
+        fn init_dora_node() -> Result<DoraNode>;
+
+        fn dora_events_into_combined(events: Box<Events>) -> CombinedEvents;
+        fn empty_combined_events() -> CombinedEvents;
+        fn next(self: &mut Events) -> Box<DoraEvent>;
+        fn next_event(events: &mut Box<Events>) -> Box<DoraEvent>;
+        fn event_type(event: &Box<DoraEvent>) -> DoraEventType;
+        fn event_as_input(event: Box<DoraEvent>) -> Result<DoraInput>;
+        fn send_output(
+            output_sender: &mut Box<OutputSender>,
+            id: String,
+            data: &[u8],
+        ) -> DoraResult;
+
+        fn next(self: &mut CombinedEvents) -> CombinedEvent;
+
+        fn is_dora(self: &CombinedEvent) -> bool;
+        fn downcast_dora(event: CombinedEvent) -> Result<Box<DoraEvent>>;
+    }
+}
+
+#[cfg(feature = "ros2-bridge")]
+pub mod ros2 {
+    pub use dora_ros2_bridge::*;
+    include!(env!("ROS2_BINDINGS_PATH"));
+}
+
+fn init_dora_node() -> eyre::Result<ffi::DoraNode> {
+    let (node, events) = dora_node_api::DoraNode::init_from_env()?;
+    let events = Events(events);
+    let send_output = OutputSender(node);
+
+    Ok(ffi::DoraNode {
+        events: Box::new(events),
+        send_output: Box::new(send_output),
+    })
+}
+
+pub struct Events(EventStream);
+
+impl Events {
+    fn next(&mut self) -> Box<DoraEvent> {
+        Box::new(DoraEvent(self.0.recv()))
+    }
+}
+
+fn next_event(events: &mut Box<Events>) -> Box<DoraEvent> {
+    events.next()
+}
+
+fn dora_events_into_combined(events: Box<Events>) -> ffi::CombinedEvents {
+    let events = events.0.map(MergedEvent::Dora);
+    ffi::CombinedEvents {
+        events: Box::new(MergedEvents {
+            events: Some(Box::new(events)),
+            next_id: 1,
+        }),
+    }
+}
+
+fn empty_combined_events() -> ffi::CombinedEvents {
+    ffi::CombinedEvents {
+        events: Box::new(MergedEvents {
+            events: Some(Box::new(stream::empty())),
+            next_id: 1,
+        }),
+    }
+}
+
+pub struct DoraEvent(Option<Event>);
+
+fn event_type(event: &DoraEvent) -> ffi::DoraEventType {
+    match &event.0 {
+        Some(event) => match event {
+            Event::Stop => ffi::DoraEventType::Stop,
+            Event::Input { .. } => ffi::DoraEventType::Input,
+            Event::InputClosed { .. } => ffi::DoraEventType::InputClosed,
+            Event::Error(_) => ffi::DoraEventType::Error,
+            _ => ffi::DoraEventType::Unknown,
+        },
+        None => ffi::DoraEventType::AllInputsClosed,
+    }
+}
+
+fn event_as_input(event: Box<DoraEvent>) -> eyre::Result<ffi::DoraInput> {
+    let Some(Event::Input {
+        id,
+        metadata: _,
+        data,
+    }) = event.0
+    else {
+        bail!("not an input event");
+    };
+    let data: Option<&BinaryArray> = data.as_binary_opt();
+    Ok(ffi::DoraInput {
+        id: id.into(),
+        data: data.map(|d| d.value(0).to_owned()).unwrap_or_default(),
+    })
+}
+
+pub struct OutputSender(dora_node_api::DoraNode);
+
+fn send_output(sender: &mut Box<OutputSender>, id: String, data: &[u8]) -> ffi::DoraResult {
+    let result = sender
+        .0
+        .send_output_raw(id.into(), Default::default(), data.len(), |out| {
+            out.copy_from_slice(data)
+        });
+    let error = match result {
+        Ok(()) => String::new(),
+        Err(err) => format!("{err:?}"),
+    };
+    ffi::DoraResult { error }
+}
+
+pub struct MergedEvents {
+    events: Option<Box<dyn Stream<Item = MergedEvent<ExternalEvent>> + Unpin>>,
+    next_id: u32,
+}
+
+impl MergedEvents {
+    fn next(&mut self) -> MergedDoraEvent {
+        let event = futures_lite::future::block_on(self.events.as_mut().unwrap().next());
+        MergedDoraEvent(event)
+    }
+
+    pub fn merge(&mut self, events: impl Stream<Item = Box<dyn Any>> + Unpin + 'static) -> u32 {
+        let id = self.next_id;
+        self.next_id += 1;
+        let events = Box::pin(events.map(move |event| ExternalEvent { event, id }));
+
+        let inner = self.events.take().unwrap();
+        let merged: Box<dyn Stream<Item = _> + Unpin + 'static> =
+            Box::new(inner.merge_external(events).map(|event| match event {
+                MergedEvent::Dora(event) => MergedEvent::Dora(event),
+                MergedEvent::External(event) => MergedEvent::External(event.flatten()),
+            }));
+        self.events = Some(merged);
+
+        id
+    }
+}
+
+impl ffi::CombinedEvents {
+    fn next(&mut self) -> ffi::CombinedEvent {
+        ffi::CombinedEvent {
+            event: Box::new(self.events.next()),
+        }
+    }
+}
+
+pub struct MergedDoraEvent(Option<MergedEvent<ExternalEvent>>);
+
+pub struct ExternalEvent {
+    pub event: Box<dyn Any>,
+    pub id: u32,
+}
+
+impl ffi::CombinedEvent {
+    fn is_dora(&self) -> bool {
+        matches!(&self.event.0, Some(MergedEvent::Dora(_)))
+    }
+}
+
+fn downcast_dora(event: ffi::CombinedEvent) -> eyre::Result<Box<DoraEvent>> {
+    match event.event.0 {
+        Some(MergedEvent::Dora(event)) => Ok(Box::new(DoraEvent(Some(event)))),
+        _ => eyre::bail!("not an external event"),
+    }
+}

apis/c++/operator/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "dora-operator-api-cxx"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+cxx = "1.0.73"
+dora-operator-api = { workspace = true }
+
+[build-dependencies]
+cxx-build = "1.0.73"

apis/c++/operator/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    let _ = cxx_build::bridge("src/lib.rs");
+    println!("cargo:rerun-if-changed=src/lib.rs");
+}

apis/c++/operator/src/lib.rs

@@ -0,0 +1,98 @@
+#![cfg(not(test))]
+#![warn(unsafe_op_in_unsafe_fn)]
+
+use dora_operator_api::{
+    self, register_operator, DoraOperator, DoraOutputSender, DoraStatus, Event, IntoArrow,
+};
+use ffi::DoraSendOutputResult;
+
+#[cxx::bridge]
+#[allow(unsafe_op_in_unsafe_fn)]
+mod ffi {
+    struct DoraOnInputResult {
+        error: String,
+        stop: bool,
+    }
+
+    struct DoraSendOutputResult {
+        error: String,
+    }
+
+    extern "Rust" {
+        type OutputSender<'a, 'b>;
+
+        fn send_output(sender: &mut OutputSender, id: &str, data: &[u8]) -> DoraSendOutputResult;
+    }
+
+    unsafe extern "C++" {
+        include!("operator.h");
+
+        type Operator;
+
+        fn new_operator() -> UniquePtr<Operator>;
+
+        fn on_input(
+            op: Pin<&mut Operator>,
+            id: &str,
+            data: &[u8],
+            output_sender: &mut OutputSender,
+        ) -> DoraOnInputResult;
+    }
+}
+
+pub struct OutputSender<'a, 'b>(&'a mut DoraOutputSender<'b>);
+
+fn send_output(sender: &mut OutputSender, id: &str, data: &[u8]) -> DoraSendOutputResult {
+    let error = sender
+        .0
+        .send(id.into(), data.to_owned().into_arrow())
+        .err()
+        .unwrap_or_default();
+    DoraSendOutputResult { error }
+}
+
+register_operator!(OperatorWrapper);
+
+struct OperatorWrapper {
+    operator: cxx::UniquePtr<ffi::Operator>,
+}
+
+impl Default for OperatorWrapper {
+    fn default() -> Self {
+        Self {
+            operator: ffi::new_operator(),
+        }
+    }
+}
+
+impl DoraOperator for OperatorWrapper {
+    fn on_event(
+        &mut self,
+        event: &Event,
+        output_sender: &mut DoraOutputSender,
+    ) -> Result<DoraStatus, std::string::String> {
+        match event {
+            Event::Input { id, data } => {
+                let operator = self.operator.as_mut().unwrap();
+                let mut output_sender = OutputSender(output_sender);
+                let data: &[u8] = data
+                    .try_into()
+                    .map_err(|err| format!("expected byte array: {err}"))?;
+
+                let result = ffi::on_input(operator, id, data, &mut output_sender);
+                if result.error.is_empty() {
+                    Ok(match result.stop {
+                        false => DoraStatus::Continue,
+                        true => DoraStatus::Stop,
+                    })
+                } else {
+                    Err(result.error)
+                }
+            }
+            _ => {
+                // ignore other events for now
+                Ok(DoraStatus::Continue)
+            }
+        }
+    }
+}

apis/c/node/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "dora-node-api-c"
+version.workspace = true
+edition = "2021"
+
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["staticlib", "lib"]
+
+
+[features]
+default = ["tracing"]
+tracing = ["dora-node-api/tracing"]
+
+[dependencies]
+eyre = "0.6.8"
+tracing = "0.1.33"
+arrow-array = { workspace = true }
+
+[dependencies.dora-node-api]
+workspace = true

apis/c/node/node_api.h

@@ -0,0 +1,22 @@
+#include <stddef.h>
+
+void *init_dora_context_from_env();
+void free_dora_context(void *dora_context);
+
+void *dora_next_event(void *dora_context);
+void free_dora_event(void *dora_event);
+
+enum DoraEventType
+{
+    DoraEventType_Stop,
+    DoraEventType_Input,
+    DoraEventType_InputClosed,
+    DoraEventType_Error,
+    DoraEventType_Unknown,
+};
+enum DoraEventType read_dora_event_type(void *dora_event);
+
+void read_dora_input_id(void *dora_event, char **out_ptr, size_t *out_len);
+void read_dora_input_data(void *dora_event, char **out_ptr, size_t *out_len);
+
+int dora_send_output(void *dora_context, char *id_ptr, size_t id_len, char *data_ptr, size_t data_len);

apis/c/node/src/lib.rs

@@ -0,0 +1,260 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+
+use arrow_array::UInt8Array;
+use dora_node_api::{arrow::array::AsArray, DoraNode, Event, EventStream};
+use eyre::Context;
+use std::{ffi::c_void, ptr, slice};
+
+pub const HEADER_NODE_API: &str = include_str!("../node_api.h");
+
+struct DoraContext {
+    node: &'static mut DoraNode,
+    events: EventStream,
+}
+
+/// Initializes a dora context from the environment variables that were set by
+/// the dora-coordinator.
+///
+/// Returns a pointer to the dora context on success. This pointer can be
+/// used to call dora API functions that expect a `context` argument. Any
+/// other use is prohibited. To free the dora context when it is no longer
+/// needed, use the [`free_dora_context`] function.
+///
+/// On error, a null pointer is returned.
+#[no_mangle]
+pub extern "C" fn init_dora_context_from_env() -> *mut c_void {
+    let context = || {
+        let (node, events) = DoraNode::init_from_env()?;
+        let node = Box::leak(Box::new(node));
+        Result::<_, eyre::Report>::Ok(DoraContext { node, events })
+    };
+    let context = match context().context("failed to initialize node") {
+        Ok(n) => n,
+        Err(err) => {
+            let err: eyre::Error = err;
+            tracing::error!("{err:?}");
+            return ptr::null_mut();
+        }
+    };
+
+    Box::into_raw(Box::new(context)).cast()
+}
+
+/// Frees the given dora context.
+///
+/// ## Safety
+///
+/// Only pointers created through [`init_dora_context_from_env`] are allowed
+/// as arguments. Each context pointer must be freed exactly once. After
+/// freeing, the pointer must not be used anymore.
+#[no_mangle]
+pub unsafe extern "C" fn free_dora_context(context: *mut c_void) {
+    let context: Box<DoraContext> = unsafe { Box::from_raw(context.cast()) };
+    // drop all fields except for `node`
+    let DoraContext { node, .. } = *context;
+    // convert the `'static` reference back to a Box, then drop it
+    let _ = unsafe { Box::from_raw(node as *const DoraNode as *mut DoraNode) };
+}
+
+/// Waits for the next incoming event for the node.
+///
+/// Returns a pointer to the event on success. This pointer must not be used
+/// directly. Instead, use the `read_dora_event_*` functions to read out the
+/// type and payload of the event. When the event is not needed anymore, use
+/// [`free_dora_event`] to free it again.
+///
+/// Returns a null pointer when all event streams were closed. This means that
+/// no more event will be available. Nodes typically react by stopping.
+///
+/// ## Safety
+///
+/// The `context` argument must be a dora context created through
+/// [`init_dora_context_from_env`]. The context must be still valid, i.e., not
+/// freed yet.
+#[no_mangle]
+pub unsafe extern "C" fn dora_next_event(context: *mut c_void) -> *mut c_void {
+    let context: &mut DoraContext = unsafe { &mut *context.cast() };
+    match context.events.recv() {
+        Some(event) => Box::into_raw(Box::new(event)).cast(),
+        None => ptr::null_mut(),
+    }
+}
+
+/// Reads out the type of the given event.
+///
+/// ## Safety
+///
+/// The `event` argument must be a dora event received through
+/// [`dora_next_event`]. The event must be still valid, i.e., not
+/// freed yet.
+#[no_mangle]
+pub unsafe extern "C" fn read_dora_event_type(event: *const ()) -> EventType {
+    let event: &Event = unsafe { &*event.cast() };
+    match event {
+        Event::Stop => EventType::Stop,
+        Event::Input { .. } => EventType::Input,
+        Event::InputClosed { .. } => EventType::InputClosed,
+        Event::Error(_) => EventType::Error,
+        _ => EventType::Unknown,
+    }
+}
+
+#[repr(C)]
+pub enum EventType {
+    Stop,
+    Input,
+    InputClosed,
+    Error,
+    Unknown,
+}
+
+/// Reads out the ID of the given input event.
+///
+/// Writes the `out_ptr` and `out_len` with the start pointer and length of the
+/// ID string of the input. The ID is guaranteed to be valid UTF-8.
+///
+/// Writes a null pointer and length `0` if the given event is not an input event.
+///
+/// ## Safety
+///
+/// The `event` argument must be a dora event received through
+/// [`dora_next_event`]. The event must be still valid, i.e., not
+/// freed yet. The returned `out_ptr` must not be used after
+/// freeing the `event`, since it points directly into the event's
+/// memory.
+#[no_mangle]
+pub unsafe extern "C" fn read_dora_input_id(
+    event: *const (),
+    out_ptr: *mut *const u8,
+    out_len: *mut usize,
+) {
+    let event: &Event = unsafe { &*event.cast() };
+    match event {
+        Event::Input { id, .. } => {
+            let id = id.as_str().as_bytes();
+            let ptr = id.as_ptr();
+            let len = id.len();
+            unsafe {
+                *out_ptr = ptr;
+                *out_len = len;
+            }
+        }
+        _ => unsafe {
+            *out_ptr = ptr::null();
+            *out_len = 0;
+        },
+    }
+}
+
+/// Reads out the data of the given input event.
+///
+/// Writes the `out_ptr` and `out_len` with the start pointer and length of the
+/// input's data array. The data array is a raw byte array, whose format
+/// depends on the source operator/node.
+///
+/// Writes a null pointer and length `0` if the given event is not an input event
+/// or when an input event has no associated data.
+///
+/// ## Safety
+///
+/// The `event` argument must be a dora event received through
+/// [`dora_next_event`]. The event must be still valid, i.e., not
+/// freed yet. The returned `out_ptr` must not be used after
+/// freeing the `event`, since it points directly into the event's
+/// memory.
+#[no_mangle]
+pub unsafe extern "C" fn read_dora_input_data(
+    event: *const (),
+    out_ptr: *mut *const u8,
+    out_len: *mut usize,
+) {
+    let event: &Event = unsafe { &*event.cast() };
+    match event {
+        Event::Input { data, metadata, .. } => match metadata.type_info.data_type {
+            dora_node_api::arrow::datatypes::DataType::UInt8 => {
+                let array: &UInt8Array = data.as_primitive();
+                let ptr = array.values().as_ptr();
+                unsafe {
+                    *out_ptr = ptr;
+                    *out_len = metadata.type_info.len;
+                }
+            }
+            dora_node_api::arrow::datatypes::DataType::Null => unsafe {
+                *out_ptr = ptr::null();
+                *out_len = 0;
+            },
+            _ => {
+                todo!("dora C++ Node does not yet support higher level type of arrow. Only UInt8. 
+                The ultimate solution should be based on arrow FFI interface. Feel free to contribute :)")
+            }
+        },
+        _ => unsafe {
+            *out_ptr = ptr::null();
+            *out_len = 0;
+        },
+    }
+}
+
+/// Frees the given dora event.
+///
+/// ## Safety
+///
+/// Only pointers created through [`dora_next_event`] are allowed
+/// as arguments. Each context pointer must be freed exactly once. After
+/// freeing, the pointer and all derived pointers must not be used anymore.
+/// This also applies to the `read_dora_event_*` functions, which return
+/// pointers into the original event structure.
+#[no_mangle]
+pub unsafe extern "C" fn free_dora_event(event: *mut c_void) {
+    let _: Box<Event> = unsafe { Box::from_raw(event.cast()) };
+}
+
+/// Sends the given output to subscribed dora nodes/operators.
+///
+/// The `id_ptr` and `id_len` fields must be the start pointer and length of an
+/// UTF8-encoded string. The ID string must correspond to one of the node's
+/// outputs specified in the dataflow YAML file.
+///
+/// The `data_ptr` and `data_len` fields must be the start pointer and length
+/// a byte array. The dora API sends this data as-is, without any processing.
+///
+/// ## Safety
+///
+/// - The `id_ptr` and `id_len` fields must be the start pointer and length of an
+///   UTF8-encoded string.
+/// - The `data_ptr` and `data_len` fields must be the start pointer and length
+///   a byte array.
+#[no_mangle]
+pub unsafe extern "C" fn dora_send_output(
+    context: *mut c_void,
+    id_ptr: *const u8,
+    id_len: usize,
+    data_ptr: *const u8,
+    data_len: usize,
+) -> isize {
+    match unsafe { try_send_output(context, id_ptr, id_len, data_ptr, data_len) } {
+        Ok(()) => 0,
+        Err(err) => {
+            tracing::error!("{err:?}");
+            -1
+        }
+    }
+}
+
+unsafe fn try_send_output(
+    context: *mut c_void,
+    id_ptr: *const u8,
+    id_len: usize,
+    data_ptr: *const u8,
+    data_len: usize,
+) -> eyre::Result<()> {
+    let context: &mut DoraContext = unsafe { &mut *context.cast() };
+    let id = std::str::from_utf8(unsafe { slice::from_raw_parts(id_ptr, id_len) })?;
+    let output_id = id.to_owned().into();
+    let data = unsafe { slice::from_raw_parts(data_ptr, data_len) };
+    context
+        .node
+        .send_output_raw(output_id, Default::default(), data.len(), |out| {
+            out.copy_from_slice(data);
+        })
+}

apis/c/operator/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "dora-operator-api-c"
+version.workspace = true
+edition = "2021"
+description = "C API implementation for Dora Operator"
+documentation.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["staticlib", "lib"]
+
+[dependencies]
+dora-operator-api-types = { workspace = true }
+
+[build-dependencies]
+dora-operator-api-types = { workspace = true }

apis/c/operator/build.rs

@@ -0,0 +1,11 @@
+use std::path::Path;
+
+fn main() {
+    dora_operator_api_types::generate_headers(Path::new("operator_types.h"))
+        .expect("failed to create operator_types.h");
+
+    // don't rebuild on changes (otherwise we rebuild on every run as we're
+    // writing the `operator_types.h` file; cargo will still rerun this script
+    // when the `dora_operator_api_types` crate changes)
+    println!("cargo:rerun-if-changed=build.rs");
+}

apis/c/operator/operator_api.h

@@ -0,0 +1,36 @@
+#ifndef __RUST_DORA_OPERATOR_API_C_WRAPPER__
+#define __RUST_DORA_OPERATOR_API_C_WRAPPER__
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stddef.h>
+#include "operator_types.h"
+
+#ifdef _WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+    EXPORT DoraInitResult_t dora_init_operator(void);
+
+    EXPORT DoraResult_t dora_drop_operator(void *operator_context);
+
+    EXPORT OnEventResult_t dora_on_event(
+        RawEvent_t *event,
+        const SendOutput_t *send_output,
+        void *operator_context);
+
+    static void __dora_type_assertions()
+    {
+        DoraInitOperator_t __dora_init_operator = {.init_operator = dora_init_operator};
+        DoraDropOperator_t __dora_drop_operator = {.drop_operator = dora_drop_operator};
+        DoraOnEvent_t __dora_on_event = {.on_event = dora_on_event};
+    }
+#ifdef __cplusplus
+} /* extern \"C\" */
+#endif
+
+#endif /* __RUST_DORA_OPERATOR_API_C_WRAPPER__ */

apis/c/operator/operator_types.h

@@ -0,0 +1,180 @@
+/*! \file */
+/*******************************************
+ *                                         *
+ *  File auto-generated by `::safer_ffi`.  *
+ *                                         *
+ *  Do not manually edit this file.        *
+ *                                         *
+ *******************************************/
+
+#ifndef __RUST_DORA_OPERATOR_API_C__
+#define __RUST_DORA_OPERATOR_API_C__
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <stddef.h>
+#include <stdint.h>
+
+/** \brief
+ *  Same as [`Vec<T>`][`rust::Vec`], but with guaranteed `#[repr(C)]` layout
+ */
+typedef struct Vec_uint8 {
+    /** <No documentation available> */
+    uint8_t * ptr;
+
+    /** <No documentation available> */
+    size_t len;
+
+    /** <No documentation available> */
+    size_t cap;
+} Vec_uint8_t;
+
+/** <No documentation available> */
+typedef struct DoraResult {
+    /** <No documentation available> */
+    Vec_uint8_t * error;
+} DoraResult_t;
+
+/** <No documentation available> */
+typedef struct DoraDropOperator {
+    /** <No documentation available> */
+    DoraResult_t (*drop_operator)(void *);
+} DoraDropOperator_t;
+
+/** <No documentation available> */
+typedef struct DoraInitResult {
+    /** <No documentation available> */
+    DoraResult_t result;
+
+    /** <No documentation available> */
+    void * operator_context;
+} DoraInitResult_t;
+
+/** <No documentation available> */
+typedef struct DoraInitOperator {
+    /** <No documentation available> */
+    DoraInitResult_t (*init_operator)(void);
+} DoraInitOperator_t;
+
+/** <No documentation available> */
+/** \remark Has the same ABI as `uint8_t` **/
+#ifdef DOXYGEN
+typedef
+#endif
+enum DoraStatus {
+    /** <No documentation available> */
+    DORA_STATUS_CONTINUE = 0,
+    /** <No documentation available> */
+    DORA_STATUS_STOP = 1,
+    /** <No documentation available> */
+    DORA_STATUS_STOP_ALL = 2,
+}
+#ifndef DOXYGEN
+; typedef uint8_t
+#endif
+DoraStatus_t;
+
+/** <No documentation available> */
+typedef struct OnEventResult {
+    /** <No documentation available> */
+    DoraResult_t result;
+
+    /** <No documentation available> */
+    DoraStatus_t status;
+} OnEventResult_t;
+
+/** <No documentation available> */
+typedef struct Input Input_t;
+
+
+#include <stdbool.h>
+
+/** <No documentation available> */
+typedef struct RawEvent {
+    /** <No documentation available> */
+    Input_t * input;
+
+    /** <No documentation available> */
+    Vec_uint8_t input_closed;
+
+    /** <No documentation available> */
+    bool stop;
+
+    /** <No documentation available> */
+    Vec_uint8_t error;
+} RawEvent_t;
+
+/** <No documentation available> */
+typedef struct Output Output_t;
+
+/** \brief
+ *  `Arc<dyn Send + Sync + Fn(A1) -> Ret>`
+ */
+typedef struct ArcDynFn1_DoraResult_Output {
+    /** <No documentation available> */
+    void * env_ptr;
+
+    /** <No documentation available> */
+    DoraResult_t (*call)(void *, Output_t);
+
+    /** <No documentation available> */
+    void (*release)(void *);
+
+    /** <No documentation available> */
+    void (*retain)(void *);
+} ArcDynFn1_DoraResult_Output_t;
+
+/** <No documentation available> */
+typedef struct SendOutput {
+    /** <No documentation available> */
+    ArcDynFn1_DoraResult_Output_t send_output;
+} SendOutput_t;
+
+/** <No documentation available> */
+typedef struct DoraOnEvent {
+    /** <No documentation available> */
+    OnEventResult_t (*on_event)(RawEvent_t *, SendOutput_t const *, void *);
+} DoraOnEvent_t;
+
+/** <No documentation available> */
+typedef struct Metadata {
+    /** <No documentation available> */
+    Vec_uint8_t open_telemetry_context;
+} Metadata_t;
+
+/** <No documentation available> */
+void
+dora_free_data (
+    Vec_uint8_t _data);
+
+/** <No documentation available> */
+void
+dora_free_input_id (
+    char * _input_id);
+
+/** <No documentation available> */
+Vec_uint8_t
+dora_read_data (
+    Input_t * input);
+
+/** <No documentation available> */
+char *
+dora_read_input_id (
+    Input_t const * input);
+
+/** <No documentation available> */
+DoraResult_t
+dora_send_operator_output (
+    SendOutput_t const * send_output,
+    char const * id,
+    uint8_t const * data_ptr,
+    size_t data_len);
+
+
+#ifdef __cplusplus
+} /* extern \"C\" */
+#endif
+
+#endif /* __RUST_DORA_OPERATOR_API_C__ */

apis/c/operator/src/lib.rs

@@ -0,0 +1,4 @@
+pub const HEADER_OPERATOR_API: &str = include_str!("../operator_api.h");
+pub const HEADER_OPERATOR_TYPES: &str = include_str!("../operator_types.h");
+
+pub use dora_operator_api_types;

apis/python/node/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+version.workspace = true
+name = "dora-node-api-python"
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["tracing", "telemetry"]
+tracing = ["dora-node-api/tracing"]
+telemetry = ["dora-runtime/telemetry"]
+
+[dependencies]
+dora-node-api = { workspace = true }
+dora-operator-api-python = { workspace = true }
+pyo3 = { workspace = true, features = ["eyre", "abi3-py37"] }
+eyre = "0.6"
+serde_yaml = "0.8.23"
+flume = "0.10.14"
+dora-runtime = { workspace = true, features = ["tracing", "metrics", "python"] }
+arrow = { workspace = true, features = ["pyarrow"] }
+pythonize = { workspace = true }
+futures = "0.3.28"
+dora-ros2-bridge-python = { workspace = true }
+
+[lib]
+name = "dora"
+crate-type = ["cdylib"]

apis/python/node/README.md

@@ -0,0 +1,21 @@
+This crate corresponds to the Node API for Dora.
+
+## Building
+
+To build the Python module for development:
+
+```bash
+python -m venv .env
+source .env/bin/activate
+pip install maturin
+maturin develop
+```
+
+## Type hinting
+
+Type hinting requires to run a second step
+
+```bash
+python generate_stubs.py dora dora/__init__.pyi
+maturin develop
+```

apis/python/node/dora/__init__.py

@@ -0,0 +1,42 @@
+""" 
+# dora-rs
+This is the dora python client for interacting with dora dataflow.
+You can install it via:
+```bash
+pip install dora-rs
+```
+"""
+
+from enum import Enum
+
+from .dora import *
+
+from .dora import (
+    Node,
+    PyEvent,
+    Ros2Context,
+    Ros2Node,
+    Ros2NodeOptions,
+    Ros2Topic,
+    Ros2Publisher,
+    Ros2Subscription,
+    start_runtime,
+    __version__,
+    __author__,
+    Ros2QosPolicies,
+    Ros2Durability,
+    Ros2Liveliness,
+)
+
+
+class DoraStatus(Enum):
+    """Dora status to indicate if operator `on_input` loop
+     should be stopped.
+    Args:
+        Enum (u8): Status signaling to dora operator to
+        stop or continue the operator.
+    """
+
+    CONTINUE = 0
+    STOP = 1
+    STOP_ALL = 2

apis/python/node/dora/__init__.pyi

@@ -0,0 +1,320 @@
+import dora
+import pyarrow
+import typing
+
+@typing.final
+class Enum:
+    """Generic enumeration.
+
+Derive from this class to define new enumerations."""
+    __members__: mappingproxy = ...
+
+@typing.final
+class Node:
+    """The custom node API lets you integrate `dora` into your application.
+It allows you to retrieve input and send output in any fashion you want.
+
+Use with:
+
+```python
+from dora import Node
+
+node = Node()
+```"""
+
+    def __init__(self) -> None:
+        """The custom node API lets you integrate `dora` into your application.
+It allows you to retrieve input and send output in any fashion you want.
+
+Use with:
+
+```python
+from dora import Node
+
+node = Node()
+```"""
+
+    def dataflow_descriptor(self) -> dict:
+        """Returns the full dataflow descriptor that this node is part of.
+
+This method returns the parsed dataflow YAML file."""
+
+    def dataflow_id(self) -> str:
+        """Returns the dataflow id."""
+
+    def merge_external_events(self, subscription: dora.Ros2Subscription) -> None:
+        """Merge an external event stream with dora main loop.
+This currently only work with ROS2."""
+
+    def next(self, timeout: float=None) -> dora.PyEvent:
+        """`.next()` gives you the next input that the node has received.
+It blocks until the next event becomes available.
+You can use timeout in seconds to return if no input is available.
+It will return `None` when all senders has been dropped.
+
+```python
+event = node.next()
+```
+
+You can also iterate over the event stream with a loop
+
+```python
+for event in node:
+match event["type"]:
+case "INPUT":
+match event["id"]:
+case "image":
+```"""
+
+    def send_output(self, output_id: str, data: pyarrow.Array, metadata: dict=None) -> None:
+        """`send_output` send data from the node.
+
+```python
+Args:
+output_id: str,
+data: pyarrow.Array,
+metadata: Option[Dict],
+```
+
+ex:
+
+```python
+node.send_output("string", b"string", {"open_telemetry_context": "7632e76"})
+```"""
+
+    def __iter__(self) -> typing.Any:
+        """Implement iter(self)."""
+
+    def __next__(self) -> typing.Any:
+        """Implement next(self)."""
+
+@typing.final
+class PyEvent:
+    """Dora Event"""
+
+    def inner(self):...
+
+    def __getitem__(self, key: typing.Any) -> typing.Any:
+        """Return self[key]."""
+
+@typing.final
+class Ros2Context:
+    """ROS2 Context holding all messages definition for receiving and sending messages to ROS2.
+
+By default, Ros2Context will use env `AMENT_PREFIX_PATH` to search for message definition.
+
+AMENT_PREFIX_PATH folder structure should be the following:
+
+- For messages: <namespace>/msg/<name>.msg
+- For services: <namespace>/srv/<name>.srv
+
+You can also use `ros_paths` if you don't want to use env variable.
+
+warning::
+dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change.
+
+```python
+context = Ros2Context()
+```"""
+
+    def __init__(self, ros_paths: typing.List[str]=None) -> None:
+        """ROS2 Context holding all messages definition for receiving and sending messages to ROS2.
+
+By default, Ros2Context will use env `AMENT_PREFIX_PATH` to search for message definition.
+
+AMENT_PREFIX_PATH folder structure should be the following:
+
+- For messages: <namespace>/msg/<name>.msg
+- For services: <namespace>/srv/<name>.srv
+
+You can also use `ros_paths` if you don't want to use env variable.
+
+warning::
+dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change.
+
+```python
+context = Ros2Context()
+```"""
+
+    def new_node(self, name: str, namespace: str, options: dora.Ros2NodeOptions) -> dora.Ros2Node:
+        """Create a new ROS2 node
+
+```python
+ros2_node = ros2_context.new_node(
+"turtle_teleop",
+"/ros2_demo",
+Ros2NodeOptions(rosout=True),
+)
+```
+
+warning::
+dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+@typing.final
+class Ros2Durability:
+    """DDS 2.2.3.4 DURABILITY"""
+
+    def __eq__(self, value: typing.Any) -> bool:
+        """Return self==value."""
+
+    def __ge__(self, value: typing.Any) -> bool:
+        """Return self>=value."""
+
+    def __gt__(self, value: typing.Any) -> bool:
+        """Return self>value."""
+
+    def __int__(self) -> None:
+        """int(self)"""
+
+    def __le__(self, value: typing.Any) -> bool:
+        """Return self<=value."""
+
+    def __lt__(self, value: typing.Any) -> bool:
+        """Return self<value."""
+
+    def __ne__(self, value: typing.Any) -> bool:
+        """Return self!=value."""
+
+    def __repr__(self) -> str:
+        """Return repr(self)."""
+    Persistent: Ros2Durability = ...
+    Transient: Ros2Durability = ...
+    TransientLocal: Ros2Durability = ...
+    Volatile: Ros2Durability = ...
+
+@typing.final
+class Ros2Liveliness:
+    """DDS 2.2.3.11 LIVELINESS"""
+
+    def __eq__(self, value: typing.Any) -> bool:
+        """Return self==value."""
+
+    def __ge__(self, value: typing.Any) -> bool:
+        """Return self>=value."""
+
+    def __gt__(self, value: typing.Any) -> bool:
+        """Return self>value."""
+
+    def __int__(self) -> None:
+        """int(self)"""
+
+    def __le__(self, value: typing.Any) -> bool:
+        """Return self<=value."""
+
+    def __lt__(self, value: typing.Any) -> bool:
+        """Return self<value."""
+
+    def __ne__(self, value: typing.Any) -> bool:
+        """Return self!=value."""
+
+    def __repr__(self) -> str:
+        """Return repr(self)."""
+    Automatic: Ros2Liveliness = ...
+    ManualByParticipant: Ros2Liveliness = ...
+    ManualByTopic: Ros2Liveliness = ...
+
+@typing.final
+class Ros2Node:
+    """ROS2 Node
+
+warnings::
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change.
+- There's a known issue about ROS2 nodes not being discoverable by ROS2
+See: https://github.com/jhelovuo/ros2-client/issues/4"""
+
+    def create_publisher(self, topic: dora.Ros2Topic, qos: dora.Ros2QosPolicies=None) -> dora.Ros2Publisher:
+        """Create a ROS2 publisher
+
+```python
+pose_publisher = ros2_node.create_publisher(turtle_pose_topic)
+```
+warnings:
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+    def create_subscription(self, topic: dora.Ros2Topic, qos: dora.Ros2QosPolicies=None) -> dora.Ros2Subscription:
+        """Create a ROS2 subscription
+
+```python
+pose_reader = ros2_node.create_subscription(turtle_pose_topic)
+```
+
+warnings:
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+    def create_topic(self, name: str, message_type: str, qos: dora.Ros2QosPolicies) -> dora.Ros2Topic:
+        """Create a ROS2 topic to connect to.
+
+```python
+turtle_twist_topic = ros2_node.create_topic(
+"/turtle1/cmd_vel", "geometry_msgs/Twist", topic_qos
+)
+```"""
+
+@typing.final
+class Ros2NodeOptions:
+    """ROS2 Node Options"""
+
+    def __init__(self, rosout: bool=None) -> None:
+        """ROS2 Node Options"""
+
+@typing.final
+class Ros2Publisher:
+    """ROS2 Publisher
+
+warnings:
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+    def publish(self, data: pyarrow.Array) -> None:
+        """Publish a message into ROS2 topic.
+
+Remember that the data format should respect the structure of the ROS2 message using an arrow Structure.
+
+ex:
+```python
+gripper_command.publish(
+pa.array(
+[
+{
+"name": "gripper",
+"cmd": np.float32(5),
+}
+]
+),
+)
+```"""
+
+@typing.final
+class Ros2QosPolicies:
+    """ROS2 QoS Policy"""
+
+    def __init__(self, durability: dora.Ros2Durability=None, liveliness: dora.Ros2Liveliness=None, reliable: bool=None, keep_all: bool=None, lease_duration: float=None, max_blocking_time: float=None, keep_last: int=None) -> dora.Ros2QoSPolicies:
+        """ROS2 QoS Policy"""
+
+@typing.final
+class Ros2Subscription:
+    """ROS2 Subscription
+
+
+warnings:
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+    def next(self):...
+
+@typing.final
+class Ros2Topic:
+    """ROS2 Topic
+
+warnings:
+- dora Ros2 bridge functionality is considered **unstable**. It may be changed
+at any point without it being considered a breaking change."""
+
+def start_runtime() -> None:
+    """Start a runtime for Operators"""

apis/python/node/generate_stubs.py

@@ -0,0 +1,517 @@
+import argparse
+import ast
+import importlib
+import inspect
+import logging
+import re
+import subprocess
+from functools import reduce
+from typing import Any, Dict, List, Mapping, Optional, Set, Tuple, Union
+
+
+def path_to_type(*elements: str) -> ast.AST:
+    base: ast.AST = ast.Name(id=elements[0], ctx=ast.Load())
+    for e in elements[1:]:
+        base = ast.Attribute(value=base, attr=e, ctx=ast.Load())
+    return base
+
+
+OBJECT_MEMBERS = dict(inspect.getmembers(object))
+BUILTINS: Dict[str, Union[None, Tuple[List[ast.AST], ast.AST]]] = {
+    "__annotations__": None,
+    "__bool__": ([], path_to_type("bool")),
+    "__bytes__": ([], path_to_type("bytes")),
+    "__class__": None,
+    "__contains__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__del__": None,
+    "__delattr__": ([path_to_type("str")], path_to_type("None")),
+    "__delitem__": ([path_to_type("typing", "Any")], path_to_type("typing", "Any")),
+    "__dict__": None,
+    "__dir__": None,
+    "__doc__": None,
+    "__eq__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__format__": ([path_to_type("str")], path_to_type("str")),
+    "__ge__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__getattribute__": ([path_to_type("str")], path_to_type("typing", "Any")),
+    "__getitem__": ([path_to_type("typing", "Any")], path_to_type("typing", "Any")),
+    "__gt__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__hash__": ([], path_to_type("int")),
+    "__init__": ([], path_to_type("None")),
+    "__init_subclass__": None,
+    "__iter__": ([], path_to_type("typing", "Any")),
+    "__le__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__len__": ([], path_to_type("int")),
+    "__lt__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__module__": None,
+    "__ne__": ([path_to_type("typing", "Any")], path_to_type("bool")),
+    "__new__": None,
+    "__next__": ([], path_to_type("typing", "Any")),
+    "__int__": ([], path_to_type("None")),
+    "__reduce__": None,
+    "__reduce_ex__": None,
+    "__repr__": ([], path_to_type("str")),
+    "__setattr__": (
+        [path_to_type("str"), path_to_type("typing", "Any")],
+        path_to_type("None"),
+    ),
+    "__setitem__": (
+        [path_to_type("typing", "Any"), path_to_type("typing", "Any")],
+        path_to_type("typing", "Any"),
+    ),
+    "__sizeof__": None,
+    "__str__": ([], path_to_type("str")),
+    "__subclasshook__": None,
+}
+
+
+def module_stubs(module: Any) -> ast.Module:
+    types_to_import = {"typing"}
+    classes = []
+    functions = []
+    for member_name, member_value in inspect.getmembers(module):
+        element_path = [module.__name__, member_name]
+        if member_name.startswith("__"):
+            pass
+        elif member_name.startswith("DoraStatus"):
+            pass
+        elif inspect.isclass(member_value):
+            classes.append(
+                class_stubs(member_name, member_value, element_path, types_to_import)
+            )
+        elif inspect.isbuiltin(member_value):
+            functions.append(
+                function_stub(
+                    member_name,
+                    member_value,
+                    element_path,
+                    types_to_import,
+                    in_class=False,
+                )
+            )
+        else:
+            logging.warning(f"Unsupported root construction {member_name}")
+    return ast.Module(
+        body=[ast.Import(names=[ast.alias(name=t)]) for t in sorted(types_to_import)]
+        + classes
+        + functions,
+        type_ignores=[],
+    )
+
+
+def class_stubs(
+    cls_name: str, cls_def: Any, element_path: List[str], types_to_import: Set[str]
+) -> ast.ClassDef:
+    attributes: List[ast.AST] = []
+    methods: List[ast.AST] = []
+    magic_methods: List[ast.AST] = []
+    constants: List[ast.AST] = []
+    for member_name, member_value in inspect.getmembers(cls_def):
+        current_element_path = [*element_path, member_name]
+        if member_name == "__init__":
+            try:
+                inspect.signature(cls_def)  # we check it actually exists
+                methods = [
+                    function_stub(
+                        member_name,
+                        cls_def,
+                        current_element_path,
+                        types_to_import,
+                        in_class=True,
+                    ),
+                    *methods,
+                ]
+            except ValueError as e:
+                if "no signature found" not in str(e):
+                    raise ValueError(
+                        f"Error while parsing signature of {cls_name}.__init_"
+                    ) from e
+        elif (
+            member_value == OBJECT_MEMBERS.get(member_name)
+            or BUILTINS.get(member_name, ()) is None
+        ):
+            pass
+        elif inspect.isdatadescriptor(member_value):
+            attributes.extend(
+                data_descriptor_stub(
+                    member_name, member_value, current_element_path, types_to_import
+                )
+            )
+        elif inspect.isroutine(member_value):
+            (magic_methods if member_name.startswith("__") else methods).append(
+                function_stub(
+                    member_name,
+                    member_value,
+                    current_element_path,
+                    types_to_import,
+                    in_class=True,
+                )
+            )
+        elif member_name == "__match_args__":
+            constants.append(
+                ast.AnnAssign(
+                    target=ast.Name(id=member_name, ctx=ast.Store()),
+                    annotation=ast.Subscript(
+                        value=path_to_type("tuple"),
+                        slice=ast.Tuple(
+                            elts=[path_to_type("str"), ast.Ellipsis()], ctx=ast.Load()
+                        ),
+                        ctx=ast.Load(),
+                    ),
+                    value=ast.Constant(member_value),
+                    simple=1,
+                )
+            )
+        elif member_value is not None:
+            constants.append(
+                ast.AnnAssign(
+                    target=ast.Name(id=member_name, ctx=ast.Store()),
+                    annotation=concatenated_path_to_type(
+                        member_value.__class__.__name__, element_path, types_to_import
+                    ),
+                    value=ast.Ellipsis(),
+                    simple=1,
+                )
+            )
+        else:
+            logging.warning(
+                f"Unsupported member {member_name} of class {'.'.join(element_path)}"
+            )
+
+    doc = inspect.getdoc(cls_def)
+    doc_comment = build_doc_comment(doc) if doc else None
+    return ast.ClassDef(
+        cls_name,
+        bases=[],
+        keywords=[],
+        body=(
+            ([doc_comment] if doc_comment else [])
+            + attributes
+            + methods
+            + magic_methods
+            + constants
+        )
+        or [ast.Ellipsis()],
+        decorator_list=[path_to_type("typing", "final")],
+    )
+
+
+def data_descriptor_stub(
+    data_desc_name: str,
+    data_desc_def: Any,
+    element_path: List[str],
+    types_to_import: Set[str],
+) -> Union[Tuple[ast.AnnAssign, ast.Expr], Tuple[ast.AnnAssign]]:
+    annotation = None
+    doc_comment = None
+
+    doc = inspect.getdoc(data_desc_def)
+    if doc is not None:
+        annotation = returns_stub(data_desc_name, doc, element_path, types_to_import)
+        m = re.findall(r"^ *:return: *(.*) *$", doc, re.MULTILINE)
+        if len(m) == 1:
+            doc_comment = m[0]
+        elif len(m) > 1:
+            raise ValueError(
+                f"Multiple return annotations found with :return: in {'.'.join(element_path)} documentation"
+            )
+
+    assign = ast.AnnAssign(
+        target=ast.Name(id=data_desc_name, ctx=ast.Store()),
+        annotation=annotation or path_to_type("typing", "Any"),
+        simple=1,
+    )
+    doc_comment = build_doc_comment(doc_comment) if doc_comment else None
+    return (assign, doc_comment) if doc_comment else (assign,)
+
+
+def function_stub(
+    fn_name: str,
+    fn_def: Any,
+    element_path: List[str],
+    types_to_import: Set[str],
+    *,
+    in_class: bool,
+) -> ast.FunctionDef:
+    body: List[ast.AST] = []
+    doc = inspect.getdoc(fn_def)
+    if doc is not None:
+        doc_comment = build_doc_comment(doc)
+        if doc_comment is not None:
+            body.append(doc_comment)
+
+    decorator_list = []
+    if in_class and hasattr(fn_def, "__self__"):
+        decorator_list.append(ast.Name("staticmethod"))
+
+    return ast.FunctionDef(
+        fn_name,
+        arguments_stub(fn_name, fn_def, doc or "", element_path, types_to_import),
+        body or [ast.Ellipsis()],
+        decorator_list=decorator_list,
+        returns=(
+            returns_stub(fn_name, doc, element_path, types_to_import) if doc else None
+        ),
+        lineno=0,
+    )
+
+
+def arguments_stub(
+    callable_name: str,
+    callable_def: Any,
+    doc: str,
+    element_path: List[str],
+    types_to_import: Set[str],
+) -> ast.arguments:
+    real_parameters: Mapping[str, inspect.Parameter] = inspect.signature(
+        callable_def
+    ).parameters
+    if callable_name == "__init__":
+        real_parameters = {
+            "self": inspect.Parameter("self", inspect.Parameter.POSITIONAL_ONLY),
+            **real_parameters,
+        }
+
+    parsed_param_types = {}
+    optional_params = set()
+
+    # Types for magic functions types
+    builtin = BUILTINS.get(callable_name)
+    if isinstance(builtin, tuple):
+        param_names = list(real_parameters.keys())
+        if param_names and param_names[0] == "self":
+            del param_names[0]
+        for name, t in zip(param_names, builtin[0]):
+            parsed_param_types[name] = t
+
+    # Types from comment
+    for match in re.findall(
+        r"^ *:type *([a-zA-Z0-9_]+): ([^\n]*) *$", doc, re.MULTILINE
+    ):
+        if match[0] not in real_parameters:
+            raise ValueError(
+                f"The parameter {match[0]} of {'.'.join(element_path)} "
+                "is defined in the documentation but not in the function signature"
+            )
+        type = match[1]
+        if type.endswith(", optional"):
+            optional_params.add(match[0])
+            type = type[:-10]
+        parsed_param_types[match[0]] = convert_type_from_doc(
+            type, element_path, types_to_import
+        )
+
+    # we parse the parameters
+    posonlyargs = []
+    args = []
+    vararg = None
+    kwonlyargs = []
+    kw_defaults = []
+    kwarg = None
+    defaults = []
+    for param in real_parameters.values():
+        if param.name != "self" and param.name not in parsed_param_types:
+            raise ValueError(
+                f"The parameter {param.name} of {'.'.join(element_path)} "
+                "has no type definition in the function documentation"
+            )
+        param_ast = ast.arg(
+            arg=param.name, annotation=parsed_param_types.get(param.name)
+        )
+
+        default_ast = None
+        if param.default != param.empty:
+            default_ast = ast.Constant(param.default)
+            if param.name not in optional_params:
+                raise ValueError(
+                    f"Parameter {param.name} of {'.'.join(element_path)} "
+                    "is optional according to the type but not flagged as such in the doc"
+                )
+        elif param.name in optional_params:
+            raise ValueError(
+                f"Parameter {param.name} of {'.'.join(element_path)} "
+                "is optional according to the documentation but has no default value"
+            )
+
+        if param.kind == param.POSITIONAL_ONLY:
+            args.append(param_ast)
+            # posonlyargs.append(param_ast)
+            # defaults.append(default_ast)
+        elif param.kind == param.POSITIONAL_OR_KEYWORD:
+            args.append(param_ast)
+            defaults.append(default_ast)
+        elif param.kind == param.VAR_POSITIONAL:
+            vararg = param_ast
+        elif param.kind == param.KEYWORD_ONLY:
+            kwonlyargs.append(param_ast)
+            kw_defaults.append(default_ast)
+        elif param.kind == param.VAR_KEYWORD:
+            kwarg = param_ast
+
+    return ast.arguments(
+        posonlyargs=posonlyargs,
+        args=args,
+        vararg=vararg,
+        kwonlyargs=kwonlyargs,
+        kw_defaults=kw_defaults,
+        defaults=defaults,
+        kwarg=kwarg,
+    )
+
+
+def returns_stub(
+    callable_name: str, doc: str, element_path: List[str], types_to_import: Set[str]
+) -> Optional[ast.AST]:
+    m = re.findall(r"^ *:rtype: *([^\n]*) *$", doc, re.MULTILINE)
+    if len(m) == 0:
+        builtin = BUILTINS.get(callable_name)
+        if isinstance(builtin, tuple) and builtin[1] is not None:
+            return builtin[1]
+        raise ValueError(
+            f"The return type of {'.'.join(element_path)} "
+            "has no type definition using :rtype: in the function documentation"
+        )
+    if len(m) > 1:
+        raise ValueError(
+            f"Multiple return type annotations found with :rtype: for {'.'.join(element_path)}"
+        )
+    return convert_type_from_doc(m[0], element_path, types_to_import)
+
+
+def convert_type_from_doc(
+    type_str: str, element_path: List[str], types_to_import: Set[str]
+) -> ast.AST:
+    type_str = type_str.strip()
+    return parse_type_to_ast(type_str, element_path, types_to_import)
+
+
+def parse_type_to_ast(
+    type_str: str, element_path: List[str], types_to_import: Set[str]
+) -> ast.AST:
+    # let's tokenize
+    tokens = []
+    current_token = ""
+    for c in type_str:
+        if "a" <= c <= "z" or "A" <= c <= "Z" or c == ".":
+            current_token += c
+        else:
+            if current_token:
+                tokens.append(current_token)
+            current_token = ""
+            if c != " ":
+                tokens.append(c)
+    if current_token:
+        tokens.append(current_token)
+
+    # let's first parse nested parenthesis
+    stack: List[List[Any]] = [[]]
+    for token in tokens:
+        if token == "[":
+            children: List[str] = []
+            stack[-1].append(children)
+            stack.append(children)
+        elif token == "]":
+            stack.pop()
+        else:
+            stack[-1].append(token)
+
+    # then it's easy
+    def parse_sequence(sequence: List[Any]) -> ast.AST:
+        # we split based on "or"
+        or_groups: List[List[str]] = [[]]
+        print(sequence)
+        # TODO: Fix sequence
+        if "Ros" in sequence and "2" in sequence:
+            sequence = ["".join(sequence)]
+        elif "dora.Ros" in sequence and "2" in sequence:
+            sequence = ["".join(sequence)]
+
+        for e in sequence:
+            if e == "or":
+                or_groups.append([])
+            else:
+                or_groups[-1].append(e)
+        if any(not g for g in or_groups):
+            raise ValueError(
+                f"Not able to parse type '{type_str}' used by {'.'.join(element_path)}"
+            )
+
+        new_elements: List[ast.AST] = []
+        for group in or_groups:
+            if len(group) == 1 and isinstance(group[0], str):
+                new_elements.append(
+                    concatenated_path_to_type(group[0], element_path, types_to_import)
+                )
+            elif (
+                len(group) == 2
+                and isinstance(group[0], str)
+                and isinstance(group[1], list)
+            ):
+                new_elements.append(
+                    ast.Subscript(
+                        value=concatenated_path_to_type(
+                            group[0], element_path, types_to_import
+                        ),
+                        slice=parse_sequence(group[1]),
+                        ctx=ast.Load(),
+                    )
+                )
+            else:
+                raise ValueError(
+                    f"Not able to parse type '{type_str}' used by {'.'.join(element_path)}"
+                )
+        return reduce(
+            lambda left, right: ast.BinOp(left=left, op=ast.BitOr(), right=right),
+            new_elements,
+        )
+
+    return parse_sequence(stack[0])
+
+
+def concatenated_path_to_type(
+    path: str, element_path: List[str], types_to_import: Set[str]
+) -> ast.AST:
+    parts = path.split(".")
+    if any(not p for p in parts):
+        raise ValueError(
+            f"Not able to parse type '{path}' used by {'.'.join(element_path)}"
+        )
+    if len(parts) > 1:
+        types_to_import.add(".".join(parts[:-1]))
+    return path_to_type(*parts)
+
+
+def build_doc_comment(doc: str) -> Optional[ast.Expr]:
+    lines = [line.strip() for line in doc.split("\n")]
+    clean_lines = []
+    for line in lines:
+        if line.startswith((":type", ":rtype")):
+            continue
+        clean_lines.append(line)
+    text = "\n".join(clean_lines).strip()
+    return ast.Expr(value=ast.Constant(text)) if text else None
+
+
+def format_with_ruff(file: str) -> None:
+    subprocess.check_call(["python", "-m", "ruff", "format", file])
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Extract Python type stub from a python module."
+    )
+    parser.add_argument(
+        "module_name", help="Name of the Python module for which generate stubs"
+    )
+    parser.add_argument(
+        "out",
+        help="Name of the Python stub file to write to",
+        type=argparse.FileType("wt"),
+    )
+    parser.add_argument(
+        "--ruff", help="Formats the generated stubs using Ruff", action="store_true"
+    )
+    args = parser.parse_args()
+    stub_content = ast.unparse(module_stubs(importlib.import_module(args.module_name)))
+    args.out.write(stub_content)
+    if args.ruff:
+        format_with_ruff(args.out.name)

apis/python/node/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["maturin>=0.13.2"]
+build-backend = "maturin"
+
+[project]
+name = "dora-rs"
+# Install pyarrow at the same time of dora-rs
+dependencies = ['pyarrow']
+
+[tool.maturin]
+features = ["pyo3/extension-module"]

apis/python/node/src/lib.rs

@@ -0,0 +1,264 @@
+#![allow(clippy::borrow_deref_ref)] // clippy warns about code generated by #[pymethods]
+
+use std::time::Duration;
+
+use arrow::pyarrow::{FromPyArrow, ToPyArrow};
+use dora_node_api::merged::{MergeExternalSend, MergedEvent};
+use dora_node_api::{DoraNode, EventStream};
+use dora_operator_api_python::{pydict_to_metadata, PyEvent};
+use dora_ros2_bridge_python::Ros2Subscription;
+use eyre::Context;
+use futures::{Stream, StreamExt};
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict};
+
+/// The custom node API lets you integrate `dora` into your application.
+/// It allows you to retrieve input and send output in any fashion you want.
+///
+/// Use with:
+///
+/// ```python
+/// from dora import Node
+///
+/// node = Node()
+/// ```
+///
+#[pyclass]
+pub struct Node {
+    events: Events,
+    node: DoraNode,
+}
+
+#[pymethods]
+impl Node {
+    #[new]
+    pub fn new() -> eyre::Result<Self> {
+        let (node, events) = DoraNode::init_from_env()?;
+
+        Ok(Node {
+            events: Events::Dora(events),
+            node,
+        })
+    }
+
+    /// `.next()` gives you the next input that the node has received.
+    /// It blocks until the next event becomes available.
+    /// You can use timeout in seconds to return if no input is available.
+    /// It will return `None` when all senders has been dropped.
+    ///
+    /// ```python
+    /// event = node.next()
+    /// ```
+    ///
+    /// You can also iterate over the event stream with a loop
+    ///
+    /// ```python
+    /// for event in node:
+    ///    match event["type"]:
+    ///        case "INPUT":
+    ///            match event["id"]:
+    ///                 case "image":
+    /// ```
+    ///
+    /// :type timeout: float, optional
+    /// :rtype: dora.PyEvent
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&mut self, py: Python, timeout: Option<f32>) -> PyResult<Option<PyEvent>> {
+        let event = py.allow_threads(|| self.events.recv(timeout.map(Duration::from_secs_f32)));
+        Ok(event)
+    }
+
+    /// You can iterate over the event stream with a loop
+    ///
+    /// ```python
+    /// for event in node:
+    ///    match event["type"]:
+    ///        case "INPUT":
+    ///            match event["id"]:
+    ///                 case "image":
+    /// ```
+    ///
+    /// :rtype: dora.PyEvent
+    pub fn __next__(&mut self, py: Python) -> PyResult<Option<PyEvent>> {
+        let event = py.allow_threads(|| self.events.recv(None));
+        Ok(event)
+    }
+
+    /// You can iterate over the event stream with a loop
+    ///
+    /// ```python
+    /// for event in node:
+    ///    match event["type"]:
+    ///        case "INPUT":
+    ///            match event["id"]:
+    ///                 case "image":
+    /// ```
+    ///
+    /// :rtype: dora.PyEvent
+    fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
+        slf
+    }
+
+    /// `send_output` send data from the node.
+    ///
+    /// ```python
+    /// Args:
+    ///    output_id: str,
+    ///    data: pyarrow.Array,
+    ///    metadata: Option[Dict],
+    /// ```
+    ///
+    /// ex:
+    ///
+    /// ```python
+    /// node.send_output("string", b"string", {"open_telemetry_context": "7632e76"})
+    /// ```
+    ///
+    /// :type output_id: str
+    /// :type data: pyarrow.Array
+    /// :type metadata: dict, optional
+    /// :rtype: None
+    pub fn send_output(
+        &mut self,
+        output_id: String,
+        data: PyObject,
+        metadata: Option<Bound<'_, PyDict>>,
+        py: Python,
+    ) -> eyre::Result<()> {
+        let parameters = pydict_to_metadata(metadata)?;
+
+        if let Ok(py_bytes) = data.downcast_bound::<PyBytes>(py) {
+            let data = py_bytes.as_bytes();
+            self.node
+                .send_output_bytes(output_id.into(), parameters, data.len(), data)
+                .wrap_err("failed to send output")?;
+        } else if let Ok(arrow_array) = arrow::array::ArrayData::from_pyarrow_bound(data.bind(py)) {
+            self.node.send_output(
+                output_id.into(),
+                parameters,
+                arrow::array::make_array(arrow_array),
+            )?;
+        } else {
+            eyre::bail!("invalid `data` type, must by `PyBytes` or arrow array")
+        }
+
+        Ok(())
+    }
+
+    /// Returns the full dataflow descriptor that this node is part of.
+    ///
+    /// This method returns the parsed dataflow YAML file.
+    ///
+    /// :rtype: dict
+    pub fn dataflow_descriptor(&self, py: Python) -> pythonize::Result<PyObject> {
+        pythonize::pythonize(py, self.node.dataflow_descriptor())
+    }
+
+    /// Returns the dataflow id.
+    ///
+    /// :rtype: str
+    pub fn dataflow_id(&self) -> String {
+        self.node.dataflow_id().to_string()
+    }
+
+    /// Merge an external event stream with dora main loop.
+    /// This currently only work with ROS2.
+    ///
+    /// :type subscription: dora.Ros2Subscription
+    /// :rtype: None
+    pub fn merge_external_events(
+        &mut self,
+        subscription: &mut Ros2Subscription,
+    ) -> eyre::Result<()> {
+        let subscription = subscription.into_stream()?;
+        let stream = futures::stream::poll_fn(move |cx| {
+            let s = subscription.as_stream().map(|item| {
+                match item.context("failed to read ROS2 message") {
+                    Ok((value, _info)) => Python::with_gil(|py| {
+                        value
+                            .to_pyarrow(py)
+                            .context("failed to convert value to pyarrow")
+                            .unwrap_or_else(|err| PyErr::from(err).to_object(py))
+                    }),
+                    Err(err) => Python::with_gil(|py| PyErr::from(err).to_object(py)),
+                }
+            });
+            futures::pin_mut!(s);
+            s.poll_next_unpin(cx)
+        });
+
+        // take out the event stream and temporarily replace it with a dummy
+        let events = std::mem::replace(
+            &mut self.events,
+            Events::Merged(Box::new(futures::stream::empty())),
+        );
+        // update self.events with the merged stream
+        self.events = Events::Merged(events.merge_external_send(Box::pin(stream)));
+
+        Ok(())
+    }
+}
+
+enum Events {
+    Dora(EventStream),
+    Merged(Box<dyn Stream<Item = MergedEvent<PyObject>> + Unpin + Send>),
+}
+
+impl Events {
+    fn recv(&mut self, timeout: Option<Duration>) -> Option<PyEvent> {
+        match self {
+            Events::Dora(events) => match timeout {
+                Some(timeout) => events.recv_timeout(timeout).map(PyEvent::from),
+                None => events.recv().map(PyEvent::from),
+            },
+            Events::Merged(events) => futures::executor::block_on(events.next()).map(PyEvent::from),
+        }
+    }
+}
+
+impl<'a> MergeExternalSend<'a, PyObject> for Events {
+    type Item = MergedEvent<PyObject>;
+
+    fn merge_external_send(
+        self,
+        external_events: impl Stream<Item = PyObject> + Unpin + Send + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + Send + 'a> {
+        match self {
+            Events::Dora(events) => events.merge_external_send(external_events),
+            Events::Merged(events) => {
+                let merged = events.merge_external_send(external_events);
+                Box::new(merged.map(|event| match event {
+                    MergedEvent::Dora(e) => MergedEvent::Dora(e),
+                    MergedEvent::External(e) => MergedEvent::External(e.flatten()),
+                }))
+            }
+        }
+    }
+}
+
+impl Node {
+    pub fn id(&self) -> String {
+        self.node.id().to_string()
+    }
+}
+
+/// Start a runtime for Operators
+///
+/// :rtype: None
+#[pyfunction]
+pub fn start_runtime() -> eyre::Result<()> {
+    dora_runtime::main().wrap_err("Dora Runtime raised an error.")
+}
+
+#[pymodule]
+fn dora(_py: Python, m: Bound<'_, PyModule>) -> PyResult<()> {
+    dora_ros2_bridge_python::create_dora_ros2_bridge_module(&m)?;
+
+    m.add_function(wrap_pyfunction!(start_runtime, &m)?)?;
+    m.add_class::<Node>()?;
+    m.add_class::<PyEvent>()?;
+    m.setattr("__version__", env!("CARGO_PKG_VERSION"))?;
+    m.setattr("__author__", "Dora-rs Authors")?;
+
+    Ok(())
+}

apis/python/operator/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "dora-operator-api-python"
+version.workspace = true
+edition = "2021"
+
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dora-node-api = { workspace = true }
+pyo3 = { workspace = true, features = ["eyre", "abi3-py37"] }
+eyre = "0.6"
+serde_yaml = "0.8.23"
+flume = "0.10.14"
+arrow = { workspace = true, features = ["pyarrow"] }
+arrow-schema = { workspace = true }
+aligned-vec = "0.5.0"

apis/python/operator/src/lib.rs

@@ -0,0 +1,259 @@
+use arrow::{array::ArrayRef, pyarrow::ToPyArrow};
+use dora_node_api::{merged::MergedEvent, Event, Metadata, MetadataParameters};
+use eyre::{Context, Result};
+use pyo3::{exceptions::PyLookupError, prelude::*, pybacked::PyBackedStr, types::PyDict};
+
+/// Dora Event
+#[pyclass]
+#[derive(Debug)]
+pub struct PyEvent {
+    event: MergedEvent<PyObject>,
+    data: Option<ArrayRef>,
+}
+
+// Dora Event
+#[pymethods]
+impl PyEvent {
+    ///
+    /// :rtype: dora.PyObject
+    pub fn __getitem__(&self, key: &str, py: Python<'_>) -> PyResult<Option<PyObject>> {
+        if key == "kind" {
+            let kind = match &self.event {
+                MergedEvent::Dora(_) => "dora",
+                MergedEvent::External(_) => "external",
+            };
+            return Ok(Some(kind.to_object(py)));
+        }
+        match &self.event {
+            MergedEvent::Dora(event) => {
+                let value = match key {
+                    "type" => Some(Self::ty(event).to_object(py)),
+                    "id" => Self::id(event).map(|v| v.to_object(py)),
+                    "value" => self.value(py)?,
+                    "metadata" => Self::metadata(event, py),
+                    "error" => Self::error(event).map(|v| v.to_object(py)),
+                    other => {
+                        return Err(PyLookupError::new_err(format!(
+                            "event has no property `{other}`"
+                        )))
+                    }
+                };
+                Ok(value)
+            }
+            MergedEvent::External(event) => {
+                let value = match key {
+                    "value" => event,
+                    _ => todo!(),
+                };
+
+                Ok(Some(value.clone()))
+            }
+        }
+    }
+
+    pub fn inner(&mut self) -> Option<&PyObject> {
+        match &self.event {
+            MergedEvent::Dora(_) => None,
+            MergedEvent::External(event) => Some(event),
+        }
+    }
+
+    fn __str__(&self) -> PyResult<String> {
+        Ok(format!("{:#?}", &self.event))
+    }
+}
+
+impl PyEvent {
+    fn ty(event: &Event) -> &str {
+        match event {
+            Event::Stop => "STOP",
+            Event::Input { .. } => "INPUT",
+            Event::InputClosed { .. } => "INPUT_CLOSED",
+            Event::Error(_) => "ERROR",
+            _other => "UNKNOWN",
+        }
+    }
+
+    fn id(event: &Event) -> Option<&str> {
+        match event {
+            Event::Input { id, .. } => Some(id),
+            Event::InputClosed { id } => Some(id),
+            _ => None,
+        }
+    }
+
+    /// Returns the payload of an input event as an arrow array (if any).
+    fn value(&self, py: Python<'_>) -> PyResult<Option<PyObject>> {
+        match (&self.event, &self.data) {
+            (MergedEvent::Dora(Event::Input { .. }), Some(data)) => {
+                // TODO: Does this call leak data?
+                let array_data = data.to_data().to_pyarrow(py)?;
+                Ok(Some(array_data))
+            }
+            _ => Ok(None),
+        }
+    }
+
+    fn metadata(event: &Event, py: Python<'_>) -> Option<PyObject> {
+        match event {
+            Event::Input { metadata, .. } => Some(metadata_to_pydict(metadata, py).to_object(py)),
+            _ => None,
+        }
+    }
+
+    fn error(event: &Event) -> Option<&str> {
+        match event {
+            Event::Error(error) => Some(error),
+            _other => None,
+        }
+    }
+}
+
+impl From<Event> for PyEvent {
+    fn from(event: Event) -> Self {
+        Self::from(MergedEvent::Dora(event))
+    }
+}
+
+impl From<MergedEvent<PyObject>> for PyEvent {
+    fn from(mut event: MergedEvent<PyObject>) -> Self {
+        let data = if let MergedEvent::Dora(Event::Input { data, .. }) = &mut event {
+            Some(data.clone())
+        } else {
+            None
+        };
+        Self { event, data }
+    }
+}
+
+pub fn pydict_to_metadata(dict: Option<Bound<'_, PyDict>>) -> Result<MetadataParameters> {
+    let mut default_metadata = MetadataParameters::default();
+    if let Some(metadata) = dict {
+        for (key, value) in metadata.iter() {
+            match key
+                .extract::<PyBackedStr>()
+                .context("Parsing metadata keys")?
+                .as_ref()
+            {
+                "watermark" => {
+                    default_metadata.watermark =
+                        value.extract().context("parsing watermark failed")?;
+                }
+                "deadline" => {
+                    default_metadata.deadline =
+                        value.extract().context("parsing deadline failed")?;
+                }
+                "open_telemetry_context" => {
+                    let otel_context: PyBackedStr = value
+                        .extract()
+                        .context("parsing open telemetry context failed")?;
+                    default_metadata.open_telemetry_context = otel_context.to_string();
+                }
+                _ => (),
+            }
+        }
+    }
+    Ok(default_metadata)
+}
+
+pub fn metadata_to_pydict<'a>(metadata: &'a Metadata, py: Python<'a>) -> pyo3::Bound<'a, PyDict> {
+    let dict = PyDict::new_bound(py);
+    dict.set_item(
+        "open_telemetry_context",
+        &metadata.parameters.open_telemetry_context,
+    )
+    .wrap_err("could not make metadata a python dictionary item")
+    .unwrap();
+    dict
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use aligned_vec::{AVec, ConstAlign};
+    use arrow::{
+        array::{
+            ArrayData, ArrayRef, BooleanArray, Float64Array, Int32Array, Int64Array, Int8Array,
+            ListArray, StructArray,
+        },
+        buffer::Buffer,
+    };
+
+    use arrow_schema::{DataType, Field};
+    use dora_node_api::{
+        arrow_utils::{copy_array_into_sample, required_data_size},
+        RawData,
+    };
+    use eyre::{Context, Result};
+
+    fn assert_roundtrip(arrow_array: &ArrayData) -> Result<()> {
+        let size = required_data_size(arrow_array);
+        let mut sample: AVec<u8, ConstAlign<128>> = AVec::__from_elem(128, 0, size);
+
+        let info = copy_array_into_sample(&mut sample, arrow_array);
+
+        let serialized_deserialized_arrow_array = RawData::Vec(sample)
+            .into_arrow_array(&info)
+            .context("Could not create arrow array")?;
+        assert_eq!(arrow_array, &serialized_deserialized_arrow_array);
+
+        Ok(())
+    }
+
+    #[test]
+    fn serialize_deserialize_arrow() -> Result<()> {
+        // Int8
+        let arrow_array = Int8Array::from(vec![1, -2, 3, 4]).into();
+        assert_roundtrip(&arrow_array).context("Int8Array roundtrip failed")?;
+
+        // Int64
+        let arrow_array = Int64Array::from(vec![1, -2, 3, 4]).into();
+        assert_roundtrip(&arrow_array).context("Int64Array roundtrip failed")?;
+
+        // Float64
+        let arrow_array = Float64Array::from(vec![1., -2., 3., 4.]).into();
+        assert_roundtrip(&arrow_array).context("Float64Array roundtrip failed")?;
+
+        // Struct
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int as ArrayRef,
+            ),
+        ])
+        .into();
+        assert_roundtrip(&struct_array).context("StructArray roundtrip failed")?;
+
+        // List
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        let list_array = ListArray::from(list_data).into();
+        assert_roundtrip(&list_array).context("ListArray roundtrip failed")?;
+
+        Ok(())
+    }
+}

apis/rust/node/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "dora-node-api"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+[features]
+default = ["tracing"]
+tracing = ["dep:dora-tracing"]
+
+[dependencies]
+dora-core = { workspace = true }
+shared-memory-server = { workspace = true }
+eyre = "0.6.7"
+serde_yaml = "0.8.23"
+tracing = "0.1.33"
+flume = "0.10.14"
+bincode = "1.3.3"
+shared_memory_extended = "0.13.0"
+dora-tracing = { workspace = true, optional = true }
+arrow = { workspace = true }
+futures = "0.3.28"
+futures-concurrency = "7.3.0"
+futures-timer = "3.0.2"
+dora-arrow-convert = { workspace = true }
+aligned-vec = "0.5.0"
+
+[dev-dependencies]
+tokio = { version = "1.24.2", features = ["rt"] }

apis/rust/node/src/daemon_connection/mod.rs

@@ -0,0 +1,74 @@
+use dora_core::{
+    config::NodeId,
+    daemon_messages::{DaemonReply, DaemonRequest, DataflowId, Timestamped},
+    message::uhlc::Timestamp,
+};
+use eyre::{bail, eyre, Context};
+use shared_memory_server::{ShmemClient, ShmemConf};
+use std::{
+    net::{SocketAddr, TcpStream},
+    time::Duration,
+};
+
+mod tcp;
+
+pub enum DaemonChannel {
+    Shmem(ShmemClient<Timestamped<DaemonRequest>, DaemonReply>),
+    Tcp(TcpStream),
+}
+
+impl DaemonChannel {
+    #[tracing::instrument(level = "trace")]
+    pub fn new_tcp(socket_addr: SocketAddr) -> eyre::Result<Self> {
+        let stream = TcpStream::connect(socket_addr).wrap_err("failed to open TCP connection")?;
+        stream.set_nodelay(true).context("failed to set nodelay")?;
+        Ok(DaemonChannel::Tcp(stream))
+    }
+
+    #[tracing::instrument(level = "trace")]
+    pub unsafe fn new_shmem(daemon_control_region_id: &str) -> eyre::Result<Self> {
+        let daemon_events_region = ShmemConf::new()
+            .os_id(daemon_control_region_id)
+            .open()
+            .wrap_err("failed to connect to dora-daemon")?;
+        let channel = DaemonChannel::Shmem(
+            unsafe { ShmemClient::new(daemon_events_region, Some(Duration::from_secs(5))) }
+                .wrap_err("failed to create ShmemChannel")?,
+        );
+        Ok(channel)
+    }
+
+    pub fn register(
+        &mut self,
+        dataflow_id: DataflowId,
+        node_id: NodeId,
+        timestamp: Timestamp,
+    ) -> eyre::Result<()> {
+        let msg = Timestamped {
+            inner: DaemonRequest::Register {
+                dataflow_id,
+                node_id,
+                dora_version: env!("CARGO_PKG_VERSION").to_owned(),
+            },
+            timestamp,
+        };
+        let reply = self
+            .request(&msg)
+            .wrap_err("failed to send register request to dora-daemon")?;
+
+        match reply {
+            dora_core::daemon_messages::DaemonReply::Result(result) => result
+                .map_err(|e| eyre!(e))
+                .wrap_err("failed to register node with dora-daemon")?,
+            other => bail!("unexpected register reply: {other:?}"),
+        }
+        Ok(())
+    }
+
+    pub fn request(&mut self, request: &Timestamped<DaemonRequest>) -> eyre::Result<DaemonReply> {
+        match self {
+            DaemonChannel::Shmem(client) => client.request(request),
+            DaemonChannel::Tcp(stream) => tcp::request(stream, request),
+        }
+    }
+}

apis/rust/node/src/daemon_connection/tcp.rs

@@ -0,0 +1,68 @@
+use dora_core::daemon_messages::{DaemonReply, DaemonRequest, Timestamped};
+use eyre::{eyre, Context};
+use std::{
+    io::{Read, Write},
+    net::TcpStream,
+};
+
+pub fn request(
+    connection: &mut TcpStream,
+    request: &Timestamped<DaemonRequest>,
+) -> eyre::Result<DaemonReply> {
+    send_message(connection, request)?;
+    if request.inner.expects_tcp_reply() {
+        receive_reply(connection)
+            .and_then(|reply| reply.ok_or_else(|| eyre!("server disconnected unexpectedly")))
+    } else {
+        Ok(DaemonReply::Empty)
+    }
+}
+
+fn send_message(
+    connection: &mut TcpStream,
+    message: &Timestamped<DaemonRequest>,
+) -> eyre::Result<()> {
+    let serialized = bincode::serialize(&message).wrap_err("failed to serialize DaemonRequest")?;
+    tcp_send(connection, &serialized).wrap_err("failed to send DaemonRequest")?;
+    Ok(())
+}
+
+fn receive_reply(connection: &mut TcpStream) -> eyre::Result<Option<DaemonReply>> {
+    let raw = match tcp_receive(connection) {
+        Ok(raw) => raw,
+        Err(err) => match err.kind() {
+            std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::ConnectionAborted => {
+                return Ok(None)
+            }
+            other => {
+                return Err(err).with_context(|| {
+                    format!(
+                        "unexpected I/O error (kind {other:?}) while trying to receive DaemonReply"
+                    )
+                })
+            }
+        },
+    };
+    bincode::deserialize(&raw)
+        .wrap_err("failed to deserialize DaemonReply")
+        .map(Some)
+}
+
+fn tcp_send(connection: &mut (impl Write + Unpin), message: &[u8]) -> std::io::Result<()> {
+    let len_raw = (message.len() as u64).to_le_bytes();
+    connection.write_all(&len_raw)?;
+    connection.write_all(message)?;
+    connection.flush()?;
+    Ok(())
+}
+
+fn tcp_receive(connection: &mut (impl Read + Unpin)) -> std::io::Result<Vec<u8>> {
+    let reply_len = {
+        let mut raw = [0; 8];
+        connection.read_exact(&mut raw)?;
+        u64::from_le_bytes(raw) as usize
+    };
+    let mut reply = vec![0; reply_len];
+    connection.read_exact(&mut reply)?;
+    Ok(reply)
+}

apis/rust/node/src/event_stream/event.rs

@@ -0,0 +1,128 @@
+use std::{ptr::NonNull, sync::Arc};
+
+use aligned_vec::{AVec, ConstAlign};
+use dora_arrow_convert::{ArrowData, IntoArrow};
+use dora_core::{
+    config::{DataId, OperatorId},
+    message::{ArrowTypeInfo, BufferOffset, Metadata},
+};
+use eyre::{Context, Result};
+use shared_memory_extended::{Shmem, ShmemConf};
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Event {
+    Stop,
+    Reload {
+        operator_id: Option<OperatorId>,
+    },
+    Input {
+        id: DataId,
+        metadata: Metadata,
+        data: ArrowData,
+    },
+    InputClosed {
+        id: DataId,
+    },
+    Error(String),
+}
+
+pub enum RawData {
+    Empty,
+    Vec(AVec<u8, ConstAlign<128>>),
+    SharedMemory(SharedMemoryData),
+}
+
+impl RawData {
+    pub fn into_arrow_array(self, type_info: &ArrowTypeInfo) -> Result<arrow::array::ArrayData> {
+        let raw_buffer = match self {
+            RawData::Empty => return Ok(().into_arrow().into()),
+            RawData::Vec(data) => {
+                let ptr = NonNull::new(data.as_ptr() as *mut _).unwrap();
+                let len = data.len();
+
+                unsafe { arrow::buffer::Buffer::from_custom_allocation(ptr, len, Arc::new(data)) }
+            }
+            RawData::SharedMemory(data) => {
+                let ptr = NonNull::new(data.data.as_ptr() as *mut _).unwrap();
+                let len = data.data.len();
+
+                unsafe { arrow::buffer::Buffer::from_custom_allocation(ptr, len, Arc::new(data)) }
+            }
+        };
+
+        buffer_into_arrow_array(&raw_buffer, type_info)
+    }
+}
+
+pub struct SharedMemoryData {
+    pub data: MappedInputData,
+    pub _drop: flume::Sender<()>,
+}
+
+fn buffer_into_arrow_array(
+    raw_buffer: &arrow::buffer::Buffer,
+    type_info: &ArrowTypeInfo,
+) -> eyre::Result<arrow::array::ArrayData> {
+    if raw_buffer.is_empty() {
+        return Ok(arrow::array::ArrayData::new_empty(&type_info.data_type));
+    }
+
+    let mut buffers = Vec::new();
+    for BufferOffset { offset, len } in &type_info.buffer_offsets {
+        buffers.push(raw_buffer.slice_with_length(*offset, *len));
+    }
+
+    let mut child_data = Vec::new();
+    for child_type_info in &type_info.child_data {
+        child_data.push(buffer_into_arrow_array(raw_buffer, child_type_info)?)
+    }
+
+    arrow::array::ArrayData::try_new(
+        type_info.data_type.clone(),
+        type_info.len,
+        type_info
+            .validity
+            .clone()
+            .map(arrow::buffer::Buffer::from_vec),
+        type_info.offset,
+        buffers,
+        child_data,
+    )
+    .context("Error creating Arrow array")
+}
+
+impl std::fmt::Debug for RawData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Data").finish_non_exhaustive()
+    }
+}
+
+pub struct MappedInputData {
+    memory: Box<Shmem>,
+    len: usize,
+}
+
+impl MappedInputData {
+    pub(crate) unsafe fn map(shared_memory_id: &str, len: usize) -> eyre::Result<Self> {
+        let memory = Box::new(
+            ShmemConf::new()
+                .os_id(shared_memory_id)
+                .writable(false)
+                .open()
+                .wrap_err("failed to map shared memory input")?,
+        );
+        Ok(MappedInputData { memory, len })
+    }
+}
+
+impl std::ops::Deref for MappedInputData {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { &self.memory.as_slice()[..self.len] }
+    }
+}
+
+unsafe impl Send for MappedInputData {}
+unsafe impl Sync for MappedInputData {}

apis/rust/node/src/event_stream/merged.rs

@@ -0,0 +1,115 @@
+use futures::{Stream, StreamExt};
+use futures_concurrency::stream::Merge;
+
+#[derive(Debug)]
+pub enum MergedEvent<E> {
+    Dora(super::Event),
+    External(E),
+}
+
+pub enum Either<A, B> {
+    First(A),
+    Second(B),
+}
+
+impl<A> Either<A, A> {
+    pub fn flatten(self) -> A {
+        match self {
+            Either::First(a) => a,
+            Either::Second(a) => a,
+        }
+    }
+}
+
+// TODO: use impl trait return type once stable
+pub trait MergeExternal<'a, E> {
+    type Item;
+
+    fn merge_external(
+        self,
+        external_events: impl Stream<Item = E> + Unpin + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + 'a>;
+}
+
+pub trait MergeExternalSend<'a, E> {
+    type Item;
+
+    fn merge_external_send(
+        self,
+        external_events: impl Stream<Item = E> + Unpin + Send + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + Send + 'a>;
+}
+
+impl<'a, E> MergeExternal<'a, E> for super::EventStream
+where
+    E: 'static,
+{
+    type Item = MergedEvent<E>;
+
+    fn merge_external(
+        self,
+        external_events: impl Stream<Item = E> + Unpin + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + 'a> {
+        let dora = self.map(MergedEvent::Dora);
+        let external = external_events.map(MergedEvent::External);
+        Box::new((dora, external).merge())
+    }
+}
+
+impl<'a, E> MergeExternalSend<'a, E> for super::EventStream
+where
+    E: 'static,
+{
+    type Item = MergedEvent<E>;
+
+    fn merge_external_send(
+        self,
+        external_events: impl Stream<Item = E> + Unpin + Send + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + Send + 'a> {
+        let dora = self.map(MergedEvent::Dora);
+        let external = external_events.map(MergedEvent::External);
+        Box::new((dora, external).merge())
+    }
+}
+
+impl<'a, E, F, S> MergeExternal<'a, F> for S
+where
+    S: Stream<Item = MergedEvent<E>> + Unpin + 'a,
+    E: 'a,
+    F: 'a,
+{
+    type Item = MergedEvent<Either<E, F>>;
+
+    fn merge_external(
+        self,
+        external_events: impl Stream<Item = F> + Unpin + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + 'a> {
+        let first = self.map(|e| match e {
+            MergedEvent::Dora(d) => MergedEvent::Dora(d),
+            MergedEvent::External(e) => MergedEvent::External(Either::First(e)),
+        });
+        let second = external_events.map(|e| MergedEvent::External(Either::Second(e)));
+        Box::new((first, second).merge())
+    }
+}
+
+impl<'a, E, F, S> MergeExternalSend<'a, F> for S
+where
+    S: Stream<Item = MergedEvent<E>> + Unpin + Send + 'a,
+    E: 'a,
+    F: 'a,
+{
+    type Item = MergedEvent<Either<E, F>>;
+
+    fn merge_external_send(
+        self,
+        external_events: impl Stream<Item = F> + Unpin + Send + 'a,
+    ) -> Box<dyn Stream<Item = Self::Item> + Unpin + Send + 'a> {
+        let first = self.map(|e| match e {
+            MergedEvent::Dora(d) => MergedEvent::Dora(d),
+            MergedEvent::External(e) => MergedEvent::External(Either::First(e)),
+        });
+        let second = external_events.map(|e| MergedEvent::External(Either::Second(e)));
+        Box::new((first, second).merge())
+    }
+}

apis/rust/node/src/event_stream/mod.rs

@@ -0,0 +1,226 @@
+use std::{sync::Arc, time::Duration};
+
+pub use event::{Event, MappedInputData, RawData};
+use futures::{
+    future::{select, Either},
+    Stream, StreamExt,
+};
+use futures_timer::Delay;
+
+use self::{
+    event::SharedMemoryData,
+    thread::{EventItem, EventStreamThreadHandle},
+};
+use crate::daemon_connection::DaemonChannel;
+use dora_core::{
+    config::NodeId,
+    daemon_messages::{
+        self, DaemonCommunication, DaemonRequest, DataflowId, NodeEvent, Timestamped,
+    },
+    message::uhlc,
+};
+use eyre::{eyre, Context};
+
+mod event;
+pub mod merged;
+mod thread;
+
+pub struct EventStream {
+    node_id: NodeId,
+    receiver: flume::r#async::RecvStream<'static, EventItem>,
+    _thread_handle: EventStreamThreadHandle,
+    close_channel: DaemonChannel,
+    clock: Arc<uhlc::HLC>,
+}
+
+impl EventStream {
+    #[tracing::instrument(level = "trace", skip(clock))]
+    pub(crate) fn init(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        daemon_communication: &DaemonCommunication,
+        clock: Arc<uhlc::HLC>,
+    ) -> eyre::Result<Self> {
+        let channel = match daemon_communication {
+            DaemonCommunication::Shmem {
+                daemon_events_region_id,
+                ..
+            } => unsafe { DaemonChannel::new_shmem(daemon_events_region_id) }.wrap_err_with(
+                || format!("failed to create shmem event stream for node `{node_id}`"),
+            )?,
+            DaemonCommunication::Tcp { socket_addr } => DaemonChannel::new_tcp(*socket_addr)
+                .wrap_err_with(|| format!("failed to connect event stream for node `{node_id}`"))?,
+        };
+
+        let close_channel = match daemon_communication {
+            DaemonCommunication::Shmem {
+                daemon_events_close_region_id,
+                ..
+            } => unsafe { DaemonChannel::new_shmem(daemon_events_close_region_id) }.wrap_err_with(
+                || format!("failed to create shmem event close channel for node `{node_id}`"),
+            )?,
+            DaemonCommunication::Tcp { socket_addr } => DaemonChannel::new_tcp(*socket_addr)
+                .wrap_err_with(|| {
+                    format!("failed to connect event close channel for node `{node_id}`")
+                })?,
+        };
+
+        Self::init_on_channel(dataflow_id, node_id, channel, close_channel, clock)
+    }
+
+    pub(crate) fn init_on_channel(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        mut channel: DaemonChannel,
+        mut close_channel: DaemonChannel,
+        clock: Arc<uhlc::HLC>,
+    ) -> eyre::Result<Self> {
+        channel.register(dataflow_id, node_id.clone(), clock.new_timestamp())?;
+        let reply = channel
+            .request(&Timestamped {
+                inner: DaemonRequest::Subscribe,
+                timestamp: clock.new_timestamp(),
+            })
+            .map_err(|e| eyre!(e))
+            .wrap_err("failed to create subscription with dora-daemon")?;
+
+        match reply {
+            daemon_messages::DaemonReply::Result(Ok(())) => {}
+            daemon_messages::DaemonReply::Result(Err(err)) => {
+                eyre::bail!("subscribe failed: {err}")
+            }
+            other => eyre::bail!("unexpected subscribe reply: {other:?}"),
+        }
+
+        close_channel.register(dataflow_id, node_id.clone(), clock.new_timestamp())?;
+
+        let (tx, rx) = flume::bounded(0);
+        let thread_handle = thread::init(node_id.clone(), tx, channel, clock.clone())?;
+
+        Ok(EventStream {
+            node_id: node_id.clone(),
+            receiver: rx.into_stream(),
+            _thread_handle: thread_handle,
+            close_channel,
+            clock,
+        })
+    }
+
+    /// wait for the next event on the events stream.
+    pub fn recv(&mut self) -> Option<Event> {
+        futures::executor::block_on(self.recv_async())
+    }
+
+    /// wait for the next event on the events stream until timeout
+    pub fn recv_timeout(&mut self, dur: Duration) -> Option<Event> {
+        futures::executor::block_on(self.recv_async_timeout(dur))
+    }
+
+    pub async fn recv_async(&mut self) -> Option<Event> {
+        self.receiver.next().await.map(Self::convert_event_item)
+    }
+
+    pub async fn recv_async_timeout(&mut self, dur: Duration) -> Option<Event> {
+        let next_event = match select(Delay::new(dur), self.receiver.next()).await {
+            Either::Left((_elapsed, _)) => {
+                Some(EventItem::TimeoutError(eyre!("Receiver timed out")))
+            }
+            Either::Right((event, _)) => event,
+        };
+        next_event.map(Self::convert_event_item)
+    }
+
+    fn convert_event_item(item: EventItem) -> Event {
+        match item {
+            EventItem::NodeEvent { event, ack_channel } => match event {
+                NodeEvent::Stop => Event::Stop,
+                NodeEvent::Reload { operator_id } => Event::Reload { operator_id },
+                NodeEvent::InputClosed { id } => Event::InputClosed { id },
+                NodeEvent::Input { id, metadata, data } => {
+                    let data = match data {
+                        None => Ok(None),
+                        Some(daemon_messages::DataMessage::Vec(v)) => Ok(Some(RawData::Vec(v))),
+                        Some(daemon_messages::DataMessage::SharedMemory {
+                            shared_memory_id,
+                            len,
+                            drop_token: _, // handled in `event_stream_loop`
+                        }) => unsafe {
+                            MappedInputData::map(&shared_memory_id, len).map(|data| {
+                                Some(RawData::SharedMemory(SharedMemoryData {
+                                    data,
+                                    _drop: ack_channel,
+                                }))
+                            })
+                        },
+                    };
+                    let data = data.and_then(|data| {
+                        let raw_data = data.unwrap_or(RawData::Empty);
+                        raw_data
+                            .into_arrow_array(&metadata.type_info)
+                            .map(arrow::array::make_array)
+                    });
+                    match data {
+                        Ok(data) => Event::Input {
+                            id,
+                            metadata,
+                            data: data.into(),
+                        },
+                        Err(err) => Event::Error(format!("{err:?}")),
+                    }
+                }
+                NodeEvent::AllInputsClosed => {
+                    let err = eyre!(
+                        "received `AllInputsClosed` event, which should be handled by background task"
+                    );
+                    tracing::error!("{err:?}");
+                    Event::Error(err.wrap_err("internal error").to_string())
+                }
+            },
+
+            EventItem::FatalError(err) => {
+                Event::Error(format!("fatal event stream error: {err:?}"))
+            }
+            EventItem::TimeoutError(err) => {
+                Event::Error(format!("Timeout event stream error: {err:?}"))
+            }
+        }
+    }
+}
+
+impl Stream for EventStream {
+    type Item = Event;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.receiver
+            .poll_next_unpin(cx)
+            .map(|item| item.map(Self::convert_event_item))
+    }
+}
+
+impl Drop for EventStream {
+    #[tracing::instrument(skip(self), fields(%self.node_id))]
+    fn drop(&mut self) {
+        let request = Timestamped {
+            inner: DaemonRequest::EventStreamDropped,
+            timestamp: self.clock.new_timestamp(),
+        };
+        let result = self
+            .close_channel
+            .request(&request)
+            .map_err(|e| eyre!(e))
+            .wrap_err("failed to signal event stream closure to dora-daemon")
+            .and_then(|r| match r {
+                daemon_messages::DaemonReply::Result(Ok(())) => Ok(()),
+                daemon_messages::DaemonReply::Result(Err(err)) => {
+                    Err(eyre!("EventStreamClosed failed: {err}"))
+                }
+                other => Err(eyre!("unexpected EventStreamClosed reply: {other:?}")),
+            });
+        if let Err(err) = result {
+            tracing::warn!("{err:?}")
+        }
+    }
+}

apis/rust/node/src/event_stream/thread.rs

@@ -0,0 +1,269 @@
+use dora_core::{
+    config::NodeId,
+    daemon_messages::{DaemonReply, DaemonRequest, DropToken, NodeEvent, Timestamped},
+    message::uhlc::{self, Timestamp},
+};
+use eyre::{eyre, Context};
+use flume::RecvTimeoutError;
+use std::{
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use crate::daemon_connection::DaemonChannel;
+
+pub fn init(
+    node_id: NodeId,
+    tx: flume::Sender<EventItem>,
+    channel: DaemonChannel,
+    clock: Arc<uhlc::HLC>,
+) -> eyre::Result<EventStreamThreadHandle> {
+    let node_id_cloned = node_id.clone();
+    let join_handle = std::thread::spawn(|| event_stream_loop(node_id_cloned, tx, channel, clock));
+    Ok(EventStreamThreadHandle::new(node_id, join_handle))
+}
+
+#[derive(Debug)]
+pub enum EventItem {
+    NodeEvent {
+        event: NodeEvent,
+        ack_channel: flume::Sender<()>,
+    },
+    FatalError(eyre::Report),
+    TimeoutError(eyre::Report),
+}
+
+pub struct EventStreamThreadHandle {
+    node_id: NodeId,
+    handle: flume::Receiver<std::thread::Result<()>>,
+}
+
+impl EventStreamThreadHandle {
+    fn new(node_id: NodeId, join_handle: std::thread::JoinHandle<()>) -> Self {
+        let (tx, rx) = flume::bounded(1);
+        std::thread::spawn(move || {
+            let _ = tx.send(join_handle.join());
+        });
+        Self {
+            node_id,
+            handle: rx,
+        }
+    }
+}
+
+impl Drop for EventStreamThreadHandle {
+    #[tracing::instrument(skip(self), fields(node_id = %self.node_id))]
+    fn drop(&mut self) {
+        if self.handle.is_empty() {
+            tracing::trace!("waiting for event stream thread");
+        }
+        match self.handle.recv_timeout(Duration::from_secs(20)) {
+            Ok(Ok(())) => {
+                tracing::trace!("event stream thread finished");
+            }
+            Ok(Err(_)) => {
+                tracing::error!("event stream thread panicked");
+            }
+            Err(RecvTimeoutError::Timeout) => {
+                tracing::warn!("timeout while waiting for event stream thread");
+            }
+            Err(RecvTimeoutError::Disconnected) => {
+                tracing::warn!("event stream thread result channel closed unexpectedly");
+            }
+        }
+    }
+}
+
+#[tracing::instrument(skip(tx, channel, clock))]
+fn event_stream_loop(
+    node_id: NodeId,
+    tx: flume::Sender<EventItem>,
+    mut channel: DaemonChannel,
+    clock: Arc<uhlc::HLC>,
+) {
+    let mut tx = Some(tx);
+    let mut pending_drop_tokens: Vec<(DropToken, flume::Receiver<()>, Instant, u64)> = Vec::new();
+    let mut drop_tokens = Vec::new();
+
+    let result = 'outer: loop {
+        if let Err(err) = handle_pending_drop_tokens(&mut pending_drop_tokens, &mut drop_tokens) {
+            break 'outer Err(err);
+        }
+
+        let daemon_request = Timestamped {
+            inner: DaemonRequest::NextEvent {
+                drop_tokens: std::mem::take(&mut drop_tokens),
+            },
+            timestamp: clock.new_timestamp(),
+        };
+        let events = match channel.request(&daemon_request) {
+            Ok(DaemonReply::NextEvents(events)) => {
+                if events.is_empty() {
+                    tracing::trace!("event stream closed for node `{node_id}`");
+                    break Ok(());
+                } else {
+                    events
+                }
+            }
+            Ok(other) => {
+                let err = eyre!("unexpected control reply: {other:?}");
+                tracing::warn!("{err:?}");
+                continue;
+            }
+            Err(err) => {
+                let err = eyre!(err).wrap_err("failed to receive incoming event");
+                tracing::warn!("{err:?}");
+                continue;
+            }
+        };
+        for Timestamped { inner, timestamp } in events {
+            if let Err(err) = clock.update_with_timestamp(&timestamp) {
+                tracing::warn!("failed to update HLC: {err}");
+            }
+            let drop_token = match &inner {
+                NodeEvent::Input {
+                    data: Some(data), ..
+                } => data.drop_token(),
+                NodeEvent::AllInputsClosed => {
+                    // close the event stream
+                    tx = None;
+                    // skip this internal event
+                    continue;
+                }
+                _ => None,
+            };
+
+            if let Some(tx) = tx.as_ref() {
+                let (drop_tx, drop_rx) = flume::bounded(0);
+                match tx.send(EventItem::NodeEvent {
+                    event: inner,
+                    ack_channel: drop_tx,
+                }) {
+                    Ok(()) => {}
+                    Err(send_error) => {
+                        let event = send_error.into_inner();
+                        tracing::trace!(
+                            "event channel was closed already, could not forward `{event:?}`"
+                        );
+
+                        break 'outer Ok(());
+                    }
+                }
+
+                if let Some(token) = drop_token {
+                    pending_drop_tokens.push((token, drop_rx, Instant::now(), 1));
+                }
+            } else {
+                tracing::warn!("dropping event because event `tx` was already closed: `{inner:?}`");
+            }
+        }
+    };
+    if let Err(err) = result {
+        if let Some(tx) = tx.as_ref() {
+            if let Err(flume::SendError(item)) = tx.send(EventItem::FatalError(err)) {
+                let err = match item {
+                    EventItem::FatalError(err) => err,
+                    _ => unreachable!(),
+                };
+                tracing::error!("failed to report fatal EventStream error: {err:?}");
+            }
+        } else {
+            tracing::error!("received error event after `tx` was closed: {err:?}");
+        }
+    }
+
+    if let Err(err) = report_remaining_drop_tokens(
+        channel,
+        drop_tokens,
+        pending_drop_tokens,
+        clock.new_timestamp(),
+    )
+    .context("failed to report remaining drop tokens")
+    {
+        tracing::warn!("{err:?}");
+    }
+}
+
+fn handle_pending_drop_tokens(
+    pending_drop_tokens: &mut Vec<(DropToken, flume::Receiver<()>, Instant, u64)>,
+    drop_tokens: &mut Vec<DropToken>,
+) -> eyre::Result<()> {
+    let mut still_pending = Vec::new();
+    for (token, rx, since, warn) in pending_drop_tokens.drain(..) {
+        match rx.try_recv() {
+            Ok(()) => return Err(eyre!("Node API should not send anything on ACK channel")),
+            Err(flume::TryRecvError::Disconnected) => {
+                // the event was dropped -> add the drop token to the list
+                drop_tokens.push(token);
+            }
+            Err(flume::TryRecvError::Empty) => {
+                let duration = Duration::from_secs(30 * warn);
+                if since.elapsed() > duration {
+                    tracing::warn!("timeout: token {token:?} was not dropped after {duration:?}");
+                }
+                still_pending.push((token, rx, since, warn + 1));
+            }
+        }
+    }
+    *pending_drop_tokens = still_pending;
+    Ok(())
+}
+
+fn report_remaining_drop_tokens(
+    mut channel: DaemonChannel,
+    mut drop_tokens: Vec<DropToken>,
+    mut pending_drop_tokens: Vec<(DropToken, flume::Receiver<()>, Instant, u64)>,
+    timestamp: Timestamp,
+) -> eyre::Result<()> {
+    while !(pending_drop_tokens.is_empty() && drop_tokens.is_empty()) {
+        report_drop_tokens(&mut drop_tokens, &mut channel, timestamp)?;
+
+        let mut still_pending = Vec::new();
+        for (token, rx, since, _) in pending_drop_tokens.drain(..) {
+            match rx.recv_timeout(Duration::from_millis(100)) {
+                Ok(()) => return Err(eyre!("Node API should not send anything on ACK channel")),
+                Err(flume::RecvTimeoutError::Disconnected) => {
+                    // the event was dropped -> add the drop token to the list
+                    drop_tokens.push(token);
+                }
+                Err(flume::RecvTimeoutError::Timeout) => {
+                    let duration = Duration::from_secs(30);
+                    if since.elapsed() > duration {
+                        tracing::warn!(
+                            "timeout: node finished, but token {token:?} was still not \
+                            dropped after {duration:?} -> ignoring it"
+                        );
+                    } else {
+                        still_pending.push((token, rx, since, 0));
+                    }
+                }
+            }
+        }
+        pending_drop_tokens = still_pending;
+        if !pending_drop_tokens.is_empty() {
+            tracing::trace!("waiting for drop for {} events", pending_drop_tokens.len());
+        }
+    }
+
+    Ok(())
+}
+
+fn report_drop_tokens(
+    drop_tokens: &mut Vec<DropToken>,
+    channel: &mut DaemonChannel,
+    timestamp: Timestamp,
+) -> Result<(), eyre::ErrReport> {
+    if drop_tokens.is_empty() {
+        return Ok(());
+    }
+    let daemon_request = Timestamped {
+        inner: DaemonRequest::ReportDropTokens {
+            drop_tokens: std::mem::take(drop_tokens),
+        },
+        timestamp,
+    };
+    match channel.request(&daemon_request)? {
+        dora_core::daemon_messages::DaemonReply::Empty => Ok(()),
+        other => Err(eyre!("unexpected ReportDropTokens reply: {other:?}")),
+    }
+}

apis/rust/node/src/lib.rs

@@ -0,0 +1,26 @@
+//! The custom node API allow you to integrate `dora` into your application.
+//! It allows you to retrieve input and send output in any fashion you want.                                                 
+//!
+//! Try it out with:
+//!
+//! ```bash
+//! dora new node --kind node
+//! ```
+//!
+//! You can also generate a dora rust project with
+//!
+//! ```bash
+//! dora new project_xyz --kind dataflow
+//! ```
+//!
+pub use arrow;
+pub use dora_arrow_convert::*;
+pub use dora_core;
+pub use dora_core::message::{uhlc, Metadata, MetadataParameters};
+pub use event_stream::{merged, Event, EventStream, MappedInputData, RawData};
+pub use flume::Receiver;
+pub use node::{arrow_utils, DataSample, DoraNode, ZERO_COPY_THRESHOLD};
+
+mod daemon_connection;
+mod event_stream;
+mod node;

apis/rust/node/src/node/arrow_utils.rs

@@ -0,0 +1,71 @@
+use arrow::array::{ArrayData, BufferSpec};
+use dora_core::message::{ArrowTypeInfo, BufferOffset};
+
+pub fn required_data_size(array: &ArrayData) -> usize {
+    let mut next_offset = 0;
+    required_data_size_inner(array, &mut next_offset);
+    next_offset
+}
+fn required_data_size_inner(array: &ArrayData, next_offset: &mut usize) {
+    let layout = arrow::array::layout(array.data_type());
+    for (buffer, spec) in array.buffers().iter().zip(&layout.buffers) {
+        // consider alignment padding
+        if let BufferSpec::FixedWidth { alignment, .. } = spec {
+            *next_offset = (*next_offset + alignment - 1) / alignment * alignment;
+        }
+        *next_offset += buffer.len();
+    }
+    for child in array.child_data() {
+        required_data_size_inner(child, next_offset);
+    }
+}
+
+pub fn copy_array_into_sample(target_buffer: &mut [u8], arrow_array: &ArrayData) -> ArrowTypeInfo {
+    let mut next_offset = 0;
+    copy_array_into_sample_inner(target_buffer, &mut next_offset, arrow_array)
+}
+
+fn copy_array_into_sample_inner(
+    target_buffer: &mut [u8],
+    next_offset: &mut usize,
+    arrow_array: &ArrayData,
+) -> ArrowTypeInfo {
+    let mut buffer_offsets = Vec::new();
+    let layout = arrow::array::layout(arrow_array.data_type());
+    for (buffer, spec) in arrow_array.buffers().iter().zip(&layout.buffers) {
+        let len = buffer.len();
+        assert!(
+            target_buffer[*next_offset..].len() >= len,
+            "target buffer too small (total_len: {}, offset: {}, required_len: {len})",
+            target_buffer.len(),
+            *next_offset,
+        );
+        // add alignment padding
+        if let BufferSpec::FixedWidth { alignment, .. } = spec {
+            *next_offset = (*next_offset + alignment - 1) / alignment * alignment;
+        }
+
+        target_buffer[*next_offset..][..len].copy_from_slice(buffer.as_slice());
+        buffer_offsets.push(BufferOffset {
+            offset: *next_offset,
+            len,
+        });
+        *next_offset += len;
+    }
+
+    let mut child_data = Vec::new();
+    for child in arrow_array.child_data() {
+        let child_type_info = copy_array_into_sample_inner(target_buffer, next_offset, child);
+        child_data.push(child_type_info);
+    }
+
+    ArrowTypeInfo {
+        data_type: arrow_array.data_type().clone(),
+        len: arrow_array.len(),
+        null_count: arrow_array.null_count(),
+        validity: arrow_array.nulls().map(|b| b.validity().to_owned()),
+        offset: arrow_array.offset(),
+        buffer_offsets,
+        child_data,
+    }
+}

apis/rust/node/src/node/control_channel.rs

@@ -0,0 +1,106 @@
+use std::sync::Arc;
+
+use crate::daemon_connection::DaemonChannel;
+use dora_core::{
+    config::{DataId, NodeId},
+    daemon_messages::{DaemonCommunication, DaemonRequest, DataMessage, DataflowId, Timestamped},
+    message::{uhlc::HLC, Metadata},
+};
+use eyre::{bail, eyre, Context};
+
+pub(crate) struct ControlChannel {
+    channel: DaemonChannel,
+    clock: Arc<HLC>,
+}
+
+impl ControlChannel {
+    #[tracing::instrument(level = "trace", skip(clock))]
+    pub(crate) fn init(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        daemon_communication: &DaemonCommunication,
+        clock: Arc<HLC>,
+    ) -> eyre::Result<Self> {
+        let channel = match daemon_communication {
+            DaemonCommunication::Shmem {
+                daemon_control_region_id,
+                ..
+            } => unsafe { DaemonChannel::new_shmem(daemon_control_region_id) }
+                .wrap_err("failed to create shmem control channel")?,
+            DaemonCommunication::Tcp { socket_addr } => DaemonChannel::new_tcp(*socket_addr)
+                .wrap_err("failed to connect control channel")?,
+        };
+
+        Self::init_on_channel(dataflow_id, node_id, channel, clock)
+    }
+
+    #[tracing::instrument(skip(channel, clock), level = "trace")]
+    pub fn init_on_channel(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        mut channel: DaemonChannel,
+        clock: Arc<HLC>,
+    ) -> eyre::Result<Self> {
+        channel.register(dataflow_id, node_id.clone(), clock.new_timestamp())?;
+
+        Ok(Self { channel, clock })
+    }
+
+    pub fn report_outputs_done(&mut self) -> eyre::Result<()> {
+        let reply = self
+            .channel
+            .request(&Timestamped {
+                inner: DaemonRequest::OutputsDone,
+                timestamp: self.clock.new_timestamp(),
+            })
+            .wrap_err("failed to report outputs done to dora-daemon")?;
+        match reply {
+            dora_core::daemon_messages::DaemonReply::Result(result) => result
+                .map_err(|e| eyre!(e))
+                .wrap_err("failed to report outputs done event to dora-daemon")?,
+            other => bail!("unexpected outputs done reply: {other:?}"),
+        }
+        Ok(())
+    }
+
+    pub fn report_closed_outputs(&mut self, outputs: Vec<DataId>) -> eyre::Result<()> {
+        let reply = self
+            .channel
+            .request(&Timestamped {
+                inner: DaemonRequest::CloseOutputs(outputs),
+                timestamp: self.clock.new_timestamp(),
+            })
+            .wrap_err("failed to report closed outputs to dora-daemon")?;
+        match reply {
+            dora_core::daemon_messages::DaemonReply::Result(result) => result
+                .map_err(|e| eyre!(e))
+                .wrap_err("failed to receive closed outputs reply from dora-daemon")?,
+            other => bail!("unexpected closed outputs reply: {other:?}"),
+        }
+        Ok(())
+    }
+
+    pub fn send_message(
+        &mut self,
+        output_id: DataId,
+        metadata: Metadata,
+        data: Option<DataMessage>,
+    ) -> eyre::Result<()> {
+        let request = DaemonRequest::SendMessage {
+            output_id,
+            metadata,
+            data,
+        };
+        let reply = self
+            .channel
+            .request(&Timestamped {
+                inner: request,
+                timestamp: self.clock.new_timestamp(),
+            })
+            .wrap_err("failed to send SendMessage request to dora-daemon")?;
+        match reply {
+            dora_core::daemon_messages::DaemonReply::Empty => Ok(()),
+            other => bail!("unexpected SendMessage reply: {other:?}"),
+        }
+    }
+}

apis/rust/node/src/node/drop_stream.rs

@@ -0,0 +1,178 @@
+use std::{sync::Arc, time::Duration};
+
+use crate::daemon_connection::DaemonChannel;
+use dora_core::{
+    config::NodeId,
+    daemon_messages::{
+        self, DaemonCommunication, DaemonReply, DaemonRequest, DataflowId, DropToken,
+        NodeDropEvent, Timestamped,
+    },
+    message::uhlc,
+};
+use eyre::{eyre, Context};
+use flume::RecvTimeoutError;
+
+pub struct DropStream {
+    receiver: flume::Receiver<DropToken>,
+    _thread_handle: DropStreamThreadHandle,
+}
+
+impl DropStream {
+    #[tracing::instrument(level = "trace", skip(hlc))]
+    pub(crate) fn init(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        daemon_communication: &DaemonCommunication,
+        hlc: Arc<uhlc::HLC>,
+    ) -> eyre::Result<Self> {
+        let channel = match daemon_communication {
+            DaemonCommunication::Shmem {
+                daemon_drop_region_id,
+                ..
+            } => {
+                unsafe { DaemonChannel::new_shmem(daemon_drop_region_id) }.wrap_err_with(|| {
+                    format!("failed to create shmem drop stream for node `{node_id}`")
+                })?
+            }
+            DaemonCommunication::Tcp { socket_addr } => DaemonChannel::new_tcp(*socket_addr)
+                .wrap_err_with(|| format!("failed to connect drop stream for node `{node_id}`"))?,
+        };
+
+        Self::init_on_channel(dataflow_id, node_id, channel, hlc)
+    }
+
+    pub fn init_on_channel(
+        dataflow_id: DataflowId,
+        node_id: &NodeId,
+        mut channel: DaemonChannel,
+        clock: Arc<uhlc::HLC>,
+    ) -> eyre::Result<Self> {
+        channel.register(dataflow_id, node_id.clone(), clock.new_timestamp())?;
+
+        let reply = channel
+            .request(&Timestamped {
+                inner: DaemonRequest::SubscribeDrop,
+                timestamp: clock.new_timestamp(),
+            })
+            .map_err(|e| eyre!(e))
+            .wrap_err("failed to create subscription with dora-daemon")?;
+
+        match reply {
+            daemon_messages::DaemonReply::Result(Ok(())) => {}
+            daemon_messages::DaemonReply::Result(Err(err)) => {
+                eyre::bail!("drop subscribe failed: {err}")
+            }
+            other => eyre::bail!("unexpected drop subscribe reply: {other:?}"),
+        }
+
+        let (tx, rx) = flume::bounded(0);
+        let node_id_cloned = node_id.clone();
+
+        let handle = std::thread::spawn(|| drop_stream_loop(node_id_cloned, tx, channel, clock));
+
+        Ok(Self {
+            receiver: rx,
+            _thread_handle: DropStreamThreadHandle::new(node_id.clone(), handle),
+        })
+    }
+}
+
+impl std::ops::Deref for DropStream {
+    type Target = flume::Receiver<DropToken>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.receiver
+    }
+}
+
+#[tracing::instrument(skip(tx, channel, clock))]
+fn drop_stream_loop(
+    node_id: NodeId,
+    tx: flume::Sender<DropToken>,
+    mut channel: DaemonChannel,
+    clock: Arc<uhlc::HLC>,
+) {
+    'outer: loop {
+        let daemon_request = Timestamped {
+            inner: DaemonRequest::NextFinishedDropTokens,
+            timestamp: clock.new_timestamp(),
+        };
+        let events = match channel.request(&daemon_request) {
+            Ok(DaemonReply::NextDropEvents(events)) => {
+                if events.is_empty() {
+                    tracing::trace!("drop stream closed for node `{node_id}`");
+                    break;
+                } else {
+                    events
+                }
+            }
+            Ok(other) => {
+                let err = eyre!("unexpected drop reply: {other:?}");
+                tracing::warn!("{err:?}");
+                continue;
+            }
+            Err(err) => {
+                let err = eyre!(err).wrap_err("failed to receive incoming drop event");
+                tracing::warn!("{err:?}");
+                continue;
+            }
+        };
+        for Timestamped { inner, timestamp } in events {
+            if let Err(err) = clock.update_with_timestamp(&timestamp) {
+                tracing::warn!("failed to update HLC: {err}");
+            }
+            match inner {
+                NodeDropEvent::OutputDropped { drop_token } => {
+                    if tx.send(drop_token).is_err() {
+                        tracing::warn!(
+                            "drop channel was closed already, could not forward \
+                            drop token`{drop_token:?}`"
+                        );
+                        break 'outer;
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct DropStreamThreadHandle {
+    node_id: NodeId,
+    handle: flume::Receiver<std::thread::Result<()>>,
+}
+
+impl DropStreamThreadHandle {
+    fn new(node_id: NodeId, join_handle: std::thread::JoinHandle<()>) -> Self {
+        let (tx, rx) = flume::bounded(1);
+        std::thread::spawn(move || {
+            let _ = tx.send(join_handle.join());
+        });
+        Self {
+            node_id,
+            handle: rx,
+        }
+    }
+}
+
+impl Drop for DropStreamThreadHandle {
+    #[tracing::instrument(skip(self), fields(node_id = %self.node_id))]
+    fn drop(&mut self) {
+        if self.handle.is_empty() {
+            tracing::trace!("waiting for drop stream thread");
+        }
+        match self.handle.recv_timeout(Duration::from_secs(2)) {
+            Ok(Ok(())) => {
+                tracing::trace!("drop stream thread done");
+            }
+            Ok(Err(_)) => {
+                tracing::error!("drop stream thread panicked");
+            }
+            Err(RecvTimeoutError::Timeout) => {
+                tracing::warn!("timeout while waiting for drop stream thread");
+            }
+            Err(RecvTimeoutError::Disconnected) => {
+                tracing::warn!("drop stream thread result channel closed unexpectedly");
+            }
+        }
+    }
+}

apis/rust/node/src/node/mod.rs

@@ -0,0 +1,475 @@
+use crate::EventStream;
+
+use self::{
+    arrow_utils::{copy_array_into_sample, required_data_size},
+    control_channel::ControlChannel,
+    drop_stream::DropStream,
+};
+use aligned_vec::{AVec, ConstAlign};
+use arrow::array::Array;
+use dora_core::{
+    config::{DataId, NodeId, NodeRunConfig},
+    daemon_messages::{DataMessage, DataflowId, DropToken, NodeConfig},
+    descriptor::Descriptor,
+    message::{uhlc, ArrowTypeInfo, Metadata, MetadataParameters},
+};
+use eyre::{bail, WrapErr};
+use shared_memory_extended::{Shmem, ShmemConf};
+use std::{
+    collections::{HashMap, VecDeque},
+    ops::{Deref, DerefMut},
+    sync::Arc,
+    time::Duration,
+};
+
+#[cfg(feature = "tracing")]
+use dora_tracing::set_up_tracing;
+
+pub mod arrow_utils;
+mod control_channel;
+mod drop_stream;
+
+pub const ZERO_COPY_THRESHOLD: usize = 4096;
+
+pub struct DoraNode {
+    id: NodeId,
+    dataflow_id: DataflowId,
+    node_config: NodeRunConfig,
+    control_channel: ControlChannel,
+    clock: Arc<uhlc::HLC>,
+
+    sent_out_shared_memory: HashMap<DropToken, ShmemHandle>,
+    drop_stream: DropStream,
+    cache: VecDeque<ShmemHandle>,
+
+    dataflow_descriptor: Descriptor,
+}
+
+impl DoraNode {
+    /// Initiate a node from environment variables set by `dora-coordinator`
+    ///
+    /// ```no_run
+    /// use dora_node_api::DoraNode;
+    ///
+    /// let (mut node, mut events) = DoraNode::init_from_env().expect("Could not init node.");
+    /// ```
+    ///
+    pub fn init_from_env() -> eyre::Result<(Self, EventStream)> {
+        let node_config: NodeConfig = {
+            let raw = std::env::var("DORA_NODE_CONFIG")
+                .wrap_err("env variable DORA_NODE_CONFIG must be set")?;
+            serde_yaml::from_str(&raw).context("failed to deserialize operator config")?
+        };
+        #[cfg(feature = "tracing")]
+        set_up_tracing(&node_config.node_id.to_string())
+            .context("failed to set up tracing subscriber")?;
+        Self::init(node_config)
+    }
+
+    #[tracing::instrument]
+    pub fn init(node_config: NodeConfig) -> eyre::Result<(Self, EventStream)> {
+        let NodeConfig {
+            dataflow_id,
+            node_id,
+            run_config,
+            daemon_communication,
+            dataflow_descriptor,
+        } = node_config;
+
+        let clock = Arc::new(uhlc::HLC::default());
+
+        let event_stream =
+            EventStream::init(dataflow_id, &node_id, &daemon_communication, clock.clone())
+                .wrap_err("failed to init event stream")?;
+        let drop_stream =
+            DropStream::init(dataflow_id, &node_id, &daemon_communication, clock.clone())
+                .wrap_err("failed to init drop stream")?;
+        let control_channel =
+            ControlChannel::init(dataflow_id, &node_id, &daemon_communication, clock.clone())
+                .wrap_err("failed to init control channel")?;
+
+        let node = Self {
+            id: node_id,
+            dataflow_id,
+            node_config: run_config,
+            control_channel,
+            clock,
+            sent_out_shared_memory: HashMap::new(),
+            drop_stream,
+            cache: VecDeque::new(),
+
+            dataflow_descriptor,
+        };
+        Ok((node, event_stream))
+    }
+
+    /// Send data from the node to the other nodes.
+    /// We take a closure as an input to enable zero copy on send.
+    ///
+    /// ```no_run
+    /// use dora_node_api::{DoraNode, MetadataParameters};
+    /// use dora_core::config::DataId;
+    ///
+    /// let (mut node, mut events) = DoraNode::init_from_env().expect("Could not init node.");
+    ///
+    /// let output = DataId::from("output_id".to_owned());
+    ///
+    /// let data: &[u8] = &[0, 1, 2, 3];
+    /// let parameters = MetadataParameters::default();
+    ///
+    /// node.send_output_raw(
+    ///    output,
+    ///    parameters,
+    ///    data.len(),
+    ///    |out| {
+    ///         out.copy_from_slice(data);
+    ///     }).expect("Could not send output");
+    /// ```
+    ///
+    pub fn send_output_raw<F>(
+        &mut self,
+        output_id: DataId,
+        parameters: MetadataParameters,
+        data_len: usize,
+        data: F,
+    ) -> eyre::Result<()>
+    where
+        F: FnOnce(&mut [u8]),
+    {
+        let mut sample = self.allocate_data_sample(data_len)?;
+        data(&mut sample);
+
+        let type_info = ArrowTypeInfo::byte_array(data_len);
+
+        self.send_output_sample(output_id, type_info, parameters, Some(sample))
+    }
+
+    pub fn send_output(
+        &mut self,
+        output_id: DataId,
+        parameters: MetadataParameters,
+        data: impl Array,
+    ) -> eyre::Result<()> {
+        let arrow_array = data.to_data();
+
+        let total_len = required_data_size(&arrow_array);
+
+        let mut sample = self.allocate_data_sample(total_len)?;
+        let type_info = copy_array_into_sample(&mut sample, &arrow_array);
+
+        self.send_output_sample(output_id, type_info, parameters, Some(sample))
+            .wrap_err("failed to send output")?;
+
+        Ok(())
+    }
+
+    pub fn send_output_bytes(
+        &mut self,
+        output_id: DataId,
+        parameters: MetadataParameters,
+        data_len: usize,
+        data: &[u8],
+    ) -> eyre::Result<()> {
+        self.send_output_raw(output_id, parameters, data_len, |sample| {
+            sample.copy_from_slice(data)
+        })
+    }
+
+    pub fn send_typed_output<F>(
+        &mut self,
+        output_id: DataId,
+        type_info: ArrowTypeInfo,
+        parameters: MetadataParameters,
+        data_len: usize,
+        data: F,
+    ) -> eyre::Result<()>
+    where
+        F: FnOnce(&mut [u8]),
+    {
+        let mut sample = self.allocate_data_sample(data_len)?;
+        data(&mut sample);
+
+        self.send_output_sample(output_id, type_info, parameters, Some(sample))
+    }
+
+    pub fn send_output_sample(
+        &mut self,
+        output_id: DataId,
+        type_info: ArrowTypeInfo,
+        parameters: MetadataParameters,
+        sample: Option<DataSample>,
+    ) -> eyre::Result<()> {
+        self.handle_finished_drop_tokens()?;
+
+        if !self.node_config.outputs.contains(&output_id) {
+            eyre::bail!("unknown output");
+        }
+        let metadata = Metadata::from_parameters(
+            self.clock.new_timestamp(),
+            type_info,
+            parameters.into_owned(),
+        );
+
+        let (data, shmem) = match sample {
+            Some(sample) => sample.finalize(),
+            None => (None, None),
+        };
+
+        self.control_channel
+            .send_message(output_id.clone(), metadata, data)
+            .wrap_err_with(|| format!("failed to send output {output_id}"))?;
+
+        if let Some((shared_memory, drop_token)) = shmem {
+            self.sent_out_shared_memory
+                .insert(drop_token, shared_memory);
+        }
+
+        Ok(())
+    }
+
+    pub fn close_outputs(&mut self, outputs: Vec<DataId>) -> eyre::Result<()> {
+        for output_id in &outputs {
+            if !self.node_config.outputs.remove(output_id) {
+                eyre::bail!("unknown output {output_id}");
+            }
+        }
+
+        self.control_channel
+            .report_closed_outputs(outputs)
+            .wrap_err("failed to report closed outputs to daemon")?;
+
+        Ok(())
+    }
+
+    pub fn id(&self) -> &NodeId {
+        &self.id
+    }
+
+    pub fn dataflow_id(&self) -> &DataflowId {
+        &self.dataflow_id
+    }
+
+    pub fn node_config(&self) -> &NodeRunConfig {
+        &self.node_config
+    }
+
+    pub fn allocate_data_sample(&mut self, data_len: usize) -> eyre::Result<DataSample> {
+        let data = if data_len >= ZERO_COPY_THRESHOLD {
+            // create shared memory region
+            let shared_memory = self.allocate_shared_memory(data_len)?;
+
+            DataSample {
+                inner: DataSampleInner::Shmem(shared_memory),
+                len: data_len,
+            }
+        } else {
+            let avec: AVec<u8, ConstAlign<128>> = AVec::__from_elem(128, 0, data_len);
+
+            avec.into()
+        };
+
+        Ok(data)
+    }
+
+    fn allocate_shared_memory(&mut self, data_len: usize) -> eyre::Result<ShmemHandle> {
+        let cache_index = self
+            .cache
+            .iter()
+            .enumerate()
+            .rev()
+            .filter(|(_, s)| s.len() >= data_len)
+            .min_by_key(|(_, s)| s.len())
+            .map(|(i, _)| i);
+        let memory = match cache_index {
+            Some(i) => {
+                // we know that this index exists, so we can safely unwrap here
+                self.cache.remove(i).unwrap()
+            }
+            None => ShmemHandle(Box::new(
+                ShmemConf::new()
+                    .size(data_len)
+                    .writable(true)
+                    .create()
+                    .wrap_err("failed to allocate shared memory")?,
+            )),
+        };
+        assert!(memory.len() >= data_len);
+
+        Ok(memory)
+    }
+
+    fn handle_finished_drop_tokens(&mut self) -> eyre::Result<()> {
+        loop {
+            match self.drop_stream.try_recv() {
+                Ok(token) => match self.sent_out_shared_memory.remove(&token) {
+                    Some(region) => self.add_to_cache(region),
+                    None => tracing::warn!("received unknown finished drop token `{token:?}`"),
+                },
+                Err(flume::TryRecvError::Empty) => break,
+                Err(flume::TryRecvError::Disconnected) => {
+                    bail!("event stream was closed before sending all expected drop tokens")
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn add_to_cache(&mut self, memory: ShmemHandle) {
+        const MAX_CACHE_SIZE: usize = 20;
+
+        self.cache.push_back(memory);
+        while self.cache.len() > MAX_CACHE_SIZE {
+            self.cache.pop_front();
+        }
+    }
+
+    /// Returns the full dataflow descriptor that this node is part of.
+    ///
+    /// This method returns the parsed dataflow YAML file.
+    pub fn dataflow_descriptor(&self) -> &Descriptor {
+        &self.dataflow_descriptor
+    }
+}
+
+impl Drop for DoraNode {
+    #[tracing::instrument(skip(self), fields(self.id = %self.id), level = "trace")]
+    fn drop(&mut self) {
+        // close all outputs first to notify subscribers as early as possible
+        if let Err(err) = self
+            .control_channel
+            .report_closed_outputs(
+                std::mem::take(&mut self.node_config.outputs)
+                    .into_iter()
+                    .collect(),
+            )
+            .context("failed to close outputs on drop")
+        {
+            tracing::warn!("{err:?}")
+        }
+
+        while !self.sent_out_shared_memory.is_empty() {
+            if self.drop_stream.len() == 0 {
+                tracing::trace!(
+                    "waiting for {} remaining drop tokens",
+                    self.sent_out_shared_memory.len()
+                );
+            }
+
+            match self.drop_stream.recv_timeout(Duration::from_secs(10)) {
+                Ok(token) => {
+                    self.sent_out_shared_memory.remove(&token);
+                }
+                Err(flume::RecvTimeoutError::Disconnected) => {
+                    tracing::warn!(
+                        "finished_drop_tokens channel closed while still waiting for drop tokens; \
+                        closing {} shared memory regions that might still be used",
+                        self.sent_out_shared_memory.len()
+                    );
+                    break;
+                }
+                Err(flume::RecvTimeoutError::Timeout) => {
+                    tracing::warn!(
+                        "timeout while waiting for drop tokens; \
+                        closing {} shared memory regions that might still be used",
+                        self.sent_out_shared_memory.len()
+                    );
+                    break;
+                }
+            }
+        }
+
+        if let Err(err) = self.control_channel.report_outputs_done() {
+            tracing::warn!("{err:?}")
+        }
+    }
+}
+
+pub struct DataSample {
+    inner: DataSampleInner,
+    len: usize,
+}
+
+impl DataSample {
+    fn finalize(self) -> (Option<DataMessage>, Option<(ShmemHandle, DropToken)>) {
+        match self.inner {
+            DataSampleInner::Shmem(shared_memory) => {
+                let drop_token = DropToken::generate();
+                let data = DataMessage::SharedMemory {
+                    shared_memory_id: shared_memory.get_os_id().to_owned(),
+                    len: self.len,
+                    drop_token,
+                };
+                (Some(data), Some((shared_memory, drop_token)))
+            }
+            DataSampleInner::Vec(buffer) => (Some(DataMessage::Vec(buffer)), None),
+        }
+    }
+}
+
+impl Deref for DataSample {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        let slice = match &self.inner {
+            DataSampleInner::Shmem(handle) => unsafe { handle.as_slice() },
+            DataSampleInner::Vec(data) => data,
+        };
+        &slice[..self.len]
+    }
+}
+
+impl DerefMut for DataSample {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        let slice = match &mut self.inner {
+            DataSampleInner::Shmem(handle) => unsafe { handle.as_slice_mut() },
+            DataSampleInner::Vec(data) => data,
+        };
+        &mut slice[..self.len]
+    }
+}
+
+impl From<AVec<u8, ConstAlign<128>>> for DataSample {
+    fn from(value: AVec<u8, ConstAlign<128>>) -> Self {
+        Self {
+            len: value.len(),
+            inner: DataSampleInner::Vec(value),
+        }
+    }
+}
+
+impl std::fmt::Debug for DataSample {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let kind = match &self.inner {
+            DataSampleInner::Shmem(_) => "SharedMemory",
+            DataSampleInner::Vec(_) => "Vec",
+        };
+        f.debug_struct("DataSample")
+            .field("len", &self.len)
+            .field("kind", &kind)
+            .finish_non_exhaustive()
+    }
+}
+
+enum DataSampleInner {
+    Shmem(ShmemHandle),
+    Vec(AVec<u8, ConstAlign<128>>),
+}
+
+struct ShmemHandle(Box<Shmem>);
+
+impl Deref for ShmemHandle {
+    type Target = Shmem;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for ShmemHandle {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+unsafe impl Send for ShmemHandle {}
+unsafe impl Sync for ShmemHandle {}

apis/rust/operator/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "dora-operator-api"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dora-operator-api-macros = { workspace = true }
+dora-operator-api-types = { workspace = true }
+dora-arrow-convert = { workspace = true }

apis/rust/operator/macros/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "dora-operator-api-macros"
+version.workspace = true
+edition = "2021"
+description = "Rust API Macros for Dora Operator"
+documentation.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "1.0.81", features = ["full"] }
+quote = "1.0.10"
+proc-macro2 = "1.0.32"

apis/rust/operator/macros/src/lib.rs

@@ -0,0 +1,74 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+extern crate proc_macro;
+
+#[proc_macro]
+pub fn register_operator(item: TokenStream) -> TokenStream {
+    // convert from `TokenStream` to `TokenStream2`, which is used by the
+    // `syn` crate
+    let item = TokenStream2::from(item);
+    // generate the dora wrapper functions
+    let generated = register_operator_impl(&item).unwrap_or_else(|err| err.to_compile_error());
+    // output the generated functions
+    let tokens = quote! {
+        #generated
+    };
+    // convert the type back from `TokenStream2` to `TokenStream`
+    tokens.into()
+}
+
+/// Generates the wrapper functions for the annotated function.
+fn register_operator_impl(item: &TokenStream2) -> syn::Result<TokenStream2> {
+    // parse the type given to the `register_operator` macro
+    let operator_ty: syn::TypePath = syn::parse2(item.clone())
+        .map_err(|e| syn::Error::new(e.span(), "expected type as argument"))?;
+
+    let init = quote! {
+        #[no_mangle]
+        pub unsafe extern "C" fn dora_init_operator() -> dora_operator_api::types::DoraInitResult {
+            dora_operator_api::raw::dora_init_operator::<#operator_ty>()
+        }
+
+        const _DORA_INIT_OPERATOR: dora_operator_api::types::DoraInitOperator = dora_operator_api::types::DoraInitOperator {
+            init_operator: dora_init_operator,
+        };
+    };
+
+    let drop = quote! {
+        #[no_mangle]
+        pub unsafe extern "C" fn dora_drop_operator(operator_context: *mut std::ffi::c_void)
+            -> dora_operator_api::types::DoraResult
+        {
+            dora_operator_api::raw::dora_drop_operator::<#operator_ty>(operator_context)
+        }
+
+        const _DORA_DROP_OPERATOR: dora_operator_api::types::DoraDropOperator = dora_operator_api::types::DoraDropOperator {
+            drop_operator: dora_drop_operator,
+        };
+    };
+
+    let on_event = quote! {
+        #[no_mangle]
+        pub unsafe extern "C" fn dora_on_event(
+            event: &mut dora_operator_api::types::RawEvent,
+            send_output: &dora_operator_api::types::SendOutput,
+            operator_context: *mut std::ffi::c_void,
+        ) -> dora_operator_api::types::OnEventResult {
+            dora_operator_api::raw::dora_on_event::<#operator_ty>(
+                event, send_output, operator_context
+            )
+        }
+
+        const _DORA_ON_EVENT: dora_operator_api::types::DoraOnEvent = dora_operator_api::types::DoraOnEvent {
+            on_event: dora_operator_api::types::OnEventFn(dora_on_event),
+        };
+    };
+
+    Ok(quote! {
+        #init
+        #drop
+        #on_event
+    })
+}

apis/rust/operator/src/lib.rs

@@ -0,0 +1,69 @@
+//! The operator API is a framework to implement dora operators.
+//! The implemented operator will be managed by `dora`.
+//!
+//! This framework enable us to make optimisation and provide advanced features.
+//! It is the recommended way of using `dora`.
+//!
+//! An operator requires to be registered and implement the `DoraOperator` trait.
+//! It is composed of an `on_event` method that defines the behaviour
+//! of the operator when there is an event such as receiving an input for example.
+//!
+//! Try it out with:
+//!
+//! ```bash
+//! dora new op --kind operator
+//! ```
+//!
+
+#![warn(unsafe_op_in_unsafe_fn)]
+#![allow(clippy::missing_safety_doc)]
+
+pub use dora_arrow_convert::*;
+pub use dora_operator_api_macros::register_operator;
+pub use dora_operator_api_types as types;
+pub use types::DoraStatus;
+use types::{
+    arrow::{self, array::Array},
+    Metadata, Output, SendOutput,
+};
+
+pub mod raw;
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Event<'a> {
+    Input { id: &'a str, data: ArrowData },
+    InputParseError { id: &'a str, error: String },
+    InputClosed { id: &'a str },
+    Stop,
+}
+
+pub trait DoraOperator: Default {
+    #[allow(clippy::result_unit_err)] // we use a () error type only for testing
+    fn on_event(
+        &mut self,
+        event: &Event,
+        output_sender: &mut DoraOutputSender,
+    ) -> Result<DoraStatus, String>;
+}
+
+pub struct DoraOutputSender<'a>(&'a SendOutput);
+
+impl DoraOutputSender<'_> {
+    ///  Send an output from the operator:
+    ///  - `id` is the `output_id` as defined in your dataflow.
+    ///  - `data` is the data that should be sent
+    pub fn send(&mut self, id: String, data: impl Array) -> Result<(), String> {
+        let (data_array, schema) =
+            arrow::ffi::to_ffi(&data.into_data()).map_err(|err| err.to_string())?;
+        let result = self.0.send_output.call(Output {
+            id: id.into(),
+            data_array,
+            schema,
+            metadata: Metadata {
+                open_telemetry_context: String::new().into(), // TODO
+            },
+        });
+        result.into_result()
+    }
+}

apis/rust/operator/src/raw.rs

@@ -0,0 +1,80 @@
+use crate::{DoraOperator, DoraOutputSender, DoraStatus, Event};
+use dora_operator_api_types::{
+    arrow, DoraInitResult, DoraResult, OnEventResult, RawEvent, SendOutput,
+};
+use std::ffi::c_void;
+
+pub type OutputFnRaw = unsafe extern "C" fn(
+    id_start: *const u8,
+    id_len: usize,
+    data_start: *const u8,
+    data_len: usize,
+    output_context: *const c_void,
+) -> isize;
+
+pub unsafe fn dora_init_operator<O: DoraOperator>() -> DoraInitResult {
+    let operator: O = Default::default();
+    let ptr: *mut O = Box::leak(Box::new(operator));
+    let operator_context: *mut c_void = ptr.cast();
+    DoraInitResult {
+        result: DoraResult { error: None },
+        operator_context,
+    }
+}
+
+pub unsafe fn dora_drop_operator<O>(operator_context: *mut c_void) -> DoraResult {
+    let raw: *mut O = operator_context.cast();
+    drop(unsafe { Box::from_raw(raw) });
+    DoraResult { error: None }
+}
+
+pub unsafe fn dora_on_event<O: DoraOperator>(
+    event: &mut RawEvent,
+    send_output: &SendOutput,
+    operator_context: *mut std::ffi::c_void,
+) -> OnEventResult {
+    let mut output_sender = DoraOutputSender(send_output);
+
+    let operator: &mut O = unsafe { &mut *operator_context.cast() };
+
+    let event_variant = if let Some(input) = &mut event.input {
+        let Some(data_array) = input.data_array.take() else {
+            return OnEventResult {
+                result: DoraResult::from_error("data already taken".to_string()),
+                status: DoraStatus::Continue,
+            };
+        };
+        let data = unsafe { arrow::ffi::from_ffi(data_array, &input.schema) };
+
+        match data {
+            Ok(data) => Event::Input {
+                id: &input.id,
+                data: arrow::array::make_array(data).into(),
+            },
+            Err(err) => Event::InputParseError {
+                id: &input.id,
+                error: format!("{err}"),
+            },
+        }
+    } else if let Some(input_id) = &event.input_closed {
+        Event::InputClosed { id: input_id }
+    } else if event.stop {
+        Event::Stop
+    } else {
+        // ignore unknown events
+        return OnEventResult {
+            result: DoraResult { error: None },
+            status: DoraStatus::Continue,
+        };
+    };
+    match operator.on_event(&event_variant, &mut output_sender) {
+        Ok(status) => OnEventResult {
+            result: DoraResult { error: None },
+            status,
+        },
+        Err(error) => OnEventResult {
+            result: DoraResult::from_error(error),
+            status: DoraStatus::Stop,
+        },
+    }
+}

apis/rust/operator/types/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "dora-operator-api-types"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+arrow = { workspace = true, features = ["ffi"] }
+dora-arrow-convert = { workspace = true }
+
+[dependencies.safer-ffi]
+version = "0.1.4"
+features = ["headers", "inventory-0-3-1"]

apis/rust/operator/types/src/lib.rs

@@ -0,0 +1,212 @@
+#![deny(elided_lifetimes_in_paths)] // required for safer-ffi
+#![allow(improper_ctypes_definitions)]
+#![allow(clippy::missing_safety_doc)]
+
+pub use arrow;
+use dora_arrow_convert::{ArrowData, IntoArrow};
+pub use safer_ffi;
+
+use arrow::{
+    array::Array,
+    ffi::{FFI_ArrowArray, FFI_ArrowSchema},
+};
+use core::slice;
+use safer_ffi::{
+    char_p::{self, char_p_boxed},
+    closure::ArcDynFn1,
+    derive_ReprC, ffi_export,
+};
+use std::{ops::Deref, path::Path};
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+pub struct DoraInitOperator {
+    pub init_operator: unsafe extern "C" fn() -> DoraInitResult,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+#[derive(Debug)]
+pub struct DoraInitResult {
+    pub result: DoraResult,
+    pub operator_context: *mut std::ffi::c_void,
+}
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+pub struct DoraDropOperator {
+    pub drop_operator: unsafe extern "C" fn(operator_context: *mut std::ffi::c_void) -> DoraResult,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+#[derive(Debug)]
+pub struct DoraResult {
+    pub error: Option<safer_ffi::boxed::Box<safer_ffi::String>>,
+}
+
+impl DoraResult {
+    pub const SUCCESS: Self = Self { error: None };
+
+    pub fn from_error(error: String) -> Self {
+        Self {
+            error: Some(Box::new(safer_ffi::String::from(error)).into()),
+        }
+    }
+
+    pub fn error(&self) -> Option<&str> {
+        self.error.as_deref().map(|s| s.deref())
+    }
+
+    pub fn into_result(self) -> Result<(), String> {
+        match self.error {
+            None => Ok(()),
+            Some(error) => {
+                let converted = safer_ffi::boxed::Box_::into(error);
+                Err((*converted).into())
+            }
+        }
+    }
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+pub struct DoraOnEvent {
+    pub on_event: OnEventFn,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(transparent)]
+pub struct OnEventFn(
+    pub  unsafe extern "C" fn(
+        event: &mut RawEvent,
+        send_output: &SendOutput,
+        operator_context: *mut std::ffi::c_void,
+    ) -> OnEventResult,
+);
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+#[derive(Debug)]
+pub struct RawEvent {
+    pub input: Option<safer_ffi::boxed::Box<Input>>,
+    pub input_closed: Option<safer_ffi::String>,
+    pub stop: bool,
+    pub error: Option<safer_ffi::String>,
+}
+
+#[derive_ReprC]
+#[repr(opaque)]
+#[derive(Debug)]
+pub struct Input {
+    pub id: safer_ffi::String,
+    pub data_array: Option<FFI_ArrowArray>,
+    pub schema: FFI_ArrowSchema,
+    pub metadata: Metadata,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+#[derive(Debug)]
+pub struct Metadata {
+    pub open_telemetry_context: safer_ffi::String,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+pub struct SendOutput {
+    pub send_output: ArcDynFn1<DoraResult, Output>,
+}
+
+#[derive_ReprC]
+#[repr(opaque)]
+#[derive(Debug)]
+pub struct Output {
+    pub id: safer_ffi::String,
+    pub data_array: FFI_ArrowArray,
+    pub schema: FFI_ArrowSchema,
+    pub metadata: Metadata,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[repr(C)]
+#[derive(Debug)]
+pub struct OnEventResult {
+    pub result: DoraResult,
+    pub status: DoraStatus,
+}
+
+#[derive_ReprC]
+#[ffi_export]
+#[derive(Debug)]
+#[repr(u8)]
+pub enum DoraStatus {
+    Continue = 0,
+    Stop = 1,
+    StopAll = 2,
+}
+
+#[ffi_export]
+pub fn dora_read_input_id(input: &Input) -> char_p_boxed {
+    char_p::new(&*input.id)
+}
+
+#[ffi_export]
+pub fn dora_free_input_id(_input_id: char_p_boxed) {}
+
+#[ffi_export]
+pub fn dora_read_data(input: &mut Input) -> Option<safer_ffi::Vec<u8>> {
+    let data_array = input.data_array.take()?;
+    let data = unsafe { arrow::ffi::from_ffi(data_array, &input.schema).ok()? };
+    let array = ArrowData(arrow::array::make_array(data));
+    let bytes: &[u8] = TryFrom::try_from(&array).ok()?;
+    Some(bytes.to_owned().into())
+}
+
+#[ffi_export]
+pub fn dora_free_data(_data: safer_ffi::Vec<u8>) {}
+
+#[ffi_export]
+pub unsafe fn dora_send_operator_output(
+    send_output: &SendOutput,
+    id: safer_ffi::char_p::char_p_ref<'_>,
+    data_ptr: *const u8,
+    data_len: usize,
+) -> DoraResult {
+    let result = || {
+        let data = unsafe { slice::from_raw_parts(data_ptr, data_len) };
+        let arrow_data = data.to_owned().into_arrow();
+        let (data_array, schema) =
+            arrow::ffi::to_ffi(&arrow_data.into_data()).map_err(|err| err.to_string())?;
+        let output = Output {
+            id: id.to_str().to_owned().into(),
+            data_array,
+            schema,
+            metadata: Metadata {
+                open_telemetry_context: String::new().into(), // TODO
+            },
+        };
+        Result::<_, String>::Ok(output)
+    };
+    match result() {
+        Ok(output) => send_output.send_output.call(output),
+        Err(error) => DoraResult {
+            error: Some(Box::new(safer_ffi::String::from(error)).into()),
+        },
+    }
+}
+
+pub fn generate_headers(target_file: &Path) -> ::std::io::Result<()> {
+    ::safer_ffi::headers::builder()
+        .to_file(target_file)?
+        .generate()
+}

binaries/cli/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "dora-cli"
+version.workspace = true
+edition = "2021"
+documentation.workspace = true
+description.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "dora"
+path = "src/main.rs"
+
+[features]
+default = ["tracing"]
+tracing = ["dep:dora-tracing"]
+
+[dependencies]
+clap = { version = "4.0.3", features = ["derive"] }
+eyre = "0.6.8"
+dora-core = { workspace = true }
+dora-node-api-c = { workspace = true }
+dora-operator-api-c = { workspace = true }
+serde = { version = "1.0.136", features = ["derive"] }
+serde_yaml = "0.9.11"
+webbrowser = "0.8.3"
+serde_json = "1.0.86"
+termcolor = "1.1.3"
+uuid = { version = "1.7", features = ["v7", "serde"] }
+inquire = "0.5.2"
+communication-layer-request-reply = { workspace = true }
+notify = "5.1.0"
+ctrlc = "3.2.5"
+tracing = "0.1.36"
+dora-tracing = { workspace = true, optional = true }
+bat = "0.24.0"
+dora-daemon = { workspace = true }
+dora-coordinator = { workspace = true }
+dora-runtime = { workspace = true }
+tokio = { version = "1.20.1", features = ["full"] }
+tokio-stream = { version = "0.1.8", features = ["io-util", "net"] }
+futures = "0.3.21"
+duration-str = "0.5"