CN117687756A - Continuous integration method, device, equipment and computer-readable storage medium - Google Patents

Abstract

A continuous integration method, device, equipment and computer-readable storage medium. The method includes: determining the priority of each task according to the task attributes, the task attributes include branch type, code change mode, trigger type and build type; determining the task processing order in order from high to low priority; based on task processing In order, each task is assigned to the processing node for processing according to the task pipeline. Through this application, the priority of each task is determined according to the task attributes, thereby determining the processing order of each task, so that important tasks can be processed in time.

Description

Continuous integration method, device, equipment and computer-readable storage medium

Technical field

This application relates to the field of software development technology, and specifically to a continuous integration method, device, equipment and computer-readable storage medium.

Background technique

Currently, in the process of software development using continuous integration tools, there is no task scheduling mechanism. Tasks are only executed sequentially according to the creation time point of the task, which results in some important tasks not being processed in time.

Contents of the invention

This application provides a continuous integration method, device, equipment and computer-readable storage medium, which can solve the technical problem in the existing technology that important tasks cannot be processed in time during the software development process using continuous integration tools.

In a first aspect, embodiments of the present application provide a continuous integration method, which includes:

Determine the priority of each task according to the task attributes, which include branch type, code change method, trigger type and build type;

Determine the order of task processing in order from high to low priority;

Based on the task processing sequence, each task is assigned to the processing node for processing according to the task pipeline.

In conjunction with the first aspect, in one implementation, the step of determining the priority of each task according to task attributes includes:

For each task, a first characteristic value is determined according to the branch type, a second characteristic value is determined according to the code change method, a third characteristic value is determined according to the trigger type, and a fourth characteristic value is determined according to the build type;

The first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue are weighted and summed to obtain the priority value;

Among them, the larger the priority value, the higher the priority of the task.

Combined with the first aspect, in one implementation, when the build type of the task is first build or build after failure, for each task, the first characteristic value is determined according to the branch type, and the second characteristic value is determined according to the code change mode. After the steps of determining the characteristic value, determining the third characteristic value according to the trigger type, and determining the fourth characteristic value according to the build type, it also includes:

Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is:

p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄

Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task.

In conjunction with the first aspect, in one embodiment, after the step of sequentially allocating each task to a processing node for processing based on the task processing sequence according to the task pipeline, the method further includes:

Obtain the processing results of each task fed back by the processing node;

For tasks whose processing result is failed, the task failure notification and the contact information of the task leader are sent to the project management server;

Receive the problem ID based on the task failure notification feedback from the project management server, and fill in the task processing log based on the problem ID to the comment area of the project management server, so that the project management server can perform semantic failure on the task processing log to determine the problem category, and based on the Please provide the contact information of the task leader to feedback the problem ID and problem category.

In conjunction with the first aspect, in one embodiment, after the step of obtaining the processing results of each task fed back by the processing node, the method further includes:

For tasks whose processing results are successful, the products corresponding to the tasks are sent to the product management server. The products include test reports and compiled executable files for the product management server to manage the products;

Receive the management information corresponding to the product fed back by the product management server;

Send a task processing success notification and the management information based on the contact information of the task leader.

In the second aspect, embodiments of the present application provide a continuous integration device, which includes:

A priority determination module, used to determine the priority of each task based on task attributes, which include branch type, code change method, trigger type and build type;

The processing sequence determination module is used to determine the task processing sequence in order from high priority to low;

The allocation module is used to allocate each task to the processing node for processing in accordance with the task pipeline based on the task processing sequence.

Combined with the second aspect, in one implementation, the priority determination module is used to:

For each task, a first characteristic value is determined according to the branch type, a second characteristic value is determined according to the code change method, a third characteristic value is determined according to the trigger type, and a fourth characteristic value is determined according to the build type;

The first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue are weighted and summed to obtain the priority value;

Among them, the larger the priority value, the higher the priority of the task.

Combined with the second aspect, in one implementation, when the build type of the task is first build or post-failure build, the priority determination module is used to:

Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is:

p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄

Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task.

In a third aspect, embodiments of the present application provide a continuous integration device. The continuous integration device includes a processor, a memory, and a continuous integration program stored on the memory and executable by the processor, wherein the When the continuous integration program is executed by the processor, the steps of the continuous integration method described in the first aspect are implemented.

In the fourth aspect, embodiments of the present application provide a computer-readable storage medium. A continuous integration program is stored on the computer-readable storage medium. When the continuous integration program is executed by a processor, the implementation as described in the first aspect is implemented. The steps of the continuous integration method described above.

The beneficial effects brought by the technical solutions provided by the embodiments of this application include:

In the embodiment of this application, the priority of each task is determined according to the task attributes; the task processing order is determined in order from high to low priority; based on the task processing order, each task is sequentially assigned to the processing node according to the task pipeline for processing. Through the embodiments of the present application, the priority of each task is determined according to the task attributes, thereby determining the processing order of each task, so that important tasks can be processed in a timely manner.

Description of the drawings

Figure 1 is a schematic flow chart of an embodiment of the continuous integration method of this application;

Figure 2 is a schematic diagram of the software development system architecture in an embodiment;

Figure 3 is a functional module schematic diagram of an embodiment of the continuous integration device of the present application;

Figure 4 is a schematic diagram of the hardware structure of the continuous integration device involved in the embodiment of the present application.

Detailed ways

In order to enable those in the technical field to better understand the solutions of the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are only These are part of the embodiments of this application, but not all of them. Based on the embodiments in this application, all other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of this application.

First, some technical terms in this application are explained to facilitate those skilled in the art to understand this application.

Jenkins is an open source software project. It is a continuous integration tool developed based on Java. It is used to monitor continuous repetitive work. It aims to provide an open and easy-to-use software platform so that software projects can perform continuous integration.

JIRA is a project and issue tracking tool that is widely used in defect tracking, customer service, requirements collection, process approval, task tracking, project tracking and agile management.

In order to make the purpose, technical solutions and advantages of the present application clearer, the embodiments of the present application will be further described in detail below with reference to the accompanying drawings.

In the first aspect, embodiments of the present application provide a continuous integration method.

In one embodiment, refer to FIG. 1 , which is a schematic flow chart of an embodiment of the continuous integration method of the present application. As shown in Figure 1, continuous integration methods include:

Step S10, determine the priority of each task according to the task attributes, which include branch type, code change method, trigger type and build type;

In this embodiment, the execution subject of the continuous integration method is a Jenkins server or a Gitlab server or other servers with the same functions. The following description takes the Jenkins server as an example.

Referring to Figure 2, Figure 2 is a schematic diagram of the software development system architecture in an embodiment. As shown in Figure 2, the code hosting platform is used to implement functions such as change point recording and code version management. Among them, the code hosting platform can be Gitlab, Gitee, etc., which can meet functions such as source code management, code review, change point tracing, and version management.

Taking Gitlab as an example, every time a developer submits a code change point, it will be recorded, including the submitter, code change point, code change description (commit message), etc. For each submission action, Gitlab will automatically assign a randomly generated If the commit ID is not repeated, if code rollback is required, the rollback operation can be performed according to the commit ID. When a certain version of the code is correctly integrated and can be released after passing the test, the corresponding code can be tagged according to the version management specifications defined by the team, and the code to be released can be pushed to the designated branch (usually the master branch) Or release branch, which can be customized according to team specifications). In addition to the code to be released, the code in the development process can also be version controlled through tagging. In order to facilitate the rollback of the code when the integration fails or the build fails, the code can be tagged periodically, such as completed When developing a certain function or module.

There are two ways to generate tasks on the Jenkins server: automatic triggering and scheduled triggering. The Jenkins server continuously monitors the code hosting platform. Through webhook, when code changes occur in the code repository specified on the code hosting platform, the Jenkins task will be triggered; the Jenkins server can set up scheduled execution tasks.

It is easy to understand that if there is only one task on the Jenkins server, there is no need to prioritize. Therefore, when there are at least two tasks on the Jenkins server, determine the priority of each task on the Jenkins server based on the task attributes of each task. priority.

Further, in one embodiment, step S10 includes:

Step S101, for each task, determine the first characteristic value according to the branch type, determine the second characteristic value according to the code change method, determine the third characteristic value according to the trigger type, and determine the fourth characteristic value according to the build type;

In this embodiment, for a task, its branch type is one of hotfixes branch, release branch, develop branch, and other branches; its code change method is one of branch merge and ordinary submission; its trigger type is automatic trigger , one of timing trigger; its build type is one of build after failure and first build.

Among them, the feature value corresponding to the hotfixes branch is g11, the feature value corresponding to the release branch is g12, the feature value corresponding to the develop branch is g13, and the feature value corresponding to other branches is g14, and g11>g12>g13>g14.

The characteristic value corresponding to branch merging is g21, and the characteristic value corresponding to ordinary submission is g22, and g21>g22.

The characteristic value corresponding to automatic triggering is g31, and the characteristic value corresponding to scheduled triggering is g32, and g31>g32.

The characteristic value corresponding to the failed build is g41, and the characteristic value corresponding to the first build is g42, and g41>g42.

If a task's branch type is hotfixes branch, its code change method is branch merge, its trigger type is automatic trigger, and its build type is build after failure, then its first characteristic value is g11, its second characteristic value is g21, The third eigenvalue is g31 and the fourth eigenvalue is g41.

Step S102, perform a weighted sum of the first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue to obtain a priority value;

Among them, the larger the priority value, the higher the priority of the task.

In this embodiment, after determining the first feature value, the second feature value, the third feature value and the fourth feature value of a task, the weight w 1 corresponding to the first feature value and the weight w ₁ corresponding to the second feature value can be determined. The weight w ₂ , the weight w ₃ corresponding to the third eigenvalue, and the weight w ₄ corresponding to the fourth eigenvalue are the weighted sum of the first eigenvalue, the second eigenvalue, the third eigenvalue, and the fourth eigenvalue, thereby obtaining the The priority value of the task. Among them, the weight w ₁ corresponding to the first eigenvalue, the weight w ₂ corresponding to the second eigenvalue, the weight w ₃ corresponding to the third eigenvalue and the weight w ₄ corresponding to the fourth eigenvalue are set according to actual needs.

By analogy, the priority value of each task can be obtained, and the larger the priority value, the higher the priority of the task.

In this embodiment, the priority of each task is determined based on the task attributes, so that more important tasks can be processed first.

Further, in one embodiment, when the construction type of the task is first build or build after failure, after step S101, it also includes:

Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is:

p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄

Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task.

In this embodiment, for example, when the other task attributes of tasks A, B, and C are consistent but only the construction type is inconsistent, task A is built for the first time, and the proportion of task processing failure = 0 at this time; task B is built after failure, and at this time The proportion of task processing failure is 1; task C is built after failure. At this time, the proportion of task processing failure is 0.3, then there are:

The priority value p1 of task A=w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+0)*w ₄ *g ₄ ;

The priority value of task B is p2=w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+1)*w ₄ *g ₄ ;

The priority value of task C is p3=w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+0.3)*w ₄ *g ₄ .

Based on this, the order of task processing is: task B is processed first, then task C, and finally task A, which increases the priority of the task to be rebuilt after failure, making it more likely to be processed first.

In this embodiment, combined with the proportion of task processing failures within the preset time period, the impact of the construction type on the priority is increased, which can make the final task processing order more consistent with the actual situation.

Step S20, determine the task processing order in order from high to low priority;

In this embodiment, the task processing order can be determined in order from high priority to low. For example, if the priority of task 1 > the priority of task 2 > the priority of task 3, then task 1 will be processed first, then task 2, and finally task 3.

Step S30: Based on the task processing sequence, each task is sequentially assigned to the processing node for processing according to the task pipeline.

In this embodiment, for example, the order of task processing is: task 1 is processed first, task 2 is processed next, and task 3 is processed last. Then task 1 is first assigned to the processing node for processing according to the task pipeline, then task 2 is assigned to the processing node for processing according to the task pipeline, and finally task 3 is assigned to the processing node for processing according to the task pipeline.

Continuing to refer to Figure 2, the processing nodes include static scanning nodes, compilation nodes, unit test nodes, etc. The processing node can be an entity server or a container. Among them, the static scanning node, compilation node, unit test node, etc. There can be multiple nodes. The advantage of configuring a Jenkins node is that it implements the master-slave mode. The Jenkins server, as the master node, is only responsible for scheduling and priority calculation. Allocating tasks to processing nodes for execution can improve the concurrency of Jenkins build task execution; if the processing node fails , you can switch other nodes to perform tasks to avoid task failure due to node failure. The image storage server in Figure 2 can also refer to the image warehouse, which stores the required Docker images. Taking the compilation node as an example, if the continuous integration system needs to have both a Windows compilation environment and a Linux compilation environment, the compilation node can perform compilation tasks through The code determines the required compilation environment and pulls the required image resources from the image storage server.

In the embodiment of this application, the priority of each task is determined according to the task attributes; the task processing order is determined in order from high to low priority; based on the task processing order, each task is sequentially assigned to the processing node according to the task pipeline for processing. Through the embodiments of the present application, the priority of each task is determined according to the task attributes, thereby determining the processing order of each task, so that important tasks can be processed in a timely manner.

Further, in one embodiment, after step S30, it also includes:

Obtain the processing results of each task fed back by the processing node; for tasks with a failed processing result, send the task failure notification and the contact information of the task leader to the project management server; receive the problem ID based on the task failure notification feedback from the project management server, and based on The problem ID is filled in the task processing log to the comment area of the project management server, so that the project management server can perform semantic failure on the task processing log to determine the problem category, and feedback the problem ID and problem category based on the contact information of the task leader.

In this embodiment, the Jenkins server sequentially allocates each task to the processing node for processing according to the task pipeline, and the processing node will feed back the processing results of each task to the Jenkins server. When the task build fails (that is, the processing result is a failed task), the project management server will be notified of the build failure and the relevant person responsible for the build will be notified. Among them, the task construction process is the process of processing tasks according to the task pipeline. For example, if a task pipeline is static scanning → compilation → unit testing, the task construction process includes three links: 1. Assign the task to the static scanning node for processing; 2. Assign the task to the compilation node for processing; 3. Assign the task to the compilation node for processing. Assigned to the unit test node for processing. Among them, any failure in processing will be regarded as a task construction failure. It should be noted that the tasks included in the task construction process are defined based on actual needs. In addition to static scanning, compilation, and unit testing, it can also include packaging and release, which is not limited here.

Continuing to refer to Figure 2, the project management server takes the Jira server as an example. The Jira server is a server with Jira software installed as an example. Of course, the project management server can also be a server with other project management software installed, such as PingCode, Worktile, Coding, Tapd, etc.

The project management server creates an issue after receiving the information notified by the Jenkins server, and feeds the issue ID back to the Jenkins server. The Jenkins server backfills the build log and test results according to the issue ID to the comment area of the project management server. Afterwards, the project management server extracts the failure reasons based on the obtained log information and categorizes the problem. The reasons for build failure can be determined by detecting relevant keywords, such as compilation failure, unit test success rate not up to standard, etc. Through reasonable Jenkins script settings, printing the results or failure logs of each build step can help the project management server identify and classify failure causes more quickly and accurately. It can provide certain support for project management, and can also reduce the incidence of similar problems through regular reviews and improve team capabilities. The project management server notifies the relevant responsible persons through the message server via email. The notification content includes the problem ID, problem category, etc.

The above is to complete the creation of the Jira issue. After the relevant personnel receive the reminder to fix the issue, the result of successful re-construction and the corresponding test report are provided. The issue can be closed after manual review and confirmation.

Further, in one embodiment, after the step of obtaining the processing results of each task fed back by the processing node, the method further includes:

For tasks with a successful processing result, the products corresponding to the tasks are sent to the product management server. The products include test reports and compiled executable files for the product management server to manage the products; receive feedback from the product management server corresponding to the products Management information: sending a task processing success notification and the management information based on the contact information of the task leader.

In this embodiment, the product includes an executable file generated by compilation and a test report. Continuing to refer to Figure 2, only when the compilation is successful and the test results meet the quality threshold requirements (that is, the processing result is a successful task), the Jenkins server will send the product corresponding to the task to the product management server for version management. The version is defined according to the team's needs. Customize to ensure that the products in the product management server are qualified and available. After the product enters the product management server and adds the version number, the product management server feeds back the management information corresponding to the product to Jenkins. The management information includes the product's version number, storage location and other information. Finally, Jenkins will notify the person responsible for the build through the message server , the notification content includes the build success result (that is, the task processing success notification) and management information. The management information can be a test report or test report link, the version number of the compiled executable file, and the storage location or link of other products in the product management server. .

Further, referring to Figure 2, the backup server provides two backup mechanisms: real-time backup and periodic backup.

The real-time backup is mainly for the Jenkins server, code hosting platform and product management server. The backup content mainly includes: the configuration files and settings of the Jenkins server, such as build scripts, Jenkins tasks, etc.; all content of the code hosting platform, including source code, code Change records, etc.; all contents of the product management server, etc. The real-time backup occurs every time a change is detected. For example, the creation of a new pipeline, changes to the code warehouse, new products entering the product management server, etc. will trigger real-time backup.

The periodic backup mainly includes: user information of each platform (system), such as account information, user permission settings, etc.; system operation logs, including the pipeline log of the Jenkins server and the system log of the Jenkins server within a period of time. , plug-ins used by the Jenkins server, etc.; the running logs of the automated testing tools deployed on the processing nodes and the system logs of the processing nodes within a period of time, as well as the Docker image used. The backup cycle can be customized.

In a second aspect, embodiments of the present application also provide a continuous integration device.

In one embodiment, refer to FIG. 3 , which is a functional module schematic diagram of an embodiment of the continuous integration device of the present application. As shown in Figure 3, the continuous integration device includes:

The priority determination module 10 is used to determine the priority of each task according to the task attributes, which include branch type, code change mode, trigger type and build type;

The processing sequence determination module 20 is used to determine the task processing sequence in order from high to low priority;

The allocation module 30 is used to sequentially allocate each task to the processing node for processing according to the task pipeline based on the task processing sequence.

Further, in one embodiment, the priority determination module 10 is used to:

For each task, a first characteristic value is determined according to the branch type, a second characteristic value is determined according to the code change method, a third characteristic value is determined according to the trigger type, and a fourth characteristic value is determined according to the build type;

The first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue are weighted and summed to obtain the priority value;

Among them, the larger the priority value, the higher the priority of the task.

Further, in one embodiment, when the construction type of the task is first build or post-failure build, the priority determination module 10 is used to:

Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is:

p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄

Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task.

Further, in one embodiment, the continuous integration device also includes a result feedback module, used for:

Obtain the processing results of each task fed back by the processing node;

For tasks whose processing result is failed, the task failure notification and the contact information of the task leader are sent to the project management server;

Receive the problem ID based on the task failure notification feedback from the project management server, and fill in the task processing log based on the problem ID to the comment area of the project management server, so that the project management server can perform semantic failure on the task processing log to determine the problem category, and based on the Please provide the contact information of the task leader to feedback the problem ID and problem category.

Further, in one embodiment, the continuous integration device also includes a product feedback module for:

For tasks whose processing results are successful, the products corresponding to the tasks are sent to the product management server. The products include test reports and compiled executable files for the product management server to manage the products;

Receive the management information corresponding to the product fed back by the product management server;

Send a task processing success notification and the management information based on the contact information of the task leader.

The functional implementation of each module in the above-mentioned continuous integration device corresponds to each step in the above-mentioned continuous integration method embodiment, and their functions and implementation processes will not be described in detail here.

In the third aspect, embodiments of the present application provide a continuous integration device. The continuous integration device may be a personal computer (PC), a notebook computer, a server, or other devices with data processing functions.

Referring to Figure 4, Figure 4 is a schematic diagram of the hardware structure of the continuous integration device involved in the embodiment of the present application. In this embodiment of the present application, the continuous integration device may include a processor, a memory, a communication interface, and a communication bus.

The communication bus can be of any type and is used to interconnect processors, memories and communication interfaces.

Communication interfaces include input/output (I/O) interfaces, physical interfaces, logical interfaces and other interfaces used to realize device interconnection within continuous integration equipment, as well as interfaces used to realize continuous integration equipment and other equipment (such as other Computing equipment or user equipment) interconnection interface. The physical interface can be an Ethernet interface, an optical fiber interface, an ATM interface, etc.; the user equipment can be a display screen (Display), keyboard (Keyboard), etc.

Memory can be various types of storage media, such as random access memory (RAM), read-only memory (ROM), non-volatile RAM (NVRAM), flash memory, optical memory , hard disk, programmable ROM (PROM), erasable PROM (erasable PROM, EPROM), electrically erasable PROM (electrically erasable PROM, EEPROM), etc.

The processor may be a general-purpose processor, and the general-purpose processor may call the continuous integration program stored in the memory and execute the continuous integration method provided by the embodiment of the present application. For example, the general-purpose processor may be a central processing unit (CPU). For the method executed when the continuous integration program is called, reference can be made to the various embodiments of the continuous integration method of this application, and will not be described again here.

Those skilled in the art can understand that the hardware structure shown in Figure 4 does not limit the present application, and may include more or fewer components than shown, or combine certain components, or arrange different components.

In a fourth aspect, embodiments of the present application further provide a computer-readable storage medium.

The computer-readable storage medium of the present application stores a continuous integration program. When the continuous integration program is executed by the processor, the steps of the continuous integration method as described above are implemented.

For the method implemented when the continuous integration program is executed, reference may be made to various embodiments of the continuous integration method of the present application, which will not be described again here.

It should be noted that the above serial numbers of the embodiments of the present application are only for description and do not represent the advantages and disadvantages of the embodiments.

The terms "including" and "having" and any variations thereof in the description and claims of this application and the above-described drawings are intended to cover non-exclusive inclusion. For example, a process, method, system, product or device that includes a series of steps or units is not limited to the listed steps or units, but optionally also includes steps or units that are not listed, or optionally also includes Other steps or units inherent to such processes, methods, products or devices. The terms "first", "second" and "third" are used to distinguish different objects, etc. They do not represent a sequence, nor do they limit "first", "second" and "third" are different types.

In the description of the embodiments of this application, "exemplary", "such as" or "for example" are used to represent examples, illustrations or explanations. Any embodiment or design described as "exemplary," "such as," or "for example" in the embodiments of the present application is not to be construed as preferred or advantageous over other embodiments or designs. Rather, use of the words "exemplary," "such as," or "for example" is intended to present the concepts in a concrete manner.

In the description of the embodiments of this application, unless otherwise stated, "/" means or, for example, A/B can mean A or B; "and/or" in the text is just a way to describe the association of associated objects. Relationship means that there can be three relationships. For example, A and/or B can mean: A exists alone, A and B exist simultaneously, and B exists alone. In addition, in the description of the embodiment of this application, " "Plural" means two or more than two.

Some of the processes described in the embodiments of this application include multiple operations or steps that appear in a specific order. However, it should be understood that these operations or steps may be performed out of the order in which they appear in the embodiments of this application or in parallel. , the sequence number of the operation is only used to distinguish different operations, the sequence number itself does not represent any execution order. Additionally, these processes may include more or fewer operations, and these operations or steps may be performed sequentially or in parallel, and these operations or steps may be combined.

Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus the necessary general hardware platform. Of course, it can also be implemented by hardware, but in many cases the former is better. implementation. Based on this understanding, the technical solution of the present application can be embodied in the form of a software product that is essentially or contributes to the existing technology. The computer software product is stored in a storage medium (such as ROM/RAM) as mentioned above. , magnetic disk, optical disk), including several instructions to cause a terminal device to execute the methods described in various embodiments of the present application.

The above are only preferred embodiments of the present application, and are not intended to limit the patent scope of the present application. Any equivalent structure or equivalent process transformation made using the contents of the description and drawings of the present application may be directly or indirectly used in other related technical fields. , are all equally included in the patent protection scope of this application.

Claims (10)

1. A continuous integration method, characterized in that the continuous integration method includes: Determine the priority of each task according to the task attributes, which include branch type, code change method, trigger type and build type; Determine the order of task processing in order from high to low priority; Based on the task processing sequence, each task is assigned to the processing node for processing according to the task pipeline. 2. The continuous integration method according to claim 1, wherein the step of determining the priority of each task according to task attributes includes: For each task, a first characteristic value is determined according to the branch type, a second characteristic value is determined according to the code change method, a third characteristic value is determined according to the trigger type, and a fourth characteristic value is determined according to the build type; The first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue are weighted and summed to obtain the priority value; Among them, the larger the priority value, the higher the priority of the task. 3. The continuous integration method according to claim 2, characterized in that when the build type of the task is first build or build after failure, for each task, the first characteristic value is determined according to the branch type, and the first characteristic value is determined according to the code. After the steps of changing the method to determine the second characteristic value, determining the third characteristic value according to the trigger type, and determining the fourth characteristic value according to the construction type, it also includes: Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is: p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄ Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task. 4. The continuous integration method according to claim 1, characterized in that, after the step of sequentially allocating each task to a processing node for processing based on the task processing sequence according to the task pipeline, it also includes: Obtain the processing results of each task fed back by the processing node; For tasks whose processing result is failed, the task failure notification and the contact information of the task leader are sent to the project management server; Receive the problem ID based on the task failure notification feedback from the project management server, and fill in the task processing log based on the problem ID to the comment area of the project management server, so that the project management server can perform semantic failure on the task processing log to determine the problem category, and based on the Please provide the contact information of the task leader to feedback the problem ID and problem category. 5. The continuous integration method according to claim 4, characterized in that, after the step of obtaining the processing results of each task fed back by the processing node, it further includes: For tasks whose processing results are successful, the products corresponding to the tasks are sent to the product management server. The products include test reports and compiled executable files for the product management server to manage the products; Receive the management information corresponding to the product fed back by the product management server; Send a task processing success notification and the management information based on the contact information of the task leader. 6. A continuous integration device, characterized in that the continuous integration device includes: A priority determination module, used to determine the priority of each task based on task attributes, which include branch type, code change method, trigger type and build type; The processing sequence determination module is used to determine the task processing sequence in order from high priority to low; The allocation module is used to allocate each task to the processing node for processing in accordance with the task pipeline based on the task processing sequence. 7. The continuous integration device according to claim 6, wherein the priority determination module is used for: For each task, a first characteristic value is determined according to the branch type, a second characteristic value is determined according to the code change method, a third characteristic value is determined according to the trigger type, and a fourth characteristic value is determined according to the build type; The first eigenvalue, the second eigenvalue, the third eigenvalue and the fourth eigenvalue are weighted and summed to obtain the priority value; Among them, the larger the priority value, the higher the priority of the task. 8. The continuous integration device according to claim 7, wherein when the build type of the task is first build or build after failure, the priority determination module is used to: Substitute the first eigenvalue g ₁ , the second eigenvalue g ₂ , the third eigenvalue g ₃ and the fourth eigenvalue g ₄ into the priority value calculation formula to obtain the priority value p. The weighting formula is: p＝w ₁ *g ₁ +w ₂ *g ₂ +w ₃ *g ₃ +(1+rate)*w ₄ *g ₄ Among them, w ₁ , w ₂ , w ₃ , and w ₄ are weights, and rate is the proportion of task processing failures within the preset time period. The larger the priority value, the higher the priority of the task. 9. A continuous integration device, characterized in that the continuous integration device includes a processor, a memory, and a continuous integration program stored on the memory and executable by the processor, wherein the continuous integration program is When the processor is executed, the steps of the continuous integration method according to any one of claims 1 to 5 are implemented. 10. A computer-readable storage medium, characterized in that a continuous integration program is stored on the computer-readable storage medium, wherein when the continuous integration program is executed by a processor, any one of claims 1 to 5 is implemented. The steps of the continuous integration approach described in Item.