` command for individual installations.
+3. **Verification**: Before code submissions, use the `make tools.verify.%` command to guarantee that all necessary tools are present and up-to-date.
+
+## Conclusion
+
+The Makefile provided by Open-IM-Server presents a centralized approach to manage and install all necessary tools during the development process. It ensures that all developers employ consistent tool versions, reducing potential issues due to version disparities. Whether you're a maintainer or a contributor to the Open-IM-Server project, understanding the workings of this Makefile will significantly enhance your developmental efficiency.
diff --git a/docs/contrib/util-scripts.md b/docs/contrib/util-scripts.md
new file mode 100644
index 0000000..30da871
--- /dev/null
+++ b/docs/contrib/util-scripts.md
@@ -0,0 +1,248 @@
+# OpenIM Bash Utility Script
+
+This script offers a variety of utilities and helpers to enhance and simplify operations related to the OpenIM project.
+
+## Table of Contents
+
+- [OpenIM Bash Utility Script](#openim-bash-utility-script)
+ - [Table of Contents](#table-of-contents)
+ - [brief descriptions of each function](#brief-descriptions-of-each-function)
+ - [Introduction](#introduction)
+ - [Usage](#usage)
+ - [SSH Key Setup](#ssh-key-setup)
+ - [openim::util::ensure-gnu-sed](#openimutilensure-gnu-sed)
+ - [openim::util::ensure-gnu-date](#openimutilensure-gnu-date)
+ - [openim::util::check-file-in-alphabetical-order](#openimutilcheck-file-in-alphabetical-order)
+ - [openim::util::require-jq](#openimutilrequire-jq)
+ - [openim::util::md5](#openimutilmd5)
+ - [openim::util::read-array](#openimutilread-array)
+ - [Color Definitions](#color-definitions)
+ - [openim::util::desc and related functions](#openimutildesc-and-related-functions)
+ - [openim::util::onCtrlC](#openimutilonctrlc)
+ - [openim::util::list-to-string](#openimutillist-to-string)
+ - [openim::util::remove-space](#openimutilremove-space)
+ - [openim::util::gencpu](#openimutilgencpu)
+ - [openim::util::gen-os-arch](#openimutilgen-os-arch)
+ - [openim::util::download-file](#openimutildownload-file)
+ - [openim::util::get-public-ip](#openimutilget-public-ip)
+ - [openim::util::extract-tarball](#openimutilextract-tarball)
+ - [openim::util::check-port-open](#openimutilcheck-port-open)
+ - [openim::util::file-lines-count](#openimutilfile-lines-count)
+
+
+## brief descriptions of each function
+
+**English:**
+1. `openim::util::ensure-gnu-sed` - Determines if GNU version of `sed` exists on the system and sets its name.
+2. `openim::util::ensure-gnu-date` - Determines if GNU version of `date` exists on the system and sets its name.
+3. `openim::util::check-file-in-alphabetical-order` - Checks if a file is sorted in alphabetical order.
+4. `openim::util::require-jq` - Checks if `jq` is installed.
+5. `openim::util::md5` - Outputs the MD5 hash of a file.
+6. `openim::util::read-array` - Reads content from standard input into an array.
+7. `openim::util::desc` - Displays descriptive information.
+8. `openim::util::run::prompt` - Displays a prompt.
+9. `openim::util::run::maybe-first-prompt` - Possibly displays the first prompt based on whether it's started or not.
+10. `openim::util::run` - Executes a command and captures its output.
+11. `openim::util::run::relative` - Returns paths relative to the current script.
+12. `openim::util::onCtrlC` - Performs an action when Ctrl+C is pressed.
+13. `openim::util::list-to-string` - Converts a list into a string.
+14. `openim::util::remove-space` - Removes spaces from a string.
+15. `openim::util::gencpu` - Retrieves CPU information.
+16. `openim::util::gen-os-arch` - Generates a repository directory based on the operating system and architecture.
+17. `openim::util::download-file` - Downloads a file from a URL.
+18. `openim::util::get-public-ip` - Retrieves the public IP address of the machine.
+19. `openim::util::extract-tarball` - Extracts a tarball to a specified directory.
+20. `openim::util::check-port-open` - Checks if a given port is open on the machine.
+21. `openim::util::file-lines-count` - Counts the number of lines in a file.
+
+
+
+## Introduction
+
+This script is mainly used to validate whether the code is correctly formatted by `gofmt`. Apart from that, it offers utilities like setting up SSH keys, various wait conditions, host and platform detection, documentation generation, etc.
+
+## Usage
+
+### SSH Key Setup
+
+To set up an SSH key:
+
+```bash
+#1. Write IPs in a file, one IP per line. Let's name it hosts-file.
+#2. Modify the default username and password in the script.
+hosts-file-path="path/to/your/hosts/file"
+openim:util::setup_ssh_key_copy "$hosts-file-path" "root" "123"
+```
+
+## openim::util::ensure-gnu-sed
+
+Ensures the presence of the GNU version of the `sed` command. Different operating systems may have variations of the `sed` command, and this utility function is used to make sure the script uses the GNU version. If it finds the GNU `sed`, it sets the `SED` variable accordingly. If not found, it checks for `gsed`, which is usually the name of GNU `sed` on macOS. If neither is found, an error message is displayed.
+
+
+
+## openim::util::ensure-gnu-date
+
+Similar to the function for `sed`, this function ensures the script uses the GNU version of the `date` command. If it identifies the GNU `date`, it sets the `DATE` variable. On macOS, it looks for `gdate` as an alternative. In the absence of both, an error message is recommended.
+
+
+
+## openim::util::check-file-in-alphabetical-order
+
+This function checks if the contents of a given file are sorted in alphabetical order. If not, it provides a command suggestion for the user to sort the file correctly.
+
+
+
+## openim::util::require-jq
+
+Verifies the installation of `jq`, a popular command-line JSON parser. If it's not present, a prompt to install it is displayed.
+
+
+
+## openim::util::md5
+
+A cross-platform function that computes the MD5 hash of its input. This function takes into account the differences in the `md5` command between macOS and Linux.
+
+
+
+## openim::util::read-array
+
+A function designed to read from stdin and populate an array, line by line. It's provided as an alternative to `mapfile -t` and is compatible with bash 3.
+
+
+
+## Color Definitions
+
+The script also defines a set of colors to enhance its console output. These include colors like red, yellow, green, blue, cyan, etc., which can be used for better user experience and clear logs.
+
+
+
+## openim::util::desc and related functions
+
+These functions seem to aid in building interactive demonstrations or tutorials in the terminal. They use the `pv` utility to control the display rate of the output, emulating typing. There's also functionality to handle user prompts and execute commands while capturing their output.
+
+
+
+## openim::util::onCtrlC
+
+Handles the `CTRL+C` command. It terminates background processes of the script when the user interrupts it using `CTRL+C`.
+
+
+
+## openim::util::list-to-string
+
+Transforms a list format (like `[10023, 2323, 3434]`) to a space-separated string (`10023 2323 3434`). Also removes unnecessary spaces and characters.
+
+
+
+## openim::util::remove-space
+
+Removes spaces from a given string.
+
+
+
+## openim::util::gencpu
+
+Fetches the number of CPUs using the `lscpu` command.
+
+
+
+## openim::util::gen-os-arch
+
+Identifies the operating system and architecture of the system running the script. This is useful to determine directories or binaries specific to that OS and architecture.
+
+
+
+## openim::util::download-file
+
+This function can be used to download a file from a URL. If `curl` is available, it uses `curl`. If not, it falls back to `wget`.
+
+```bash
+function openim::util::download-file() {
+ local url="$1"
+ local dest="$2"
+
+ if command -v curl &>/dev/null; then
+ curl -L "${url}" -o "${dest}"
+ elif command -v wget &>/dev/null; then
+ wget "${url}" -O "${dest}"
+ else
+ openim::log::error "Neither curl nor wget available. Cannot download file."
+ return 1
+ fi
+}
+```
+
+
+
+## openim::util::get-public-ip
+
+Fetches the public IP address of the machine.
+
+```bash
+function openim::util::get-public-ip() {
+ if command -v curl &>/dev/null; then
+ curl -s https://ipinfo.io/ip
+ elif command -v wget &>/dev/null; then
+ wget -qO- https://ipinfo.io/ip
+ else
+ openim::log::error "Neither curl nor wget available. Cannot fetch public IP."
+ return 1
+ fi
+}
+```
+
+
+
+## openim::util::extract-tarball
+
+This function extracts a tarball to a specified directory.
+
+```bash
+function openim::util::extract-tarball() {
+ local tarball="$1"
+ local dest="$2"
+
+ mkdir -p "${dest}"
+ tar -xzf "${tarball}" -C "${dest}"
+}
+```
+
+
+
+## openim::util::check-port-open
+
+Checks if a given port is open on the local machine.
+
+```bash
+function openim::util::check-port-open() {
+ local port="$1"
+ if command -v nc &>/dev/null; then
+ echo -n > /dev/tcp/127.0.0.1/"${port}" 2>&1
+ return $?
+ elif command -v telnet &>/dev/null; then
+ telnet 127.0.0.1 "${port}" 2>&1 | grep -q "Connected"
+ return $?
+ else
+ openim::log::error "Neither nc nor telnet available. Cannot check port."
+ return 1
+ fi
+}
+```
+
+
+
+## openim::util::file-lines-count
+
+Counts the number of lines in a file.
+
+```bash
+function openim::util::file-lines-count() {
+ local file="$1"
+ if [[ -f "${file}" ]]; then
+ wc -l < "${file}"
+ else
+ openim::log::error "File does not exist: ${file}"
+ return 1
+ fi
+}
+```
\ No newline at end of file
diff --git a/docs/contrib/version.md b/docs/contrib/version.md
new file mode 100644
index 0000000..cbcddad
--- /dev/null
+++ b/docs/contrib/version.md
@@ -0,0 +1,238 @@
+# OpenIM Branch Management and Versioning: A Blueprint for High-Grade Software Development
+
+[📚 **OpenIM TOC**](#openim-branch-management-and-versioning-a-blueprint-for-high-grade-software-development)
+- [OpenIM Branch Management and Versioning: A Blueprint for High-Grade Software Development](#openim-branch-management-and-versioning-a-blueprint-for-high-grade-software-development)
+ - [Unfolding the Mechanism of OpenIM Version Maintenance](#unfolding-the-mechanism-of-openim-version-maintenance)
+ - [Main Branch: The Heart of OpenIM Development](#main-branch-the-heart-of-openim-development)
+ - [Release Branch: The Beacon of Stability](#release-branch-the-beacon-of-stability)
+ - [Tag Management: The Cornerstone of Version Control](#tag-management-the-cornerstone-of-version-control)
+ - [Release Management: A Guided Tour](#release-management-a-guided-tour)
+ - [Milestones, Branching, and Addressing Major Bugs](#milestones-branching-and-addressing-major-bugs)
+ - [Version Skew Policy](#version-skew-policy)
+ - [Supported version skew](#supported-version-skew)
+ - [OpenIM Versioning, Branching, and Tag Strategy](#openim-versioning-branching-and-tag-strategy)
+ - [Supported Version Skew](#supported-version-skew-1)
+ - [openim-api](#openim-api)
+ - [openim-rpc-\* Components](#openim-rpc--components)
+ - [Other OpenIM Services](#other-openim-services)
+ - [Supported Component Upgrade Order](#supported-component-upgrade-order)
+ - [openim-api](#openim-api-1)
+ - [openim-rpc-\* Components](#openim-rpc--components-1)
+ - [Other OpenIM Services](#other-openim-services-1)
+ - [Conclusion](#conclusion)
+ - [Applying Principles: A Git Workflow Example](#applying-principles-a-git-workflow-example)
+ - [Release Process](#release-process)
+ - [Docker Images Version Management](#docker-images-version-management)
+ - [More](#more)
+
+
+At OpenIM, we acknowledge the profound impact of implementing a robust and efficient version management system, hence we abide by the established standards of [Semantic Versioning 2.0.0](https://semver.org/lang/zh-CN/).
+
+Our software blueprint orchestrates a tripartite version management system that integrates the `main` branch, the `release` branch, and `tag` management. These constituents operate in synchrony to preserve the reliability and traceability of our software across various stages of development.
+
+## Unfolding the Mechanism of OpenIM Version Maintenance
+
+Our version maintenance protocol revolves around two primary branches, namely: `main` and `release`. We resort to Semantic Versioning 2.0.0 for marking distinctive versions of our software, representing substantial milestones in its evolution.
+
+In the OpenIM repository, version identification strictly complies with the `MAJOR.MINOR.PATCH` protocol. Herein:
+
+- The `MAJOR` version indicates a shift arising from incompatible changes to the API.
+- The `MINOR` version suggests the addition of features in a backward-compatible manner.
+- The `PATCH` version flags backward-compatible bug fixes.
+
+## Main Branch: The Heart of OpenIM Development
+
+The `main` branch is the operational heart of our development process. Housing the most recent and advanced features, this branch serves as the nerve center for all enhancements and updates. It encapsulates the freshest, though possibly unstable, facets of the software. Visit our `main` branch [here](https://github.com/openimsdk/open-im-server-deploy/tree/main).
+
+## Release Branch: The Beacon of Stability
+
+For every major release, we curate a corresponding `release` branch, e.g., `release-v3.1`. This branch symbolizes an embodiment of stability and ensures an updated version of the software, providing a dependable option for users favoring stability over nascent, yet possibly unstable, features. Visit the `release-v3.1` branch [here](https://github.com/openimsdk/open-im-server-deploy/tree/release-v3.1).
+
+## Tag Management: The Cornerstone of Version Control
+
+In OpenIM's version control system, the role of `tags` stands paramount. Owing to their immutable nature, tags can be effectively utilized to retrieve a specific version of the software. Explore our library of tags [here](https://github.com/openimsdk/open-im-server-deploy/tags).
+
+Our Docker image versions are intimately entwined with these tripartite components. For instance, a Docker image tag may correspond to `ghcr.io/openimsdk/openim-server:v3.1.0`, a release to `ghcr.io/openimsdk/openim-server:release-v3.0`, and the main branch to `ghcr.io/openimsdk/openim-server:main` or `ghcr.io/openimsdk/openim-server:latest`.
+
+To further clarify, the semantics of our version numbers are as follows:
+
+- **Revision version number**: This represents bug fixes or code optimizations. Typically, it entails no new feature additions and ensures backward compatibility.
+- **Build version number**: Auto-generated by the system, each code submission prompts an automatic increment by 1.
+- **Version modifiers**: These hint at the software's development stage and stability. Some commonly used modifiers are `alpha`, `beta`, `rc`, `ga`, `r/release/or nothing`, and `lts`.
+ - `alpha`: An internal testing version with numerous bugs, typically used for communication among developers.
+ - `beta`: A test version with numerous bugs, generally used for testing by eager community members, who provide feedback to the developers.
+ - `rc`: Release candidate, which is to be released as the official version. It's the last test version before the official version.
+ - `ga`: General Availability, the first stable release.
+ - `r/release/or nothing`: The final release version, intended for general users.
+ - `lts`: Long Term Support, the official will specify the maintenance year for this version and will fix all bugs discovered in this version.
+
+Whenever a project undergoes a partial functional addition, the minor version number increments by 1, resetting the revision version number to 0. In contrast, any major project overhaul results in an increment by 1 in the major version number. The build number, typically auto-generated during the compilation process, only requires format definition, thereby eliminating manual control.
+
+## Release Management: A Guided Tour
+
+Our GitHub repository at https://github.com/openimsdk/open-im-server-deploy/releases associates a release with each tag, with a distinction between Pre-release and Latest, determined by the branch source. Every significant feature launch prompts the issue of a `release` branch, such as `release-v3.2`, as a beacon of stability and Latest release.
+
+Pre-releases correspond to releases from the `main` branch, denoting tags with Version modifiers such as `v3.2.1-beta.0`, `v3.2.1-rc.1`, etc. If you are seeking the most recent, albeit possibly unstable, release with new features, these tags, originating from the latest `main` branch code, are your go-to.
+
+Conversely, if stability is your primary concern, you should opt for the release tagged Latest, denoted by tags without Version modifiers, such as `v3.2.1`, `v3.2.2` etc. These tags are linked to the latest stable maintenance branch, like `release-v3.2`.
+
+## Milestones, Branching, and Addressing Major Bugs
+
+**About:**
+
++ [OpenIM Milestones](https://github.com/openimsdk/open-im-server-deploy/milestones)
++ [OpenIM Tags](https://github.com/openimsdk/open-im-server-deploy/tags)
++ [OpenIM Branches](https://github.com/openimsdk/open-im-server-deploy/branches)
+
+We create a new branch, such as `release-v3.1`, for each significant milestone (e.g., v3.1.0), housing all relevant code for that release. All enhancements and bug fixes targeting the subsequent version (e.g., v3.2.0) are integrated into this branch.
+
+`PATCH` versions (represented by Z in `X.Y.Z`) are primarily propelled by bug fixes, and their release may be either priority-driven or scheduled. In contrast, `MINOR` versions (represented by Y in `X.Y.Z`) are contingent upon the project's roadmap, milestone completion, or a pre-established timeline, always maintaining backward-compatible APIs.
+
+When dealing with major bugs, we selectively merge the fix into the affected version (e.g., v3.1 or the `release-v3.1` branch), as well as the `main` branch. This dual pronged strategy ensures that users on older versions receive crucial bug fixes, while also keeping the `main` branch updated.
+
+We reinforce our approach to branch management and versioning with stringent testing protocols. Automated tests and code review sessions form vital components of maintaining a robust and reliable codebase.
+
+## Version Skew Policy
+
+This document describes the maximum version skew supported between various openim components. Specific cluster deployment tools may place additional restrictions on version skew.
+
+### Supported version skew
+
+In highly-available (HA) clusters, the newest and oldest `openim-api` instances must be within one minor version.
+
+### OpenIM Versioning, Branching, and Tag Strategy
+
+Similar to Kubernetes, OpenIM has a strict versioning, branching, and tag strategy to ensure compatibility among its various services and components. This document outlines the policies, especially focusing on the version skew supported between OpenIM's components. Given that the current version is v3.3, the policy references will be centered around this version.
+
+#### Supported Version Skew
+
+##### openim-api
+
+In highly-available (HA) clusters, the newest and oldest `openim-api` instances must be within one minor version.
+
+Example:
+
++ Newest `openim-api` is at v3.3
++ Other `openim-api` instances are supported at v3.3 and v3.2
+
+##### openim-rpc-* Components
+
+All `openim-rpc-*` components (e.g., `openim-rpc-auth`, `openim-rpc-conversation`, etc.) should adhere to the following rules:
+
+1. They must not be newer than `openim-api`.
+2. They may be up to one minor version older than `openim-api`.
+
+Example:
+
++ `openim-api` is at v3.3
++ All `openim-rpc-*` components are supported at v3.3 and v3.2
+
+Note: If version skew exists between `openim-api` instances in an HA cluster, this narrows the allowed `openim-rpc-*` components versions.
+
+##### Other OpenIM Services
+
+Other OpenIM services such as `openim-cmdutils`, `openim-crontask`, `openim-msggateway`, etc. should adhere to the following rules:
+
+1. These services must not be newer than `openim-api`.
+2. They are expected to match the `openim-api` minor version but may be up to one minor version older (to allow live upgrades).
+
+Example:
+
++ `openim-api` is at v3.3
++ `openim-msggateway`, `openim-cmdutils`, and other services are supported at v3.3 and v3.2
+
+#### Supported Component Upgrade Order
+
+The version skew policy has implications on the order in which components should be upgraded. Below is the recommended order to transition an existing cluster from version v3.2 to v3.3:
+
+##### openim-api
+
+Pre-requisites:
+
+1. In a single-instance cluster, the existing `openim-api` instance is v3.2.
+2. In an HA cluster, all `openim-api` instances are at v3.2 or v3.3.
+3. All `openim-rpc-*` and other OpenIM services communicating with this server are at version v3.2.
+
+Upgrade Procedure:
+
+1. Upgrade `openim-api` to v3.3.
+
+##### openim-rpc-* Components
+
+Pre-requisites:
+
+1. The `openim-api` instances these components communicate with are at v3.3.
+
+Upgrade Procedure:
+
+2. Upgrade all `openim-rpc-*` components to v3.3.
+
+##### Other OpenIM Services
+
+Pre-requisites:
+
+1. The `openim-api` instances these services communicate with are at v3.3.
+
+Upgrade Procedure:
+
+2. Upgrade other OpenIM services such as `openim-msggateway`, `openim-cmdutils`, etc., to v3.3.
+
+#### Conclusion
+
+Just like Kubernetes, it's essential for OpenIM to have a strict versioning and upgrade policy to ensure seamless operation and compatibility among its various services. Adhering to the policies outlined above will help in achieving this goal.
+
+
+## Applying Principles: A Git Workflow Example
+
+The workflow to address a bug fix might follow these steps:
+
+```bash
+# Checkout the branch for the version that needs the bug fix
+git checkout release-v3.1
+
+# Create a new branch for the bug fix
+git checkout -b bug/bug-name
+
+# ... Make changes, commit your work ...
+
+# Push the branch to your remote repository
+git push origin bug/bug-name
+
+# After the pull request is merged into the release-v3.1 branch,
+# checkout and update your main branch
+git checkout main
+git pull origin main
+
+# Merge or rebase the changes from release-v3.1 into main
+git merge release-v3.1
+
+# Push the updates to the main branch
+git push origin main
+```
+
+## Release Process
+
+```
+Publishing v3.2.0: A Step-by-Step Guide
+(1) Create the tag v3.2.0-alpha.0 from the main branch.
+(2) Bugs are fixed on the main branch. Once the bugs are resolved, tag the main branch as v3.2.0-rc.0.
+(3) After further testing, if v3.2.0-rc.0 is deemed stable, create a branch named release-v3.2 from the tag v3.2.0-rc.0.
+(4) From the release-v3.2 branch, create the tag v3.2.0. At this point, the official release of v3.2.0 is complete.
+
+After the release of v3.2.0, if urgent bugs are discovered, fix them on the release-v3.2 branch. Then, submit two pull requests (PRs) to both the main and release-v3.2 branches. Tag the release-v3.2 branch as v3.2.1.
+```
+
+Throughout this process, active communication within the team is pivotal to maintaining transparency and consensus on changes.
+
+## Docker Images Version Management
+
+For more details on managing Docker image versions, visit [OpenIM Docker Images Administration](https://github.com/openimsdk/open-im-server-deploy/blob/main/docs/contrib/images.md).
+
+## More
+
+More on multi-branch version management design and version management design at helm charts：
+
+About Helm's version management strategy for Multiple Apps and multiple Services:
+
++ [中文版本管理文档](https://github.com/openimsdk/helm-charts/blob/main/docs/contrib/version-zh.md)
++ [English version management documents](https://github.com/openimsdk/helm-charts/blob/main/docs/contrib/version.md)
diff --git a/docs/contributing/CONTRIBUTING-JP.md b/docs/contributing/CONTRIBUTING-JP.md
new file mode 100644
index 0000000..1798d4e
--- /dev/null
+++ b/docs/contributing/CONTRIBUTING-JP.md
@@ -0,0 +1,33 @@
+# How do I contribute code to OpenIM
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/contributing/CONTRIBUTING-PL.md b/docs/contributing/CONTRIBUTING-PL.md
new file mode 100644
index 0000000..1798d4e
--- /dev/null
+++ b/docs/contributing/CONTRIBUTING-PL.md
@@ -0,0 +1,33 @@
+# How do I contribute code to OpenIM
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/images/architecture-layers.png b/docs/images/architecture-layers.png
new file mode 100644
index 0000000..d9e6e4d
Binary files /dev/null and b/docs/images/architecture-layers.png differ
diff --git a/docs/images/architecture.jpg b/docs/images/architecture.jpg
new file mode 100644
index 0000000..138a724
Binary files /dev/null and b/docs/images/architecture.jpg differ
diff --git a/docs/images/oepnim-design.png b/docs/images/oepnim-design.png
new file mode 100644
index 0000000..74cb79a
Binary files /dev/null and b/docs/images/oepnim-design.png differ
diff --git a/docs/images/open-im-logo.png b/docs/images/open-im-logo.png
new file mode 100644
index 0000000..4fb6a67
Binary files /dev/null and b/docs/images/open-im-logo.png differ
diff --git a/docs/images/open-im-server.png b/docs/images/open-im-server.png
new file mode 100644
index 0000000..35df36f
Binary files /dev/null and b/docs/images/open-im-server.png differ
diff --git a/docs/images/wechat.jpg b/docs/images/wechat.jpg
new file mode 100644
index 0000000..85b812a
Binary files /dev/null and b/docs/images/wechat.jpg differ
diff --git a/docs/meeting-api.md b/docs/meeting-api.md
new file mode 100644
index 0000000..f35ea81
--- /dev/null
+++ b/docs/meeting-api.md
@@ -0,0 +1,415 @@
+# 会议管理接口文档
+
+## 接口列表
+
+### 1. 创建会议
+
+**接口地址：** `POST /meeting/create_meeting`
+
+**请求参数：**
+
+```json
+{
+ "meetingID": "string", // 会议ID（选填，不填则自动生成）
+ "subject": "string", // 会议主题（必填）
+ "coverURL": "string", // 封面URL（选填）
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒，必填）
+ "description": "string", // 会议描述（选填）
+ "duration": 60, // 会议时长（分钟，选填）
+ "estimatedCount": 100, // 会议预估人数（选填）
+ "enableMic": true, // 是否开启连麦（选填，默认false）
+ "enableComment": true, // 是否开启评论（选填，默认false）
+ "anchorUserIDs": ["user1", "user2"], // 主播用户ID列表（多选，选填）
+ "ex": "string" // 扩展字段（选填）
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "meetingInfo": {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 1, // 会议状态：1-已预约，2-进行中，3-已结束，4-已取消
+ "creatorUserID": "string", // 创建者用户ID
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "estimatedCount": 100, // 会议预估人数
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUserIDs": ["user1", "user2"], // 主播用户ID列表（多选）
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "createTime": 1234567890000, // 创建时间戳（毫秒）
+ "updateTime": 1234567890000, // 更新时间戳（毫秒）
+ "ex": "string", // 扩展字段
+ "groupID": "string" // 关联的群聊ID
+ },
+ "groupID": "string" // 创建的群聊ID
+ }
+}
+```
+
+**说明：**
+- 创建会议时会自动创建一个群聊，群聊名称为"群聊-[会议主题]"
+- 会议封面会作为群聊头像
+- 如果有主播列表，第一个主播自动成为群主，其他主播成为管理员
+- 如果没有主播列表，创建者自动成为群主
+
+---
+
+### 2. 更新会议
+
+**接口地址：** `POST /meeting/update_meeting`
+
+**请求参数：**
+
+```json
+{
+ "meetingID": "string", // 会议ID（必填）
+ "subject": "string", // 会议主题（选填）
+ "coverURL": "string", // 封面URL（选填）
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒，选填）
+ "status": 2, // 会议状态：1-已预约，2-进行中，3-已结束，4-已取消（选填）
+ "description": "string", // 会议描述（选填）
+ "duration": 60, // 会议时长（分钟，选填）
+ "estimatedCount": 100, // 会议预估人数（选填）
+ "enableMic": true, // 是否开启连麦（选填，使用指针以区分是否设置）
+ "enableComment": true, // 是否开启评论（选填，使用指针以区分是否设置）
+ "anchorUserIDs": ["user1", "user2"], // 主播用户ID列表（多选，选填）
+ "ex": "string" // 扩展字段（选填）
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "meetingInfo": {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 2, // 会议状态：1-已预约，2-进行中，3-已结束，4-已取消
+ "creatorUserID": "string", // 创建者用户ID
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "estimatedCount": 100, // 会议预估人数
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUserIDs": ["user1", "user2"], // 主播用户ID列表（多选）
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "createTime": 1234567890000, // 创建时间戳（毫秒）
+ "updateTime": 1234567890000, // 更新时间戳（毫秒）
+ "ex": "string", // 扩展字段
+ "groupID": "string" // 关联的群聊ID
+ }
+ }
+}
+```
+
+**说明：**
+- 可以单独更新任意字段，只传需要更新的字段即可
+- 更新主题时会同步更新群聊名称
+- 更新封面时会同步更新群聊头像
+- 更新主播列表时，第一个主播会成为群主，其他主播会成为管理员
+- 只有创建者可以更新会议
+
+---
+
+### 3. 获取会议列表
+
+**接口地址：** `POST /meeting/get_meetings`
+
+**请求参数：**
+
+```json
+{
+ "creatorUserID": "string", // 创建者用户ID（选填）
+ "status": 1, // 会议状态（选填）：1-已预约，2-进行中，3-已结束，4-已取消
+ "keyword": "string", // 搜索关键词（选填，搜索主题和描述）
+ "startTime": 1234567890000, // 开始时间戳（毫秒，选填）
+ "endTime": 1234567890000, // 结束时间戳（毫秒，选填）
+ "pagination": {
+ "pageNumber": 1, // 页码，从1开始（选填，默认1）
+ "showNumber": 20 // 每页数量（选填，默认20）
+ }
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "total": 100, // 总数
+ "meetings": [
+ {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 1, // 会议状态：1-已预约，2-进行中，3-已结束，4-已取消
+ "creatorUserID": "string", // 创建者用户ID
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "estimatedCount": 100, // 会议预估人数
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUserIDs": ["user1", "user2"], // 主播用户ID列表（多选）
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "createTime": 1234567890000, // 创建时间戳（毫秒）
+ "updateTime": 1234567890000, // 更新时间戳（毫秒）
+ "ex": "string", // 扩展字段
+ "groupID": "string" // 关联的群聊ID
+ }
+ ]
+ }
+}
+```
+
+**说明：**
+- 支持多种查询条件，可以组合使用
+- 查询优先级：creatorUserID > status > keyword > startTime/endTime > 全部
+- 支持分页查询
+- 返回的会议信息中包含主播的完整用户信息（用户ID、昵称、头像等）
+
+---
+
+### 4. 删除会议
+
+**接口地址：** `POST /meeting/delete_meeting`
+
+**请求参数：**
+
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {}
+}
+```
+
+**说明：**
+- 只有创建者可以删除会议
+- 删除会议不会删除关联的群聊
+
+---
+
+## 会议状态说明
+
+- `1` - 已预约：会议已创建，等待开始
+- `2` - 进行中：会议正在进行
+- `3` - 已结束：会议已结束（用户端不可见）
+- `4` - 已取消：会议已取消（用户端不可见）
+
+**注意：** 用户端接口只能查看状态1（已预约）和2（进行中）的会议，状态3（已结束）和4（已取消）的会议对用户端不可见。
+
+---
+
+## 通用响应格式
+
+所有接口都遵循统一的响应格式：
+
+```json
+{
+ "errCode": 0, // 错误码，0表示成功
+ "errMsg": "", // 错误消息
+ "errDlt": "", // 错误详情
+ "data": {} // 响应数据
+}
+```
+
+---
+
+## 用户端接口
+
+### 5. 获取会议信息（用户端）
+
+**接口地址：** `POST /meeting/get_meeting`
+
+**请求参数：**
+
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "meetingInfo": {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 1, // 会议状态：1-已预约，2-进行中
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "groupID": "string" // 关联的群聊ID
+ }
+ }
+}
+```
+
+**说明：**
+- 用户端接口只显示状态为1（已预约）和2（进行中）的会议
+- 如果会议状态为3（已结束）或4（已取消），将返回错误
+- 用户端接口不返回管理字段（创建者ID、扩展字段、创建时间、更新时间等）
+- 返回的主播信息包含用户ID、昵称、头像等完整用户信息
+
+---
+
+### 6. 获取会议列表（用户端）
+
+**接口地址：** `POST /meeting/get_meetings_public`
+
+**请求参数：**
+
+```json
+{
+ "status": 1, // 会议状态（选填）：1-已预约，2-进行中（只能查询这两个状态）
+ "keyword": "string", // 搜索关键词（选填，搜索主题和描述）
+ "startTime": 1234567890000, // 开始时间戳（毫秒，选填）
+ "endTime": 1234567890000, // 结束时间戳（毫秒，选填）
+ "pagination": {
+ "pageNumber": 1, // 页码，从1开始（选填，默认1）
+ "showNumber": 20 // 每页数量（选填，默认20）
+ }
+}
+```
+
+**响应参数：**
+
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "total": 100, // 总数（只包含状态1和2的会议）
+ "meetings": [
+ {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 1, // 会议状态：1-已预约，2-进行中
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "groupID": "string" // 关联的群聊ID
+ }
+ ]
+ }
+}
+```
+
+**说明：**
+- 用户端接口只显示状态为1（已预约）和2（进行中）的会议
+- 如果指定status参数，只能传入1或2，传入其他值将返回错误
+- 如果不指定status，查询结果会自动过滤，只返回状态1和2的会议
+- 用户端接口不支持按创建者查询
+- 用户端接口不返回管理字段（创建者ID、扩展字段、创建时间、更新时间等）
+- 返回的主播信息包含用户ID、昵称、头像等完整用户信息
+
+---
+
+## 注意事项
+
+1. 所有接口都需要在请求头中携带 `token` 进行身份验证
+2. 创建和更新会议时，预约时间不能早于当前时间
+3. 创建会议时会自动创建关联的群聊，群聊名称为"群聊-[会议主题]"
+4. 更新会议主题或封面时，会同步更新关联群聊的名称或头像
+5. 只有会议创建者可以更新和删除会议
+6. 用户端接口只提供查看功能，不包含创建、更新、删除等管理功能
+7. 用户端接口返回的数据已过滤管理字段（创建者ID、扩展字段、创建时间、更新时间等）
+8. 用户端接口只显示状态为1（已预约）和2（进行中）的会议，状态3（已结束）和4（已取消）的会议对用户端不可见
diff --git a/docs/meeting-client-api.md b/docs/meeting-client-api.md
new file mode 100644
index 0000000..9f81f05
--- /dev/null
+++ b/docs/meeting-client-api.md
@@ -0,0 +1,619 @@
+# OpenIM 会议接口文档（用户端 - 前端对接版）
+
+本文档专门用于前端开发人员对接 OpenIM 会议相关 API 接口（用户端）。
+
+## 目录
+
+- [基础说明](#基础说明)
+- [会议状态说明](#会议状态说明)
+- [用户端接口](#用户端接口)
+- [业务规则](#业务规则)
+- [错误码说明](#错误码说明)
+- [注意事项](#注意事项)
+
+---
+
+## 基础说明
+
+### 请求格式
+
+- **请求方法**: 所有接口均使用 `POST` 方法
+- **Content-Type**: `application/json`
+- **请求头**: 需要在请求头中携带 `token` 进行身份验证
+
+```http
+POST /meeting/get_meeting
+Content-Type: application/json
+token: your_token_here
+```
+
+### 响应格式
+
+所有接口统一返回以下格式：
+
+```json
+{
+ "errCode": 0, // 错误码，0表示成功
+ "errMsg": "", // 错误消息
+ "errDlt": "", // 错误详情
+ "data": {} // 响应数据，具体结构见各接口说明
+}
+```
+
+### 基础URL
+
+根据部署环境配置，例如：
+- 开发环境: `http://localhost:10002`
+- 生产环境: `https://your-domain.com`
+
+---
+
+## 会议状态说明
+
+| 状态值 | 状态名称 | 说明 | 用户端可见 |
+|--------|---------|------|-----------|
+| 1 | 已预约 | 会议已创建，等待开始 | ✅ 可见 |
+| 2 | 进行中 | 会议正在进行 | ✅ 可见 |
+| 3 | 已结束 | 会议已结束 | ❌ 不可见 |
+| 4 | 已取消 | 会议已取消 | ❌ 不可见 |
+
+**重要提示**：
+- 用户端接口只能查看状态为 **1（已预约）** 和 **2（进行中）** 的会议
+- 状态为 **3（已结束）** 和 **4（已取消）** 的会议对用户端不可见
+
+---
+
+## 用户端接口
+
+### 1. 获取会议信息
+
+**接口地址**: `POST /meeting/get_meeting`
+
+**接口描述**: 获取单个会议信息，只能查看已预约和进行中的会议
+
+**请求参数**:
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "meetingInfo": {
+ "meetingID": "string", // 会议ID
+ "subject": "string", // 会议主题
+ "coverURL": "string", // 封面URL
+ "scheduledTime": 1234567890000, // 预约时间戳（毫秒）
+ "status": 1, // 会议状态：1-已预约，2-进行中
+ "description": "string", // 会议描述
+ "duration": 60, // 会议时长（分钟）
+ "enableMic": true, // 是否开启连麦
+ "enableComment": true, // 是否开启评论
+ "anchorUsers": [ // 主播用户信息列表
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ },
+ {
+ "userID": "user2",
+ "nickname": "主播2",
+ "faceURL": "https://example.com/avatar2.jpg"
+ }
+ ],
+ "groupID": "string", // 关联的群聊ID
+ "checkInCount": 50 // 签到人数统计
+ }
+ }
+}
+```
+
+**业务规则**:
+1. 用户端接口只显示状态为 **1（已预约）** 和 **2（进行中）** 的会议
+2. 如果会议状态为 **3（已结束）** 或 **4（已取消）**，将返回错误
+3. 用户端接口不返回管理字段：
+ - `creatorUserID`（创建者ID）
+ - `ex`（扩展字段）
+ - `createTime`（创建时间）
+ - `updateTime`（更新时间）
+ - `estimatedCount`（预估人数）
+ - `anchorUserIDs`（主播ID列表，只返回 `anchorUsers`）
+4. 返回的主播信息包含用户ID、昵称、头像等完整用户信息
+5. 返回签到人数统计（`checkInCount`），用于显示会议签到情况
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误或会议不可用（会议已结束或已取消）
+- `1004`: 会议不存在
+- `500`: 服务器内部错误
+
+---
+
+### 2. 获取会议列表
+
+**接口地址**: `POST /meeting/get_meetings_public`
+
+**接口描述**: 获取会议列表，只能查看已预约和进行中的会议
+
+**请求参数**:
+```json
+{
+ "status": 1, // 会议状态（选填）：1-已预约，2-进行中（只能查询这两个状态）
+ "keyword": "string", // 搜索关键词（选填，搜索主题和描述）
+ "startTime": 1234567890000, // 开始时间戳（毫秒，选填）
+ "endTime": 1234567890000, // 结束时间戳（毫秒，选填）
+ "pagination": {
+ "pageNumber": 1, // 页码，从1开始（选填，默认1）
+ "showNumber": 20 // 每页数量（选填，默认20）
+ }
+}
+```
+
+**参数说明**:
+- `status`: 如果指定，只能传入 `1` 或 `2`，传入其他值将返回错误
+- 如果不指定 `status`，查询结果会自动过滤，只返回状态1和2的会议
+- 用户端接口不支持按创建者查询（没有 `creatorUserID` 参数）
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "total": 100, // 总数（只包含状态1和2的会议）
+ "meetings": [
+ {
+ "meetingID": "string",
+ "subject": "string",
+ "coverURL": "string",
+ "scheduledTime": 1234567890000,
+ "status": 1,
+ "description": "string",
+ "duration": 60,
+ "enableMic": true,
+ "enableComment": true,
+ "anchorUsers": [
+ {
+ "userID": "user1",
+ "nickname": "主播1",
+ "faceURL": "https://example.com/avatar1.jpg"
+ }
+ ],
+ "groupID": "string", // 关联的群聊ID
+ "checkInCount": 50 // 签到人数统计
+ }
+ ]
+ }
+}
+```
+
+**业务规则**:
+1. 用户端接口只显示状态为 **1（已预约）** 和 **2（进行中）** 的会议
+2. 如果指定 `status` 参数，只能传入 `1` 或 `2`，传入其他值将返回错误
+3. 如果不指定 `status`，查询结果会自动过滤，只返回状态1和2的会议
+4. 用户端接口不支持按创建者查询
+5. 用户端接口不返回管理字段（创建者ID、扩展字段、创建时间、更新时间、预估人数等）
+6. 返回的主播信息包含用户ID、昵称、头像等完整用户信息
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误（如状态值不是1或2）
+- `500`: 服务器内部错误
+
+---
+
+## 签到接口
+
+### 1. 会议签到
+
+**接口地址**: `POST /meeting/check_in`
+
+**接口描述**: 用户对会议进行签到，一个用户在一个会议中只能签到一次
+
+**请求参数**:
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "checkInID": "string", // 签到ID
+ "checkInTime": 1234567890000 // 签到时间戳（毫秒）
+ }
+}
+```
+
+**业务规则**:
+1. 一个用户在一个会议中只能签到一次
+2. 只能对状态为 **1（已预约）** 和 **2（进行中）** 的会议签到
+3. 签到成功后会自动更新会议的签到统计（`checkInCount`）
+4. 如果用户已经签到过，会返回错误
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误或会议不可用（会议已结束或已取消）
+- `1001`: 用户已签到
+- `1004`: 会议不存在
+- `500`: 服务器内部错误
+
+---
+
+### 2. 检查用户是否已签到
+
+**接口地址**: `POST /meeting/check_user_check_in`
+
+**接口描述**: 检查当前用户是否已对指定会议签到
+
+**请求参数**:
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "isCheckedIn": true, // 是否已签到
+ "checkInInfo": { // 签到信息（如果已签到）
+ "checkInID": "string",
+ "meetingID": "string",
+ "userID": "string",
+ "checkInTime": 1234567890000,
+ "userInfo": {
+ "userID": "string",
+ "nickname": "string",
+ "faceURL": "string"
+ }
+ }
+ }
+}
+```
+
+**业务规则**:
+1. 如果用户已签到，返回 `isCheckedIn: true` 和签到详细信息
+2. 如果用户未签到，返回 `isCheckedIn: false`，`checkInInfo` 为 `null`
+3. 已签到时，会返回用户的基本信息（用户ID、昵称、头像等）
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误
+- `500`: 服务器内部错误
+
+---
+
+### 3. 获取会议签到列表
+
+**接口地址**: `POST /meeting/get_check_ins`
+
+**接口描述**: 获取指定会议的所有签到记录列表
+
+**请求参数**:
+```json
+{
+ "meetingID": "string", // 会议ID（必填）
+ "pagination": {
+ "pageNumber": 1, // 页码，从1开始（选填，默认1）
+ "showNumber": 20 // 每页数量（选填，默认20）
+ }
+}
+```
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "total": 100, // 总数
+ "checkIns": [
+ {
+ "checkInID": "string", // 签到ID
+ "meetingID": "string", // 会议ID
+ "userID": "string", // 用户ID
+ "checkInTime": 1234567890000, // 签到时间戳（毫秒）
+ "userInfo": { // 用户信息
+ "userID": "string",
+ "nickname": "string",
+ "faceURL": "string"
+ }
+ }
+ ]
+ }
+}
+```
+
+**业务规则**:
+1. 支持分页查询
+2. 签到列表按签到时间倒序排列（最新签到的在前）
+3. 每个签到记录包含用户的完整信息（用户ID、昵称、头像等）
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误
+- `500`: 服务器内部错误
+
+---
+
+### 4. 获取会议签到统计
+
+**接口地址**: `POST /meeting/get_check_in_stats`
+
+**接口描述**: 获取指定会议的签到人数统计
+
+**请求参数**:
+```json
+{
+ "meetingID": "string" // 会议ID（必填）
+}
+```
+
+**响应参数**:
+```json
+{
+ "errCode": 0,
+ "errMsg": "",
+ "errDlt": "",
+ "data": {
+ "meetingID": "string", // 会议ID
+ "checkInCount": 50 // 签到人数
+ }
+}
+```
+
+**业务规则**:
+1. 返回会议的签到总人数
+2. 这个统计也会在会议信息中的 `checkInCount` 字段中返回
+
+**错误码**:
+- `0`: 成功
+- `1001`: 参数错误
+- `500`: 服务器内部错误
+
+---
+
+## 业务规则
+
+### 1. 会议与群聊的关联
+
+- 创建会议时会自动创建一个群聊
+- 群聊名称为：`"会议群-{会议主题}"`
+- 会议封面会作为群聊头像
+- 群聊的 `ex` 字段中会包含会议标识：
+ ```json
+ {
+ "isMeetingGroup": true,
+ "meetingID": "会议ID"
+ }
+ ```
+
+### 2. 主播与群角色的关系
+
+- **有主播列表时**：
+ - 第一个主播 → 群主
+ - 其他主播 → 管理员
+ - 创建者（如果不在主播列表中）→ 普通成员
+- **没有主播列表时**：
+ - 创建者 → 群主
+
+### 3. 评论开关与群禁言
+
+- **开启评论** (`enableComment: true`)：
+ - 自动取消群禁言
+ - 群成员可以发送消息
+- **关闭评论** (`enableComment: false`)：
+ - 自动禁言群
+ - 群成员无法发送消息
+
+### 4. 权限控制
+
+- **查看会议**：用户端只能查看已预约和进行中的会议
+
+### 5. 时间验证
+
+- 创建会议时，预约时间不能早于当前时间
+- 更新会议时，如果更新预约时间，也不能早于当前时间
+
+---
+
+## 错误码说明
+
+### 通用错误码
+
+| 错误码 | 说明 |
+|--------|------|
+| 0 | 成功 |
+| 500 | 服务器内部错误 |
+| 1001 | 参数错误 |
+| 1002 | 权限不足 |
+| 1004 | 记录不存在 |
+
+### 会议相关错误场景
+
+| 错误码 | 场景 |
+|--------|------|
+| 1001 | 查询状态不是1或2 |
+| 1004 | 会议不存在 |
+| 1004 | 查询已结束或已取消的会议 |
+
+---
+
+## 注意事项
+
+### 1. 认证
+
+- 所有接口都需要在请求头中携带 `token` 进行身份验证
+- Token通过 `/auth/get_user_token` 接口获取
+
+### 2. 请求格式
+
+- 所有接口使用 `POST` 方法
+- Content-Type: `application/json`
+- 请求体为JSON格式
+
+### 3. 响应格式
+
+- 所有接口统一返回格式：`{errCode, errMsg, errDlt, data}`
+- `errCode` 为 0 表示成功，非0表示失败
+- 失败时查看 `errMsg` 和 `errDlt` 获取错误详情
+
+### 4. 时间戳
+
+- 所有时间戳均为毫秒级Unix时间戳
+- 例如：`1234567890000` 表示 2009-02-13 23:31:30
+
+### 5. 分页参数
+
+- 分页参数统一格式：
+ ```json
+ {
+ "pagination": {
+ "pageNumber": 1, // 页码，从1开始
+ "showNumber": 20 // 每页数量
+ }
+ }
+ ```
+
+### 6. 用户端接口特点
+
+- 只能查看状态为 **1（已预约）** 和 **2（进行中）** 的会议
+- 不返回管理字段：
+ - `creatorUserID`（创建者ID）
+ - `ex`（扩展字段）
+ - `createTime`（创建时间）
+ - `updateTime`（更新时间）
+ - `estimatedCount`（预估人数）
+ - `anchorUserIDs`（主播ID列表，只返回 `anchorUsers`）
+- 不支持按创建者查询（没有 `creatorUserID` 参数）
+
+### 7. 主播信息
+
+- 用户端接口只返回 `anchorUsers`（主播详细信息）
+- 主播信息包含：`userID`、`nickname`、`faceURL` 等
+
+### 8. 群聊关联
+
+- 每个会议都会关联一个群聊
+- 通过 `groupID` 字段可以获取关联的群聊ID
+- 可以使用群聊相关接口（`/group/*`）操作关联的群聊
+
+### 9. 会议状态流转
+
+```
+1（已预约） → 2（进行中） → 3（已结束）
+ ↓
+ 4（已取消）
+```
+
+- 用户端只能查看状态 **1（已预约）** 和 **2（进行中）** 的会议
+- 状态 **3（已结束）** 和 **4（已取消）** 的会议对用户端不可见
+
+---
+
+## 接口汇总表
+
+| 接口路径 | 方法 | 描述 | 权限要求 |
+|---------|------|------|---------|
+| `/meeting/get_meeting` | POST | 获取会议信息 | 登录用户 |
+| `/meeting/get_meetings_public` | POST | 获取会议列表 | 登录用户 |
+
+---
+
+## 请求示例
+
+```bash
+curl -X POST http://localhost:10002/meeting/get_meeting \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "meetingID": "meeting123"
+ }'
+```
+
+### 获取会议列表
+
+```bash
+curl -X POST http://localhost:10002/meeting/get_meetings_public \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "status": 1,
+ "keyword": "产品",
+ "pagination": {
+ "pageNumber": 1,
+ "showNumber": 20
+ }
+ }'
+```
+
+### 会议签到
+
+```bash
+curl -X POST http://localhost:10002/meeting/check_in \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "meetingID": "meeting123"
+ }'
+```
+
+### 检查用户是否已签到
+
+```bash
+curl -X POST http://localhost:10002/meeting/check_user_check_in \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "meetingID": "meeting123"
+ }'
+```
+
+### 获取会议签到列表
+
+```bash
+curl -X POST http://localhost:10002/meeting/get_check_ins \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "meetingID": "meeting123",
+ "pagination": {
+ "pageNumber": 1,
+ "showNumber": 20
+ }
+ }'
+```
+
+### 获取会议签到统计
+
+```bash
+curl -X POST http://localhost:10002/meeting/get_check_in_stats \
+ -H "Content-Type: application/json" \
+ -H "token: your_token" \
+ -d '{
+ "meetingID": "meeting123"
+ }'
+```
+
+---
+
+**最后更新时间**: 2025-01-23
+
diff --git a/docs/readme/README_cs.md b/docs/readme/README_cs.md
new file mode 100644
index 0000000..145dc54
--- /dev/null
+++ b/docs/readme/README_cs.md
@@ -0,0 +1,183 @@
+
+
+ 
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
diff --git a/docs/readme/README_da.md b/docs/readme/README_da.md
new file mode 100644
index 0000000..be5a1a3
--- /dev/null
+++ b/docs/readme/README_da.md
@@ -0,0 +1,185 @@
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+[](https://github.com/openimsdk/open-im-server-deploy/stargazers)
+[](https://github.com/openimsdk/open-im-server-deploy/network/members)
+[](https://app.codecov.io/gh/openimsdk/open-im-server-deploy)
+[](https://goreportcard.com/report/github.com/openimsdk/open-im-server-deploy)
+[](https://pkg.go.dev/git.imall.cloud/openim/open-im-server-deploy)
+[](https://github.com/openimsdk/open-im-server-deploy/blob/main/LICENSE)
+[](https://join.slack.com/t/openimsdk/shared_invite/zt-2ijy1ys1f-O0aEDCr7ExRZ7mwsHAVg9A)
+[](https://www.bestpractices.dev/projects/8045)
+[](https://github.com/openimsdk/open-im-server-deploy/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22)
+[](https://golang.org/)
+
+
+ English ·
+ 中文 ·
+ Українська ·
+ Česky ·
+ Magyar ·
+ Español ·
+ فارسی ·
+ Français ·
+ Deutsch ·
+ Polski ·
+ Indonesian ·
+ Suomi ·
+ മലയാളം ·
+ 日本語 ·
+ Nederlands ·
+ Italiano ·
+ Русский ·
+ Português (Brasil) ·
+ Esperanto ·
+ 한국어 ·
+ العربي ·
+ Tiếng Việt ·
+ Dansk ·
+ Ελληνικά ·
+ Türkçe
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+> **Note**
+> @openimbot and @kubbot have made great contributions to the community as community 🤖robots(@openimsdk/bot), respectively.
+> Thanks to the @openimsdk/openim team for all their hard work on this release.
+> Thank you to all the [💕developers and contributors](https://github.com/{{ .Env.USERNAME }}/{{ .ProjectName }}/graphs/contributors), people from all over the world, OpenIM brings us together
+> Contributions to this project are welcome! Please see [CONTRIBUTING.md](https://github.com/{{ .Env.USERNAME }}/{{ .ProjectName }}/blob/main/CONTRIBUTING.md) for details.
\ No newline at end of file
diff --git a/scripts/template/project_README.md b/scripts/template/project_README.md
new file mode 100644
index 0000000..96575e6
--- /dev/null
+++ b/scripts/template/project_README.md
@@ -0,0 +1,41 @@
+# Project myproject
+
+
+
+## Features
+
+
+
+## Getting Started
+
+### Prerequisites
+
+
+
+### Building
+
+
+
+### Running
+
+
+
+## Using
+
+
+
+## Contributing
+
+
+
+## Community(optional)
+
+
+
+## Authors
+
+
+
+## License
+
+
diff --git a/start-config.yml b/start-config.yml
new file mode 100644
index 0000000..da95904
--- /dev/null
+++ b/start-config.yml
@@ -0,0 +1,18 @@
+serviceBinaries:
+ openim-api: 1
+ openim-crontask: 4
+ openim-rpc-user: 1
+ openim-msggateway: 1
+ openim-push: 8
+ openim-msgtransfer: 8
+ openim-rpc-conversation: 1
+ openim-rpc-auth: 1
+ openim-rpc-group: 1
+ openim-rpc-friend: 1
+ openim-rpc-msg: 1
+ openim-rpc-third: 1
+toolBinaries:
+ - check-free-memory
+ - check-component
+ - seq
+maxFileDescriptors: 10000
diff --git a/test/e2e/README.md b/test/e2e/README.md
new file mode 100644
index 0000000..2910f36
--- /dev/null
+++ b/test/e2e/README.md
@@ -0,0 +1,136 @@
+# OpenIM End-to-End (E2E) Testing Module
+
+## Overview
+
+This repository contains the End-to-End (E2E) testing suite for OpenIM, a comprehensive instant messaging platform. The E2E tests are designed to simulate real-world usage scenarios to ensure that all components of the OpenIM system are functioning correctly in an integrated environment.
+
+The tests cover various aspects of the system, including API endpoints, chat services, web interfaces, and RPC components, as well as performance and scalability under different load conditions.
+
+## Directory Structure
+
+```bash
+❯ tree e2e
+test/e2e/
+├── conformance/ # Contains tests for verifying OpenIM API conformance
+├── framework/ # Provides auxiliary code and libraries for building and running E2E tests
+│ ├── config/ # Test configuration files and management
+│ ├── ginkgowrapper/ # Functions wrapping the testing library for handling test failures and skips
+│ └── helpers/ # Helper functions such as user creation, message sending, etc.
+├── api/ # End-to-end tests for OpenIM API
+├── chat/ # Tests for the business server (including login, registration, and other logic)
+├── web/ # Tests for the web frontend (login, registration, message sending and receiving)
+├── rpc/ # End-to-end tests for various RPC components
+│ ├── auth/ # Tests for the authentication service
+│ ├── conversation/ # Tests for conversation management
+│ ├── friend/ # Tests for friend relationship management
+│ ├── group/ # Tests for group management
+│ └── message/ # Tests for message handling
+├── scalability/ # Tests for the scalability of the OpenIM system
+├── performance/ # Performance tests such as load testing and stress testing
+└── upgrade/ # Tests for compatibility and stability during OpenIM upgrades
+```
+
+The E2E tests are organized into the following directory structure:
+
+- `conformance/`: Contains tests to verify the conformance of OpenIM API implementations.
+- `framework/`: Provides helper code for constructing and running E2E tests using the Ginkgo framework.
+ - `config/`: Manages test configurations and options.
+ - `ginkgowrapper/`: Wrappers for Ginkgo's `Fail` and `Skip` functions to handle structured data panics.
+ - `helpers/`: Utility functions for common test actions like user creation, message dispatching, etc.
+- `api/`: E2E tests for the OpenIM API endpoints.
+- `chat/`: Tests for the chat service, including authentication, session management, and messaging logic.
+- `web/`: Tests for the web interface, including user interactions and information exchange.
+- `rpc/`: E2E tests for each of the RPC components.
+ - `auth/`: Tests for the authentication service.
+ - `conversation/`: Tests for conversation management.
+ - `friend/`: Tests for friend relationship management.
+ - `group/`: Tests for group management.
+ - `message/`: Tests for message handling.
+- `scalability/`: Tests for the scalability of the OpenIM system.
+- `performance/`: Performance tests, including load and stress tests.
+- `upgrade/`: Tests for the upgrade process of OpenIM, ensuring compatibility and stability.
+
+## Prerequisites
+
+Since the deployment of OpenIM requires some components such as Mongo and Kafka, you should think a bit before using E2E tests
+
+```bash
+docker compose up -d
+```
+
+OR User [kubernetes deployment](https://github.com/openimsdk/helm-charts)
+
+Before running the E2E tests, ensure that you have the following prerequisites installed:
+
+- Docker
+- Kubernetes
+- Ginkgo test framework
+- Go (version 1.19 or higher)
+
+## Configuration
+
+Test configurations can be customized via the `config/` directory. The configuration files are in YAML format and allow you to set parameters such as API endpoints, user credentials, and test data.
+
+## Running the Tests
+
+To run a single test or set of tests, you'll need the [Ginkgo](https://github.com/onsi/ginkgo) tool installed on your machine:
+
+```
+ginkgo --help
+ --focus value
+ If set, ginkgo will only run specs that match this regular expression. Can be specified multiple times, values are ORed.
+```
+
+To run the entire suite of E2E tests, use the following command:
+
+```sh
+ginkgo -v --randomizeAllSpecs --randomizeSuites --failOnPending --cover --trace --race --progress
+```
+
+You can also run a specific test or group of tests by specifying the path to the test directory:
+
+```bash
+ginkgo -v ./test/e2e/chat
+```
+
+Or you can use Makefile to run the tests:
+
+```bash
+make test-e2e
+```
+
+## Test Development
+
+To contribute to the E2E tests:
+
+1. Clone the repository and navigate to the `test/e2e/` directory.
+2. Create a new test file or modify an existing test to cover a new scenario.
+3. Write test cases using the Ginkgo BDD style, ensuring that they are clear and descriptive.
+4. Run the tests locally to ensure they pass.
+5. Submit a pull request with your changes.
+
+Please refer to the `CONTRIBUTING.md` file for more detailed instructions on contributing to the test suite.
+
+
+## Reporting Issues
+
+If you encounter any issues while running the E2E tests, please open an issue on the GitHub repository with the following information:
+
+Open issue: https://github.com/openimsdk/open-im-server-deploy/issues/new/choose, choose "Failing Test" template.
+
++ A clear and concise description of the issue.
++ Steps to reproduce the behavior.
++ Relevant logs and test output.
++ Any other context that could be helpful in troubleshooting.
+
+
+## Continuous Integration (CI)
+
+The E2E test suite is integrated with CI, which runs the tests automatically on each code commit. The results are reported back to the pull request or commit to provide immediate feedback on the impact of the changes.
+
+[](https://github.com/openimsdk/open-im-server-deploy/actions/workflows/e2e-test.yml)
+
+
+## Contact
+
+For any queries or assistance, please reach out to the OpenIM development team at [support@openim.com](mailto:support@openim.com).
\ No newline at end of file
diff --git a/test/e2e/api/token/token.go b/test/e2e/api/token/token.go
new file mode 100644
index 0000000..c862dc6
--- /dev/null
+++ b/test/e2e/api/token/token.go
@@ -0,0 +1,149 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package token
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+)
+
+// API endpoints and other constants.
+const (
+ APIHost = "http://127.0.0.1:10002"
+ UserTokenURL = APIHost + "/auth/user_token"
+ UserRegisterURL = APIHost + "/user/user_register"
+ SecretKey = "openIM123"
+ OperationID = "1646445464564"
+)
+
+// UserTokenRequest represents a request to get a user token.
+type UserTokenRequest struct {
+ Secret string `json:"secret"`
+ PlatformID int `json:"platformID"`
+ UserID string `json:"userID"`
+}
+
+// UserTokenResponse represents a response containing a user token.
+type UserTokenResponse struct {
+ Token string `json:"token"`
+ ErrCode int `json:"errCode"`
+}
+
+// User represents user data for registration.
+type User struct {
+ UserID string `json:"userID"`
+ Nickname string `json:"nickname"`
+ FaceURL string `json:"faceURL"`
+}
+
+// UserRegisterRequest represents a request to register a user.
+type UserRegisterRequest struct {
+ Users []User `json:"users"`
+}
+
+/* func main() {
+ // Example usage of functions
+ token, err := GetUserToken("openIM123456")
+ if err != nil {
+ log.Fatalf("Error getting user token: %v", err)
+ }
+ fmt.Println("Token:", token)
+
+ err = RegisterUser(token, "testUserID", "TestNickname", "https://example.com/image.jpg")
+ if err != nil {
+ log.Fatalf("Error registering user: %v", err)
+ }
+} */
+
+// GetUserToken requests a user token from the API.
+func GetUserToken(userID string) (string, error) {
+ reqBody := UserTokenRequest{
+ Secret: SecretKey,
+ PlatformID: 1,
+ UserID: userID,
+ }
+ reqBytes, err := json.Marshal(reqBody)
+ if err != nil {
+ return "", err
+ }
+
+ resp, err := http.Post(UserTokenURL, "application/json", bytes.NewBuffer(reqBytes))
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+
+ var tokenResp UserTokenResponse
+ if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+ return "", err
+ }
+
+ if tokenResp.ErrCode != 0 {
+ return "", fmt.Errorf("error in token response: %v", tokenResp.ErrCode)
+ }
+
+ return tokenResp.Token, nil
+}
+
+// RegisterUser registers a new user using the API.
+func RegisterUser(token, userID, nickname, faceURL string) error {
+ user := User{
+ UserID: userID,
+ Nickname: nickname,
+ FaceURL: faceURL,
+ }
+ reqBody := UserRegisterRequest{
+ Users: []User{user},
+ }
+ reqBytes, err := json.Marshal(reqBody)
+ if err != nil {
+ return err
+ }
+
+ client := &http.Client{}
+ req, err := http.NewRequest("POST", UserRegisterURL, bytes.NewBuffer(reqBytes))
+ if err != nil {
+ return err
+ }
+
+ req.Header.Add("Content-Type", "application/json")
+ req.Header.Add("operationID", OperationID)
+ req.Header.Add("token", token)
+
+ resp, err := client.Do(req)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ respBody, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+
+ var respData map[string]any
+ if err := json.Unmarshal(respBody, &respData); err != nil {
+ return err
+ }
+
+ if errCode, ok := respData["errCode"].(float64); ok && errCode != 0 {
+ return fmt.Errorf("error in user registration response: %v", respData)
+ }
+
+ return nil
+}
diff --git a/test/e2e/api/user/curd.go b/test/e2e/api/user/curd.go
new file mode 100644
index 0000000..da193f0
--- /dev/null
+++ b/test/e2e/api/user/curd.go
@@ -0,0 +1,71 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package user
+
+import (
+ "fmt"
+
+ gettoken "git.imall.cloud/openim/open-im-server-deploy/test/e2e/api/token"
+ "git.imall.cloud/openim/open-im-server-deploy/test/e2e/framework/config"
+)
+
+// UserInfoRequest represents a request to get or update user information.
+type UserInfoRequest struct {
+ UserIDs []string `json:"userIDs,omitempty"`
+ UserInfo *gettoken.User `json:"userInfo,omitempty"`
+}
+
+// GetUsersOnlineStatusRequest represents a request to get users' online status.
+type GetUsersOnlineStatusRequest struct {
+ UserIDs []string `json:"userIDs"`
+}
+
+// GetUsersInfo retrieves detailed information for a list of user IDs.
+func GetUsersInfo(token string, userIDs []string) error {
+
+ url := fmt.Sprintf("http://%s:%s/user/get_users_info", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := UserInfoRequest{
+ UserIDs: userIDs,
+ }
+ return sendPostRequestWithToken(url, token, requestBody)
+}
+
+// UpdateUserInfo updates the information for a user.
+func UpdateUserInfo(token, userID, nickname, faceURL string) error {
+
+ url := fmt.Sprintf("http://%s:%s/user/update_user_info", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := UserInfoRequest{
+ UserInfo: &gettoken.User{
+ UserID: userID,
+ Nickname: nickname,
+ FaceURL: faceURL,
+ },
+ }
+ return sendPostRequestWithToken(url, token, requestBody)
+}
+
+// GetUsersOnlineStatus retrieves the online status for a list of user IDs.
+func GetUsersOnlineStatus(token string, userIDs []string) error {
+
+ url := fmt.Sprintf("http://%s:%s/user/get_users_online_status", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := GetUsersOnlineStatusRequest{
+ UserIDs: userIDs,
+ }
+
+ return sendPostRequestWithToken(url, token, requestBody)
+}
diff --git a/test/e2e/api/user/user.go b/test/e2e/api/user/user.go
new file mode 100644
index 0000000..8c0c1f9
--- /dev/null
+++ b/test/e2e/api/user/user.go
@@ -0,0 +1,125 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package user
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+
+ gettoken "git.imall.cloud/openim/open-im-server-deploy/test/e2e/api/token"
+ "git.imall.cloud/openim/open-im-server-deploy/test/e2e/framework/config"
+)
+
+// ForceLogoutRequest represents a request to force a user logout.
+type ForceLogoutRequest struct {
+ PlatformID int `json:"platformID"`
+ UserID string `json:"userID"`
+}
+
+// CheckUserAccountRequest represents a request to check a user account.
+type CheckUserAccountRequest struct {
+ CheckUserIDs []string `json:"checkUserIDs"`
+}
+
+// GetUsersRequest represents a request to get a list of users.
+type GetUsersRequest struct {
+ Pagination Pagination `json:"pagination"`
+}
+
+// Pagination specifies the page number and number of items per page.
+type Pagination struct {
+ PageNumber int `json:"pageNumber"`
+ ShowNumber int `json:"showNumber"`
+}
+
+// ForceLogout forces a user to log out.
+func ForceLogout(token, userID string, platformID int) error {
+
+ url := fmt.Sprintf("http://%s:%s/auth/force_logout", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := ForceLogoutRequest{
+ PlatformID: platformID,
+ UserID: userID,
+ }
+ return sendPostRequestWithToken(url, token, requestBody)
+}
+
+// CheckUserAccount checks if the user accounts exist.
+func CheckUserAccount(token string, userIDs []string) error {
+
+ url := fmt.Sprintf("http://%s:%s/user/account_check", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := CheckUserAccountRequest{
+ CheckUserIDs: userIDs,
+ }
+ return sendPostRequestWithToken(url, token, requestBody)
+}
+
+// GetUsers retrieves a list of users with pagination.
+func GetUsers(token string, pageNumber, showNumber int) error {
+
+ url := fmt.Sprintf("http://%s:%s/user/account_check", config.LoadConfig().APIHost, config.LoadConfig().APIPort)
+
+ requestBody := GetUsersRequest{
+ Pagination: Pagination{
+ PageNumber: pageNumber,
+ ShowNumber: showNumber,
+ },
+ }
+ return sendPostRequestWithToken(url, token, requestBody)
+}
+
+// sendPostRequestWithToken sends a POST request with a token in the header.
+func sendPostRequestWithToken(url, token string, body any) error {
+ reqBytes, err := json.Marshal(body)
+ if err != nil {
+ return err
+ }
+
+ client := &http.Client{}
+ req, err := http.NewRequest("POST", url, bytes.NewBuffer(reqBytes))
+ if err != nil {
+ return err
+ }
+
+ req.Header.Add("Content-Type", "application/json")
+ req.Header.Add("operationID", gettoken.OperationID)
+ req.Header.Add("token", token)
+
+ resp, err := client.Do(req)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ respBody, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+
+ var respData map[string]any
+ if err := json.Unmarshal(respBody, &respData); err != nil {
+ return err
+ }
+
+ if errCode, ok := respData["errCode"].(float64); ok && errCode != 0 {
+ return fmt.Errorf("error in response: %v", respData)
+ }
+
+ return nil
+}
diff --git a/test/e2e/conformance/.keep b/test/e2e/conformance/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/conformance/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/e2e.go b/test/e2e/e2e.go
new file mode 100644
index 0000000..72bcd98
--- /dev/null
+++ b/test/e2e/e2e.go
@@ -0,0 +1,51 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package e2e
+
+import (
+ "testing"
+
+ gettoken "git.imall.cloud/openim/open-im-server-deploy/test/e2e/api/token"
+ "git.imall.cloud/openim/open-im-server-deploy/test/e2e/api/user"
+)
+
+// RunE2ETests checks configuration parameters (specified through flags) and then runs
+// E2E tests using the Ginkgo runner.
+// If a "report directory" is specified, one or more JUnit test reports will be
+// generated in this directory, and cluster logs will also be saved.
+// This function is called on each Ginkgo node in parallel mode.
+func RunE2ETests(t *testing.T) {
+
+ // Example usage of new functions
+ token, _ := gettoken.GetUserToken("openIM123456")
+
+ // Example of getting user info
+ _ = user.GetUsersInfo(token, []string{"user1", "user2"})
+
+ // Example of updating user info
+ _ = user.UpdateUserInfo(token, "user1", "NewNickname", "https://github.com/openimsdk/open-im-server-deploy/blob/main/assets/logo/openim-logo.png")
+
+ // Example of getting users' online status
+ _ = user.GetUsersOnlineStatus(token, []string{"user1", "user2"})
+
+ // Example of forcing a logout
+ _ = user.ForceLogout(token, "4950983283", 2)
+
+ // Example of checking user account
+ _ = user.CheckUserAccount(token, []string{"openIM123456", "anotherUserID"})
+
+ // Example of getting users
+ _ = user.GetUsers(token, 1, 100)
+}
diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go
new file mode 100644
index 0000000..7db3596
--- /dev/null
+++ b/test/e2e/e2e_test.go
@@ -0,0 +1,37 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package e2e
+
+import (
+ "flag"
+ "testing"
+
+ "git.imall.cloud/openim/open-im-server-deploy/test/e2e/framework/config"
+)
+
+// handleFlags sets up all flags and parses the command line.
+func handleFlags() {
+ config.CopyFlags(config.Flags, flag.CommandLine)
+ flag.Parse()
+}
+
+func TestMain(m *testing.M) {
+ handleFlags()
+ m.Run()
+}
+
+func TestE2E(t *testing.T) {
+ RunE2ETests(t)
+}
diff --git a/test/e2e/framework/config/config.go b/test/e2e/framework/config/config.go
new file mode 100644
index 0000000..14074fe
--- /dev/null
+++ b/test/e2e/framework/config/config.go
@@ -0,0 +1,84 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package config
+
+import (
+ "flag"
+ "os"
+)
+
+// Flags is the flag set that AddOptions adds to. Test authors should
+// also use it instead of directly adding to the global command line.
+var Flags = flag.NewFlagSet("", flag.ContinueOnError)
+
+// CopyFlags ensures that all flags that are defined in the source flag
+// set appear in the target flag set as if they had been defined there
+// directly. From the flag package it inherits the behavior that there
+// is a panic if the target already contains a flag from the source.
+func CopyFlags(source *flag.FlagSet, target *flag.FlagSet) {
+ source.VisitAll(func(flag *flag.Flag) {
+ // We don't need to copy flag.DefValue. The original
+ // default (from, say, flag.String) was stored in
+ // the value and gets extracted by Var for the help
+ // message.
+ target.Var(flag.Value, flag.Name, flag.Usage)
+ })
+}
+
+// Config defines the configuration structure for the OpenIM components.
+type Config struct {
+ APIHost string
+ APIPort string
+ MsgGatewayHost string
+ MsgTransferHost string
+ PushHost string
+ RPCAuthHost string
+ RPCConversationHost string
+ RPCFriendHost string
+ RPCGroupHost string
+ RPCMsgHost string
+ RPCThirdHost string
+ RPCUserHost string
+ // Add other configuration fields as needed
+}
+
+// LoadConfig loads the configurations from environment variables or default values.
+func LoadConfig() *Config {
+ return &Config{
+ APIHost: getEnv("OPENIM_API_HOST", "127.0.0.1"),
+ APIPort: getEnv("API_OPENIM_PORT", "10002"),
+
+ // TODO: Set default variable
+ MsgGatewayHost: getEnv("OPENIM_MSGGATEWAY_HOST", "default-msggateway-host"),
+ MsgTransferHost: getEnv("OPENIM_MSGTRANSFER_HOST", "default-msgtransfer-host"),
+ PushHost: getEnv("OPENIM_PUSH_HOST", "default-push-host"),
+ RPCAuthHost: getEnv("OPENIM_RPC_AUTH_HOST", "default-rpc-auth-host"),
+ RPCConversationHost: getEnv("OPENIM_RPC_CONVERSATION_HOST", "default-rpc-conversation-host"),
+ RPCFriendHost: getEnv("OPENIM_RPC_FRIEND_HOST", "default-rpc-friend-host"),
+ RPCGroupHost: getEnv("OPENIM_RPC_GROUP_HOST", "default-rpc-group-host"),
+ RPCMsgHost: getEnv("OPENIM_RPC_MSG_HOST", "default-rpc-msg-host"),
+ RPCThirdHost: getEnv("OPENIM_RPC_THIRD_HOST", "default-rpc-third-host"),
+ RPCUserHost: getEnv("OPENIM_RPC_USER_HOST", "default-rpc-user-host"),
+ }
+}
+
+// getEnv is a helper function to read an environment variable or return a default value.
+func getEnv(key, defaultValue string) string {
+ value, exists := os.LookupEnv(key)
+ if !exists {
+ return defaultValue
+ }
+ return value
+}
diff --git a/test/e2e/framework/config/config_test.go b/test/e2e/framework/config/config_test.go
new file mode 100644
index 0000000..66f845d
--- /dev/null
+++ b/test/e2e/framework/config/config_test.go
@@ -0,0 +1,89 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package config
+
+import (
+ "flag"
+ "reflect"
+ "testing"
+)
+
+func TestCopyFlags(t *testing.T) {
+ type args struct {
+ source *flag.FlagSet
+ target *flag.FlagSet
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Copy empty source to empty target",
+ args: args{
+ source: flag.NewFlagSet("source", flag.ContinueOnError),
+ target: flag.NewFlagSet("target", flag.ContinueOnError),
+ },
+ wantErr: false,
+ },
+ {
+ name: "Copy non-empty source to empty target",
+ args: args{
+ source: func() *flag.FlagSet {
+ fs := flag.NewFlagSet("source", flag.ContinueOnError)
+ fs.String("test-flag", "default", "test usage")
+ return fs
+ }(),
+ target: flag.NewFlagSet("target", flag.ContinueOnError),
+ },
+ wantErr: false,
+ },
+ {
+ name: "Copy source to target with existing flag",
+ args: args{
+ source: func() *flag.FlagSet {
+ fs := flag.NewFlagSet("source", flag.ContinueOnError)
+ fs.String("test-flag", "default", "test usage")
+ return fs
+ }(),
+ target: func() *flag.FlagSet {
+ fs := flag.NewFlagSet("target", flag.ContinueOnError)
+ fs.String("test-flag", "default", "test usage")
+ return fs
+ }(),
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ defer func() {
+ if r := recover(); (r != nil) != tt.wantErr {
+ t.Errorf("CopyFlags() panic = %v, wantErr %v", r, tt.wantErr)
+ }
+ }()
+ CopyFlags(tt.args.source, tt.args.target)
+
+ // Verify the replicated tag
+ if !tt.wantErr {
+ tt.args.source.VisitAll(func(f *flag.Flag) {
+ if gotFlag := tt.args.target.Lookup(f.Name); gotFlag == nil || !reflect.DeepEqual(gotFlag, f) {
+ t.Errorf("CopyFlags() failed to copy flag %s", f.Name)
+ }
+ })
+ }
+ })
+ }
+}
diff --git a/test/e2e/framework/ginkgowrapper/.keep b/test/e2e/framework/ginkgowrapper/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/framework/ginkgowrapper/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/framework/ginkgowrapper/ginkgowrapper.go b/test/e2e/framework/ginkgowrapper/ginkgowrapper.go
new file mode 100644
index 0000000..814d393
--- /dev/null
+++ b/test/e2e/framework/ginkgowrapper/ginkgowrapper.go
@@ -0,0 +1,15 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package ginkgowrapper
diff --git a/test/e2e/framework/ginkgowrapper/ginkgowrapper_test.go b/test/e2e/framework/ginkgowrapper/ginkgowrapper_test.go
new file mode 100644
index 0000000..814d393
--- /dev/null
+++ b/test/e2e/framework/ginkgowrapper/ginkgowrapper_test.go
@@ -0,0 +1,15 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package ginkgowrapper
diff --git a/test/e2e/framework/helpers/.keep b/test/e2e/framework/helpers/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/framework/helpers/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/framework/helpers/chat/chat.go b/test/e2e/framework/helpers/chat/chat.go
new file mode 100644
index 0000000..0613ff5
--- /dev/null
+++ b/test/e2e/framework/helpers/chat/chat.go
@@ -0,0 +1,167 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "os/exec"
+ "path/filepath"
+)
+
+var (
+ // The default template version.
+ defaultTemplateVersion = "v1.3.0"
+)
+
+func main() {
+ // Define the URL to get the latest version
+ // latestVersionURL := "https://github.com/openimsdk/chat/releases/latest"
+ // latestVersion, err := getLatestVersion(latestVersionURL)
+ // if err != nil {
+ // fmt.Printf("Failed to get the latest version: %v\n", err)
+ // return
+ // }
+ latestVersion := defaultTemplateVersion
+
+ // getLatestVersion
+
+ // Construct the download URL
+ downloadURL := fmt.Sprintf("https://github.com/openimsdk/chat/releases/download/%s/chat_Linux_x86_64.tar.gz", latestVersion)
+
+ // Set the installation directory
+ installDir := "/tmp/chat"
+
+ // Clear the installation directory before proceeding
+ err := os.RemoveAll(installDir)
+ if err != nil {
+ fmt.Printf("Failed to clear installation directory: %v\n", err)
+ return
+ }
+
+ // Create the installation directory
+ err = os.MkdirAll(installDir, 0755)
+ if err != nil {
+ fmt.Printf("Failed to create installation directory: %v\n", err)
+ return
+ }
+
+ // Download and extract OpenIM Chat to the installation directory
+ err = downloadAndExtract(downloadURL, installDir)
+ if err != nil {
+ fmt.Printf("Failed to download and extract OpenIM Chat: %v\n", err)
+ return
+ }
+
+ // Create configuration file directory
+ configDir := filepath.Join(installDir, "config")
+ err = os.MkdirAll(configDir, 0755)
+ if err != nil {
+ fmt.Printf("Failed to create configuration directory: %v\n", err)
+ return
+ }
+
+ // Download configuration files
+ configURL := "https://raw.githubusercontent.com/openimsdk/chat/main/config/config.yaml"
+ err = downloadAndExtract(configURL, configDir)
+ if err != nil {
+ fmt.Printf("Failed to download and extract configuration files: %v\n", err)
+ return
+ }
+
+ // Define the processes to be started
+ cmds := []string{
+ "admin-api",
+ "admin-rpc",
+ "chat-api",
+ "chat-rpc",
+ }
+
+ // Start each process in a new goroutine
+ for _, cmd := range cmds {
+ go startProcess(filepath.Join(installDir, cmd))
+ }
+
+ // Block the main thread indefinitely
+ select {}
+}
+
+/* func getLatestVersion(url string) (string, error) {
+ resp, err := webhook.Get(url)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+
+// location := resp.Header.Get("Location")
+// if location == "" {
+// return defaultTemplateVersion, nil
+// }
+
+ // Extract the version number from the URL
+ latestVersion := filepath.Base(location)
+ return latestVersion, nil
+} */
+
+// downloadAndExtract downloads a file from a URL and extracts it to a destination directory.
+func downloadAndExtract(url, destDir string) error {
+ resp, err := http.Get(url)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return fmt.Errorf("error downloading file, HTTP status code: %d", resp.StatusCode)
+ }
+
+ // Create the destination directory
+ err = os.MkdirAll(destDir, 0755)
+ if err != nil {
+ return err
+ }
+
+ // Define the path for the downloaded file
+ filePath := filepath.Join(destDir, "downloaded_file.tar.gz")
+ file, err := os.Create(filePath)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+
+ // Copy the downloaded file
+ _, err = io.Copy(file, resp.Body)
+ if err != nil {
+ return err
+ }
+
+ // Extract the file
+ cmd := exec.Command("tar", "xzvf", filePath, "-C", destDir)
+ cmd.Stdout = os.Stdout
+ cmd.Stderr = os.Stderr
+ return cmd.Run()
+}
+
+// startProcess starts a process and prints any errors encountered.
+func startProcess(cmdPath string) {
+ cmd := exec.Command(cmdPath)
+ cmd.Stdout = os.Stdout
+ cmd.Stderr = os.Stderr
+ if err := cmd.Run(); err != nil {
+ fmt.Printf("Failed to start process %s: %v\n", cmdPath, err)
+ }
+}
diff --git a/test/e2e/page/chat_page.go b/test/e2e/page/chat_page.go
new file mode 100644
index 0000000..d92c7ec
--- /dev/null
+++ b/test/e2e/page/chat_page.go
@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package page
diff --git a/test/e2e/page/login_page.go b/test/e2e/page/login_page.go
new file mode 100644
index 0000000..d92c7ec
--- /dev/null
+++ b/test/e2e/page/login_page.go
@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package page
diff --git a/test/e2e/performance/.keep b/test/e2e/performance/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/performance/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/rpc/auth/.keep b/test/e2e/rpc/auth/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/rpc/auth/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/rpc/conversation/.keep b/test/e2e/rpc/conversation/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/rpc/conversation/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/rpc/friend/.keep b/test/e2e/rpc/friend/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/rpc/friend/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/rpc/group/.keep b/test/e2e/rpc/group/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/rpc/group/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/rpc/message/.keep b/test/e2e/rpc/message/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/rpc/message/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/scalability/.keep b/test/e2e/scalability/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/scalability/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/upgrade/.keep b/test/e2e/upgrade/.keep
new file mode 100644
index 0000000..4f07f1c
--- /dev/null
+++ b/test/e2e/upgrade/.keep
@@ -0,0 +1 @@
+.keep
\ No newline at end of file
diff --git a/test/e2e/web/Readme.md b/test/e2e/web/Readme.md
new file mode 100644
index 0000000..741ca51
--- /dev/null
+++ b/test/e2e/web/Readme.md
@@ -0,0 +1,2 @@
+# OpenIM Web E2E
+
diff --git a/test/jwt/main.go b/test/jwt/main.go
new file mode 100644
index 0000000..0ef8452
--- /dev/null
+++ b/test/jwt/main.go
@@ -0,0 +1,48 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "fmt"
+
+ "github.com/golang-jwt/jwt/v4"
+)
+
+func main() {
+ rawJWT := `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VySUQiOiI4MjkzODEzMTgzIiwiUGxhdGZvcm1JRCI6NSwiZXhwIjoxNzA2NTk0MTU0LCJuYmYiOjE2OTg4MTc4NTQsImlhdCI6MTY5ODgxODE1NH0.QCJHzU07SC6iYBoFO6Zsm61TNDor2D89I4E3zg8HHHU`
+
+ // Verify the token
+ claims := &jwt.MapClaims{}
+ parsedT, err := jwt.ParseWithClaims(rawJWT, claims, func(token *jwt.Token) (any, error) {
+ // Validate the alg is HMAC signature
+ if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+ return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+ }
+
+ if kid, ok := token.Header["kid"].(string); ok {
+ fmt.Println("kid", kid)
+ }
+
+ return []byte("key1"), nil
+ })
+
+ if err != nil || !parsedT.Valid {
+ fmt.Println("token valid failed", err)
+
+ return
+ }
+
+ fmt.Println("ok")
+}
diff --git a/test/readme b/test/readme
new file mode 100644
index 0000000..8c865ce
--- /dev/null
+++ b/test/readme
@@ -0,0 +1,17 @@
+## Run the Tests
+
+read: [Test Docs](./docs/contrib/test.md)
+
+To run a single test or set of tests, you'll need the [Ginkgo](https://github.com/onsi/ginkgo) tool installed on your
+machine:
+
+```console
+go install github.com/onsi/ginkgo/ginkgo@latest
+```
+
+```shell
+ginkgo --help
+ --focus value
+ If set, ginkgo will only run specs that match this regular expression. Can be specified multiple times, values are ORed.
+
+```
diff --git a/test/stress-test-v2/README.md b/test/stress-test-v2/README.md
new file mode 100644
index 0000000..cbd4bdb
--- /dev/null
+++ b/test/stress-test-v2/README.md
@@ -0,0 +1,19 @@
+# Stress Test V2
+
+## Usage
+
+You need set `TestTargetUserList` variables.
+
+### Build
+
+```bash
+
+go build -o test/stress-test-v2/stress-test-v2 test/stress-test-v2/main.go
+```
+
+### Excute
+
+```bash
+
+tools/stress-test-v2/stress-test-v2 -c config/
+```
diff --git a/test/stress-test-v2/main.go b/test/stress-test-v2/main.go
new file mode 100644
index 0000000..15e6082
--- /dev/null
+++ b/test/stress-test-v2/main.go
@@ -0,0 +1,759 @@
+package main
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "os/signal"
+ "sync"
+ "syscall"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/apistruct"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+ "git.imall.cloud/openim/protocol/auth"
+ "git.imall.cloud/openim/protocol/constant"
+ "git.imall.cloud/openim/protocol/group"
+ "git.imall.cloud/openim/protocol/sdkws"
+ pbuser "git.imall.cloud/openim/protocol/user"
+ "github.com/openimsdk/tools/log"
+ "github.com/openimsdk/tools/system/program"
+)
+
+// 1. Create 100K New Users
+// 2. Create 100 100K Groups
+// 3. Create 1000 999 Groups
+// 4. Send message to 100K Groups every second
+// 5. Send message to 999 Groups every minute
+
+var (
+ // Use default userIDs List for testing, need to be created.
+ TestTargetUserList = []string{
+ // "",
+ }
+ // DefaultGroupID = "" // Use default group ID for testing, need to be created.
+)
+
+var (
+ ApiAddress string
+
+ // API method
+ GetAdminToken = "/auth/get_admin_token"
+ UserCheck = "/user/account_check"
+ CreateUser = "/user/user_register"
+ ImportFriend = "/friend/import_friend"
+ InviteToGroup = "/group/invite_user_to_group"
+ GetGroupMemberInfo = "/group/get_group_members_info"
+ SendMsg = "/msg/send_msg"
+ CreateGroup = "/group/create_group"
+ GetUserToken = "/auth/user_token"
+)
+
+const (
+ MaxUser = 100000
+ Max1kUser = 1000
+ Max100KGroup = 100
+ Max999Group = 1000
+ MaxInviteUserLimit = 999
+
+ CreateUserTicker = 1 * time.Second
+ CreateGroupTicker = 1 * time.Second
+ Create100KGroupTicker = 1 * time.Second
+ Create999GroupTicker = 1 * time.Second
+ SendMsgTo100KGroupTicker = 1 * time.Second
+ SendMsgTo999GroupTicker = 1 * time.Minute
+)
+
+type BaseResp struct {
+ ErrCode int `json:"errCode"`
+ ErrMsg string `json:"errMsg"`
+ Data json.RawMessage `json:"data"`
+}
+
+type StressTest struct {
+ Conf *conf
+ AdminUserID string
+ AdminToken string
+ DefaultGroupID string
+ DefaultUserID string
+ UserCounter int
+ CreateUserCounter int
+ Create100kGroupCounter int
+ Create999GroupCounter int
+ MsgCounter int
+ CreatedUsers []string
+ CreatedGroups []string
+ Mutex sync.Mutex
+ Ctx context.Context
+ Cancel context.CancelFunc
+ HttpClient *http.Client
+ Wg sync.WaitGroup
+ Once sync.Once
+}
+
+type conf struct {
+ Share config.Share
+ Api config.API
+}
+
+func initConfig(configDir string) (*config.Share, *config.API, error) {
+ var (
+ share = &config.Share{}
+ apiConfig = &config.API{}
+ )
+
+ err := config.Load(configDir, config.ShareFileName, config.EnvPrefixMap[config.ShareFileName], share)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = config.Load(configDir, config.OpenIMAPICfgFileName, config.EnvPrefixMap[config.OpenIMAPICfgFileName], apiConfig)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return share, apiConfig, nil
+}
+
+// Post Request
+func (st *StressTest) PostRequest(ctx context.Context, url string, reqbody any) ([]byte, error) {
+ // Marshal body
+ jsonBody, err := json.Marshal(reqbody)
+ if err != nil {
+ log.ZError(ctx, "Failed to marshal request body", err, "url", url, "reqbody", reqbody)
+ return nil, err
+ }
+
+ req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(jsonBody))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("operationID", st.AdminUserID)
+ if st.AdminToken != "" {
+ req.Header.Set("token", st.AdminToken)
+ }
+
+ // log.ZInfo(ctx, "Header info is ", "Content-Type", "application/json", "operationID", st.AdminUserID, "token", st.AdminToken)
+
+ resp, err := st.HttpClient.Do(req)
+ if err != nil {
+ log.ZError(ctx, "Failed to send request", err, "url", url, "reqbody", reqbody)
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ respBody, err := io.ReadAll(resp.Body)
+ if err != nil {
+ log.ZError(ctx, "Failed to read response body", err, "url", url)
+ return nil, err
+ }
+
+ var baseResp BaseResp
+ if err := json.Unmarshal(respBody, &baseResp); err != nil {
+ log.ZError(ctx, "Failed to unmarshal response body", err, "url", url, "respBody", string(respBody))
+ return nil, err
+ }
+
+ if baseResp.ErrCode != 0 {
+ err = fmt.Errorf(baseResp.ErrMsg)
+ // log.ZError(ctx, "Failed to send request", err, "url", url, "reqbody", reqbody, "resp", baseResp)
+ return nil, err
+ }
+
+ return baseResp.Data, nil
+}
+
+func (st *StressTest) GetAdminToken(ctx context.Context) (string, error) {
+ req := auth.GetAdminTokenReq{
+ Secret: st.Conf.Share.Secret,
+ UserID: st.AdminUserID,
+ }
+
+ resp, err := st.PostRequest(ctx, ApiAddress+GetAdminToken, &req)
+ if err != nil {
+ return "", err
+ }
+
+ data := &auth.GetAdminTokenResp{}
+ if err := json.Unmarshal(resp, &data); err != nil {
+ return "", err
+ }
+
+ return data.Token, nil
+}
+
+func (st *StressTest) CheckUser(ctx context.Context, userIDs []string) ([]string, error) {
+ req := pbuser.AccountCheckReq{
+ CheckUserIDs: userIDs,
+ }
+
+ resp, err := st.PostRequest(ctx, ApiAddress+UserCheck, &req)
+ if err != nil {
+ return nil, err
+ }
+
+ data := &pbuser.AccountCheckResp{}
+ if err := json.Unmarshal(resp, &data); err != nil {
+ return nil, err
+ }
+
+ unRegisteredUserIDs := make([]string, 0)
+
+ for _, res := range data.Results {
+ if res.AccountStatus == constant.UnRegistered {
+ unRegisteredUserIDs = append(unRegisteredUserIDs, res.UserID)
+ }
+ }
+
+ return unRegisteredUserIDs, nil
+}
+
+func (st *StressTest) CreateUser(ctx context.Context, userID string) (string, error) {
+ user := &sdkws.UserInfo{
+ UserID: userID,
+ Nickname: userID,
+ }
+
+ req := pbuser.UserRegisterReq{
+ Users: []*sdkws.UserInfo{user},
+ }
+
+ _, err := st.PostRequest(ctx, ApiAddress+CreateUser, &req)
+ if err != nil {
+ return "", err
+ }
+
+ st.UserCounter++
+ return userID, nil
+}
+
+func (st *StressTest) CreateUserBatch(ctx context.Context, userIDs []string) error {
+ // The method can import a large number of users at once.
+ var userList []*sdkws.UserInfo
+
+ defer st.Once.Do(
+ func() {
+ st.DefaultUserID = userIDs[0]
+ fmt.Println("Default Send User Created ID:", st.DefaultUserID)
+ })
+
+ needUserIDs, err := st.CheckUser(ctx, userIDs)
+ if err != nil {
+ return err
+ }
+
+ for _, userID := range needUserIDs {
+ user := &sdkws.UserInfo{
+ UserID: userID,
+ Nickname: userID,
+ }
+ userList = append(userList, user)
+ }
+
+ req := pbuser.UserRegisterReq{
+ Users: userList,
+ }
+
+ _, err = st.PostRequest(ctx, ApiAddress+CreateUser, &req)
+ if err != nil {
+ return err
+ }
+
+ st.UserCounter += len(userList)
+ return nil
+}
+
+func (st *StressTest) GetGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]string, error) {
+ needInviteUserIDs := make([]string, 0)
+
+ const maxBatchSize = 500
+ if len(userIDs) > maxBatchSize {
+ for i := 0; i < len(userIDs); i += maxBatchSize {
+ end := min(i+maxBatchSize, len(userIDs))
+ batchUserIDs := userIDs[i:end]
+
+ // log.ZInfo(ctx, "Processing group members batch", "groupID", groupID, "batch", i/maxBatchSize+1,
+ // "batchUserCount", len(batchUserIDs))
+
+ // Process a single batch
+ batchReq := group.GetGroupMembersInfoReq{
+ GroupID: groupID,
+ UserIDs: batchUserIDs,
+ }
+
+ resp, err := st.PostRequest(ctx, ApiAddress+GetGroupMemberInfo, &batchReq)
+ if err != nil {
+ log.ZError(ctx, "Batch query failed", err, "batch", i/maxBatchSize+1)
+ continue
+ }
+
+ data := &group.GetGroupMembersInfoResp{}
+ if err := json.Unmarshal(resp, &data); err != nil {
+ log.ZError(ctx, "Failed to parse batch response", err, "batch", i/maxBatchSize+1)
+ continue
+ }
+
+ // Process the batch results
+ existingMembers := make(map[string]bool)
+ for _, member := range data.Members {
+ existingMembers[member.UserID] = true
+ }
+
+ for _, userID := range batchUserIDs {
+ if !existingMembers[userID] {
+ needInviteUserIDs = append(needInviteUserIDs, userID)
+ }
+ }
+ }
+
+ return needInviteUserIDs, nil
+ }
+
+ req := group.GetGroupMembersInfoReq{
+ GroupID: groupID,
+ UserIDs: userIDs,
+ }
+
+ resp, err := st.PostRequest(ctx, ApiAddress+GetGroupMemberInfo, &req)
+ if err != nil {
+ return nil, err
+ }
+
+ data := &group.GetGroupMembersInfoResp{}
+ if err := json.Unmarshal(resp, &data); err != nil {
+ return nil, err
+ }
+
+ existingMembers := make(map[string]bool)
+ for _, member := range data.Members {
+ existingMembers[member.UserID] = true
+ }
+
+ for _, userID := range userIDs {
+ if !existingMembers[userID] {
+ needInviteUserIDs = append(needInviteUserIDs, userID)
+ }
+ }
+
+ return needInviteUserIDs, nil
+}
+
+func (st *StressTest) InviteToGroup(ctx context.Context, groupID string, userIDs []string) error {
+ req := group.InviteUserToGroupReq{
+ GroupID: groupID,
+ InvitedUserIDs: userIDs,
+ }
+ _, err := st.PostRequest(ctx, ApiAddress+InviteToGroup, &req)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (st *StressTest) SendMsg(ctx context.Context, userID string, groupID string) error {
+ contentObj := map[string]any{
+ // "content": fmt.Sprintf("index %d. The current time is %s", st.MsgCounter, time.Now().Format("2006-01-02 15:04:05.000")),
+ "content": fmt.Sprintf("The current time is %s", time.Now().Format("2006-01-02 15:04:05.000")),
+ }
+
+ req := &apistruct.SendMsgReq{
+ SendMsg: apistruct.SendMsg{
+ SendID: userID,
+ SenderNickname: userID,
+ GroupID: groupID,
+ ContentType: constant.Text,
+ SessionType: constant.ReadGroupChatType,
+ Content: contentObj,
+ },
+ }
+
+ _, err := st.PostRequest(ctx, ApiAddress+SendMsg, &req)
+ if err != nil {
+ log.ZError(ctx, "Failed to send message", err, "userID", userID, "req", &req)
+ return err
+ }
+
+ st.MsgCounter++
+
+ return nil
+}
+
+// Max userIDs number is 1000
+func (st *StressTest) CreateGroup(ctx context.Context, groupID string, userID string, userIDsList []string) (string, error) {
+ groupInfo := &sdkws.GroupInfo{
+ GroupID: groupID,
+ GroupName: groupID,
+ GroupType: constant.WorkingGroup,
+ }
+
+ req := group.CreateGroupReq{
+ OwnerUserID: userID,
+ MemberUserIDs: userIDsList,
+ GroupInfo: groupInfo,
+ }
+
+ resp := group.CreateGroupResp{}
+
+ response, err := st.PostRequest(ctx, ApiAddress+CreateGroup, &req)
+ if err != nil {
+ return "", err
+ }
+
+ if err := json.Unmarshal(response, &resp); err != nil {
+ return "", err
+ }
+
+ // st.GroupCounter++
+
+ return resp.GroupInfo.GroupID, nil
+}
+
+func main() {
+ var configPath string
+ // defaultConfigDir := filepath.Join("..", "..", "..", "..", "..", "config")
+ // flag.StringVar(&configPath, "c", defaultConfigDir, "config path")
+ flag.StringVar(&configPath, "c", "", "config path")
+ flag.Parse()
+
+ if configPath == "" {
+ _, _ = fmt.Fprintln(os.Stderr, "config path is empty")
+ os.Exit(1)
+ return
+ }
+
+ fmt.Printf(" Config Path: %s\n", configPath)
+
+ share, apiConfig, err := initConfig(configPath)
+ if err != nil {
+ program.ExitWithError(err)
+ return
+ }
+
+ ApiAddress = fmt.Sprintf("http://%s:%s", "127.0.0.1", fmt.Sprint(apiConfig.Api.Ports[0]))
+
+ ctx, cancel := context.WithCancel(context.Background())
+ // ch := make(chan struct{})
+
+ st := &StressTest{
+ Conf: &conf{
+ Share: *share,
+ Api: *apiConfig,
+ },
+ AdminUserID: share.IMAdminUser.UserIDs[0],
+ Ctx: ctx,
+ Cancel: cancel,
+ HttpClient: &http.Client{
+ Timeout: 50 * time.Second,
+ },
+ }
+
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+ go func() {
+ <-c
+ fmt.Println("\nReceived stop signal, stopping...")
+
+ go func() {
+ // time.Sleep(5 * time.Second)
+ fmt.Println("Force exit")
+ os.Exit(0)
+ }()
+
+ st.Cancel()
+ }()
+
+ token, err := st.GetAdminToken(st.Ctx)
+ if err != nil {
+ log.ZError(ctx, "Get Admin Token failed.", err, "AdminUserID", st.AdminUserID)
+ }
+
+ st.AdminToken = token
+ fmt.Println("Admin Token:", st.AdminToken)
+ fmt.Println("ApiAddress:", ApiAddress)
+
+ for i := range MaxUser {
+ userID := fmt.Sprintf("v2_StressTest_User_%d", i)
+ st.CreatedUsers = append(st.CreatedUsers, userID)
+ st.CreateUserCounter++
+ }
+
+ // err = st.CreateUserBatch(st.Ctx, st.CreatedUsers)
+ // if err != nil {
+ // log.ZError(ctx, "Create user failed.", err)
+ // }
+
+ const batchSize = 1000
+ totalUsers := len(st.CreatedUsers)
+ successCount := 0
+
+ if st.DefaultUserID == "" && len(st.CreatedUsers) > 0 {
+ st.DefaultUserID = st.CreatedUsers[0]
+ }
+
+ for i := 0; i < totalUsers; i += batchSize {
+ end := min(i+batchSize, totalUsers)
+
+ userBatch := st.CreatedUsers[i:end]
+ log.ZInfo(st.Ctx, "Creating user batch", "batch", i/batchSize+1, "count", len(userBatch))
+
+ err = st.CreateUserBatch(st.Ctx, userBatch)
+ if err != nil {
+ log.ZError(st.Ctx, "Batch user creation failed", err, "batch", i/batchSize+1)
+ } else {
+ successCount += len(userBatch)
+ log.ZInfo(st.Ctx, "Batch user creation succeeded", "batch", i/batchSize+1,
+ "progress", fmt.Sprintf("%d/%d", successCount, totalUsers))
+ }
+ }
+
+ // Execute create 100k group
+ st.Wg.Add(1)
+ go func() {
+ defer st.Wg.Done()
+
+ create100kGroupTicker := time.NewTicker(Create100KGroupTicker)
+ defer create100kGroupTicker.Stop()
+
+ for i := range Max100KGroup {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Create 100K Group")
+ return
+
+ case <-create100kGroupTicker.C:
+ // Create 100K groups
+ st.Wg.Add(1)
+ go func(idx int) {
+ startTime := time.Now()
+ defer func() {
+ elapsedTime := time.Since(startTime)
+ log.ZInfo(st.Ctx, "100K group creation completed",
+ "groupID", fmt.Sprintf("v2_StressTest_Group_100K_%d", idx),
+ "index", idx,
+ "duration", elapsedTime.String())
+ }()
+
+ defer st.Wg.Done()
+ defer func() {
+ st.Mutex.Lock()
+ st.Create100kGroupCounter++
+ st.Mutex.Unlock()
+ }()
+
+ groupID := fmt.Sprintf("v2_StressTest_Group_100K_%d", idx)
+
+ if _, err = st.CreateGroup(st.Ctx, groupID, st.DefaultUserID, TestTargetUserList); err != nil {
+ log.ZError(st.Ctx, "Create group failed.", err)
+ // continue
+ }
+
+ for i := 0; i <= MaxUser/MaxInviteUserLimit; i++ {
+ InviteUserIDs := make([]string, 0)
+ // ensure TargetUserList is in group
+ InviteUserIDs = append(InviteUserIDs, TestTargetUserList...)
+
+ startIdx := max(i*MaxInviteUserLimit, 1)
+ endIdx := min((i+1)*MaxInviteUserLimit, MaxUser)
+
+ for j := startIdx; j < endIdx; j++ {
+ userCreatedID := fmt.Sprintf("v2_StressTest_User_%d", j)
+ InviteUserIDs = append(InviteUserIDs, userCreatedID)
+ }
+
+ if len(InviteUserIDs) == 0 {
+ // log.ZWarn(st.Ctx, "InviteUserIDs is empty", nil, "groupID", groupID)
+ continue
+ }
+
+ InviteUserIDs, err := st.GetGroupMembersInfo(ctx, groupID, InviteUserIDs)
+ if err != nil {
+ log.ZError(st.Ctx, "GetGroupMembersInfo failed.", err, "groupID", groupID)
+ continue
+ }
+
+ if len(InviteUserIDs) == 0 {
+ // log.ZWarn(st.Ctx, "InviteUserIDs is empty", nil, "groupID", groupID)
+ continue
+ }
+
+ // Invite To Group
+ if err = st.InviteToGroup(st.Ctx, groupID, InviteUserIDs); err != nil {
+ log.ZError(st.Ctx, "Invite To Group failed.", err, "UserID", InviteUserIDs)
+ continue
+ // os.Exit(1)
+ // return
+ }
+ }
+ }(i)
+ }
+ }
+ }()
+
+ // create 999 groups
+ st.Wg.Add(1)
+ go func() {
+ defer st.Wg.Done()
+
+ create999GroupTicker := time.NewTicker(Create999GroupTicker)
+ defer create999GroupTicker.Stop()
+
+ for i := range Max999Group {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Create 999 Group")
+ return
+
+ case <-create999GroupTicker.C:
+ // Create 999 groups
+ st.Wg.Add(1)
+ go func(idx int) {
+ startTime := time.Now()
+ defer func() {
+ elapsedTime := time.Since(startTime)
+ log.ZInfo(st.Ctx, "999 group creation completed",
+ "groupID", fmt.Sprintf("v2_StressTest_Group_1K_%d", idx),
+ "index", idx,
+ "duration", elapsedTime.String())
+ }()
+
+ defer st.Wg.Done()
+ defer func() {
+ st.Mutex.Lock()
+ st.Create999GroupCounter++
+ st.Mutex.Unlock()
+ }()
+
+ groupID := fmt.Sprintf("v2_StressTest_Group_1K_%d", idx)
+
+ if _, err = st.CreateGroup(st.Ctx, groupID, st.DefaultUserID, TestTargetUserList); err != nil {
+ log.ZError(st.Ctx, "Create group failed.", err)
+ // continue
+ }
+ for i := 0; i <= Max1kUser/MaxInviteUserLimit; i++ {
+ InviteUserIDs := make([]string, 0)
+ // ensure TargetUserList is in group
+ InviteUserIDs = append(InviteUserIDs, TestTargetUserList...)
+
+ startIdx := max(i*MaxInviteUserLimit, 1)
+ endIdx := min((i+1)*MaxInviteUserLimit, Max1kUser)
+
+ for j := startIdx; j < endIdx; j++ {
+ userCreatedID := fmt.Sprintf("v2_StressTest_User_%d", j)
+ InviteUserIDs = append(InviteUserIDs, userCreatedID)
+ }
+
+ if len(InviteUserIDs) == 0 {
+ // log.ZWarn(st.Ctx, "InviteUserIDs is empty", nil, "groupID", groupID)
+ continue
+ }
+
+ InviteUserIDs, err := st.GetGroupMembersInfo(ctx, groupID, InviteUserIDs)
+ if err != nil {
+ log.ZError(st.Ctx, "GetGroupMembersInfo failed.", err, "groupID", groupID)
+ continue
+ }
+
+ if len(InviteUserIDs) == 0 {
+ // log.ZWarn(st.Ctx, "InviteUserIDs is empty", nil, "groupID", groupID)
+ continue
+ }
+
+ // Invite To Group
+ if err = st.InviteToGroup(st.Ctx, groupID, InviteUserIDs); err != nil {
+ log.ZError(st.Ctx, "Invite To Group failed.", err, "UserID", InviteUserIDs)
+ continue
+ // os.Exit(1)
+ // return
+ }
+ }
+ }(i)
+ }
+ }
+ }()
+
+ // Send message to 100K groups
+ st.Wg.Wait()
+ fmt.Println("All groups created successfully, starting to send messages...")
+ log.ZInfo(ctx, "All groups created successfully, starting to send messages...")
+
+ var groups100K []string
+ var groups999 []string
+
+ for i := range Max100KGroup {
+ groupID := fmt.Sprintf("v2_StressTest_Group_100K_%d", i)
+ groups100K = append(groups100K, groupID)
+ }
+
+ for i := range Max999Group {
+ groupID := fmt.Sprintf("v2_StressTest_Group_1K_%d", i)
+ groups999 = append(groups999, groupID)
+ }
+
+ send100kGroupLimiter := make(chan struct{}, 20)
+ send999GroupLimiter := make(chan struct{}, 100)
+
+ // execute Send message to 100K groups
+ go func() {
+ ticker := time.NewTicker(SendMsgTo100KGroupTicker)
+ defer ticker.Stop()
+
+ for {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Send Message to 100K Group")
+ return
+
+ case <-ticker.C:
+ // Send message to 100K groups
+ for _, groupID := range groups100K {
+ send100kGroupLimiter <- struct{}{}
+ go func(groupID string) {
+ defer func() { <-send100kGroupLimiter }()
+ if err := st.SendMsg(st.Ctx, st.DefaultUserID, groupID); err != nil {
+ log.ZError(st.Ctx, "Send message to 100K group failed.", err)
+ }
+ }(groupID)
+ }
+ // log.ZInfo(st.Ctx, "Send message to 100K groups successfully.")
+ }
+ }
+ }()
+
+ // execute Send message to 999 groups
+ go func() {
+ ticker := time.NewTicker(SendMsgTo999GroupTicker)
+ defer ticker.Stop()
+
+ for {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Send Message to 999 Group")
+ return
+
+ case <-ticker.C:
+ // Send message to 999 groups
+ for _, groupID := range groups999 {
+ send999GroupLimiter <- struct{}{}
+ go func(groupID string) {
+ defer func() { <-send999GroupLimiter }()
+
+ if err := st.SendMsg(st.Ctx, st.DefaultUserID, groupID); err != nil {
+ log.ZError(st.Ctx, "Send message to 999 group failed.", err)
+ }
+ }(groupID)
+ }
+ // log.ZInfo(st.Ctx, "Send message to 999 groups successfully.")
+ }
+ }
+ }()
+
+ <-st.Ctx.Done()
+ fmt.Println("Received signal to exit, shutting down...")
+}
diff --git a/test/stress-test/README.md b/test/stress-test/README.md
new file mode 100644
index 0000000..cba93e2
--- /dev/null
+++ b/test/stress-test/README.md
@@ -0,0 +1,19 @@
+# Stress Test
+
+## Usage
+
+You need set `TestTargetUserList` and `DefaultGroupID` variables.
+
+### Build
+
+```bash
+
+go build -o test/stress-test/stress-test test/stress-test/main.go
+```
+
+### Excute
+
+```bash
+
+tools/stress-test/stress-test -c config/
+```
diff --git a/test/stress-test/main.go b/test/stress-test/main.go
new file mode 100755
index 0000000..fb126db
--- /dev/null
+++ b/test/stress-test/main.go
@@ -0,0 +1,458 @@
+package main
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "os/signal"
+ "sync"
+ "syscall"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/apistruct"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+ "git.imall.cloud/openim/protocol/auth"
+ "git.imall.cloud/openim/protocol/constant"
+ "git.imall.cloud/openim/protocol/group"
+ "git.imall.cloud/openim/protocol/relation"
+ "git.imall.cloud/openim/protocol/sdkws"
+ pbuser "git.imall.cloud/openim/protocol/user"
+ "github.com/openimsdk/tools/log"
+ "github.com/openimsdk/tools/system/program"
+)
+
+/*
+ 1. Create one user every minute
+ 2. Import target users as friends
+ 3. Add users to the default group
+ 4. Send a message to the default group every second, containing index and current timestamp
+ 5. Create a new group every minute and invite target users to join
+*/
+
+// !!! ATTENTION: This variable is must be added!
+var (
+ // Use default userIDs List for testing, need to be created.
+ TestTargetUserList = []string{
+ "",
+ }
+ DefaultGroupID = "" // Use default group ID for testing, need to be created.
+)
+
+var (
+ ApiAddress string
+
+ // API method
+ GetAdminToken = "/auth/get_admin_token"
+ CreateUser = "/user/user_register"
+ ImportFriend = "/friend/import_friend"
+ InviteToGroup = "/group/invite_user_to_group"
+ SendMsg = "/msg/send_msg"
+ CreateGroup = "/group/create_group"
+ GetUserToken = "/auth/user_token"
+)
+
+const (
+ MaxUser = 10000
+ MaxGroup = 1000
+
+ CreateUserTicker = 1 * time.Minute // Ticker is 1min in create user
+ SendMessageTicker = 1 * time.Second // Ticker is 1s in send message
+ CreateGroupTicker = 1 * time.Minute
+)
+
+type BaseResp struct {
+ ErrCode int `json:"errCode"`
+ ErrMsg string `json:"errMsg"`
+ Data json.RawMessage `json:"data"`
+}
+
+type StressTest struct {
+ Conf *conf
+ AdminUserID string
+ AdminToken string
+ DefaultGroupID string
+ DefaultUserID string
+ UserCounter int
+ GroupCounter int
+ MsgCounter int
+ CreatedUsers []string
+ CreatedGroups []string
+ Mutex sync.Mutex
+ Ctx context.Context
+ Cancel context.CancelFunc
+ HttpClient *http.Client
+ Wg sync.WaitGroup
+ Once sync.Once
+}
+
+type conf struct {
+ Share config.Share
+ Api config.API
+}
+
+func initConfig(configDir string) (*config.Share, *config.API, error) {
+ var (
+ share = &config.Share{}
+ apiConfig = &config.API{}
+ )
+
+ err := config.Load(configDir, config.ShareFileName, config.EnvPrefixMap[config.ShareFileName], share)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = config.Load(configDir, config.OpenIMAPICfgFileName, config.EnvPrefixMap[config.OpenIMAPICfgFileName], apiConfig)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return share, apiConfig, nil
+}
+
+// Post Request
+func (st *StressTest) PostRequest(ctx context.Context, url string, reqbody any) ([]byte, error) {
+ // Marshal body
+ jsonBody, err := json.Marshal(reqbody)
+ if err != nil {
+ log.ZError(ctx, "Failed to marshal request body", err, "url", url, "reqbody", reqbody)
+ return nil, err
+ }
+
+ req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(jsonBody))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/json")
+ req.Header.Set("operationID", st.AdminUserID)
+ if st.AdminToken != "" {
+ req.Header.Set("token", st.AdminToken)
+ }
+
+ // log.ZInfo(ctx, "Header info is ", "Content-Type", "application/json", "operationID", st.AdminUserID, "token", st.AdminToken)
+
+ resp, err := st.HttpClient.Do(req)
+ if err != nil {
+ log.ZError(ctx, "Failed to send request", err, "url", url, "reqbody", reqbody)
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ respBody, err := io.ReadAll(resp.Body)
+ if err != nil {
+ log.ZError(ctx, "Failed to read response body", err, "url", url)
+ return nil, err
+ }
+
+ var baseResp BaseResp
+ if err := json.Unmarshal(respBody, &baseResp); err != nil {
+ log.ZError(ctx, "Failed to unmarshal response body", err, "url", url, "respBody", string(respBody))
+ return nil, err
+ }
+
+ if baseResp.ErrCode != 0 {
+ err = fmt.Errorf(baseResp.ErrMsg)
+ log.ZError(ctx, "Failed to send request", err, "url", url, "reqbody", reqbody, "resp", baseResp)
+ return nil, err
+ }
+
+ return baseResp.Data, nil
+}
+
+func (st *StressTest) GetAdminToken(ctx context.Context) (string, error) {
+ req := auth.GetAdminTokenReq{
+ Secret: st.Conf.Share.Secret,
+ UserID: st.AdminUserID,
+ }
+
+ resp, err := st.PostRequest(ctx, ApiAddress+GetAdminToken, &req)
+ if err != nil {
+ return "", err
+ }
+
+ data := &auth.GetAdminTokenResp{}
+ if err := json.Unmarshal(resp, &data); err != nil {
+ return "", err
+ }
+
+ return data.Token, nil
+}
+
+func (st *StressTest) CreateUser(ctx context.Context, userID string) (string, error) {
+ user := &sdkws.UserInfo{
+ UserID: userID,
+ Nickname: userID,
+ }
+
+ req := pbuser.UserRegisterReq{
+ Users: []*sdkws.UserInfo{user},
+ }
+
+ _, err := st.PostRequest(ctx, ApiAddress+CreateUser, &req)
+ if err != nil {
+ return "", err
+ }
+
+ st.UserCounter++
+ return userID, nil
+}
+
+func (st *StressTest) ImportFriend(ctx context.Context, userID string) error {
+ req := relation.ImportFriendReq{
+ OwnerUserID: userID,
+ FriendUserIDs: TestTargetUserList,
+ }
+
+ _, err := st.PostRequest(ctx, ApiAddress+ImportFriend, &req)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (st *StressTest) InviteToGroup(ctx context.Context, userID string) error {
+ req := group.InviteUserToGroupReq{
+ GroupID: st.DefaultGroupID,
+ InvitedUserIDs: []string{userID},
+ }
+ _, err := st.PostRequest(ctx, ApiAddress+InviteToGroup, &req)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (st *StressTest) SendMsg(ctx context.Context, userID string) error {
+ contentObj := map[string]any{
+ "content": fmt.Sprintf("index %d. The current time is %s", st.MsgCounter, time.Now().Format("2006-01-02 15:04:05.000")),
+ }
+
+ req := &apistruct.SendMsgReq{
+ SendMsg: apistruct.SendMsg{
+ SendID: userID,
+ SenderNickname: userID,
+ GroupID: st.DefaultGroupID,
+ ContentType: constant.Text,
+ SessionType: constant.ReadGroupChatType,
+ Content: contentObj,
+ },
+ }
+
+ _, err := st.PostRequest(ctx, ApiAddress+SendMsg, &req)
+ if err != nil {
+ log.ZError(ctx, "Failed to send message", err, "userID", userID, "req", &req)
+ return err
+ }
+
+ st.MsgCounter++
+
+ return nil
+}
+
+func (st *StressTest) CreateGroup(ctx context.Context, userID string) (string, error) {
+ groupID := fmt.Sprintf("StressTestGroup_%d_%s", st.GroupCounter, time.Now().Format("20060102150405"))
+
+ groupInfo := &sdkws.GroupInfo{
+ GroupID: groupID,
+ GroupName: groupID,
+ GroupType: constant.WorkingGroup,
+ }
+
+ req := group.CreateGroupReq{
+ OwnerUserID: userID,
+ MemberUserIDs: TestTargetUserList,
+ GroupInfo: groupInfo,
+ }
+
+ resp := group.CreateGroupResp{}
+
+ response, err := st.PostRequest(ctx, ApiAddress+CreateGroup, &req)
+ if err != nil {
+ return "", err
+ }
+
+ if err := json.Unmarshal(response, &resp); err != nil {
+ return "", err
+ }
+
+ st.GroupCounter++
+
+ return resp.GroupInfo.GroupID, nil
+}
+
+func main() {
+ var configPath string
+ // defaultConfigDir := filepath.Join("..", "..", "..", "..", "..", "config")
+ // flag.StringVar(&configPath, "c", defaultConfigDir, "config path")
+ flag.StringVar(&configPath, "c", "", "config path")
+ flag.Parse()
+
+ if configPath == "" {
+ _, _ = fmt.Fprintln(os.Stderr, "config path is empty")
+ os.Exit(1)
+ return
+ }
+
+ fmt.Printf(" Config Path: %s\n", configPath)
+
+ share, apiConfig, err := initConfig(configPath)
+ if err != nil {
+ program.ExitWithError(err)
+ return
+ }
+
+ ApiAddress = fmt.Sprintf("http://%s:%s", "127.0.0.1", fmt.Sprint(apiConfig.Api.Ports[0]))
+
+ ctx, cancel := context.WithCancel(context.Background())
+ ch := make(chan struct{})
+
+ defer cancel()
+
+ st := &StressTest{
+ Conf: &conf{
+ Share: *share,
+ Api: *apiConfig,
+ },
+ AdminUserID: share.IMAdminUser.UserIDs[0],
+ Ctx: ctx,
+ Cancel: cancel,
+ HttpClient: &http.Client{
+ Timeout: 50 * time.Second,
+ },
+ }
+
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+ go func() {
+ <-c
+ fmt.Println("\nReceived stop signal, stopping...")
+
+ select {
+ case <-ch:
+ default:
+ close(ch)
+ }
+
+ st.Cancel()
+ }()
+
+ token, err := st.GetAdminToken(st.Ctx)
+ if err != nil {
+ log.ZError(ctx, "Get Admin Token failed.", err, "AdminUserID", st.AdminUserID)
+ }
+
+ st.AdminToken = token
+ fmt.Println("Admin Token:", st.AdminToken)
+ fmt.Println("ApiAddress:", ApiAddress)
+
+ st.DefaultGroupID = DefaultGroupID
+
+ st.Wg.Add(1)
+ go func() {
+ defer st.Wg.Done()
+
+ ticker := time.NewTicker(CreateUserTicker)
+ defer ticker.Stop()
+
+ for st.UserCounter < MaxUser {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Create user", "reason", "context done")
+ return
+
+ case <-ticker.C:
+ // Create User
+ userID := fmt.Sprintf("%d_Stresstest_%s", st.UserCounter, time.Now().Format("0102150405"))
+
+ userCreatedID, err := st.CreateUser(st.Ctx, userID)
+ if err != nil {
+ log.ZError(st.Ctx, "Create User failed.", err, "UserID", userID)
+ os.Exit(1)
+ return
+ }
+ // fmt.Println("User Created ID:", userCreatedID)
+
+ // Import Friend
+ if err = st.ImportFriend(st.Ctx, userCreatedID); err != nil {
+ log.ZError(st.Ctx, "Import Friend failed.", err, "UserID", userCreatedID)
+ os.Exit(1)
+ return
+ }
+ // Invite To Group
+ if err = st.InviteToGroup(st.Ctx, userCreatedID); err != nil {
+ log.ZError(st.Ctx, "Invite To Group failed.", err, "UserID", userCreatedID)
+ os.Exit(1)
+ return
+ }
+
+ st.Once.Do(func() {
+ st.DefaultUserID = userCreatedID
+ fmt.Println("Default Send User Created ID:", userCreatedID)
+ close(ch)
+ })
+ }
+ }
+ }()
+
+ st.Wg.Add(1)
+ go func() {
+ defer st.Wg.Done()
+
+ ticker := time.NewTicker(SendMessageTicker)
+ defer ticker.Stop()
+ <-ch
+
+ for {
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Send message", "reason", "context done")
+ return
+
+ case <-ticker.C:
+ // Send Message
+ if err = st.SendMsg(st.Ctx, st.DefaultUserID); err != nil {
+ log.ZError(st.Ctx, "Send Message failed.", err, "UserID", st.DefaultUserID)
+ continue
+ }
+ }
+ }
+ }()
+
+ st.Wg.Add(1)
+ go func() {
+ defer st.Wg.Done()
+
+ ticker := time.NewTicker(CreateGroupTicker)
+ defer ticker.Stop()
+ <-ch
+
+ for st.GroupCounter < MaxGroup {
+
+ select {
+ case <-st.Ctx.Done():
+ log.ZInfo(st.Ctx, "Stop Create Group", "reason", "context done")
+ return
+
+ case <-ticker.C:
+
+ // Create Group
+ _, err := st.CreateGroup(st.Ctx, st.DefaultUserID)
+ if err != nil {
+ log.ZError(st.Ctx, "Create Group failed.", err, "UserID", st.DefaultUserID)
+ os.Exit(1)
+ return
+ }
+
+ // fmt.Println("Group Created ID:", groupID)
+ }
+ }
+ }()
+
+ st.Wg.Wait()
+}
diff --git a/test/testdata/README.md b/test/testdata/README.md
new file mode 100644
index 0000000..b9dfea6
--- /dev/null
+++ b/test/testdata/README.md
@@ -0,0 +1,64 @@
+
+# Test Data for OpenIM Server
+
+This directory (`testdata`) contains various JSON formatted data files that are used for testing the OpenIM Server.
+
+## Structure
+
+```bash
+testdata/
+│
+├── README.md # 描述该目录下各子目录和文件的作用
+│
+├── storage/ # 存储模拟的数据库数据
+│ ├── users.json # 用户的模拟数据
+│ └── messages.json # 消息的模拟数据
+│
+├── requests/ # 存储模拟的请求数据
+│ ├── login.json # 模拟登陆请求
+│ ├── register.json # 模拟注册请求
+│ └── sendMessage.json # 模拟发送消息请求
+│
+└── responses/ # 存储模拟的响应数据
+ ├── login.json # 模拟登陆响应
+ ├── register.json # 模拟注册响应
+ └── sendMessage.json # 模拟发送消息响应
+```
+
+Here is an overview of what each subdirectory or file represents:
+
+- `db/` - This directory contains mock data mimicking the actual database contents.
+ - `users.json` - Represents a list of users in the system. Each entry contains user-specific information such as user ID, username, password hash, etc.
+ - `messages.json` - Contains a list of messages exchanged between users. Each message entry includes the sender's and receiver's user IDs, message content, timestamp, etc.
+- `requests/` - This directory contains mock requests that a client might send to the server.
+ - `login.json` - Represents a user login request. It includes fields such as username and password.
+ - `register.json` - Mimics a user registration request. Contains details such as username, password, email, etc.
+ - `sendMessage.json` - Simulates a message sending request from a user to another user.
+- `responses/` - This directory holds the expected server responses for the respective requests.
+ - `login.json` - Represents a successful login response from the server. It typically includes a session token and user-specific information.
+ - `register.json` - Simulates a successful registration response from the server, usually containing the new user's ID, username, etc.
+ - `sendMessage.json` - Depicts a successful message sending response from the server, confirming the delivery of the message.
+
+## JSON Format
+
+All the data files in this directory are in JSON format. JSON (JavaScript Object Notation) is a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate.
+
+Here is a simple example of what a JSON file might look like:
+
+```bash
+ "users": [
+ {
+ "id": 1,
+ "username": "user1",
+ "password": "password1"
+ },
+ {
+ "id": 2,
+ "username": "user2",
+ "password": "password2"
+ }
+ ]
+
+```
+
+In this example, "users" is an array of user objects. Each user object has an "id", "username", and "password".
diff --git a/test/testdata/db/messages.json b/test/testdata/db/messages.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/db/users.json b/test/testdata/db/users.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/requests/login.json b/test/testdata/requests/login.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/requests/register.json b/test/testdata/requests/register.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/requests/send-message.json b/test/testdata/requests/send-message.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/responses/login.json b/test/testdata/responses/login.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/responses/register.json b/test/testdata/responses/register.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/testdata/responses/sendMessage.json b/test/testdata/responses/sendMessage.json
new file mode 100644
index 0000000..e69de29
diff --git a/test/webhook/msgmodify/main.go b/test/webhook/msgmodify/main.go
new file mode 100644
index 0000000..c73b6f3
--- /dev/null
+++ b/test/webhook/msgmodify/main.go
@@ -0,0 +1,65 @@
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "strings"
+
+ cbapi "git.imall.cloud/openim/open-im-server-deploy/pkg/callbackstruct"
+ "git.imall.cloud/openim/protocol/constant"
+ "github.com/gin-gonic/gin"
+)
+
+func main() {
+ g := gin.Default()
+ g.POST("/callbackExample/callbackBeforeMsgModifyCommand", toGin(handlerMsg))
+ if err := g.Run(":10006"); err != nil {
+ panic(err)
+ }
+}
+
+func toGin[R any](fn func(c *gin.Context, req *R)) gin.HandlerFunc {
+ return func(c *gin.Context) {
+ body, err := io.ReadAll(c.Request.Body)
+ if err != nil {
+ c.String(http.StatusInternalServerError, err.Error())
+ return
+ }
+ fmt.Printf("HTTP %s %s %s\n", c.Request.Method, c.Request.URL, body)
+ var req R
+ if err := json.Unmarshal(body, &req); err != nil {
+ c.String(http.StatusInternalServerError, err.Error())
+ return
+ }
+ fn(c, &req)
+ }
+}
+
+func handlerMsg(c *gin.Context, req *cbapi.CallbackMsgModifyCommandReq) {
+ var resp cbapi.CallbackMsgModifyCommandResp
+ if req.ContentType != constant.Text {
+ c.JSON(http.StatusOK, &resp)
+ return
+ }
+ var textElem struct {
+ Content string `json:"content"`
+ }
+ if err := json.Unmarshal([]byte(req.Content), &textElem); err != nil {
+ c.String(http.StatusInternalServerError, err.Error())
+ return
+ }
+ const word = "xxx"
+ if strings.Contains(textElem.Content, word) {
+ textElem.Content = strings.ReplaceAll(textElem.Content, word, strings.Repeat("*", len(word)))
+ content, err := json.Marshal(&textElem)
+ if err != nil {
+ c.String(http.StatusInternalServerError, err.Error())
+ return
+ }
+ tmp := string(content)
+ resp.Content = &tmp
+ }
+ c.JSON(http.StatusOK, &resp)
+}
diff --git a/tools/README.md b/tools/README.md
new file mode 100644
index 0000000..bf1e289
--- /dev/null
+++ b/tools/README.md
@@ -0,0 +1,25 @@
+# Notes about go workspace
+
+As openim is using go1.18's [workspace feature](https://go.dev/doc/tutorial/workspaces), once you add a new module, you need to run `go work use -r .` at root directory to update the workspace synced.
+
+### Create a new extensions
+
+1. Create your tools_name directory in pkg `/tools` first and cd into it.
+2. Init the project.
+3. Then `go work use -r .` at current directory to update the workspace.
+4. Create your tools
+
+You can execute the following commands to do things above:
+
+```bash
+# edit the CRD_NAME and CRD_GROUP to your own
+export OPENIM_TOOLS_NAME=
+
+# copy and paste to create a new CRD and Controller
+mkdir tools/${OPENIM_TOOLS_NAME}
+cd tools/${OPENIM_TOOLS_NAME}
+go mod init github.com/openimsdk/open-im-server-deploy/tools/${OPENIM_TOOLS_NAME}
+go mod tidy
+go work use -r .
+cd ../..
+```
\ No newline at end of file
diff --git a/tools/changelog/changelog.go b/tools/changelog/changelog.go
new file mode 100644
index 0000000..c9e2be2
--- /dev/null
+++ b/tools/changelog/changelog.go
@@ -0,0 +1,198 @@
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "regexp"
+ "strings"
+)
+
+// You can specify a tag as a command line argument to generate the changelog for a specific version.
+// Example: go run tools/changelog/changelog.go v0.0.33
+// If no tag is provided, the latest release will be used.
+
+// Setting repo owner and repo name by generate changelog
+const (
+ repoOwner = "openimsdk"
+ repoName = "open-im-server-deploy"
+)
+
+// GitHubRepo struct represents the repo details.
+type GitHubRepo struct {
+ Owner string
+ Repo string
+ FullChangelog string
+}
+
+// ReleaseData represents the JSON structure for release data.
+type ReleaseData struct {
+ TagName string `json:"tag_name"`
+ Body string `json:"body"`
+ HtmlUrl string `json:"html_url"`
+ Published string `json:"published_at"`
+}
+
+// Method to classify and format release notes.
+func (g *GitHubRepo) classifyReleaseNotes(body string) map[string][]string {
+ result := map[string][]string{
+ "feat": {},
+ "fix": {},
+ "chore": {},
+ "refactor": {},
+ "build": {},
+ "other": {},
+ }
+
+ // Regular expression to extract PR number and URL (case insensitive)
+ rePR := regexp.MustCompile(`(?i)in (https://github\.com/[^\s]+/pull/(\d+))`)
+
+ // Split the body into individual lines.
+ lines := strings.Split(body, "\n")
+
+ for _, line := range lines {
+ // Skip lines that contain "deps: Merge"
+ if strings.Contains(strings.ToLower(line), "deps: merge #") {
+ continue
+ }
+
+ // Use a regular expression to extract Full Changelog link and its title (case insensitive).
+ if strings.Contains(strings.ToLower(line), "**full changelog**") {
+ matches := regexp.MustCompile(`(?i)\*\*full changelog\*\*: (https://github\.com/[^\s]+/compare/([^\s]+))`).FindStringSubmatch(line)
+ if len(matches) > 2 {
+ // Format the Full Changelog link with title
+ g.FullChangelog = fmt.Sprintf("[%s](%s)", matches[2], matches[1])
+ }
+ continue // Skip further processing for this line.
+ }
+
+ if strings.HasPrefix(line, "*") {
+ var category string
+
+ // Use strings.ToLower to make the matching case insensitive
+ lowerLine := strings.ToLower(line)
+
+ // Determine the category based on the prefix (case insensitive).
+ if strings.HasPrefix(lowerLine, "* feat") {
+ category = "feat"
+ } else if strings.HasPrefix(lowerLine, "* fix") {
+ category = "fix"
+ } else if strings.HasPrefix(lowerLine, "* chore") {
+ category = "chore"
+ } else if strings.HasPrefix(lowerLine, "* refactor") {
+ category = "refactor"
+ } else if strings.HasPrefix(lowerLine, "* build") {
+ category = "build"
+ } else {
+ category = "other"
+ }
+
+ // Extract PR number and URL (case insensitive)
+ matches := rePR.FindStringSubmatch(line)
+ if len(matches) == 3 {
+ prURL := matches[1]
+ prNumber := matches[2]
+ // Format the line with the PR link and use original content for the final result
+ formattedLine := fmt.Sprintf("* %s [#%s](%s)", strings.Split(line, " by ")[0][2:], prNumber, prURL)
+ result[category] = append(result[category], formattedLine)
+ } else {
+ // If no PR link is found, just add the line as is
+ result[category] = append(result[category], line)
+ }
+ }
+ }
+
+ return result
+}
+
+// Method to generate the final changelog.
+func (g *GitHubRepo) generateChangelog(tag, date, htmlURL, body string) string {
+ sections := g.classifyReleaseNotes(body)
+
+ // Convert ISO 8601 date to simpler format (YYYY-MM-DD)
+ formattedDate := date[:10]
+
+ // Changelog header with tag, date, and links.
+ changelog := fmt.Sprintf("## [%s](%s) \t(%s)\n\n", tag, htmlURL, formattedDate)
+
+ if len(sections["feat"]) > 0 {
+ changelog += "### New Features\n" + strings.Join(sections["feat"], "\n") + "\n\n"
+ }
+ if len(sections["fix"]) > 0 {
+ changelog += "### Bug Fixes\n" + strings.Join(sections["fix"], "\n") + "\n\n"
+ }
+ if len(sections["chore"]) > 0 {
+ changelog += "### Chores\n" + strings.Join(sections["chore"], "\n") + "\n\n"
+ }
+ if len(sections["refactor"]) > 0 {
+ changelog += "### Refactors\n" + strings.Join(sections["refactor"], "\n") + "\n\n"
+ }
+ if len(sections["build"]) > 0 {
+ changelog += "### Builds\n" + strings.Join(sections["build"], "\n") + "\n\n"
+ }
+ if len(sections["other"]) > 0 {
+ changelog += "### Others\n" + strings.Join(sections["other"], "\n") + "\n\n"
+ }
+
+ if g.FullChangelog != "" {
+ changelog += fmt.Sprintf("**Full Changelog**: %s\n", g.FullChangelog)
+ }
+
+ return changelog
+}
+
+// Method to fetch release data from GitHub API.
+func (g *GitHubRepo) fetchReleaseData(version string) (*ReleaseData, error) {
+ var apiURL string
+
+ if version == "" {
+ // Fetch the latest release.
+ apiURL = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", g.Owner, g.Repo)
+ } else {
+ // Fetch a specific version.
+ apiURL = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/tags/%s", g.Owner, g.Repo, version)
+ }
+
+ resp, err := http.Get(apiURL)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ var releaseData ReleaseData
+ err = json.Unmarshal(body, &releaseData)
+ if err != nil {
+ return nil, err
+ }
+
+ return &releaseData, nil
+}
+
+func main() {
+ repo := &GitHubRepo{Owner: repoOwner, Repo: repoName}
+
+ // Get the version from command line arguments, if provided
+ var version string // Default is use latest
+
+ if len(os.Args) > 1 {
+ version = os.Args[1] // Use the provided version
+ }
+
+ // Fetch release data (either for latest or specific version)
+ releaseData, err := repo.fetchReleaseData(version)
+ if err != nil {
+ fmt.Println("Error fetching release data:", err)
+ return
+ }
+
+ // Generate and print the formatted changelog
+ changelog := repo.generateChangelog(releaseData.TagName, releaseData.Published, releaseData.HtmlUrl, releaseData.Body)
+ fmt.Println(changelog)
+}
diff --git a/tools/check-component/main.go b/tools/check-component/main.go
new file mode 100644
index 0000000..e9b5574
--- /dev/null
+++ b/tools/check-component/main.go
@@ -0,0 +1,194 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "path/filepath"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+ "github.com/openimsdk/tools/db/mongoutil"
+ "github.com/openimsdk/tools/db/redisutil"
+ "github.com/openimsdk/tools/discovery/etcd"
+ "github.com/openimsdk/tools/discovery/zookeeper"
+ "github.com/openimsdk/tools/mq/kafka"
+ "github.com/openimsdk/tools/s3/minio"
+ "github.com/openimsdk/tools/system/program"
+)
+
+const maxRetry = 180
+
+const (
+ MountConfigFilePath = "CONFIG_PATH"
+ DeploymentType = "DEPLOYMENT_TYPE"
+ KUBERNETES = "kubernetes"
+)
+
+func CheckZookeeper(ctx context.Context, config *config.ZooKeeper) error {
+ // Temporary disable logging
+ originalLogger := log.Default().Writer()
+ log.SetOutput(io.Discard)
+ defer log.SetOutput(originalLogger) // Ensure logging is restored
+ return zookeeper.Check(ctx, config.Address, config.Schema, zookeeper.WithUserNameAndPassword(config.Username, config.Password))
+}
+
+func CheckEtcd(ctx context.Context, config *config.Etcd) error {
+ return etcd.Check(ctx, config.Address, "/check_openim_component",
+ true,
+ etcd.WithDialTimeout(10*time.Second),
+ etcd.WithMaxCallSendMsgSize(20*1024*1024),
+ etcd.WithUsernameAndPassword(config.Username, config.Password))
+}
+
+func CheckMongo(ctx context.Context, config *config.Mongo) error {
+ return mongoutil.Check(ctx, config.Build())
+}
+
+func CheckRedis(ctx context.Context, config *config.Redis) error {
+ return redisutil.Check(ctx, config.Build())
+}
+
+func CheckMinIO(ctx context.Context, config *config.Minio) error {
+ return minio.Check(ctx, config.Build())
+}
+
+func CheckKafka(ctx context.Context, conf *config.Kafka) error {
+ return kafka.CheckHealth(ctx, conf.Build())
+}
+
+func initConfig(configDir string) (*config.Mongo, *config.Redis, *config.Kafka, *config.Minio, *config.Discovery, error) {
+ var (
+ mongoConfig = &config.Mongo{}
+ redisConfig = &config.Redis{}
+ kafkaConfig = &config.Kafka{}
+ minioConfig = &config.Minio{}
+ discovery = &config.Discovery{}
+ thirdConfig = &config.Third{}
+ )
+
+ err := config.Load(configDir, config.MongodbConfigFileName, config.EnvPrefixMap[config.MongodbConfigFileName], mongoConfig)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+
+ err = config.Load(configDir, config.RedisConfigFileName, config.EnvPrefixMap[config.RedisConfigFileName], redisConfig)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+
+ err = config.Load(configDir, config.KafkaConfigFileName, config.EnvPrefixMap[config.KafkaConfigFileName], kafkaConfig)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+
+ err = config.Load(configDir, config.OpenIMRPCThirdCfgFileName, config.EnvPrefixMap[config.OpenIMRPCThirdCfgFileName], thirdConfig)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+
+ if thirdConfig.Object.Enable == "minio" {
+ err = config.Load(configDir, config.MinioConfigFileName, config.EnvPrefixMap[config.MinioConfigFileName], minioConfig)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+ } else {
+ minioConfig = nil
+ }
+ err = config.Load(configDir, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename], discovery)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+ return mongoConfig, redisConfig, kafkaConfig, minioConfig, discovery, nil
+}
+
+func main() {
+ var index int
+ var configDir string
+ flag.IntVar(&index, "i", 0, "Index number")
+ defaultConfigDir := filepath.Join("..", "..", "..", "..", "..", "config")
+ flag.StringVar(&configDir, "c", defaultConfigDir, "Configuration dir")
+ flag.Parse()
+
+ fmt.Printf("%s Index: %d, Config Path: %s\n", filepath.Base(os.Args[0]), index, configDir)
+
+ mongoConfig, redisConfig, kafkaConfig, minioConfig, zookeeperConfig, err := initConfig(configDir)
+ if err != nil {
+ program.ExitWithError(err)
+ }
+
+ ctx := context.Background()
+ err = performChecks(ctx, mongoConfig, redisConfig, kafkaConfig, minioConfig, zookeeperConfig, maxRetry)
+ if err != nil {
+ // Assume program.ExitWithError logs the error and exits.
+ // Replace with your error handling logic as necessary.
+ program.ExitWithError(err)
+ }
+}
+
+func performChecks(ctx context.Context, mongoConfig *config.Mongo, redisConfig *config.Redis, kafkaConfig *config.Kafka, minioConfig *config.Minio, discovery *config.Discovery, maxRetry int) error {
+ checksDone := make(map[string]bool)
+
+ checks := map[string]func(ctx context.Context) error{
+ "Mongo": func(ctx context.Context) error {
+ return CheckMongo(ctx, mongoConfig)
+ },
+ "Redis": func(ctx context.Context) error {
+ return CheckRedis(ctx, redisConfig)
+ },
+ "Kafka": func(ctx context.Context) error {
+ return CheckKafka(ctx, kafkaConfig)
+ },
+ }
+ if minioConfig != nil {
+ checks["MinIO"] = func(ctx context.Context) error {
+ return CheckMinIO(ctx, minioConfig)
+ }
+ }
+ if discovery.Enable == "etcd" {
+ checks["Etcd"] = func(ctx context.Context) error {
+ return CheckEtcd(ctx, &discovery.Etcd)
+ }
+ }
+
+ for i := 0; i < maxRetry; i++ {
+ allSuccess := true
+ for name, check := range checks {
+ if !checksDone[name] {
+ if err := check(ctx); err != nil {
+ fmt.Printf("%s check failed: %v\n", name, err)
+ allSuccess = false
+ } else {
+ fmt.Printf("%s check succeeded.\n", name)
+ checksDone[name] = true
+ }
+ }
+ }
+
+ if allSuccess {
+ fmt.Println("All components checks passed successfully.")
+ return nil
+ }
+
+ time.Sleep(1 * time.Second)
+ }
+
+ return fmt.Errorf("not all components checks passed successfully after %d attempts", maxRetry)
+}
diff --git a/tools/check-free-memory/main.go b/tools/check-free-memory/main.go
new file mode 100644
index 0000000..e182a15
--- /dev/null
+++ b/tools/check-free-memory/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/shirou/gopsutil/mem"
+)
+
+func main() {
+ vMem, err := mem.VirtualMemory()
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Failed to get virtual memory info: %v\n", err)
+ os.Exit(1)
+ }
+
+ // Use the Available field to get the available memory
+ availableMemoryGB := float64(vMem.Available) / float64(1024*1024*1024)
+
+ if availableMemoryGB < 1.0 {
+ fmt.Fprintf(os.Stderr, "System available memory is less than 1GB: %.2fGB\n", availableMemoryGB)
+ os.Exit(1)
+ } else {
+ fmt.Printf("System available memory is sufficient: %.2fGB\n", availableMemoryGB)
+ }
+}
diff --git a/tools/imctl/.gitignore b/tools/imctl/.gitignore
new file mode 100644
index 0000000..72ff17c
--- /dev/null
+++ b/tools/imctl/.gitignore
@@ -0,0 +1,50 @@
+# Copyright © 2023 OpenIMSDK.
+#
+# Licensed 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
+#
+# http://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.
+
+# ==============================================================================
+# For the entire design of.gitignore, ignore git commits and ignore files
+#===============================================================================
+#
+
+### OpenIM developer supplement ###
+logs
+.devcontainer
+components
+out-test
+Dockerfile.cross
+
+### Makefile ###
+tmp/
+bin/
+output/
+_output/
+
+### OpenIM Config ###
+config/config.yaml
+./config/config.yaml
+.env
+./.env
+
+# files used by the developer
+.idea.md
+.todo.md
+.note.md
+
+# ==============================================================================
+# Created by https://www.toptal.com/developers/gitignore/api/go,git,vim,tags,test,emacs,backup,jetbrains
+# Edit at https://www.toptal.com/developers/gitignore?templates=go,git,vim,tags,test,emacs,backup,jetbrains
+
+cmd/
+internal/
+pkg/
diff --git a/tools/imctl/README.md b/tools/imctl/README.md
new file mode 100644
index 0000000..4f4ff4a
--- /dev/null
+++ b/tools/imctl/README.md
@@ -0,0 +1,89 @@
+# [RFC #0005] OpenIM CTL Module Proposal
+
+## Meta
+
+- Name: OpenIM CTL Module Enhancement
+- Start Date: 2023-08-23
+- Author(s): @cubxxw
+- Status: Draft
+- RFC Pull Request: (leave blank)
+- OpenIMSDK Pull Request: (leave blank)
+- OpenIMSDK Issue: https://github.com/openimsdk/open-im-server-deploy/issues/924
+- Supersedes: N/A
+
+## 📇Topics
+
+- RFC #0000 OpenIMSDK CTL Module Proposal
+ - [Meta](#meta)
+ - [Summary](#summary)
+ - [Definitions](#definitions)
+ - [Motivation](#motivation)
+ - [What it is](#what-it-is)
+ - [How it Works](#how-it-works)
+ - [Migration](#migration)
+ - [Drawbacks](#drawbacks)
+ - [Alternatives](#alternatives)
+ - [Prior Art](#prior-art)
+ - [Unresolved Questions](#unresolved-questions)
+ - [Spec. Changes (OPTIONAL)](#spec-changes-optional)
+ - [History](#history)
+
+## Summary
+
+The OpenIM CTL module proposal aims to provide an integrated tool for the OpenIM system, offering utilities for user management, system monitoring, debugging, configuration, and more. This tool will enhance the extensibility of the OpenIM system and reduce dependencies on individual modules.
+
+## Definitions
+
+- **OpenIM**: An Instant Messaging system.
+- **`imctl`**: The control command-line tool for OpenIM.
+- **E2E Testing**: End-to-End Testing.
+- **API**: Application Programming Interface.
+
+## Motivation
+
+- Improve the OpenIM system's extensibility and reduce dependencies on individual modules.
+- Simplify the process for testers to perform automated tests.
+- Enhance interaction with scripts and reduce the system's coupling.
+- Implement a consistent tool similar to kubectl for a streamlined user experience.
+
+## What it is
+
+`imctl` is a command-line utility designed for OpenIM to provide functionalities including:
+
+- User Management: Add, delete, or disable user accounts.
+- System Monitoring: View metrics like online users, message transfer rate.
+- Debugging: View logs, adjust log levels, check system states.
+- Configuration Management: Update system settings, manage plugins/modules.
+- Data Management: Backup, restore, import, or export data.
+- System Maintenance: Update, restart services, or maintenance mode.
+
+## How it Works
+
+`imctl`, inspired by kubectl, will have sub-commands and options for the functionalities mentioned. Developers, operations, and testers can invoke these commands to manage and monitor the OpenIM system.
+
+## Migration
+
+Currently, the `imctl` will be housed in `tools/imctl`, and later on, the plan is to move it to `cmd/imctl`. Migration guidelines will be provided to ensure smooth transitions.
+
+## Drawbacks
+
+- Overhead in learning and adapting to a new tool for existing users.
+- Potential complexities in implementing some of the advanced functionalities.
+
+## Alternatives
+
+- Continue using individual modules for OpenIM management.
+- Utilize third-party tools or platforms with similar functionalities, customizing them for OpenIM.
+
+## Prior Art
+
+Kubectl from Kubernetes is a significant inspiration for `imctl`, offering a comprehensive command-line tool for managing clusters.
+
+## Unresolved Questions
+
+- What other functionalities might be required in future versions of `imctl`?
+- What's the expected timeline for transitioning from `tools/imctl` to `cmd/imctl`?
+
+## Spec. Changes (OPTIONAL)
+
+As of now, there are no proposed changes to the core specifications or extensions. Future changes based on community feedback might necessitate spec changes, which will be documented accordingly.
\ No newline at end of file
diff --git a/tools/imctl/main.go b/tools/imctl/main.go
new file mode 100644
index 0000000..9116132
--- /dev/null
+++ b/tools/imctl/main.go
@@ -0,0 +1,22 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import "fmt"
+
+func main() {
+
+ fmt.Println("imctl")
+}
diff --git a/tools/infra/main.go b/tools/infra/main.go
new file mode 100644
index 0000000..f6225a3
--- /dev/null
+++ b/tools/infra/main.go
@@ -0,0 +1,52 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "fmt"
+
+ "github.com/fatih/color"
+)
+
+// Define a function to print important link information
+func printLinks() {
+ blue := color.New(color.FgBlue).SprintFunc()
+ fmt.Printf("OpenIM Github: %s\n", blue("https://github.com/OpenIMSDK/Open-IM-Server"))
+ fmt.Printf("Slack Invitation: %s\n", blue("https://openimsdk.slack.com"))
+ fmt.Printf("Follow Twitter: %s\n", blue("https://twitter.com/founder_im63606"))
+}
+
+func main() {
+ yellow := color.New(color.FgYellow)
+ blue := color.New(color.FgBlue, color.Bold)
+
+ yellow.Println("Please use the release branch or tag for production environments!")
+
+ message := `
+____ _____ __ __
+/ __ \ |_ _|| \/ |
+| | | | _ __ ___ _ __ | | | \ / |
+| | | || '_ \ / _ \| '_ \ | | | |\/| |
+| |__| || |_) || __/| | | | _| |_ | | | |
+\____/ | .__/ \___||_| |_||_____||_| |_|
+ | |
+ |_|
+
+Keep checking for updates!
+`
+
+ blue.Println(message)
+ printLinks() // Call the function to print the link information
+}
diff --git a/tools/ncpu/README.md b/tools/ncpu/README.md
new file mode 100644
index 0000000..f7c05d5
--- /dev/null
+++ b/tools/ncpu/README.md
@@ -0,0 +1,39 @@
+# ncpu
+
+**ncpu** is a simple utility to fetch the number of CPU cores across different operating systems.
+
+## Introduction
+
+In various scenarios, especially while compiling code, it's beneficial to know the number of available CPU cores to optimize the build process. However, the command to fetch the CPU core count differs between operating systems. For example, on Linux, we use `nproc`, while on macOS, it's `sysctl -n hw.ncpu`. The `ncpu` utility provides a unified way to obtain this number, regardless of the platform.
+
+## Usage
+
+To retrieve the number of CPU cores, simply use the `ncpu` command:
+
+```bash
+$ ncpu
+```
+
+This will return an integer representing the number of available CPU cores.
+
+### Example:
+
+Let's say you're compiling a project using `make`. To utilize all the CPU cores for the compilation process, you can use:
+
+```bash
+$ make -j $(ncpu) build # or any other build command
+```
+
+The above command will ensure the build process takes advantage of all the available CPU cores, thereby potentially speeding up the compilation.
+
+## Why use `ncpu`?
+
+- **Cross-platform compatibility**: No need to remember or detect which OS-specific command to use. Just use `ncpu`!
+
+- **Ease of use**: A simple and intuitive command that's easy to incorporate into scripts or command-line operations.
+
+- **Consistency**: Ensures consistent behavior and output across different systems and environments.
+
+## Installation
+
+(Include installation steps here, e.g., how to clone the repo, build the tool, or install via package manager.)
diff --git a/tools/ncpu/main.go b/tools/ncpu/main.go
new file mode 100644
index 0000000..062618b
--- /dev/null
+++ b/tools/ncpu/main.go
@@ -0,0 +1,32 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "fmt"
+ "runtime"
+
+ "go.uber.org/automaxprocs/maxprocs"
+)
+
+func main() {
+ // Set maxprocs with a custom logger that does nothing to ignore logs.
+ maxprocs.Set(maxprocs.Logger(func(string, ...interface{}) {
+ // Intentionally left blank to suppress all log output from automaxprocs.
+ }))
+
+ // Now this will print the GOMAXPROCS value without printing the automaxprocs log message.
+ fmt.Println(runtime.GOMAXPROCS(0))
+}
diff --git a/tools/ncpu/main_test.go b/tools/ncpu/main_test.go
new file mode 100644
index 0000000..f242032
--- /dev/null
+++ b/tools/ncpu/main_test.go
@@ -0,0 +1,35 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import "testing"
+
+func Test_main(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "Test_main",
+ },
+ {
+ name: "Test_main2",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ main()
+ })
+ }
+}
diff --git a/tools/s3/README.md b/tools/s3/README.md
new file mode 100644
index 0000000..ac30347
--- /dev/null
+++ b/tools/s3/README.md
@@ -0,0 +1,12 @@
+# After s3 switches the storage engine, convert the data
+
+- build
+```shell
+go build -o s3convert main.go
+```
+
+- start
+```shell
+./s3convert -config -name
+# ./s3convert -config ./../../config -name minio
+```
diff --git a/tools/s3/internal/conversion.go b/tools/s3/internal/conversion.go
new file mode 100644
index 0000000..318cc24
--- /dev/null
+++ b/tools/s3/internal/conversion.go
@@ -0,0 +1,203 @@
+package internal
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "log"
+ "net/http"
+ "path/filepath"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache/redis"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database/mgo"
+ "github.com/mitchellh/mapstructure"
+ "github.com/openimsdk/tools/db/mongoutil"
+ "github.com/openimsdk/tools/db/redisutil"
+ "github.com/openimsdk/tools/s3"
+ "github.com/openimsdk/tools/s3/aws"
+ "github.com/openimsdk/tools/s3/cos"
+ "github.com/openimsdk/tools/s3/kodo"
+ "github.com/openimsdk/tools/s3/minio"
+ "github.com/openimsdk/tools/s3/oss"
+ "github.com/spf13/viper"
+ "go.mongodb.org/mongo-driver/mongo"
+)
+
+const defaultTimeout = time.Second * 10
+
+func readConf(path string, val any) error {
+ v := viper.New()
+ v.SetConfigFile(path)
+ if err := v.ReadInConfig(); err != nil {
+ return err
+ }
+ fn := func(config *mapstructure.DecoderConfig) {
+ config.TagName = "mapstructure"
+ }
+ return v.Unmarshal(val, fn)
+}
+
+func getS3(path string, name string, thirdConf *config.Third) (s3.Interface, error) {
+ switch name {
+ case "minio":
+ ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
+ defer cancel()
+ var minioConf config.Minio
+ if err := readConf(filepath.Join(path, minioConf.GetConfigFileName()), &minioConf); err != nil {
+ return nil, err
+ }
+ var redisConf config.Redis
+ if err := readConf(filepath.Join(path, redisConf.GetConfigFileName()), &redisConf); err != nil {
+ return nil, err
+ }
+ rdb, err := redisutil.NewRedisClient(ctx, redisConf.Build())
+ if err != nil {
+ return nil, err
+ }
+ return minio.NewMinio(ctx, redis.NewMinioCache(rdb), *minioConf.Build())
+ case "cos":
+ return cos.NewCos(*thirdConf.Object.Cos.Build())
+ case "oss":
+ return oss.NewOSS(*thirdConf.Object.Oss.Build())
+ case "kodo":
+ return kodo.NewKodo(*thirdConf.Object.Kodo.Build())
+ case "aws":
+ return aws.NewAws(*thirdConf.Object.Aws.Build())
+ default:
+ return nil, fmt.Errorf("invalid object enable: %s", name)
+ }
+}
+
+func getMongo(path string) (database.ObjectInfo, error) {
+ var mongoConf config.Mongo
+ if err := readConf(filepath.Join(path, mongoConf.GetConfigFileName()), &mongoConf); err != nil {
+ return nil, err
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
+ defer cancel()
+ mgocli, err := mongoutil.NewMongoDB(ctx, mongoConf.Build())
+ if err != nil {
+ return nil, err
+ }
+ return mgo.NewS3Mongo(mgocli.GetDB())
+}
+
+func Main(path string, engine string) error {
+ var thirdConf config.Third
+ if err := readConf(filepath.Join(path, thirdConf.GetConfigFileName()), &thirdConf); err != nil {
+ return err
+ }
+ if thirdConf.Object.Enable == engine {
+ return errors.New("same s3 storage")
+ }
+ s3db, err := getMongo(path)
+ if err != nil {
+ return err
+ }
+ oldS3, err := getS3(path, engine, &thirdConf)
+ if err != nil {
+ return err
+ }
+ newS3, err := getS3(path, thirdConf.Object.Enable, &thirdConf)
+ if err != nil {
+ return err
+ }
+ count, err := getEngineCount(s3db, oldS3.Engine())
+ if err != nil {
+ return err
+ }
+ log.Printf("engine %s count: %d", oldS3.Engine(), count)
+ var skip int
+ for i := 1; i <= count+1; i++ {
+ log.Printf("start %d/%d", i, count)
+ start := time.Now()
+ res, err := doObject(s3db, newS3, oldS3, skip)
+ if err != nil {
+ log.Printf("end [%s] %d/%d error %s", time.Since(start), i, count, err)
+ return err
+ }
+ log.Printf("end [%s] %d/%d result %+v", time.Since(start), i, count, *res)
+ if res.Skip {
+ skip++
+ }
+ if res.End {
+ break
+ }
+ }
+ return nil
+}
+
+func getEngineCount(db database.ObjectInfo, name string) (int, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
+ defer cancel()
+ count, err := db.GetEngineCount(ctx, name)
+ if err != nil {
+ return 0, err
+ }
+ return int(count), nil
+}
+
+func doObject(db database.ObjectInfo, newS3, oldS3 s3.Interface, skip int) (*Result, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
+ defer cancel()
+ infos, err := db.GetEngineInfo(ctx, oldS3.Engine(), 1, skip)
+ if err != nil {
+ return nil, err
+ }
+ if len(infos) == 0 {
+ return &Result{End: true}, nil
+ }
+ obj := infos[0]
+ if _, err := db.Take(ctx, newS3.Engine(), obj.Name); err == nil {
+ return &Result{Skip: true}, nil
+ } else if !errors.Is(err, mongo.ErrNoDocuments) {
+ return nil, err
+ }
+ downloadURL, err := oldS3.AccessURL(ctx, obj.Key, time.Hour, &s3.AccessURLOption{})
+ if err != nil {
+ return nil, err
+ }
+ putURL, err := newS3.PresignedPutObject(ctx, obj.Key, time.Hour, &s3.PutOption{ContentType: obj.ContentType})
+ if err != nil {
+ return nil, err
+ }
+ downloadResp, err := http.Get(downloadURL)
+ if err != nil {
+ return nil, err
+ }
+ defer downloadResp.Body.Close()
+ switch downloadResp.StatusCode {
+ case http.StatusNotFound:
+ return &Result{Skip: true}, nil
+ case http.StatusOK:
+ default:
+ return nil, fmt.Errorf("download object failed %s", downloadResp.Status)
+ }
+ log.Printf("file size %d", obj.Size)
+ request, err := http.NewRequest(http.MethodPut, putURL.URL, downloadResp.Body)
+ if err != nil {
+ return nil, err
+ }
+ putResp, err := http.DefaultClient.Do(request)
+ if err != nil {
+ return nil, err
+ }
+ defer putResp.Body.Close()
+ if putResp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("put object failed %s", putResp.Status)
+ }
+ ctx, cancel = context.WithTimeout(context.Background(), defaultTimeout)
+ defer cancel()
+ if err := db.UpdateEngine(ctx, obj.Engine, obj.Name, newS3.Engine()); err != nil {
+ return nil, err
+ }
+ return &Result{}, nil
+}
+
+type Result struct {
+ Skip bool
+ End bool
+}
diff --git a/tools/s3/main.go b/tools/s3/main.go
new file mode 100644
index 0000000..5f54795
--- /dev/null
+++ b/tools/s3/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "os"
+
+ "git.imall.cloud/openim/open-im-server-deploy/tools/s3/internal"
+)
+
+func main() {
+ var (
+ name string
+ config string
+ )
+ flag.StringVar(&name, "name", "", "old previous storage name")
+ flag.StringVar(&config, "config", "", "config directory")
+ flag.Parse()
+ if err := internal.Main(config, name); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+ fmt.Fprintln(os.Stdout, "success")
+}
diff --git a/tools/seq/internal/seq.go b/tools/seq/internal/seq.go
new file mode 100644
index 0000000..aeaec86
--- /dev/null
+++ b/tools/seq/internal/seq.go
@@ -0,0 +1,347 @@
+package internal
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "os"
+ "os/signal"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+ "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database/mgo"
+ "github.com/mitchellh/mapstructure"
+ "github.com/openimsdk/tools/db/mongoutil"
+ "github.com/openimsdk/tools/db/redisutil"
+ "github.com/openimsdk/tools/utils/runtimeenv"
+ "github.com/redis/go-redis/v9"
+ "github.com/spf13/viper"
+ "go.mongodb.org/mongo-driver/bson"
+ "go.mongodb.org/mongo-driver/mongo"
+ "go.mongodb.org/mongo-driver/mongo/options"
+)
+
+const StructTagName = "yaml"
+
+const (
+ MaxSeq = "MAX_SEQ:"
+ MinSeq = "MIN_SEQ:"
+ ConversationUserMinSeq = "CON_USER_MIN_SEQ:"
+ HasReadSeq = "HAS_READ_SEQ:"
+)
+
+const (
+ batchSize = 100
+ dataVersionCollection = "data_version"
+ seqKey = "seq"
+ seqVersion = 38
+)
+
+func readConfig[T any](dir string, name string) (*T, error) {
+ if runtimeenv.RuntimeEnvironment() == config.KUBERNETES {
+ dir = os.Getenv(config.MountConfigFilePath)
+ }
+ v := viper.New()
+ v.SetEnvPrefix(config.EnvPrefixMap[name])
+ v.AutomaticEnv()
+ v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+ v.SetConfigFile(filepath.Join(dir, name))
+ if err := v.ReadInConfig(); err != nil {
+ return nil, err
+ }
+
+ var conf T
+ if err := v.Unmarshal(&conf, func(config *mapstructure.DecoderConfig) {
+ config.TagName = StructTagName
+ }); err != nil {
+ return nil, err
+ }
+
+ return &conf, nil
+}
+
+func Main(conf string, del time.Duration) error {
+ redisConfig, err := readConfig[config.Redis](conf, config.RedisConfigFileName)
+ if err != nil {
+ return err
+ }
+
+ mongodbConfig, err := readConfig[config.Mongo](conf, config.MongodbConfigFileName)
+ if err != nil {
+ return err
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+ defer cancel()
+ rdb, err := redisutil.NewRedisClient(ctx, redisConfig.Build())
+ if err != nil {
+ return err
+ }
+ mgocli, err := mongoutil.NewMongoDB(ctx, mongodbConfig.Build())
+ if err != nil {
+ return err
+ }
+ versionColl := mgocli.GetDB().Collection(dataVersionCollection)
+ converted, err := CheckVersion(versionColl, seqKey, seqVersion)
+ if err != nil {
+ return err
+ }
+ if converted {
+ fmt.Println("[seq] seq data has been converted")
+ return nil
+ }
+ if _, err := mgo.NewSeqConversationMongo(mgocli.GetDB()); err != nil {
+ return err
+ }
+ cSeq, err := mgo.NewSeqConversationMongo(mgocli.GetDB())
+ if err != nil {
+ return err
+ }
+ uSeq, err := mgo.NewSeqUserMongo(mgocli.GetDB())
+ if err != nil {
+ return err
+ }
+ uSpitHasReadSeq := func(id string) (conversationID string, userID string, err error) {
+ // HasReadSeq + userID + ":" + conversationID
+ arr := strings.Split(id, ":")
+ if len(arr) != 2 || arr[0] == "" || arr[1] == "" {
+ return "", "", fmt.Errorf("invalid has read seq id %s", id)
+ }
+ userID = arr[0]
+ conversationID = arr[1]
+ return
+ }
+ uSpitConversationUserMinSeq := func(id string) (conversationID string, userID string, err error) {
+ // ConversationUserMinSeq + conversationID + "u:" + userID
+ arr := strings.Split(id, "u:")
+ if len(arr) != 2 || arr[0] == "" || arr[1] == "" {
+ return "", "", fmt.Errorf("invalid has read seq id %s", id)
+ }
+ conversationID = arr[0]
+ userID = arr[1]
+ return
+ }
+
+ ts := []*taskSeq{
+ {
+ Prefix: MaxSeq,
+ GetSeq: cSeq.GetMaxSeq,
+ SetSeq: cSeq.SetMaxSeq,
+ },
+ {
+ Prefix: MinSeq,
+ GetSeq: cSeq.GetMinSeq,
+ SetSeq: cSeq.SetMinSeq,
+ },
+ {
+ Prefix: HasReadSeq,
+ GetSeq: func(ctx context.Context, id string) (int64, error) {
+ conversationID, userID, err := uSpitHasReadSeq(id)
+ if err != nil {
+ return 0, err
+ }
+ return uSeq.GetUserReadSeq(ctx, conversationID, userID)
+ },
+ SetSeq: func(ctx context.Context, id string, seq int64) error {
+ conversationID, userID, err := uSpitHasReadSeq(id)
+ if err != nil {
+ return err
+ }
+ return uSeq.SetUserReadSeq(ctx, conversationID, userID, seq)
+ },
+ },
+ {
+ Prefix: ConversationUserMinSeq,
+ GetSeq: func(ctx context.Context, id string) (int64, error) {
+ conversationID, userID, err := uSpitConversationUserMinSeq(id)
+ if err != nil {
+ return 0, err
+ }
+ return uSeq.GetUserMinSeq(ctx, conversationID, userID)
+ },
+ SetSeq: func(ctx context.Context, id string, seq int64) error {
+ conversationID, userID, err := uSpitConversationUserMinSeq(id)
+ if err != nil {
+ return err
+ }
+ return uSeq.SetUserMinSeq(ctx, conversationID, userID, seq)
+ },
+ },
+ }
+
+ cancel()
+ ctx = context.Background()
+
+ var wg sync.WaitGroup
+ wg.Add(len(ts))
+
+ for i := range ts {
+ go func(task *taskSeq) {
+ defer wg.Done()
+ err := seqRedisToMongo(ctx, rdb, task.GetSeq, task.SetSeq, task.Prefix, del, &task.Count)
+ task.End = time.Now()
+ task.Error = err
+ }(ts[i])
+ }
+ start := time.Now()
+ done := make(chan struct{})
+ go func() {
+ wg.Wait()
+ close(done)
+ }()
+
+ sigs := make(chan os.Signal, 1)
+ signal.Notify(sigs, syscall.SIGTERM)
+
+ ticker := time.NewTicker(time.Second)
+ defer ticker.Stop()
+ var buf bytes.Buffer
+
+ printTaskInfo := func(now time.Time) {
+ buf.Reset()
+ buf.WriteString(now.Format(time.DateTime))
+ buf.WriteString(" \n")
+ for i := range ts {
+ task := ts[i]
+ if task.Error == nil {
+ if task.End.IsZero() {
+ buf.WriteString(fmt.Sprintf("[%s] converting %s* count %d", now.Sub(start), task.Prefix, atomic.LoadInt64(&task.Count)))
+ } else {
+ buf.WriteString(fmt.Sprintf("[%s] success %s* count %d", task.End.Sub(start), task.Prefix, atomic.LoadInt64(&task.Count)))
+ }
+ } else {
+ buf.WriteString(fmt.Sprintf("[%s] failed %s* count %d error %s", task.End.Sub(start), task.Prefix, atomic.LoadInt64(&task.Count), task.Error))
+ }
+ buf.WriteString("\n")
+ }
+ fmt.Println(buf.String())
+ }
+
+ for {
+ select {
+ case <-ctx.Done():
+ return ctx.Err()
+ case s := <-sigs:
+ return fmt.Errorf("exit by signal %s", s)
+ case <-done:
+ errs := make([]error, 0, len(ts))
+ for i := range ts {
+ task := ts[i]
+ if task.Error != nil {
+ errs = append(errs, fmt.Errorf("seq %s failed %w", task.Prefix, task.Error))
+ }
+ }
+ if len(errs) > 0 {
+ return errors.Join(errs...)
+ }
+ printTaskInfo(time.Now())
+ if err := SetVersion(versionColl, seqKey, seqVersion); err != nil {
+ return fmt.Errorf("set mongodb seq version %w", err)
+ }
+ return nil
+ case now := <-ticker.C:
+ printTaskInfo(now)
+ }
+ }
+}
+
+type taskSeq struct {
+ Prefix string
+ Count int64
+ Error error
+ End time.Time
+ GetSeq func(ctx context.Context, id string) (int64, error)
+ SetSeq func(ctx context.Context, id string, seq int64) error
+}
+
+func seqRedisToMongo(ctx context.Context, rdb redis.UniversalClient, getSeq func(ctx context.Context, id string) (int64, error), setSeq func(ctx context.Context, id string, seq int64) error, prefix string, delAfter time.Duration, count *int64) error {
+ var (
+ cursor uint64
+ keys []string
+ err error
+ )
+ for {
+ keys, cursor, err = rdb.Scan(ctx, cursor, prefix+"*", batchSize).Result()
+ if err != nil {
+ return err
+ }
+ if len(keys) > 0 {
+ for _, key := range keys {
+ seqStr, err := rdb.Get(ctx, key).Result()
+ if err != nil {
+ return fmt.Errorf("redis get %s failed %w", key, err)
+ }
+ seq, err := strconv.Atoi(seqStr)
+ if err != nil {
+ return fmt.Errorf("invalid %s seq %s", key, seqStr)
+ }
+ if seq < 0 {
+ return fmt.Errorf("invalid %s seq %s", key, seqStr)
+ }
+ id := strings.TrimPrefix(key, prefix)
+ redisSeq := int64(seq)
+ mongoSeq, err := getSeq(ctx, id)
+ if err != nil {
+ return fmt.Errorf("get mongo seq %s failed %w", key, err)
+ }
+ if mongoSeq < redisSeq {
+ if err := setSeq(ctx, id, redisSeq); err != nil {
+ return fmt.Errorf("set mongo seq %s failed %w", key, err)
+ }
+ }
+ if delAfter > 0 {
+ if err := rdb.Expire(ctx, key, delAfter).Err(); err != nil {
+ return fmt.Errorf("redis expire key %s failed %w", key, err)
+ }
+ } else {
+ if err := rdb.Del(ctx, key).Err(); err != nil {
+ return fmt.Errorf("redis del key %s failed %w", key, err)
+ }
+ }
+ atomic.AddInt64(count, 1)
+ }
+ }
+ if cursor == 0 {
+ return nil
+ }
+ }
+}
+
+func CheckVersion(coll *mongo.Collection, key string, currentVersion int) (converted bool, err error) {
+ type VersionTable struct {
+ Key string `bson:"key"`
+ Value string `bson:"value"`
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+ defer cancel()
+ res, err := mongoutil.FindOne[VersionTable](ctx, coll, bson.M{"key": key})
+ if err == nil {
+ ver, err := strconv.Atoi(res.Value)
+ if err != nil {
+ return false, fmt.Errorf("version %s parse error %w", res.Value, err)
+ }
+ if ver >= currentVersion {
+ return true, nil
+ }
+ return false, nil
+ } else if errors.Is(err, mongo.ErrNoDocuments) {
+ return false, nil
+ } else {
+ return false, err
+ }
+}
+
+func SetVersion(coll *mongo.Collection, key string, version int) error {
+ ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+ defer cancel()
+ option := options.Update().SetUpsert(true)
+ filter := bson.M{"key": key}
+ update := bson.M{"$set": bson.M{"key": key, "value": strconv.Itoa(version)}}
+ return mongoutil.UpdateOne(ctx, coll, filter, update, false, option)
+}
diff --git a/tools/seq/main.go b/tools/seq/main.go
new file mode 100644
index 0000000..bdff249
--- /dev/null
+++ b/tools/seq/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/tools/seq/internal"
+)
+
+func main() {
+ var (
+ config string
+ second int
+ )
+ flag.StringVar(&config, "c", "", "config directory")
+ flag.IntVar(&second, "sec", 3600*24, "delayed deletion of the original seq key after conversion")
+ flag.Parse()
+ if err := internal.Main(config, time.Duration(second)*time.Second); err != nil {
+ fmt.Println("seq task", err)
+ os.Exit(1)
+ return
+ }
+ fmt.Println("seq task success!")
+}
diff --git a/tools/url2im/main.go b/tools/url2im/main.go
new file mode 100644
index 0000000..1631738
--- /dev/null
+++ b/tools/url2im/main.go
@@ -0,0 +1,119 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "flag"
+ "log"
+ "os"
+ "path/filepath"
+ "time"
+
+ "git.imall.cloud/openim/open-im-server-deploy/tools/url2im/pkg"
+)
+
+/*take.txt
+{"url":"http://xxx/xxxx","name":"xxxx","contentType":"image/jpeg"}
+{"url":"http://xxx/xxxx","name":"xxxx","contentType":"image/jpeg"}
+{"url":"http://xxx/xxxx","name":"xxxx","contentType":"image/jpeg"}
+*/
+
+func main() {
+ var conf pkg.Config // Configuration object, '*' denotes required fields
+
+ // *Required*: Path for the task log file
+ flag.StringVar(&conf.TaskPath, "task", "take.txt", "Path for the task log file")
+
+ // Optional: Path for the progress log file
+ flag.StringVar(&conf.ProgressPath, "progress", "", "Path for the progress log file")
+
+ // Number of concurrent operations
+ flag.IntVar(&conf.Concurrency, "concurrency", 1, "Number of concurrent operations")
+
+ // Number of retry attempts
+ flag.IntVar(&conf.Retry, "retry", 1, "Number of retry attempts")
+
+ // Optional: Path for the temporary directory
+ flag.StringVar(&conf.TempDir, "temp", "", "Path for the temporary directory")
+
+ // Cache size in bytes (downloads move to disk when exceeded)
+ flag.Int64Var(&conf.CacheSize, "cache", 1024*1024*100, "Cache size in bytes")
+
+ // Request timeout in milliseconds
+ flag.Int64Var((*int64)(&conf.Timeout), "timeout", 5000, "Request timeout in milliseconds")
+
+ // *Required*: API endpoint for the IM service
+ flag.StringVar(&conf.Api, "api", "http://127.0.0.1:10002", "API endpoint for the IM service")
+
+ // IM administrator's user ID
+ flag.StringVar(&conf.UserID, "userID", "openIM123456", "IM administrator's user ID")
+
+ // Secret for the IM configuration
+ flag.StringVar(&conf.Secret, "secret", "openIM123", "Secret for the IM configuration")
+
+ flag.Parse()
+ if !filepath.IsAbs(conf.TaskPath) {
+ var err error
+ conf.TaskPath, err = filepath.Abs(conf.TaskPath)
+ if err != nil {
+ log.Println("get abs path err:", err)
+ return
+ }
+ }
+ if conf.ProgressPath == "" {
+ conf.ProgressPath = conf.TaskPath + ".progress.txt"
+ } else if !filepath.IsAbs(conf.ProgressPath) {
+ var err error
+ conf.ProgressPath, err = filepath.Abs(conf.ProgressPath)
+ if err != nil {
+ log.Println("get abs path err:", err)
+ return
+ }
+ }
+ if conf.TempDir == "" {
+ conf.TempDir = conf.TaskPath + ".temp"
+ }
+ if info, err := os.Stat(conf.TempDir); err == nil {
+ if !info.IsDir() {
+ log.Printf("temp dir %s is not dir\n", err)
+ return
+ }
+ } else if os.IsNotExist(err) {
+ if err := os.MkdirAll(conf.TempDir, os.ModePerm); err != nil {
+ log.Printf("mkdir temp dir %s err %+v\n", conf.TempDir, err)
+ return
+ }
+ defer os.RemoveAll(conf.TempDir)
+ } else {
+ log.Println("get temp dir err:", err)
+ return
+ }
+ if conf.Concurrency <= 0 {
+ conf.Concurrency = 1
+ }
+ if conf.Retry <= 0 {
+ conf.Retry = 1
+ }
+ if conf.CacheSize <= 0 {
+ conf.CacheSize = 1024 * 1024 * 100 // 100M
+ }
+ if conf.Timeout <= 0 {
+ conf.Timeout = 5000
+ }
+ conf.Timeout = conf.Timeout * time.Millisecond
+ if err := pkg.Run(conf); err != nil {
+ log.Println("main err:", err)
+ }
+}
diff --git a/tools/url2im/pkg/api.go b/tools/url2im/pkg/api.go
new file mode 100644
index 0000000..25eb76c
--- /dev/null
+++ b/tools/url2im/pkg/api.go
@@ -0,0 +1,124 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+
+ "git.imall.cloud/openim/protocol/auth"
+ "git.imall.cloud/openim/protocol/third"
+ "github.com/openimsdk/tools/errs"
+)
+
+type Api struct {
+ Api string
+ UserID string
+ Secret string
+ Token string
+ Client *http.Client
+}
+
+func (a *Api) apiPost(ctx context.Context, path string, req any, resp any) error {
+ operationID, _ := ctx.Value("operationID").(string)
+ if operationID == "" {
+ return errs.New("call api operationID is empty")
+ }
+ reqBody, err := json.Marshal(req)
+ if err != nil {
+ return err
+ }
+ request, err := http.NewRequestWithContext(ctx, http.MethodPost, a.Api+path, bytes.NewReader(reqBody))
+ if err != nil {
+ return err
+ }
+ DefaultRequestHeader(request.Header)
+ request.ContentLength = int64(len(reqBody))
+ request.Header.Set("Content-Type", "application/json")
+ request.Header.Set("operationID", operationID)
+ if a.Token != "" {
+ request.Header.Set("token", a.Token)
+ }
+ response, err := a.Client.Do(request)
+ if err != nil {
+ return err
+ }
+ defer response.Body.Close()
+ body, err := io.ReadAll(response.Body)
+ if err != nil {
+ return err
+ }
+ if response.StatusCode != http.StatusOK {
+ return fmt.Errorf("api %s status %s body %s", path, response.Status, body)
+ }
+ var baseResponse struct {
+ ErrCode int `json:"errCode"`
+ ErrMsg string `json:"errMsg"`
+ ErrDlt string `json:"errDlt"`
+ Data json.RawMessage `json:"data"`
+ }
+ if err := json.Unmarshal(body, &baseResponse); err != nil {
+ return err
+ }
+ if baseResponse.ErrCode != 0 {
+ return fmt.Errorf("api %s errCode %d errMsg %s errDlt %s", path, baseResponse.ErrCode, baseResponse.ErrMsg, baseResponse.ErrDlt)
+ }
+ if resp != nil {
+ if err := json.Unmarshal(baseResponse.Data, resp); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (a *Api) GetAdminToken(ctx context.Context) (string, error) {
+ req := auth.GetAdminTokenReq{
+ UserID: a.UserID,
+ Secret: a.Secret,
+ }
+ var resp auth.GetAdminTokenResp
+ if err := a.apiPost(ctx, "/auth/get_admin_token", &req, &resp); err != nil {
+ return "", err
+ }
+ return resp.Token, nil
+}
+
+func (a *Api) GetPartLimit(ctx context.Context) (*third.PartLimitResp, error) {
+ var resp third.PartLimitResp
+ if err := a.apiPost(ctx, "/object/part_limit", &third.PartLimitReq{}, &resp); err != nil {
+ return nil, err
+ }
+ return &resp, nil
+}
+
+func (a *Api) InitiateMultipartUpload(ctx context.Context, req *third.InitiateMultipartUploadReq) (*third.InitiateMultipartUploadResp, error) {
+ var resp third.InitiateMultipartUploadResp
+ if err := a.apiPost(ctx, "/object/initiate_multipart_upload", req, &resp); err != nil {
+ return nil, err
+ }
+ return &resp, nil
+}
+
+func (a *Api) CompleteMultipartUpload(ctx context.Context, req *third.CompleteMultipartUploadReq) (string, error) {
+ var resp third.CompleteMultipartUploadResp
+ if err := a.apiPost(ctx, "/object/complete_multipart_upload", req, &resp); err != nil {
+ return "", err
+ }
+ return resp.Url, nil
+}
diff --git a/tools/url2im/pkg/buffer.go b/tools/url2im/pkg/buffer.go
new file mode 100644
index 0000000..b4c1046
--- /dev/null
+++ b/tools/url2im/pkg/buffer.go
@@ -0,0 +1,110 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import (
+ "bytes"
+ "io"
+ "os"
+)
+
+type ReadSeekSizeCloser interface {
+ io.ReadSeekCloser
+ Size() int64
+}
+
+func NewReader(r io.Reader, max int64, path string) (ReadSeekSizeCloser, error) {
+ buf := make([]byte, max+1)
+ n, err := io.ReadFull(r, buf)
+ if err == nil {
+ f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o666)
+ if err != nil {
+ return nil, err
+ }
+ var ok bool
+ defer func() {
+ if !ok {
+ _ = f.Close()
+ _ = os.Remove(path)
+ }
+ }()
+ if _, err := f.Write(buf[:n]); err != nil {
+ return nil, err
+ }
+ cn, err := io.Copy(f, r)
+ if err != nil {
+ return nil, err
+ }
+ if _, err := f.Seek(0, io.SeekStart); err != nil {
+ return nil, err
+ }
+ ok = true
+ return &fileBuffer{
+ f: f,
+ n: cn + int64(n),
+ }, nil
+ } else if err == io.EOF || err == io.ErrUnexpectedEOF {
+ return &memoryBuffer{
+ r: bytes.NewReader(buf[:n]),
+ }, nil
+ } else {
+ return nil, err
+ }
+}
+
+type fileBuffer struct {
+ n int64
+ f *os.File
+}
+
+func (r *fileBuffer) Read(p []byte) (n int, err error) {
+ return r.f.Read(p)
+}
+
+func (r *fileBuffer) Seek(offset int64, whence int) (int64, error) {
+ return r.f.Seek(offset, whence)
+}
+
+func (r *fileBuffer) Size() int64 {
+ return r.n
+}
+
+func (r *fileBuffer) Close() error {
+ name := r.f.Name()
+ if err := r.f.Close(); err != nil {
+ return err
+ }
+ return os.Remove(name)
+}
+
+type memoryBuffer struct {
+ r *bytes.Reader
+}
+
+func (r *memoryBuffer) Read(p []byte) (n int, err error) {
+ return r.r.Read(p)
+}
+
+func (r *memoryBuffer) Seek(offset int64, whence int) (int64, error) {
+ return r.r.Seek(offset, whence)
+}
+
+func (r *memoryBuffer) Close() error {
+ return nil
+}
+
+func (r *memoryBuffer) Size() int64 {
+ return r.r.Size()
+}
diff --git a/tools/url2im/pkg/config.go b/tools/url2im/pkg/config.go
new file mode 100644
index 0000000..740e748
--- /dev/null
+++ b/tools/url2im/pkg/config.go
@@ -0,0 +1,30 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import "time"
+
+type Config struct {
+ TaskPath string
+ ProgressPath string
+ Concurrency int
+ Retry int
+ Timeout time.Duration
+ Api string
+ UserID string
+ Secret string
+ TempDir string
+ CacheSize int64
+}
diff --git a/tools/url2im/pkg/http.go b/tools/url2im/pkg/http.go
new file mode 100644
index 0000000..50fb30c
--- /dev/null
+++ b/tools/url2im/pkg/http.go
@@ -0,0 +1,21 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import "net/http"
+
+func DefaultRequestHeader(header http.Header) {
+ header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36")
+}
diff --git a/tools/url2im/pkg/manage.go b/tools/url2im/pkg/manage.go
new file mode 100644
index 0000000..4e46002
--- /dev/null
+++ b/tools/url2im/pkg/manage.go
@@ -0,0 +1,400 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import (
+ "bufio"
+ "context"
+ "crypto/md5"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "io"
+ "log"
+ "net/http"
+ "net/url"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/openimsdk/tools/errs"
+
+ "git.imall.cloud/openim/protocol/third"
+)
+
+type Upload struct {
+ URL string `json:"url"`
+ Name string `json:"name"`
+ ContentType string `json:"contentType"`
+}
+
+type Task struct {
+ Index int
+ Upload Upload
+}
+
+type PartInfo struct {
+ ContentType string
+ PartSize int64
+ PartNum int
+ FileMd5 string
+ PartMd5 string
+ PartSizes []int64
+ PartMd5s []string
+}
+
+func Run(conf Config) error {
+ m := &Manage{
+ prefix: time.Now().Format("20060102150405"),
+ conf: &conf,
+ ctx: context.Background(),
+ }
+ return m.Run()
+}
+
+type Manage struct {
+ conf *Config
+ ctx context.Context
+ api *Api
+ partLimit *third.PartLimitResp
+ prefix string
+ tasks chan Task
+ id uint64
+ success int64
+ failed int64
+}
+
+func (m *Manage) tempFilePath() string {
+ return filepath.Join(m.conf.TempDir, fmt.Sprintf("%s_%d", m.prefix, atomic.AddUint64(&m.id, 1)))
+}
+
+func (m *Manage) Run() error {
+ defer func(start time.Time) {
+ log.Printf("run time %s\n", time.Since(start))
+ }(time.Now())
+ m.api = &Api{
+ Api: m.conf.Api,
+ UserID: m.conf.UserID,
+ Secret: m.conf.Secret,
+ Client: &http.Client{Timeout: m.conf.Timeout},
+ }
+ var err error
+ ctx := context.WithValue(m.ctx, "operationID", fmt.Sprintf("%s_init", m.prefix))
+ m.api.Token, err = m.api.GetAdminToken(ctx)
+ if err != nil {
+ return err
+ }
+ m.partLimit, err = m.api.GetPartLimit(ctx)
+ if err != nil {
+ return err
+ }
+ progress, err := ReadProgress(m.conf.ProgressPath)
+ if err != nil {
+ return err
+ }
+ progressFile, err := os.OpenFile(m.conf.ProgressPath, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
+ if err != nil {
+ return err
+ }
+ var mutex sync.Mutex
+ writeSuccessIndex := func(index int) {
+ mutex.Lock()
+ defer mutex.Unlock()
+ if _, err := progressFile.Write([]byte(strconv.Itoa(index) + "\n")); err != nil {
+ log.Printf("write progress err: %v\n", err)
+ }
+ }
+ file, err := os.Open(m.conf.TaskPath)
+ if err != nil {
+ return err
+ }
+ m.tasks = make(chan Task, m.conf.Concurrency*2)
+ go func() {
+ defer file.Close()
+ defer close(m.tasks)
+ scanner := bufio.NewScanner(file)
+ var (
+ index int
+ num int
+ )
+ for scanner.Scan() {
+ line := strings.TrimSpace(scanner.Text())
+ if line == "" {
+ continue
+ }
+ index++
+ if progress.IsUploaded(index) {
+ log.Printf("index: %d already uploaded %s\n", index, line)
+ continue
+ }
+ var upload Upload
+ if err := json.Unmarshal([]byte(line), &upload); err != nil {
+ log.Printf("index: %d json.Unmarshal(%s) err: %v", index, line, err)
+ continue
+ }
+ num++
+ m.tasks <- Task{
+ Index: index,
+ Upload: upload,
+ }
+ }
+ if num == 0 {
+ log.Println("mark all completed")
+ }
+ }()
+ var wg sync.WaitGroup
+ wg.Add(m.conf.Concurrency)
+ for i := 0; i < m.conf.Concurrency; i++ {
+ go func(tid int) {
+ defer wg.Done()
+ for task := range m.tasks {
+ var success bool
+ for n := 0; n < m.conf.Retry; n++ {
+ ctx := context.WithValue(m.ctx, "operationID", fmt.Sprintf("%s_%d_%d_%d", m.prefix, tid, task.Index, n+1))
+ if urlRaw, err := m.RunTask(ctx, task); err == nil {
+ writeSuccessIndex(task.Index)
+ log.Println("index:", task.Index, "upload success", "urlRaw", urlRaw)
+ success = true
+ break
+ } else {
+ log.Printf("index: %d upload: %+v err: %v", task.Index, task.Upload, err)
+ }
+ }
+ if success {
+ atomic.AddInt64(&m.success, 1)
+ } else {
+ atomic.AddInt64(&m.failed, 1)
+ log.Printf("index: %d upload: %+v failed", task.Index, task.Upload)
+ }
+ }
+ }(i + 1)
+ }
+ wg.Wait()
+ log.Printf("execution completed success %d failed %d\n", m.success, m.failed)
+ return nil
+}
+
+func (m *Manage) RunTask(ctx context.Context, task Task) (string, error) {
+ resp, err := m.HttpGet(ctx, task.Upload.URL)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+ reader, err := NewReader(resp.Body, m.conf.CacheSize, m.tempFilePath())
+ if err != nil {
+ return "", err
+ }
+ defer reader.Close()
+ part, err := m.getPartInfo(ctx, reader, reader.Size())
+ if err != nil {
+ return "", err
+ }
+ var contentType string
+ if task.Upload.ContentType == "" {
+ contentType = part.ContentType
+ } else {
+ contentType = task.Upload.ContentType
+ }
+ initiateMultipartUploadResp, err := m.api.InitiateMultipartUpload(ctx, &third.InitiateMultipartUploadReq{
+ Hash: part.PartMd5,
+ Size: reader.Size(),
+ PartSize: part.PartSize,
+ MaxParts: -1,
+ Cause: "batch-import",
+ Name: task.Upload.Name,
+ ContentType: contentType,
+ })
+ if err != nil {
+ return "", err
+ }
+ if initiateMultipartUploadResp.Upload == nil {
+ return initiateMultipartUploadResp.Url, nil
+ }
+ if _, err := reader.Seek(0, io.SeekStart); err != nil {
+ return "", err
+ }
+ uploadParts := make([]*third.SignPart, part.PartNum)
+ for _, part := range initiateMultipartUploadResp.Upload.Sign.Parts {
+ uploadParts[part.PartNumber-1] = part
+ }
+ for i, currentPartSize := range part.PartSizes {
+ md5Reader := NewMd5Reader(io.LimitReader(reader, currentPartSize))
+ if err := m.doPut(ctx, m.api.Client, initiateMultipartUploadResp.Upload.Sign, uploadParts[i], md5Reader, currentPartSize); err != nil {
+ return "", err
+ }
+ if md5val := md5Reader.Md5(); md5val != part.PartMd5s[i] {
+ return "", fmt.Errorf("upload part %d failed, md5 not match, expect %s, got %s", i, part.PartMd5s[i], md5val)
+ }
+ }
+ urlRaw, err := m.api.CompleteMultipartUpload(ctx, &third.CompleteMultipartUploadReq{
+ UploadID: initiateMultipartUploadResp.Upload.UploadID,
+ Parts: part.PartMd5s,
+ Name: task.Upload.Name,
+ ContentType: contentType,
+ Cause: "batch-import",
+ })
+ if err != nil {
+ return "", err
+ }
+ return urlRaw, nil
+}
+
+func (m *Manage) partSize(size int64) (int64, error) {
+ if size <= 0 {
+ return 0, errs.New("size must be greater than 0")
+ }
+ if size > m.partLimit.MaxPartSize*int64(m.partLimit.MaxNumSize) {
+ return 0, errs.New("size must be less than", "size", m.partLimit.MaxPartSize*int64(m.partLimit.MaxNumSize))
+ }
+ if size <= m.partLimit.MinPartSize*int64(m.partLimit.MaxNumSize) {
+ return m.partLimit.MinPartSize, nil
+ }
+ partSize := size / int64(m.partLimit.MaxNumSize)
+ if size%int64(m.partLimit.MaxNumSize) != 0 {
+ partSize++
+ }
+ return partSize, nil
+}
+
+func (m *Manage) partMD5(parts []string) string {
+ s := strings.Join(parts, ",")
+ md5Sum := md5.Sum([]byte(s))
+ return hex.EncodeToString(md5Sum[:])
+}
+
+func (m *Manage) getPartInfo(ctx context.Context, r io.Reader, fileSize int64) (*PartInfo, error) {
+ partSize, err := m.partSize(fileSize)
+ if err != nil {
+ return nil, err
+ }
+ partNum := int(fileSize / partSize)
+ if fileSize%partSize != 0 {
+ partNum++
+ }
+ partSizes := make([]int64, partNum)
+ for i := 0; i < partNum; i++ {
+ partSizes[i] = partSize
+ }
+ partSizes[partNum-1] = fileSize - partSize*(int64(partNum)-1)
+ partMd5s := make([]string, partNum)
+ buf := make([]byte, 1024*8)
+ fileMd5 := md5.New()
+ var contentType string
+ for i := 0; i < partNum; i++ {
+ h := md5.New()
+ r := io.LimitReader(r, partSize)
+ for {
+ if n, err := r.Read(buf); err == nil {
+ if contentType == "" {
+ contentType = http.DetectContentType(buf[:n])
+ }
+ h.Write(buf[:n])
+ fileMd5.Write(buf[:n])
+ } else if err == io.EOF {
+ break
+ } else {
+ return nil, err
+ }
+ }
+ partMd5s[i] = hex.EncodeToString(h.Sum(nil))
+ }
+ partMd5Val := m.partMD5(partMd5s)
+ fileMd5val := hex.EncodeToString(fileMd5.Sum(nil))
+ return &PartInfo{
+ ContentType: contentType,
+ PartSize: partSize,
+ PartNum: partNum,
+ FileMd5: fileMd5val,
+ PartMd5: partMd5Val,
+ PartSizes: partSizes,
+ PartMd5s: partMd5s,
+ }, nil
+}
+
+func (m *Manage) doPut(ctx context.Context, client *http.Client, sign *third.AuthSignParts, part *third.SignPart, reader io.Reader, size int64) error {
+ rawURL := part.Url
+ if rawURL == "" {
+ rawURL = sign.Url
+ }
+ if len(sign.Query)+len(part.Query) > 0 {
+ u, err := url.Parse(rawURL)
+ if err != nil {
+ return err
+ }
+ query := u.Query()
+ for i := range sign.Query {
+ v := sign.Query[i]
+ query[v.Key] = v.Values
+ }
+ for i := range part.Query {
+ v := part.Query[i]
+ query[v.Key] = v.Values
+ }
+ u.RawQuery = query.Encode()
+ rawURL = u.String()
+ }
+ req, err := http.NewRequestWithContext(ctx, http.MethodPut, rawURL, reader)
+ if err != nil {
+ return err
+ }
+ for i := range sign.Header {
+ v := sign.Header[i]
+ req.Header[v.Key] = v.Values
+ }
+ for i := range part.Header {
+ v := part.Header[i]
+ req.Header[v.Key] = v.Values
+ }
+ req.ContentLength = size
+ resp, err := client.Do(req)
+ if err != nil {
+ return err
+ }
+ defer func() {
+ _ = resp.Body.Close()
+ }()
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+ if resp.StatusCode/200 != 1 {
+ return fmt.Errorf("PUT %s part %d failed, status code %d, body %s", rawURL, part.PartNumber, resp.StatusCode, string(body))
+ }
+ return nil
+}
+
+func (m *Manage) HttpGet(ctx context.Context, url string) (*http.Response, error) {
+ reqUrl := url
+ for {
+ request, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, nil)
+ if err != nil {
+ return nil, err
+ }
+ DefaultRequestHeader(request.Header)
+ response, err := m.api.Client.Do(request)
+ if err != nil {
+ return nil, err
+ }
+ if response.StatusCode != http.StatusOK {
+ _ = response.Body.Close()
+ return nil, fmt.Errorf("webhook get %s status %s", url, response.Status)
+ }
+ return response, nil
+ }
+}
diff --git a/tools/url2im/pkg/md5.go b/tools/url2im/pkg/md5.go
new file mode 100644
index 0000000..26b8d47
--- /dev/null
+++ b/tools/url2im/pkg/md5.go
@@ -0,0 +1,43 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import (
+ "crypto/md5"
+ "encoding/hex"
+ "hash"
+ "io"
+)
+
+func NewMd5Reader(r io.Reader) *Md5Reader {
+ return &Md5Reader{h: md5.New(), r: r}
+}
+
+type Md5Reader struct {
+ h hash.Hash
+ r io.Reader
+}
+
+func (r *Md5Reader) Read(p []byte) (n int, err error) {
+ n, err = r.r.Read(p)
+ if err == nil && n > 0 {
+ r.h.Write(p[:n])
+ }
+ return
+}
+
+func (r *Md5Reader) Md5() string {
+ return hex.EncodeToString(r.h.Sum(nil))
+}
diff --git a/tools/url2im/pkg/progress.go b/tools/url2im/pkg/progress.go
new file mode 100644
index 0000000..5f30495
--- /dev/null
+++ b/tools/url2im/pkg/progress.go
@@ -0,0 +1,55 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package pkg
+
+import (
+ "bufio"
+ "os"
+ "strconv"
+
+ "github.com/kelindar/bitmap"
+)
+
+func ReadProgress(path string) (*Progress, error) {
+ file, err := os.Open(path)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return &Progress{}, nil
+ }
+ return nil, err
+ }
+ defer file.Close()
+ scanner := bufio.NewScanner(file)
+ var upload bitmap.Bitmap
+ for scanner.Scan() {
+ index, err := strconv.Atoi(scanner.Text())
+ if err != nil || index < 0 {
+ continue
+ }
+ upload.Set(uint32(index))
+ }
+ return &Progress{upload: upload}, nil
+}
+
+type Progress struct {
+ upload bitmap.Bitmap
+}
+
+func (p *Progress) IsUploaded(index int) bool {
+ if p == nil {
+ return false
+ }
+ return p.upload.Contains(uint32(index))
+}
diff --git a/tools/versionchecker/main.go b/tools/versionchecker/main.go
new file mode 100644
index 0000000..bec7daa
--- /dev/null
+++ b/tools/versionchecker/main.go
@@ -0,0 +1,113 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "os/exec"
+ "runtime"
+
+ "github.com/fatih/color"
+ "github.com/openimsdk/tools/utils/timeutil"
+)
+
+func ExecuteCommand(cmdName string, args ...string) (string, error) {
+ cmd := exec.Command(cmdName, args...)
+ var out bytes.Buffer
+ var stderr bytes.Buffer
+ cmd.Stdout = &out
+ cmd.Stderr = &stderr
+
+ err := cmd.Run()
+ if err != nil {
+ return "", fmt.Errorf("error executing %s: %v, stderr: %s", cmdName, err, stderr.String())
+ }
+ return out.String(), nil
+}
+
+func printTime() string {
+ formattedTime := timeutil.GetCurrentTimeFormatted()
+ return fmt.Sprintf("Current Date & Time: %s", formattedTime)
+}
+
+func getGoVersion() string {
+ version := runtime.Version()
+ goos := runtime.GOOS
+ goarch := runtime.GOARCH
+ return fmt.Sprintf("Go Version: %s\nOS: %s\nArchitecture: %s", version, goos, goarch)
+}
+
+func getDockerVersion() string {
+ version, err := ExecuteCommand("docker", "--version")
+ if err != nil {
+ return "Docker is not installed. Please install it to get the version."
+ }
+ return version
+}
+
+func getKubernetesVersion() string {
+ version, err := ExecuteCommand("kubectl", "version", "--client", "--short")
+ if err != nil {
+ return "Kubernetes is not installed. Please install it to get the version."
+ }
+ return version
+}
+
+func getGitVersion() string {
+ version, err := ExecuteCommand("git", "branch", "--show-current")
+ if err != nil {
+ return "Git is not installed. Please install it to get the version."
+ }
+ return version
+}
+
+// // NOTE: You'll need to provide appropriate commands for OpenIM versions.
+// func getOpenIMServerVersion() string {
+// // Placeholder
+// openimVersion := version.GetSingleVersion()
+// return "OpenIM Server: " + openimVersion + "\n"
+// }
+
+// func getOpenIMClientVersion() (string, error) {
+// openIMClientVersion, err := version.GetClientVersion()
+// if err != nil {
+// return "", err
+// }
+// return "OpenIM Client: " + openIMClientVersion.ClientVersion + "\n", nil
+// }
+
+func main() {
+ // red := color.New(color.FgRed).SprintFunc()
+ // green := color.New(color.FgGreen).SprintFunc()
+ blue := color.New(color.FgBlue).SprintFunc()
+ // yellow := color.New(color.FgYellow).SprintFunc()
+ fmt.Println(blue("## Go Version"))
+ fmt.Println(getGoVersion())
+ fmt.Println(blue("## Branch Type"))
+ fmt.Println(getGitVersion())
+ fmt.Println(blue("## Docker Version"))
+ fmt.Println(getDockerVersion())
+ fmt.Println(blue("## Kubernetes Version"))
+ fmt.Println(getKubernetesVersion())
+ // fmt.Println(blue("## OpenIM Versions"))
+ // fmt.Println(getOpenIMServerVersion())
+ // clientVersion, err := getOpenIMClientVersion()
+ // if err != nil {
+ // fmt.Println(red("Error getting OpenIM Client Version: "), err)
+ // } else {
+ // fmt.Println(clientVersion)
+ // }
+}
diff --git a/tools/yamlfmt/main.go b/tools/yamlfmt/main.go
new file mode 100644
index 0000000..a8d3a76
--- /dev/null
+++ b/tools/yamlfmt/main.go
@@ -0,0 +1,72 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+// OPENIM plan on prow tools
+package main
+
+import (
+ "flag"
+ "fmt"
+ "io"
+ "os"
+
+ "gopkg.in/yaml.v3"
+)
+
+func main() {
+ // Prow OWNERs file defines the default indent as 2 spaces.
+ indent := flag.Int("indent", 2, "default indent")
+ flag.Parse()
+ for _, path := range flag.Args() {
+ sourceYaml, err := os.ReadFile(path)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "%s: %v\n", path, err)
+ continue
+ }
+ rootNode, err := fetchYaml(sourceYaml)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "%s: %v\n", path, err)
+ continue
+ }
+ writer, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o666)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "%s: %v\n", path, err)
+ continue
+ }
+ err = streamYaml(writer, indent, rootNode)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "%s: %v\n", path, err)
+ continue
+ }
+ }
+}
+
+func fetchYaml(sourceYaml []byte) (*yaml.Node, error) {
+ rootNode := yaml.Node{}
+ err := yaml.Unmarshal(sourceYaml, &rootNode)
+ if err != nil {
+ return nil, err
+ }
+ return &rootNode, nil
+}
+
+func streamYaml(writer io.Writer, indent *int, in *yaml.Node) error {
+ encoder := yaml.NewEncoder(writer)
+ encoder.SetIndent(*indent)
+ err := encoder.Encode(in)
+ if err != nil {
+ return err
+ }
+ return encoder.Close()
+}
diff --git a/tools/yamlfmt/main_test.go b/tools/yamlfmt/main_test.go
new file mode 100644
index 0000000..0a72e49
--- /dev/null
+++ b/tools/yamlfmt/main_test.go
@@ -0,0 +1,158 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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
+//
+// http://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.
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "reflect"
+ "testing"
+
+ "github.com/likexian/gokit/assert"
+ "gopkg.in/yaml.v3"
+)
+
+func Test_main(t *testing.T) {
+ sourceYaml := ` # See the OWNERS docs at https://go.k8s.io/owners
+approvers:
+- dep-approvers
+- thockin # Network
+- liggitt
+
+labels:
+- sig/architecture
+`
+
+ outputYaml := `# See the OWNERS docs at https://go.k8s.io/owners
+approvers:
+ - dep-approvers
+ - thockin # Network
+ - liggitt
+labels:
+ - sig/architecture
+`
+ node, _ := fetchYaml([]byte(sourceYaml))
+ var output bytes.Buffer
+ indent := 2
+ writer := bufio.NewWriter(&output)
+ _ = streamYaml(writer, &indent, node)
+ _ = writer.Flush()
+ assert.Equal(t, outputYaml, string(output.Bytes()), "yaml was not formatted correctly")
+}
+
+func Test_fetchYaml(t *testing.T) {
+ type args struct {
+ sourceYaml []byte
+ }
+ tests := []struct {
+ name string
+ args args
+ want *yaml.Node
+ wantErr bool
+ }{
+ {
+ name: "Valid YAML",
+ args: args{sourceYaml: []byte("key: value")},
+ want: &yaml.Node{
+ Kind: yaml.MappingNode,
+ Tag: "!!map",
+ Value: "",
+ Content: []*yaml.Node{
+ {
+ Kind: yaml.ScalarNode,
+ Tag: "!!str",
+ Value: "key",
+ },
+ {
+ Kind: yaml.ScalarNode,
+ Tag: "!!str",
+ Value: "value",
+ },
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "Invalid YAML",
+ args: args{sourceYaml: []byte("key:")},
+ want: nil,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := fetchYaml(tt.args.sourceYaml)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("fetchYaml() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("fetchYaml() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func Test_streamYaml(t *testing.T) {
+ type args struct {
+ indent *int
+ in *yaml.Node
+ }
+ defaultIndent := 2
+ tests := []struct {
+ name string
+ args args
+ wantWriter string
+ wantErr bool
+ }{
+ {
+ name: "Valid YAML node with default indent",
+ args: args{
+ indent: &defaultIndent,
+ in: &yaml.Node{
+ Kind: yaml.MappingNode,
+ Tag: "!!map",
+ Value: "",
+ Content: []*yaml.Node{
+ {
+ Kind: yaml.ScalarNode,
+ Tag: "!!str",
+ Value: "key",
+ },
+ {
+ Kind: yaml.ScalarNode,
+ Tag: "!!str",
+ Value: "value",
+ },
+ },
+ },
+ },
+ wantWriter: "key: value\n",
+ wantErr: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ writer := &bytes.Buffer{}
+ if err := streamYaml(writer, tt.args.indent, tt.args.in); (err != nil) != tt.wantErr {
+ t.Errorf("streamYaml() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if gotWriter := writer.String(); gotWriter != tt.wantWriter {
+ t.Errorf("streamYaml() = %v, want %v", gotWriter, tt.wantWriter)
+ }
+ })
+ }
+}
diff --git a/version/version b/version/version
new file mode 100644
index 0000000..88d050b
--- /dev/null
+++ b/version/version
@@ -0,0 +1 @@
+main
\ No newline at end of file
diff --git a/version/version.go b/version/version.go
new file mode 100644
index 0000000..32ad278
--- /dev/null
+++ b/version/version.go
@@ -0,0 +1,14 @@
+package version
+
+import (
+ _ "embed"
+ "strings"
+)
+
+//go:embed version
+var Version string
+
+func init() {
+ Version = strings.Trim(Version, "\n")
+ Version = strings.TrimSpace(Version)
+}
+
+