[WIP] Refactor(rust-sdk): rewrite and align with java sdk

.dockerignore

@@ -1,2 +1,31 @@
 dist/
 build/
+**/build/
+
+# VCS and gradle caches (the wrapper is not used; system gradle lives in the
+# builder image).
+.git/
+.gitignore
+.gradle/
+**/.gradle/
+
+# Non-Java SDKs (not included in Gradle build)
+eventmesh-sdks/eventmesh-sdk-rust/
+eventmesh-sdks/eventmesh-sdk-go/
+eventmesh-sdks/eventmesh-sdk-c/
+
+# Rust / Node build artifacts. Keep the pattern slashless so Docker excludes
+# both the target directory itself and everything below it in any SDK context.
+**/target
+**/node_modules/
+
+# IDE / editor cruft.
+.idea/
+.vscode/
+*.iml
+*.ipr
+*.iws
+
+# Docs & misc
+docs/
+*.md

.zed/settings.json

@@ -0,0 +1,15 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "cargo": {
+          "features": "all"
+        }
+      }
+    }
+  }
+}

eventmesh-sdks/eventmesh-sdk-rust/AGENTS.md

@@ -0,0 +1,10 @@
+# Agent guidance for the EventMesh Rust SDK
+
+This crate is independent of the repository's Gradle build. Before changing it, read the project-owned documentation instead of duplicating it here:
+
+- [README.md](README.md) — supported features, installation, and public behavior.
+- [CONTRIBUTING.md](CONTRIBUTING.md) — prerequisites, checks, end-to-end tests, documentation ownership, and code conventions.
+- [ARCHITECTURE.md](ARCHITECTURE.md) — protocol boundaries, generated code, and transport-specific implementation constraints.
+- [examples/README.md](examples/README.md) — runnable examples and exact feature flags.
+
+Keep those files authoritative. Update this file only when instructions specific to coding agents cannot be expressed naturally in the contributor or architecture documentation.

eventmesh-sdks/eventmesh-sdk-rust/ARCHITECTURE.md

@@ -0,0 +1,52 @@
+# EventMesh Rust SDK architecture
+
+This document records implementation constraints and protocol boundaries. For public usage, see [README.md](README.md); for build and test commands, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Public API boundaries
+
+- `src/lib.rs` denies unsafe code.
+- `src/transport/mod.rs` defines `Publisher` with async functions in the trait. It is not object-safe; use `GrpcProducer`, `HttpProducer`, or `TcpProducer` directly rather than `dyn Publisher`.
+- Subscription is intentionally transport-specific. Each consumer owns its receive loop where applicable and exposes lifecycle methods suited to its protocol.
+- `src/common/` contains protocol keys, status codes, constants, and the shared `LoadBalanceSelector`.
+
+## Generated protobuf code
+
+`build.rs` uses `tonic-build` to compile `proto/eventmesh-{service,cloudevents}.proto` into Cargo's `OUT_DIR`. It creates client stubs only and enables `--experimental_allow_proto3_optional`. The two `.proto` inputs and the hand-written `src/proto_gen.rs` wrapper are checked in. The generated Rust files remain in `OUT_DIR` and are loaded by `tonic::include_proto!`; under the current build setup, those generated files are not checked in. Add convenience aliases to `proto_gen.rs` rather than editing build output.
+
+## Wire formats
+
+`EventMeshMessage` is a business model, not a shared wire DTO. Each transport owns its serialization:
+
+| Transport | Boundary | Encoding |
+| --- | --- | --- |
+| gRPC | `src/transport/grpc/codec.rs` | CloudEvents protobuf |
+| HTTP | `src/transport/http/codec.rs` | Form URL encoding, with JSON in `content` |
+| TCP | `src/transport/tcp/message.rs` | Length-prefixed binary frames with `EventMesh` magic |
+
+TCP CloudEvents use `protocoltype=cloudevents` and raw `application/cloudevents+json` bytes, matching the Java runtime codec path.
+
+## Configuration
+
+- Every transport consumes the public configuration types directly:
+  `GrpcConfig`, `HttpConfig`, and `TcpConfig`, together with the role
+  options (`ProducerOptions`, `ConsumerOptions`) passed to each role
+  factory. There are no transport-private configuration adapters.
+- `GrpcChannel::connect` creates the tonic channel on the current Tokio
+  runtime. Roles receive the channel explicitly and clones share its
+  multiplexed HTTP/2 connection. Applications using multiple Tokio runtimes
+  create a separate channel in each runtime.
+- `HttpConfig` carries an `EndpointSet`; endpoint weights feed the shared
+  load balancer and identity/credentials ride as HTTP headers.
+- `TcpConfig` keeps connect, protocol-control, business request, heartbeat,
+  and reconnect timeouts separate for Java compatibility. Heartbeats and
+  GOODBYE are fire-and-forget.
+
+## HTTP lifecycle and routing
+
+The managed `HttpConsumer` binds its axum callback server before registration, then owns registration, heartbeat, and shutdown. Applications that host their own endpoint use `WebhookRegistration` and the public codec helpers `parse_push_body`, `PushMessageRequestBody::to_event_mesh_message`, and `WebhookReply`. `WebhookHandler` and `WebhookState` in `src/transport/http/webhook.rs` are internal implementation details.
+
+All SDK HTTP operations use code-header routing at `/`. The bodies are `application/x-www-form-urlencoded`, so sending them to a Runtime path-based handler can select an incompatible JSON model. The heartbeat runs every 30 seconds in a background Tokio task tied to a `CancellationToken`.
+
+## TCP connection lifecycle
+
+In `src/transport/tcp/connection.rs`, `establish()` performs the socket and HELLO handshake. `run()` wraps `io_loop()` in the reconnect loop. With reconnect enabled, I/O failures trigger exponential backoff and re-establishment. `take_reconnect_rx()` notifies consumers after successful reconnects so they can replay subscriptions.

eventmesh-sdks/eventmesh-sdk-rust/CONTRIBUTING.md

@@ -0,0 +1,72 @@
+# Contributing to the EventMesh Rust SDK
+
+This guide covers `eventmesh-sdks/eventmesh-sdk-rust`. Repository-wide Apache EventMesh contribution requirements still apply.
+
+## Prerequisites
+
+- Rust 1.86.0 or newer (the crate MSRV)
+- `protoc` on `PATH` for builds that enable `grpc`, `full`, or `e2e`
+- Docker and a compatible EventMesh runtime only for live end-to-end tests
+- Java 8 or newer and Maven for the optional cross-SDK interop tests
+
+`build.rs` invokes `tonic-build`; generated protobuf code lives in `OUT_DIR` and must not be edited or committed.
+
+## Local checks
+
+Run these before submitting a Rust SDK change:
+
+```bash
+cargo fmt --check
+cargo clippy --no-default-features --lib -- -D warnings
+cargo clippy --features full --all-targets -- -D warnings
+cargo test --features full
+cargo doc --features full --no-deps
+```
+
+Use `cargo test --features full --test codec_test` for the codec test binary. Examples are feature-gated in `Cargo.toml`; compile the one you changed with its documented `cargo run --example ... --features ...` command, or compile all supported paths with `cargo check --examples --features full`.
+
+## End-to-end tests
+
+The e2e suite is opt-in so a normal `cargo test` never requires Docker:
+
+```bash
+cargo test --features e2e
+```
+
+The harness starts the `rocketmq` docker-compose profile unless `EVENTMESH_E2E_EXTERNAL=1` points it at an already running runtime. An absent runtime is a failure by default. `EVENTMESH_E2E_ALLOW_SKIP=1` is only for an intentional local skip and must not be used for release verification.
+
+The bundled compose file pins the Runtime to `apache/eventmesh:v1.12.0`. Run the bidirectional Rust/Java gRPC, HTTP, and TCP checks with:
+
+```bash
+cargo test --features interop_e2e --test e2e interop
+```
+
+Those tests build `interop/java-peer` with Maven on first use. The standalone peer depends on `org.apache.eventmesh:eventmesh-sdk-java:1.12.0-release`; it does not compile or load the Java SDK source tree from this repository.
+
+The TCP reconnect test runs in the normal e2e suite. It uses a unique client subsystem and the Runtime admin API to disconnect only its own TCP sessions, so it does not restart or disrupt the shared Runtime container.
+
+Each test uses a unique topic and consumer group. gRPC and HTTP cases may run in parallel; TCP cases are serialized because Runtime route refresh and RocketMQ rebalance state are shared. The harness creates and warms topics through the admin API before publishing.
+
+The standalone in-memory broker requires a topic and subscription before the first publish and does not implement request/reply. Use a runtime profile with request/reply support for complete release verification. Topic creation uses form URL encoding at `POST /topic`.
+
+## Documentation responsibilities
+
+Keep each document in its intended layer.
+
+| Change | Update |
+| --- | --- |
+| Installation, feature choice, or common behavior | `README.md` |
+| Public type, method, feature-gated API, or behavior | rustdoc in `src/` |
+| Runnable workflow or transport use | the matching file in `examples/` and `examples/README.md` |
+| Validation, e2e, or contributor workflow | this file |
+| Protocol boundary or internal architecture | `ARCHITECTURE.md` |
+
+Public rustdoc should state feature requirements, ownership/lifecycle rules, and error or acknowledgement behavior where relevant. Prefer an executable doctest when it has no runtime dependency; otherwise mark the snippet `rust,ignore` and point users to a runnable example.
+
+## Code conventions
+
+- Add the Apache license header to every new `.rs` file.
+- Mirror the established consuming builder style for configuration additions.
+- Keep transport wire formats behind the public v2 API. Transports consume the public configuration types (`GrpcConfig`, `HttpConfig`, `TcpConfig`, role options) directly — do not reintroduce transport-private configuration adapters.
+
+Follow the additional protocol boundaries and internal constraints in [ARCHITECTURE.md](ARCHITECTURE.md).