[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,83 @@
+# 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.
+- Consumers and webhook servers invoke the public `MessageHandler` directly with `Message`. Transport-private helpers decode and encode that envelope; there is no separate listener trait or handler adapter with an associated message type.
+- Producers use concrete transport methods behind the public `GrpcProducer`, `HttpProducer`, and `TcpProducer` APIs. Message dialect selection remains in the public producer facade, while each transport owns its wire encoding and supported operations. There is no internal `Publisher` or `RequestReply` trait requiring unused or unsupported methods.
+- 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`.
+- Internal transport helpers and re-exports are gated by their consuming features; `common` and `model` have no module-wide unused-code exemptions. The shared Java wire-key and status/request-code catalogs retain documented `dead_code` exemptions on their constant-only implementations.
+
+## 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 |
+
+Native messages separate business data from delivery context:
+
+- `EventMeshMessage` owns topic, content, business/unique IDs, TTL, content type, and business properties.
+- `DeliveryContext` in `src/model/delivery.rs` owns received protocol descriptors and known identity/routing attributes. Its public API is read-only; only SDK decoders can attach it. Credentials are redacted in Debug output.
+- `decode_native_message` in `src/transport/mod.rs` separates wire attributes for every native decoder. HTTP form fields take precedence over duplicated IDs in `extFields`. Protocol-specific wire representations remain private.
+- Property builders and setters reject reserved names using the shared classification in `src/model/delivery.rs`. Encoders retain the same guard as defense in depth and never serialize a delivery context during normal publish, broadcast, or a new request.
+- TCP `RESPONSE_TO_SERVER` encoding restores known reply-routing attributes from the original request context, including Runtime `req0*`/`rsp0*`, cluster, and RocketMQ `correlation99id`/`reply99to99client`. The consumer attaches the original request context even if the handler returns a message received elsewhere. gRPC replies retain routing from their original protobuf request. ACK correlation continues to use the original wire frame.
+
+TTL has one business source: its dedicated field. HTTP/gRPC retain their 4000 ms outbound default; TCP leaves an unset TTL to the Runtime. Content type is also a dedicated field, encoded as a gRPC attribute, TCP message header, or HTTP `extFields` entry. Decoders reject malformed or out-of-i64-range TTL while preserving numeric values until outbound validation. CloudEvents keep their standard attributes/extensions; native-to-CloudEvents reply conversion maps the dedicated fields and reply context explicitly.
+
+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.
+
+## Consumer lifecycle waits
+
+Consumer lifecycle waits keep task ownership in `transport::task::BackgroundTask`. Waiting borrows the `JoinHandle`; completed results stay in the owner until the remaining cleanup has finished. Cancelling `join()` therefore preserves both unfinished tasks and pending failures for a later wait. Dropping the owner aborts any unfinished task.
+
+## gRPC stream subscription limitations
+
+Two known stream lifecycle limitations are retained without behavior changes in this SDK revision:
+
+- `spawn_stream_driver` ignores frames without `seqnum`, including subscription responses with a non-success `statuscode`. Runtime `SubscribeStreamProcessor` uses `ServiceUtils.sendResponseCompleted` for validation errors and `sendStreamResponseCompleted` for ACL errors, followed by normal stream completion. Consequently, `open()` and `join()` can both succeed for a rejected subscription. In the Java SDK, `EventMeshCloudEventBuilder.buildMessageFromEventMeshCloudEvent` treats an event with neither `seqnum` nor `uniqueid` as subscription-list content; `SubStreamHandler.onNext` logs a resulting `Set` without checking the response status. Its stream `subscribe` returns `void` and does not await acceptance.
+- `unsubscribe_stream_rpc` removes only the requested local topics. Runtime `ConsumerManager.deregisterClient` calls `closeEventStream` on the removed topic's emitter, which is shared by all topics on that subscription stream. The Rust driver treats EOF as terminal and cancels the heartbeat; it does not reconnect or replay remaining subscriptions. Java `EventMeshGrpcConsumer.unsubscribe` likewise retains the remaining topics, while `SubStreamHandler.onCompleted` only logs completion. Its `sender` is never reset, so subsequent subscriptions and heartbeat-triggered `resubscribe` reuse the closed stream. Java heartbeats can continue because Runtime `updateClientTime` checks client records, not emitter liveness.
+
+The relevant Java sources are under `eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/` and `eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/core/protocol/grpc/` in this repository. These observations come from source review; they do not establish live Java end-to-end coverage. Public usage constraints are documented in the README and `GrpcStreamConsumer` rustdoc.
+
+## 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_message`, and `WebhookReply`. `to_message` resolves the dialect from the HTTP headers and `extFields`; the built-in handler calls the same decoder. `WebhookHandler` and `WebhookState` in `src/transport/http/webhook.rs` are internal implementation details.
+
+The consumer owns the spawned server and heartbeat before awaiting registration, so dropping the startup future runs the same local cleanup as dropping an active consumer.
+
+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
+
+The consumer invokes each handler inside an asynchronous `catch_unwind` boundary covering both future construction and polling. An unwinding handler panic is logged with the delivery sequence, skips reply/ACK for that delivery, and keeps the receive loop running. The boundary does not restore application state. Explicit handler errors and reply encoding/enqueue failures still close the connection without ACK.
+
+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.
+
+Broadcasts use a driver completion channel to await `Framed::send`, including its socket flush, without waiting for a server ACK. Queue reservation and completion share one control-timeout deadline. A cancelled broadcast still waiting in the outbound queue is skipped; a write already in progress may have reached the server.

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