You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eventmesh.apache.org by ch...@apache.org on 2023/01/31 09:45:33 UTC
[incubator-eventmesh-site] branch master updated: update i18n docs
This is an automated email from the ASF dual-hosted git repository.
chenguangsheng pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-eventmesh-site.git
The following commit(s) were added to refs/heads/master by this push:
new 34db5d37 update i18n docs
34db5d37 is described below
commit 34db5d37bd160b5923eee58d0a1bcf42411449d0
Author: qqeasonchen <qq...@gmail.com>
AuthorDate: Tue Jan 31 17:45:10 2023 +0800
update i18n docs
---
.../current/contribute/02-write-unit-test.md | 59 +-
.../contribute/03-new-contributor-guidelines.md | 0
.../current/design-document/01-workflow.md | 145 ++--
.../current/design-document/02-runtime-protocol.md | 403 ++++++------
.../current/design-document/03-stream.md | 129 ++--
.../current/design-document/04-schema-registry.md | 134 ----
.../current/design-document/05-metrics-export.md | 48 +-
.../current/design-document/06-cloudevents.md | 134 ++--
.../current/design-document/07-tracing.md | 87 ---
.../current/design-document/08-spi.md | 56 +-
.../current/design-document}/09-event-bridge.md | 0
.../design-document}/10-knative-connector.md | 0
.../current/design-document}/11-prometheus.md | 0
.../current/design-document}/12-zipkin.md | 0
.../current/design-document}/13-jaeger.md | 0
.../current/design-document/14-webhook.md | 0
.../current/design-document/15-https.md | 0
.../current/design-document/_category_.json | 3 +-
.../current/installation/01-runtime.md | 90 ---
.../current/installation/02-runtime-with-docker.md | 107 ---
.../current/installation/03-store.md | 5 -
.../current/installation/_category_.json | 5 -
.../current}/instruction/00-eclipse.md | 0
.../current}/instruction/01-store-with-docker.md | 0
.../current}/instruction/01-store.md | 0
.../current}/instruction/02-runtime-with-docker.md | 0
.../current}/instruction/02-runtime.md | 0
.../current}/instruction/03-demo.md | 0
.../current}/instruction/_category_.json | 0
.../current/introduction.md | 69 +-
.../current/metrics-tracing/01-prometheus.md | 24 -
.../current/metrics-tracing/02-zipkin.md | 38 --
.../current/metrics-tracing/_category_.json | 5 -
.../current/roadmap.md | 58 +-
.../current}/sdk-java/01-intro.md | 0
.../current/sdk-java/02-http.md | 38 +-
.../current/sdk-java/03-tcp.md | 22 +-
.../current/sdk-java/04-grpc.md | 32 +-
.../current/sdk-java/_category_.json | 1 -
zh/docs/contribute/01-release.md | 731 ---------------------
zh/docs/contribute/02-write-unit-test.md | 78 ---
zh/docs/contribute/_category_.json | 5 -
zh/docs/desing-document/01-workflow.md | 258 --------
zh/docs/desing-document/02-runtime-protocol.md | 420 ------------
zh/docs/desing-document/03-stream.md | 115 ----
zh/docs/desing-document/05-metrics-export.md | 47 --
zh/docs/desing-document/06-cloudevents.md | 102 ---
zh/docs/desing-document/08-spi.md | 111 ----
zh/docs/desing-document/_category_.json | 4 -
zh/docs/introduction.md | 49 --
zh/docs/roadmap.md | 47 --
zh/docs/sdk-java/02-http.md | 118 ----
zh/docs/sdk-java/03-tcp.md | 118 ----
zh/docs/sdk-java/04-grpc.md | 174 -----
zh/docs/sdk-java/_category_.json | 4 -
55 files changed, 625 insertions(+), 3448 deletions(-)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/contribute/02-write-unit-test.md b/i18n/zh/docusaurus-plugin-content-docs/current/contribute/02-write-unit-test.md
index 0c48e46b..055cdce3 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/contribute/02-write-unit-test.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/contribute/02-write-unit-test.md
@@ -1,40 +1,41 @@
-# Unit Test Requirement
+# 单元测试要求
-- Each unit test case should use assertions instead of `System.out` output or `if` statement
-- Each unit test case shouldn't call other cases or depend on the order of execution.
-- Each unit test case should be repeatable and not depend on the external environment because the test might be executed in the continuous integration.
-- The scope of each unit test should be small enough to help locate the problem at the method level.
+- 每个单元测试都应该使用断言`assertions` 而不是 `System.out` 打印或者`if`语句
+- 每个单元测试都不应该调用其他用例，或者依赖于执行顺序
+- 每个单元测试都应该是可以循环执行的，并且单元测试不可以依赖外部环境，因为单元测试可能在持续集成环境中运行。
+- 每个单元测试的测试范围应该足够小且精准，以便于定位方法级别的问题。
-## Location and Naming Rules
+## 路径和命名规则
-- The unit test should be placed in `src/test/java`.
-- The unit test configuration file should be placed in `src/test/resources`. For example:
- - Class to be tested: `src/main/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBody.java`
- - Unit test: `src/test/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBodyTest.java`
- - Unit test configuration: `src/test/resources/configuration.properties`
-- The package name of the unit test class should be identical to the class to be tested.
-- The name of the unit test class should be `{class or interface to be tested}Test`. For example:
- - Class to be tested: `EventMeshUtil`
- - Unit test class: `EventMeshUtilTest`
-- The name of each test case should be `test{method name}`. For example:
- - Method to be tested: `addProp(String key, String val)`
- - Unit test case: `testAddProp`
+- 单元测试应该写在`src/test/java`目录下。
+- 单元测试的配置文件应该放在`src/test/resources`目录下，如下示例：
+ - 将被测试的类：`src/main/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBody.java`
+ - 单元测试类：`src/test/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBodyTest.java`
+ - 单元测试配置文件：`src/test/resources/configuration.properties`
+- 单元测试类的包名应该和被测试的类的包名相同
+- 单元测试的类的名字应该是`{被测试的类名+}Test`。 比如：
+ - 将被测试的类是：`EventMeshUtil`
+ - 单元测试类的类名就是： `EventMeshUtilTest`
+- 每个单元测试的名字必须是 `test{+方法名}`，比如：
+ - 将被测试的方法：`addProp(String key, String val)`
+ - 单元测试的名字就是：`testAddProp`
-## Assertion Usage
+## 断言的用法
-### Common Assertion
+
+### 常见的断言
| Methods | Instructions |
| :-------------- | :-------------- |
-| `assertEquals` | Determines whether two objects or primitive types are equal |
-| `assertNotEquals` | Determines whether two objects or primitive types are not equal |
-| `assertTrue` | Determines whether the given Boolean value is `true` |
-| `assertFalse` | Determines whether the given Boolean value is `false` |
-| `assertNull` | Determines whether the given object reference is `null` |
-| `assertNotNull` | Determines whether the given object reference is not `null` |
-| `assertAll` | When multiple decision logic are processed together if only one error is reported, the whole test will fail |
-
-### Example
+| `assertEquals` | 确定两个对象或原语类型是否相等 |
+| `assertNotEquals` | 确定两个对象或原语类型是否不相等 |
+| `assertTrue` | 确定给定的布尔值是否是 `true` |
+| `assertFalse` | 确定给定的布尔值是否是 `false` |
+| `assertNull` | 确定给定的对象是否是 `null` |
+| `assertNotNull` | 确定给定的对象是否不是 `null` |
+| `assertAll` | 如果同时处理多个逻辑，如果只有一个逻辑断言失败，整个测试将会失败|
+
+### 示例
#### `assertEquals()`
diff --git a/zh/docs/contribute/03-new-contributor-guidelines.md b/i18n/zh/docusaurus-plugin-content-docs/current/contribute/03-new-contributor-guidelines.md
similarity index 100%
rename from zh/docs/contribute/03-new-contributor-guidelines.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/contribute/03-new-contributor-guidelines.md
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/01-workflow.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/01-workflow.md
index 43589178..444c0945 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/01-workflow.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/01-workflow.md
@@ -1,49 +1,46 @@
-# EventMesh Workflow
+# EventMesh工作流
-## Business Problem
+## 业务场景
-Imaging you are building a simple Order Management System for an E-Commerce Store. The system should be able to receive and provision new orders from a store website. The provisioning process should be able to process all orders, handle payments, as well as process shipments.
+图中你正在构建一个简单的电商订单管理系统，系统能够接收和调配新的订单，调配流程需要处理所有的订单创建，付款处理以及发货处理。
-For high availability and high performance, you architect the system using event-driven architecture (EDA), and build microservice apps to handle store frontend, order management, payment processing, and shipment management. You deploy the whole system in a cloud environment. To handle high workloads, you leverage a messaging system to buffer the loads, and scale up multiple instances of microservices. The architecture could look similar to:
+为了实现高可用和高性能，你可以使用事件驱动架构（EDA）构建微服务应用去处理商店前端，订单管理，支付处理和发货管理。你可以在云上部署整个系统。要处理高并发，你可以利用消息系统缓冲，并扩展多个微服务实例。架构类似于：
-
+
-While each microservice is acting on its own event channels, EventMesh plays a crucial role of doing Event Orchestration.
+当每个微服务都在自己的事件通道上运行时，EventMesh在执行事件编排方面发挥着至关重要的作用。
-We use [CNCF Serverless Workflow](https://serverlessworkflow.io/) to describe this Event Workflow Orchestration.
+我们使用 [CNCF Serverless工作流](https://serverlessworkflow.io/) 来描述此事件工作流编排。
-## CNCF Serverless Workflow
+## CNCF Serverless工作流
-CNCF Serverless Workflow defines a vendor-neutral, open-source, and fully community-driven ecosystem for defining and running DSL-based workflows that target the Serverless technology domain.
+CNCF Serverless工作流定义了一个厂商中立、开源和完全社区驱动的生态系统，用于定义和运行针对Serverless技术领域的基于DSL的工作流。
-Serverless Workflow defines a Domain Specific Language (DSL) to describe stateful and stateless workflow-based orchestrations of serverless functions and microservices.
+Serverless工作流定义了一种领域特定语言（DSL）来描述有状态和无状态的基于工作流的serverless函数和微服务编排。
-More details could be found in its [official github site](https://github.com/serverlessworkflow/specification)
+详见[官方github](https://github.com/serverlessworkflow/specification)
-## EventMesh Workflow
+## EventMesh工作流
-We leverage Serverless Workflow DSL to describe the EventMesh workflow. Based on its spec, the workflow is consists of a series of workflow states used to describe the control-flow logic. At this time we only support event related workflow states. See the supported states in [Workflow DSL Design](#workflow-dsl-design-wip).
+我们利用Serverless工作流DSL来描述EventMesh工作流。根据其规范，工作流由一系列用于描述控制流逻辑的工作流状态组成。目前，我们仅支持与事件相关的工作流状态。请参见[工作流DSL设计](#workflow-dsl-design-wip)中支持的状态。
-A `workflow state` can include applicable `actions`, or services/functions that should be invoked during workflow execution. These `actions` can reference reusable `function` definitions which define how these functions/services should be invoked. They can also reference events that trigger event-based service invocations, and events to wait for that denote completion of such event-based service invocation completion.
+`工作流状态`可以包含通用的`操作`，或在工作流执行期间应调用的服务/函数。这些`操作`可以引用可复用的`函数`定义（应如何调用这些函数/服务），还可以引用触发基于事件的服务调用的事件，以及要等待的事件，这些事件表示这种基于事件的服务调用完成。
-In EDA solution, we usually defined our event-driven microservice using AsyncAPI. Serverless workflow `function` definitions support defining invocation semantics using AsyncAPI. See [Using Funtions for AsyncAPI Service](https://github.com/serverlessworkflow/specification/blob/main/specification.md#using-functions-for-async-api-service-invocations) for more information.
+在EDA解决方案中，我们通常使用AsyncAPI定义事件驱动的微服务。Serverless工作流“函数”定义支持使用AsyncAPI定义调用语义。有关详细信息，请参见[Using Funtions for AsyncAPI Service](https://github.com/serverlessworkflow/specification/blob/main/specification.md#using-functions-for-async-api-service-invocations)。
### AsyncAPI
-AsyncAPI is an open source initiative that seeks to improve the current state of Event-Driven Architectures (EDA).
-Our long-term goal is to make working with EDAs as easy as it is to work with REST APIs.
-That goes from documentation to code generation, discovery to event management.
-Most of the processes you apply to your REST APIs nowadays would be applicable to your event-driven/asynchronous APIs too.
+AsyncAPI是一项开源计划，旨在改善事件驱动体系结构（EDA）的当前状态。我们的长期目标是让使用EDA和使用REST API一样容易。包括从文档到代码生成、发现到事件管理。现在应用于REST API的大多数流程也适用于事件驱动/异步API。
-See AsyncAPI detail in the [official site](https://www.asyncapi.com/docs/getting-started)
+详见[AsyncAPI官网](https://www.asyncapi.com/docs/getting-started)
-### Workflow Example
+### 工作流示例
-In this example, we build the event-driven workflow of the Order management system above.
+在本示例中，我们构建了上面订单管理系统的事件驱动工作流。
-First, we need to define AsyncAPI definitions for our microservice apps.
+首先，我们需要为我们的微服务应用定义AsyncAPI。
-- Online Store App
+- 在线商店应用程序
```yaml
asyncapi: 2.2.0
@@ -59,7 +56,7 @@ channels:
```
-- Order Service
+- 订单服务
```yaml
asyncapi: 2.2.0
@@ -79,7 +76,7 @@ channels:
$ref : '#/components/Order'
```
-- Payment Service
+- 支付服务
```yaml
asyncapi: 2.2.0
@@ -99,7 +96,7 @@ channels:
$ref : '#/components/OrderPayment'
```
-- Shipment Service
+- 物流服务
```yaml
asyncapi: 2.2.0
@@ -114,7 +111,7 @@ channels:
$ref : '#/components/OrderShipment'
```
-Once that is defined, we define the order workflow that describes our Order Management business logic.
+接下来，定义描述订单管理业务逻辑的订单工作流。
```yaml
id: storeorderworkflow
@@ -179,83 +176,83 @@ events:
kind: produced
```
-The corresponding workflow diagram is the following:
+对应的工作流图如下：
-
+
-## EventMesh Workflow Engine
+## EventMesh工作流引擎
-In the following architecture diagram, the EventMesh Catalog, EventMesh Workflow Engine and EventMesh Runtime are running in three different processors.
+在下面的体系结构图中, EventMesh目录, EventMesh工作流引擎 和 EventMesh Runtime在三个不同的处理器中运行。
-
+
-The steps running the workflow is the followings:
+运行工作流的步骤如下：
-1. Deploy the Publisher and Subscriber Apps in the environment.
- Describe the App APIs using AsyncAPI, generate the asyncAPI yaml.
- Register the Publisher and Subscriber Apps in EventMesh Catalog using AsyncAPI.
+1. 在环境中部署发布者和订阅者应用程序。
+ 使用AsyncAPI描述应用程序API，生成asyncAPI yaml。
+ 使用AsyncAPI在EventMesh目录中注册发布者和订阅者应用程序。
-2. Register the Serverless Workflow DSL in EventMesh Workflow Engine.
+2. 在EventMesh工作流引擎中注册Serverless工作流DSL。
-3. EventMesh Workflow Engine query the EventMesh Catalog for Publisher and Subscribers required in Workflow DSL `function`
+3. 工作流引擎从EventMesh目录查询发布服务器和订阅服务器的需要的工作流DSL`函数`。
-4. Event-driven Apps are publish events to EventMesh Runtime to trigger the Workflow. EventMesh Workflow Engine also publish and subscribe events for orchestrating the events.
+4. 事件驱动App将事件发布到EventMesh Runtime触发工作流。EventMesh工作流引擎发布和订阅事件、编排事件。
-### EventMesh Catalog Design
+### EventMesh Catalog 设计
-EventMesh Catalog store the Publisher, Subscriber and Channel metadata. consists of the following modules:
+EventMesh目录存储发布者、订阅者和通道元数据。由以下模块组成：
-- AsyncAPI Parser
+- AsyncAPI解析器
- Using the SDK provided by AsyncAPI community (see [tool list](https://www.asyncapi.com/docs/community/tooling)),
- parse and validated the AsyncAPI yaml inputs, and generate the AsyncAPI definition.
+ 使用AsyncAPI社区提供的SDK ([tool list](https://www.asyncapi.com/docs/community/tooling)),
+ 解析并验证AsyncAPI yaml输入，并生成AsyncAPI定义。
-- Publisher, Channel, Subscriber Modules
+- 发布者, 通道, 订阅者模块
- From the AsyncAPI definition store the Publisher, Subscriber and Channel information.
+ 从AsyncAPI定义存储发布者、订阅者和通道信息。
-### EventMesh Workflow Engine Design
+### EventMesh工作流引擎设计
-EventMesh Workflow Engine consists of the following modules:
+工作流引擎由以下模块组成：
-- Workflow Parser
+- 工作流解析器
- Using the SDK provided by Serverless Workflow community (see supported [SDKs](https://github.com/serverlessworkflow/specification#sdks)),
- parse and validated the workflow DSL inputs, and generate workflow definition.
+ 使用Serverless Workflow社区提供的SDK([SDKs](https://github.com/serverlessworkflow/specification#sdks)),
+ 解析和验证工作流DSL输入，并生成工作流定义。
-- Workflow Module
+- 工作流模块
- It manages a workflow instance life cycle, from create, start, stop to destroy.
+ 管理工作流实例的生命周期，从创建、启动、停止到销毁。
-- State Module
+- 状态模块
- It manages workflow state life cycle. We support the event-related states, and the supported state list below is Work-in-Progress.
+ 管理工作流状态生命周期。支持与事件相关的状态，and the supported state list below is Work-in-Progress.
- | Workflow State | Description |
+ | 工作流状态 | 描述 |
| --- | --- |
- | Operation | Execute the AsyncAPI functions defined in the Actions |
- | Event | Check if the defined Event matched, if so execute the defined AsyncAPI functions |
- | Switch | Check the event is matched with the event-conditions, and execute teh defined AsyncAPI functions |
- | Parallel | Execute the defined AsyncAPI functions in parallel |
- | ForEach | Iterate the inputCollection and execute the defined AsyncAPI functions |
+ | Operation | 执行Actions中定义的AsyncAPI函数 |
+ | Event | 检查定义的事件是否匹配，如果匹配，执行定义的AsyncAPI函数 |
+ | Switch | 检查事件是否与事件条件匹配，并执行定义的AsyncAPI函数 |
+ | Parallel | 并行执行定义的AsyncAPI函数 |
+ | ForEach | 迭代输入集合并执行定义的AsyncAPI函数 |
-- Action Module
+- 行为模块
- It managed the functions inside the action.
+ 管理函数中的行为。
-- Function Module
+- 函数模块
- It manages the AsyncAPI functions by creating the publisher and/or subscriber in EventMesh Runtime, and manage the publisher/subscriber life cycle.
+ 通过在EventMesh Runtime中创建发布者和/或订阅者来管理AsyncAPI函数，并管理发布者/订阅者生命周期。
- | AsyncAPI Operation | EventMesh Runtime |
- | --- | --- |
- | Publish | Publisher |
- | Subscribe | Subscriber |
+ | AsyncAPI 操作 | EventMesh Runtime |
+ | --- | --- |
+ | Publish | Publisher |
+ | Subscribe | Subscriber |
-- Event Module
+- 事件模块
- It manages the CloudEvents data model, including event filter, correlation and transformation using the rules defined in the workflow DSL.
+ 使用工作流DSL中定义的规则管理CloudEvent数据模型，包括事件过滤器、关联和转换。
-- Retry Module
+- 重试模块
- It manages the retry logic of the event publishing into EventMesh Runtime.
+ 管理事件发布到EventMesh Runtime的重试逻辑。
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/02-runtime-protocol.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/02-runtime-protocol.md
index 165528b2..d5f15560 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/02-runtime-protocol.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/02-runtime-protocol.md
@@ -1,151 +1,164 @@
-# EventMesh Runtime Protocol
+# TCP协议文档
-## TCP Protocol
+#### 1. 协议格式
-### Protocol Format
+
-|Name|Size|Description|
-|-|-|-|
-|Magic Code|9 bytes|Default: `EventMesh`|
-|Protocol Version|4 bytes|Default: `0000`|
-|Message Size|4 bytes|The total length of the message|
-|Header Size|4 bytes|The length of the message header|
-|Message Body||The content of the message|
+**消息组成详解：**
-### Message Object in the Business Logic Layer
+```
+魔术字：9位，当前值为“EventMesh”
+
+通信协议版本号：4位，当前值为“0000”
+
+消息总长度值(length)：4位，int类型
+
+消息头长度值(headerLength)：4位，int类型
+
+消息头(header)：长度 = headerLength
+
+消息体(body)：长度 = length - headerLength - 4 - 4
+```
+
+#### 2. 业务逻辑层
-#### Message Composition
++ 消息组成
-The `Package` class in the [`Package.java` file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/tcp/Package.java) is the TCP message object used in business logic layer. The class contains the `header` and `body` fields.
+消息头（header）+ 消息体（body）
```java
public class Package {
- private Header header;
- private Object body;
+
+ private Header header;
+ private Object body;
}
+
public class Header {
- private Command cmd;
- private int code;
- private String msg;
- private String seq;
+
+ private Command cmd;
+ private int code;
+ private String msg;
+ private String seq;
}
```
-#### Specification
++ 详解
+
+消息头(header)：类型为Header，Header中有Command字段，用于区分不同的消息类型
-- Message Header (the `header` field): The `cmd` field in the `Header` class specifies the different types of messages.
-- Message Body (the `body` field): The type of the message body should be defined based on `cmd` field in the `Header` class.
+消息体(body)：对于不同的消息类型，body的类型不同
-|Command|Type of Body|
-|-|-|
-| HEARTBEAT_REQUEST, HEARTBEAT_RESPONSE, HELLO_RESPONSE, CLIENT_GOODBYE_REQUEST, CLIENT_GOODBYE_RESPONSE, SERVER_GOODBYE_REQUEST, SERVER_GOODBYE_RESPONSE, LISTEN_REQUEST, LISTEN_RESPONSE, UNSUBSCRIBE_REQUEST, SUBSCRIBE_RESPONSE, UNSUBSCRIBE_RESPONSE, ASYNC_MESSAGE_TO_SERVER_ACK, BROADCAST_MESSAGE_TO_SERVER_ACK|N/A|
-|HELLO_REQUEST|UserAgent|
-|SUBSCRIBE_REQUEST|Subscription|
-| REQUEST_TO_SERVER, REQUEST_TO_CLIENT, RESPONSE_TO_SERVER, RESPONSE_TO_CLIENT, ASYNC_MESSAGE_TO_SERVER, ASYNC_MESSAGE_TO_CLIENT, BROADCAST_MESSAGE_TO_SERVER, BROADCAST_MESSAGE_TO_CLIENT, ASYNC_MESSAGE_TO_CLIENT_ACK, BROADCAST_MESSAGE_TO_CLIENT_ACK, RESPONSE_TO_CLIENT_ACK, REQUEST_TO_CLIENT_ACK|OpenMessage|
-|REDIRECT_TO_CLIENT|RedirectInfo|
+| 消息命令字 | body类型 |
+| ------------------------------------------------------------ | ------------ |
+| HEARTBEAT_REQUEST, HEARTBEAT_RESPONSE, HELLO_RESPONSE, CLIENT_GOODBYE_REQUEST, CLIENT_GOODBYE_RESPONSE, SERVER_GOODBYE_REQUEST, SERVER_GOODBYE_RESPONSE, LISTEN_REQUEST, LISTEN_RESPONSE, UNSUBSCRIBE_REQUEST, SUBSCRIBE_RESPONSE, UNSUBSCRIBE_RESPONSE, ASYNC_MESSAGE_TO_SERVER_ACK, BROADCAST_MESSAGE_TO_SERVER_ACK | 无 |
+| HELLO_REQUEST | UserAgent |
+| SUBSCRIBE_REQUEST | Subscription |
+| REQUEST_TO_SERVER, REQUEST_TO_CLIENT, RESPONSE_TO_SERVER, RESPONSE_TO_CLIENT, ASYNC_MESSAGE_TO_SERVER, ASYNC_MESSAGE_TO_CLIENT, BROADCAST_MESSAGE_TO_SERVER, BROADCAST_MESSAGE_TO_CLIENT, ASYNC_MESSAGE_TO_CLIENT_ACK, BROADCAST_MESSAGE_TO_CLIENT_ACK, RESPONSE_TO_CLIENT_ACK, REQUEST_TO_CLIENT_ACK | OpenMessage |
+| REDIRECT_TO_CLIENT | RedirectInfo |
-### Example of Client-Server Interaction
+#### 3. Client 与 Eventmesh-Runtime(Server)交互场景详解
```java
public enum Command {
- // Heartbeat
- HEARTBEAT_REQUEST(0), // Client send heartbeat request to server
- HEARTBEAT_RESPONSE(1), // Server reply heartbeat response to client
-
- // Hello
- HELLO_REQUEST(2), // Client send connect request to server
- HELLO_RESPONSE(3), // Server reply connect response to client
-
- // Disconncet
- CLIENT_GOODBYE_REQUEST(4), // Client send disconnect request to server
- CLIENT_GOODBYE_RESPONSE(5), // Server reply disconnect response to client
- SERVER_GOODBYE_REQUEST(6), // Server send disconncet request to client
- SERVER_GOODBYE_RESPONSE(7), // Client reply disconnect response to server
-
- // Subscribe and UnSubscribe
- SUBSCRIBE_REQUEST(8), // Slient send subscribe request to server
- SUBSCRIBE_RESPONSE(9), // Server reply subscribe response to client
- UNSUBSCRIBE_REQUEST(10), // Client send unsubscribe request to server
- UNSUBSCRIBE_RESPONSE(11), // Server reply unsubscribe response to client
-
- // Listen
- LISTEN_REQUEST(12), // Client send listen request to server
- LISTEN_RESPONSE(13), // Server reply listen response to client
-
- // Send sync message
- REQUEST_TO_SERVER(14), // Client (Producer) send sync message to server
- REQUEST_TO_CLIENT(15), // Server push sync message to client(Consumer)
- REQUEST_TO_CLIENT_ACK(16), // Client (Consumer) send ack of sync message to server
- RESPONSE_TO_SERVER(17), // Client (Consumer) send reply message to server
- RESPONSE_TO_CLIENT(18), // Server push reply message to client(Producer)
- RESPONSE_TO_CLIENT_ACK(19), // Client (Producer) send acknowledgement of reply message to server
-
- // Send async message
- ASYNC_MESSAGE_TO_SERVER(20), // Client send async msg to server
- ASYNC_MESSAGE_TO_SERVER_ACK(21), // Server reply ack of async msg to client
- ASYNC_MESSAGE_TO_CLIENT(22), // Server push async msg to client
- ASYNC_MESSAGE_TO_CLIENT_ACK(23), // Client reply ack of async msg to server
-
- // Send broadcast message
- BROADCAST_MESSAGE_TO_SERVER(24), // Client send broadcast msg to server
- BROADCAST_MESSAGE_TO_SERVER_ACK(25), // Server reply ack of broadcast msg to client
- BROADCAST_MESSAGE_TO_CLIENT(26), // Server push broadcast msg to client
- BROADCAST_MESSAGE_TO_CLIENT_ACK(27), // Client reply ack of broadcast msg to server
-
- // Redirect
- REDIRECT_TO_CLIENT(30), // Server send redirect instruction to client
+
+ //心跳
+ HEARTBEAT_REQUEST(0), //client发给server的心跳包
+ HEARTBEAT_RESPONSE(1), //server回复client的心跳包
+
+ //握手
+ HELLO_REQUEST(2), //client发给server的握手请求
+ HELLO_RESPONSE(3), //server回复client的握手请求
+
+ //断连
+ CLIENT_GOODBYE_REQUEST(4), //client主动断连时通知server
+ CLIENT_GOODBYE_RESPONSE(5), //server回复client的主动断连通知
+ SERVER_GOODBYE_REQUEST(6), //server主动断连时通知client
+ SERVER_GOODBYE_RESPONSE(7), //client回复server的主动断连通知
+
+ //订阅管理
+ SUBSCRIBE_REQUEST(8), //client发给server的订阅请求
+ SUBSCRIBE_RESPONSE(9), //server回复client的订阅请求
+ UNSUBSCRIBE_REQUEST(10), //client发给server的取消订阅请求
+ UNSUBSCRIBE_RESPONSE(11), //server回复client的取消订阅请求
+
+ //监听
+ LISTEN_REQUEST(12), //client发给server的启动监听请求
+ LISTEN_RESPONSE(13), //server回复client的监听请求
+
+ //RR
+ REQUEST_TO_SERVER(14), //client将RR请求发送给server
+ REQUEST_TO_CLIENT(15), //server将RR请求推送给client
+ REQUEST_TO_CLIENT_ACK(16), //client收到RR请求后ACK给server
+ RESPONSE_TO_SERVER(17), //client将RR回包发送给server
+ RESPONSE_TO_CLIENT(18), //server将RR回包推送给client
+ RESPONSE_TO_CLIENT_ACK(19), //client收到回包后ACK给server
+
+ //异步事件
+ ASYNC_MESSAGE_TO_SERVER(20), //client将异步事件发送给server
+ ASYNC_MESSAGE_TO_SERVER_ACK(21), //server收到异步事件后ACK给client
+ ASYNC_MESSAGE_TO_CLIENT(22), //server将异步事件推送给client
+ ASYNC_MESSAGE_TO_CLIENT_ACK(23), //client收到异步事件后ACK给server
+
+ //广播
+ BROADCAST_MESSAGE_TO_SERVER(24), //client将广播消息发送给server
+ BROADCAST_MESSAGE_TO_SERVER_ACK(25), //server收到广播消息后ACK给client
+ BROADCAST_MESSAGE_TO_CLIENT(26), //server将广播消息推送给client
+ BROADCAST_MESSAGE_TO_CLIENT_ACK(27), //client收到广播消息后ACK给server
+
+ //重定向指令
+ REDIRECT_TO_CLIENT(30), //server将重定向指令推动给client
}
```
-### Client-Initiated Interaction
-
-|Scene|Client Request|Server Response|
-|-|-|-|
-| Hello | HELLO_REQUEST | HELLO_RESPONSE | |
-| Heartbeat | HEARTBEAT_REQUEST | HEARTBEAT_RESPONSE | |
-| Subscribe | SUBSCRIBE_REQUEST | SUBSCRIBE_RESPONSE | |
-| Unsubscribe | UNSUBSCRIBE_REQUEST | UNSUBSCRIBE_RESPONSE | |
-| Listen | LISTEN_REQUEST | LISTEN_RESPONSE | |
-| Send sync message | REQUEST_TO_SERVER | RESPONSE_TO_CLIENT | |
-| Send the response of sync message| RESPONSE_TO_SERVER | N/A | |
-| Send async message | ASYNC_MESSAGE_TO_SERVER | ASYNC_MESSAGE_TO_SERVER_ACK | |
-| Send broadcast message | BROADCAST_MESSAGE_TO_SERVER | BROADCAST_MESSAGE_TO_SERVER_ACK | |
-| Client start to disconnect | CLIENT_GOODBYE_REQUEST | CLIENT_GOODBYE_RESPONSE | |
+#### 4. Client发起交互
-### Server-Initiated Interaction
+| 场景 | Client向Server发送消息命令字 | Server回复Client消息的命令字 | 说明 |
+| -------------- | ---------------------------- | ------------------------------- | ---- |
+| 握手 | HELLO_REQUEST | HELLO_RESPONSE | |
+| 心跳 | HEARTBEAT_REQUEST | HEARTBEAT_RESPONSE | |
+| 订阅 | SUBSCRIBE_REQUEST | SUBSCRIBE_RESPONSE | |
+| 取消订阅 | UNSUBSCRIBE_REQUEST | UNSUBSCRIBE_RESPONSE | |
+| 开始监听消息 | LISTEN_REQUEST | LISTEN_RESPONSE | |
+| 发送RR请求 | REQUEST_TO_SERVER | RESPONSE_TO_CLIENT | |
+| 发送RR回包 | RESPONSE_TO_SERVER | 无 | |
+| 发送异步事件 | ASYNC_MESSAGE_TO_SERVER | ASYNC_MESSAGE_TO_SERVER_ACK | |
+| 发送广播事件 | BROADCAST_MESSAGE_TO_SERVER | BROADCAST_MESSAGE_TO_SERVER_ACK | |
+| 客户端主动断连 | CLIENT_GOODBYE_REQUEST | CLIENT_GOODBYE_RESPONSE | |
-|Scene|Server Request|Client Response|Remark|
-|-|-| ------------------------------- | ---- |
-| Push sync message to client | REQUEST_TO_CLIENT | REQUEST_TO_CLIENT_ACK | |
-| Push the response message of sync message to client | RESPONSE_TO_CLIENT | RESPONSE_TO_CLIENT_ACK | |
-| Push async message to client | ASYNC_MESSAGE_TO_CLIENT | ASYNC_MESSAGE_TO_CLIENT_ACK | |
-| Push broadcast message to client | BROADCAST_MESSAGE_TO_CLIENT | BROADCAST_MESSAGE_TO_CLIENT_ACK | |
-| Server start to disconnect | SERVER_GOODBYE_REQUEST | -- | |
-| Server send redirect | REDIRECT_TO_CLIENT | -- | |
+#### 5. Server发起交互
-### Type of Message
+| 场景 | Server向Client发送消息命令字 | Client回复Server消息命令字 | 说明 |
+| ------------------ | ---------------------------- | ------------------------------- | ---- |
+| 客户端接收RR请求 | REQUEST_TO_CLIENT | REQUEST_TO_CLIENT_ACK | |
+| 客户端接收RR回包 | RESPONSE_TO_CLIENT | RESPONSE_TO_CLIENT_ACK | |
+| 客户端接收异步事件 | ASYNC_MESSAGE_TO_CLIENT | ASYNC_MESSAGE_TO_CLIENT_ACK | |
+| 客户端接收广播事件 | BROADCAST_MESSAGE_TO_CLIENT | BROADCAST_MESSAGE_TO_CLIENT_ACK | |
+| 服务端主动断连 | SERVER_GOODBYE_REQUEST | 无 | |
+| 服务端进行重定向 | REDIRECT_TO_CLIENT | 无 | |
+| | | | |
-#### Sync Message
+#### 6. 消息类型
-
++ 发送RR消息
-#### Async Message
+
-
++ 发送异步单播消息
-#### Boardcast Message
+
-
++ 发送广播消息
-## HTTP Protocol
+
-### Protocol Format
+## HTTP协议文档
-The `EventMeshMessage` class in the [`EventMeshMessage.java` file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-common/src/main/java/org/apache/eventmesh/common/EventMeshMessage.java) is the HTTP message definition of EventMesh Runtime.
+Java类`LiteMessage`的`content`字段表示一个特殊的协议，因此，如果您要使用eventmesh-sdk-java的http-client，则只需设计协议的`content`即可。`LiteMessage`组成如下：
```java
-public class EventMeshMessage {
+public class LiteMessage {
+
private String bizSeqNo;
private String uniqueId;
@@ -156,105 +169,111 @@ public class EventMeshMessage {
private Map<String, String> prop;
- private final long createTime = System.currentTimeMillis();
+ private long createTime = System.currentTimeMillis();
}
```
-### HTTP Post Request
+#### 1. 消息发送方式与组成
-#### Heartbeat Message
+**消息发送方式**：POST方式
-##### Request Header
+**消息组成**：请求头(RequestHeader) + 请求体(RequestBody)
-| Key | Description |
++ 心跳消息
+
+**RequestHeader**
+
+| Key | 说明 |
| -------- | ---------------- |
-| Env | Enviroment of Client |
-| Region | Region of Client |
-| Idc | IDC of Client |
-| Dcn | DCN of Client |
-| Sys | Subsystem ID of Client |
-| Pid | Client Process ID |
-| Ip | Client Ip |
-| Username | Client username |
-| Passwd | Client password |
-| Version | Protocol version |
-| Language | Develop language |
-| Code | Request Code |
+| Env | client所属环境 |
+| Region | client所属区域 |
+| Idc | client所属IDC |
+| Dcn | client所在DCN |
+| Sys | client所属子系统 |
+| Pid | client进程号 |
+| Ip | client Ip |
+| Username | client 用户名 |
+| Passwd | client 密码 |
+| Version | 协议版本 |
+| Language | 语言描述 |
+| Code | 请求码 |
+
+**RequestBody**
-##### Request Body
+| Key | 说明 |
+| ----------------- | ------------------------------ |
+| clientType | 客户端类型 |
+| heartbeatEntities | 心跳实体，包含topic、url等信息 |
-|Key|Description|
-|-|-|
-|`clientType`|`ClientType.PUB` for Producer, `ClientType.SUB` for Consumer|
-|`heartbeatEntities`|Topic, URL, etc.|
++ 订阅消息：
-#### Subscribe Message
+**RequestHeader**
-##### Request Header
+与心跳消息一致
-The request header of the Subscribe message is identical to the request header of the Heartbeat message.
+**RequestBody**
-##### Request Body
+| Key | 说明 |
+| ----- | ----------------- |
+| topic | 客户端订阅的topic |
+| url | topic对应的url |
-|Key|Description|
-|-|-|
-|`topic`|The topic that the client requested to subscribe to|
-|`url`|The callback URL of the client|
++ 取消订阅消息：
-#### Unsubscribe Message
+**RequestHeader**
-##### Request Header
+与心跳消息一致
-The request header of the Unsubscribe message is identical to the request header of the Heartbeat message.
+**RequestBody**
-##### Request Body
+与订阅消息一致
-The request body of the Unsubscribe message is identical to the request body of the Subscribe message.
++ 发送异步事件：
-#### Send Async Message
+**RequestHeader**
-##### Request Header
+与心跳消息一致
-The request header of the Send Async message is identical to the request header of the Heartbeat message.
+**RequestBody**
-##### Request Body
+| Key | 说明 |
+| -------- | ----------------------- |
+| topic | 客户端请求的topic |
+| content | 客户端发送的topic的内容 |
+| ttl | 客户端请求超时时间 |
+| bizSeqNo | 客户端请求业务流水号 |
+| uniqueId | 客户端请求消息唯一标识 |
-|Key|Description|
-|-|-|
-|`topic`|Topic of the message|
-|`content`|The content of the message|
-|`ttl`|The time-to-live of the message|
-|`bizSeqNo`|The biz sequence number of the message|
-|`uniqueId`|The unique ID of the message|
+#### 2. Client发起交互
-### Client-Initiated Interaction
+| 场景 | Client向Server发送消息请求码 | Server回复Client消息的响应码 | 说明 |
+| ------------ | ---------------------------- | --------------------------------------- | ---- |
+| 心跳 | HEARTBEAT(203) | SUCCESS(0)/EVENTMESH_HEARTBEAT_ERROR(19) | |
+| 订阅 | SUBSCRIBE(206) | SUCCESS(0)/EVENTMESH_SUBSCRIBE_ERROR(17) | |
+| 取消订阅 | UNSUBSCRIBE(207) | SUCCESS(0)/EVENTMESH_UNSUBSCRIBE_ERROR(18) | |
+| 发送异步事件 | MSG_SEND_ASYNC(104) | SUCCESS(0)/EVENTMESH_SEND_ASYNC_MSG_ERR(14) | |
-|Scene|Client Request|Server Response|Remark|
-|-|-|-|-|
-| Heartbeat | HEARTBEAT(203) | SUCCESS(0) or EVENTMESH_HEARTBEAT_ERROR(19) | |
-| Subscribe | SUBSCRIBE(206) | SUCCESS(0) or EVENTMESH_SUBSCRIBE_ERROR(17) | |
-| Unsubscribe | UNSUBSCRIBE(207) | SUCCESS(0) or EVENTMESH_UNSUBSCRIBE_ERROR(18) | |
-| Send async message | MSG_SEND_ASYNC(104) | SUCCESS(0) or EVENTMESH_SEND_ASYNC_MSG_ERR(14) | |
+#### 3. Server发起交互
-### Server-Initiated Interaction
+| 场景 | Server向Client发送消息请求码 | Client回复Server消息响应码 | 说明 |
+| ------------------ | ---------------------------- | -------------------------- | ---------------------- |
+| 客户端接收异步事件 | HTTP_PUSH_CLIENT_ASYNC(105) | retCode | retCode值为0时代表成功 |
-|Scene|Client Request|Server Response|Remark|
-|-|-|-|-|
-|Push async message to the client|HTTP_PUSH_CLIENT_ASYNC(105)|`retCode`|The push is successful if the `retCode` is `0`|
+## gRPC 协议文档
-## gRPC Protocol
+#### 1. protobuf
-### Protobuf
+在 `eventmesh-protocol-gprc` 模块有 Eventmesh gRPC 客户端的 protobuf 文件. the protobuf 文件路径是 `/src/main/proto/eventmesh-client.proto`.
-The `eventmesh-protocol-gprc` module contains the [protobuf definition file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-protocol-plugin/eventmesh-protocol-grpc/src/main/proto/eventmesh-client.proto) of the Evenmesh client. The `gradle build` command generates the gRPC codes, which are located in `/build/generated/source/proto/main`. The generated gRPC codes are used in `eventmesh-sdk-java` module.
+用gradle build 生成 gRPC 代码在 `/build/generated/source/proto/main`. 生成代码用于 `eventmesh-sdk-java` 模块.
-### Data Model
+#### 2. gRPC 数据模型
-#### Message
++ 消息
-The message data model used by `publish()`, `requestReply()` and `broadcast()` APIs is defined as:
+以下消息数据模型用于 `publish()`, `requestReply()` 和 `broadcast()` APIs.
-```protobuf
+```
message RequestHeader {
string env = 1;
string region = 2;
@@ -306,11 +325,11 @@ message Response {
}
```
-#### Subscription
++ 订阅
-The subscription data model used by `subscribe()` and `unsubscribe()` APIs is defined as:
+以下订阅数据模型用于 `subscribe()` 和 `unsubscribe()` APIs.
-```protobuf
+```
message Subscription {
RequestHeader header = 1;
string consumerGroup = 2;
@@ -336,11 +355,11 @@ message Subscription {
}
```
-#### Heartbeat
++ 心跳
-The heartbeat data model used by the `heartbeat()` API is defined as:
+以下心跳数据模型用于 `heartbeat()` API.
-```protobuf
+```
message Heartbeat {
enum ClientType {
PUB = 0;
@@ -361,40 +380,40 @@ message Heartbeat {
}
```
-### Service Definition
+#### 3. gRPC 服务接口
-#### Event Publisher Service
++ 事件生产端服务 APIs
-```protobuf
+```
service PublisherService {
- // Async event publish
+ # 异步事件生产
rpc publish(SimpleMessage) returns (Response);
- // Sync event publish
+ # 同步事件生产
rpc requestReply(SimpleMessage) returns (Response);
- // Batch event publish
+ # 批量事件生产
rpc batchPublish(BatchMessage) returns (Response);
}
```
-#### Event Consumer Service
++ 事件消费端服务 APIs
-```protobuf
+```
service ConsumerService {
- // The subscribed event will be delivered by invoking the webhook url in the Subscription
+ # 所消费事件通过 HTTP Webhook推送事件
rpc subscribe(Subscription) returns (Response);
- // The subscribed event will be delivered through stream of Message
+ # 所消费事件通过 TCP stream推送事件
rpc subscribeStream(Subscription) returns (stream SimpleMessage);
rpc unsubscribe(Subscription) returns (Response);
}
```
-#### Client Hearthbeat Service
++ 客户端心跳服务 API
-```protobuf
+```
service HeartbeatService {
rpc heartbeat(Heartbeat) returns (Response);
}
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/03-stream.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/03-stream.md
index 7f2534a5..9f733d82 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/03-stream.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/03-stream.md
@@ -1,118 +1,115 @@
# EventMesh Stream
-## Overview of Event Streaming
+## 事件流概述
-Event Streaming is an implementation of Pub/Sub architecture pattern,it consist of
+事件流是发布/订阅架构模式的一种实现，它包括以下几个部分
-- Message or Event: Change of State.
+- 消息或事件：状态变化。
-- Topic: Partition in messaging middle ware broker.
+- 主题：消息中间件代理中的分区。
-- Consumer: Can subscribe to read events from broker topic.
+- 消费者：可以从代理主题订阅读取事件。
-- Producer: Generate events
+- 生产者：生成事件
-Streaming of event is continuous flow of events in order to maintain order between events, events flow should be in a specific direction means from producers to consumers.
+事件流是事件的连续流动，为了维持事件之间的秩序，事件流应该以特定的方式从生产者流向消费者。
-## Requirements
+## 要求
-### Functional Requirements
+### 功能要求
-| Requirement ID | Requirement Description | Comments |
+| 需求编号 | 需求描述 | 注释 |
| -------------- | ----------------------- | -------- |
-| F-1 | EventMesh users should be able to achieve Event Streaming functionality in EventMesh | Functionality |
-| F-2 | EventMesh users can apply dynamic user specific logics for routing, filter, transformation etc | Functionality |
+| F-1 | EventMesh用户应该能够在 EventMesh 中实现事件流功能 | 功能性 |
+| F-2 | EventMesh用户可以为路由、过滤、转换等应用动态用户特定逻辑 | 功能性 |
-## Design Details
+## 设计细节
-We are introduce EventMesh Stream component allow us to use programming model and binder abstractions
-from Spring Cloud Stream natively within Apache Camel.
+我们引入了 EventMesh Stream 组件，允许我们在 Apache Camel 中本地使用来自 Spring Cloud Stream 的编程模型和绑定器抽象。
-[Spring-Cloud-Stream](https://spring.io/projects/spring-cloud-stream) Spring Cloud Stream is a framework for building
-highly scalable event-driven microservices connected with shared messaging systems.
+[Spring-Cloud-Stream](https://spring.io/projects/spring-cloud-stream) Spring Cloud Stream是一个用于构建
+与共享消息传递系统连接的、高度可扩展的事件驱动微服务框架。
-[Apache Camel](https://camel.apache.org/) Camel is an Open Source integration framework that empowers you to quickly
-and easily integrate various systems consuming or producing data.
+[Apache Camel](https://camel.apache.org/) Camel 是一个开源集成框架，使您能够快速轻松地集成各种消费或生产数据的系统。
-## Architecture
+## 架构
-
+
-## Design
+## 设计
-### EventMesh-Stream Component
+### EventMesh-Stream 组件
-- Event
-- Event Channel
-- Event EndPoint
-- Event Pipes & Filters
-- Event Routes
-- Event Converter
+- Event（事件）
+- Event Channel（事件通道）
+- Event EndPoint（事件端点）
+- Event Pipes & Filters（事件管道和过滤器）
+- Event Routes（事件路由器）
+- Event Converter（事件转换器）
-#### Event
+#### Event（事件）
-> A event is the smallest unit for transmitting data in system. It structure divided into headers, body and attachments.
+> 事件是系统中传输数据的最小单位。它的结构分为标题、正文和附件。
-#### Event Channel
+#### Event Channel（事件通道）
-> A event channel is a logical channel in system, we are achieving by Spring Cloud Stream programming model, it has abstract functionality around messaging channels(As of now Spring `MessageChannel`).
+> 事件通道是系统中的逻辑通道，我们是通过 Spring Cloud Stream 编程模型实现的，它具有围绕消息通道的抽象功能（截至目前用的是 Spring `MessageChannel`）。
-#### Event EndPoint
+#### Event EndPoint（事件端点）
-> A event endpoint is the interface between an application and a messaging system. We can define two types of endpoint
+> 事件端点是应用程序和消息传递系统之间的接口。我们可以定义两种类型的端点
-- Consumer endpoint - Appears at start of a route and read incoming events from an incoming channel.
-- Producer endpoint - Appears at end of a route and write incoming events to an outgoing channel.
+- 消费者端点 - 出现在路由开始并从传入通道读取传入事件。
+- 生产者端点 - 出现在路由的末尾并将传入事件写入传出通道。
-#### Event Pipes & Filters
+#### Event Pipes & Filters（事件管道和过滤器）
-> We can construct a route by creating chain of filters( Apache Camel `Processor`), where the output of one filter is fed into input for next filter in the pipeline.
-The main advantage of the pipeline is that you can create complex event processing logic.
+> 我们可以通过创建过滤器链（Apache Camel `Processor`）来构建路由，其中一个过滤器的输出被用于管道中下一个过滤器的输入。管道的主要优点是可以创建复杂的事件处理逻辑。
-#### Event Routes
+#### Event Routes（事件路由器）
-> A event router, is a type of filter on consumer and redirect them to the appropriate target endpoint based on a decision criteria.
+> 事件路由器是消费者的一种过滤器，并根据决策标准将它们重定向到适当的目标端点。
-#### Event Converter
+#### Event Converter（事件转换器）
-> The event converter that modifies the contents of a event, translating it to a different format(i.e cloudevents -> Event (Camel) -> Binder Message(Spring Message) and vice versa).
+> 事件转换器用于修改事件内容，将其转换为不同的格式（换而言之 cloudevents -> Event (Camel) -> Binder Message(Spring Message)，反之亦然）。
-## EventMesh-Stream Component Interfaces
+## EventMesh-Stream 组件接口
-### Component
+### Component（组件）
-Component interface is the primary entry point, you can use Component object as a factory to create EndPoint objects.
+Component 接口是主要的入口点，您可以使用 Component 对象作为工厂来创建 EndPoint 对象。
-
+
-### EndPoint
+### EndPoint（端点）
-EndPoint which is act as factories for creating Consumer, Producer and Event objects.
+EndPoint 作为创建消费者、生产者和事件对象的工厂。
-- `createConsumer()` — Creates a consumer endpoint, which represents the source endpoint at the beginning of a route.
-- `createProducer()` — Creates a producer endpoint, which represents the target endpoint at the end of a route.
+- `createConsumer()` — 创建消费者端点，该端点表示路由开始的源端点。
+- `createProducer()` — 创建生产者端点，该端点表示路由末端的目标端点。
-
+
-#### Producer
+#### Producer（生产者）
-User can create following types of producer
-> Synchronous Producer-Processing thread blocks until the producer has finished the event processing.
+用户可以创建以下类型的生产者
+> 同步生产者：处理线程阻塞，直到生产者完成事件处理。
-
+
-In future Producer Types:
+未来将会实现的生产者类型：
-- Asynchronous Producer - Producer process the event in a sub-thread.
+- 异步生产者 - 生产者在子线程中处理事件。
-#### Consumer
+#### Consumer（消费者）
-User can create following types of consumer
-> Event-driven consumer-the processing of an incoming request is initiated when message binder call a method in consumer.
+用户可以创建以下类型的消费者
+> 事件驱动的消费者：当消息绑定器调用消费者中的方法时，开始处理传入请求。
-
+
-In the Future
+未来将会实现的消费者类型：
-- Scheduled poll consumer
-- Custom polling consumer
+- 定时轮训消费者
+- 自定义轮询消费者
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/04-schema-registry.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/04-schema-registry.md
deleted file mode 100644
index 7c5d2282..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/04-schema-registry.md
+++ /dev/null
@@ -1,134 +0,0 @@
-# EventMesh Schema Registry (OpenSchema)
-
-## Overview of Schema and Schema Registry
-
-### Schema
-
-A Schema stands for the description of serialization instances(string/stream/file/...) and has two properties. First, it is also in the format of serialization type. Second, it defines what requirements such serialized instances should satisfy.
-
-Besides describing a serialization instance, a Schema may also be used for validating whether an instance is legitimate. The reason is that it defines the ```type```(and other properties) of a serialized instance and inside keys. Taking JSON Schema for example, it could not only be referred when describing a JSON string, but also be used for validating whether a string satisfies properties defined in the schema[[1]](#References).
-
-Commonly, there are JSON Schema, Protobuf Schema, and Avro Schema.
-
-### Schema Registry
-
-Schema Registry is a server provides RESTful interfaces. It could receive and store Schemas from clients, as well as provide intrefaces for other clients to retrieve Schemas from it.
-
-It could be applied to validation process and (de-)serialization process.
-
-### Comparison of Schema Registry in Different Projects
-
-Project | Application
-:---: | :---
-EMQ[[2]](#References) | Mainly in (de-)serialization process. Use "Schema Registry" and "Rule Matching" to transfer a message from one serialization format to another.
-Pulsar[[3]](#References) | Mainly in validation process. Use "Schema Registry" to validate a message.
-Confluentinc[[4]](#References) | In both validation and (de-)serialization process.
-
-## Overview of OpenSchema
-
-OpenSchema[[5]](#References) proposes a specification for data schema when exchanging the message and event in more and more modern cloud-native applications. It designs a RESTful interface for storing and retrieving such as Avro, JSON Schema, and Protobuf3 schemas from three aspects(subject/schema/compatibility).
-
-## Requirements(Goals)
-
-| Requirement ID | Requirement Description | Comments |
-| :------------- | ------------------------------------------------------------ | ------------- |
-| F-1 | In transmission, no message needs to contain schema information which bring efficiency. | Functionality |
-| F-2 | The message content from producer could be validated whether serialized correctly according to schema. | Functionality |
-
-## Design Details
-
-### Architecture
-
-
-
-### Process of Transferring Messages under Schema Registry
-
-
-
-The highlevel process of messages transmission contains 10 steps as follows:
-
-- 1: Consumer subscribes "TOPIC" messages from EventMesh.
-- 2: Producer registers a schema to EventMesh.
-- 3: EventMesh registers a schema to Schema Registry.
-- 4: Schema Registry returns the id of newly created schema; EventMesh caches such id and schema.
-- 5: EventMesh returns the id of schema to Producer.
-- 6: Producer patches the id in front of messages and send messages to EventMesh.
-- 7: EventMesh validates the messages in the entry port and send it to EventStore; EventMesh retrieves messages from EventStore.
-- 8: EventMesh unpatches the id and send it to Schema Registry(if such `<id, schema>` does not exists in local cache).
-- 9: Schema Registry returns schema and EventMesh caches it.
-- 10: EventMesh patches schema in front of messages and push it to consumer.
-
-## Current Progress
-
-### Status
-
-**Current state**: Developing
-
-**Discussion thread**: ISSUE #339
-
-### Proposed Changes
-
-The proposal has two aspects.
-
-First is a separated Open Schema Registry, which includes storage and compatibility check for schema.
-This proposal is under developing.
-
-Second is the integration of Open Schema in Eventmesh, which includes validation for schema. This proposal is to be developed.
-
-As for the first proposal, some developing statuses are as follows.
-
-#### Status Code and Exception Code
-
-No. | Status Code | Exception Code | Description | status
---- | :---: | :---: | :---: | :---:
-1 | 401 | 40101 | Unauthorized Exception | ✔
-2 | 404 | 40401 | Schema Non- Exception | ✔
-3 | ^ | 40402 | Subject Non-exist Exception | ✔
-4 | ^ | 40403 | Version Non-exist Exception | ✔
-5 | 409 | 40901 | Compatibility Exception | ✔
-6 | 422 | 42201 | Schema Format Exception | ✔
-7 | ^ | 42202 | Subject Format Exception | ✔
-8 | ^ | 42203 | Version Format Exception | ✔
-9 | ^ | 42204 | Compatibility Format Exception | ✔
-10 | 500 | 50001 | Storage Service Exception | ✔
-11 | ^ | 50002 | Timeout Exception | ✔
-
-#### API Development Status
-
-No. | Type | URL | response | exception | code | test
---- | --- | --- | --- | --- | --- | ---
-1 | GET | /schemas/ids/{string: id} | `Schema.class` | 40101\40401\50001 | ✔ | ❌
-2 | GET | /schemas/ids/{string: id}/subjects | `SubjectAndVersion.class` | 40101\40401\50001 | ✔ | ❌
-3 | GET | /subjects | `List\<String>` | 40101\50001 | ✔ | ❌
-4 | GET | /subjects/{string: subject}/versions | `List\<Integer>` | 40101\40402\50001 | ✔ | ❌
-5 | DELETE | /subjects/(string: subject) | `List\<Integer>` | 40101\40402\50001 | ✔ | ❌
-6 | GET | /subjects/(string: subject) | `Subject.class` | 40101\40402\50001 | ✔ | ❌
-7 | GET | /subjects/(string: subject)/versions/(version: version)/schema | `SubjectWithSchema.class` | 40101\40402\40403\50001 | ✔ | ❌
-8 | POST | /subjects/(string: subject)/versions | `SchemaIdResponse.class` | 40101\40901\42201\50001\50002 | - | ❌
-9 | POST | /subjects/(string: subject)/ | `Subject.class` | 40101\40901\42202\50001\50002 | ✔ | ❌
-10 | DELETE | /subjects/(string: subject)/versions/(version: version) | `int` | 40101\40402\40403\40901\50001| - | ❌
-11 | POST | /compatibility/subjects/(string: subject)/versions/(version: version) | `CompatibilityResultResponse.class` | 40101\40402\40403\42201\42203\50001| - | ❌
-12 | GET | /compatibility/(string: subject) | `Compatibility.class` | 40101\40402\50001 | ✔ | ❌
-13 | PUT | /compatibility/(string: subject) | `Compatibility.class` | 40101\40402\40901\42204\50001 | - | ❌
-
-#### Overall Project Structure
-
-```SchemaController.java```+```SchemaService.java``` : ```OpenSchema 7.1.1~7.1.2 (API 1~2)```
-
-```SubjectController.java```+```SubjectService.java``` : ```OpenSchema 7.2.1~7.2.8 (API 3~10)```
-
-```CompatibilityController.java```+```CompatibilityService.java``` : ```OpenSchema 7.3.1~7.3.3 (API 11~13)``` + ```Check for Compatibility```
-
-
-
-## References
-
-[1] [schema validator (github.com)](https://github.com/search?q=schema+validator)
-
-[2] [EMQ: Schema Registry](https://www.jianshu.com/p/33e0655c642b)
-
-[3] [Pulsar: Schema Registry](https://mp.weixin.qq.com/s/PaB66-Si00cX80py5ig5Mw)
-
-[4] [confluentinc/schema-registry](https://github.com/confluentinc/schema-registry)
-
-[5] [openmessaging/openschema](https://github.com/openmessaging/openschema)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/05-metrics-export.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/05-metrics-export.md
index bab18761..38be6e07 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/05-metrics-export.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/05-metrics-export.md
@@ -1,47 +1,47 @@
-# EventMesh Metrics (OpenTelemetry and Prometheus)
+# EventMesh 指标（OpenTelemetry 和 Prometheus
-## Introduction
+## 介绍
-[EventMesh(incubating)](https://github.com/apache/incubator-eventmesh) is a dynamic cloud-native eventing infrastructure.
+[EventMesh(incubating)](https://github.com/apache/incubator-eventmesh) 是一个动态的云原生事件基础设施.
-## An overview of OpenTelemetry
+## OpenTelemetry 概述
-OpenTelemetry is a collection of tools, APIs, and SDKs. You can use it to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.
+OpenTelemetry 是工具、API 和 SDK 的集合。您可以使用它来检测、生成、收集和导出遥测数据（指标、日志和跟踪）以进行分析，以便了解您的软件的性能和行为。
-## An overview of Prometheus
+## 概述 Prometheus
-Power your metrics and alerting with a leading open-source monitoring solution.
+使用领先的开源监控解决方案为您的指标和警报提供支持。
-- Dimensional data
-- Powerful queries
-- Great visualization
-- Efficient storage
-- Simple operation
-- Precise alerting
-- Many client libraries
-- Many integrations
+- 尺寸数据
+- 强大的查询
+- 伟大的可视化
+- 高效存储
+- 操作简单
+- 精准预警
+- 许多客户端库
+- 许多集成
-## Requirements
+## 要求
-### Functional Requirements
+### 功能要求
| Requirement ID | Requirement Description | Comments |
| :------------- | ------------------------------------------------------------ | ------------- |
| F-1 | EventMesh users should be able to observe HTTP metrics from Prometheus | Functionality |
| F-2 | EventMesh users should be able to observe TCP metrics from Prometheus | Functionality |
-## Design Details
+## 设计 细节
-use the meter instrument provided by OpenTelemetry to observe the metrics exist in EventMesh then export to Prometheus.
+使用由提供的儀表儀器 OpenTelemetry 觀察指標存在於 EventMesh 然後導出到 Prometheus.
-1、Initialize a meter instrument
+1、初始化儀表儀器
-2、set the Prometheus server
+2、設置 Prometheus 服務器
-3、different metrics observer built
+3、创建了不同的指标观察者
-## Appendix
+## 附录
-### References
+### 参考资料
<https://github.com/open-telemetry/docs-cn/blob/main/QUICKSTART.md#%E5%88%9B%E5%BB%BA%E5%9F%BA%E7%A1%80Span>
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/06-cloudevents.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/06-cloudevents.md
index bff91b45..2d53e607 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/06-cloudevents.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/06-cloudevents.md
@@ -1,106 +1,102 @@
-# CloudEvents Integration
+# CloudEvents 集成
-## Introduction
+## 介绍
-[CloudEvents](https://github.com/cloudevents/spec) is a specification for describing event data in common formats to provide interoperability across services, platforms and systems.
+[CloudEvents](https://github.com/cloudevents/spec) 是一种描述事件数据的格式规范，它提供了跨服务、平台与系统的互操作性。
-As of May 2021, EventMesh contains the following major components: `eventmesh-runtime`, `eventmesh-sdk-java` and `eventmesh-connector-rocketmq`.
-For a customer to use EventMesh, `eventmesh-runtime` can be deployed as microservices to transmit
-customer's events between event producers and consumers. Customer's applications can then interact
-with `eventmesh-runtime` using `eventmesh-sdk-java` to publish/subscribe for events on given topics.
+截止至 2021 年 5 月，EventMesh 包含了以下主要组件：`eventmesh-runtime`, `eventmesh-sdk-java` 和 `eventmesh-connector-rocketmq`。
-CloudEvents support has been a highly desired feature by EventMesh users. There are many reasons
-for users to prefer using a SDK with CloudEvents support:
+对于使用 EventMesh 的用户，`eventmesh-runtime` 可以被部署为微服务来在生产者和消费者间传输用户的事件。
+用户的应用程序可以通过 `eventmesh-sdk-java` 来与 `eventmesh-runtime` 进行交互，即发布或订阅指定主题的事件。
-- CloudEvents is a more widely accepted and supported way to describe events. `eventmesh-sdk-java`
- currently uses the `LiteMessage` structure to describe events, which is less standardized.
-- CloudEvents's Java SDK has a wider range of distribution methods. For example, EventMesh users
- currently need to use the SDK tarball or build from source for every EventMesh release. With
- CloudEvents support, it's easier for users to take a dependency on EventMesh's SDK using CloudEvents's public distributions (e.g. through a Maven configuration).
-- CloudEvents's SDK supports multiple languages. Although EventMesh currently only supports a Java SDK, in future if more languages need to be supported, the extensions can be easier with experience on binding Java SDK with CloudEvents.
+EventMesh 的用户非常渴望能得到对 CloudEvents 的支持。有许多理由使得用户倾向于使用集成了 CloudEvents 支持的 SDK：
-## Requirements
+- CloudEvents 是一种更为广泛接受和支持的描述事件的方式。目前，`eventmesh-sdk-java` 使用的是 `LiteMessage` 结构
+ 来描述事件，其标准化程度较低。
+- CloudEvents 的 Java SDK 有更广泛的分发方式。比如，目前 EventMesh 的用户需要使用 SDK 的 tar 包，或对每个 EventMesh 的
+ 发布版本从源码编译。有了 CloudEvents 的支持，用户可以更方便地通过 CloudEvents 的公开分发（比如，配置 Maven）来添加
+ EventMesh SDK 依赖项。
+- CloudEvents 的 SDK 支持多种语言。尽管目前 EventMesh 只提供了 Java SDK，但在未来，如果要为更多语言提供支持，将 Java SDK
+ 与 CloudEvents 绑定的经验将使工作变得容易。
-### Functional Requirements
+## 需求
-| Requirement ID | Requirement Description | Comments |
-| -------------- | ----------------------- | -------- |
-| F-1 | EventMesh users should be able to depend on a public SDK to publish/subscribe events in CloudEvents format | Functionality |
-| F-2 | EventMesh users should continue to have access to existing EventMesh client features (e.g. load balancing) with an SDK that supports CloudEvent | Feature Parity |
-| F-3 | EventMesh developers should be able to sync `eventmesh-sdk-java` and an SDK with CloudEvents support without much effort/pain | Maintainability |
-| F-4 | EventMesh support pluggable protocols for developers integrate other protocols (e.g. CloudEvents\EventMesh Message\OpenMessage\MQTT ...) | Functionality |
-| F-5 | EventMesh support the unified api for publish/subscribe events to/from event store | Functionality |
+### 功能需求
-### Performance Requirements
+| 需求 ID | 需求描述 | 备注 |
+| ------ | ------- | --- |
+| F-1 | EventMesh 用户应能使用公共 SDK 依赖项来发布或订阅 CloudEvents 格式的事件 | 功能性 |
+| F-2 | EventMesh 用户应能在提供了 CloudEvents 支持的 SDK 中继续使用现有的 EventMesh 客户端功能（如负载均衡） | 功能等价 |
+| F-3 | EventMesh 的开发者应不需要付出特别多努力/痛苦来在 `eventmesh-sdk-java` 和提供了 CloudEvents 支持的 SDK 之间同步 | 可维护性 |
+| F-4 | EventMesh 支持可插拔的协议，以便开发者整合其他协议（例如：CloudEvents / EventMesh MessageOpenMessage / MQTT...） | 功能性 |
+| F-5 | EventMesh 支持统一的 API 以供从/向事件库发布或订阅事件 | 功能性 |
-| Requirement ID | Requirement Description | Comments |
-| -------------- | ----------------------- | -------- |
-| P-1 | Client side latency for SDK with CloudEvents support should be similar to current SDK | |
+### 性能需求
-## Design Details
+| 需求 ID | 需求描述 | 备注 |
+| ------ | ------- | --- |
+| P-1 | 提供了 CloudEvents 支持的 SDK 应具有与目前的 SDK 相近的客户端延迟 | |
-Binding with the CloudEvents Java SDK (similar to what Kafka already did, see Reference for more details)
-should be an easy way to achieve the requirements.
+## 设计细节
-### Pluggable Protocols
+与 CloudEvents 的 Java SDK 绑定（这与 Kafka 已经完成的工作类似，请在附录中的参考资料了解更多细节）是达成上述需求的一种简单方法。
-
+### 可插拔协议
-### Process of CloudEvents under EventMesh
+
-#### For TCP
+### EventMesh 集成 CloudEvents 进度表
-##### SDK side for publish
+#### TCP
-- add the CloudEvents identifier in `package` header
-- use `CloudEventBuilder` build the CloudEvent and put it into the `package` body
+##### SDK 端发布
-##### SDK side for subscribe
+- 在 `package` 首部中添加 CloudEvents 标识符
+- 使用 `CloudEventBuilder` 构造 CloudEvent，并将其放入 `package` 体中
-- add `convert` function under the `ReceiveMsgHook` interface, for converting the `package` body to the specific protocol with the identifier in `package` header
-- different protocols should implement the `ReceiveMsgHook` interface
+##### SDK 端订阅
-##### Server side for publish
+- 在 `ReceiveMsgHook` 接口下添加 `convert` 函数，其用于将 `package` 体转换为具有 `package` 首部标识符的特定协议
+- 不同协议应实现 `ReceiveMsgHook` 接口
-- design the protocol convert api contains `decodeMessage` interface which convert the package's body to CloudEvent
-- update `Session.upstreamMsg()` in `MessageTransferTask` change the input parameter Message to CloudEvent, the CloudEvent use the last step `decodeMessage` api convert
-- update `SessionSender.send()` change the input parameter `Message` to `CloudEvent`
-- update `MeshMQProducer` api support send `CloudEvents` in runtime
-- support the implementation in `connector-plugin` for send `CloudEvents` to EventStore
+##### 服务端发布
-##### Server side for subscribe
+- 设计包含 `decodeMessage` 接口的协议转换 API，其可以把包体转换为 CloudEvent
+- 更新 `MessageTransferTask` 下的 `Session.upstreamMsg()`，将入参 `Message` 改为 `CloudEvent`，这使用了
+ 上一步的 `decodeMessage` API 来进行对 CloudEvent 的转换
+- 更新 `SessionSender.send()`，将入参 `Message` 改为 `CloudEvent`
+- 更新 `MeshMQProducer` API，支持在运行时发送 `CloudEvents`
+- 在 `connector-plugin` 中实现支持向 EventStore 中发送 `CloudEvents`
-- support change the `RocketMessage` to `CloudEvent` in connector-plugin
+##### 服务端订阅
-- overwrite the `AsyncMessageListener.consume()` function, change the input parameter `Message` to `CloudEvent`
+- 支持将连接器插件中的 `RocketMessage` 改为 `CloudEvent
+- 重写 `AsyncMessageListener.consume()` 函数，将入参 `Message` 改为 `CloudEvent`
+- 更新 `MeshMQPushConsumer.updateOffset()`，将入参 `Message` 改为 `CloudEvent`
+- 更新 `DownStreamMsgContext`，将入参 `Message` 改为 `CloudEvent`，更新 `DownStreamMsgContext.ackMsg`
-- update the `MeshMQPushConsumer.updateOffset()` implementation change the the input parameter `Message` to `CloudEvent`
+#### HTTP
-- update `DownStreamMsgContext` , change the input parameter `Message` to `CloudEvent`, update the `DownStreamMsgContext.ackMsg`
+##### SDK 端发布
-#### For HTTP
+- 支持 `LiteProducer.publish(cloudEvent)`
+- 在 http 请求头中添加 CloudEvents 标识符
-##### SDK side for publish
+##### SDK 端订阅
-- support `LiteProducer.publish(cloudEvent)`
-- add the CloudEvents identifier in http request header
+##### 服务端发布
-##### SDK side for subscribe
+- 支持根据 `HttpCommand` 首部中的协议类型，通过可插拔的协议插件构造 `HttpCommand.body`
+- 支持在消息处理器中发布 CloudEvent
-##### Server side for publish
+##### 服务端订阅
-- support build the `HttpCommand.body` by pluggable protocol plugins according the protocol type in `HttpCommand` header
-- support publish the CloudEvent in message processors
+- 更新 `EventMeshConsumer.subscribe()`
+- 更新 `HandleMsgContext`， 将入参 `Message` 改为 `CloudEvent`
+- 更新 `AsyncHttpPushRequest.tryHTTPRequest()`
-##### Server side for subscribe
+## 附录
-- update the `EventMeshConsumer.subscribe()`
-
-- update `HandleMsgContext` , change the input parameter `Message` to `CloudEvent`
-- update `AsyncHttpPushRequest.tryHTTPRequest()`
-
-## Appendix
-
-### References
+### 参考资料
- <https://cloudevents.github.io/sdk-java/kafka>
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/07-tracing.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/07-tracing.md
deleted file mode 100644
index 1b191965..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/07-tracing.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Distributed Tracing
-
-## Overview of OpenTelemetry
-
-OpenTelemetry is a collection of tools, APIs, and SDKs. You can use it to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.
-
-## Requirements
-
-- set tracer
-- different exporter
-- start and end span in server
-
-## Design Details
-
-- SpanProcessor: BatchSpanProcessor
-
-- Exporter: log(default), would be changed from properties
-
-```java
-// Configure the batch spans processor. This span processor exports span in batches.
-BatchSpanProcessor batchSpansProcessor =
- BatchSpanProcessor.builder(exporter)
- .setMaxExportBatchSize(512) // set the maximum batch size to use
- .setMaxQueueSize(2048) // set the queue size. This must be >= the export batch size
- .setExporterTimeout(
- 30, TimeUnit.SECONDS) // set the max amount of time an export can run before getting
- // interrupted
- .setScheduleDelay(5, TimeUnit.SECONDS) // set time between two different exports
- .build();
-OpenTelemetrySdk.builder()
- .setTracerProvider(
- SdkTracerProvider.builder().addSpanProcessor(batchSpansProcessor).build())
- .build();
-```
-
-1. When using the method 'init()' of the class "EventMeshHTTPServer", the class "AbstractHTTPServer” will get the tracer
-
-```java
-super.openTelemetryTraceFactory = new OpenTelemetryTraceFactory(eventMeshHttpConfiguration);
-super.tracer = openTelemetryTraceFactory.getTracer(this.getClass().toString());
-super.textMapPropagator = openTelemetryTraceFactory.getTextMapPropagator();
-```
-
-2. then the trace in class "AbstractHTTPServer” will work.
-
-## Problems
-
-### How to set different exporter in class 'OpenTelemetryTraceFactory'? (Solved)
-
-After I get the exporter type from properties, how to deal with it.
-
-The 'logExporter' only needs to new it.
-
-But the 'zipkinExporter' needs to new and use the "getZipkinExporter()" method.
-
-## Solutions
-
-### Solution of different exporter
-
-Use reflection to get an exporter.
-
-First of all, different exporter must implement the interface 'EventMeshExporter'.
-
-Then we get the exporter name from the configuration and reflect to the class.
-
-```java
-//different spanExporter
-String exporterName = configuration.eventMeshTraceExporterType;
-//use reflection to get spanExporter
-String className = String.format("org.apache.eventmesh.runtime.exporter.%sExporter",exporterName);
-EventMeshExporter eventMeshExporter = (EventMeshExporter) Class.forName(className).newInstance();
-spanExporter = eventMeshExporter.getSpanExporter(configuration);
-```
-
-Additional, this will surround with try catch.If the specified exporter cannot be obtained successfully, the default exporter log will be used instead
-
-#### Improvement of different exporter
-
-SPI (To be completed)
-
-## Appendix
-
-### References
-
-<https://github.com/open-telemetry/docs-cn/blob/main/QUICKSTART.md>
-
-<https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/netty>
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/08-spi.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/08-spi.md
index 94da666e..5fb301f4 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/08-spi.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/08-spi.md
@@ -1,41 +1,43 @@
-# Service Provider Interface
+# EventMesh SPI
-## Introduction
+## 介绍
-In order to improve scalability，EventMesh introduce the SPI（Service Provider Interface）mechanism, which can help to automatically find the concrete implementation
-class of the extended interface at runtime and load it dynamically. In EventMesh, all extension modules are implemented by using plugin.
-User can develop custom plugins by simply implementing extended interfaces, and select the plugin to be run at runtime by simply declare at configuration.
+为了提高扩展性，EventMesh通过引入SPI（Service Provider Interface）机制，能够在运行时自动寻找扩展接口的具体实现类，动态加载。
+在EventMesh中，一切扩展点都利用SPI采用插件的实现方式，用户可以通过实现扩展接口，开发自定义的插件，在运行时通过简单的配置，声明式的选择所需要运行的插件。
-## eventmesh-spi module
+## eventmesh-spi模块
-The implementation of SPI is at eventmesh-spi module, there are three main classes `EventMeshSPI`, `EventMeshExtensionFactory` and `ExtensionClassLoader`.
+SPI相关的代码位于eventmesh-spi模块下，其中主要包括EventMeshExtensionFactory, EventMeshSPI, ExtensionClassLoader这三个类。
### EventMeshSPI
-EventMeshSPI is an SPI declaration annotation, all extended interface that want to be implemented should be declared by @EventMeshSPI.
+EventMeshSPI是SPI注解，所有需要采用SPI实现扩展的接口都需要使用@EventMeshSPI注解标记。
```java
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface EventMeshSPI {
+
/**
* If true, the spi instance is singleton
*/
boolean isSingleton() default false;
+
}
```
-Use annotation to declare the interface is an SPI extended interface can improve the readability of the code.
-On the other hand, @EventMeshSPI contains a isSingleton attribute which used to declare whether the extension instance is a singleton.
-If this attribute is true, that means the instance of this interface will be singleton.
+这么做的原因是可以通过注解的方式声明接口为SPI扩展接口，提高代码的可读性。同时，@EventMeshSPI注解中包含一个isSingleton属性，
+用来声明该扩展接口是否采用单例的实现方式，如果为true，那么该接口的实现类将会使用单例的实现方式，在一个JVM进程中全局唯一。
### EventMeshExtensionFactory
-EventMeshExtensionFactory is a factory used to get the SPI extension instance which contains a static method `getExtension(Class<T> extensionType, String extensionName)`.
+EventMeshExtensionFactory是SPI实现类的获取工厂，包含一个静态方法`getExtension(Class<T> extensionType, String extensionName)`，
+接收扩展接口字节码对象和扩展实例名称，用于获取扩展接口的具体实现类。
```java
public enum EventMeshExtensionFactory {
+ ;
/**
* @param extensionType extension plugin class type
* @param extensionName extension instance name
@@ -43,16 +45,15 @@ public enum EventMeshExtensionFactory {
* @return plugin instance
*/
public static <T> T getExtension(Class<T> extensionType, String extensionName) {
- /* ... */
}
}
```
-If you want to get the extension instance, you should use EventMeshExtensionFactory.
+所有需要获取扩展实现的地方都应该通过EventMeshExtensionFactory获取。
### ExtensionClassLoader
-ExtensionClassLoader is used to load extension instance classed, it has two subclass MetaInfExtensionClassLoader and JarExtensionClassLoader.
+ExtensionClassLoader是扩展接口实现类的加载接口，包含两个实现子类MetaInfExtensionClassLoader和JarExtensionClassLoader。
```java
/**
@@ -63,6 +64,7 @@ ExtensionClassLoader is used to load extension instance classed, it has two subc
* </ul>
*/
public interface ExtensionClassLoader {
+
/**
* load
*
@@ -74,40 +76,36 @@ public interface ExtensionClassLoader {
}
```
-MetaInfExtensionClassLoader used to load class from classPath, and JarExtensionClassLoader used to load class from extension jar on the plugin directory.
-In the future, we might support the implementation to load from the maven repository.
+MetaInfExtensionClassLoader用于从classPath直接加载实现类，JarExtensionClassLoader用于从配置目录下通过加载Jar包的方式加载实现类，未来可能还会提供通过从Maven仓库下加载实现类。
-## SPI use case
+## SPI使用示例
-The following is an example of how to use the SPI to declare a plugin.
+下面以eventmesh-connector-plugin为例，介绍SPI具体的使用过程。
-First, we create an eventmesh-connector-api module, and define the extension interface MeshMQProducer, and we use @EventMeshSPI on the MeshMQProducer,
-which indicates the MeshMQProducer is an SPI interface.
+首先定义一个eventmesh-connector-api模块，并且定义扩展接口MeshMQProducer。在MeshMQProducer接口上使用@EventMeshSPI注解进行声明，表明该接口是一个SPI扩展接口
```java
@EventMeshSPI(isSingleton = false)
public interface MeshMQProducer extends Producer {
- /* ... */
+...
}
```
-Then we create an eventmesh-connector-rocketmq module, which contains the concrete implementation named RocketMQProducerImpl.
+eventmesh-connector-rocketmq模块中包含采用rocketmq的具体实现方式RocketMQProducerImpl。
```java
public class RocketMQProducerImpl implements MeshMQProducer {
- /* ... */
+...
}
```
-At the same time, we need to create a file with the full qualified name of the SPI interface under the resource/META-INF/eventmesh directory
-in the eventmesh-connector-rocketmq module.
-
+同时，还需要在eventmesh-connector-rocketmq模块中resource/META-INF/eventmesh目录下创建文件名为SPI接口全限定名的文件
org.apache.eventmesh.api.producer.Producer
-The content of the file is the extension instance name and the corresponding instance full class name
+文件内容为扩展实例名和对应的实例全类名
```properties
rocketmq=org.apache.eventmesh.connector.rocketmq.producer.RocketMQProducerImpl
```
-At this point, an SPI expansion module is complete. We can use `EventMeshExtensionFactory.getExtension(MeshMQProducer.class, "rocketmq")` to get the `RocketMQProducerImpl` instance.
+至此，一个SPI扩展模块就完成了。在使用的时候只需要通过EventMeshExtensionFactory.getExtension(MeshMQProducer.class, “rocketmq”)就可以获取RocketMQProducerImpl实现类。
diff --git a/zh/docs/desing-document/09-event-bridge.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/09-event-bridge.md
similarity index 100%
rename from zh/docs/desing-document/09-event-bridge.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/09-event-bridge.md
diff --git a/zh/docs/desing-document/10-knative-connector.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/10-knative-connector.md
similarity index 100%
rename from zh/docs/desing-document/10-knative-connector.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/10-knative-connector.md
diff --git a/zh/docs/desing-document/11-prometheus.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/11-prometheus.md
similarity index 100%
rename from zh/docs/desing-document/11-prometheus.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/11-prometheus.md
diff --git a/zh/docs/desing-document/12-zipkin.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/12-zipkin.md
similarity index 100%
rename from zh/docs/desing-document/12-zipkin.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/12-zipkin.md
diff --git a/zh/docs/desing-document/13-jaeger.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/13-jaeger.md
similarity index 100%
rename from zh/docs/desing-document/13-jaeger.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/13-jaeger.md
diff --git a/zh/docs/desing-document/webhook.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/14-webhook.md
similarity index 100%
rename from zh/docs/desing-document/webhook.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/14-webhook.md
diff --git a/zh/docs/desing-document/https.md b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/15-https.md
similarity index 100%
rename from zh/docs/desing-document/https.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/design-document/15-https.md
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/_category_.json b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/_category_.json
index f9283e2f..95b7eed0 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/design-document/_category_.json
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/design-document/_category_.json
@@ -1,5 +1,4 @@
{
- "position": 6,
- "label": "Design Document",
+ "label": "Documentation",
"collapsed": false
}
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/installation/01-runtime.md b/i18n/zh/docusaurus-plugin-content-docs/current/installation/01-runtime.md
deleted file mode 100644
index fa2816a7..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/installation/01-runtime.md
+++ /dev/null
@@ -1,90 +0,0 @@
-# EventMesh Runtime
-
-EventMesh Runtime is the core component of Apache EventMesh (Incubating). It is the middleware that transmits events between producers and consumers. The documentation introduces the step to install and start the latest release of EventMesh Runtime in the local or test environment. The EventMesh Runtime requires a Linux-based system with JDK (Java Development Kit) 8. JDK 8 could be installed with the system package manager or the [openjdk:8-jdk](https://hub.docker.com/_/openjdk) Docker image.
-
-```console
-# Debian, Ubuntu, etc.
-apt-get install openjdk-8-jdk
-
-# Fedora, Oracle Linux, Red Hat Enterprise Linux, etc.
-yum install java-1.8.0-openjdk-devel
-
-# Docker
-docker pull openjdk:8-jdk
-```
-
-## Install Executable Binaries
-
-Download and extract the executable binaries of the latest release (v1.4.0) from [GitHub releases](https://github.com/apache/incubator-eventmesh/releases).
-
-```console
-wget https://github.com/apache/incubator-eventmesh/releases/download/v1.4.0/apache-eventmesh-1.4.0-incubating-bin.tar.gz
-
-tar -xvzf apache-eventmesh-1.4.0-incubating-bin.tar.gz
-```
-
-Edit the `eventmesh.properties` to change the configuration (e.g. TCP port, client blacklist) of EventMesh Runtime. The executable binaries contain all plugins in the bundle, thus there's no need to build them from source code.
-
-```console
-cd apache-eventmesh-1.4.0-incubating
-vim conf/eventmesh.properties
-```
-
-Execute the `start.sh` script to start the EventMesh Runtime server.
-
-```console
-bash bin/start.sh
-```
-
-## Build from Source Code
-
-Gradle is the build automation tool used by Apache EventMesh (Incubating). Please refer to the [offical guide](https://docs.gradle.org/current/userguide/installation.html) to install the latest release of Gradle.
-
-Download and extract the source code of the latest release (v1.4.0) from [GitHub releases](https://github.com/apache/incubator-eventmesh/releases).
-
-```console
-wget https://github.com/apache/incubator-eventmesh/archive/refs/tags/v1.4.0.tar.gz
-
-tar -xvzf v1.4.0.tar.gz
-```
-
-Build the source code with Gradle.
-
-```console
-cd incubator-eventmesh-1.4.0
-gradle clean build
-```
-
-Edit the `eventmesh.properties` to change the configuration (e.g. TCP port, client blacklist) of EventMesh Runtime.
-
-```console
-cd dist
-vim conf/eventmesh.properties
-```
-
-Execute the `start.sh` script to start the EventMesh Runtime server.
-
-```console
-bash bin/start.sh
-```
-
-### Build and Load Plugins
-
-Apache EventMesh (Incubating) introduces the SPI (Service Provider Interface) mechanism, which enables EventMesh to discover and load the plugins at runtime. The plugins could be installed with these methods:
-
-- Gradle Dependencies: Declare the plugins as the build dependencies in `eventmesh-starter/build.gradle`.
-
-```gradle
-dependencies {
- implementation project(":eventmesh-runtime")
-
- // Example: Load the RocketMQ plugin
- implementation project(":eventmesh-connector-plugin:eventmesh-connector-rocketmq")
-}
-```
-
-- Plugin directory: EventMesh loads the plugins in the `dist/plugin` directory based on `eventmesh.properties`. The `installPlugin` task of Gradle builds and moves the plugins into the `dist/plugin` directory.
-
-```console
-gradle installPlugin
-```
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/installation/02-runtime-with-docker.md b/i18n/zh/docusaurus-plugin-content-docs/current/installation/02-runtime-with-docker.md
deleted file mode 100644
index 6e648777..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/installation/02-runtime-with-docker.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# EventMesh Runtime (Docker)
-
-The documentation introduces the steps to install the latest release of EventMesh Runtime with Docker and connect to Apache RocketMQ. It's recommended to use a Linux-based system with [Docker Engine](https://docs.docker.com/engine/install/). Please follow the [Docker tutorial](https://docs.docker.com/get-started/) to get familiar with the basic concepts (registry, volume, etc.) and commands of Docker.
-
-## Pull EventMesh Image
-
-Download the pre-built image of [`eventmesh`](https://hub.docker.com/r/eventmesh/eventmesh) from Docker Hub with `docker pull`:
-
-```console
-$ sudo docker pull eventmesh/eventmesh:v1.4.0
-v1.4.0: Pulling from eventmesh/eventmesh
-2d473b07cdd5: Pull complete
-2b97b2e51c1a: Pull complete
-ccef593d4fe7: Pull complete
-70beb7ae51cd: Pull complete
-0a2cf32321af: Pull complete
-5d764ea8950d: Pull complete
-d97f44e8825f: Pull complete
-Digest: sha256:0edc758be313c61758c1b598ef3315e3b6f707b127ad649063caf67d8876cc45
-Status: Downloaded newer image for eventmesh/eventmesh:v1.4.0
-docker.io/eventmesh/eventmesh:v1.4.0
-```
-
-To verify that the `eventmesh/eventmesh` image is successfully installed, list the downloaded images with `docker images`:
-
-```console
-$ sudo docker images
-eventmesh/eventmesh v1.4.0 6e2964599c78 2 weeks ago 937MB
-```
-
-## Edit Configuration
-
-Edit the `eventmesh.properties` to change the configuration (e.g. TCP port, client blacklist) of EventMesh Runtime. To integrate RocketMQ as a connector, these two configuration files should be created: `eventmesh.properties` and `rocketmq-client.properties`.
-
-```shell
-sudo mkdir -p /data/eventmesh/rocketmq/conf
-cd /data/eventmesh/rocketmq/conf
-sudo touch eventmesh.properties
-sudo touch rocketmq-client.properties
-```
-
-### `eventmesh.properties`
-
-The `eventmesh.properties` file contains the properties of EventMesh runtime environment and integrated plugins. Please refer to the [default configuration file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-runtime/conf/eventmesh.properties) for the available configuration keys.
-
-```shell
-sudo vim eventmesh.properties
-```
-
-| Configuration Key | Default Value | Description |
-|-|-|-|
-| `eventMesh.server.http.port` | 10105 | EventMesh HTTP server port |
-| `eventMesh.server.tcp.port` | 10000 | EventMesh TCP server port |
-| `eventMesh.server.grpc.port` | 10205 | EventMesh gRPC server port |
-
-### `rocketmq-client.properties`
-
-The `rocketmq-client.properties` file contains the properties of the Apache RocketMQ nameserver.
-
-```shell
-sudo vim rocketmq-client.properties
-```
-
-Please refer to the [default configuration file](https://github.com/apache/incubator-eventmesh/blob/1.3.0/eventmesh-runtime/conf/rocketmq-client.properties) and change the value of `eventMesh.server.rocketmq.namesrvAddr` to the nameserver address of RocketMQ.
-
-| Configuration Key | Default Value | Description |
-|-|-|-|
-| `eventMesh.server.rocketmq.namesrvAddr` | `127.0.0.1:9876;127.0.0.1:9876` | The address of RocketMQ nameserver |
-
-## Run and Manage EventMesh Container
-
-Run an EventMesh container from the `eventmesh/eventmesh` image with the `docker run` command. The `-p` option of the command binds the container port with the host machine port. The `-v` option of the command mounts the configuration files from files in the host machine.
-
-```shell
-sudo docker run -d -p 10000:10000 -p 10105:10105 \
--v /data/eventmesh/rocketmq/conf/eventmesh.properties:/data/app/eventmesh/conf/eventmesh.properties \
--v /data/eventmesh/rocketmq/conf/rocketmq-client.properties:/data/app/eventmesh/conf/rocketmq-client.properties \
-eventmesh/eventmesh:v1.4.0
-```
-
-The `docker ps` command lists the details (id, name, status, etc.) of the running containers. The container id is the unique identifier of the container.
-
-```console
-$ sudo docker ps
-CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
-<container_id> eventmesh/eventmesh:v1.4.0 "/bin/sh -c 'sh star…" About a minute ago Up About a minute 0.0.0.0:10000->10000/tcp, :::10000->10000/tcp, 0.0.0.0:10105->10105/tcp, :::10105->10105/tcp <container_name>
-```
-
-To connect to the EventMesh container:
-
-```shell
-sudo docker exec -it [container id or name] /bin/bash
-```
-
-To read the log of the EventMesh container:
-
-```shell
-tail -f ../logs/eventmesh.out
-```
-
-To stop or remove the container:
-
-```shell
-sudo docker stop [container id or name]
-
-sudo docker rm -f [container id or name]
-```
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/installation/03-store.md b/i18n/zh/docusaurus-plugin-content-docs/current/installation/03-store.md
deleted file mode 100644
index 56aea406..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/installation/03-store.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# EventMesh Store
-
-:::caution
-The documentation of EventMesh Store is WIP (Work-in-Progress).
-:::
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/installation/_category_.json b/i18n/zh/docusaurus-plugin-content-docs/current/installation/_category_.json
deleted file mode 100644
index 690c6eb2..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/installation/_category_.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
- "position": 2,
- "label": "Installation and Deployment",
- "collapsed": false
-}
diff --git a/zh/docs/instruction/00-eclipse.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/00-eclipse.md
similarity index 100%
rename from zh/docs/instruction/00-eclipse.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/00-eclipse.md
diff --git a/zh/docs/instruction/01-store-with-docker.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/01-store-with-docker.md
similarity index 100%
rename from zh/docs/instruction/01-store-with-docker.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/01-store-with-docker.md
diff --git a/zh/docs/instruction/01-store.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/01-store.md
similarity index 100%
rename from zh/docs/instruction/01-store.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/01-store.md
diff --git a/zh/docs/instruction/02-runtime-with-docker.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/02-runtime-with-docker.md
similarity index 100%
rename from zh/docs/instruction/02-runtime-with-docker.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/02-runtime-with-docker.md
diff --git a/zh/docs/instruction/02-runtime.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/02-runtime.md
similarity index 100%
rename from zh/docs/instruction/02-runtime.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/02-runtime.md
diff --git a/zh/docs/instruction/03-demo.md b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/03-demo.md
similarity index 100%
rename from zh/docs/instruction/03-demo.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/03-demo.md
diff --git a/zh/docs/instruction/_category_.json b/i18n/zh/docusaurus-plugin-content-docs/current/instruction/_category_.json
similarity index 100%
rename from zh/docs/instruction/_category_.json
rename to i18n/zh/docusaurus-plugin-content-docs/current/instruction/_category_.json
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/introduction.md b/i18n/zh/docusaurus-plugin-content-docs/current/introduction.md
index 4bb804dd..43c821dd 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/introduction.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/introduction.md
@@ -1,46 +1,49 @@
----
-sidebar_position: 0
----
+# Apache EventMesh (Incubating)
-# Introduction to EventMesh
+[](https://github.com/apache/incubator-eventmesh/actions/workflows/ci.yml)
+[](https://codecov.io/gh/apache/incubator-eventmesh)
+[](https://lgtm.com/projects/g/apache/incubator-eventmesh/context:java)
+[](https://lgtm.com/projects/g/apache/incubator-eventmesh/alerts/)
+[](https://github.com/apache/incubator-eventmesh/releases)
+[](https://www.apache.org/licenses/LICENSE-2.0.html)
-[](https://github.com/apache/incubator-eventmesh/actions/workflows/ci.yml)
-[](https://codecov.io/gh/apache/incubator-eventmesh)
-[](https://lgtm.com/projects/g/apache/incubator-eventmesh/context:java)
-[](https://lgtm.com/projects/g/apache/incubator-eventmesh/alerts/)
-[](https://www.apache.org/licenses/LICENSE-2.0.html)
-[](https://github.com/apache/incubator-eventmesh/releases)
-[](https://join.slack.com/t/apacheeventmesh/shared_invite/zt-16y1n77va-q~JepYy3RqpkygDYmQaQbw)
+## 什么是Event Mesh？
-**Apache EventMesh (Incubating)** is a dynamic event-driven application runtime used to decouple the application and backend middleware layer, which supports a wide range of use cases that encompass complex multi-cloud, widely distributed topologies using diverse technology stacks.
+EventMesh是一个动态的云原生事件驱动架构基础设施，用于分离应用程序和后端中间件层，它支持广泛的用例，包括复杂的混合云、使用了不同技术栈的分布式架构。
-## What is EventMesh
+
-[EventMesh](https://solace.com/what-is-an-event-mesh) is an architecture layer that provides dynamic distribution of events, thus event consumers could receive events from any event producer, no matter where the producer and consumer are attached to the mesh, without the need for configuration of event routing. It is enabled by a network of interconnected [event brokers](https://solace.com/what-is-an-event-broker/) and bridges applications and services in an [event-driven architecture](h [...]
+**EventMesh架构：**
-## Features
+
-- **Communication Protocol**: EventMesh could communicate with clients with TCP, HTTP, or gRPC.
-- **CloudEvents**: EventMesh supports the [CloudEvents](https://cloudevents.io) specification as the format of the events. CloudEvents is a specification for describing event data in common formats to provide interoperability across services, platforms, and systems.
-- **Schema Registry**: EventMesh implements a schema registry that receives and stores schemas from clients and provides an interface for other clients to retrieve schemas.
-- **Observability**: EventMesh exposed a range of metrics, such as the average latency of the HTTP protocol and the number of delivered messages. The metrics could be collected and analyzed with Prometheus or OpenTelemetry.
-- **Event Workflow Orchestration**: EventMesh Workflow could receive an event and decide which command to trigger next based on the workflow definitions and the current workflow state. The workflow definition could be written with the [Serverless Workflow](https://serverlessworkflow.io) DSL.
+**EventMesh云原生结构：**
-## Components
+
-Apache EventMesh (Incubating) consists of multiple components that integrate different middlewares and messaging protocols to enhance the functionalities of the application runtime.
+Event Mesh允许将来自一个应用程序的事件动态路由到任何其他应用程序. Event Mesh的一般功能:
-- **eventmesh-runtime**: The middleware that transmits events between producers and consumers, which supports cloud-native apps and microservices.
-- **eventmesh-sdk-java**: The Java SDK that supports HTTP, HTTPS, TCP, and [gRPC](https://grpc.io) protocols.
-- **eventmesh-connector-plugin**: The collection of plugins that connects middlewares such as [Apache Kafka](https://kafka.apache.org), [Apache RocketMQ](https://rocketmq.apache.org), [Apache Pulsar](https://pulsar.apache.org/), and [Redis](https://redis.io).
-- **eventmesh-registry-plugin**: The collection of plugins that integrate service registries such as [Nacos](https://nacos.io) and [etcd](https://etcd.io).
-- **eventmesh-security-plugin**: The collection of plugins that implement security mechanisms, such as ACL (access control list), authentication, and authorization.
-- **eventmesh-protocol-plugin**: The collection of plugins that implement messaging protocols, such as [CloudEvents](https://cloudevents.io) and [MQTT](https://mqtt.org).
-- **eventmesh-admin**: The control plane that manages clients, topics, and subscriptions.
+* 事件驱动;
+* 事件治理;
+* 动态路由;
+* 云原生
-## Contributors
+部件：
-Each contributor has played an important role in promoting the robust development of Apache EventMesh (Incubating). We sincerely appreciate all contributors who have contributed code and documents. The following is the list of contributors in EventMesh-related repositories.
+* eventmesh-runtime：一种中间件，用于在事件生产者和消费者之间传输事件，支持云原生应用程序和微服务
+* eventmesh-sdk-java：当前支持HTTP、HHTTP、TCP和 [gRPC](https://grpc.io) 协议
+
+
+## 快速开始
+
+1. 构建并部署 event-store(RocketMQ), 请参见[说明](instruction/01-store.md)
+2. 构建并部署 eventmesh-runtime，请参见[说明](instruction/02-runtime.md)
+3. 运行 eventmesh-sdk-java 演示，请参见[说明](instruction/03-demo.md)
+
+## 贡献
+
+永远欢迎参与共建, 请参阅[贡献](../../03-new-contributor-guidelines.md)了解详细指南
+
+您可以从发现和解决问题开始～
+[GitHub Issues](https://github.com/apache/incubator-eventmesh/issues)
-- [apache/incubator-eventmesh](https://github.com/apache/incubator-eventmesh/graphs/contributors)
-- [apache/incubator-eventmesh-site](https://github.com/apache/incubator-eventmesh-site/graphs/contributors)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/01-prometheus.md b/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/01-prometheus.md
deleted file mode 100644
index 1bc6e0e5..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/01-prometheus.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# Observe Metrics with Prometheus
-
-## Prometheus
-
-[Prometheus](https://prometheus.io/docs/introduction/overview/) is an open-source system monitoring and alerting toolkit that collects and stores the metrics as time-series data. EventMesh exposes a collection of metrics data that could be scraped and analyzed by Prometheus. Please follow [the "First steps with Prometheus" tutorial](https://prometheus.io/docs/introduction/first_steps/) to download and install the latest release of Prometheus.
-
-## Edit Prometheus Configuration
-
-The `eventmesh-runtime/conf/prometheus.yml` configuration file specifies the port of the metrics HTTP endpoint. The default metrics port is `19090`.
-
-```properties
-eventMesh.metrics.prometheus.port=19090
-```
-
-Please refer to [the Prometheus configuration guide](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) to add the EventMesh metrics as a scrape target in the configuration file. Here's the minimum configuration that creates a job with the name `eventmesh` and the endpoint `http://localhost:19090`:
-
-```yaml
-scrape_configs:
- - job_name: "eventmesh"
- static_configs:
- - targets: ["localhost:19090"]
-```
-
-Please navigate to the Prometheus dashboard (e.g. `http://localhost:9090`) to view the list of metrics exported by EventMesh, which are prefixed with `eventmesh_`.
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/02-zipkin.md b/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/02-zipkin.md
deleted file mode 100644
index f4d07252..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/02-zipkin.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Collect Trace with Zipkin
-
-## Zipkin
-
-Distributed tracing is a method used to profile and monitor applications built with microservices architecture. Distributed tracing helps pinpoint where failures occur and what causes poor performance.
-
-[Zipkin](https://zipkin.io) is a distributed tracing system that helps collect timing data needed to troubleshoot latency problems in service architectures. EventMesh exposes a collection of trace data that could be collected and analyzed by Zipkin. Please follow [the "Zipkin Quickstart" tutorial](https://zipkin.io/pages/quickstart.html) to download and install the latest release of Zipkin.
-
-## Configuration
-
-To enable the trace exporter of EventMesh Runtime, set the `eventMesh.server.trace.enabled` field in the `conf/eventmesh.properties` file to `true`.
-
-```conf
-# Trace plugin
-eventMesh.server.trace.enabled=true
-eventMesh.trace.plugin=zipkin
-```
-
-To customize the behavior of the trace exporter such as timeout or export interval, edit the `exporter.properties` file.
-
-```conf
-# Set the maximum batch size to use
-eventmesh.trace.max.export.size=512
-# Set the queue size. This must be >= the export batch size
-eventmesh.trace.max.queue.size=2048
-# Set the max amount of time an export can run before getting(TimeUnit=SECONDS)
-eventmesh.trace.export.timeout=30
-# Set time between two different exports (TimeUnit=SECONDS)
-eventmesh.trace.export.interval=5
-```
-
-To send the exported trace data to Zipkin, edit the `eventmesh.trace.zipkin.ip` and `eventmesh.trace.zipkin.port` fields in the `conf/zipkin.properties` file to match the configuration of the Zipkin server.
-
-```conf
-# Zipkin's IP and Port
-eventmesh.trace.zipkin.ip=localhost
-eventmesh.trace.zipkin.port=9411
-```
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/_category_.json b/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/_category_.json
deleted file mode 100644
index 72c4414d..00000000
--- a/i18n/zh/docusaurus-plugin-content-docs/current/metrics-tracing/_category_.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
- "position": 4,
- "label": "Metrics and Tracing",
- "collapsed": false
-}
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/roadmap.md b/i18n/zh/docusaurus-plugin-content-docs/current/roadmap.md
index e890da3f..a3d7695c 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/roadmap.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/roadmap.md
@@ -2,26 +2,46 @@
sidebar_position: 1
---
-# Development Roadmap
+# EventMesh产品路线图
-The development roadmap of Apache EventMesh (Incubating) is an overview of the planned features and milestones involved in the next several releases. The recent features and bug fixes are documented in the [release notes](https://eventmesh.apache.org/events/release-notes/v1.4.0). The order of the features listed below doesn't correspond to their priorities.
+下表列出了EventMesh的新特性和bug修复情况，详情请参考 [release notes](https://eventmesh.apache.org/events/release-notes/v1.4.0).
## List of Features and Milestones
-| Status | Description | Reference |
-| --- | --- | --- |
-| **Implemented** | gRPC Integration | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Event Governance for Choreography | [GitHub Issue](https://github.com/apache/incubator-eventmesh/blob/master/docs/en/features/eventmesh-workflow-design.md) |
-| Planned | Knative Eventing Infrastructure | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/790), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-463) |
-| Planned | Dashboard | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/700), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-465) |
-| Planned | Event Streaming | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
-| Planned | Federated Connector | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/577) |
-| Planned | Transaction Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/697) |
-| Planned | Event Query Language (EQL)| [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/778) |
-| Planned | Metadata consistency persistent| [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/817) |
-| Planned | Go SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/762) |
-| Planned | Rust SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/815) |
-| Planned | WebAssembly Runtime| [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/576) |
-| Planned | Filter Chain | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/664) |
-| Planned | Kafka-based EventStore| [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/199) |
-| Planned | Redis-based EventStore| [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/389) |
+| Status | Description | Reference |
+|-------------------------------------------|---------------------------------| --- |
+| **Implemented in 1.0.0** | Support HTTP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.0.0** | Support TCP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.0.0** | Support Pub/Sub Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.1.1** | Provide Java SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.1.1** | Support HTTPS | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.2.0** | Support RocketMQ as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.2.0** | Support Heartbeat | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenSchema | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Integrate with OpenTelemetry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.3.0** | Support CloudEvents | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.4.0** | Support gRPC | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Provide Golang SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Nacos Registry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.5.0** | Support Federal Government | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Integrate with Consul | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Support Webhook | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **Implemented in 1.6.0 (to be released)** | Support etcd | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Knative Eventing Infrastructure | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/790), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-463) |
+| **In Progress** | Dashboard | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/700), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-465) |
+| **In Progress** | Support Kafka as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
+| **In Progress** | Support Pulsar as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
+| **In Progress** | Support Dledger | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Workflow | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Redis | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| **In Progress** | Support Zookeeper | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| Planned | Provide NodeJS SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
+| Planned | Transaction Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/697) |
+| Planned | Event Query Language (EQL) | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/778) |
+| Planned | Metadata consistency persistent | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/817) |
+| Planned | Rust SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/815) |
+| Planned | WebAssembly Runtime | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/576) |
+| Planned | Filter Chain | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/664) |
+
diff --git a/zh/docs/sdk-java/01-intro.md b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/01-intro.md
similarity index 100%
rename from zh/docs/sdk-java/01-intro.md
rename to i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/01-intro.md
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/02-http.md b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/02-http.md
index eb71cb5f..9a8acd0d 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/02-http.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/02-http.md
@@ -1,6 +1,6 @@
-# HTTP Protocol
+# HTTP 协议
-EventMesh SDK for Java implements the HTTP producer and consumer of asynchronous messages. Both the producer and consumer require an instance of `EventMeshHttpClientConfig` class that specifies the configuration of EventMesh HTTP client. The `liteEventMeshAddr`, `userName`, and `password` fields should match the `eventmesh.properties` file of EventMesh runtime.
+EventMesh Java SDK 实现了 HTTP 异步消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh HTTP 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
```java
import org.apache.eventmesh.client.http.conf.EventMeshHttpClientConfig;
@@ -25,9 +25,9 @@ public class HTTP {
}
```
-## HTTP Consumer
+## HTTP 消费者
-The `EventMeshHttpConsumer` class implements the `heartbeat`, `subscribe`, and `unsubscribe` methods. The `subscribe` method accepts a list of `SubscriptionItem` that defines the topics to be subscribed and a callback URL.
+类 `EventMeshHttpConsumer` 实现了 `heartbeat`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题和回调的 URL 地址。
```java
import org.apache.eventmesh.client.http.consumer.EventMeshHttpConsumer;
@@ -53,11 +53,11 @@ public class HTTP {
}
```
-The EventMesh runtime will send a POST request that contains the message in the [CloudEvents format](https://github.com/cloudevents/spec) to the callback URL. The [`SubController.java` file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/http/demo/sub/controller/SubController.java) implements a Spring Boot controller that receives and parses the callback messages.
+EventMesh runtime 将发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 信息的 POST 请求到这个回调的 URL 地址。类 [SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/http/demo/sub/controller/SubController.java) 实现了 Spring Boot controller，它将接收并解析回调信息。
-## HTTP Producer
+## HTTP 生产者
-The `EventMeshHttpProducer` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value. The message should be an instance of either of these classes:
+类 `EventMeshHttpProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
- `org.apache.eventmesh.common.EventMeshMessage`
- `io.cloudevents.CloudEvent`
@@ -92,3 +92,27 @@ public class HTTP {
}
}
```
+
+## 使用Curl 命令
+
+本段落介绍通过Curl命令体验事件的收发功能
+
+### 事件发送
+
+启动EventMesh Runtime服务后，可以使用Curl命令将事件用HTTP POST方法发布到指定的主题，Body内容必须是JSON格式，执行命令示例如下:
+
+```shell
+curl -H "Content-Type:application/json" -X POST -d '{"name": "admin", "pass":"12345678"}' http://127.0.0.1:10105/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC
+```
+
+
+
+### 事件订阅
+
+启动EventMesh Runtime服务后，可以使用Curl命令用HTTP POST方法订阅指定的主题列表，Body内容必须是JSON格式，执行命令示例如下:
+
+```shell
+curl -H "Content-Type:application/json" -X POST -d '{"url": "http://127.0.0.1:8088/sub/test", "consumerGroup":"TEST-GROUP", "topic":[{"mode":"CLUSTERING","topic":"TEST-TOPIC-HTTP-ASYNC","type":"ASYNC"}]}' http://127.0.0.1:10105/eventmesh/subscribe/local
+```
+
+你可以在项目`eventmesh-examples`模块中看到这个例子。
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/03-tcp.md b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/03-tcp.md
index be6f9e31..54f5eca5 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/03-tcp.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/03-tcp.md
@@ -1,6 +1,6 @@
-# TCP Protocol
+# TCP 协议
-EventMesh SDK for Java implements the TCP producer and consumer of synchronous, asynchronous, and broadcast messages. Both the producer and consumer require an instance of `EventMeshTCPClientConfig` class that specifies the configuration of EventMesh gRPC client. The `host` and `port` fields should match the `eventmesh.properties` file of EventMesh runtime.
+EventMesh Java SDK 实现了同步、异步和广播 TCP 消息的生产者和消费者。 二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh TCP 客户端的配置信息。其中的 `host` 和 `port` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
```java
import org.apache.eventmesh.client.tcp.conf.EventMeshTCPClientConfig;
@@ -19,9 +19,9 @@ public class AsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
}
```
-## TCP Consumer
+## TCP 消费者
-The consumer should implement the `ReceiveMsgHook` class, which is defined in [`ReceiveMsgHook.java`](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/tcp/common/ReceiveMsgHook.java).
+消费者应该实现 `ReceiveMsgHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/tcp/common/ReceiveMsgHook.java)。
```java
public interface ReceiveMsgHook<ProtocolMessage> {
@@ -29,7 +29,7 @@ public interface ReceiveMsgHook<ProtocolMessage> {
}
```
-The `EventMeshTCPClient` class implements the `subscribe` method. The `subscribe` method accepts the topic, the `SubscriptionMode`, and the `SubscriptionType`. The `handle` method will be invoked when the consumer receives a message from the topic it subscribes. If the `SubscriptionType` is `SYNC`, the return value of `handle` will be sent back to the producer.
+类 `EventMeshTCPClient` 实现了 `subscribe` 方法。该方法接收话题、`SubscriptionMode` 和 `SubscriptionType`。`handle` 方法将会在消费者从订阅的话题中收到消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
```java
import org.apache.eventmesh.client.tcp.EventMeshTCPClient;
@@ -68,11 +68,11 @@ public class TCPConsumer implements ReceiveMsgHook<CloudEvent> {
}
```
-## TCP Producer
+## TCP 生产者
-### Asynchronous Producer
+### 异步生产者
-The `EventMeshTCPClient` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value and returns the response message from the consumer.
+类 `EventMeshTCPClient` 实现了 `public` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
```java
/* ... */
@@ -91,9 +91,9 @@ CloudEvent event = CloudEventBuilder.v1()
client.publish(event, 1000);
```
-### Synchronous Producer
+### 同步生产者
-The `EventMeshTCPClient` class implements the `rr` method. The `rr` method accepts the message to be published and an optional timeout value and returns the response message from the consumer.
+类 `EventMeshTCPClient` 实现了 `rr` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
```java
/* ... */
@@ -115,4 +115,4 @@ CloudEvent replyEvent = EventFormatProvider
.getInstance()
.resolveFormat(JsonFormat.CONTENT_TYPE)
.deserialize(response.getBody().toString().getBytes(StandardCharsets.UTF_8));
-```
+```
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/04-grpc.md b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/04-grpc.md
index 81f03a8d..b0781870 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/04-grpc.md
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/04-grpc.md
@@ -1,6 +1,6 @@
-# gRPC Protocol
+# gRPC 协议
-EventMesh SDK for Java implements the gRPC producer and consumer of synchronous, asynchronous, and broadcast messages. Both the producer and consumer require an instance of `EventMeshGrpcClientConfig` class that specifies the configuration of EventMesh gRPC client. The `liteEventMeshAddr`, `userName`, and `password` fields should match the `eventmesh.properties` file of EventMesh runtime.
+EventMesh Java SDK 实现了 gRPC 同步、异步和广播消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh gRPC 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
```java
import org.apache.eventmesh.client.grpc.config.EventMeshGrpcClientConfig;
@@ -20,11 +20,11 @@ public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
}
```
-## gRPC Consumer
+## gRPC 消费者
-### Stream Consumer
+### 流消费者
-The EventMesh runtime sends the message from producers to the stream consumer as a series of event streams. The consumer should implement the `ReceiveMsgHook` class, which is defined in [`ReceiveMsgHook.java`](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/consumer/ReceiveMsgHook.java).
+EventMesh runtime 会将来自生产者的信息作为一系列事件流向流消费者发送。消费者应实现 `ReceiveHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/consumer/ReceiveMsgHook.java)。
```java
public interface ReceiveMsgHook<T> {
@@ -33,7 +33,7 @@ public interface ReceiveMsgHook<T> {
}
```
-The `EventMeshGrpcConsumer` class implements the `registerListener`, `subscribe`, and `unsubscribe` methods. The `subscribe` method accepts a list of `SubscriptionItem` that defines the topics to be subscribed to. The `registerListener` accepts an instance of a class that implements the `ReceiveMsgHook`. The `handle` method will be invoked when the consumer receives a message from the topic it subscribes. If the `SubscriptionType` is `SYNC`, the return value of `handle` will be sent back [...]
+类 `EventMeshGrpcConsumer` 实现了 `registerListener`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题。`registerListener` 接收一个实现了 `ReceiveMsgHook` 的实例。`handle` 方法将会在消费者收到订阅的主题消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
```java
import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
@@ -75,9 +75,9 @@ public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
}
```
-### Webhook Consumer
+### Webhook 消费者
-The `subscribe` method of the `EventMeshGrpcConsumer` class accepts a list of `SubscriptionItem` that defines the topics to be subscribed and an optional callback URL. If the callback URL is provided, the EventMesh runtime will send a POST request that contains the message in the [CloudEvents format](https://github.com/cloudevents/spec) to the callback URL. The [`SubController.java` file](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apach [...]
+类 `EventMeshGrpcConsumer` 的 `subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的主题和一个可选的 timeout 值。如果提供了回调 URL，EventMesh runtime 将向回调 URL 地址发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 消息的 POST 请求。[SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/grpc/sub/app/controller/SubController.java) 实现了一个接收并解析回调信息的 Spring Boot controller。
```java
import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
@@ -109,11 +109,11 @@ public class SubService implements InitializingBean {
}
```
-## gRPC Producer
+## gRPC 生产者
-### Asynchronous Producer
+### 异步生产者
-The `EventMeshGrpcProducer` class implements the `publish` method. The `publish` method accepts the message to be published and an optional timeout value. The message should be an instance of either of these classes:
+类 `EventMeshGrpcProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
- `org.apache.eventmesh.common.EventMeshMessage`
- `io.cloudevents.CloudEvent`
@@ -138,16 +138,16 @@ CloudEvent event = CloudEventBuilder.v1()
eventMeshGrpcProducer.publish(event);
```
-### Synchronous Producer
+### 同步生产者
-The `EventMeshGrpcProducer` class implements the `requestReply` method. The `requestReply` method accepts the message to be published and an optional timeout value. The method returns the message returned from the consumer. The message should be an instance of either of these classes:
+类 `EventMeshGrpcProducer` 实现了 `requestReply` 方法。`requestReply` 方法接收将被发布的消息和一个可选的 timeout 值。方法会返回消费者返回的消息。消息应是下列类的一个实例：
- `org.apache.eventmesh.common.EventMeshMessage`
- `io.cloudevents.CloudEvent`
-### Batch Producer
+### 批量生产者
-The `EventMeshGrpcProducer` class overloads the `publish` method, which accepts a list of messages to be published and an optional timeout value. The messages in the list should be an instance of either of these classes:
+类 `EventMeshGrpcProducer` 重写了 `publish` 方法，该方法接收一个将被发布的消息列表和一个可选的 timeout 值。列表中的消息应是下列类的一个实例：
- `org.apache.eventmesh.common.EventMeshMessage`
- `io.cloudevents.CloudEvent`
@@ -171,4 +171,4 @@ for (int i = 0; i < 5; i++) {
eventMeshGrpcProducer.publish(cloudEventList);
/* ... */
-```
+```
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/_category_.json b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/_category_.json
index e93d4cdd..9d0a27c5 100644
--- a/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/_category_.json
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/sdk-java/_category_.json
@@ -1,5 +1,4 @@
{
- "position": 3,
"label": "EventMesh SDK for Java",
"collapsed": false
}
diff --git a/zh/docs/contribute/01-release.md b/zh/docs/contribute/01-release.md
deleted file mode 100644
index 0810a757..00000000
--- a/zh/docs/contribute/01-release.md
+++ /dev/null
@@ -1,731 +0,0 @@
-# Release Creation Process
-
-:::caution
-The documentation of Release Creation Process is WIP (Work-in-Progress).
-:::
-
-## 理解 Apache 发布的内容和流程
-
-Source Release 是 Apache 关注的重点，也是发布的必须内容；而 Binary Release 是可选项，
-
-请参考以下链接，找到更多关于 ASF 的发布指南:
-
-- [Apache Release Guide](http://www.apache.org/dev/release-publishing)
-- [Apache Release Policy](http://www.apache.org/dev/release.html)
-- [Maven Release Info](http://www.apache.org/dev/publishing-maven-artifacts.html)
-
-
-## 本地构建环境准备
-
-主要包括签名工具、Maven 仓库认证相关准备
-
-### 1.安装GPG
-
-在[GnuPG官网](https://www.gnupg.org/download/index.html)下载安装包。GnuPG的1.x版本和2.x版本的命令有细微差别，下列说明以**GnuPG-2.x**版本为例
-
-```sh
-$ gpg --version #检查版本，应该为2.x
-```
-
-### 2.用gpg生成key
-
-根据提示，生成 key
-
-> 注意：请使用Apache邮箱生成GPG的Key
-
-```shell
-$ gpg --full-gen-key
-gpg (GnuPG) 2.0.12; Copyright (C) 2009 Free Software Foundation, Inc.
-This is free software: you are free to change and redistribute it.
-There is NO WARRANTY, to the extent permitted by law.
-
-Please select what kind of key you want:
- (1) RSA and RSA (default)
- (2) DSA and Elgamal
- (3) DSA (sign only)
- (4) RSA (sign only)
-Your selection? 1
-RSA keys may be between 1024 and 4096 bits long.
-What keysize do you want? (2048) 4096
-Requested keysize is 4096 bits
-Please specify how long the key should be valid.
- 0 = key does not expire
- <n> = key expires in n days
- <n>w = key expires in n weeks
- <n>m = key expires in n months
- <n>y = key expires in n years
-Key is valid for? (0)
-Key does not expire at all
-Is this correct? (y/N) y
-
-GnuPG needs to construct a user ID to identify your key.
-
-Real name: ${输入用户名}
-Email address: ${邮箱地址}
-Comment: CODE SIGNING KEY
-You selected this USER-ID:
- "${输入用户名} (CODE SIGNING KEY) <${邮箱地址}>"
-
-Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
-You need a Passphrase to protect your secret key. # 填入密码，以后打包过程中会经常用到
-```
-
-### 3.查看 key
-
-```shell
-$ gpg --list-keys
-pub rsa4096/579C25F5 2021-04-26 # 579C25F5就是key id
-uid [ultimate] ${输入用户名} <${邮箱地址}>
-sub rsa4096 2021-04-26
-
-# 通过key id发送public key到keyserver
-$ gpg --keyserver pgpkeys.mit.edu --send-key 579C25F5
-# 其中，pgpkeys.mit.edu为随意挑选的keyserver，keyserver列表为：https://sks-keyservers.net/status/，相互之间是自动同步的，选任意一个都可以。
-$ gpg --keyserver hkp://pgpkeys.mit.edu --recv-keys 579C25F5 # 验证是否同步到公网，网络不好可能需多试几次
-```
-
-**注：如果有多个 public key，设置默认 key。**修改`~/.gnupg/gpg.conf`
-
-```sh
-# If you have more than 1 secret key in your keyring, you may want to
-# uncomment the following option and set your preferred keyid.
-default-key 28681CB1
-```
-
-**如果有多个 public key, 也可以删除无用的 key：**
-
-```shell
-$ gpg --delete-secret-keys 29BBC3CB # 先删除私钥，指明key id
-gpg (GnuPG) 2.2.27; Copyright (C) 2021 g10 Code GmbH
-This is free software: you are free to change and redistribute it.
-There is NO WARRANTY, to the extent permitted by law.
-
-sec rsa4096/EE8DAE7D29BBC3CB 2021-04-27 mikexue <mi...@apache.org>
-
-Delete this key from the keyring? (y/N) y
-This is a secret key! - really delete? (y/N) y
-```
-
-```shell
-$ gpg --delete-keys 29BBC3CB # 删除公钥，指明key id
-gpg (GnuPG) 2.2.27; Copyright (C) 2021 g10 Code GmbH
-This is free software: you are free to change and redistribute it.
-There is NO WARRANTY, to the extent permitted by law.
-
-
-pub rsa4096/EE8DAE7D29BBC3CB 2021-04-27 mikexue <mi...@apache.org>
-
-Delete this key from the keyring? (y/N) y
-```
-
-由于公钥服务器没有检查机制，任何人都可以用你的名义上传公钥，所以没有办法保证服务器上的公钥的可靠性。 通常，你可以在网站上公布一个公钥指纹，让其他人核对下载到的公钥是否为真。
-
-```shell
-# fingerprint参数生成公钥指纹：
-$gpg --fingerprint mikexue
-pub rsa4096 2021-04-26 [SCA]
- F84A 0041 D70B 37AF 9C7B F0B3 39F4 29D7 579C 25F5
-uid [ultimate] mikexue <mi...@apache.org>
-sub rsa4096 2021-04-26 [E]
-```
-
-登录 [https://id.apache.org](https://id.apache.org/), 将上面的 fingerprint （即 F84A 0041 D70B 37AF 9C7B F0B3 39F4 29D7 579C 25F5） 粘贴到自己的用户信息中 OpenPGP Public Key Primary Fingerprint
-
-
-
-## 发布Apache Maven仓库
-
-> 注：EventMesh使用Gradle构建，需修改gradle相关配置
-
-### 1.导出私钥文件
-
-```shell
-$ gpg --export-secret-keys -o secring.gpg #私钥文件妥善保管，后面配置需要
-```
-
-### 2.准备分支
-
-从主干分支拉取新分支作为发布分支，如现在要发布$`{release_version}`版本，则从develop分支拉出新分支`${release_version}-release`，此后`${release_version}` Release Candidates涉及的修改及打标签等都在`${release_version}-release`分支进行，最终发布完成后合入主干分支。
-
-### 3.更新版本说明
-
-更新官网项目的如下文件，并提交至master分支：
-
-https://github.com/apache/incubator-eventmesh-site/tree/master/events/release-notes
-
-### 4.配置根项目下gradle.properties文件
-
-```shell
-group=org.apache.eventmesh
-version=1.2.0-release
-#40位公钥的最后8位
-signing.keyId=579C25F5
-#生成密钥时填的passphrase
-signing.password=
-#导出的私钥文件secring.gpg路径
-signing.secretKeyRingFile=../secring.gpg
-#apache 账号
-apacheUserName=
-#apache 密码
-apachePassWord=
-```
-
-### 5.检查子模块下gradle.properties文件
-
-```shell
-group=org.apache.eventmesh
-version=${release_version}
-```
-
-### 6.检查并配置根项目下build.gradle文件
-
-```shell
-publishing {
- publications {
- mavenJava(MavenPublication) {
- from components.java
- artifact packageSources
- artifact packageJavadoc
- versionMapping {
- usage('java-api') {
- fromResolutionOf('runtimeClasspath')
- }
- usage('java-runtime') {
- fromResolutionResult()
- }
- }
- pom {
- name = 'EventMesh'
- description = 'Apache EventMesh'
- url = 'https://github.com/apache/incubator-eventmesh'
- licenses {
- license {
- name = 'The Apache License, Version 2.0'
- url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
- }
- }
- developers {
- developer {
- id = 'Apache EventMesh(incubating)'
- name = 'Apache EventMesh(incubating) of ASF'
- url = 'https://eventmesh.apache.org/'
- }
- }
- scm {
- connection = 'scm:git:git@github.com:apache/incubator-eventmesh.git'
- developerConnection = 'scm:git:git@github.com:apache/incubator-eventmesh.git'
- url = 'https://github.com/apache/incubator-eventmesh'
- }
- }
- }
- }
- repositories {
- maven {
- def releasesRepoUrl = 'https://repository.apache.org/service/local/staging/deploy/maven2/'
- def snapshotsRepoUrl = 'https://repository.apache.org/content/repositories/snapshots/'
- url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
- credentials {
- username apacheUserName
- password apachePassWord
- }
-
- }
- }
-}
-
-signing {
- sign publishing.publications.mavenJava
-}
-```
-
-### 7.上传发布包
-
-执行如下命令，需要对jar、源码包、doc和pom等文件签名加密
-
-```shell
-$ gradle signMavenJavaPublication publish
-```
-
-上述命令执行成功后，待发布版本会自动上传到Apache的临时筹备仓库(staging repository)。所有被deploy到远程[maven仓库](http://repository.apache.org/)的Artifacts都会处于staging状态，访问https://repository.apache.org/#stagingRepositories, 使用Apache的LDAP账户登录后，就会看到上传的版本，`Repository`列的内容即为${STAGING.REPOSITORY}。 点击`Close`来告诉Nexus这个构建已经完成，只有这样该版本才是可用的。 如果电子签名等出现问题，`Close`会失败，可以通过`Activity`查看失败信息。
-
-
-
-## 发布Apache SVN仓库
-
-### 1.准备svn本机环境（Apache使用svn托管项目的发布内容）
-
-### 2.checkout到本地目录
-
-```shell
-$ svn checkout https://dist.apache.org/repos/dist/dev/incubator/eventmesh/
-# 假定本地目录为 ~/apache/eventmesh
-```
-
-### 3.添加gpg公钥
-
-添加public key到[KEYS](https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS)文件并提交到SVN仓库（第一次做发布的人需要做这个操作，具体操作参考KEYS文件里的说明）。KEYS主要是让参与投票的人在本地导入，用来校验sign的正确性
-
-Windows
-
-```sh
-$ gpg --list-sigs <your name> | out-file -append KEYS -encoding utf8
-$ gpg --armor --export <your name> | out-file -append KEYS -encoding utf8
-```
-
-> Mac OS/Linux
-
-```sh
-$ (gpg --list-sigs <your name> && gpg --armor --export <your name>) >> KEYS
-```
-
-### 4.添加待发布内容到SVN目录
-
-```shell
-$ cd ~/apache/eventmesh # eventmesh svn根目录
-$ mkdir ${release_version}-${rc_version}
-```
-
-#### 4.1 创建tag
-
-在`${release_version}-release`分支上创建tag，需带有rc版本，为预发布版本
-
-```shell
-$ git tag -a v{$release_version}-{$rc_version} -m "Tagging the ${release_version} first Release Candidate (Candidates start at zero)"
-$ git push origin --tags
-```
-
-#### 4.2 打包源码
-
-检查项目源码命名，将源码命名为`apache-eventmesh-${release_version}-incubating-src`，将源码打包为tar.gz格式
-
-```shell
-$ tar -czvf apache-eventmesh-${release_version}-incubating-source.tar.gz apache-eventmesh-${release_version}-incubating-src
-```
-
-#### 4.3 打包二进制
-
-> 编译上一步打包的源码
-
-检查编译后的文件命名，将二进制文件命名为`apache-eventmesh-${release_version}-incubating`
-
-> 注：需将源码根目录下的`NOTICE`文件，`DISCLAIMER-WIP`文件以及`tools/third-party-licenses`目录下的`LICENSE`文件拷贝到二进制的包中
-
-```shell
-$ gradle clean jar dist && gradle installPlugin && gradle tar -x test
-$ tar -czvf apache-eventmesh-${release_version}-incubating-bin.tar.gz apache-eventmesh-${release_version}-incubating
-```
-
-压缩source包、bin包，并将相关的压缩包拷贝到svn本地仓库下`/apache/eventmesh/${release_version}-${rc_version}`
-
-### 5.生成签名/sha512文件
-
-> 针对源码包与二进制包生成签名/sha512文件
-
-```shell
-$ for i in *.tar.gz; do echo $i; gpg --print-md SHA512 $i > $i.sha512 ; done #计算sha512
-$ for i in *.tar.gz; do echo $i; gpg --armor --output $i.asc --detach-sig $i ; done #计算签名
-```
-
-### 6.提交到Apache svn
-
-```shell
-$ cd ~/apache/eventmesh # eventmesh svn根目录
-$ svn status
-$ svn commit -m 'prepare for ${release_version}-${rc_version}'
-```
-
-
-
-## 验证Release Candidates
-
-详细检查列表请参考官方的[check list](https://cwiki.apache.org/confluence/display/INCUBATOR/Incubator+Release+Checklist)
-
-从以下地址下载要发布的Release Candidates到本地环境：
-
-```shell
-https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
-```
-
-然后开始验证环节，验证包含但不限于以下内容和形式
-
-### 1.检查签名和hash等信息
-
-> 由于操作系统不同，检查的命令或有差异，具体可参考[官方检查步骤](https://www.apache.org/info/verification.html)
-
-#### 1.1检查sha512哈希
-
-> Mac OS/Linux
-
-```shell
-$ shasum -a apache-eventmesh-${release_version}-incubating-source.tar.gz
-#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-source.tar.gz.sha512文件内容作对比
-$ shasum -a apache-eventmesh-${release_version}-incubating-bin.tar.gz
-#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-bin.tar.gz.sha512文件内容作对比
-```
-
-> Windows
-
-```shell
-$ certUtil -hashfile apache-eventmesh-${release_version}-incubating-source.tar.gz SHA512
-#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-source.tar.gz.sha512文件内容作对比
-$ certUtil -hashfile apache-eventmesh-${release_version}-incubating-bin.tar.gz SHA512
-#并将输出内容与 apache-eventmesh-${release_version}-${rc_version}-incubating-bin.tar.gz.sha512文件内容作对比
-```
-
-#### 1.2检查gpg签名
-
-首先导入发布人公钥。从svn仓库导入KEYS到本地环境。（发布版本的人不需要再导入，帮助做验证的人需要导入，用户名填发版人的即可）
-
-```shell
-$ curl https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS >> KEYS
-$ gpg --import KEYS
-$ gpg --edit-key "${发布人的gpg用户名}"
- > trust
-
-Please decide how far you trust this user to correctly verify other users' keys
-(by looking at passports, checking fingerprints from different sources, etc.)
-
- 1 = I don't know or won't say
- 2 = I do NOT trust
- 3 = I trust marginally
- 4 = I trust fully
- 5 = I trust ultimately
- m = back to the main menu
-
-Your decision? 5
-
- > save
-```
-
-然后使用如下命令检查签名
-
-```shell
-$ gpg --verify apache-eventmesh-${release_version}-incubating-source.tar.gz.asc apache-eventmesh-${release_version}-incubating-source-tar.gz
-$ gpg --verify apache-eventmesh-${release_version}-incubating-bin.tar.gz.asc apache-eventmesh-${release_version}-incubating-bin.tar.gz
-```
-
-### 2.检查源码包的文件内容
-
-解压缩`apache-eventmesh-${release_version}-incubating-source-tar.gz`，进行如下检查:
-
-- 检查源码包是否包含由于包含不必要文件，致使tar包过于庞大
-- 文件夹包含单词`incubating`
-- 存在`LICENSE`和`NOTICE`文件
-- 存在`DISCLAIMER`文件
-- `NOTICE`文件中的年份正确
-- 只存在文本文件，不存在二进制文件
-- 所有文件的开头都有ASF许可证
-- 能够正确编译，单元测试可以通过 (./gradle build) (目前支持JAVA 8/gradle 7.0/idea 2021.1.1及以上)
-- 检查是否有多余文件或文件夹，例如空文件夹等
-
-### 3.检查二进制包的文件内容
-
-- 文件夹包含单词`incubating`
-- 存在`LICENSE`和`NOTICE`文件
-- 存在`DISCLAIMER`文件
-- `NOTICE`文件中的年份正确
-- 所有文本文件开头都有ASF许可证
-- 检查第三方依赖许可证：
- - 第三方依赖的许可证兼容
- - 所有第三方依赖的许可证都在`LICENSE`文件中声名
- - 依赖许可证的完整版全部在`license`目录
- - 如果依赖的是Apache许可证并且存在`NOTICE`文件，那么这些`NOTICE`文件也需要加入到版本的`NOTICE`文件中
-
-你可以参考此文章：[ASF第三方许可证策](https://apache.org/legal/resolved.html)
-
-## 发起投票
-
-> EventMesh 仍在孵化阶段，需要进行两次投票
-
-- EventMesh社区投票，发送邮件至：`dev@eventmesh.apache.org`
-- incubator社区投票，发送邮件至：`general@incubator.apache.org` EventMesh毕业后，只需要在EventMesh社区投票
-
-### 1.EventMesh社区投票阶段
-
-1. EventMesh社区投票，发起投票邮件到`dev@eventmesh.apache.org`。PMC需要先按照文档检查版本的正确性，然后再进行投票。 经过至少72小时并统计到3个`+1 PMC member`票后，即可进入下一阶段的投票。
-2. 宣布投票结果,发起投票结果邮件到`dev@eventmesh.apache.org`。
-
-### 2.EventMesh社区投票模板
-
-标题：
-
-```
-[VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
-```
-
-正文：
-
-```
-Hello EventMesh Community,
-
- This is a call for vote to release Apache EventMesh (incubating) version ${release_version}-${rc_version}.
-
- Release notes:
- https://github.com/apache/incubator-eventmesh/releases/tag/v${release_version}-${rc_version}
-
- The release candidates:
- https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
-
- Maven artifacts are available in a staging repository at:
- https://repository.apache.org/content/repositories/orgapacheeventmesh-{staging-id}
-
- Git tag for the release:
- https://github.com/apache/incubator-eventmesh/tree/v${release_version}-${rc_version}
-
- Keys to verify the Release Candidate:
- https://downloads.apache.org/incubator/eventmesh/KEYS
-
- Hash for the release tag:
- #hashCode of this release tag
-
- GPG user ID:
- ${YOUR.GPG.USER.ID}
-
- The vote will be open for at least 72 hours or until necessary number of votes are reached.
-
- Please vote accordingly:
-
- [ ] +1 approve
-
- [ ] +0 no opinion
-
- [ ] -1 disapprove with the reason
-
- Checklist for reference:
-
- [ ] Download links are valid.
-
- [ ] Checksums and PGP signatures are valid.
-
- [ ] Source code distributions have correct names matching the current release.
-
- [ ] LICENSE and NOTICE files are correct for each EventMesh repo.
-
- [ ] All files have license headers if necessary.
-
- [ ] No compiled archives bundled in source archive.
-
- More detail checklist please refer:
- https://cwiki.apache.org/confluence/display/INCUBATOR/Incubator+Release+Checklist
-
-Thanks,
-Your EventMesh Release Manager
-```
-
-### 3.宣布投票结果模板
-
-标题：
-
-```
-[RESULT][VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
-```
-
-正文：
-
-```
-Hello Apache EventMesh PPMC and Community,
-
- The vote closes now as 72hr have passed. The vote PASSES with
-
- xx (+1 non-binding) votes from the PPMC,
- xx (+1 binding) votes from the IPMC,
- xx (+1 non-binding) votes from the rest of the developer community,
- and no further 0 or -1 votes.
-
- The vote thread: {vote_mail_address}
-
- I will now bring the vote to general@incubator.apache.org to get approval by the IPMC.
- If this vote passes also, the release is accepted and will be published.
-
-Thank you for your support.
-Your EventMesh Release Manager
-```
-
-### 4.Incubator社区投票阶段
-
-1. Incubator社区投票，发起投票邮件到`general@incubator.apache.org`，需3个 `+1 IPMC Member`投票，方可进入下一阶段。
-2. 宣布投票结果,发起投票结果邮件到`general@incubator.apache.org` 并抄送至`dev@eventmesh.apache.org`。
-
-### 5.Incubator社区投票模板
-
-标题：
-
-```
-[VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
-```
-
-内容：
-
-```
-Hello Incubator Community,
-
- This is a call for a vote to release Apache EventMesh(Incubating) version ${release_version} ${rc_version}
-
- The Apache EventMesh community has voted on and approved a proposal to release
- Apache EventMesh(Incubating) version ${release_version} ${rc_version}
-
- We now kindly request the Incubator PMC members review and vote on this
- incubator release.
-
- EventMesh community vote thread:
- • [投票链接]
-
- Vote result thread:
- • [投票结果链接]
-
- The release candidate:
- •https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version}/
-
- Git tag for the release:
- • https://github.com/apache/incubator-eventmesh/tree/${release_version}-${rc_version}
- Release notes:
- • https://github.com/apache/incubator-eventmesh/releases/tag/${release_version}-${rc_version}
-
- The artifacts signed with PGP key [填写你个人的KEY], corresponding to [填写你个人的邮箱], that can be found in keys file:
- • https://downloads.apache.org/incubator/eventmesh/KEYS
-
- The vote will be open for at least 72 hours or until necessary number of votes are reached.
-
- Please vote accordingly:
-
- [ ] +1 approve
- [ ] +0 no opinion
- [ ] -1 disapprove with the reason
-
-Thanks,
-On behalf of Apache EventMesh(Incubating) community
-```
-
-### 6.宣布投票结果模板
-
-标题：
-
-```
-[RESULT][VOTE] Release Apache EventMesh (incubating) ${release_version} ${rc_version}
-```
-
-内容：
-
-```
-Hi all,
-
- Thanks for reviewing and voting for Apache EventMesh(Incubating) version ${release_version} ${rc_version} release, I am happy to announce the release voting has passed with [投票结果数] binding votes, no +0 or -1 votes.
-
- Binding votes are from IPMC
- - xxx
- - xxx
- - xxx
-
- Non-binding votes:
- +1 xxx
- +0 xxx
- -1 xxx
-
- The voting thread is:
- • [投票结果链接]
-
- Many thanks for all our mentors helping us with the release procedure, and all IPMC helped us to review and vote for Apache EventMesh(Incubating) release. I will be working on publishing the artifacts soon.
-
-Thanks,
-On behalf of Apache EventMesh(Incubating) community
-```
-
-## 正式发布
-
-### 1.合并分支
-
-合并`${release_version}-release`分支的改动到`master`分支，合并完成后删除`release`分支
-
-```shell
-$ git checkout master
-$ git merge origin/${release_version}-release
-$ git pull
-$ git push origin master
-$ git push --delete origin ${release_version}-release
-$ git branch -d ${release_version}-release
-```
-
-### 2.迁移源码与二进制包
-
-将源码和二进制包从svn的`dev`目录移动到`release`目录
-
-```shell
-$ svn mv https://dist.apache.org/repos/dist/dev/incubator/eventmesh/${release_version}-${rc_version} https://dist.apache.org/repos/dist/release/incubator/eventmesh/ -m "transfer packages for ${release_version}-${rc_version}" #移动源码包与二进制包
-$ svn delete https://dist.apache.org/repos/dist/release/incubator/eventmesh/KEYS -m "delete KEYS" #清除原有release目录下的KEYS
-$ svn cp https://dist.apache.org/repos/dist/dev/incubator/eventmesh/KEYS https://dist.apache.org/repos/dist/release/incubator/eventmesh/ -m "transfer KEYS for ${release_version}-${rc_version}" #拷贝dev目录KEYS到release目录
-```
-
-### 3.确认dev和release下的包是否正确
-
-- 确认[dev](https://dist.apache.org/repos/dist/dev/incubator/eventmesh/)下的`${release_version}-${rc_version}`已被删除
-- 删除[release](https://dist.apache.org/repos/dist/release/incubator/eventmesh/)目录下上一个版本的发布包，这些包会被自动保存在[这里](https://archive.apache.org/dist/incubator/eventmesh/)
-
-```shell
-$ svn delete https://dist.apache.org/repos/dist/release/incubator/eventmesh/${last_release_version} -m "Delete ${last_release_version}"
-```
-
-### 4.在Apache Staging仓库发布版本
-
-- 登录http://repository.apache.org , 使用Apache账号登录
-- 点击左侧的Staging repositories，
-- 搜索EventMesh关键字，选择你最近上传的仓库，投票邮件中指定的仓库
-- 点击上方的`Release`按钮，这个过程会进行一系列检查
-
-> 等仓库同步到其他数据源，一般需要24小时
-
-### 5.GitHub版本发布
-
-1.Tag the commit (on which the vote happened) with the release version without `-${RELEASE_CANDIDATE}`. 例如：after a successful vote on `v1.2-rc5`, the hash will be tagged again with `v1.2` only.
-
-2.在 [GitHub Releases](https://github.com/apache/incubator-eventmesh/releases) 页面的 `${release_version}` 版本上点击 `Edit`
-
-编辑版本号及版本说明，并点击 `Publish release`
-
-### 6.更新下载页面
-
-等待并确认新的发布版本同步至 Apache 镜像后，更新如下页面：
-
-https://eventmesh.apache.org/download/
-
-https://eventmesh.apache.org/zh/download/
-
-GPG签名文件和哈希校验文件的下载连接应该使用这个前缀：`https://downloads.apache.org/incubator/eventmesh/`
-
-> 注意：项目下载链接应该使用 https://www.apache.org/dyn/closer.lua 而不是 closer.cgi 或者 mirrors.cgi
-
-### 7.邮件通知版本发布完成
-
-> 请确保Apache Staging仓库已发布成功，一般是在该步骤的24小时后发布邮件
-
-发邮件到 `dev@eventmesh.apache.org` 、 `announce@apache.org`和`general@incubator.apache.org`
-
-标题：
-
-```
-[ANNOUNCE] Apache EventMesh (incubating) ${release_version} available
-```
-
-正文：
-
-```
-Hi all,
-
-Apache EventMesh (incubating) Team is glad to announce the new release of Apache EventMesh (incubating) ${release_version}.
-
-Apache EventMesh (incubating) is a dynamic cloud-native eventing infrastructure used to decouple the application and backend middleware layer, which supports a wide range of use cases that encompass complex multi-cloud, widely distributed topologies using diverse technology stacks.
-
-Download Links: https://eventmesh.apache.org/projects/eventmesh/download/
-
-Release Notes: https://eventmesh.apache.org/events/release-notes/v${release_version}/
-
-Website: https://eventmesh.apache.org/
-
-EventMesh Resources:
-- Issue: https://github.com/apache/incubator-eventmesh/issues
-- Mailing list: dev@eventmesh.apache.org
-
-
-
-Apache EventMesh (incubating) Team
-```
-
diff --git a/zh/docs/contribute/02-write-unit-test.md b/zh/docs/contribute/02-write-unit-test.md
deleted file mode 100644
index 055cdce3..00000000
--- a/zh/docs/contribute/02-write-unit-test.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# 单元测试要求
-
-- 每个单元测试都应该使用断言`assertions` 而不是 `System.out` 打印或者`if`语句
-- 每个单元测试都不应该调用其他用例，或者依赖于执行顺序
-- 每个单元测试都应该是可以循环执行的，并且单元测试不可以依赖外部环境，因为单元测试可能在持续集成环境中运行。
-- 每个单元测试的测试范围应该足够小且精准，以便于定位方法级别的问题。
-
-## 路径和命名规则
-
-- 单元测试应该写在`src/test/java`目录下。
-- 单元测试的配置文件应该放在`src/test/resources`目录下，如下示例：
- - 将被测试的类：`src/main/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBody.java`
- - 单元测试类：`src/test/java/org/apache/eventmesh/common/protocol/http/body/BaseResponseBodyTest.java`
- - 单元测试配置文件：`src/test/resources/configuration.properties`
-- 单元测试类的包名应该和被测试的类的包名相同
-- 单元测试的类的名字应该是`{被测试的类名+}Test`。 比如：
- - 将被测试的类是：`EventMeshUtil`
- - 单元测试类的类名就是： `EventMeshUtilTest`
-- 每个单元测试的名字必须是 `test{+方法名}`，比如：
- - 将被测试的方法：`addProp(String key, String val)`
- - 单元测试的名字就是：`testAddProp`
-
-## 断言的用法
-
-
-### 常见的断言
-
-| Methods | Instructions |
-| :-------------- | :-------------- |
-| `assertEquals` | 确定两个对象或原语类型是否相等 |
-| `assertNotEquals` | 确定两个对象或原语类型是否不相等 |
-| `assertTrue` | 确定给定的布尔值是否是 `true` |
-| `assertFalse` | 确定给定的布尔值是否是 `false` |
-| `assertNull` | 确定给定的对象是否是 `null` |
-| `assertNotNull` | 确定给定的对象是否不是 `null` |
-| `assertAll` | 如果同时处理多个逻辑，如果只有一个逻辑断言失败，整个测试将会失败|
-
-### 示例
-
-#### `assertEquals()`
-
-```java
-configuration.init();
-Assert.assertEquals("value1", configuration.eventMeshEnv);
-```
-
-#### `assertTrue()`
-
-```java
-BaseResponseHeader header = BaseResponseHeader.buildHeader("200");
-Assert.assertTrue(header.toMap().containsKey(ProtocolKey.REQUEST_CODE));
-```
-
-#### `assertFalse()`
-
-```java
-Class<NacosRegistryService> nacosRegistryServiceClass = NacosRegistryService.class;
-Field initStatus = nacosRegistryServiceClass.getDeclaredField("INIT_STATUS");
-initStatus.setAccessible(true);
-Object initStatusField = initStatus.get(nacosRegistryService);
-Assert.assertFalse((Boolean.parseBoolean(initStatusField.toString())));
-```
-
-#### `assertNull()`
-
-```java
-DefaultFullHttpResponse response = httpCommand.httpResponse();
-Assert.assertNull(response);
-```
-
-#### `assertNotNull()`
-
-```java
-Codec.Decoder cd = new Codec.Decoder();
-ArrayList<Object> result = new ArrayList<>();
-cd.decode(null, buf, result);
-Assert.assertNotNull(result.get(0));
-```
diff --git a/zh/docs/contribute/_category_.json b/zh/docs/contribute/_category_.json
deleted file mode 100644
index 56d36f91..00000000
--- a/zh/docs/contribute/_category_.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
- "position": 5,
- "label": "Contribute",
- "collapsed": false
-}
diff --git a/zh/docs/desing-document/01-workflow.md b/zh/docs/desing-document/01-workflow.md
deleted file mode 100644
index 444c0945..00000000
--- a/zh/docs/desing-document/01-workflow.md
+++ /dev/null
@@ -1,258 +0,0 @@
-# EventMesh工作流
-
-## 业务场景
-
-图中你正在构建一个简单的电商订单管理系统，系统能够接收和调配新的订单，调配流程需要处理所有的订单创建，付款处理以及发货处理。
-
-为了实现高可用和高性能，你可以使用事件驱动架构（EDA）构建微服务应用去处理商店前端，订单管理，支付处理和发货管理。你可以在云上部署整个系统。要处理高并发，你可以利用消息系统缓冲，并扩展多个微服务实例。架构类似于：
-
-
-
-当每个微服务都在自己的事件通道上运行时，EventMesh在执行事件编排方面发挥着至关重要的作用。
-
-我们使用 [CNCF Serverless工作流](https://serverlessworkflow.io/) 来描述此事件工作流编排。
-
-## CNCF Serverless工作流
-
-CNCF Serverless工作流定义了一个厂商中立、开源和完全社区驱动的生态系统，用于定义和运行针对Serverless技术领域的基于DSL的工作流。
-
-Serverless工作流定义了一种领域特定语言（DSL）来描述有状态和无状态的基于工作流的serverless函数和微服务编排。
-
-详见[官方github](https://github.com/serverlessworkflow/specification)
-
-## EventMesh工作流
-
-我们利用Serverless工作流DSL来描述EventMesh工作流。根据其规范，工作流由一系列用于描述控制流逻辑的工作流状态组成。目前，我们仅支持与事件相关的工作流状态。请参见[工作流DSL设计](#workflow-dsl-design-wip)中支持的状态。
-
-`工作流状态`可以包含通用的`操作`，或在工作流执行期间应调用的服务/函数。这些`操作`可以引用可复用的`函数`定义（应如何调用这些函数/服务），还可以引用触发基于事件的服务调用的事件，以及要等待的事件，这些事件表示这种基于事件的服务调用完成。
-
-在EDA解决方案中，我们通常使用AsyncAPI定义事件驱动的微服务。Serverless工作流“函数”定义支持使用AsyncAPI定义调用语义。有关详细信息，请参见[Using Funtions for AsyncAPI Service](https://github.com/serverlessworkflow/specification/blob/main/specification.md#using-functions-for-async-api-service-invocations)。
-
-### AsyncAPI
-
-AsyncAPI是一项开源计划，旨在改善事件驱动体系结构（EDA）的当前状态。我们的长期目标是让使用EDA和使用REST API一样容易。包括从文档到代码生成、发现到事件管理。现在应用于REST API的大多数流程也适用于事件驱动/异步API。
-
-详见[AsyncAPI官网](https://www.asyncapi.com/docs/getting-started)
-
-### 工作流示例
-
-在本示例中，我们构建了上面订单管理系统的事件驱动工作流。
-
-首先，我们需要为我们的微服务应用定义AsyncAPI。
-
-- 在线商店应用程序
-
-```yaml
-asyncapi: 2.2.0
-info:
- title: Online Store application
- version: '0.1.0'
-channels:
- store/order:
- subscribe:
- operationId: newStoreOrder
- message:
- $ref : '#/components/NewOrder'
-
-```
-
-- 订单服务
-
-```yaml
-asyncapi: 2.2.0
-info:
- title: Order Service
- version: '0.1.0'
-channels:
- order/inbound:
- publish:
- operationId: sendOrder
- message:
- $ref : '#/components/Order'
- order/outbound:
- subscribe:
- operationId: processedOrder
- message:
- $ref : '#/components/Order'
-```
-
-- 支付服务
-
-```yaml
-asyncapi: 2.2.0
-info:
- title: Payment Service
- version: '0.1.0'
-channels:
- payment/inbound:
- publish:
- operationId: sendPayment
- message:
- $ref : '#/components/OrderPayment'
- payment/outbound:
- subscribe:
- operationId: paymentReceipt
- message:
- $ref : '#/components/OrderPayment'
-```
-
-- 物流服务
-
-```yaml
-asyncapi: 2.2.0
-info:
- title: Shipment Service
- version: '0.1.0'
-channels:
- shipment/inbound:
- publish:
- operationId: sendShipment
- message:
- $ref : '#/components/OrderShipment'
-```
-
-接下来，定义描述订单管理业务逻辑的订单工作流。
-
-```yaml
-id: storeorderworkflow
-version: '1.0'
-specVersion: '0.8'
-name: Store Order Management Workflow
-states:
- - name: Receive New Order Event
- type: event
- onEvents:
- - eventRefs:
- - NewOrderEvent
- actions:
- - eventRef:
- triggerEventRef: OrderServiceSendEvent
- resultEventRef: OrderServiceResultEvent
- - eventRef:
- triggerEventRef: PaymentServiceSendEvent
- resultEventRef: PaymentServiceResultEvent
- transition: Check Payment Status
- - name: Check Payment Status
- type: switch
- dataConditions:
- - name: Payment Successfull
- condition: "${ .payment.status == 'success' }"
- transition: Send Order Shipment
- - name: Payment Denied
- condition: "${ .payment.status == 'denied' }"
- end: true
- defaultCondition:
- end: true
- - name: Send Order Shipment
- type: operation
- actions:
- - eventRef:
- triggerEventRef: ShipmentServiceSendEvent
- end: true
-events:
- - name: NewOrderEvent
- source: file://onlineStoreApp.yaml#newStoreOrder
- type: asyncapi
- kind: consumed
- - name: OrderServiceSendEvent
- source: file://orderService.yaml#sendOrder
- type: asyncapi
- kind: produced
- - name: OrderServiceResultEvent
- source: file://orderService.yaml#processedOrder
- type: asyncapi
- kind: consumed
- - name: PaymentServiceSendEvent
- source: file://paymentService.yaml#sendPayment
- type: asyncapi
- kind: produced
- - name: PaymentServiceResultEvent
- source: file://paymentService.yaml#paymentReceipt
- type: asyncapi
- kind: consumed
- - name: ShipmentServiceSendEvent
- source: file://shipmentService.yaml#sendShipment
- type: asyncapi
- kind: produced
-```
-
-对应的工作流图如下：
-
-
-
-## EventMesh工作流引擎
-
-在下面的体系结构图中, EventMesh目录, EventMesh工作流引擎 和 EventMesh Runtime在三个不同的处理器中运行。
-
-
-
-运行工作流的步骤如下：
-
-1. 在环境中部署发布者和订阅者应用程序。
- 使用AsyncAPI描述应用程序API，生成asyncAPI yaml。
- 使用AsyncAPI在EventMesh目录中注册发布者和订阅者应用程序。
-
-2. 在EventMesh工作流引擎中注册Serverless工作流DSL。
-
-3. 工作流引擎从EventMesh目录查询发布服务器和订阅服务器的需要的工作流DSL`函数`。
-
-4. 事件驱动App将事件发布到EventMesh Runtime触发工作流。EventMesh工作流引擎发布和订阅事件、编排事件。
-
-### EventMesh Catalog 设计
-
-EventMesh目录存储发布者、订阅者和通道元数据。由以下模块组成：
-
-- AsyncAPI解析器
-
- 使用AsyncAPI社区提供的SDK ([tool list](https://www.asyncapi.com/docs/community/tooling)),
- 解析并验证AsyncAPI yaml输入，并生成AsyncAPI定义。
-
-- 发布者, 通道, 订阅者模块
-
- 从AsyncAPI定义存储发布者、订阅者和通道信息。
-
-### EventMesh工作流引擎设计
-
-工作流引擎由以下模块组成：
-
-- 工作流解析器
-
- 使用Serverless Workflow社区提供的SDK([SDKs](https://github.com/serverlessworkflow/specification#sdks)),
- 解析和验证工作流DSL输入，并生成工作流定义。
-
-- 工作流模块
-
- 管理工作流实例的生命周期，从创建、启动、停止到销毁。
-
-- 状态模块
-
- 管理工作流状态生命周期。支持与事件相关的状态，and the supported state list below is Work-in-Progress.
-
- | 工作流状态 | 描述 |
- | --- | --- |
- | Operation | 执行Actions中定义的AsyncAPI函数 |
- | Event | 检查定义的事件是否匹配，如果匹配，执行定义的AsyncAPI函数 |
- | Switch | 检查事件是否与事件条件匹配，并执行定义的AsyncAPI函数 |
- | Parallel | 并行执行定义的AsyncAPI函数 |
- | ForEach | 迭代输入集合并执行定义的AsyncAPI函数 |
-
-- 行为模块
-
- 管理函数中的行为。
-
-- 函数模块
-
- 通过在EventMesh Runtime中创建发布者和/或订阅者来管理AsyncAPI函数，并管理发布者/订阅者生命周期。
-
- | AsyncAPI 操作 | EventMesh Runtime |
- | --- | --- |
- | Publish | Publisher |
- | Subscribe | Subscriber |
-
-- 事件模块
-
- 使用工作流DSL中定义的规则管理CloudEvent数据模型，包括事件过滤器、关联和转换。
-
-- 重试模块
-
- 管理事件发布到EventMesh Runtime的重试逻辑。
diff --git a/zh/docs/desing-document/02-runtime-protocol.md b/zh/docs/desing-document/02-runtime-protocol.md
deleted file mode 100644
index d5f15560..00000000
--- a/zh/docs/desing-document/02-runtime-protocol.md
+++ /dev/null
@@ -1,420 +0,0 @@
-# TCP协议文档
-
-#### 1. 协议格式
-
-
-
-**消息组成详解：**
-
-```
-魔术字：9位，当前值为“EventMesh”
-
-通信协议版本号：4位，当前值为“0000”
-
-消息总长度值(length)：4位，int类型
-
-消息头长度值(headerLength)：4位，int类型
-
-消息头(header)：长度 = headerLength
-
-消息体(body)：长度 = length - headerLength - 4 - 4
-```
-
-#### 2. 业务逻辑层
-
-+ 消息组成
-
-消息头（header）+ 消息体（body）
-
-```java
-public class Package {
-
- private Header header;
- private Object body;
-}
-
-
-public class Header {
-
- private Command cmd;
- private int code;
- private String msg;
- private String seq;
-}
-```
-
-+ 详解
-
-消息头(header)：类型为Header，Header中有Command字段，用于区分不同的消息类型
-
-消息体(body)：对于不同的消息类型，body的类型不同
-
-| 消息命令字 | body类型 |
-| ------------------------------------------------------------ | ------------ |
-| HEARTBEAT_REQUEST, HEARTBEAT_RESPONSE, HELLO_RESPONSE, CLIENT_GOODBYE_REQUEST, CLIENT_GOODBYE_RESPONSE, SERVER_GOODBYE_REQUEST, SERVER_GOODBYE_RESPONSE, LISTEN_REQUEST, LISTEN_RESPONSE, UNSUBSCRIBE_REQUEST, SUBSCRIBE_RESPONSE, UNSUBSCRIBE_RESPONSE, ASYNC_MESSAGE_TO_SERVER_ACK, BROADCAST_MESSAGE_TO_SERVER_ACK | 无 |
-| HELLO_REQUEST | UserAgent |
-| SUBSCRIBE_REQUEST | Subscription |
-| REQUEST_TO_SERVER, REQUEST_TO_CLIENT, RESPONSE_TO_SERVER, RESPONSE_TO_CLIENT, ASYNC_MESSAGE_TO_SERVER, ASYNC_MESSAGE_TO_CLIENT, BROADCAST_MESSAGE_TO_SERVER, BROADCAST_MESSAGE_TO_CLIENT, ASYNC_MESSAGE_TO_CLIENT_ACK, BROADCAST_MESSAGE_TO_CLIENT_ACK, RESPONSE_TO_CLIENT_ACK, REQUEST_TO_CLIENT_ACK | OpenMessage |
-| REDIRECT_TO_CLIENT | RedirectInfo |
-
-#### 3. Client 与 Eventmesh-Runtime(Server)交互场景详解
-
-```java
-public enum Command {
-
- //心跳
- HEARTBEAT_REQUEST(0), //client发给server的心跳包
- HEARTBEAT_RESPONSE(1), //server回复client的心跳包
-
- //握手
- HELLO_REQUEST(2), //client发给server的握手请求
- HELLO_RESPONSE(3), //server回复client的握手请求
-
- //断连
- CLIENT_GOODBYE_REQUEST(4), //client主动断连时通知server
- CLIENT_GOODBYE_RESPONSE(5), //server回复client的主动断连通知
- SERVER_GOODBYE_REQUEST(6), //server主动断连时通知client
- SERVER_GOODBYE_RESPONSE(7), //client回复server的主动断连通知
-
- //订阅管理
- SUBSCRIBE_REQUEST(8), //client发给server的订阅请求
- SUBSCRIBE_RESPONSE(9), //server回复client的订阅请求
- UNSUBSCRIBE_REQUEST(10), //client发给server的取消订阅请求
- UNSUBSCRIBE_RESPONSE(11), //server回复client的取消订阅请求
-
- //监听
- LISTEN_REQUEST(12), //client发给server的启动监听请求
- LISTEN_RESPONSE(13), //server回复client的监听请求
-
- //RR
- REQUEST_TO_SERVER(14), //client将RR请求发送给server
- REQUEST_TO_CLIENT(15), //server将RR请求推送给client
- REQUEST_TO_CLIENT_ACK(16), //client收到RR请求后ACK给server
- RESPONSE_TO_SERVER(17), //client将RR回包发送给server
- RESPONSE_TO_CLIENT(18), //server将RR回包推送给client
- RESPONSE_TO_CLIENT_ACK(19), //client收到回包后ACK给server
-
- //异步事件
- ASYNC_MESSAGE_TO_SERVER(20), //client将异步事件发送给server
- ASYNC_MESSAGE_TO_SERVER_ACK(21), //server收到异步事件后ACK给client
- ASYNC_MESSAGE_TO_CLIENT(22), //server将异步事件推送给client
- ASYNC_MESSAGE_TO_CLIENT_ACK(23), //client收到异步事件后ACK给server
-
- //广播
- BROADCAST_MESSAGE_TO_SERVER(24), //client将广播消息发送给server
- BROADCAST_MESSAGE_TO_SERVER_ACK(25), //server收到广播消息后ACK给client
- BROADCAST_MESSAGE_TO_CLIENT(26), //server将广播消息推送给client
- BROADCAST_MESSAGE_TO_CLIENT_ACK(27), //client收到广播消息后ACK给server
-
- //重定向指令
- REDIRECT_TO_CLIENT(30), //server将重定向指令推动给client
-}
-```
-
-#### 4. Client发起交互
-
-| 场景 | Client向Server发送消息命令字 | Server回复Client消息的命令字 | 说明 |
-| -------------- | ---------------------------- | ------------------------------- | ---- |
-| 握手 | HELLO_REQUEST | HELLO_RESPONSE | |
-| 心跳 | HEARTBEAT_REQUEST | HEARTBEAT_RESPONSE | |
-| 订阅 | SUBSCRIBE_REQUEST | SUBSCRIBE_RESPONSE | |
-| 取消订阅 | UNSUBSCRIBE_REQUEST | UNSUBSCRIBE_RESPONSE | |
-| 开始监听消息 | LISTEN_REQUEST | LISTEN_RESPONSE | |
-| 发送RR请求 | REQUEST_TO_SERVER | RESPONSE_TO_CLIENT | |
-| 发送RR回包 | RESPONSE_TO_SERVER | 无 | |
-| 发送异步事件 | ASYNC_MESSAGE_TO_SERVER | ASYNC_MESSAGE_TO_SERVER_ACK | |
-| 发送广播事件 | BROADCAST_MESSAGE_TO_SERVER | BROADCAST_MESSAGE_TO_SERVER_ACK | |
-| 客户端主动断连 | CLIENT_GOODBYE_REQUEST | CLIENT_GOODBYE_RESPONSE | |
-
-#### 5. Server发起交互
-
-| 场景 | Server向Client发送消息命令字 | Client回复Server消息命令字 | 说明 |
-| ------------------ | ---------------------------- | ------------------------------- | ---- |
-| 客户端接收RR请求 | REQUEST_TO_CLIENT | REQUEST_TO_CLIENT_ACK | |
-| 客户端接收RR回包 | RESPONSE_TO_CLIENT | RESPONSE_TO_CLIENT_ACK | |
-| 客户端接收异步事件 | ASYNC_MESSAGE_TO_CLIENT | ASYNC_MESSAGE_TO_CLIENT_ACK | |
-| 客户端接收广播事件 | BROADCAST_MESSAGE_TO_CLIENT | BROADCAST_MESSAGE_TO_CLIENT_ACK | |
-| 服务端主动断连 | SERVER_GOODBYE_REQUEST | 无 | |
-| 服务端进行重定向 | REDIRECT_TO_CLIENT | 无 | |
-| | | | |
-
-#### 6. 消息类型
-
-+ 发送RR消息
-
-
-
-+ 发送异步单播消息
-
-
-
-+ 发送广播消息
-
-
-
-## HTTP协议文档
-
-Java类`LiteMessage`的`content`字段表示一个特殊的协议，因此，如果您要使用eventmesh-sdk-java的http-client，则只需设计协议的`content`即可。`LiteMessage`组成如下：
-
-```java
-public class LiteMessage {
-
- private String bizSeqNo;
-
- private String uniqueId;
-
- private String topic;
-
- private String content;
-
- private Map<String, String> prop;
-
- private long createTime = System.currentTimeMillis();
-}
-```
-
-#### 1. 消息发送方式与组成
-
-**消息发送方式**：POST方式
-
-**消息组成**：请求头(RequestHeader) + 请求体(RequestBody)
-
-+ 心跳消息
-
-**RequestHeader**
-
-| Key | 说明 |
-| -------- | ---------------- |
-| Env | client所属环境 |
-| Region | client所属区域 |
-| Idc | client所属IDC |
-| Dcn | client所在DCN |
-| Sys | client所属子系统 |
-| Pid | client进程号 |
-| Ip | client Ip |
-| Username | client 用户名 |
-| Passwd | client 密码 |
-| Version | 协议版本 |
-| Language | 语言描述 |
-| Code | 请求码 |
-
-**RequestBody**
-
-| Key | 说明 |
-| ----------------- | ------------------------------ |
-| clientType | 客户端类型 |
-| heartbeatEntities | 心跳实体，包含topic、url等信息 |
-
-+ 订阅消息：
-
-**RequestHeader**
-
-与心跳消息一致
-
-**RequestBody**
-
-| Key | 说明 |
-| ----- | ----------------- |
-| topic | 客户端订阅的topic |
-| url | topic对应的url |
-
-+ 取消订阅消息：
-
-**RequestHeader**
-
-与心跳消息一致
-
-**RequestBody**
-
-与订阅消息一致
-
-+ 发送异步事件：
-
-**RequestHeader**
-
-与心跳消息一致
-
-**RequestBody**
-
-| Key | 说明 |
-| -------- | ----------------------- |
-| topic | 客户端请求的topic |
-| content | 客户端发送的topic的内容 |
-| ttl | 客户端请求超时时间 |
-| bizSeqNo | 客户端请求业务流水号 |
-| uniqueId | 客户端请求消息唯一标识 |
-
-#### 2. Client发起交互
-
-| 场景 | Client向Server发送消息请求码 | Server回复Client消息的响应码 | 说明 |
-| ------------ | ---------------------------- | --------------------------------------- | ---- |
-| 心跳 | HEARTBEAT(203) | SUCCESS(0)/EVENTMESH_HEARTBEAT_ERROR(19) | |
-| 订阅 | SUBSCRIBE(206) | SUCCESS(0)/EVENTMESH_SUBSCRIBE_ERROR(17) | |
-| 取消订阅 | UNSUBSCRIBE(207) | SUCCESS(0)/EVENTMESH_UNSUBSCRIBE_ERROR(18) | |
-| 发送异步事件 | MSG_SEND_ASYNC(104) | SUCCESS(0)/EVENTMESH_SEND_ASYNC_MSG_ERR(14) | |
-
-#### 3. Server发起交互
-
-| 场景 | Server向Client发送消息请求码 | Client回复Server消息响应码 | 说明 |
-| ------------------ | ---------------------------- | -------------------------- | ---------------------- |
-| 客户端接收异步事件 | HTTP_PUSH_CLIENT_ASYNC(105) | retCode | retCode值为0时代表成功 |
-
-## gRPC 协议文档
-
-#### 1. protobuf
-
-在 `eventmesh-protocol-gprc` 模块有 Eventmesh gRPC 客户端的 protobuf 文件. the protobuf 文件路径是 `/src/main/proto/eventmesh-client.proto`.
-
-用gradle build 生成 gRPC 代码在 `/build/generated/source/proto/main`. 生成代码用于 `eventmesh-sdk-java` 模块.
-
-#### 2. gRPC 数据模型
-
-+ 消息
-
-以下消息数据模型用于 `publish()`, `requestReply()` 和 `broadcast()` APIs.
-
-```
-message RequestHeader {
- string env = 1;
- string region = 2;
- string idc = 3;
- string ip = 4;
- string pid = 5;
- string sys = 6;
- string username = 7;
- string password = 8;
- string language = 9;
- string protocolType = 10;
- string protocolVersion = 11;
- string protocolDesc = 12;
-}
-
-message SimpleMessage {
- RequestHeader header = 1;
- string producerGroup = 2;
- string topic = 3;
- string content = 4;
- string ttl = 5;
- string uniqueId = 6;
- string seqNum = 7;
- string tag = 8;
- map<string, string> properties = 9;
-}
-
-message BatchMessage {
- RequestHeader header = 1;
- string producerGroup = 2;
- string topic = 3;
-
- message MessageItem {
- string content = 1;
- string ttl = 2;
- string uniqueId = 3;
- string seqNum = 4;
- string tag = 5;
- map<string, string> properties = 6;
- }
-
- repeated MessageItem messageItem = 4;
-}
-
-message Response {
- string respCode = 1;
- string respMsg = 2;
- string respTime = 3;
-}
-```
-
-+ 订阅
-
-以下订阅数据模型用于 `subscribe()` 和 `unsubscribe()` APIs.
-
-```
-message Subscription {
- RequestHeader header = 1;
- string consumerGroup = 2;
-
- message SubscriptionItem {
- enum SubscriptionMode {
- CLUSTERING = 0;
- BROADCASTING = 1;
- }
-
- enum SubscriptionType {
- ASYNC = 0;
- SYNC = 1;
- }
-
- string topic = 1;
- SubscriptionMode mode = 2;
- SubscriptionType type = 3;
- }
-
- repeated SubscriptionItem subscriptionItems = 3;
- string url = 4;
-}
-```
-
-+ 心跳
-
-以下心跳数据模型用于 `heartbeat()` API.
-
-```
-message Heartbeat {
- enum ClientType {
- PUB = 0;
- SUB = 1;
- }
-
- RequestHeader header = 1;
- ClientType clientType = 2;
- string producerGroup = 3;
- string consumerGroup = 4;
-
- message HeartbeatItem {
- string topic = 1;
- string url = 2;
- }
-
- repeated HeartbeatItem heartbeatItems = 5;
-}
-```
-
-#### 3. gRPC 服务接口
-
-+ 事件生产端服务 APIs
-
-```
-service PublisherService {
- # 异步事件生产
- rpc publish(SimpleMessage) returns (Response);
-
- # 同步事件生产
- rpc requestReply(SimpleMessage) returns (Response);
-
- # 批量事件生产
- rpc batchPublish(BatchMessage) returns (Response);
-}
-```
-
-+ 事件消费端服务 APIs
-
-```
-service ConsumerService {
- # 所消费事件通过 HTTP Webhook推送事件
- rpc subscribe(Subscription) returns (Response);
-
- # 所消费事件通过 TCP stream推送事件
- rpc subscribeStream(Subscription) returns (stream SimpleMessage);
-
- rpc unsubscribe(Subscription) returns (Response);
-}
-```
-
-+ 客户端心跳服务 API
-
-```
-service HeartbeatService {
- rpc heartbeat(Heartbeat) returns (Response);
-}
-```
diff --git a/zh/docs/desing-document/03-stream.md b/zh/docs/desing-document/03-stream.md
deleted file mode 100644
index 9f733d82..00000000
--- a/zh/docs/desing-document/03-stream.md
+++ /dev/null
@@ -1,115 +0,0 @@
-# EventMesh Stream
-
-## 事件流概述
-
-事件流是发布/订阅架构模式的一种实现，它包括以下几个部分
-
-- 消息或事件：状态变化。
-
-- 主题：消息中间件代理中的分区。
-
-- 消费者：可以从代理主题订阅读取事件。
-
-- 生产者：生成事件
-
-事件流是事件的连续流动，为了维持事件之间的秩序，事件流应该以特定的方式从生产者流向消费者。
-
-## 要求
-
-### 功能要求
-
-| 需求编号 | 需求描述 | 注释 |
-| -------------- | ----------------------- | -------- |
-| F-1 | EventMesh用户应该能够在 EventMesh 中实现事件流功能 | 功能性 |
-| F-2 | EventMesh用户可以为路由、过滤、转换等应用动态用户特定逻辑 | 功能性 |
-
-## 设计细节
-
-我们引入了 EventMesh Stream 组件，允许我们在 Apache Camel 中本地使用来自 Spring Cloud Stream 的编程模型和绑定器抽象。
-
-[Spring-Cloud-Stream](https://spring.io/projects/spring-cloud-stream) Spring Cloud Stream是一个用于构建
-与共享消息传递系统连接的、高度可扩展的事件驱动微服务框架。
-
-[Apache Camel](https://camel.apache.org/) Camel 是一个开源集成框架，使您能够快速轻松地集成各种消费或生产数据的系统。
-
-## 架构
-
-
-
-## 设计
-
-### EventMesh-Stream 组件
-
-- Event（事件）
-- Event Channel（事件通道）
-- Event EndPoint（事件端点）
-- Event Pipes & Filters（事件管道和过滤器）
-- Event Routes（事件路由器）
-- Event Converter（事件转换器）
-
-#### Event（事件）
-
-> 事件是系统中传输数据的最小单位。它的结构分为标题、正文和附件。
-
-#### Event Channel（事件通道）
-
-> 事件通道是系统中的逻辑通道，我们是通过 Spring Cloud Stream 编程模型实现的，它具有围绕消息通道的抽象功能（截至目前用的是 Spring `MessageChannel`）。
-
-#### Event EndPoint（事件端点）
-
-> 事件端点是应用程序和消息传递系统之间的接口。我们可以定义两种类型的端点
-
-- 消费者端点 - 出现在路由开始并从传入通道读取传入事件。
-- 生产者端点 - 出现在路由的末尾并将传入事件写入传出通道。
-
-#### Event Pipes & Filters（事件管道和过滤器）
-
-> 我们可以通过创建过滤器链（Apache Camel `Processor`）来构建路由，其中一个过滤器的输出被用于管道中下一个过滤器的输入。管道的主要优点是可以创建复杂的事件处理逻辑。
-
-#### Event Routes（事件路由器）
-
-> 事件路由器是消费者的一种过滤器，并根据决策标准将它们重定向到适当的目标端点。
-
-#### Event Converter（事件转换器）
-
-> 事件转换器用于修改事件内容，将其转换为不同的格式（换而言之 cloudevents -> Event (Camel) -> Binder Message(Spring Message)，反之亦然）。
-
-## EventMesh-Stream 组件接口
-
-### Component（组件）
-
-Component 接口是主要的入口点，您可以使用 Component 对象作为工厂来创建 EndPoint 对象。
-
-
-
-### EndPoint（端点）
-
-EndPoint 作为创建消费者、生产者和事件对象的工厂。
-
-- `createConsumer()` — 创建消费者端点，该端点表示路由开始的源端点。
-- `createProducer()` — 创建生产者端点，该端点表示路由末端的目标端点。
-
-
-
-#### Producer（生产者）
-
-用户可以创建以下类型的生产者
-> 同步生产者：处理线程阻塞，直到生产者完成事件处理。
-
-
-
-未来将会实现的生产者类型：
-
-- 异步生产者 - 生产者在子线程中处理事件。
-
-#### Consumer（消费者）
-
-用户可以创建以下类型的消费者
-> 事件驱动的消费者：当消息绑定器调用消费者中的方法时，开始处理传入请求。
-
-
-
-未来将会实现的消费者类型：
-
-- 定时轮训消费者
-- 自定义轮询消费者
diff --git a/zh/docs/desing-document/05-metrics-export.md b/zh/docs/desing-document/05-metrics-export.md
deleted file mode 100644
index 38be6e07..00000000
--- a/zh/docs/desing-document/05-metrics-export.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# EventMesh 指标（OpenTelemetry 和 Prometheus
-
-## 介绍
-
-[EventMesh(incubating)](https://github.com/apache/incubator-eventmesh) 是一个动态的云原生事件基础设施.
-
-## OpenTelemetry 概述
-
-OpenTelemetry 是工具、API 和 SDK 的集合。您可以使用它来检测、生成、收集和导出遥测数据（指标、日志和跟踪）以进行分析，以便了解您的软件的性能和行为。
-
-## 概述 Prometheus
-
-使用领先的开源监控解决方案为您的指标和警报提供支持。
-
-- 尺寸数据
-- 强大的查询
-- 伟大的可视化
-- 高效存储
-- 操作简单
-- 精准预警
-- 许多客户端库
-- 许多集成
-
-## 要求
-
-### 功能要求
-
-| Requirement ID | Requirement Description | Comments |
-| :------------- | ------------------------------------------------------------ | ------------- |
-| F-1 | EventMesh users should be able to observe HTTP metrics from Prometheus | Functionality |
-| F-2 | EventMesh users should be able to observe TCP metrics from Prometheus | Functionality |
-
-## 设计 细节
-
-使用由提供的儀表儀器 OpenTelemetry 觀察指標存在於 EventMesh 然後導出到 Prometheus.
-
-1、初始化儀表儀器
-
-2、設置 Prometheus 服務器
-
-3、创建了不同的指标观察者
-
-## 附录
-
-### 参考资料
-
-<https://github.com/open-telemetry/docs-cn/blob/main/QUICKSTART.md#%E5%88%9B%E5%BB%BA%E5%9F%BA%E7%A1%80Span>
diff --git a/zh/docs/desing-document/06-cloudevents.md b/zh/docs/desing-document/06-cloudevents.md
deleted file mode 100644
index 2d53e607..00000000
--- a/zh/docs/desing-document/06-cloudevents.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# CloudEvents 集成
-
-## 介绍
-
-[CloudEvents](https://github.com/cloudevents/spec) 是一种描述事件数据的格式规范，它提供了跨服务、平台与系统的互操作性。
-
-截止至 2021 年 5 月，EventMesh 包含了以下主要组件：`eventmesh-runtime`, `eventmesh-sdk-java` 和 `eventmesh-connector-rocketmq`。
-
-对于使用 EventMesh 的用户，`eventmesh-runtime` 可以被部署为微服务来在生产者和消费者间传输用户的事件。
-用户的应用程序可以通过 `eventmesh-sdk-java` 来与 `eventmesh-runtime` 进行交互，即发布或订阅指定主题的事件。
-
-EventMesh 的用户非常渴望能得到对 CloudEvents 的支持。有许多理由使得用户倾向于使用集成了 CloudEvents 支持的 SDK：
-
-- CloudEvents 是一种更为广泛接受和支持的描述事件的方式。目前，`eventmesh-sdk-java` 使用的是 `LiteMessage` 结构
- 来描述事件，其标准化程度较低。
-- CloudEvents 的 Java SDK 有更广泛的分发方式。比如，目前 EventMesh 的用户需要使用 SDK 的 tar 包，或对每个 EventMesh 的
- 发布版本从源码编译。有了 CloudEvents 的支持，用户可以更方便地通过 CloudEvents 的公开分发（比如，配置 Maven）来添加
- EventMesh SDK 依赖项。
-- CloudEvents 的 SDK 支持多种语言。尽管目前 EventMesh 只提供了 Java SDK，但在未来，如果要为更多语言提供支持，将 Java SDK
- 与 CloudEvents 绑定的经验将使工作变得容易。
-
-## 需求
-
-### 功能需求
-
-| 需求 ID | 需求描述 | 备注 |
-| ------ | ------- | --- |
-| F-1 | EventMesh 用户应能使用公共 SDK 依赖项来发布或订阅 CloudEvents 格式的事件 | 功能性 |
-| F-2 | EventMesh 用户应能在提供了 CloudEvents 支持的 SDK 中继续使用现有的 EventMesh 客户端功能（如负载均衡） | 功能等价 |
-| F-3 | EventMesh 的开发者应不需要付出特别多努力/痛苦来在 `eventmesh-sdk-java` 和提供了 CloudEvents 支持的 SDK 之间同步 | 可维护性 |
-| F-4 | EventMesh 支持可插拔的协议，以便开发者整合其他协议（例如：CloudEvents / EventMesh MessageOpenMessage / MQTT...） | 功能性 |
-| F-5 | EventMesh 支持统一的 API 以供从/向事件库发布或订阅事件 | 功能性 |
-
-### 性能需求
-
-| 需求 ID | 需求描述 | 备注 |
-| ------ | ------- | --- |
-| P-1 | 提供了 CloudEvents 支持的 SDK 应具有与目前的 SDK 相近的客户端延迟 | |
-
-## 设计细节
-
-与 CloudEvents 的 Java SDK 绑定（这与 Kafka 已经完成的工作类似，请在附录中的参考资料了解更多细节）是达成上述需求的一种简单方法。
-
-### 可插拔协议
-
-
-
-### EventMesh 集成 CloudEvents 进度表
-
-#### TCP
-
-##### SDK 端发布
-
-- 在 `package` 首部中添加 CloudEvents 标识符
-- 使用 `CloudEventBuilder` 构造 CloudEvent，并将其放入 `package` 体中
-
-##### SDK 端订阅
-
-- 在 `ReceiveMsgHook` 接口下添加 `convert` 函数，其用于将 `package` 体转换为具有 `package` 首部标识符的特定协议
-- 不同协议应实现 `ReceiveMsgHook` 接口
-
-##### 服务端发布
-
-- 设计包含 `decodeMessage` 接口的协议转换 API，其可以把包体转换为 CloudEvent
-- 更新 `MessageTransferTask` 下的 `Session.upstreamMsg()`，将入参 `Message` 改为 `CloudEvent`，这使用了
- 上一步的 `decodeMessage` API 来进行对 CloudEvent 的转换
-- 更新 `SessionSender.send()`，将入参 `Message` 改为 `CloudEvent`
-- 更新 `MeshMQProducer` API，支持在运行时发送 `CloudEvents`
-- 在 `connector-plugin` 中实现支持向 EventStore 中发送 `CloudEvents`
-
-##### 服务端订阅
-
-- 支持将连接器插件中的 `RocketMessage` 改为 `CloudEvent
-- 重写 `AsyncMessageListener.consume()` 函数，将入参 `Message` 改为 `CloudEvent`
-- 更新 `MeshMQPushConsumer.updateOffset()`，将入参 `Message` 改为 `CloudEvent`
-- 更新 `DownStreamMsgContext`，将入参 `Message` 改为 `CloudEvent`，更新 `DownStreamMsgContext.ackMsg`
-
-#### HTTP
-
-##### SDK 端发布
-
-- 支持 `LiteProducer.publish(cloudEvent)`
-- 在 http 请求头中添加 CloudEvents 标识符
-
-##### SDK 端订阅
-
-##### 服务端发布
-
-- 支持根据 `HttpCommand` 首部中的协议类型，通过可插拔的协议插件构造 `HttpCommand.body`
-- 支持在消息处理器中发布 CloudEvent
-
-##### 服务端订阅
-
-- 更新 `EventMeshConsumer.subscribe()`
-- 更新 `HandleMsgContext`， 将入参 `Message` 改为 `CloudEvent`
-- 更新 `AsyncHttpPushRequest.tryHTTPRequest()`
-
-## 附录
-
-### 参考资料
-
-- <https://cloudevents.github.io/sdk-java/kafka>
diff --git a/zh/docs/desing-document/08-spi.md b/zh/docs/desing-document/08-spi.md
deleted file mode 100644
index 5fb301f4..00000000
--- a/zh/docs/desing-document/08-spi.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# EventMesh SPI
-
-## 介绍
-
-为了提高扩展性，EventMesh通过引入SPI（Service Provider Interface）机制，能够在运行时自动寻找扩展接口的具体实现类，动态加载。
-在EventMesh中，一切扩展点都利用SPI采用插件的实现方式，用户可以通过实现扩展接口，开发自定义的插件，在运行时通过简单的配置，声明式的选择所需要运行的插件。
-
-## eventmesh-spi模块
-
-SPI相关的代码位于eventmesh-spi模块下，其中主要包括EventMeshExtensionFactory, EventMeshSPI, ExtensionClassLoader这三个类。
-
-### EventMeshSPI
-
-EventMeshSPI是SPI注解，所有需要采用SPI实现扩展的接口都需要使用@EventMeshSPI注解标记。
-
-```java
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-public @interface EventMeshSPI {
-
- /**
- * If true, the spi instance is singleton
- */
- boolean isSingleton() default false;
-
-}
-```
-
-这么做的原因是可以通过注解的方式声明接口为SPI扩展接口，提高代码的可读性。同时，@EventMeshSPI注解中包含一个isSingleton属性，
-用来声明该扩展接口是否采用单例的实现方式，如果为true，那么该接口的实现类将会使用单例的实现方式，在一个JVM进程中全局唯一。
-
-### EventMeshExtensionFactory
-
-EventMeshExtensionFactory是SPI实现类的获取工厂，包含一个静态方法`getExtension(Class<T> extensionType, String extensionName)`，
-接收扩展接口字节码对象和扩展实例名称，用于获取扩展接口的具体实现类。
-
-```java
-public enum EventMeshExtensionFactory {
- ;
- /**
- * @param extensionType extension plugin class type
- * @param extensionName extension instance name
- * @param <T> the type of the plugin
- * @return plugin instance
- */
- public static <T> T getExtension(Class<T> extensionType, String extensionName) {
- }
-}
-```
-
-所有需要获取扩展实现的地方都应该通过EventMeshExtensionFactory获取。
-
-### ExtensionClassLoader
-
-ExtensionClassLoader是扩展接口实现类的加载接口，包含两个实现子类MetaInfExtensionClassLoader和JarExtensionClassLoader。
-
-```java
-/**
- * Load extension class
- * <ul>
- * <li>{@link MetaInfExtensionClassLoader}</li>
- * <li>{@link JarExtensionClassLoader}</li>
- * </ul>
- */
-public interface ExtensionClassLoader {
-
- /**
- * load
- *
- * @param extensionType extension type class
- * @param <T> extension type
- * @return extension instance name to extension instance class
- */
- <T> Map<String, Class<?>> loadExtensionClass(Class<T> extensionType);
-}
-```
-
-MetaInfExtensionClassLoader用于从classPath直接加载实现类，JarExtensionClassLoader用于从配置目录下通过加载Jar包的方式加载实现类，未来可能还会提供通过从Maven仓库下加载实现类。
-
-## SPI使用示例
-
-下面以eventmesh-connector-plugin为例，介绍SPI具体的使用过程。
-
-首先定义一个eventmesh-connector-api模块，并且定义扩展接口MeshMQProducer。在MeshMQProducer接口上使用@EventMeshSPI注解进行声明，表明该接口是一个SPI扩展接口
-
-```java
-@EventMeshSPI(isSingleton = false)
-public interface MeshMQProducer extends Producer {
-...
-}
-```
-
-eventmesh-connector-rocketmq模块中包含采用rocketmq的具体实现方式RocketMQProducerImpl。
-
-```java
-public class RocketMQProducerImpl implements MeshMQProducer {
-...
-}
-```
-
-同时，还需要在eventmesh-connector-rocketmq模块中resource/META-INF/eventmesh目录下创建文件名为SPI接口全限定名的文件
-org.apache.eventmesh.api.producer.Producer
-
-文件内容为扩展实例名和对应的实例全类名
-
-```properties
-rocketmq=org.apache.eventmesh.connector.rocketmq.producer.RocketMQProducerImpl
-```
-
-至此，一个SPI扩展模块就完成了。在使用的时候只需要通过EventMeshExtensionFactory.getExtension(MeshMQProducer.class, “rocketmq”)就可以获取RocketMQProducerImpl实现类。
diff --git a/zh/docs/desing-document/_category_.json b/zh/docs/desing-document/_category_.json
deleted file mode 100644
index 95b7eed0..00000000
--- a/zh/docs/desing-document/_category_.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
- "label": "Documentation",
- "collapsed": false
-}
diff --git a/zh/docs/introduction.md b/zh/docs/introduction.md
deleted file mode 100644
index 43c821dd..00000000
--- a/zh/docs/introduction.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Apache EventMesh (Incubating)
-
-[](https://github.com/apache/incubator-eventmesh/actions/workflows/ci.yml)
-[](https://codecov.io/gh/apache/incubator-eventmesh)
-[](https://lgtm.com/projects/g/apache/incubator-eventmesh/context:java)
-[](https://lgtm.com/projects/g/apache/incubator-eventmesh/alerts/)
-[](https://github.com/apache/incubator-eventmesh/releases)
-[](https://www.apache.org/licenses/LICENSE-2.0.html)
-
-## 什么是Event Mesh？
-
-EventMesh是一个动态的云原生事件驱动架构基础设施，用于分离应用程序和后端中间件层，它支持广泛的用例，包括复杂的混合云、使用了不同技术栈的分布式架构。
-
-
-
-**EventMesh架构：**
-
-
-
-**EventMesh云原生结构：**
-
-
-
-Event Mesh允许将来自一个应用程序的事件动态路由到任何其他应用程序. Event Mesh的一般功能:
-
-* 事件驱动;
-* 事件治理;
-* 动态路由;
-* 云原生
-
-部件：
-
-* eventmesh-runtime：一种中间件，用于在事件生产者和消费者之间传输事件，支持云原生应用程序和微服务
-* eventmesh-sdk-java：当前支持HTTP、HHTTP、TCP和 [gRPC](https://grpc.io) 协议
-
-
-## 快速开始
-
-1. 构建并部署 event-store(RocketMQ), 请参见[说明](instruction/01-store.md)
-2. 构建并部署 eventmesh-runtime，请参见[说明](instruction/02-runtime.md)
-3. 运行 eventmesh-sdk-java 演示，请参见[说明](instruction/03-demo.md)
-
-## 贡献
-
-永远欢迎参与共建, 请参阅[贡献](../../03-new-contributor-guidelines.md)了解详细指南
-
-您可以从发现和解决问题开始～
-[GitHub Issues](https://github.com/apache/incubator-eventmesh/issues)
-
diff --git a/zh/docs/roadmap.md b/zh/docs/roadmap.md
deleted file mode 100644
index a3d7695c..00000000
--- a/zh/docs/roadmap.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-sidebar_position: 1
----
-
-# EventMesh产品路线图
-
-下表列出了EventMesh的新特性和bug修复情况，详情请参考 [release notes](https://eventmesh.apache.org/events/release-notes/v1.4.0).
-
-## List of Features and Milestones
-
-| Status | Description | Reference |
-|-------------------------------------------|---------------------------------| --- |
-| **Implemented in 1.0.0** | Support HTTP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.0.0** | Support TCP | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.0.0** | Support Pub/Sub Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.1.1** | Provide Java SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.1.1** | Support HTTPS | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.2.0** | Support RocketMQ as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.2.0** | Support Heartbeat | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.3.0** | Integrate with OpenSchema | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.3.0** | Integrate with OpenTelemetry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.3.0** | Support CloudEvents | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.4.0** | Support gRPC | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.5.0** | Provide Golang SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.5.0** | Support Nacos Registry | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.5.0** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.5.0** | Support Federal Government | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.6.0 (to be released)** | Integrate with Consul | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.6.0 (to be released)** | Support Webhook | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **Implemented in 1.6.0 (to be released)** | Support etcd | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Knative Eventing Infrastructure | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/790), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-463) |
-| **In Progress** | Dashboard | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/700), [GSoC '22](https://issues.apache.org/jira/browse/COMDEV-465) |
-| **In Progress** | Support Kafka as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
-| **In Progress** | Support Pulsar as EventStore | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/676) |
-| **In Progress** | Support Dledger | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Workflow | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Support Redis | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Support Mesh Bridge | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| **In Progress** | Support Zookeeper | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| Planned | Provide NodeJS SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/417) |
-| Planned | Transaction Event | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/697) |
-| Planned | Event Query Language (EQL) | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/778) |
-| Planned | Metadata consistency persistent | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/817) |
-| Planned | Rust SDK | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/815) |
-| Planned | WebAssembly Runtime | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/576) |
-| Planned | Filter Chain | [GitHub Issue](https://github.com/apache/incubator-eventmesh/issues/664) |
-
diff --git a/zh/docs/sdk-java/02-http.md b/zh/docs/sdk-java/02-http.md
deleted file mode 100644
index 9a8acd0d..00000000
--- a/zh/docs/sdk-java/02-http.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# HTTP 协议
-
-EventMesh Java SDK 实现了 HTTP 异步消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh HTTP 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
-
-```java
-import org.apache.eventmesh.client.http.conf.EventMeshHttpClientConfig;
-import org.apache.eventmesh.common.utils.IPUtils;
-import org.apache.eventmesh.common.utils.ThreadUtils;
-
-public class HTTP {
- public static void main(String[] args) throws Exception {
- EventMeshHttpClientConfig eventMeshClientConfig = EventMeshHttpClientConfig.builder()
- .liteEventMeshAddr("localhost:10105")
- .producerGroup("TEST_PRODUCER_GROUP")
- .env("env")
- .idc("idc")
- .ip(IPUtils.getLocalAddress())
- .sys("1234")
- .pid(String.valueOf(ThreadUtils.getPID()))
- .userName("eventmesh")
- .password("password")
- .build();
- /* ... */
- }
-}
-```
-
-## HTTP 消费者
-
-类 `EventMeshHttpConsumer` 实现了 `heartbeat`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题和回调的 URL 地址。
-
-```java
-import org.apache.eventmesh.client.http.consumer.EventMeshHttpConsumer;
-import org.apache.eventmesh.common.protocol.SubscriptionItem;
-import org.apache.eventmesh.common.protocol.SubscriptionMode;
-import org.apache.eventmesh.common.protocol.SubscriptionType;
-import com.google.common.collect.Lists;
-
-public class HTTP {
- final String url = "http://localhost:8080/callback";
- final List<SubscriptionItem> topicList = Lists.newArrayList(
- new SubscriptionItem("eventmesh-async-topic", SubscriptionMode.CLUSTERING, SubscriptionType.ASYNC)
- );
-
- public static void main(String[] args) throws Exception {
- /* ... */
- eventMeshHttpConsumer = new EventMeshHttpConsumer(eventMeshClientConfig);
- eventMeshHttpConsumer.heartBeat(topicList, url);
- eventMeshHttpConsumer.subscribe(topicList, url);
- /* ... */
- eventMeshHttpConsumer.unsubscribe(topicList, url);
- }
-}
-```
-
-EventMesh runtime 将发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 信息的 POST 请求到这个回调的 URL 地址。类 [SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/http/demo/sub/controller/SubController.java) 实现了 Spring Boot controller，它将接收并解析回调信息。
-
-## HTTP 生产者
-
-类 `EventMeshHttpProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
-
-- `org.apache.eventmesh.common.EventMeshMessage`
-- `io.cloudevents.CloudEvent`
-- `io.openmessaging.api.Message`
-
-```java
-import org.apache.eventmesh.client.http.producer.EventMeshHttpProducer;
-import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
-import org.apache.eventmesh.common.Constants;
-import org.apache.eventmesh.common.utils.JsonUtils;
-
-import io.cloudevents.CloudEvent;
-import io.cloudevents.core.builder.CloudEventBuilder;
-
-public class HTTP {
- public static void main(String[] args) throws Exception {
- /* ... */
- EventMeshHttpProducer eventMeshHttpProducer = new EventMeshHttpProducer(eventMeshClientConfig);
- Map<String, String> content = new HashMap<>();
- content.put("content", "testAsyncMessage");
-
- CloudEvent event = CloudEventBuilder.v1()
- .withId(UUID.randomUUID().toString())
- .withSubject("eventmesh-async-topic")
- .withSource(URI.create("/"))
- .withDataContentType("application/cloudevents+json")
- .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
- .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
- .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
- .build();
- eventMeshHttpProducer.publish(event);
- }
-}
-```
-
-## 使用Curl 命令
-
-本段落介绍通过Curl命令体验事件的收发功能
-
-### 事件发送
-
-启动EventMesh Runtime服务后，可以使用Curl命令将事件用HTTP POST方法发布到指定的主题，Body内容必须是JSON格式，执行命令示例如下:
-
-```shell
-curl -H "Content-Type:application/json" -X POST -d '{"name": "admin", "pass":"12345678"}' http://127.0.0.1:10105/eventmesh/publish/TEST-TOPIC-HTTP-ASYNC
-```
-
-
-
-### 事件订阅
-
-启动EventMesh Runtime服务后，可以使用Curl命令用HTTP POST方法订阅指定的主题列表，Body内容必须是JSON格式，执行命令示例如下:
-
-```shell
-curl -H "Content-Type:application/json" -X POST -d '{"url": "http://127.0.0.1:8088/sub/test", "consumerGroup":"TEST-GROUP", "topic":[{"mode":"CLUSTERING","topic":"TEST-TOPIC-HTTP-ASYNC","type":"ASYNC"}]}' http://127.0.0.1:10105/eventmesh/subscribe/local
-```
-
-你可以在项目`eventmesh-examples`模块中看到这个例子。
\ No newline at end of file
diff --git a/zh/docs/sdk-java/03-tcp.md b/zh/docs/sdk-java/03-tcp.md
deleted file mode 100644
index 54f5eca5..00000000
--- a/zh/docs/sdk-java/03-tcp.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# TCP 协议
-
-EventMesh Java SDK 实现了同步、异步和广播 TCP 消息的生产者和消费者。 二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh TCP 客户端的配置信息。其中的 `host` 和 `port` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
-
-```java
-import org.apache.eventmesh.client.tcp.conf.EventMeshTCPClientConfig;
-import org.apache.eventmesh.client.tcp.common.ReceiveMsgHook;
-import io.cloudevents.CloudEvent;
-
-public class AsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
- public static void main(String[] args) throws InterruptedException {
- EventMeshTCPClientConfig eventMeshTcpClientConfig = EventMeshTCPClientConfig.builder()
- .host(eventMeshIp)
- .port(eventMeshTcpPort)
- .userAgent(userAgent)
- .build();
- /* ... */
- }
-}
-```
-
-## TCP 消费者
-
-消费者应该实现 `ReceiveMsgHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/tcp/common/ReceiveMsgHook.java)。
-
-```java
-public interface ReceiveMsgHook<ProtocolMessage> {
- Optional<ProtocolMessage> handle(ProtocolMessage msg);
-}
-```
-
-类 `EventMeshTCPClient` 实现了 `subscribe` 方法。该方法接收话题、`SubscriptionMode` 和 `SubscriptionType`。`handle` 方法将会在消费者从订阅的话题中收到消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
-
-```java
-import org.apache.eventmesh.client.tcp.EventMeshTCPClient;
-import org.apache.eventmesh.client.tcp.EventMeshTCPClientFactory;
-import org.apache.eventmesh.client.tcp.common.ReceiveMsgHook;
-import org.apache.eventmesh.common.protocol.SubscriptionMode;
-import org.apache.eventmesh.common.protocol.SubscriptionType;
-import io.cloudevents.CloudEvent;
-
-public class TCPConsumer implements ReceiveMsgHook<CloudEvent> {
- public static TCPConsumer handler = new TCPConsumer();
- private static EventMeshTCPClient<CloudEvent> client;
-
- public static void main(String[] args) throws Exception {
- client = EventMeshTCPClientFactory.createEventMeshTCPClient(
- eventMeshTcpClientConfig,
- CloudEvent.class
- );
- client.init();
-
- client.subscribe(
- "eventmesh-sync-topic",
- SubscriptionMode.CLUSTERING,
- SubscriptionType.SYNC
- );
-
- client.registerSubBusiHandler(handler);
- client.listen();
- }
-
- @Override
- public Optional<CloudEvent> handle(CloudEvent message) {
- log.info("Messaged received: {}", message);
- return Optional.of(message);
- }
-}
-```
-
-## TCP 生产者
-
-### 异步生产者
-
-类 `EventMeshTCPClient` 实现了 `public` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
-
-```java
-/* ... */
-client = EventMeshTCPClientFactory.createEventMeshTCPClient(eventMeshTcpClientConfig, CloudEvent.class);
-client.init();
-
-CloudEvent event = CloudEventBuilder.v1()
- .withId(UUID.randomUUID().toString())
- .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
- .withSource(URI.create("/"))
- .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
- .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
- .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
- .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
- .build();
-client.publish(event, 1000);
-```
-
-### 同步生产者
-
-类 `EventMeshTCPClient` 实现了 `rr` 方法。该方法接收将被发布的消息和一个可选的 timeout 值，并返回来自消费者的响应消息。
-
-```java
-/* ... */
-client = EventMeshTCPClientFactory.createEventMeshTCPClient(eventMeshTcpClientConfig, CloudEvent.class);
-client.init();
-
-CloudEvent event = CloudEventBuilder.v1()
- .withId(UUID.randomUUID().toString())
- .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
- .withSource(URI.create("/"))
- .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
- .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
- .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
- .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
- .build();
-
-Package response = client.rr(event, 1000);
-CloudEvent replyEvent = EventFormatProvider
- .getInstance()
- .resolveFormat(JsonFormat.CONTENT_TYPE)
- .deserialize(response.getBody().toString().getBytes(StandardCharsets.UTF_8));
-```
\ No newline at end of file
diff --git a/zh/docs/sdk-java/04-grpc.md b/zh/docs/sdk-java/04-grpc.md
deleted file mode 100644
index b0781870..00000000
--- a/zh/docs/sdk-java/04-grpc.md
+++ /dev/null
@@ -1,174 +0,0 @@
-# gRPC 协议
-
-EventMesh Java SDK 实现了 gRPC 同步、异步和广播消息的生产者和消费者。二者都需要一个 `EventMeshHttpClientConfig` 类实例来指定 EventMesh gRPC 客户端的配置信息。其中的 `liteEventMeshAddr`、`userName` 和 `password` 字段需要和 EventMesh runtime `eventmesh.properties` 文件中的相匹配。
-
-```java
-import org.apache.eventmesh.client.grpc.config.EventMeshGrpcClientConfig;
-import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
-import io.cloudevents.CloudEvent;
-
-public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
- public static void main(String[] args) throws InterruptedException {
- EventMeshGrpcClientConfig eventMeshClientConfig = EventMeshGrpcClientConfig.builder()
- .serverAddr("localhost")
- .serverPort(10205)
- .consumerGroup(ExampleConstants.DEFAULT_EVENTMESH_TEST_CONSUMER_GROUP)
- .env("env").idc("idc")
- .sys("1234").build();
- /* ... */
- }
-}
-```
-
-## gRPC 消费者
-
-### 流消费者
-
-EventMesh runtime 会将来自生产者的信息作为一系列事件流向流消费者发送。消费者应实现 `ReceiveHook` 类，其被定义在 [ReceiveMsgHook.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/consumer/ReceiveMsgHook.java)。
-
-```java
-public interface ReceiveMsgHook<T> {
- Optional<T> handle(T msg) throws Throwable;
- String getProtocolType();
-}
-```
-
-类 `EventMeshGrpcConsumer` 实现了 `registerListener`、`subscribe` 和 `unsubscribe` 方法。`subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的话题。`registerListener` 接收一个实现了 `ReceiveMsgHook` 的实例。`handle` 方法将会在消费者收到订阅的主题消息时被调用。如果 `SubscriptionType` 是 `SYNC`，`handle` 的返回值将被发送回生产者。
-
-```java
-import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
-import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
-import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
-import org.apache.eventmesh.common.protocol.SubscriptionItem;
-import org.apache.eventmesh.common.protocol.SubscriptionMode;
-import org.apache.eventmesh.common.protocol.SubscriptionType;
-import io.cloudevents.CloudEvent;
-
-public class CloudEventsAsyncSubscribe implements ReceiveMsgHook<CloudEvent> {
- public static CloudEventsAsyncSubscribe handler = new CloudEventsAsyncSubscribe();
- public static void main(String[] args) throws InterruptedException {
- /* ... */
- SubscriptionItem subscriptionItem = new SubscriptionItem(
- "eventmesh-async-topic",
- SubscriptionMode.CLUSTERING,
- SubscriptionType.ASYNC
- );
- EventMeshGrpcConsumer eventMeshGrpcConsumer = new EventMeshGrpcConsumer(eventMeshClientConfig);
-
- eventMeshGrpcConsumer.init();
- eventMeshGrpcConsumer.registerListener(handler);
- eventMeshGrpcConsumer.subscribe(Collections.singletonList(subscriptionItem));
- /* ... */
- eventMeshGrpcConsumer.unsubscribe(Collections.singletonList(subscriptionItem));
- }
-
- @Override
- public Optional<CloudEvent> handle(CloudEvent message) {
- log.info("Messaged received: {}", message);
- return Optional.empty();
- }
-
- @Override
- public String getProtocolType() {
- return EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME;
- }
-}
-```
-
-### Webhook 消费者
-
-类 `EventMeshGrpcConsumer` 的 `subscribe` 方法接收一个 `SubscriptionItem` 对象的列表，其中定义了要订阅的主题和一个可选的 timeout 值。如果提供了回调 URL，EventMesh runtime 将向回调 URL 地址发送一个包含 [CloudEvents 格式](https://github.com/cloudevents/spec) 消息的 POST 请求。[SubController.java](https://github.com/apache/incubator-eventmesh/blob/master/eventmesh-examples/src/main/java/org/apache/eventmesh/grpc/sub/app/controller/SubController.java) 实现了一个接收并解析回调信息的 Spring Boot controller。
-
-```java
-import org.apache.eventmesh.client.grpc.consumer.EventMeshGrpcConsumer;
-import org.apache.eventmesh.client.grpc.consumer.ReceiveMsgHook;
-import org.apache.eventmesh.client.tcp.common.EventMeshCommon;
-import org.apache.eventmesh.common.protocol.SubscriptionItem;
-import org.apache.eventmesh.common.protocol.SubscriptionMode;
-import org.apache.eventmesh.common.protocol.SubscriptionType;
-
-@Component
-public class SubService implements InitializingBean {
- final String url = "http://localhost:8080/callback";
-
- public void afterPropertiesSet() throws Exception {
- /* ... */
- eventMeshGrpcConsumer = new EventMeshGrpcConsumer(eventMeshClientConfig);
- eventMeshGrpcConsumer.init();
-
- SubscriptionItem subscriptionItem = new SubscriptionItem(
- "eventmesh-async-topic",
- SubscriptionMode.CLUSTERING,
- SubscriptionType.ASYNC
- );
-
- eventMeshGrpcConsumer.subscribe(Collections.singletonList(subscriptionItem), url);
- /* ... */
- eventMeshGrpcConsumer.unsubscribe(Collections.singletonList(subscriptionItem), url);
- }
-}
-```
-
-## gRPC 生产者
-
-### 异步生产者
-
-类 `EventMeshGrpcProducer` 实现了 `publish` 方法。`publish` 方法接收将被发布的消息和一个可选的 timeout 值。消息应是下列类的一个实例：
-
-- `org.apache.eventmesh.common.EventMeshMessage`
-- `io.cloudevents.CloudEvent`
-
-```java
-/* ... */
-EventMeshGrpcProducer eventMeshGrpcProducer = new EventMeshGrpcProducer(eventMeshClientConfig);
-eventMeshGrpcProducer.init();
-
-Map<String, String> content = new HashMap<>();
-content.put("content", "testAsyncMessage");
-
-CloudEvent event = CloudEventBuilder.v1()
- .withId(UUID.randomUUID().toString())
- .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
- .withSource(URI.create("/"))
- .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
- .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
- .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
- .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
- .build();
-eventMeshGrpcProducer.publish(event);
-```
-
-### 同步生产者
-
-类 `EventMeshGrpcProducer` 实现了 `requestReply` 方法。`requestReply` 方法接收将被发布的消息和一个可选的 timeout 值。方法会返回消费者返回的消息。消息应是下列类的一个实例：
-
-- `org.apache.eventmesh.common.EventMeshMessage`
-- `io.cloudevents.CloudEvent`
-
-### 批量生产者
-
-类 `EventMeshGrpcProducer` 重写了 `publish` 方法，该方法接收一个将被发布的消息列表和一个可选的 timeout 值。列表中的消息应是下列类的一个实例：
-
-- `org.apache.eventmesh.common.EventMeshMessage`
-- `io.cloudevents.CloudEvent`
-
-```java
-/* ... */
-List<CloudEvent> cloudEventList = new ArrayList<>();
-for (int i = 0; i < 5; i++) {
- CloudEvent event = CloudEventBuilder.v1()
- .withId(UUID.randomUUID().toString())
- .withSubject(ExampleConstants.EVENTMESH_GRPC_ASYNC_TEST_TOPIC)
- .withSource(URI.create("/"))
- .withDataContentType(ExampleConstants.CLOUDEVENT_CONTENT_TYPE)
- .withType(EventMeshCommon.CLOUD_EVENTS_PROTOCOL_NAME)
- .withData(JsonUtils.serialize(content).getBytes(StandardCharsets.UTF_8))
- .withExtension(Constants.EVENTMESH_MESSAGE_CONST_TTL, String.valueOf(4 * 1000))
- .build();
-
- cloudEventList.add(event);
-}
-
-eventMeshGrpcProducer.publish(cloudEventList);
-/* ... */
-```
\ No newline at end of file
diff --git a/zh/docs/sdk-java/_category_.json b/zh/docs/sdk-java/_category_.json
deleted file mode 100644
index 9d0a27c5..00000000
--- a/zh/docs/sdk-java/_category_.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
- "label": "EventMesh SDK for Java",
- "collapsed": false
-}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@eventmesh.apache.org
For additional commands, e-mail: commits-help@eventmesh.apache.org