chore: import upstream snapshot with attribution
MCP Bash Server CI / Test MCP Bash Server (dev) (push) Has been cancelled
MCP Bash Server CI / Test MCP Bash Server (release) (push) Has been cancelled

This commit is contained in:
wehub-resource-sync
2026-07-13 13:11:39 +08:00
commit c8cebdfeee
4654 changed files with 626756 additions and 0 deletions
+83
View File
@@ -0,0 +1,83 @@
---
id: 'become_committer'
title: 'Become A Committer'
sidebar_position: 2
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
## Become A Committer of Apache HertzBeat
Anyone being supportive of the community and working in any of the
CoPDoC areas can become an Apache HertzBeat™ committer. The CoPDoC is an
acronym from ASF to describe how we recognize your contributions not
only by code.
- **Community** - You can join us via our mailing list, issue
trackers, discussions page to interact with community members, and
share vision and knowledge
- **Project** - a clear vision and consensus are needed
- **Documentation** - without it, the stuff remains only in the minds
of the authors
- **Code** - discussion goes nowhere without code
Apache HertzBeat™ community strives to be meritocratic. Thus, once someone
has contributed sufficiently to any area of CoPDoC they can be a
candidate for committer-ship and at last voted in as a HertzBeat
committer. Being an Apache HertzBeat™ committer does not necessarily mean
you must commit code with your commit privilege to the codebase; it
means you are committed to the HertzBeat project and are productively
contributing to our community's success.
## Committer requirements
There are no strict rules for becoming a committer or new PMC member.
Candidates for new committers are typically people that are active
contributors and community members. Anyway, if the rules can be
clarified a little bit, it can somehow clear the doubts in the minds
of contributors and make the community more transparent, reasonable,
and fair.
### Continuous contributions
Committer candidates should have a decent amount of continuous
engagements and contributions (fixing bugs, adding new features,
writing documentation, maintaining issues boards, code review, or answering
community questions) to HertzBeat.
- 3+ months with activity and engagement.
- 20+ pr coding, document, test or other contributions.
### Quality of contributions
- A solid general understanding of the project
- Well tested, well-designed, following Apache HertzBeat™ coding
standards, and simple patches.
- Well-organized and detailed user-oriented documentation.
### Community involvement
- Be active, courteous, and respectful on the dev mailing list and
help mentor newer contributors
and users.
- Be active, courteous, and respectful on the issue tracker for
project maintenance
- Be active, courteous, and respectful for pull requests reviewing
- Be involved in the design road map discussions with a professional
and diplomatic approach even if there is a disagreement
- Promoting the project by writing articles or holding events
+82
View File
@@ -0,0 +1,82 @@
---
id: 'become_pmc_member'
title: 'Become A new PMC member'
sidebar_position: 3
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
## Become A new PMC member of Apache HertzBeat
Anyone being supportive of the community and working in any of the
CoPDoC areas can become an Apache HertzBeat™ new PMC member. The CoPDoC is an
acronym from ASF to describe how we recognize your contributions not
only by code.
- **Community** - You can join us via our mailing list, issue
trackers, discussions page to interact with community members, and
share vision and knowledge
- **Project** - a clear vision and consensus are needed
- **Documentation** - without it, the stuff remains only in the minds
of the authors
- **Code** - discussion goes nowhere without code
Apache HertzBeat™ community strives to be meritocratic. Thus, once someone
has contributed sufficiently to any area of CoPDoC they can be a
candidate for new PMC membership and at last voted in as a HertzBeat
PMC member. Being an Apache HertzBeat™ new PMC member does not necessarily mean
you must commit code with your commit privilege to the codebase; it
means you are committed to the HertzBeat project and are productively
contributing to our community's success.
## new PMC member requirements
There are no strict rules for becoming a committer or new PMC member.
Candidates for new PMC member are typically people that are active
contributors and community members. Anyway, if the rules can be
clarified a little bit, it can somehow clear the doubts in the minds
of contributors and make the community more transparent, reasonable,
and fair.
### Continuous contributions
PMC member candidates should have a decent amount of continuous
engagements and contributions (fixing bugs, adding new features,
writing documentation, maintaining issues boards, code review, or answering
community questions) to HertzBeat.
- 12+ months with activity and engagement.
### Quality of contributions
- A solid general understanding of the project
- Well tested, well-designed, following Apache HertzBeat™ coding
standards, and simple patches.
- Well-organized and detailed user-oriented documentation.
### Community involvement
- Be active, courteous, and respectful on the dev mailing list and
help mentor newer contributors
and users.
- Be active, courteous, and respectful on the issue tracker for
project maintenance
- Be active, courteous, and respectful for pull requests reviewing
- Be involved in the design road map discussions with a professional
and diplomatic approach even if there is a disagreement
- Promoting the project by writing articles or holding events
@@ -0,0 +1,648 @@
---
id: 'code_style_and_quality_guide'
title: 'Code style and quality guide'
sidebar_position: 3
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
## 1 Pull Requests & Changes Rule
1. `ISSUE`/`PR`(pull request) driving and naming
- After creating a new `PR`, you need to associate the existing corresponding `ISSUE` at the Github Development button on the `PR` page (if there is no corresponding ISSUE, it is recommended to create a new corresponding ISSUE).
- Title naming format
`[feature/bugfix/doc/improve/refactor/bug/cleanup] title`
2. Description
- Please fill in the `PR` template to describe the contribution. So that the reviewer can understand the problem and solution from the description, rather than just from the code.
- Check the CheckList
3. It's recommended that `PR` should be arranged changes such as `cleanup`, `Refactor`, `improve`, and `feature` into separated `PRs`/`Commits`.
4. Commit message(English, lowercase, no special characters)
The commit of messages should follow a pattern similar to the `[feature/bugfix/doc/improve/refactor/bug/cleanup] title`
## 2 Code Checkstyle
### 2.1 Configure Checkstyle
1. Install the Checkstyle-IDEA plugin.
2. Open Checkstyle Settings. Click **Settings****Tools****Checkstyle**.
3. Set **Checkstyle version** to **10.14.2**.
4. Set **Scan scope** to **Only Java sources (including tests)**.
5. Click **+** button in the **Configuration** section to open a dialog to choose the checkstyle config file.
1. Enter a **Description**. For example, hertzbeat.
2. Select **Use a local checkstyle file**.
3. Set **File** to **script/checkstyle/checkstyle.xml**.
4. Select **Store relative to project location**.
5. Click **Next****Next****Finish**.
6. Activate the configuration you just added by toggling the corresponding box.
7. Click **OK**.
- Backend code specification Maven plugin: `checkstyle`
Just run `mvn checkstyle:checkstyle`.
- Frontend code formatting plugin `eslint`
Just run `pnpm run lint:fix` in web-app
### 2.2 Document style check
1. Install `markdownlint-cli2` and run `npm install markdownlint-cli2 --global`
2. Run `markdownlint-cli2 "home/**/*.md"` in the project to automatically detect the Markdown file format.
3. Run `markdownlint-cli2 --fix "home/**/*.md"` in the project to automatically format the Markdown file format to ensure that all documents meet the specifications.
Error code description:
| **Error code** | **description** |
|--------------------------------------------| ------------------------------------------------------------ |
| **MD001 heading-increment** | Heading levels should only increment by one level at a time |
| **MD003 heading-style** | Heading style |
| **MD004 ul-style** | Unordered list style |
| **MD005 list-indent** | Inconsistent indentation for list items at the same level |
| **MD007 ul-indent** | Unordered list indentation |
| **MD009 no-trailing-spaces** | Trailing spaces |
| **MD010 no-hard-tabs** | Hard tabs |
| **MD011 no-reversed-links** | Reversed link syntax |
| **MD012 no-multiple-blanks** | Multiple consecutive blank lines |
| **MD013 line-length** | Line length |
| **MD014 commands-show-output** | Dollar signs used before commands without showing output |
| **MD018 no-missing-space-atx** | No space after hash on atx style heading |
| **MD019 no-multiple-space-atx** | Multiple spaces after hash on atx style heading |
| **MD020 no-missing-space-closed-atx** | No space inside hashes on closed atx style heading |
| **MD021 no-multiple-space-closed-atx** | Multiple spaces inside hashes on closed atx style heading |
| **MD022 blanks-around-headings** | Headings should be surrounded by blank lines |
| **MD023 heading-start-left** | Headings must start at the beginning of the line |
| **MD024 no-duplicate-heading** | Multiple headings with the same content |
| **MD025 single-title/single-h1** | Multiple top-level headings in the same document |
| **MD026 no-trailing-punctuation** | Trailing punctuation in heading |
| **MD027 no-multiple-space-blockquote** | Multiple spaces after blockquote symbol |
| **MD028 no-blanks-blockquote** | Blank line inside blockquote |
| **MD029 ol-prefix** | Ordered list item prefix |
| **MD030 list-marker-space** | Spaces after list markers |
| **MD031 blanks-around-fences** | Fenced code blocks should be surrounded by blank lines |
| **MD032 blanks-around-lists** | Lists should be surrounded by blank lines |
| **MD033 no-inline-html** | Inline HTML |
| **MD034 no-bare-urls** | Bare URL used |
| **MD035 hr-style** | Horizontal rule style |
| **MD036 no-emphasis-as-heading** | Emphasis used instead of a heading |
| **MD037 no-space-in-emphasis** | Spaces inside emphasis markers |
| **MD038 no-space-in-code** | Spaces inside code span elements |
| **MD039 no-space-in-links** | Spaces inside link text |
| **MD040 fenced-code-language** | Fenced code blocks should have a language specified |
| **MD041 first-line-heading/first-line-h1** | First line in a file should be a top-level heading |
| **MD042 no-empty-links** | No empty links |
| **MD043 required-headings** | Required heading structure |
| **MD044 proper-names** | Proper names should have the correct capitalization |
| **MD045 no-alt-text** | Images should have alternate text (alt text) |
| **MD046 code-block-style** | Code block style |
| **MD047 single-trailing-newline** | Files should end with a single newline character |
| **MD048 code-fence-style** | Code fence style |
| **MD049 emphasis-style** | Emphasis style |
| **MD050 strong-style** | Strong style |
| **MD051 link-fragments** | Link fragments should be valid |
| **MD052 reference-links-images** | Reference links and images should use a label that is defined |
| **MD053 link-image-reference-definitions** | Link and image reference definitions should be needed |
| **MD054 link-image-style** | Link and image style |
| **MD055 table-pipe-style** | Table pipe style |
| **MD056 table-column-count** | Table column count |
## 3 Programming Specification
### 3.1 Naming Style
1. Prioritize selecting nouns for variable naming, it's easier to distinguish between `variables` or `methods`.
```java
Cache`<String>` publicKeyCache;
```
2. Pinyin abbreviations are prohibited for variables (excluding nouns such as place names), such as chengdu.
3. It is recommended to end variable names with a `type`.
For variables of type `Collection/List`, take `xxxx` (plural representing multiple elements) or end with `xxxList` (specific type).
For variables of type `map`, describe the `key` and `value` clearly:
```java
Map<Long, User> idUserMap;
Map<Long, String> userIdNameMap;
```
4. That can intuitively know the type and meaning of the variable through its name.
Method names should start with a verb first as follows:
```java
void computeVcores(Object parameter1);
```
> Note: It is not necessary to strictly follow this rule in the `Builder` tool class.
### 3.2 Constant Variables Definition
1. Redundant strings should be extracted as constants
> If a constant has been hardcoded twice or more times, please directly extract it as a constant and change the corresponding reference.
> In generally, constants in `log` can be ignored to extract.
- Negative demo:
```java
public static RestResponse success(Object data) {
RestResponse resp = new RestResponse();
resp.put("status", "success");
resp.put("code", ResponseCode.CODE_SUCCESS);
resp.put("data", data);
return resp;
}
public static RestResponse error() {
RestResponse resp = new RestResponse();
resp.put("status", "error");
resp.put("code", ResponseCode.CODE_FAIL);
resp.put("data", null);
return resp;
}
```
- Positive demo:
> Strings are extracted as constant references.
```java
public static final String STATUS = "status";
public static final String CODE = "code";
public static final String DATA = "data";
public static RestResponse success(Object data) {
RestResponse resp = new RestResponse();
resp.put(STATUS, "success");
resp.put(CODE, ResponseCode.CODE_SUCCESS);
resp.put(DATA, data);
return resp;
}
public static RestResponse error() {
RestResponse resp = new RestResponse();
resp.put(STATUS, "error");
resp.put(CODE, ResponseCode.CODE_FAIL);
resp.put(DATA, null);
return resp;
}
```
2. Ensure code readability and intuitiveness
- The string in the `annotation` symbol doesn't need to be extracted as constant.
- The referenced `package` or `resource` name doesn't need to be extracted as constant.
3. Variables that have not been reassigned must also be declared as `<mark>` final `</mark>` types.
4. About the arrangement order of `constant/variable` lines
Sort the variable lines in the class in the order of
1. `public static final V`, `static final V`,`protected static final V`, `private static final V`
2. `public static v`, `static v`,`protected static v`, `private static v`
3. `public v`, `v`, `protected v`, `private v`
### 3.3 Methods Rule
1. Sort the methods in the class in the order of `public`, `protected`, `private`
Static methods of a class can be placed after non-static methods and sorted according to consistent method visibility.
2. When there are restrictions on the method, the parameters and returned values of the method need to be annotated with `@Nonnull` or `@Nullable` annotations and constraints.
For example, if the parameter cannot be null, it is best to add a `@Nonnull` annotation. If the returned value can be null, the `@Nullable` annotation should be added first.
`<mark>` Note: that the package name is `<b>`javax.validation.requirements`</b>` `</mark>`
3. If there are too many lines of code in the method, please have a try on using multiple sub methods at appropriate points to segment the method body.
Generally speaking, it needs to adhere to the following principles:
- Convenient testing
- Good semantics
- Easy to read
In addition, it is also necessary to consider whether the splitting is reasonable in terms of components, logic, abstraction, and other aspects in the scenario.
> However, there is currently no clear definition of demo. During the evolution process, we will provide additional examples for developers to have a clearer reference and understanding.
### 3.4 Collection Rule
1. For `collection` returned values, unless there are special `concurrent` (such as thread safety), always return the `interface`, such as:
- returns `<mark>` List `</mark>` if use `ArrayList`
- returns `<mark>` Map `</mark>` if use `HashMap`
- returns `<mark>` Set `</mark>` if use `HashSet`
2. If there are multiple threads, the following declaration or returned types can be used:
```java
private CurrentHashMap map;
public CurrentHashMap funName();
```
3. Use `isEmpty()` instead of `length() == 0` or `size() == 0`
- Negative demo
```java
if (pathPart.length() == 0) {
return;
}
```
- Positive demo
```java
if (pathPart.isEmpty()) {
return;
}
```
### 3.5 Concurrent Processing
1. The `thread pool` needs to be managed, using a unified entry point to obtain the `thread pool`.
`<mark>` Note: During the evolution process, we will provide additional examples for developers to have a clearer reference and understanding. `</mark>`
2. `Thread pool` needs to be resource constrained to prevent resource leakage caused by improper handling
### 3.6 Control/Condition Statements
1. Avoid unreasonable `condition/control` branches order leads to:
- Multiple code line `depths` of `n+1`
- Redundant lines
Generally speaking, if a method's code line depth exceeds `2+ Tabs` due to continuous nested `if... else..`, it should be considered to try
- `merging branches`,
- `inverting branch conditions`
- `extracting private methods`
to reduce code line depth and improve readability like follows:
- Union or merge the logic into the next level calling
- Negative demo:
```java
if (isInsert) {
save(platform);
} else {
updateById(platform);
}
```
- Positive demo:
```java
saveOrUpdate(platform);
```
- Merge the conditions
- Negative demo:
```java
if (expression1) {
if (expression2) {
......
}
}
```
- Positive demo:
```java
if (expression1 && expression2) {
......
}
```
- Reverse the condition
- Negative demo:
```java
public void doSomething() {
// Ignored more deeper block lines
// .....
if (condition1) {
// ...
} else {
// ...
}
}
```
- Positive demo:
```java
public void doSomething() {
// Ignored more deeper block lines
// .....
if (!condition1) {
// ...
return;
}
// ...
}
```
- Using a single variable or method to reduce the complex conditional expression
- Negative demo:
```java
if (dbType.indexOf("sqlserver") >= 0 || dbType.indexOf("sql server") >= 0) {
// ...
}
```
- Positive demo:
```java
if (containsSqlServer(dbType)) {
// ....
}
//.....
// definition of the containsSqlServer
```
> Using `sonarlint` and `better highlights` to check code depth looks like good in the future.
### 3.7 Code Comments Rule
1. Method lacks comments:
- `When`: When can the method be called
- `How`: How to use this method and how to pass parameters, etc.
- `What`: What functions does this method achieve
- `Note`: What should developers pay attention to when calling this method
2. Missing necessary class header description comments.
Add `What`, `Note`, etc. like mentioned in the `1`.
3. The method declaration in the interface must be annotated.
- If the semantics of the implementation and the annotation content at the interface declaration are inconsistent, the specific implementation method also needs to be rewritten with annotations.
- If the semantics of the method implementation are consistent with the annotation content at the interface declaration, it is not recommended to write annotations to avoid duplicate annotations.
4. The first word in the comment lines need to be capitalized, like `param` lines, `return` lines.
If a special reference as a subject does not need to be capitalized, special symbols such as quotation marks need to be noted.
### 3.8 Java Lambdas
1. Prefer `non-capturing` lambdas (lambdas that do not contain references to the outer scope).
Capturing lambdas need to create a new object instance for every call. `Non-capturing` lambdas can use the same instance for each invocation.
- Negative demo:
```java
map.computeIfAbsent(key, x -> key.toLowerCase())
```
- Positive demo:
```java
map.computeIfAbsent(key, k -> k.toLowerCase());
```
2. Consider method references instead of inline lambdas
- Negative demo:
```java
map.computeIfAbsent(key, k-> Loader.load(k));
```
- Positive demo:
```java
map.computeIfAbsent(key, Loader::load);
```
### 3.9 Java Streams
- Avoid Java Streams in any performance critical code.
- The main motivation to use Java Streams would be to improve code readability. As such, they can be a good match in parts of the code that are not data-intensive, but deal with coordination.
- Even in the latter case, try to limit the scope to a method, or a few private methods within an internal class.
### 3.10 Pre-Conditions Checking
1. Use a unified `Utils.requireXXX` to complete the validation of the prerequisite, and if possible, replace the `AlertXXException.throwIfXXX` by new pre-conditions checking.
### 3.11 StringUtils
1. Use `StringUtils.isBlank` instead of `StringUtils.isEmpty`
- Negative demo:
```java
if (StringUtils.isEmpty(name)) {
return;
}
```
- Positive demo:
```java
if (StringUtils.isBlank(name)) {
return;
}
```
2. Use `StringUtils.isNotBlank` instead of `StringUtils.isNotEmpty`
- Negative demo:
```java
if (StringUtils.isNotEmpty(name)) {
return;
}
```
- Positive demo:
```java
if (StringUtils.isNotBlank(name)) {
return;
}
```
3. Use `StringUtils.isAllBlank` instead of `StringUtils.isAllEmpty`
- Negative demo:
```java
if (StringUtils.isAllEmpty(name, age)) {
return;
}
```
- Positive demo:
```java
if (StringUtils.isAllBlank(name, age)) {
return;
}
```
### 3.12 `Enum` Class
1. Enumeration value comparison
- Negative demo:
```java
if (status.equals(JobStatus.RUNNING)) {
return;
}
```
- Positive demo:
```java
if (status == JobStatus.RUNNING) {
return;
}
```
2. Enumeration classes do not need to implement Serializable
- Negative demo:
```java
public enum JobStatus implements Serializable {
// ...
}
```
- Positive demo:
```java
public enum JobStatus {
// ...
}
```
3. Use `Enum.name()` instead of `Enum.toString()`
- Negative demo:
```java
System.out.println(JobStatus.RUNNING.toString());
```
- Positive demo:
```java
System.out.println(JobStatus.RUNNING.name());
```
4. Enumeration class names uniformly use the Enum suffix
- Negative demo:
```java
public enum JobStatus {
// ...
}
```
- Positive demo:
```java
public enum JobStatusEnum {
// ...
}
```
### 3.13 `Deprecated` Annotation
- Negative demo:
```java
@deprecated
public void process(String input) {
// ...
}
```
- Positive demo:
```java
@Deprecated
public void process(String input) {
// ...
}
```
## 4 Log
1. Use `placeholders` for log output:
- Negative demo
```java
log.info("Deploy cluster request " + deployRequest);
```
- Positive demo
```java
log.info("load plugin:{} to {}", file.getName(), appPlugins);
```
2. Pay attention to the selection of `log level` when printing logs
When printing the log content, if the actual parameters of the log placeholder are passed, it is necessary to avoid premature evaluation to avoid unnecessary evaluation caused by the log level.
- Negative demo:
Assuming the current log level is `INFO`:
```java
// ignored declaration lines.
List`<User>` userList = getUsersByBatch(1000);
LOG.debug("All users: {}", getAllUserIds(userList));
```
- Positive demo:
In this case, we should determine the log level in advance before making actual log calls as follows:
```java
// ignored declaration lines.
List`<User>` userList = getUsersByBatch(1000);
if (LOG.isDebugEnabled()) {
LOG.debug("All ids of users: {}", getAllIDsOfUsers(userList));
}
```
## 5 Testing
1. It's recommended to use `JUnit5` to develop test case preparation
2. The implemented interface needs to write the `e2e` test case script under the `e2e` module.
## References
- [https://site.mockito.org/](https://site.mockito.org/)
- [https://alibaba.github.io/p3c/](https://alibaba.github.io/p3c/)
- [https://junit.org/junit5/](https://junit.org/junit5/)
- [https://streampark.apache.org/](https://streampark.apache.org/)
+21
View File
@@ -0,0 +1,21 @@
---
id: contact
title: Join discussion
sidebar_label: Discussion
---
> If you need any help or want to exchange suggestions during the use process, you can discuss and exchange through ISSUE or Github Discussion.
[Join the Mailing Lists](https://lists.apache.org/list.html?dev@hertzbeat.apache.org) : Mail to `dev-subscribe@hertzbeat.apache.org` to subscribe mailing lists.
[Chat On Discord](https://discord.gg/Fb6M73htGr)
WeChat Group : Add friend `ahertzbeat` and invite to the group.
WeChat Official Account : Search ID `usthecom`.
[Github Discussion](https://github.com/apache/hertzbeat/discussions)
[Follow Us Twitter](https://x.com/hertzbeat1024)
[Subscribe YouTube](https://www.youtube.com/channel/UCri75zfWX0GHqJFPENEbLow)
+178
View File
@@ -0,0 +1,178 @@
---
id: 'contribution'
title: 'Contributor Guide'
sidebar_position: 0
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
> We are committed to maintaining a happy community that helps each other, welcome every contributor to join us!
## Kinds of Contributions
>
> In the HertzBeat community, there are many ways to contribute:
- 💻**Code**: Can help the community complete some tasks, write new features or fix some bugs;
- ⚠️**Test**: Can come to participate in the writing of test code, including unit testing, integration testing, e2e testing;
- 📖**Docs**: Can write or Documentation improved to help users better understand and use HertzBeat;
- 📝**Blog**: You can write articles about HertzBeat to help the community better promote;
- 🤔**Discussion**: You can participate in the discussion of new features of HertzBeat and integrate your ideas with HertzBeat;
- 💡**Preach**: Can help publicize or promote the HertzBeat community, speak in meetup or summit;
- 💬**Suggestion**: You can also make some suggestions to the project or community to promote the healthy development of the community;
More see [Contribution Types](https://allcontributors.org/en/reference/emoji-key/)
Even small corrections to typos are very welcome :)
### Getting HertzBeat up and running
> To get HertzBeat code running on your development tools, and able to debug with breakpoints.
> This is a front-end and back-end separation project. To start the local code, the back-end manager and the front-end web-app must be started separately.
#### Backend start
1. Requires `maven3+`, `java25` and `lombok` environments
2. (Optional) Modify the configuration file: `hertzbeat-startup/src/main/resources/application.yml`
3. Execute under the project root directory: `mvn clean install -DskipTests`
4. Add VM Options: `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`
5. Start `springboot startup` service: `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
#### Frontend start
1. Need `Node pnpm` Environment, Make sure `Node.js >= 18`
2. Cd to the `web-app` directory: `cd web-app`
3. Install pnpm if not existed `npm install -g pnpm`
4. Install Dependencies: `pnpm install` or `pnpm install --registry=https://registry.npmmirror.com` in `web-app`
5. After the local backend is started, start the local frontend in the web-app directory: `pnpm start`
6. Browser access to localhost:4200 to start, default account/password is *admin/hertzbeat*
### Find tasks
Find the issue you are interested in! On our GitHub repo issue list, we often publish some issues with the label good first issue or status: volunteer wanted.
These issues welcome the help of contributors. Among them, good first issues tend to have low thresholds and are suitable for novices.
Of course, if you have a good idea, you can also propose it directly on GitHub Discussion or contact with community.
### Submit Pull Request
1. First you need to fork your target [hertzbeat repository](https://github.com/apache/hertzbeat).
2. Then download the code locally with git command:
```shell
git clone git@github.com:`YOUR_USERNAME`/hertzbeat.git #Recommended
```
3. After the download is complete, please refer to the getting started guide or README file of the target repository to initialize the project.
4. Then, you can refer to the following command to submit the code:
```shell
git checkout -b a-feature-branch #Recommended
```
5. Submit the code as a commit, the commit message format specification required: [module name or type name]feature or bugfix or doc: custom message.
```shell
git add <modified file/path>
git commit -m '[docs]feature: necessary instructions' #Recommended
```
6. Push to the remote repository
```shell
git push origin a-feature-branch
```
7. Then you can initiate a new PR (Pull Request) on GitHub.
Please note that the title of the PR needs to conform to our spec, and write the necessary description in the PR to facilitate code review by Committers and other contributors.
### Wait for the code to be merged
After submitting the PR, the Committee or the community's friends will review the code you submitted (Code Review), and will propose some modification suggestions or conduct some discussions. Please pay attention to your PR in time.
If subsequent changes are required, there is no need to initiate a new PR. After submitting a commit on the original branch and pushing it to the remote repository, the PR will be automatically updated.
In addition, our project has a relatively standardized and strict CI inspection process. After submitting PR, CI will be triggered. Please pay attention to whether it passes the CI inspection.
Finally, the Committers can merge the PR into the master branch.
### After the code is merged
After the code has been merged, you can delete the development branch on both the local and remote repositories:
```shell
git branch -d a-dev-branch
git push origin --delete a-dev-branch
```
On the master/main branch, you can do the following to sync the upstream repository:
```shell
git remote add upstream https://github.com/apache/hertzbeat.git #Bind the remote warehouse, if it has been executed, it does not need to be executed again
git checkout master
git pull upstream master
```
### Get Contributor Certificate
After your pr is merged, you can send an email `dev@hertzbeat.apache.org` to request your Apache HertzBeat™ contributor electronic certificate.
```text
Title: [Contributor] Request for a Contributor Certificate: <Your Full Name>
Body:
Hello,
I would like to request a Contributor Certificate for my contributions to the Apache HertzBeat™ project.
- Full Name: <Your Full Name> # The Full Name will be printed on the certificate, any name you want.
- GitHub Username: <Your GitHub Username>
- Pull Request Links: <List the URLs of the pull requests you have submitted>
- Email Address: <Your Email Address>
Best regards,
<Your Name>
```
You will receive a reply with an electronic certificate within a few working days, and your name will also appear in the list of contributors.
Attention contributor certificates are electronic, and certificates for you to become a `Committer` or `PMC` are physical.
Certificate Sample:
![cert](/img/docs/hertzbeat-cert.png)
### HertzBeat Improvement Proposal (HIP)
If you have major new features(e.g., support metrics push gateway, support logs monitoring), you need to write a design document known as a HertzBeat Improvement Proposal (HIP). Before starting to write a HIP, make sure you follow the process [guide](https://github.com/apache/hertzbeat/tree/master/hip).
### How to become a Committer?
With the above steps, you are a contributor to HertzBeat. Repeat the previous steps to stay active in the community, keep at, you can become a Committer!
### Join Discussion
[Discussion](contact)
+72
View File
@@ -0,0 +1,72 @@
---
id: development
title: How to Run or Build HertzBeat?
sidebar_label: Development
---
## Getting HertzBeat code up and running
> To get HertzBeat code running on your development tools, and able to debug with breakpoints.
> This is a front-end and back-end separation project.
> To start the local code, the back-end [manager](https://github.com/apache/hertzbeat/tree/master/hertzbeat-manager) and the front-end [web-app](https://github.com/apache/hertzbeat/tree/master/web-app) must be started separately.
### Backend start
1. Requires `maven3+`, `java25` and `lombok` environments
2. (Optional) Modify the configuration file: `hertzbeat-startup/src/main/resources/application.yml`
3. Execute under the project root directory: `mvn clean install -DskipTests`
4. Add VM Options: `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`
5. Start `springboot startup` service: `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
### Frontend start
1. Need `Node pnpm` Environment, Make sure `Node.js >= 18`
2. Cd to the `web-app` directory: `cd web-app`
3. Install pnpm if not existed `npm install -g pnpm`
4. Install Dependencies: `pnpm install` or `pnpm install --registry=https://registry.npmmirror.com` in `web-app`
5. After the local backend is started, start the local frontend in the web-app directory: `pnpm start`
6. Browser access to localhost:4200 to start, default account/password is *admin/hertzbeat*
## Build HertzBeat binary package
> Requires `maven3+`, `java25`, `node` and `pnpm` environments.
### Frontend build
1. Need `Node pnpm` Environment, Make sure `Node.js >= 18`
2. Cd to the `web-app` directory: `cd web-app`
3. Install pnpm if not existed `npm install -g pnpm`
4. Install Dependencies: `pnpm install` or `pnpm install --registry=https://registry.npmmirror.com` in `web-app`
5. Build web-app: `pnpm package`
### Backend build
1. Requires `maven3+`, `java25` environments
2. Execute under the project root directory: `mvn clean package -Prelease`
The HertzBeat install package will be generated at `dist/apache-hertzbeat-{version}-bin.tar.gz`
### Collector build
1. Requires `maven3+`, `java25` environments
2. Execute under the project root directory: `mvn clean install`
3. Cd to the `hertzbeat-collector` directory: `cd hertzbeat-collector`
4. Build the JVM collector package under `hertzbeat-collector` directory: `mvn clean package -Pcluster`
5. Build the native collector package under `hertzbeat-collector` directory: `mvn clean package -pl hertzbeat-collector-collector -am -Pnative`
> Native collector packaging requires GraalVM for JDK 25 with the `native-image` tool available in `PATH`.
The HertzBeat collector packages will be generated at `dist/apache-hertzbeat-collector-{version}-bin.tar.gz` and a platform-specific native package such as `dist/apache-hertzbeat-collector-native-{version}-linux-amd64-bin.tar.gz`
+113
View File
@@ -0,0 +1,113 @@
---
id: 'document'
title: 'Documentation Notice'
sidebar_position: 1
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
Good documentation is critical for any type of software. Any contribution that can improve the HertzBeat documentation is welcome.
## Get the document project
Documentation for the HertzBeat project is maintained in [git repository home directory](https://github.com/apache/hertzbeat/tree/master/home).
First you need to fork the document project into your own github repository, and then clone the document to your local computer.
```shell
git clone git@github.com:<your-github-user-name>/hertzbeat.git
```
## Preview and generate static files
This website is compiled using node, using Docusaurus framework components
1. Download and install nodejs (version 18.8.0)
2. Clone the code to the local `git clone git@github.com:apache/hertzbeat.git`
3. In `home` directory run `pnpm install` to install the required dependent libraries.
4. In `home` directory run `pnpm start`, you can visit [http://localhost:3000](http://localhost:3000) to view the English mode preview of the site
5. In `home` directory run `pnpm start-zh-cn`, you can visit [http://localhost:3000](http://localhost:3000) to view the Chinese mode preview of the site
6. To generate static website resource files, run `pnpm build`. The static resources of the build are in the build directory.
## Document Format Inspection
In Apache HertzBeat, all MD articles have to pass MD's [CI](https://github.com/apache/hertzbeat/blob/master/.github/workflows/doc-build-test.yml) inspection before they can be merged. The purpose is to keep the website looking nice and the formatting of the articles consistent.
After you have written an MD article, you can execute the following command locally to check whether the content of the MD article meets the requirements, so as to reduce the workload of review and save your time:
```shell
cd home && pnpm install
pnpm md-lint
# If the documentation is wrong, you can use pnpm md-lint-fix to fix it.
pnpm md-lint-fix
```
For formatting rules for MD articles you can refer to: [Markdown-lint-rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md)
MD format configuration file in the project: [.markdownlint-cli2.jsonc](https://github.com/apache/hertzbeat/blob/master/.markdownlint-cli2.jsonc)
## Directory structure
```html
|-- docs
|-- blog
|-- i18n
| `-- zh-CN // internationalized chinese
| |-- code.json
| |-- docusaurus-plugin-content-blog
| |-- docusaurus-plugin-content-docs
| `-- docusaurus-theme-classic
|-- resource // static resource file
|-- src
| |-- theme
| |-- css
| |-- js
| |-- pages
| | |-- components
| | |-- index.js
| |-- constants.js
|-- static // picture static resource
| |-- img //
| | |-- blog // blog picture
| | |-- docs // document picture
| | |-- home // product picture
| | |-- icons // icon
|-- docusaurus.config.js
|-- sidebars.js // document sidebar menu configuration
```
## Specification
### Naming convention of files
Consist entirely of lowercase letters, numbers, underscores, and dashes.
Positive example: `render-dom.js / signup.css / index.html / company-logo.png / hertz_beat.md`
Counter example: `renderDom.js / UserManagement.html`
### Resource Path
Image resources are unified under `static/img/{module name}`
css and other style files are placed in the `src/css` directory
### Page content modification
> All pages doc can be directly jumped to the corresponding github resource modification page through the 'Edit this page' button at the bottom
+537
View File
@@ -0,0 +1,537 @@
---
id: 'how_to_release'
title: How to Release
sidebar_position: 4
---
This tutorial describes in detail how to release Apache HertzBeat™, take the release of version 1.7.3 as an example.
## 1. Environmental requirements
This release process is operated in the UbuntuOS(Windows,Mac), and the following tools are required:
- JDK 25
- Node18 pnpm
- Apache Maven 3.x
- GnuPG 2.x
- Git
- SVN (apache uses svn to host project releases)
> Pay attention to setting environment variables `export GPG_TTY=$(tty)`
## 2. Preparing for release
> First summarize the account information to better understand the operation process, will be used many times later.
>
> - apache id: `muchunjin (APACHE LDAP UserName)`
> - apache passphrase: `APACHE LDAP Passphrase`
> - apache email: `muchunjin@apache.org`
> - gpg real name: `muchunjin (Any name can be used, here I set it to the same name as the apache id)`
> - gpg key passphrase: `The password set when creating the gpg key, you need to remember this password`
### 2.1 Key generation
```shell
$ gpg --full-gen-key
gpg (GnuPG) 2.2.27; Copyright (C) 2021 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)
(14) Existing key from card
Your selection? 1 # Please enter 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (3072) 4096 # Please enter 4096 here
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) 0 # Please enter 0
Key does not expire at all
Is this correct? (y/N) y # Please enter y here
GnuPG needs to construct a user ID to identify your key.
Real name: muchunjin # Please enter 'gpg real name'
Email address: muchunjin@apache.org # Please enter your apache email address here
Comment: apache key # Please enter some comments here
You selected this USER-ID:
"muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O # Please enter O here
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
# At this time, a dialog box will pop up, asking you to enter the key for this gpg.
# you need to remember that it will be used in subsequent steps.
┌─────────────────────────────────────────────────────┐
│ Please enter this passphrase to │
│ protect your new key │
│ │
│ Passphrase: _______________________________________ │
│ │
`<OK>` `<Cancel>`
└─────────────────────────────────────────────────────┘
# Here you need to re-enter the password in the previous step.
┌─────────────────────────────────────────────────────┐
│ Please re-enter this passphrase │
│ │
│ Passphrase: _______________________________________ │
│ │
`<OK>` `<Cancel>`
└─────────────────────────────────────────────────────┘
gpg: key ACFB69E705016886 marked as ultimately trusted
gpg: revocation certificate stored as '/root/.gnupg/openpgp-revocs.d/DC12398CCC33A5349EB9663DF9D970AB18C9EDF6.rev'
public and secret key created and signed.
pub rsa4096 2023-05-01 [SC]
85778A4CE4DD04B7E07813ABACFB69E705016886
uid muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)
sub rsa4096 2023-05-01 [E]
```
Keys can be viewed through the `gpg --list-signatures` command
### 2.2 Upload the generated key to the public server
```shell
$ gpg --keyid-format SHORT --list-keys
/root/.gnupg/pubring.kbx
------------------------
pub rsa4096/05016886 2023-05-01 [SC]
85778A4CE4DD04B7E07813ABACFB69E705016886
uid [ultimate] muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)
sub rsa4096/0C5A4E1C 2023-05-01 [E]
# Send public key to keyserver via key id
$ gpg --keyserver keyserver.ubuntu.com --send-key 05016886
# Among them, keyserver.ubuntu.com is the selected keyserver, it is recommended to use this, because the Apache Nexus verification uses this keyserver
```
#### 2.3 Check if the key is created successfully
Verify whether it is synchronized to the public network, it will take about a minute to find out the answer, if not successful, you can upload and retry multiple times.
```shell
$ gpg --keyserver keyserver.ubuntu.com --recv-keys 05016886 # If the following content appears, it means success
gpg: key ACFB69E705016886: "muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)" not changed
gpg: Total number processed: 1
gpg: unchanged: 1
```
Or enter [https://keyserver.ubuntu.com/](https://keyserver.ubuntu.com/) address in the browser, enter the name of the key and click 'Search key' to search if existed.
#### 2.4 Add the gpg public key to the KEYS file of the Apache SVN project repo
- Apache HertzBeat™ Branch Dev [https://dist.apache.org/repos/dist/dev/hertzbeat](https://dist.apache.org/repos/dist/dev/hertzbeat)
- Apache HertzBeat™ Branch Release [https://dist.apache.org/repos/dist/release/hertzbeat](https://dist.apache.org/repos/dist/release/hertzbeat)
##### 2.4.1 Add public key to KEYS in dev branch
```shell
$ mkdir -p svn/dev
$ cd svn/dev
$ svn co https://dist.apache.org/repos/dist/dev/hertzbeat
$ cd svn/dev/hertzbeat
# Append the KEY you generated to the file KEYS, and check if it is added correctly
$ (gpg --list-sigs muchunjin@apache.org && gpg --export --armor muchunjin@apache.org) >> KEYS
$ svn ci -m "add gpg key for muchunjin"
```
##### 2.4.2 Add public key to KEYS in release branch
```shell
$ mkdir -p svn/release
$ cd svn/release
$ svn co https://dist.apache.org/repos/dist/release/hertzbeat
$ cd svn/release/hertzbeat
# Append the KEY you generated to the file KEYS, and check if it is added correctly
$ (gpg --list-sigs muchunjin@apache.org && gpg --export --armor muchunjin@apache.org) >> KEYS
$ svn ci -m "add gpg key for muchunjin"
```
## 3. Prepare material package & release
### Build Package
#### 3.1 Based on the master branch, create a release-`release_version`-rcx branch, such as release-1.7.3-rc1, And create a tag named v1.7.3-rc1 based on the release-1.7.3-rc1 branch, and set this tag as pre-release
```shell
git checkout master
git checkout -b release-1.7.3-rc1
```
#### 3.2 checkout release branch to local
```shell
git checkout release-1.7.3-rc1
```
#### 3.3 Compile the binary package
> Build HertzBeat server binary, run script in `web-app`
```shell
pnpm install
pnpm package
```
> run script in root
```shell
mvn clean package -Prelease
```
then
```shell
mvn clean install
```
> Build HertzBeat collector binary, run script in `collector`
```shell
mvn clean package -Pcluster
```
> Build the native collector binary for the current host with GraalVM JDK 25 and `native-image`
```shell
mvn clean package -pl hertzbeat-collector-collector -am -Pnative
```
> The repository workflow `.github/workflows/collector-native-build.yml` is a release helper, not a regular PR or push CI workflow.
>
> It is intentionally manual-only because multi-platform native builds are relatively slow and consume scarce Linux ARM, macOS, and Windows runners. During release preparation, open the Actions page, select `Collector Native Release`, run it from the release branch or tag, and then download the uploaded artifacts for signing and publishing.
The release package are here:
- `dist/apache-hertzbeat-{version}-bin.tar.gz`
- `dist/apache-hertzbeat-collector-{version}-bin.tar.gz`
- `dist/apache-hertzbeat-collector-native-{version}-linux-amd64-bin.tar.gz`
- `dist/apache-hertzbeat-collector-native-{version}-linux-arm64-bin.tar.gz`
- `dist/apache-hertzbeat-collector-native-{version}-macos-amd64-bin.tar.gz`
- `dist/apache-hertzbeat-collector-native-{version}-macos-arm64-bin.tar.gz`
- `dist/apache-hertzbeat-collector-native-{version}-windows-amd64-bin.zip`
- `dist/apache-hertzbeat-{version}-docker-compose.tar.gz`
#### 3.4 Package the source code
> Package the project source code
```shell
git archive \
--format=tar.gz \
--output="dist/apache-hertzbeat-1.7.3-src.tar.gz" \
--prefix=apache-hertzbeat-1.7.3-src/ \
release-1.7.3-rc1
```
The archive package is here `dist/apache-hertzbeat-1.7.3-src.tar.gz`
### Sign package
#### 3.5 Sign binary and source packages
> The `gpg -u 33545C76` `33545C76` is your gpg secret ID, see from `gpg --keyid-format SHORT --list-keys`
```shell
cd dist
# sign
for i in *.tar.gz; do echo $i; gpg -u 33545C76 --armor --output $i.asc --detach-sig $i ; done
# SHA512
for i in *.tar.gz; do echo $i; sha512sum $i > $i.sha512 ; done
# if macos sha512sum not found, you can install by brew install coreutils
```
> The final file list is as follows
```text
apache-hertzbeat-1.7.3-src.tar.gz
apache-hertzbeat-1.7.3-src.tar.gz.asc
apache-hertzbeat-1.7.3-src.tar.gz.sha512
apache-hertzbeat-1.7.3-bin.tar.gz
apache-hertzbeat-1.7.3-bin.tar.gz.asc
apache-hertzbeat-1.7.3-bin.tar.gz.sha512
apache-hertzbeat-1.7.3-docker-compose.tar.gz
apache-hertzbeat-1.7.3-docker-compose.tar.gz.asc
apache-hertzbeat-1.7.3-docker-compose.tar.gz.sha512
apache-hertzbeat-collector-1.7.3-bin.tar.gz
apache-hertzbeat-collector-1.7.3-bin.tar.gz.asc
apache-hertzbeat-collector-1.7.3-bin.tar.gz.sha512
```
#### 3.6 Verify signature
```shell
$ cd dist
# Verify signature
$ for i in *.tar.gz; do echo $i; gpg --verify $i.asc $i ; done
apache-hertzbeat-1.7.3-bin.tar.gz
gpg: Signature made Tue May 2 12:16:35 2023 CST
gpg: using RSA key 85778A4CE4DD04B7E07813ABACFB69E705016886
gpg: Good signature from "muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)" [ultimate]
apache-hertzbeat-1.7.3-docker-compose.tar.gz
gpg: Signature made Tue May 2 12:16:36 2023 CST
gpg: using RSA key 85778A4CE4DD04B7E07813ABACFB69E705016886
gpg: Good signature from "muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)" [ultimate]
apache-hertzbeat-1.7.3-src.tar.gz
gpg: Signature made Tue May 2 12:16:37 2023 CST
gpg: using RSA key 85778A4CE4DD04B7E07813ABACFB69E705016886
gpg: Good signature from "muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)" [ultimate]
apache-hertzbeat-collector-1.7.3-bin.tar.gz
gpg: Signature made Tue May 2 12:16:37 2023 CST
gpg: using RSA key 85778A4CE4DD04B7E07813ABACFB69E705016886
gpg: Good signature from "muchunjin (apache key) [muchunjin@apache.org](mailto:muchunjin@apache.org)" [ultimate]
# Verify SHA512
$ for i in *.tar.gz; do echo $i; sha512sum --check $i.sha512; done
apache-hertzbeat-1.7.3-src.tar.gz
apache-hertzbeat-1.7.3-src.tar.gz: OK
apache-hertzbeat-1.7.3-bin.tar.gz
apache-hertzbeat-1.7.3-bin.tar.gz: OK
apache-hertzbeat-1.7.3-docker-compose.tar.gz
apache-hertzbeat-1.7.3-docker-compose.tar.gz: OK
apache-hertzbeat-collector-1.7.3-bin.tar.gz
apache-hertzbeat-collector-1.7.3-bin.tar.gz: OK
```
#### 3.7 Publish the dev directory of the Apache SVN material package
- Clone the dev directory
```shell
# Check out the dev directory of the Apache SVN to the svn/dev directory under dist in the root directory of the Apache HertzBeat™ project
svn co https://dist.apache.org/repos/dist/dev/hertzbeat svn/dev
svn co --depth empty https://dist.apache.org/repos/dist/dev/hertzbeat
```
- Copy the material package to the dev directory
Create a version number directory and name it in the form of `release_version`-`RC_version`. RC_version starts from 1, that is, the candidate version starts from RC1. During the release process, there is a problem that causes the vote to fail.
If it needs to be corrected, it needs to iterate the RC version , the RC version number needs to be +1. For example: Vote for version 1.7.3-RC1. If the vote passes without any problems, the RC1 version material will be released as the final version material.
If there is a problem (when the hertzbeat/incubator community votes, the voters will strictly check various release requirements and compliance issues) and need to be corrected, then re-initiate the vote after the correction, and the candidate version for the next vote is 1.7.3- RC2.
```shell
mkdir -p svn/dev/1.7.3-RC1
cp -f dist/* svn/dev/1.7.3-RC1
```
- Commit to SVN
```shell
cd svn/dev
# 1.check svn status
svn status
# 2. add to svn
svn add 1.7.3-RC1
svn status
# 3. Submit to svn remote server
svn commit -m "release for HertzBeat 1.7.3"
```
- Check Apache SVN Commit Results
> Visit the address [https://dist.apache.org/repos/dist/dev/hertzbeat/](https://dist.apache.org/repos/dist/dev/hertzbeat/) in the browser, check if existed the new material package
## 4. Enter the community voting stage
### 4.1 Send a Community Vote Email
Send a voting email in the community requires at least three `+1` and no `-1`.
> `Send to`: [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) <br />
> `Title`: [VOTE] Release Apache HertzBeat™ 1.7.3 rc1 <br />
> `Body`:
```text
Hello HertzBeat Community:
This is a call for vote to release Apache HertzBeat™ version release-1.7.3-RC1.
Apache HertzBeat™ - A real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
Release notes:
https://github.com/apache/hertzbeat/releases/tag/v1.7.3-rc1
The release candidates:
https://dist.apache.org/repos/dist/dev/hertzbeat/1.7.3-RC1/
Git tag for the release:
https://github.com/apache/hertzbeat/releases/tag/v1.7.3-rc1
The artifacts signed with PGP key [33545C76], corresponding to [muchunjin@apache.org], that can be found in keys file:
https://downloads.apache.org/hertzbeat/KEYS
The vote will be open for at least 72 hours or until the necessary number of votes are reached.
Please vote accordingly:
[ ] +1 approve
[ ] +0 no opinion
[ ] -1 disapprove with the reason
*Valid check is a requirement for a vote. *Checklist for reference:
[ ] Download HertzBeat 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 HertzBeat repo.
[ ] All files have license headers if necessary.
[ ] No compiled archives bundled in source archive.
[ ] Can compile from source.
Steps to validate the releasePlease refer to:
https://hertzbeat.apache.org/docs/community/how_to_verify_release
How to Build:
https://hertzbeat.apache.org/docs/community/development/#build-hertzbeat-binary-package
Thanks!
```
After 72 hours, the voting results will be counted, and the voting result email will be sent, as follows.
> `Send to`: [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) <br />
> `Title`: [RESULT]\[VOTE\] Release Apache HertzBeat™ 1.7.3-rc1 <br />
> `Body`:
```text
Dear HertzBeat community,
Thanks for your review and vote for "Release Apache HertzBeat™ 1.7.3-rc1"
I'm happy to announce the vote has passed:
---
4 binding +1, from:
- cc
1 non-binding +1, from:
- Roc Marshal
---
no 0 or -1 votes.
Vote thread:
https://lists.apache.org/thread/t01b2lbtqzyt7j4dsbdp5qjc3gngjsdq
---
Thank you to everyone who helped us to verify and vote for this release. We will move to the ASF Incubator voting shortly.
---
Best,
ChunJin Mu
```
One item of the email content is `Vote thread`, and the link is obtained here: [https://lists.apache.org/list.html?dev@hertzbeat.apache.org](https://lists.apache.org/list.html?dev@hertzbeat.apache.org)
## 4. Complete the final publishing steps
### 4.1 Migrating source and binary packages
```shell
svn mv https://dist.apache.org/repos/dist/dev/hertzbeat/1.7.3-RC1 https://dist.apache.org/repos/dist/release/hertzbeat/1.7.3 -m "transfer packages for 1.7.3-RC1"
```
#### 4.2 Add the new version download address to the official website
[https://github.com/apache/hertzbeat/blob/master/home/docs/download.md](https://github.com/apache/hertzbeat/blob/master/home/docs/download.md)
[https://github.com/apache/hertzbeat/blob/master/home/i18n/zh-cn/docusaurus-plugin-content-docs/current/download.md](https://github.com/apache/hertzbeat/blob/master/home/i18n/zh-cn/docusaurus-plugin-content-docs/current/download.md)
Open the official website address [https://hertzbeat.apache.org/docs/download/](https://hertzbeat.apache.org/docs/download/) to see if there is a new version of the download
> It should be noted that the download link may take effect after an hour, so please pay attention to it.
#### 4.3 Generate a release on github
Update pre-release to create a tag named v1.7.3 based on the release-1.7.3-rc1 branch, and set this tag to latest release.
:::tip
You can modify it on the original RC Release without creating a new Release.
:::
Then enter Release Title and Describe
- Release Title:
```text
v1.7.3
```
- Describe:
```text
xxx
release note: xxx
```
Then click the `Publish release` button.
The rename the release-1.7.3-rc1 branch to release-1.7.3.
#### 4.5 Send new version announcement email
> `Send to`: [announce@apache.org](mailto:announce@apache.org) <br />
> `cc`: [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) <br />
> `Title`: [ANNOUNCE] Apache HertzBeat™ 1.7.3 released <br />
> `Body`:
```text
Hi Community,
We are glad to announce the release of Apache HertzBeat™ 1.7.3.
Thanks again for your help.
Apache HertzBeat™ (https://hertzbeat.apache.org/) - A real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
Download Link:
https://hertzbeat.apache.org/docs/download/
Release Note:
https://github.com/apache/hertzbeat/releases/tag/v1.7.3
Website:
https://hertzbeat.apache.org/
HertzBeat Resources:
- Issue: https://github.com/apache/hertzbeat/issues
- Mailing list: dev@hertzbeat.apache.org
---
Apache HertzBeat™ Team
---
Best,
ChunJin Mu
```
This version release is over.
---
This doc refer from [Apache StreamPark](https://streampark.apache.org/)
+185
View File
@@ -0,0 +1,185 @@
---
id: how_to_verify_release
title: How to Verify Release
sidebar_position: 4
---
## Verify the candidate version
For detailed check list, please refer to the official [check list](https://cwiki.apache.org/confluence/display/INCUBATOR/Incubator+Release+Checklist)
Version content accessible in browser [https://dist.apache.org/repos/dist/dev/hertzbeat/](https://dist.apache.org/repos/dist/dev/hertzbeat/)
### 1. Download the candidate version
Download the candidate version to be released to the local environment Need to rely on gpg tool, if not, it is recommended to install `gpg2`.
:::caution
If the network is poor, downloading may be time-consuming. The download is completed normally in about 20 minutes, please wait patiently.
:::
```shell
#If there is svn locally, you can clone to the local
$ svn co https://dist.apache.org/repos/dist/dev/hertzbeat/`release_version`-`rc_version`/
#or download the material file directly
$ wget https://dist.apache.org/repos/dist/dev/hertzbeat/`release_version`-`rc_version`/xxx.xxx
```
### 2. Verify that the uploaded version is compliant
Start the verification process, which includes but is not limited to the following content and forms.
#### 2.1 Check whether the release package is complete
The package uploaded to dist must include the source code package, and the binary package is optional.
1. Whether to include the source code package
2. Whether to include the signature of the source code package
3. Whether to include the sha512 of the source code package
4. If the binary package is uploaded, also check the contents listed in (2)-(4)
#### 2.2 Check gpg signature
First import the publisher's public key. Import KEYS from the svn repository to the local environment. (The person who releases the version does not need to import it again, the person who helps to do the verification needs to import it, and the user name is enough for the person who issued the version)
##### 2.2.1 Import public key
```shell
-curl https://downloads.apache.org/hertzbeat/KEYS > KEYS # Download KEYS
gpg --import KEYS # Import KEYS to local
```
##### 2.2.2 Trust the public key
Trust the KEY used in this version:
```shell
$ gpg --edit-key xxxxxxxxxx #KEY user used in this version
gpg (GnuPG) 2.2.21; Copyright (C) 2020 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.
Secret key is available.
gpg> trust #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 #choose 5
Do you really want to set this key to ultimate trust? (y/N) y #choose y
gpg>
```
##### 2.2.3 Check the gpg signature
```shell
for i in *.tar.gz; do echo $i; gpg --verify $i.asc $i; done
```
check result
> If something like the following appears, it means the signature is correct. Keyword: **`Good signature`**
```shell
apache-hertzbeat-${release_version}-src.tar.gz
gpg: Signature made XXXX
gpg: using RSA key XXXXX
gpg: Good signature from "XXX <xxx@apache.org>"
```
#### 2.3 Check sha512 hash
```shell
for i in *.tar.gz; do echo $i; sha512sum --check $i.sha512; done
```
#### 2.4 Check the binary package
unzip `apache-hertzbeat-${release.version}-bin.tar.gz`
```shell
tar -xzvf apache-hertzbeat-${release.version}-bin.tar.gz
```
check as follows:
- [ ] Check whether the source package contains unnecessary files, which makes the tar package too large
- [ ] There are `LICENSE` and `NOTICE` files
- [ ] The year in the `NOTICE` file is correct
- [ ] Only text files exist, not binary files
- [ ] All files have ASF license at the beginning
- [ ] Able to compile correctly
- [ ] .....
#### 2.5 Check the source package
> If the binary/web-binary package is uploaded, check the binary package.
Unzip `apache-hertzbeat-${release_version}-src.tar.gz`
```shell
cd apache-hertzbeat-${release_version}-src
```
compile the source code: [Build HertzBeat Binary Package](https://hertzbeat.apache.org/docs/community/development/#build-hertzbeat-binary-package)
and check as follows:
- [ ] There are `LICENSE` and `NOTICE` files
- [ ] The year in the `NOTICE` file is correct
- [ ] All text files have ASF license at the beginning
- [ ] Check the third-party dependent license:
- [ ] Compatible with third-party dependent licenses
- [ ] All third-party dependent licenses are named in the `LICENSE` file
- [ ] If you are relying on the Apache license and there is a `NOTICE` file, then these `NOTICE` files also need to be added to the version of the `NOTICE` file
- [ ] .....
You can refer to this article: [ASF Third Party License Policy](https://apache.org/legal/resolved.html)
### 3. Email reply
If you initiate a posting vote, you can refer to this response example to reply to the email after verification
:::caution Attention
When replying to the email, you must bring the information that you have checked by yourself. Simply replying to `+1 approve` is invalid.
When new PMC votes in the [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) hertzbeat community, Please bring the binding suffix to indicate that it has a binding vote for the vote in the hertzbeat community, and it is convenient to count the voting results.
:::
Non-PMC member:
```text
+1 (non-binding)
I checked:
1. All download links are valid
2. Checksum and signature are OK
3. LICENSE and NOTICE are exist
4. Build successfully on macOS(Big Sur)
5.
```
PMC member:
```text
+1 (binding)
I checked:
1. All download links are valid
2. Checksum and signature are OK
3. LICENSE and NOTICE are exist
4. Build successfully on macOS(Big Sur)
5.
```
---
This doc refer from [Apache StreamPark](https://streampark.apache.org/)
+61
View File
@@ -0,0 +1,61 @@
---
id: 'mailing_lists'
title: 'Mailing Lists'
sidebar_position: 1
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
The [Developer Mailing List](https://lists.apache.org/list.html?dev@hertzbeat.apache.org) is the community-recommended way to communicate and obtain the latest information.
Before you post anything to the mailing lists, be sure that you already **subscribe** to them.
## Usages
### Developer List
- Use this list for your HertzBeat questions
- Used by HertzBeat contributors to discuss development of HertzBeat
| List Name | Address | Subscribe | Unsubscribe | Archive |
|--------------------|--------------------------|--------------------------------------------------------|------------------------------------------------------------|------------------------------------------------------------------------|
| **Developer List** | [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) | [subscribe](mailto:dev-subscribe@hertzbeat.apache.org) | [unsubscribe](mailto:dev-unsubscribe@hertzbeat.apache.org) | [archive](https://lists.apache.org/list.html?dev@hertzbeat.apache.org) |
### Notification List
- Notifications on changes to the HertzBeat codebase
| List Name | Address | Subscribe | Unsubscribe | Archive |
|-----------------------|------------------------------------|------------------------------------------------------------------|----------------------------------------------------------------------|----------------------------------------------------------------------------------|
| **Notification List** | [notifications@hertzbeat.apache.org](mailto:notifications@hertzbeat.apache.org) | [subscribe](mailto:notifications-subscribe@hertzbeat.apache.org) | [unsubscribe](mailto:notifications-unsubscribe@hertzbeat.apache.org) | [archive](https://lists.apache.org/list.html?notifications@hertzbeat.apache.org) |
## Steps for Subscription
Sending a subscription email is also very simple. The steps are as follows:
- 1、**Subscribe**: Click the **subscribe** button in the above table, and it redirects to your mail client. The subject and content are arbitrary.
After that, you will receive a confirmation email from [dev-help@hertzbeat.apache.org](mailto:dev-help@hertzbeat.apache.org) (if not received, please confirm whether the email is automatically classified as SPAM, promotion email, subscription email, etc.).
- 2、**Confirm**: Reply directly to the confirmation email, or click on the link in the email to reply quickly. The subject and content are arbitrary.
- 3、**Welcome**: After completing the above steps, you will receive a welcome email with the subject WELCOME to [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org), and you have successfully subscribed to the Apache HertzBeat mailing list.
## Post Plain Text Mails
When posting to the mailing lists, please use plain text emails.
**Do not use HTML emails**.
HTML emails are more likely to be targeted as spam mails and rejected.
It may get malformed through different mail clients and not easily readable by others.
+92
View File
@@ -0,0 +1,92 @@
---
id: maturity
title: Maturity
sidebar_position: 0
---
## Maturity Assessment for Apache HertzBeat™
The goals of this maturity model are to describe how Apache projects operate in a concise and high-level way, and to
provide a basic framework that projects may choose to use to evaluate themselves.
More details can be found in
the [Apache Project Maturity Model](https://community.apache.org/apache-way/apache-project-maturity-model.html).
## Status of this assessment
This assessment is evaluated during HertzBeat's Incubating.
## Maturity model assessment
The following table is filled according to
the [Apache Maturity Model](https://community.apache.org/apache-way/apache-project-maturity-model.html). Mentors and
community members are welcome to comment and modify it.
### CODE
| **ID** | **Description** | **Status** |
|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **CD10** | The project produces Open Source software for distribution to the public, at no charge. | **YES** The project source code is licensed under the `Apache License 2.0`. |
| **CD20** | Anyone can easily discover and access the project's code.. | **YES** The [official website](https://hertzbeat.apache.org/) includes `GitHub` link which can access the project's repository on GitHub directly. |
| **CD30** | Anyone using standard, widely-available tools, can build the code in a reproducible way. | **YES** Apache HertzBeat provide `how-to-build` document for every component to tell user how to compile on bare metal, such as the [core's](https://hertzbeat.apache.org/docs/community/development). |
| **CD40** | The full history of the project's code is available via a source code control system, in a way that allows anyone to recreate any released version. | **YES** It depends on git, and anyone can view the full history of the project via commit logs. |
| **CD50** | The source code control system establishes the provenance of each line of code in a reliable way, based on strong authentication of the committer. When third parties contribute code, commit messages provide reliable information about the code provenance. | **YES** The project uses GitHub and managed by Apache Infra, it ensuring provenance of each line of code to a committer. And the third-party contributions are accepted in accordance with the contributing guides. |
### LICENSE
| **ID** | **Description** | **Status** |
|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **LC10** | The Apache License, version 2.0, covers the released code. | **YES** The [LICENSE](https://github.com/apache/hertzbeat/blob/master/LICENSE) is in GitHub repository. And all source files are with APLv2 header, checked by Github Action. |
| **LC20** | Libraries that are mandatory dependencies of the project's code do not create more restrictions than the Apache License does. | **YES** All dependencies are listed. |
| **LC30** | The libraries mentioned in LC20 are available as Open Source software. | **YES** All dependencies are listed are available as Open Source software |
| **LC40** | Committers are bound by an Individual Contributor Agreement (the "Apache iCLA") that defines which code they may commit and how they need to identify code that is not their own. | **YES** All committers have iCLAs. |
| **LC50** | The project clearly defines and documents the copyright ownership of everything that the project produces. | **YES** And all source files are with APLv2 header, checked by GitHub Action. |
### Releases
| **ID** | **Description** | **Status** |
|----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **RE10** | Releases consist of source code, distributed using standard and open archive formats that are expected to stay readable in the long term. | **YES** Source release is distributed via [dist.apache.org](https://dist.apache.org/repos/dist/release/incubator/hertzbeat/) and linked from [download page](https://hertzbeat.apache.org/docs/download). |
| **RE20** | The project's PPMC (Project Management Committee, see CS10) approves each software release in order to make the release an act of the Foundation. | **YES** All releases have been voted at [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org) and [general@incubator.apache.org](mailto:general@incubator.apache.org), and have at least 3 PPMC member's votes. |
| **RE30** | Releases are signed and/or distributed along with digests that anyone can reliably use to validate the downloaded archives. | **YES** All releases are signed, and the [KEYS](https://dist.apache.org/repos/dist/release/hertzbeat/KEYS) are available. |
| **RE40** | The project can distribute convenience binaries alongside source code, but they are not Apache Releases, they are provided with no guarantee. | **YES** User can easily build binaries from source code, and we do not provide binaries as Apache Releases. |
| **RE50** | The project documents a repeatable release process so that someone new to the project can independently generate the complete set of artifacts required for a release. | **YES** We can follow the [Release guide](https://hertzbeat.apache.org/docs/community/how_to_release) to make a new Apache HertzBeat release, and so far we had 4 different release managers. |
### Quality
| **ID** | **Description** | **Status** |
|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **QU10** | The project is open and honest about the quality of its code. Various levels of quality and maturity for various modules are natural and acceptable as long as they are clearly communicated. | **YES** We encourage user to [report issues](https://github.com/apache/hertzbeat/issues). |
| **QU20** | The project puts a very high priority on producing secure software. | **YES** All security reports are actively handled. |
| **QU30** | The project provides a well-documented, secure and private channel to report security issues, along with a documented way of responding to them. | **Yes** The official Github Repo provides a [security doc](https://github.com/apache/hertzbeat/blob/master/SECURITY.md) |
| **QU40** | The project puts a high priority on backwards compatibility and aims to document any incompatible changes and provide tools and documentation to help users transition to new features. | **Yes** We follow semantic versions. As long as it's within one major version, it's backward compatible. And when any breaking changes added, we provide corresponding upgrade guides. |
| **QU50** | The project strives to respond to documented bug reports in a timely manner. | **YES** The project has resolved 743+ issues and 2348+ pull requests so far, with very prompt response. |
### Community
| **ID** | **Description** | **Status** |
|----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **CO10** | The project has a well-known homepage that points to all the information required to operate according to this maturity model. | **YES** The [official website](https://hertzbeat.apache.org/) includes all information user need to run Apache HertzBeat. |
| **CO20** | The community welcomes contributions from anyone who acts in good faith and in a respectful manner, and who adds value to the project. | **Yes** We provide contributing guides for every component. And we also have a [general contributing guide](https://hertzbeat.apache.org/docs/community/contribution) |
| **CO30** | Contributions include source code, documentation, constructive bug reports, constructive discussions, marketing and generally anything that adds value to the project. | **YES** All good contributions including code and non-code are welcomed. |
| **CO40** | The community strives to be meritocratic and gives more rights and responsibilities to contributors who, over time, add value to the project. | **YES** The community has elected 3 new PMC members and 13 new committers so far. |
| **CO50** | The project documents how contributors can earn more rights such as commit access or decision power, and applies these principles consistently. | **YES** The community has clear docs on nominating committers and PPMC members |
| **CO60** | The community operates based on consensus of its members (see CS10) who have decision power. Dictators, benevolent or not, are not welcome in Apache projects. | **YES** All decisions are made after vote by community members. |
| **CO70** | The project strives to answer user questions in a timely manner. | **YES** We use [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org), [GitHub issue](https://github.com/apache/hertzbeat/issues) and [GitHub discussion](https://github.com/apache/hertzbeat/discussions) to do this in a timely manner. |
### Consensus
| **ID** | **Description** | **Status** |
|----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|
| **CS10** | The project maintains a public list of its contributors who have decision power. The project's PPMC (Project Management Committee) consists of those contributors. | **Yes** See [members](https://hertzbeat.apache.org/team/) with all PPMC members and committers. |
| **CS20** | Decisions require a consensus among PPMC members and are documented on the project's main communications channel. The PPMC takes community opinions into account, but the PPMC has the final word. | **YES** All decisions are made by votes on [dev@hertzbeat.apache.org](mailto:dev@hertzbeat.apache.org), and with at least 3 +1 votes from PPMC. |
| **CS30** | The project uses documented voting rules to build consensus when discussion is not sufficient. | **YES** The project uses the standard ASF voting rules. |
| **CS40** | In Apache projects, vetoes are only valid for code commits. The person exercising the veto must justify it with a technical explanation, as per the Apache voting rules defined in CS30. | **YES** Apache HertzBeat community has not used the veto power yet except for code commits. |
| **CS50** | All "important" discussions happen asynchronously in written form on the project's main communications channel. Offline, face-to-face or private discussions that affect the project are also documented on that channel. | **YES** All important discussions and conclusions are recorded in written form. |
### Independence
| **ID** | **Description** | **Status** |
|----------|------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **IN10** | The project is independent from any corporate or organizational influence. | **YES** The PPMC members and committer of Apache HertzBeat are from several different companies, and majority of them are NOT From the company that donated this project. |
| **IN20** | Contributors act as themselves, not as representatives of a corporation or organization. | **YES** The contributors act on their own initiative without representing a corporation or organization. |
@@ -0,0 +1,287 @@
---
id: 'new_committer_process'
title: 'New Committer Process'
sidebar_position: 4
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
[Apache New Committer Guideline](https://community.apache.org/newcommitter.html#new-committer-process)
## The process of new Committer
- Call a vote in mailing `private@hertzbeat.apache.org`
see **Committer Vote Template**
- Close the vote
see **Close Vote Template**
- If the result is positive, invite the new committer
see **Committer Invite Template**
- If accepted, then: Accept the committer
see **Committer Accept Template**
- New Committer sign CLA and wait for CLA is recorded
- Request creation of the committer account
see **Committer Account Creation**
- Wait until root says it is done
- [Roster](https://whimsy.apache.org/roster/ppmc/hertzbeat) add the new committer
- Announce the new committer
see **Announce New Committer Template**
## Template
Note that, there are three placeholder in template should be replaced before using
- NEW_COMMITTER_NAME This Must Be Public Name, Not Github Name Or Id.
- NEW_COMMITTER_EMAIL
- NEW_COMMITTER_APACHE_NAME
### Committer Vote Template
:::note
NEW_COMMITTER_NAME This Must Be Public Name, Not Github Name Or Id.
:::
```text
To: private@hertzbeat.apache.org
Subject: [VOTE] New committer: `NEW_COMMITTER_NAME`
```
```text
Hi HertzBeat PMC,
This is a formal vote about inviting `NEW_COMMITTER_NAME` as our community new committer.
Work list: https://github.com/apache/hertzbeat/commits?author=xxx
Here is the list of `NEW_COMMITTER_NAME`'s contributions in HertzBeat Community:
> [27 commits](https://github.com/apache/hertzbeat/commits?author=xxx)
>
> 7,495 ++ 627 --
Submitted PR (27 commits)
- [ISSUE #4534] [feature] add new feature in hertzbeat #3445
- xxx
Submitted Issues (18 commits)
- [bug] find some bugs in hertzbeat nodes #6565
- xxx
Please vote:
+1: I support this proposal and will welcome `NEW_COMMITTER_NAME` as a committer.
+0: I don't care.
-1: I object to this proposal and here are my reasons.
This vote will be open for at least 7 days.
See voting guidelines at
https://community.apache.org/newcommitter.html
Best Wishes,
ttt
```
Note that, Voting ends one week from today, i.e.
[midnight UTC on YYYY-MM-DD](https://www.timeanddate.com/counters/customcounter.html?year=YYYY&month=MM&day=DD)
[Apache Voting Guidelines](https://community.apache.org/newcommitter.html)
### Close Vote Template
```text
To: private@hertzbeat.apache.org
Subject: [RESULT] [VOTE] New committer: `NEW_COMMITTER_NAME`
```
```text
Hi HertzBeat PMC,
The vote has now closed. The results are:
Binding Votes:
+1 [TOTAL BINDING +1 VOTES]
0 [TOTAL BINDING +0/-0 VOTES]
-1 [TOTAL BINDING -1 VOTES]
The vote is ***successful/not successful***
```
### Committer Invite Template
```text
To: NewCommiter@domain.com
Cc: private@hertzbeat.apache.org
Subject: Invitation to become HertzBeat committer: [Candidate Name]
```
```text
Hello [Candidate Name],
The HertzBeat Project Management Committee (PMC)
hereby offers you committer privileges to the project
These privileges are offered on the understanding that you'll use them
reasonably and with common sense. We like to work on trust
rather than unnecessary constraints.
Being a committer enables you to more easily make
changes without needing to go through the patch
submission process.
Being a committer does not require you to
participate any more than you already do. It does
tend to make one even more committed. You will
probably find that you spend more time here.
Of course, you can decline and instead remain as a
contributor, participating as you do now.
This personal invitation is a chance for you to accept or decline in private.
Please let us know in reply to this message whether you accept or decline.
Also, please refrain from sharing that you were invited before the official
announcement by the PMC.
If you accept, you will need an Apache account (id) with privileges.
Please follow these instructions.
A. If you already have an ICLA on file:
1. If you already have an Apache account, let us know your id and we
will grant you privileges on the project repositories.
2. If you have previously sent an ICLA, let us know the email address
and public name used on the ICLA and your preferred Apache id, and
we will request your account.
3. If the email address on the previously submitted ICLA is no longer
valid, let us know the email address and public name used on the new ICLA,
and your preferred Apache id. Continue to step B below and file your new ICLA.
Look to see if your preferred ID is already taken at
https://people.apache.org/committer-index.html
B. If there is not already an ICLA on file, you need to submit an ICLA:
1. Details of the ICLA and the forms are found
through this link: https://www.apache.org/licenses/#clas
2. Instructions for its completion and return to
the Secretary of the ASF are found at
https://www.apache.org/licenses/contributor-agreements.html#submitting
Do not copy the project or any other individual on your message
to Secretary, as the form contains Personally Identifiable Information
that should be kept private.
3. When you complete the ICLA form, be sure to include in the form
the Apache HertzBeat project and choose a
unique Apache ID. Look to see if your preferred
ID is already taken at
https://people.apache.org/committer-index.html
This will allow the Secretary to notify the PMC
when your ICLA has been recorded.
When recording of your ICLA is noted, you will
receive a follow-up message with the next steps for
establishing you as a committer.
```
### Committer Accept Template
```text
To: `NEW_COMMITTER_EMAIL`
Cc: private@hertzbeat.apache.org
Subject: Re: invitation to become HertzBeat committer
```
```text
Welcome. Here are the next steps in becoming a project committer. After that
we will make an announcement to the dev@hertzbeat.apache.org list.
You need to send a Contributor License Agreement to the ASF.
Normally you would send an Individual CLA. If you also make
contributions done in work time or using work resources,
see the Corporate CLA. Ask us if you have any issues.
https://www.apache.org/licenses/#clas.
You need to choose a preferred ASF user name and alternatives.
In order to ensure it is available you can view a list of taken IDs at
https://people.apache.org/committer-index.html
Please notify us when you have submitted the CLA and by what means
you did so. This will enable us to monitor its progress.
We will arrange for your Apache user account when the CLA has
been recorded.
After that is done, please make followup replies to the dev@hertzbeat.apache.org list.
We generally discuss everything there and keep the
private@hertzbeat.apache.org list for occasional matters which must be private.
The developer section of the website describes roles within the ASF and provides other
resources:
https://www.apache.org/foundation/how-it-works.html
https://www.apache.org/dev/
The incubator also has some useful information for new committers
in incubating projects:
https://incubator.apache.org/guides/committer.html
https://incubator.apache.org/guides/ppmc.html
Just as before you became a committer, participation in any ASF community
requires adherence to the ASF Code of Conduct:
https://www.apache.org/foundation/policies/conduct.html
Yours,
The Apache HertzBeat new PMC
```
### Announce New Committer Template
```text
To: dev@hertzbeat.apache.org, `NEW_COMMITTER_EMAIL`
Subject: [ANNOUNCE] New committer: `NEW_COMMITTER_NAME`
```
```text
Hello Community,
The Podling Project Management Committee (new PMC) for Apache HertzBeat
has invited `NEW_COMMITTER_NAME` to become a committer and we are pleased to
announce that he has accepted.
`NEW_COMMITTER_NAME` is active in the Apache HertzBeat community, hope to see your
further interactions with the community!
Thanks for your contributions.
Best Wishes!
```
@@ -0,0 +1,308 @@
---
id: 'new_pmc_ember_process'
title: 'new PMC Member Process'
sidebar_position: 5
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
[Apache New Committer Guideline](https://community.apache.org/newcommitter.html#new-committer-process)
## The process of new PMC member
- Call a vote in mailing `private@hertzbeat.apache.org`
see **PMC Member Vote Template**
- Close the vote
see **Close Vote Template**
- Board Approval of new PMC member
see **Board Approval of new PMC member**
- If the result is positive, invite the new PMC member
see **PMC member Invite Template**
- If accept, then: Accept the PMC member
see **PMC Member Accept Template**
- Notify the PMC member of completion
see **PMC Member Done Template**
- Announce the new PMC member
see **PMC Member Announce Template**
## Template
Note that, there are three placeholder in template should be replaced before using
- NEW_PMC_NAME
- NEW_PMC_EMAIL
- NEW_PMC_APACHE_NAME
### PMC member Vote Template
```text
To: private@hertzbeat.apache.org
Subject: [VOTE] new PMC member candidate: `NEW_PMC_NAME`
```
```text
Hi HertzBeat PMC,
This is a formal vote about inviting `NEW_PMC_NAME` as our new PMC member.
${Work list}[1]
[1] https://github.com/apache/hertzbeat/commits?author=`NEW_PMC_NAME`
```
Note that, Voting ends one week from today, i.e. [midnight UTC on YYYY-MM-DD](https://www.timeanddate.com/counters/customcounter.html?year=YYYY&month=MM&day=DD)
[Apache Voting Guidelines](https://community.apache.org/newcommitter.html)
### Close Vote Template
```text
To: private@hertzbeat.apache.org
Subject: [RESULT] [VOTE] new PMC member: `NEW_PMC_NAME`
```
```text
Hi HertzBeat PMC,
The vote has now closed. The results are:
Binding Votes:
+1 [TOTAL BINDING +1 VOTES]
0 [TOTAL BINDING +0/-0 VOTES]
-1 [TOTAL BINDING -1 VOTES]
The vote is ***successful/not successful***
```
### Board Approval of new PMC member Template
```text
To: board@apache.org
Cc: private@`<project>`.apache.org
Subject: [NOTICE] `NEW_PMC_NAME` for HertzBeat PMC member
```
```text
HertzBeat proposes to invite `NEW_PMC_NAME` to join the PMC.
The vote result is available here: https://lists.apache.org/...
```
[Apache New Pmc Guide](https://www.apache.org/dev/pmc.html#newpmc)
### PMC member Invite Template
```text
To: `NEW_PMC_EMAIL`
Cc: private@hertzbeat.apache.org
Subject: Invitation to become HertzBeat PMC member: `NEW_PMC_NAME`
```
```text
Hello [Candidate Name],
The HertzBeat Project Management Committee (PMC)
hereby offers you PMC members privileges to the project
These privileges are offered on the understanding that you'll use them
reasonably and with common sense. We like to work on trust
rather than unnecessary constraints.
Being a PMC member enables you
to guide the direction of the project.
Being a committer does not require you to
participate any more than you already do. It does
tend to make one even more committed. You will
probably find that you spend more time here.
Of course, you can decline and instead remain as a
contributor, participating as you do now.
This personal invitation is a chance for you to accept or decline in private.
Please let us know in reply to this message whether you accept or decline.
Also, please refrain from sharing that you were invited before the official
announcement by the PMC.
If you accept, you will need an Apache account (id) with privileges.
Please follow these instructions.
A. If you already have an ICLA on file:
1. If you already have an Apache account, let us know your id and we
will grant you privileges on the project repositories.
2. If you have previously sent an ICLA, let us know the email address
and public name used on the ICLA and your preferred Apache id, and
we will request your account.
3. If the email address on the previously submitted ICLA is no longer
valid, let us know the email address and public name used on the new ICLA,
and your preferred Apache id. Continue to step B below and file your new ICLA.
Look to see if your preferred ID is already taken at
https://people.apache.org/committer-index.html
B. If there is not already an ICLA on file, you need to submit an ICLA:
1. Details of the ICLA and the forms are found
through this link: https://www.apache.org/licenses/#clas
2. Instructions for its completion and return to
the Secretary of the ASF are found at
https://www.apache.org/licenses/contributor-agreements.html#submitting
Do not copy the project or any other individual on your message
to Secretary, as the form contains Personally Identifiable Information
that should be kept private.
3. When you complete the ICLA form, be sure to include in the form
the Apache HertzBeat project and choose a
unique Apache ID. Look to see if your preferred
ID is already taken at
https://people.apache.org/committer-index.html
This will allow the Secretary to notify the PMC
when your ICLA has been recorded.
When recording of your ICLA is noted, you will
receive a follow-up message with the next steps for
establishing you as a PMC.
```
### PMC member Accept Template
```text
To: `NEW_PMC_EMAIL`
Cc: private@hertzbeat.apache.org
Subject: Re: invitation to become HertzBeat PMC member
```
```text
Welcome. Here are the next steps in becoming a project PMC. After that
we will make an announcement to the dev@hertzbeat.apache.org list.
You need to send a Contributor License Agreement to the ASF.
Normally you would send an Individual CLA. If you also make
contributions done in work time or using work resources,
see the Corporate CLA. Ask us if you have any issues.
https://www.apache.org/licenses/#clas.
You need to choose a preferred ASF user name and alternatives.
In order to ensure it is available you can view a list of taken IDs at
https://people.apache.org/committer-index.html
Please notify us when you have submitted the CLA and by what means
you did so. This will enable us to monitor its progress.
We will arrange for your Apache user account when the CLA has
been recorded.
After that is done, please make followup replies to the dev@hertzbeat.apache.org list.
We generally discuss everything there and keep the
private@hertzbeat.apache.org list for occasional matters which must be private.
The developer section of the website describes roles within the ASF and provides other
resources:
https://www.apache.org/foundation/how-it-works.html
https://www.apache.org/dev/
The incubator also has some useful information for new PMC
in incubating projects:
https://incubator.apache.org/guides/committer.html
https://incubator.apache.org/guides/ppmc.html
Just as before you became a PMC member, participation in any ASF community
requires adherence to the ASF Code of Conduct:
https://www.apache.org/foundation/policies/conduct.html
Yours,
The Apache HertzBeat PMC
```
### PMC member Done Template
```text
To: private@hertzbeat.apache.org, `NEW_PMC_EMAIL`
Subject: account request: `NEW_PMC_NAME`
```
```text
`NEW_PMC_EMAIL`, as you know, the ASF Infrastructure has set up your
committer account with the username '`NEW_PMC_APACHE_NAME`'.
Please follow the instructions to set up your SSH,
svn password, svn configuration, email forwarding, etc.
https://www.apache.org/dev/#committers
You have commit access to specific sections of the
ASF repository, as follows:
The general "committers" at:
https://svn.apache.org/repos/private/committers
If you have any questions during this phase, then please
see the following resources:
Apache developer's pages: https://www.apache.org/dev/
Incubator committer guide: https://incubator.apache.org/guides/committer.html
Naturally, if you don't understand anything be sure to ask us on the dev@hertzbeat.apache.org mailing list.
Documentation is maintained by volunteers and hence can be out-of-date and incomplete - of course
you can now help fix that.
A PMC member will announce your election to the dev list soon.
```
### PMC member Announce Template
```text
To: dev@hertzbeat.apache.org
[ANNOUNCE] new PMC member: `NEW_PMC_NAME`
```
```text
Hi HertzBeat Community,
The Podling Project Management Committee (PMC) for Apache HertzBeat
has invited `NEW_PMC_NAME` to become our PMC member and
we are pleased to announce that he has accepted.
### add specific details here ###
Please join me in congratulating `NEW_PMC_NAME`!
Being a committer enables easier contribution to the
project since there is no need to go via the patch
submission process. This should enable better productivity.
A PMC member helps manage and guide the direction of the project.
Thanks,
On behalf of the Apache HertzBeat PMC
```
+72
View File
@@ -0,0 +1,72 @@
---
id: 'submit_code'
title: 'Submit Code'
sidebar_position: 2
---
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
* First from the remote repository [https://github.com/apache/hertzbeat.git](https://github.com/apache/hertzbeat.git) fork a copy of the code into your own repository
* The remote dev and merge branch is `master`.
* Clone your repository to your local
```shell
git clone git@github.com:<Your Github ID>/hertzbeat.git
```
* Add remote repository address, named upstream
```shell
git remote add upstream git@github.com:apache/hertzbeat.git
```
* View repository
```shell
git remote -v
```
> At this time, there will be two repositories: origin (your own repository) and upstream (remote repository)
* Get/Update remote repository code
```shell
git fetch upstream
```
* Synchronize remote repository code to local repository
```shell
git checkout origin/dev
git merge --no-ff upstream/dev
```
* **⚠️Note that you must create a new branch to develop features `git checkout -b feature-xxx`. It is not recommended to use the master branch for direct development**
* After modifying the code locally, submit it to your own repository:
**Note that the submission information does not contain special characters**
```shell
git commit -m 'commit content'
git push
```
* Submit changes to the remote repository, you can see a green button "Compare & pull request" on your repository page, click it.
* Select the modified local branch and the branch you want to merge with the past, you need input the message carefully, describe doc is important as code, click "Create pull request".
* Then the community Committers will do CodeReview, and then he will discuss some details (design, implementation, performance, etc.) with you, afterward you can directly update the code in this branch according to the suggestions (no need to create a new PR). When this pr is approved, the commit will be merged into the master branch
* Finally, congratulations, you have become an official contributor to HertzBeat ! You will be added to the contributor wall, you can contact the community to obtain a contributor certificate.