You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@flink.apache.org by GitBox <gi...@apache.org> on 2020/05/15 07:08:10 UTC
[GitHub] [flink] carp84 commented on a change in pull request #12139: [FLINK-16076] Translate "Queryable State" page into Chinese
carp84 commented on a change in pull request #12139:
URL: https://github.com/apache/flink/pull/12139#discussion_r425599346
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -27,75 +27,55 @@ under the License.
{:toc}
<div class="alert alert-warning">
- <strong>Note:</strong> The client APIs for queryable state are currently in an evolving state and
- there are <strong>no guarantees</strong> made about stability of the provided interfaces. It is
- likely that there will be breaking API changes on the client side in the upcoming Flink versions.
+ <strong>Note:</strong> 目前客户端的API处于不断演进的状态，<strong>无法保证</strong>当前的接口是稳定的。在接下来的Flink版本中，
+ 客户端的API很有可能会发生变化。
</div>
-In a nutshell, this feature exposes Flink's managed keyed (partitioned) state
-(see [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) to the outside world and
-allows the user to query a job's state from outside Flink. For some scenarios, queryable state
-eliminates the need for distributed operations/transactions with external systems such as key-value
-stores which are often the bottleneck in practice. In addition, this feature may be particularly
-useful for debugging purposes.
+简而言之, 这个特性将Flink的managed keyed (partitioned) state
+(参考 [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) 暴露给外部，从而用户可以在Flink外部查询作业状态。
+在某些场景中，可查询状态消除了对外部系统的分布式操作/事务的需求，比如KV存储系统，而这些外部系统往往会成为瓶颈。除此之外，这个特性对于调试作业非常有用。
<div class="alert alert-warning">
- <strong>Attention:</strong> When querying a state object, that object is accessed from a concurrent
- thread without any synchronization or copying. This is a design choice, as any of the above would lead
- to increased job latency, which we wanted to avoid. Since any state backend using Java heap space,
- <i>e.g.</i> <code>MemoryStateBackend</code> or <code>FsStateBackend</code>, does not work
- with copies when retrieving values but instead directly references the stored values, read-modify-write
- patterns are unsafe and may cause the queryable state server to fail due to concurrent modifications.
- The <code>RocksDBStateBackend</code> is safe from these issues.
+ <strong>注意:</strong> 进行查询时，状态会在并发线程中被访问，但并不会对状态进行同步和拷贝。这种设计是为了避免同步和拷贝带来的作业延时。对于使用Java堆内存的状态后端，
+ <i>比如</i> <code>MemoryStateBackend</code> 或者 <code>FsStateBackend</code>, 它们获取状态时不会进行拷贝，而是直接引用状态对象，所以对状态的读、修改和写是不安全的，并且
+ 可能会因为并发修改导致查询失败。但 <code>RocksDBStateBackend</code> 是安全的，不会遇到上述的问题。
</div>
-## Architecture
+## 架构
-Before showing how to use the Queryable State, it is useful to briefly describe the entities that compose it.
-The Queryable State feature consists of three main entities:
+在展示如何使用可查询状态之前，先简单描述一下该特性的组成部分，主要包括以下三部分:
- 1. the `QueryableStateClient`, which (potentially) runs outside the Flink cluster and submits the user queries,
- 2. the `QueryableStateClientProxy`, which runs on each `TaskManager` (*i.e.* inside the Flink cluster) and is responsible
- for receiving the client's queries, fetching the requested state from the responsible Task Manager on his behalf, and
- returning it to the client, and
- 3. the `QueryableStateServer` which runs on each `TaskManager` and is responsible for serving the locally stored state.
+ 1. `QueryableStateClient`, 可能运行在Flink集群外部，负责提交用户的查询请求,
Review comment:
可能运行在 -> （默认）运行在
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -27,75 +27,55 @@ under the License.
{:toc}
<div class="alert alert-warning">
- <strong>Note:</strong> The client APIs for queryable state are currently in an evolving state and
- there are <strong>no guarantees</strong> made about stability of the provided interfaces. It is
- likely that there will be breaking API changes on the client side in the upcoming Flink versions.
+ <strong>Note:</strong> 目前客户端的API处于不断演进的状态，<strong>无法保证</strong>当前的接口是稳定的。在接下来的Flink版本中，
+ 客户端的API很有可能会发生变化。
</div>
-In a nutshell, this feature exposes Flink's managed keyed (partitioned) state
-(see [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) to the outside world and
-allows the user to query a job's state from outside Flink. For some scenarios, queryable state
-eliminates the need for distributed operations/transactions with external systems such as key-value
-stores which are often the bottleneck in practice. In addition, this feature may be particularly
-useful for debugging purposes.
+简而言之, 这个特性将Flink的managed keyed (partitioned) state
+(参考 [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) 暴露给外部，从而用户可以在Flink外部查询作业状态。
+在某些场景中，可查询状态消除了对外部系统的分布式操作/事务的需求，比如KV存储系统，而这些外部系统往往会成为瓶颈。除此之外，这个特性对于调试作业非常有用。
<div class="alert alert-warning">
- <strong>Attention:</strong> When querying a state object, that object is accessed from a concurrent
- thread without any synchronization or copying. This is a design choice, as any of the above would lead
- to increased job latency, which we wanted to avoid. Since any state backend using Java heap space,
- <i>e.g.</i> <code>MemoryStateBackend</code> or <code>FsStateBackend</code>, does not work
- with copies when retrieving values but instead directly references the stored values, read-modify-write
- patterns are unsafe and may cause the queryable state server to fail due to concurrent modifications.
- The <code>RocksDBStateBackend</code> is safe from these issues.
+ <strong>注意:</strong> 进行查询时，状态会在并发线程中被访问，但并不会对状态进行同步和拷贝。这种设计是为了避免同步和拷贝带来的作业延时。对于使用Java堆内存的状态后端，
+ <i>比如</i> <code>MemoryStateBackend</code> 或者 <code>FsStateBackend</code>, 它们获取状态时不会进行拷贝，而是直接引用状态对象，所以对状态的读、修改和写是不安全的，并且
+ 可能会因为并发修改导致查询失败。但 <code>RocksDBStateBackend</code> 是安全的，不会遇到上述的问题。
</div>
-## Architecture
+## 架构
-Before showing how to use the Queryable State, it is useful to briefly describe the entities that compose it.
-The Queryable State feature consists of three main entities:
+在展示如何使用可查询状态之前，先简单描述一下该特性的组成部分，主要包括以下三部分:
- 1. the `QueryableStateClient`, which (potentially) runs outside the Flink cluster and submits the user queries,
- 2. the `QueryableStateClientProxy`, which runs on each `TaskManager` (*i.e.* inside the Flink cluster) and is responsible
- for receiving the client's queries, fetching the requested state from the responsible Task Manager on his behalf, and
- returning it to the client, and
- 3. the `QueryableStateServer` which runs on each `TaskManager` and is responsible for serving the locally stored state.
+ 1. `QueryableStateClient`, 可能运行在Flink集群外部，负责提交用户的查询请求,
+ 2. `QueryableStateClientProxy`, 运行在每个 `TaskManager` 上(*比如* Flink集群内部), 负责接收客户端的查询请求, 从所负责的Task Manager获取请求的状态, 并返回给客户端,
Review comment:
*比如* -> *即*
从所负责的TaskManager获取请求的状态 -> 从对应的TaskManager获取请求的状态
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -202,35 +174,29 @@ CompletableFuture<S> getKvState(
StateDescriptor<S, V> stateDescriptor)
{% endhighlight %}
-The above returns a `CompletableFuture` eventually holding the state value for the queryable state instance identified
-by `queryableStateName` of the job with ID `jobID`. The `key` is the key whose state you are interested in and the
-`keyTypeInfo` will tell Flink how to serialize/deserialize it. Finally, the `stateDescriptor` contains the necessary
-information about the requested state, namely its type (`Value`, `Reduce`, etc) and the necessary information on how
-to serialize/deserialize it.
+该方法会返回一个`CompletableFuture`，最终会保存作业ID为`jobID`，可查询状态名称为`queryableStateName`的状态。`key`指定所要查询的状态所属的key，
+`keyTypeInfo`告诉Flink如何对key进行序列化/反序列化。`stateDescriptor`包含了所请求状态的必要信息，即状态的类型(`Value`，`Reduce`等等)，
+以及如何对其进行序列化/反序列。
-The careful reader will notice that the returned future contains a value of type `S`, *i.e.* a `State` object containing
-the actual value. This can be any of the state types supported by Flink: `ValueState`, `ReduceState`, `ListState`, `MapState`,
-`AggregatingState`, and the currently deprecated `FoldingState`.
+细心的读者会注意到返回的future包含类型为`S`的值，*比如*一个存储实际值的`State`对象。它可以是Flink支持的任何类型的状态: `ValueState`, `ReduceState`,
Review comment:
*比如* -> *即*
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -288,34 +254,27 @@ resultFuture.thenAccept(response -> {
## Configuration
-The following configuration parameters influence the behaviour of the queryable state server and client.
-They are defined in `QueryableStateOptions`.
+下面的配置参数会影响可查询状态服务器端和客户端的行为，它们在`QueryableStateOptions`中定义。
### State Server
-* `queryable-state.server.ports`: the server port range of the queryable state server. This is useful to avoid port clashes if more
- than 1 task managers run on the same machine. The specified range can be: a port: "9123", a range of ports: "50100-50200",
- or a list of ranges and or points: "50100-50200,50300-50400,51234". The default port is 9067.
-* `queryable-state.server.network-threads`: number of network (event loop) threads receiving incoming requests for the state server (0 => #slots)
-* `queryable-state.server.query-threads`: number of threads handling/serving incoming requests for the state server (0 => #slots).
+* `queryable-state.server.ports`: 服务器端口范围。如果同一台机器上运行了多个task manager，可以避免端口冲突。指定的范围可以是一个具体的端口号，如"9123"，
+ 可以是一个端口范围，如"50100-50200"，或者可以是端口范围以及端口号的组合，如"50100-50200,50300-50400,51234"。默认端口号是9067。
+* `queryable-state.server.network-threads`: 服务器端network (event loop) thread的数量，用来接收查询请求 (0 => #slots)。
+* `queryable-state.server.query-threads`: 服务器端处理查询请求的线程数 (0 => #slots)。
### Proxy
-* `queryable-state.proxy.ports`: the server port range of the queryable state proxy. This is useful to avoid port clashes if more
- than 1 task managers run on the same machine. The specified range can be: a port: "9123", a range of ports: "50100-50200",
- or a list of ranges and or points: "50100-50200,50300-50400,51234". The default port is 9069.
-* `queryable-state.proxy.network-threads`: number of network (event loop) threads receiving incoming requests for the client proxy (0 => #slots)
-* `queryable-state.proxy.query-threads`: number of threads handling/serving incoming requests for the client proxy (0 => #slots).
-
-## Limitations
-
-* The queryable state life-cycle is bound to the life-cycle of the job, *e.g.* tasks register
-queryable state on startup and unregister it on disposal. In future versions, it is desirable to
-decouple this in order to allow queries after a task finishes, and to speed up recovery via state
-replication.
-* Notifications about available KvState happen via a simple tell. In the future this should be improved to be
-more robust with asks and acknowledgements.
-* The server and client keep track of statistics for queries. These are currently disabled by
-default as they would not be exposed anywhere. As soon as there is better support to publish these
-numbers via the Metrics system, we should enable the stats.
+* `queryable-state.proxy.ports`: 代理的服务端口范围。 如果同一台机器上运行了多个task manager，可以避免端口冲突。指定的范围可以是一个具体的端口号，如"9123"，
+ 可以是一个端口范围，如"50100-50200"，或者可以是端口范围以及端口号的组合，如"50100-50200,50300-50400,51234"。默认端口号是9069。
+* `queryable-state.proxy.network-threads`: 代理上network (event loop) thread的数量，用来接收查询请求 (0 => #slots)。
+* `queryable-state.proxy.query-threads`: 代理上处理查询请求的线程数 (0 => #slots)。
+
+## 限制
+
+* 可查询状态的生命周期受限于作业的生命周期，*比如，* tasks在启动是注册可查询状态，并在销毁时注销。在未来的版本中，希望能够将其解耦
Review comment:
*比如，* -> *比如*
启动是 -> 启动时
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -27,75 +27,55 @@ under the License.
{:toc}
<div class="alert alert-warning">
- <strong>Note:</strong> The client APIs for queryable state are currently in an evolving state and
- there are <strong>no guarantees</strong> made about stability of the provided interfaces. It is
- likely that there will be breaking API changes on the client side in the upcoming Flink versions.
+ <strong>Note:</strong> 目前客户端的API处于不断演进的状态，<strong>无法保证</strong>当前的接口是稳定的。在接下来的Flink版本中，
+ 客户端的API很有可能会发生变化。
Review comment:
注意: 目前queryable state的客户端API还在演进中，不保证现有接口的稳定性，在后续的Flink版本中有可能发生API变化。
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -27,75 +27,55 @@ under the License.
{:toc}
<div class="alert alert-warning">
- <strong>Note:</strong> The client APIs for queryable state are currently in an evolving state and
- there are <strong>no guarantees</strong> made about stability of the provided interfaces. It is
- likely that there will be breaking API changes on the client side in the upcoming Flink versions.
+ <strong>Note:</strong> 目前客户端的API处于不断演进的状态，<strong>无法保证</strong>当前的接口是稳定的。在接下来的Flink版本中，
+ 客户端的API很有可能会发生变化。
</div>
-In a nutshell, this feature exposes Flink's managed keyed (partitioned) state
-(see [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) to the outside world and
-allows the user to query a job's state from outside Flink. For some scenarios, queryable state
-eliminates the need for distributed operations/transactions with external systems such as key-value
-stores which are often the bottleneck in practice. In addition, this feature may be particularly
-useful for debugging purposes.
+简而言之, 这个特性将Flink的managed keyed (partitioned) state
+(参考 [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) 暴露给外部，从而用户可以在Flink外部查询作业状态。
+在某些场景中，可查询状态消除了对外部系统的分布式操作/事务的需求，比如KV存储系统，而这些外部系统往往会成为瓶颈。除此之外，这个特性对于调试作业非常有用。
<div class="alert alert-warning">
- <strong>Attention:</strong> When querying a state object, that object is accessed from a concurrent
- thread without any synchronization or copying. This is a design choice, as any of the above would lead
- to increased job latency, which we wanted to avoid. Since any state backend using Java heap space,
- <i>e.g.</i> <code>MemoryStateBackend</code> or <code>FsStateBackend</code>, does not work
- with copies when retrieving values but instead directly references the stored values, read-modify-write
- patterns are unsafe and may cause the queryable state server to fail due to concurrent modifications.
- The <code>RocksDBStateBackend</code> is safe from these issues.
+ <strong>注意:</strong> 进行查询时，状态会在并发线程中被访问，但并不会对状态进行同步和拷贝。这种设计是为了避免同步和拷贝带来的作业延时。对于使用Java堆内存的状态后端，
+ <i>比如</i> <code>MemoryStateBackend</code> 或者 <code>FsStateBackend</code>, 它们获取状态时不会进行拷贝，而是直接引用状态对象，所以对状态的读、修改和写是不安全的，并且
Review comment:
read-modify-write建议保持不翻译，即“所以read-modify-write操作是不安全的，并且有可能因为并发修改导致查询失败”
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -27,75 +27,55 @@ under the License.
{:toc}
<div class="alert alert-warning">
- <strong>Note:</strong> The client APIs for queryable state are currently in an evolving state and
- there are <strong>no guarantees</strong> made about stability of the provided interfaces. It is
- likely that there will be breaking API changes on the client side in the upcoming Flink versions.
+ <strong>Note:</strong> 目前客户端的API处于不断演进的状态，<strong>无法保证</strong>当前的接口是稳定的。在接下来的Flink版本中，
+ 客户端的API很有可能会发生变化。
</div>
-In a nutshell, this feature exposes Flink's managed keyed (partitioned) state
-(see [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) to the outside world and
-allows the user to query a job's state from outside Flink. For some scenarios, queryable state
-eliminates the need for distributed operations/transactions with external systems such as key-value
-stores which are often the bottleneck in practice. In addition, this feature may be particularly
-useful for debugging purposes.
+简而言之, 这个特性将Flink的managed keyed (partitioned) state
+(参考 [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)) 暴露给外部，从而用户可以在Flink外部查询作业状态。
+在某些场景中，可查询状态消除了对外部系统的分布式操作/事务的需求，比如KV存储系统，而这些外部系统往往会成为瓶颈。除此之外，这个特性对于调试作业非常有用。
<div class="alert alert-warning">
- <strong>Attention:</strong> When querying a state object, that object is accessed from a concurrent
- thread without any synchronization or copying. This is a design choice, as any of the above would lead
- to increased job latency, which we wanted to avoid. Since any state backend using Java heap space,
- <i>e.g.</i> <code>MemoryStateBackend</code> or <code>FsStateBackend</code>, does not work
- with copies when retrieving values but instead directly references the stored values, read-modify-write
- patterns are unsafe and may cause the queryable state server to fail due to concurrent modifications.
- The <code>RocksDBStateBackend</code> is safe from these issues.
+ <strong>注意:</strong> 进行查询时，状态会在并发线程中被访问，但并不会对状态进行同步和拷贝。这种设计是为了避免同步和拷贝带来的作业延时。对于使用Java堆内存的状态后端，
+ <i>比如</i> <code>MemoryStateBackend</code> 或者 <code>FsStateBackend</code>, 它们获取状态时不会进行拷贝，而是直接引用状态对象，所以对状态的读、修改和写是不安全的，并且
+ 可能会因为并发修改导致查询失败。但 <code>RocksDBStateBackend</code> 是安全的，不会遇到上述的问题。
</div>
-## Architecture
+## 架构
-Before showing how to use the Queryable State, it is useful to briefly describe the entities that compose it.
-The Queryable State feature consists of three main entities:
+在展示如何使用可查询状态之前，先简单描述一下该特性的组成部分，主要包括以下三部分:
- 1. the `QueryableStateClient`, which (potentially) runs outside the Flink cluster and submits the user queries,
- 2. the `QueryableStateClientProxy`, which runs on each `TaskManager` (*i.e.* inside the Flink cluster) and is responsible
- for receiving the client's queries, fetching the requested state from the responsible Task Manager on his behalf, and
- returning it to the client, and
- 3. the `QueryableStateServer` which runs on each `TaskManager` and is responsible for serving the locally stored state.
+ 1. `QueryableStateClient`, 可能运行在Flink集群外部，负责提交用户的查询请求,
+ 2. `QueryableStateClientProxy`, 运行在每个 `TaskManager` 上(*比如* Flink集群内部), 负责接收客户端的查询请求, 从所负责的Task Manager获取请求的状态, 并返回给客户端,
+ 3. `QueryableStateServer`, 运行在 `TaskManager` 上，负责服务本地存储的状态.
-The client connects to one of the proxies and sends a request for the state associated with a specific
-key, `k`. As stated in [Working with State]({{ site.baseurl }}/dev/stream/state/state.html), keyed state is organized in
-*Key Groups*, and each `TaskManager` is assigned a number of these key groups. To discover which `TaskManager` is
-responsible for the key group holding `k`, the proxy will ask the `JobManager`. Based on the answer, the proxy will
-then query the `QueryableStateServer` running on that `TaskManager` for the state associated with `k`, and forward the
-response back to the client.
+客户端连接到一个代理，并发送请求获取特定`k`对应的状态。 如 [Working with State]({{ site.baseurl }}/dev/stream/state/state.html)所述, keyed state按照
+*Key Groups*进行划分, 每个`TaskManager`会分配其中的一些key groups。为了找到`k`所属key group的TaskManager, 代理会询问`JobManager`。根据返回的结果, 代理
+将会向运行在`TaskManager`上的`QueryableStateServer`查询`k`下的状态, 并将结果返回给客户端。
-## Activating Queryable State
+## 激活可查询状态
-To enable queryable state on your Flink cluster, you need to do the following:
+为了在Flink集群上使用可查询状态，需要进行以下操作：
- 1. copy the `flink-queryable-state-runtime{{ site.scala_version_suffix }}-{{site.version }}.jar`
-from the `opt/` folder of your [Flink distribution](https://flink.apache.org/downloads.html "Apache Flink: Downloads"),
-to the `lib/` folder.
- 2. set the property `queryable-state.enable` to `true`. See the [Configuration]({{ site.baseurl }}/ops/config.html#queryable-state) documentation for details and additional parameters.
+ 1. 将`flink-queryable-state-runtime{{ site.scala_version_suffix }}-{{site.version }}.jar`
+从[Flink distribution](https://flink.apache.org/downloads.html "Apache Flink: Downloads")的`opt/`目录拷贝到`lib/`目录。
+ 2. 将参数`queryable-state.enable`设置为`true`。详细信息以及其它参数可参考文档[Configuration]({{ site.baseurl }}/ops/config.html#queryable-state).
-To verify that your cluster is running with queryable state enabled, check the logs of any
-task manager for the line: `"Started the Queryable State Proxy Server @ ..."`.
+为了验证集群的可查询状态已经被激活，可以检查任意task manager的日志中是否包含"Started the Queryable State Proxy Server @ ..."。
-## Making State Queryable
+## 将状态设置为可查询
-Now that you have activated queryable state on your cluster, it is time to see how to use it. In order for a state to
-be visible to the outside world, it needs to be explicitly made queryable by using:
+激活集群的可查询状态功能后，还要将状态设置为可查询的才能对外可见，可以通过以下两种方式进行设置：
-* either a `QueryableStateStream`, a convenience object which acts as a sink and offers its incoming values as queryable
-state, or
-* the `stateDescriptor.setQueryable(String queryableStateName)` method, which makes the keyed state represented by the
- state descriptor, queryable.
+* 创建 `QueryableStateStream`, 它会作为一个sink，并将输入数据转化为可查询状态；
+* 通过 `stateDescriptor.setQueryable(String queryableStateName)` 将状态描述符所表示的keyed state设置成可查询的
-The following sections explain the use of these two approaches.
+接下来的部分将详细解释这两种方式。
### Queryable State Stream
-Calling `.asQueryableState(stateName, stateDescriptor)` on a `KeyedStream` returns a `QueryableStateStream` which offers
-its values as queryable state. Depending on the type of state, there are the following variants of the `asQueryableState()`
-method:
+在`KeyedStream`上调用`.asQueryableState(stateName, stateDescriptor)`将会返回一个`QueryableStateStream`， 它会将流数据转化为可查询状态。
+取决于状态的类型，`asQueryableState()`有以下一些方法变体：
Review comment:
取决于 -> 对应
##########
File path: docs/dev/stream/state/queryable_state.zh.md
##########
@@ -202,35 +174,29 @@ CompletableFuture<S> getKvState(
StateDescriptor<S, V> stateDescriptor)
{% endhighlight %}
-The above returns a `CompletableFuture` eventually holding the state value for the queryable state instance identified
-by `queryableStateName` of the job with ID `jobID`. The `key` is the key whose state you are interested in and the
-`keyTypeInfo` will tell Flink how to serialize/deserialize it. Finally, the `stateDescriptor` contains the necessary
-information about the requested state, namely its type (`Value`, `Reduce`, etc) and the necessary information on how
-to serialize/deserialize it.
+该方法会返回一个`CompletableFuture`，最终会保存作业ID为`jobID`，可查询状态名称为`queryableStateName`的状态。`key`指定所要查询的状态所属的key，
Review comment:
该方法会返回一个最终将包含状态值的queryable state实例，该实例可通过`JobID`和`queryableStateName`识别。在方法参数中，`key`用来指定所要查询的状态所属的key
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org