csg-robomaster

+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

CONTRIBUTING.md ADDED Viewed

	@@ -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.lock ADDED Viewed

The diff for this file is too large to render. See raw diff

Cargo.toml ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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.

README.md ADDED Viewed

	@@ -0,0 +1,200 @@

+---
+language:
+- en
+pipeline_tag: image-to-text
+tags:
+- code
+license: apache-2.0
+---
+# **csg-robomaster**          [[中文]](#chinese)    [[English]](#english)
+<a id="english"></a>
+<p align="center">
+<img width="900px" alt="OpenCSG" src="https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/Z8ahDx_3z98ThvRlc_RSA.jpeg">
+</p>
+<p align="center"><a href="https://opencsg.com/models">[OpenCSG Community]</a>   <a href="https://github.com/opencsgs">[github]</a>  <a href="https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/HU6vz21qKTEmUBCWqCFh9.jpeg">[wechat]</a>  <a href="https://twitter.com/OpenCsg">[Twitter]</a> </p>
+</div>
+OpenCSG stands for Converged resources, Software refinement, and Generative LM. The 'C' represents Converged resources, indicating the integration and full utilization of hybrid resources. The 'S' stands for Software refinement, signifying software that is refined by large models. The 'G' represents Generative LM, which denotes widespread, inclusive, and democratized generative large models.
+The vision of OpenCSG is to empower every industry, every company, and every individual to own their models. We adhere to the principles of openness and open source, making the large model software stack of OpenCSG available to the community. We welcome everyone to use, send feedback, and contribute collaboratively.
+# Getting Started
+Create a new python environment for robomaster and dora-rs
+```bash
+conda create -n robomaster python=3.8
+pip install robomaster dora-rs==0.3.4
+pip install -r requirements_robot.txt
+```
+## Robomaster Jailbreak
+### Installation of the Robomaster S1 Hack
+This guide is an updated version of the original [Robomaster S1 SDK Hack Guide](https://www.bug-br.org.br/s1_sdk_hack.zip) and is intended for use on a Windows 11 system.
+#### Prerequisites
+Before you get started, you'll need the following:
+- Robomaster S1 (do not update it to the latest version, as it may block the hack).
+- [Robomaster App](https://www.dji.com/fr/robomaster-s1/downloads).
+- [Android SDK Platform-Tools](https://developer.android.com/tools/releases/platform-tools). Simply unzip it and keep the path handy.
+- A micro USB cable. If this guide doesn't work, there might be an issue with the cable, and you may need to replace it with one that supports data transfer.
+#### Instructions
+1. Start the Robomaster App and connect the Robomaster S1 using one of the two options provided (via router or via Wi-Fi).
+2. While connected, use a micro USB cable to connect the robot to the computer's USB port. You should hear a beep sound, similar to when you connect any device. (Please note that no other Android device should be connected via USB during this process).
+3. In the Lab section of the app, create a new Python application and paste the following code:
+   ```python
+   def root_me(module):
+       __import__ = rm_define.__dict__['__builtins__']['__import__']
+       return __import__(module, globals(), locals(), [], 0)
+   builtins = root_me('builtins')
+   subprocess = root_me('subprocess')
+   proc = subprocess.Popen('/system/bin/adb_en.sh', shell=True, executable='/system/bin/sh', stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+   ```
+4. Run the code; there should be no errors, and the console should display **Execution Complete**
+5. Without closing the app, navigate to the folder containing the Android SDK Platform-Tools and open a terminal inside it.
+6. Run the ADP command `.\adb.exe devices `. If everything is working correctly, you should see output similar to this: ![image](https://github.com/Felixhuangsiling/Dora-Robomaster/assets/77993249/dc6368ec-052c-4b18-8fdc-0ec314adb073)
+7. Execute the upload.sh script located in the folder `s1_SDK`.
+8. Once everything has been executed, restart the S1 by turning it off and then back on. While it's booting up, you should hear two chimes instead of the usual single chime, indicating that the hack has been successful.
+## Robomaster Connection
+Make sure to be connected using the wifi hotspot of the robomaster which is the most stable one.
+The default password for the hotpsot is: 12341234
+You might need to have a second wifi card if you want to be able to run the demo with internet on.
+## Post-Installation test
+Please try running model operators and robomaster with:
+conda activate robomaster
+```bash
+cd examples/hf-operator
+python test_sta.py
+```
+## Running the demo
+```bash
+# This requires dora==0.3.4
+# cargo install dora-cli
+dora up
+dora start graphs/dataflow_robot_vlm.yml --attach --hot-reload
+```
+## Kill process in case of failure
+Due to a Python GIL issue, we currently meed to kill processes manually. You can use the following command to do so:
+```bash
+pkill -f 'import dora;'
+```
+## LICENSE
+Apache-2.0
+<p>
+</p>
+<a id="chinese"></a>
+<p>
+</p>
+# OpenCSG介绍
+<p align="center">
+<img width="300px" alt="OpenCSG" src="https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/GwYXPKuEoGCGcMICeW-sb.jpeg">
+</p>
+<p align="center"><a href="https://opencsg.com/models">[OpenCSG 社区]</a>   <a href="https://github.com/opencsgs">[github]</a>  <a href="https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/HU6vz21qKTEmUBCWqCFh9.jpeg">[微信]</a>  <a href="https://twitter.com/OpenCsg">[推特]</a> </p>
+</div>
+OpenCSG中 Open是开源开放；C 代表 Converged resources，整合和充分利用的混合异构资源优势，算力降本增效；S 代表 Software refined，重新定义软件的交付方式，通过大模型驱动软件开发，人力降本增效；G 代表 Generative LM，大众化、普惠化和民主化的可商用的开源生成式大模型。
+OpenCSG的愿景是让每个行业、每个公司、每个人都拥有自己的模型。 我们坚持开源开放的原则，将OpenCSG的大模型软件栈开源到社区，欢迎使用、反馈和参与共建，欢迎关注。
+## 快速开始
+为了在RoboMaster S1上部署小型语言模型，需要进行一些基础部署工作。首先，通过以下命令下载相关项目代码：
+git clone https://opencsg.com/codes/csg-robomaster
+接下来，创建项目的环境，使用以下命令：
+conda create -n robomaster python=3.8
+pip install robomaster dora-rs==0.3.4
+pip install -r requirements_robot.txt
+接着，需要进行RoboMaster S1的破解工作。具体步骤如下：
+1. 启动RoboMaster应用程序，并选择通过路由器或通过WLAN的方式连接RoboMaster S1。
+2. 连接成功后，使用微型USB电缆将RoboMaster S1连接到计算机的USB端口。连接成功时会听到一声“哔”的声音，类似于连接任何设备时的声音。（请注意，在此过程中不得通过USB连接其他安卓设备）
+3. 在应用程序的“实验室”部分，创建一个新的Python应用程序，并粘贴以下代码：
+   ```python
+   def root_me(module):
+       __import__ = rm_define.__dict__['__builtins__']['__import__']
+       return __import__(module, globals(), locals(), [], 0)
+   builtins = root_me('builtins')
+   subprocess = root_me('subprocess')
+   proc = subprocess.Popen('/system/bin/adb_en.sh', shell=True, executable='/system/bin/sh', stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+   ```
+4. 运行代码，如果没有出现错误，控制台应显示“执行完毕”的结果。
+5. 在不关闭应用程序的情况下，导航至包含Android SDK Platform-Tools文件夹的位置，并在其中打开终端。
+6. 运行 ADP 命令 .\adb.exe devices 。 如果一切正常，应该会看到类似下面的输出：
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/HQDBQXWXI4ptd_D1gSVUr.png)
+8. 执行位于 s1_SDK 文件夹中的 upload.sh 脚本。
+9. 当所有步骤执行完毕后，关闭RoboMaster S1并重新启动。在启动过程中，您应该会听到两声鸣叫，而不是通常的一声鸣叫，这表明破解操作已成功。
+完成基础部署后，就可以进行RoboMaster S1的连接与测试。具体步骤如下：
+1. 确保使用稳定的RoboMaster无线热点连接，无线热点的默认密码是12341234。如果想在联网的情况下运行演示程序，可能需要使用第二张无线网卡。
+2. 尝试使用以下命令测试与RoboMaster S1的连接：
+```bash
+conda activate robomaster
+cd examples/hf-operator
+python test_sta.py
+也可以直接在命令行中运行测试文件中的代码。如果通信成功，控制台将显示类似下面的输出：
+```
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/MQ-1sajxDKAfsiw7JF6ph.png)
+成功连接并测试后，就可以运行具身智能机器人的演示程序了。在命令行中使用以下命令：
+```bash
+  # This requires dora==0.3.4
+  # cargo install dora-cli
+  dora up
+  dora start graphs/dataflow_robot_vlm.yml --attach --hot-reload
+```
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c71b27d43e4dee51a8b31a/4Eb0Wk85QTQb8C1Tj_min.png)
+目前，互动方式是在笔记本电脑上按下向上箭头键，将信息录制并发送到机器人的视觉语言模型（Visual Language Model，VLM）。这一基础部署工作为RoboMaster S1上的具身智能机器人开发奠定了坚实的基础。通过结合小型语言模型和具身智能的人性化交互设计，具身智能机器人不仅将广泛应用于家庭、教育和医疗等行业，提供个性化的服务，还将推动智能技术在更广泛的场景中的普及。

apis/c++/node/Cargo.toml ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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/dora/__pycache__/__init__.cpython-38.pyc ADDED Viewed

Binary file (1.09 kB). View file

apis/python/node/generate_stubs.py ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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"]