Batch time sequence synchronization method and tool for git multi-project specific submission

Abstract

The invention discloses a batch time sequence synchronization method and tool for git multi-project specific submission, and the method comprises the steps: decompressing a special toolkit to a specified directory, creating a code directory in a same-level directory, and downloading a git project code to be synchronized to the code directory through git clock; a Python3.7 and a dependency package are installed; running an app.py file in the toolkit, and accessing a specified address to open a visual operation interface; inputting a plurality of pieces of specific submission information of the plurality of git engineering codes into an interface textbox according to the format of engineering names and submission IDs; a target branch is clicked, synchronization is triggered, and the tool automatically executes batch synchronization according to the rule that the same project code is submitted and ranked according to the original time. According to the method, M-time code submission of N projects can be synchronized from one branch to another branch quickly and accurately through a tool.

Description

Technical Field

[0001] This invention relates to the field of software development technology, specifically to a method and tool for batch time-series synchronization of specific commits across multiple Git projects. Background Technology

[0002] In software development and version control within the telecommunications industry, code is typically managed using Git, and a branching development model is often employed during development (e.g., the 'pro' branch is used for production environment release preparation, and the 'master' branch is used for basic version maintenance). Once the code has been developed, tested, and successfully released on the 'pro' branch, the corresponding code must be committed and synchronized to the 'master' branch to provide a unified code foundation for subsequent requirement iterations, testing, and releases.

[0003] In existing technologies, the `cherry-pick` command provided by Git is the core tool for synchronizing a single commit, but it can only perform branch synchronization operations on a single commit of a single project. However, actual production environment releases often involve N projects (such as independent projects corresponding to multiple business modules), and each project may contain M code commits. In this case, the existing technology has significant drawbacks: First, the synchronization efficiency is extremely low, requiring manual execution of the `cherry-pick` command for each project and each commit, which is tedious and time-consuming; second, the commit order is prone to being disordered, and manual operation cannot guarantee that multiple commits of the same project are synchronized in their original chronological order, which may lead to code conflicts or logical anomalies; third, there is a lack of unified result feedback, and whether the synchronization is successful or not, and the changes involved, need to be manually checked one by one, which is prone to missing key information.

[0004] Existing technologies cannot meet the needs for efficient and accurate synchronization in scenarios with multiple projects and multiple submissions, which seriously affects the standardization of version maintenance and the continuity of subsequent development. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a method for batch time-series synchronization of specific commits across multiple Git projects. This method solves the problem of batch synchronizing the released code from one branch of a Git project to another after a production release, enabling program version maintenance.

[0006] This invention discloses a method for batch time-series synchronization of specific commits across multiple Git projects, comprising the following steps: Step 1: Toolkit Deployment and Project Preparation Extract the dedicated tool package to the specified directory, create a code directory in the same directory, and use git clone to download the git project code to be synchronized to the code directory; (2) Operating environment configuration: Install Python 3.7 and its dependencies; Step 3, Tool Launch and Interface Access: Run the app.py file in the toolkit and open the visual operation interface by accessing the specified address through a browser; Step 4, Submit Information Input: Enter specific commit information for multiple Git projects into the text boxes on the interface in the format of "Project Name, Commit ID"; Step 5: Batch time synchronization: Select the target branch and trigger synchronization. The tool will automatically perform batch synchronization according to the rule of "code commits in the same project are sorted by their original time". Step 6, Output the results: The interface displays the commit ID, commit information, changed files, and synchronization status of each project.

[0007] As a further improvement of the present invention, in step 1, the specified directory is E:\ProjCfg\workspace, and the name of the special tool package is tools.rar.

[0008] As a further improvement of the present invention, in step 2, the dependency package includes Flask, render_template, request, and Repo.

[0009] As a further improvement of the present invention, in step 3, the specified access address is http: / / 127.0.0.1:5000 / , and the visual operation interface supports multiple sets of "project name, submission ID" information input.

[0010] As a further improvement of the present invention, in step 4, the commit ID can be extracted from the first 8 characters of the git commit ID.

[0011] As a further improvement of the present invention, in step 5, the target branch includes the master branch, and the synchronization process does not require manual intervention in the commit order.

[0012] As a further improvement of the present invention, in step 6, the synchronization state includes success and failure.

[0013] This invention also discloses a Git multi-project specific commit batch timing synchronization tool for implementing the above method, comprising: Toolkit module: Stores the main app.py program and its dependency files, and provides configuration for project access paths; Environment configuration module: limits the Python 3.7 runtime environment and its dependencies; Interactive interface module: Provides a commit message input text box, target branch selection options, and an execute button, and supports browser access; Synchronization module: Built-in sorting rules (commits of the same project are sorted by original time) and git cherry-pick calling logic to achieve batch synchronization; Results output module: Collects synchronization process information and outputs project name, commit ID, commit information, changed files, and synchronization status.

[0014] As a further improvement of the present invention, the synchronous execution module supports ≥1 Git project, and the number of commits for each project is ≥1; the tool supports running the app.py file through Sublime Text and PyCharm integration tools.

[0015] As a further improvement of the present invention, the sorting rule only applies to multiple submissions of the same project, and there is no mandatory restriction on the synchronization order of submissions of different projects.

[0016] Compared with the prior art, the beneficial effects of the present invention are as follows: This invention uses a tool to quickly and accurately synchronize M code submissions from N projects to another branch in chronological order of submission, enabling code version control so that subsequent development can be based on this foundation. Attached Figure Description

[0017] Figure 1 This is a flowchart of the batch time-series synchronization method for specific commits in multiple Git projects disclosed in this invention; Figure 2 This is a flowchart illustrating the framework of the batch time-series synchronization tool for specific commits across multiple Git projects disclosed in this invention. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0019] The present invention will now be described in further detail with reference to the accompanying drawings: like Figure 1 As shown, this invention provides a method for batch time-series synchronization of specific commits across multiple Git projects, comprising the following steps: Step 1: Toolkit Deployment and Project Preparation Extract the dedicated tool package tools.rar to the specified directory E:\ProjCfg\workspace, create a code directory in the same directory, and use git clone to download the git project code to be synchronized to the code directory; (2) Operating environment configuration: Install Python 3.7 and the dependencies for Flask, render_template, request, and Repo; Step 3, Tool Launch and Interface Access: Log in directly to the Python directory and run the app.py file in the tool package (or run it through the integrated tools Sublime or PyCharm installed on your machine). After the program runs, access the specified address http: / / 127.0.0.1:5000 / through your browser to open the visual operation interface; the visual operation interface supports multiple sets of "project name, submission ID" information input; Step 4, Submit Information Input: Enter specific commit information for multiple Git projects into the interface text boxes in the format of "Project Name, Commit ID"; where the commit ID can be the first 8 characters of the Git commit ID. Step 5: Batch time synchronization: Select the target master branch and trigger synchronization. The tool will automatically perform batch synchronization according to the rule of "code commits in the same project are sorted by their original time". No manual intervention is required to change the commit order during the synchronization process. Step 6, Output the results: The interface displays the commit ID, commit information, changed files, and synchronization status for each project; the synchronization status includes success and failure.

[0020] like Figure 2 As shown, this invention provides a Git multi-project specific commit batch time-series synchronization tool for implementing the above method, comprising: The toolkit module stores the main app.py program and its dependency files, and provides configuration for project access paths; the tools support running the app.py file through Sublime Text and PyCharm integration tools. Environment configuration module: requires a Python 3.7 runtime environment and dependencies for Flask, render_template, request, and Repo; Interactive interface module: Provides a commit message input text box, target branch selection options, and an execute button, and supports browser access; The synchronization execution module includes built-in sorting rules (commits within the same project are sorted by their original time) and git cherry-pick calling logic to achieve batch synchronization. The sorting rules only apply to multiple commits within the same project; there are no strict restrictions on the synchronization order of commits from different projects. The synchronization execution module supports at least one Git project, with at least one commit per project. The tool supports running the app.py file via Sublime Text and PyCharm integration tools. Results output module: Collects synchronization process information and outputs project name, commit ID, commit information, changed files, and synchronization status. Example

[0021] I. Implementation Scenarios This embodiment takes two Git projects (test1.git and test2.git) for telecommunications industry software development as an example. Each project contains two code commits. These commits need to be synchronized from the pro branch to the master branch in batches to verify the feasibility of the present invention.

[0022] II. Implementation Steps 1. Toolkit and Environment Configuration Extract tools.rar to E:\ProjCfg\workspace, and create a code subdirectory in that directory; Open the command-line tool, navigate to the code directory, and execute "git clone test1.git" and "git clone test2.git" to download the two project codes to your local machine; Install Python 3.7 locally and execute "pip install Flask render_template requestRepo" to install the dependencies.

[0023] 2. Tool Launch and Interface Access Navigate to the directory E:\ProjCfg\workspace\tools\python and double-click to run app.py; Open your browser and enter http: / / 127.0.0.1:5000 / . The tool's visual interface will load successfully.

[0024] 3. Information preparation and input Make two code changes and commits on the pro branch of the test1.git project, and record the commit IDs (abc12345 and abc67890 respectively), with commit times T1 and T2 respectively. <T2); Make two code changes and commits on the pro branch of the test2.git project, and record the commit IDs (def12345 and def67890 respectively), with commit times of T3 and T4 respectively. <T4); Shuffle all the input order of the commits and organize them in the format of "project name, commit ID" as follows: test1.git,abc67890, test2.git,def67890, test1.git,abc12345, test2.git,def12345; Paste the above-mentioned information into the text box in the tool interface and select the "Synchronize master" option.

[0025] 4. Synchronous execution and result verification Click the submit button, and the tool will automatically execute the synchronization process: Recognize the input project name and commit ID, and match them with the local project repository under the code directory; Sort by commit time: the two commits of test1.git are sorted by T1 (abc12345) → T2 (abc67890), and the two commits of test2.git are sorted by T3 (def12345) → T4 (def67890); After sorting each project in turn, commit and perform cherry-pick synchronization to synchronize from one branch to another; After synchronization is complete, the interface output will include: test1.git: Commit IDs abc12345 (commit information, changed files) and abc67890 (commit information, changed files) are both successfully synchronized; test2.git: Commit IDs def12345 (commit information, changed files) and def67890 (commit information, changed files) both have successful synchronization status.

[0026] The above are merely preferred embodiments of the present invention and are not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for batch time-series synchronization of specific commits across multiple Git projects, characterized in that, Includes the following steps: Step 1: Toolkit Deployment and Project Preparation Extract the dedicated tool package to the specified directory, create a code directory in the same directory, and use git clone to download the git project code to be synchronized to the code directory; (2) Operating environment configuration: Install Python 3.7 and its dependencies; Step 3, Tool Launch and Interface Access: Run the app.py file in the toolkit and open the visual operation interface by accessing the specified address through a browser; Step 4, Submit Information Input: Enter specific commit information for multiple Git projects into the text boxes on the interface in the format of "Project Name, Commit ID"; Step 5: Batch time synchronization: Select the target branch and trigger synchronization. The tool will automatically perform batch synchronization according to the rule of "code commits in the same project are sorted by their original time". Step 6, Output the results: The interface displays the commit ID, commit information, changed files, and synchronization status of each project.

2. The method according to claim 1, characterized in that, In step 1, the specified directory is E:\ProjCfg\workspace, and the name of the special toolkit is tools.rar.

3. The method according to claim 1, characterized in that, In step 2, the dependency packages include Flask, render_template, request, and Repo.

4. The method according to claim 1, characterized in that, In step 3, the specified access address is http: / / 127.0.0.1:5000 / , and the visual operation interface supports multiple sets of "project name, submission ID" information input.

5. The method according to claim 1, characterized in that, In step 4, the commit ID can be extracted by taking the first 8 characters of the git commit ID.

6. The method according to claim 1, characterized in that, In step 5, the target branch includes the master branch, and the synchronization process does not require manual intervention in the commit order.

7. The method according to claim 1, characterized in that, In step 6, the synchronization status includes success and failure.

8. A Git multi-project specific commit batch timing synchronization tool for implementing the method of any one of claims 1 to 7, characterized in that, include: Toolkit module: Stores the main app.py program and its dependency files, and provides configuration for project access paths; Environment configuration module: limits the Python 3.7 runtime environment and its dependencies; Interactive interface module: Provides a commit message input text box, target branch selection options, and an execute button, and supports browser access; Synchronization module: Built-in sorting rules and git cherry-pick calling logic to achieve batch synchronization; Results output module: Collects synchronization process information and outputs project name, commit ID, commit information, changed files, and synchronization status.

9. The tool according to claim 8, characterized in that, The synchronous execution module supports at least one Git project, and each project has at least one commit. The tool supports running the app.py file through Sublime Text and PyCharm integration tools.

10. The tool according to claim 8, characterized in that, The sorting rules apply only to multiple submissions within the same project; there are no mandatory restrictions on the synchronization order of submissions from different projects.

Images