Help Center/CodeArts Repo/Service Overview/Functions
Updated on 2026-01-29 GMT+08:00
View PDF

Functions

CodeArts Repo has the following functions:

Configuring Personal Environment

You need to configure the environment before developing code in CodeArts Repo.

You need to set up the local Git environment first as it is the basic tool for code-hosting.

When you push code to or pull code from a cloud repository, the cloud repository needs to verify your identity and permissions. CodeArts Repo provides the verification methods of SSH key, HTTPS password, GPG public key, and access token to maintain code access security.

When you commit code or create a merge request (MR), the system will use the commit email address to identify the committer. Therefore, you are advised to configure the commit email address before code development.

When a code repository involves large file storage, you can configure Git LFS.

For details, see Environment and Personal Settings.

Configuring Repository Settings

You can have the same settings for all repositories in a project or repository group in CodeArts Repo.

If you do so, you will be more efficient in managing multiple repositories and ensure the consistency of repository rules in the project or repository group.

For details, see :

Configuring Protected Branch Rules

Frequent team commits to the main branch during software development can lead to degraded code quality and security vulnerabilities.

To address these issues, you can configure protected branch rules to allow developers to merge code through merge requests while restricting direct pushes by non-maintainers, prohibiting force pushes, and preventing branch deletion.

By setting project-level or repository-level protected branch rules, you can prevent unauthorized code commits and ensure strict code review, improving code quality and security.

For details, see :

Configuring Merge Request Rules

In a software development team, code merge requests need to be reviewed rigorously to ensure code quality and team collaboration efficiency. However, in reality, the lack of effective rule settings may lead to problems such as code quality degradation and low team collaboration efficiency.

Configuring merge request rules can resolve these problems. If some problems are not resolved, developers cannot merge code or close the merge request.

For details, see :

Configuring E2E Settings

E2E configuration is a core feature that can be associated with code merge and related work items to facilitate tracing and management.

For details, see :

Configuring Webhook Settings

Nowadays during software development, development teams often need to integrate code-hosting repository with CI/CD tools or other third-party systems to automate builds, tests, and deployment.

Such manual processes, however, are time-consuming and error-prone. Configuring webhooks can seamlessly connect the CodeArts Repo repositories to third-party systems. When a subscribed branch push or tag push event occurs, a POST request is automatically sent to trigger the third-party system to perform operations such as pop-up notifications, build, image updates, and deployment, streamlining the development and deployment processes.

You can select event types to subscribe to based on project requirements. You can also avoid irrelevant event triggering by branch filtering using regular expression rules to maximize resource usage while meeting diverse project needs.

CodeArts Repo leverages token authentication to transmit authentication information through HTTP request headers. Meanwhile, users need to encrypt and decrypt sensitive data in URLs to ensure the security of API calling and data transmission and reduce information leakage risks.

You can configure third-party system URLs for webhooks in CodeArts Repo and customize token types in addition to preset options. Therefore, you can flexibly interconnect with various self-built systems or mainstream CI/CD tools to for different technology stacks and service scenarios.

For details, see :

Creating a Repository

You can create a repository using any of the following methods:

  • Create a custom repository. When a team starts a new project and needs to customize the repository structure and rules, you can create a code repository in this way.
  • Create a repository with a template. A team can create a repository based on the preset system template without setting up basic configurations from scratch. This ensures the consistency of project initialization and reduces repeated configurations.
  • Fork a repository. Developers can fork an existing repository when they need to make contributions or study the project's codebase. This process replicates the original code, branches, and full commit history, and allows for subsequent updates and synchronization with the original repository via merge requests.
  • Migrate a repository. Your team can migrate data from other code-hosting platforms to CodeArts Repo to keep historical project data. Currently, data can be migrated from GitHub, GitLab, self-built GitLab, Gitee, Coding, Codeup, Bitbucket, and Gerrit repositories.

For details, see :

Forking a Repository

In software development, large projects usually contain multiple sub-projects. Frequent code commits and tests during development may cause instability of the project version repository (source repository). Forking a repository allows developers to create an identical mirror repository based on the source repository. Developers can develop and test freely in the forked repository without affecting the source repository.

Only when the new features are fully tested and confirmed can the modifications in the merge request be merged to the source repository. This workflow effectively addresses code management challenges in large-scale development and facilitates team collaboration. By using the forked repository, developers can develop in an independent environment to ensure the stability and security of the source repository.

For details, see Forking a Repository.

Backing Up a Repository

To ensure code security and recoverability during software development, teams generally perform regular backups of their repositories. However, when they are trying to do so, they may face complex operations and connectivity issues. To solve this, you can back up the repository to another region of Huawei Cloud, which is essentially an external repository import from one region to another.

Of course, you can also back up the repository to your local computer using the clone command generated by HTTPS or SSH and copy the command to your local Git client after ensuring repository connectivity.

For details, see Backing Up a Repository.

Managing Branches

During software development, team members often need to handle multiple feature development or bug fixes at the same time, which may cause code conflicts and version management disorder. To solve this problem, you can use the branch function in the version management tool.

Branching is the most commonly used method in version management. Branches isolate tasks in a project to prevent them from affecting each other, and can be merged for version release.

When you create a Git repository in CodeArts Repo, a master (production) branch is generated by default and used as the branch of the latest version. You can create custom branches at any time for personalized scenarios.

Teams can properly plan branch policies, such as master (production), develop (development), feature (function), release (release), and hotfix (emergency repair) branches, to ensure that each development task is performed independently, reduce code conflicts, and improve development efficiency.

For details, see :

Managing Tags

During software development, team members often need to trace back to a specific version for troubleshooting or feature rollback. However, the ID of each commit is a long string of codes. Compared with the version number such as V1.0.0, the commit ID is not easy to remember and is not identifiable. As a result, it is difficult to quickly locate a specific version. To help team members manage versions and locate faults more efficiently, Git provides tags to help teams manage versions. You can use Git tags to mark commits and manage important versions in a project for future tracking.

Every tag points to a commit. No matter how later versions change, the tag always points to the commit. It can be regarded as a version snapshot that is permanently saved (the version is removed from the repository only when being manually deleted).

By tagging important versions and giving them a name (for example, myTag_V1.0.0 or first commercial version), team members can easily remember and track these versions, improving work efficiency.

For details, see Managing Tags.

Repository Network

During software development, development teams frequently need to examine the code's commit history to understand and track code changes. However, the historical records in the traditional file tab can display only the changes of a single file and cannot display the relationships between different commits. This makes it difficult for team members to understand the overall code changes. CodeArts Repo provides repository network to help developers review code and collaborate more efficiently. This network displays the entire commit history (including the action, time, committer, system-generated commit remarks, and manually entered remarks) of a branch or tag and the relationship between commits in a flow chart.

Compared with the history on the file tab page, the commit network can display the relationship between commits, helping team members understand overall code changes and improving collaboration efficiency.

For details, see Viewing the Repository Network.

Managing Versions

During software development, team members often need to modify and optimize the same project, which may cause code version confusion and low development efficiency. To solve this problem, the version management function can record, track, maintain, and control changes of a product or system series, including but not limited to branches, tags, and difference comparison.

Therefore, teams can effectively manage code changes, improve collaboration efficiency, and ensure smooth project implementation.

For details, see Managing Code Files.

Comparing Code File Difference

During software development, team members often need to compare different versions of code to ensure code quality and team collaboration efficiency. However, manual comparison of code versions is time-consuming and error-prone. Comparison provides an intuitive display of code differences among versions, which streamline your version management.

On the repository console, you can compare the code differences of any branch, tag, or commit. Changes are displayed in different styles, helping you quickly spot what is updated, added, and deleted.

With this function, developers can quickly identify code changes and improve the efficiency of code review and merging.

For details, see :

Cherry-Pick

During software development, team members often need to introduce specific fixes or features from other branches without introducing all changes on the branches. When you need to merge commits from another branch locally, if you merge the entire branch, unnecessary code changes may be introduced, causing confusion in the repository. You can run the git cherry-pick command to extract a commit and apply it to a version.

For details, see History Tab: Viewing the Commit History of a Branch or Tag Version.

Cloning or Downloading a Repository to the Localhost

During software development, developers often need to modify code on local computers to facilitate development. However, when developers need to synchronize locally modified code to CodeArts Repo, the synchronization process may be complex and inefficient. CodeArts Repo allows you to synchronize code between the cloud and local by uploading, cloning, or downloading. It provides multiple cloning or downloading methods, including but not limited to using the Git command line tool and GUI client, to meet different user requirements, simplify the synchronization process, and improve development efficiency.

For details, see Cloning or Downloading a Repository to a Local PC.

Coding Online

During software development, developers often need to edit code on different devices. However, such scenario is often hindered by the traditional development environment and affects development efficiency. CodeArts Repo provides the IDE Online function for you to edit code online. You can modify code on the console to improve the problem fixing speed and operation flexibility.

For details, see Editing and Creating a Merge Request.

Resolving Code Conflicts

In team development, if multiple developers modify the same file at the same time, code commits may conflict, causing code push failures. CodeArts Repo supports code conflict resolution to ensure efficient team development. The solutions are as follows:

  • You can pull the remote code repository to the workspace of the local repository, use Git to automatically merge the modifications that can be merged, manually resolve the conflicts, and commit the code again through add-commit-push method.
  • You can also use the online conflict resolution tool provided by CodeArts Repo to directly resolve conflicts online.

For details, see Resolving Code Conflicts in an MR.

Associating Work Items

During software development, team members need to commit code frequently to develop new features or fix bugs. Thus, how to ensure that these commits are associated with specific tasks becomes a challenge in project management. You can associate each code commit with a work item in CodeArts Req, helping developers accurately record the corresponding work when fixing bugs and committing new features.

Associating work items also helps project managers view the committer and committed content involved in each requirement and bug fix, improving project transparency and management efficiency.

In the CodeArts Repo console, any operation on a file must be accompanied by a commit message. That is, each save operation can be equal to a commit. The mandatory commit message corresponds to the -m content of the commit command. CodeArts Repo captures keywords from -m (commit message) to automatically associate work items, eliminating the disconnection between code commits and work tasks.

For details, see Integrated Systems.

Viewing and Commenting Commit Records

When developing software in a team, developers often need to review code commits to track issues or understand the reasons for code changes. However, when there are many team members and frequent commits, it is difficult to find specific commit records and understand their background information. CodeArts Repo allows you to view details about the commit history and related file changes.

You can view the commit history on the History tab page of the Files or Commit Graph of a repository. You can click a commit record to view the committer, commit number, parent node, number of comments, and code change comparisons. You can comment on a commit or reply a comment. This not only helps team members quickly locate problems, but also facilitates team collaboration.

For details, see "Uploading Code Files to CodeArts Repo" > "Viewing Commit History" > "Viewing the Commit History on the Repo Activities Page" in User Guide.

Configuring Notifications

When using a code repository for project collaboration, team members need to be aware of the repository status changes in a timely manner to ensure smooth project progress. However, when the repository is frozen due to arrears, manually closed, or permanently deleted due to the freezing period exceeding the retention period, team members may not be notified in a timely manner, which hinders the project progress.

When key events such as repository freezing, closing, merge requests, or deletion occur, CodeArts Repo automatically sends email notifications to specified repository members to ensure timely information delivery. This helps team members quickly respond to repository status changes and ensures smooth project progress.

For details, see Setting Notifications for Repositories and MRs.

Managing Members

In enterprise-level project management, member management is a key part for the security and collaboration efficiency of repositories. However, when project members need to collaborate across tenants, they may encounter complex issues related to permission management and member invitation, leading to inefficient collaboration.

CodeArts Repo clearly defines that repository members are drawn from the project members. It allows the tenant where the project creator resides to invite IAM accounts from other tenants to join the project. Only the repository creator (owner) and repository administrator can edit repository members. Other members can only view the repository member list. This facilitates cross-tenant member management and improves collaboration efficiency.

For details, see Managing Repo Member Permissions.

Configuring IP Address Whitelist

Enterprise usually need to strictly control repository access to protect sensitive data from unauthorized access. However, if the IP address whitelist is not configured, any IP address may attempt to access the repository, which poses potential security risks.

Setting the IP address whitelist for a project or repository gives only specified IP addresses access to the repositories, improving security.

Only access requests from IP addresses within the whitelist are allowed, while access requests from all other IP addresses are denied, significantly enhancing repository security.

For details about how to configure IP address whitelists, see Configuring an IP Whitelist.

Risky Operations

CodeArts Repo allows administrators to change repository owners (risky). Exercise caution when doing this.

For details, see Managing Code Files.

Audit Logs

CodeArts Repo uses the audit log system that supports multi-dimensional query to quickly query information such as the operation time, operator, specific behavior, and branches and tags affected by the behavior, improving problem locating efficiency and code management security.

For details, see Audit Logs.