A continuous integration method, device and computer-readable storage medium

Abstract

The present application relates to the technical field of software development, and in particular to a continuous integration method, device, and computer-readable storage medium. The method includes: obtaining updated code for incremental development; obtaining the compilation target of the updated code and other compilation targets that have a dependency relationship with the compilation target of the updated code, performing compilation testing on the obtained compilation target, and caching the compilation results and test results after the compilation test; in one submission action, querying whether other compilation targets that have a dependency relationship with the compilation target of the updated code have been modified; if not, indexing all updated compilation targets and corresponding compilation results in the cache, and merging them into the cache of existing test target results; if so, returning to recompile the updated code. The present application solves the technical problem of low code integration efficiency in existing complex devices when submitting code for compilation testing at one time during software development.

Description

Technical Field

[0001] The present application relates to the technical field of software development, and in particular to a continuous integration method, device, and computer-readable storage medium. Background Art

[0002] In software development, when code needs to be updated, engineers will update the newly updated code to the overall code base through a code submission action. The code submitted in a code submission usually consists of modified codes from different parts.

[0003] Any code change may lead to a decrease in overall code quality and, in turn, cause serious accidents. Therefore, maintaining a high-quality, accurate code base is a very important and challenging task. Continuous Integration (CI / Continues Integration) is a process for automating code development in software engineering. Only code submissions that can be compiled and pass all tests can be merged into the code base. A common scenario is that an engineer submits a code consisting of multiple code modifications to the code base. The code base executes the continuous integration steps to compile, test, and merge the new submissions. Under complex devices, it often faces problems such as low efficiency and time consumption. Summary of the Invention

[0004] To this end, embodiments of the present application provide a continuous integration method, apparatus, and computer-readable storage medium, which can solve the technical problem of low code integration efficiency during software development in existing complex devices, where code is submitted once for compilation and testing. The specific technical solution is as follows:

[0005] In a first aspect, an embodiment of the present application provides a continuous integration method, the method comprising:

[0006] Get updated code for incremental development;

[0007] Obtaining a compilation target of the updated code and other compilation targets having a dependency relationship with the compilation target of the updated code, performing a compilation test on the obtained compilation targets, and caching compilation results and test results after the compilation test;

[0008] In a commit action, check whether other compilation targets that have dependencies with the compilation target of the updated code have been modified; if not, index all updated compilation targets and corresponding compilation results in the cache and merge them into the cache of existing test target results; if so, return to recompile the updated code.

[0009] Preferably, the compiling and testing the acquired compilation target, and caching the compilation results and the test results after the compilation and testing comprises:

[0010] Check whether the compilation target has corresponding compilation results;

[0011] If so, use the corresponding compilation result;

[0012] If not, perform compilation test on the obtained compilation target, and cache the compilation results and test results after compilation test.

[0013] Preferably, the step of checking whether the compilation target has a corresponding compilation result is:

[0014] Check whether the compilation target has a corresponding compilation result by indexing the index value of the related source file of the declared compilation target.

[0015] Preferably, the compilation result includes a cache file, and the compilation result after the cache compilation test includes:

[0016] In a compilation test, data of each step in the compilation test process is cached as a cache file.

[0017] Preferably, for a single cache file, the content of the entire cache file is used as the index, and the link library generated after compiling the cache file is used as the index value.

[0018] Preferably, for all cache files compiled at one time, the contents of all cache files are used as indexes, and the executable files linked to the link libraries of all cache files are used as index values.

[0019] Preferably, the method further comprises:

[0020] Code optimization is performed on the current update code, and the code optimization includes static checking and dynamic checking.

[0021] Preferably, the method further comprises:

[0022] Construct a reviewer relationship tree with a multi-tree structure, divide the code into at least one code file according to the module, each node of the reviewer relationship tree corresponds to a code file, and a file describing the reviewer is stored in the directory corresponding to at least one node of the reviewer relationship tree. In the reviewer relationship tree, child nodes inherit the reviewer of the parent node;

[0023] Each time the code is updated, a recursive query is performed upwards based on the node where the modified code file is located until the corresponding reviewer is found.

[0024] In a second aspect, an embodiment of the present application provides a continuous integration device, comprising:

[0025] Acquisition module, used to obtain updated code for incremental development;

[0026] A step-by-step compilation module is used to obtain a compilation target of the update code and other compilation targets having dependencies with the compilation target of the update code, perform compilation tests on the obtained compilation targets, and cache compilation results and test results after the compilation tests;

[0027] The index module is used to query whether other compilation targets that have dependencies with the compilation target of the updated code have been modified in a submission action; if not, all updated compilation targets and corresponding compilation results in the index cache are merged into the cache of existing test target results; if so, return to recompile the updated code.

[0028] In a third aspect, an embodiment of the present application provides a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of any one of the aforementioned continuous integration methods are implemented.

[0029] In summary, compared with the prior art, the technical solutions provided by the embodiments of the present application have at least the following beneficial effects:

[0030] 1. By performing compilation and testing simultaneously with partial code modifications, the integration tasks are split and compilation and testing of some tasks are moved forward to each modification. This advances the starting point of the process, significantly shortens the waiting time for code submission and merging into the code base, and improves overall efficiency.

[0031] 2. By setting up a reviewer relationship tree, the granularity of the review nodes can be refined. The reviewer relationship tree can quickly locate the reviewer of the modified code file. Even for cross-module development, the corresponding reviewer can be found by scanning the node. BRIEF DESCRIPTION OF THE DRAWINGS

[0032] Figure 1 This is a flowchart of a continuous integration method provided in one embodiment of the present application.

[0033] Figure 2 This is a schematic diagram of the structure of a continuous integration device provided in one embodiment of the present application. DETAILED DESCRIPTION

[0034] This specific embodiment is merely an explanation of the present application and is not a limitation of the present application. After reading this specification, those skilled in the art may make non-creative modifications to the present embodiment as needed, but as long as they are within the scope of the claims of the present application, they are protected by the patent law.

[0035] To make the purpose, technical solutions, and advantages of the embodiments of this application more clear, the technical solutions in the embodiments of this application will be clearly and completely described below in conjunction with the drawings in the embodiments of this application. Obviously, the described embodiments are part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0036] In addition, the term "and / or" in this application is simply a description of the association relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent three situations: A exists alone, A and B exist simultaneously, and B exists alone. In addition, the character " / " in this application, unless otherwise specified, generally indicates that the related objects are in an "or" relationship.

[0037] In this application, the terms "first", "second", etc. are used to distinguish identical or similar items with substantially the same effects and functions. It should be understood that there is no logical or temporal dependency between "first", "second", and "nth", nor is there any limitation on the quantity and execution order.

[0038] In the present application, the term "at least one" means one or more, and the term "plurality" means three or more. For example, a plurality of first positions means three or more first positions.

[0039] After code development, it needs to be compiled, which translates the code into a binary file that can be read by a computer. During code development, multiple code revisions are often submitted in a single commit. After modifying a portion of the code, you need to wait until other portions are modified before compiling and testing all the submitted modifications in a single commit. This can lead to at least the following problems:

[0040] (1) The waiting time for compiling and testing after code modification is long;

[0041] (2) If errors occur during the compilation and testing of part of the code submitted for compilation and testing, it will affect the submission of other correct codes;

[0042] (3) It takes a long time to compile and test all updated codes in one submission.

[0043] The embodiments of the present application are described in further detail below with reference to the accompanying drawings.

[0044] Reference Figure 1 In one embodiment of the present application, a continuous integration method is provided, and the main steps of the method are described as follows:

[0045] S1: Get updated code for incremental development;

[0046] S2: Obtaining a compilation target of the updated code and other compilation targets having a dependency relationship with the compilation target of the updated code, performing a compilation test on the obtained compilation targets, and caching compilation results and test results after the compilation test;

[0047] S5: In a commit action, check whether other compilation targets that have dependencies with the compilation target of the updated code have been modified; if not, index all updated compilation targets and corresponding compilation results in the cache and merge them into the cache of existing test target results; if so, return to recompile the updated code.

[0048] Specifically, in this embodiment, the code development step includes adding external dependencies, implementing the code, and adding corresponding unit tests. Engineers use an incremental development approach during code development, where each modification only modifies a portion of the code logic, ensuring that each modification meets the requirements for compilation and testing.

[0049] Specifically, in this embodiment, each modified code is compiled and tested, and the compilation test is to compile and test the corresponding unit test. The compilation result obtained by the compilation test is a compiled binary file, and the test result is the result of the unit test. The compilation result and the test result are cached. Specifically, in this embodiment, the compilation result and the test result are cached in the server. In other embodiments of this application, they can be cached in other hardware devices with storage functions, which will not be described in detail here.

[0050] Each time the updated code is compiled and tested, the object of each compilation test is set to the pre-declared compilation target and other compilation targets that may have dependencies on the updated code. The compilation target contains metadata such as source file path, dependency path, etc.

[0051] Because different engineers may make modifications to different functional modules during the software development process, in a submission action, it is necessary to first query whether the compilation target that the updated code submitted by the current engineer depends on has been updated by other engineers; if the compilation target that the updated code submitted by the current engineer depends on has not been updated, query the compilation targets and compilation results of all updated codes at this moment to perform code integration, and there is no need to compile and test all submitted codes at one time, thereby improving overall efficiency; if the compilation target that the updated code submitted by the current engineer depends on has been updated, return to the compilation and testing phase of the updated code submitted by the current engineer, obtain all compilation targets that the updated code has dependencies on, re-compile and test, cache the compilation results and test results, and then perform the submission action and subsequent query steps. The setting of this step can reduce the situation where other engineers modify other compilation targets that the current engineer's updated code has dependencies on during the period from the time the current engineer completes the compilation test and caches the compilation test results to the time before submission, resulting in the current engineer submitting content that is not the latest.

[0052] This application solution splits the integration tasks by performing compilation and testing while modifying some codes, and advances the compilation and testing of some tasks to each modification, thus advancing the starting point of the process, greatly shortening the waiting time for code submission and merging into the code base, and improving overall efficiency.

[0053] Optionally, in another embodiment, performing a compilation test on the obtained compilation target, and caching the compilation result and the test result after the compilation test includes:

[0054] S21: Check whether the compilation target has corresponding compilation results;

[0055] S22: If yes, use the corresponding compilation result;

[0056] S23: If not, perform compilation test on the obtained compilation target, and cache the compilation result and test result after the compilation test.

[0057] Specifically, during code compilation, the following may require recompilation:

[0058] 1) Different compilation targets may all depend on a basic compilation target, so this compilation target needs to be compiled multiple times.

[0059] 2) When trying to compile multiple times, the same compilation target was compiled multiple times.

[0060] In this embodiment, a compilation target is pre-declared. Before compiling a target, the server searches for relevant data for all targets to determine whether existing compilation output exists. If so, no compilation test is performed for that target, and the existing compilation result is directly used. Compilation testing is a very time-consuming operation, so before the target is compiled and tested, checking whether a compilation result exists and, if so, reusing the compilation result can significantly improve overall efficiency and reduce resource waste.

[0061] Optionally, in another embodiment, the compilation result includes a cache file, and the compilation result after the cache compilation test is: in one compilation test, the data of each step in the compilation test process is cached as a cache file.

[0062] In actual applications, the compilation and testing process is divided into many steps, such as preprocessing, compilation, linking, etc. In the implementation of the present application, the data of each step is cached. Before the compilation target is compiled and tested, a hierarchical indexing method can be used to index the relevant source files, indexing data of different dimensions to correspond to different steps in the compilation and testing. Through the settings of the implementation of the present application, only the modified code files can be compiled and tested, and the unmodified parts can reuse the previous cached files, subdividing the index granularity, thereby reducing the content of repeated compilation and testing, and further improving the overall efficiency.

[0063] Optionally, in another embodiment, for a single cache file, the content of the entire cache file is used as the index, and the link library generated after compiling the cache file is used as the index value.

[0064] For all cache files compiled at one time, the contents of all cache files are used as indexes, and the executable files linked with the link libraries of all cache files are used as index values.

[0065] Through the configuration of this embodiment, the link library and / or the executable file is used as the index value, thereby realizing fast reading of data and reducing the time for sorting and grouping.

[0066] Optionally, in another embodiment, step S21 is: checking whether the compilation target has a corresponding compilation result by indexing the relevant source files of the declared compilation target.

[0067] By indexing the source files, the location of the compilation target related data can be accurately located to achieve the purpose of accurate search.

[0068] Optionally, in another embodiment, the method further comprises:

[0069] S3: Optimizing the current updated code. The code optimization includes static checking and dynamic checking.

[0070] Specifically, in this embodiment, code inspection can effectively improve code quality. Furthermore, code inspection is not only for improving code quality, but has penetrated into the logic inspection of code programs, memory usage inspection and even higher-level inspection, which greatly affects the function and performance of the program.

[0071] Static checking involves performing syntax analysis of the corresponding programming language on the current code modifications. This allows the discovery of obvious code errors, such as unused variables, unreachable code, and non-portable code, without actually running the code. Static checking can: 1. Help program developers automatically perform static code analysis to quickly locate hidden code errors and defects; 2. Help code designers focus more on analyzing and resolving code design defects; 3. Significantly reduce the time spent on line-by-line code checking, improving software reliability and saving software development and testing costs. In this embodiment, the tool for static checking is cppcheck. In other embodiments of this application, it can also be pc-lint, splint, etc., which are not limited here.

[0072] During dynamic checking, the code is executed and the memory, addresses, and other resources used by the code are analyzed to ensure correct logical operation. Dynamic checking can detect problems that static checking cannot, such as memory leaks, access to uninitialized memory, and thread concurrency issues. In this embodiment, the tools used for dynamic checking can be AddressSanitizer, LeakSanitizer, ThreadSanitizer, MemorySanitizer, etc., without limitation.

[0073] Optionally, in another embodiment, the method further includes: pre-constructing a reviewer relationship tree with a multi-branch tree structure, dividing the code into at least one code file according to the module, each node of the reviewer relationship tree corresponds to a code file, and a file describing the reviewer is stored in the directory corresponding to at least one node of the reviewer relationship tree, and the child node in the reviewer relationship tree inherits the reviewer of the parent node.

[0074] S4: After each code update, recursively query upwards based on the node where the modified code file is located until the corresponding reviewer is found.

[0075] Specifically, during large-scale software development, code modifications often require review by senior engineers. In the current common process, different code modules are manually assigned corresponding responsible persons, and code development is performed within a single module. This approach presents challenges when cross-module development occurs, such as difficulty locating responsible persons, unclear module divisions, and inaccurate review granularity, significantly increasing communication and operational costs.

[0076] In this embodiment, the structure of the reviewer organization is abstracted, that is, a multi-branch tree structure relationship network, that is, a reviewer relationship tree, is established according to the review authority of the reviewer.

[0077] In one example of this embodiment, in a multi-branch tree structure, the reviewer of a parent node includes the permissions of the reviewers of child nodes. The review permissions of child nodes belonging to different parent nodes can be different. In the multi-branch tree structure, a node corresponding to a reviewer can have multiple child nodes. Specifically, in the reviewer relationship tree, each node corresponds to a code file. Files describing the reviewers are stored in directories corresponding to certain nodes in the reviewer relationship tree. In addition, child nodes in the reviewer relationship tree inherit the reviewer of the parent node.

[0078] When the code file of a node on the reviewer relationship tree is modified, a recursive query is performed upward based on the node where the modified code file is located. If a file describing the reviewer is stored in the directory corresponding to the node, the corresponding reviewer is notified; if there is no file describing the reviewer in the directory corresponding to the current node, the parent node of the node is queried until a file describing the reviewer is found, and the corresponding reviewer is notified.

[0079] If it is cross-module development, you can automatically scan the nodes corresponding to the modified code files, find the corresponding reviewers for the modifications of different modules, and automatically notify the reviewers to review.

[0080] Furthermore, in this embodiment, there may be a situation where the queried reviewer does not review the modified code file in time. In this case, the reviewer relationship tree can be recursively queried upward to find the reviewer at the previous level.

[0081] Furthermore, in this embodiment, S2, S3, and S4 are parallel steps, and step S5 is performed only after S2, S3, and S4 are all completed.

[0082] Specifically, before a submission occurs, the updated code that needs to be submitted for integration is checked to see whether there are cached results, whether it has passed static and dynamic checks, and whether a reviewer has been found for review. Only after these three steps can the updated code be submitted for integration with the code base to ensure the accuracy and security of the updated code.

[0083] It should be understood that the size of the serial numbers of the steps in the above embodiments does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0084] Reference Figure 2 In one embodiment of the present application, a continuous integration device is provided, which corresponds one-to-one to the continuous integration method in the above embodiment. The continuous integration device includes:

[0085] Acquisition module, used to obtain updated code for incremental development;

[0086] A step-by-step compilation module is used to obtain a compilation target of the update code and other compilation targets having dependencies with the compilation target of the update code, perform compilation tests on the obtained compilation targets, and cache compilation results and test results after the compilation tests;

[0087] The index module is used to query whether other compilation targets that have dependencies with the compilation target of the updated code have been modified in a submission action; if not, all updated compilation targets and corresponding compilation results in the index cache are merged into the cache of existing test target results; if so, return to recompile the updated code.

[0088] Furthermore, in another embodiment, the compiling and testing the obtained compilation target, and caching the compilation result and the test result after the compilation and testing includes:

[0089] Check whether the compilation target has corresponding compilation results;

[0090] If so, use the corresponding compilation result;

[0091] If not, perform compilation test on the obtained compilation target, and cache the compilation results and test results after compilation test.

[0092] Furthermore, in another embodiment, the compilation result includes a cache file, and the compilation result after the cache compilation test includes:

[0093] In a compilation test, data of each step in the compilation test process is cached as a cache file.

[0094] Furthermore, in another embodiment, for a single cache file, the content of the entire cache file is used as an index, and the link library generated after compiling the cache file is used as the index value.

[0095] Furthermore, in another embodiment, for all cache files compiled at one time, the contents of all cache files are used as indexes, and the executable files linked to the link libraries of all cache files are used as index values.

[0096] Furthermore, in another embodiment, the step of checking whether the compilation target has a corresponding compilation result is:

[0097] Check whether the compilation target has a corresponding compilation result by indexing the index value of the related source file of the declared compilation target.

[0098] Furthermore, in another embodiment, the device further comprises:

[0099] The checking module is used to perform code optimization on the current update code, wherein the code optimization includes static checking and dynamic checking.

[0100] Furthermore, in another embodiment, the device further comprises:

[0101] A reviewer relationship construction module is used to construct a reviewer relationship tree with a multi-tree structure. The code is divided into at least one code file according to the module. Each node of the reviewer relationship tree corresponds to a code file. The directory corresponding to at least one node of the reviewer relationship tree stores a file describing the reviewer. In the reviewer relationship tree, child nodes inherit the reviewer of the parent node.

[0102] The query module is used to recursively query upwards according to the node where the modified code file is located after each code update until the corresponding reviewer is found.

[0103] Each module of the continuous integration device described above can be implemented in whole or in part through software, hardware, or a combination thereof. Each module can be embedded in or independent of a processor in a computer device in hardware form, or can be stored in a computer device memory in software form, so that the processor can call and execute the corresponding operations of each module.

[0104] In one embodiment of the present application, a computer device is provided, which may be a server. The computer device includes a processor, memory, and a network interface connected via a device bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device can be implemented by any type of volatile or non-volatile storage device, or a combination thereof. Volatile or non-volatile storage devices include, but are not limited to, magnetic disks, optical disks, EEPROM (Electrically Erasable Programmable Read Only Memory), EPROM (Erasable Programmable Read Only Memory), SRAM (Static Random Access Memory), ROM (Read-Only Memory), magnetic storage, flash memory, and PROM (Programmable Read-Only Memory). The memory of the computer device provides an environment for the operation of the operating device and computer program stored therein. The network interface of the computer device is used to communicate with an external terminal via a network connection. When executed by the processor, the computer program implements the steps of the continuous integration method described in the above embodiment.

[0105] In one embodiment of the present application, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the computer-readable storage medium implements the continuous integration method steps described in the above embodiment. The computer-readable storage medium includes ROM (Read-Only Memory), RAM (Random-Access Memory), CD-ROM (Compact Disc Read-Only Memory), magnetic disk, floppy disk, etc.

[0106] Those skilled in the art will clearly understand that for the sake of convenience and conciseness of description, the division of the above-mentioned functional units and modules is only used as an example. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the device described in this application is divided into different functional units or modules to complete all or part of the functions described above.

Claims

1. A continuous integration method, characterized in that: The method comprises: Get updated code for incremental development; Obtaining a compilation target of the updated code and other compilation targets having a dependency relationship with the compilation target of the updated code, performing a compilation test on the obtained compilation targets, and caching compilation results and test results after the compilation test; In a commit action, check whether other compilation targets that have dependencies on the compilation target of the updated code have been modified; if not, index all updated compilation targets and corresponding compilation results in the cache and merge them into the cache of existing test target results; if yes, return to recompile the updated code; Construct a reviewer relationship tree with a multi-tree structure, divide the code into at least one code file according to the module, each node of the reviewer relationship tree corresponds to a code file, and a file describing the reviewer is stored in the directory corresponding to at least one node of the reviewer relationship tree. In the reviewer relationship tree, child nodes inherit the reviewer of the parent node; Each time the code is updated, a recursive query is performed upwards based on the node where the modified code file is located until the corresponding reviewer is found.

2. The continuous integration method according to claim 1, characterized in that The compiling and testing of the obtained compiling target and caching the compiling and testing results after the compiling and testing include: Check whether the compilation target has corresponding compilation results; If so, use the corresponding compilation result; If not, perform compilation test on the obtained compilation target, and cache the compilation results and test results after compilation test.

3. The continuous integration method according to claim 2, characterized in that The compilation result includes a cache file, and the compilation result after the cache compilation test includes: In a compilation test, data of each step in the compilation test process is cached as a cache file.

4. The continuous integration method according to claim 3, characterized in that For a single cache file, the content of the entire cache file is used as the index, and the link library generated after compiling the cache file is used as the index value.

5. The continuous integration method according to claim 4, characterized in that: For all cache files compiled at one time, the contents of all cache files are used as indexes, and the executable files linked with the link libraries of all cache files are used as index values.

6. The continuous integration method according to claim 5, characterized in that: The check to see if the compilation target has the corresponding compilation result is: Check whether the compilation target has a corresponding compilation result by indexing the index value of the related source file of the declared compilation target.

7. The continuous integration method according to claim 1, characterized in that: The method further comprises: Code optimization is performed on the current update code, and the code optimization includes static checking and dynamic checking.

8. A continuous integration device, characterized in that: The device comprises: Acquisition module, used to obtain updated code for incremental development; A step-by-step compilation module is used to obtain a compilation target of the update code and other compilation targets having dependencies with the compilation target of the update code, perform compilation tests on the obtained compilation targets, and cache compilation results and test results after the compilation tests; An indexing module is used to query, during a commit action, whether other compilation targets that have dependencies on the compilation target of the updated code have been modified; if not, all updated compilation targets and corresponding compilation results in the index cache are merged into the cache of existing test target results; if yes, return to recompile the updated code; A reviewer relationship construction module is used to construct a reviewer relationship tree with a multi-tree structure. The code is divided into at least one code file according to the module. Each node of the reviewer relationship tree corresponds to a code file. The directory corresponding to at least one node of the reviewer relationship tree stores a file describing the reviewer. In the reviewer relationship tree, child nodes inherit the reviewer of the parent node. The query module is used to recursively query upwards according to the node where the modified code file is located after each code update until the corresponding reviewer is found.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of the continuous integration method according to any one of claims 1 to 7 are implemented.

Images