CN111090436B - Jenkins compiling result summarizing method, device and equipment - Google Patents
Jenkins compiling result summarizing method, device and equipment Download PDFInfo
- Publication number
- CN111090436B CN111090436B CN201911332528.8A CN201911332528A CN111090436B CN 111090436 B CN111090436 B CN 111090436B CN 201911332528 A CN201911332528 A CN 201911332528A CN 111090436 B CN111090436 B CN 111090436B
- Authority
- CN
- China
- Prior art keywords
- target
- result
- jenkins
- compiling result
- compiling
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 33
- 238000013515 script Methods 0.000 claims abstract description 57
- 238000004590 computer program Methods 0.000 claims description 10
- 230000008676 import Effects 0.000 claims description 9
- 230000000694 effects Effects 0.000 abstract description 3
- 238000010586 diagram Methods 0.000 description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000010354 integration Effects 0.000 description 2
- 230000006978 adaptation Effects 0.000 description 1
- 238000004883 computer application Methods 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000002054 transplantation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
Abstract
The invention discloses a method for summarizing Jenkins compiling results, which comprises the following steps: analyzing the received Jenkins compiling result summarizing request to obtain each target compiling result keyword of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, executing the modified compiling result collecting script to perform compiling result collecting operation on the target item, and obtaining a target item compiling result; and outputting a target item compiling result. By applying the technical scheme provided by the embodiment of the invention, the project compiling result viewing efficiency is greatly improved, and the error rate is greatly reduced. The invention also discloses a Jenkins compilation result summarizing device, equipment and a storage medium, and the Jenkins compilation result summarizing device, the equipment and the storage medium have corresponding technical effects.
Description
Technical Field
The invention relates to the technical field of computer application, in particular to a Jenkins compiling result summarizing method, device and equipment and a computer readable storage medium.
Background
Jenkins is an open source software project, is a continuous integration tool developed based on Java, is used for monitoring continuous and repeated work, and aims to provide an open and easy-to-use software platform to enable continuous integration of software. Jenkins can manage the automatic compilation of many items that can be compiled after downloading code from its own specified version library. And the user checks the compiling result, such as the compiling number obtained by automatically compiling the project by utilizing Jenkins, some information finally input into the version library and the like, according to the requirement.
The existing mode of viewing the automatic compiling result of the project by using Jenkins is that a user manually opens each content in the compiling result of each project to view one by one. If the Jenkins are managed in a large number of projects, a manual one-by-one checking method is adopted, checking efficiency is low, and errors are prone to occurring.
In summary, how to effectively solve the problems of low viewing efficiency, easy error, high requirement on the program editing capability of a user and the like in the existing compiling result viewing mode is a problem that needs to be solved urgently by a person skilled in the art at present.
Disclosure of Invention
The invention aims to provide a Jenkins compiling result summarizing method, which greatly improves the project compiling result viewing efficiency and greatly reduces the error rate; another object of the present invention is to provide a Jenkins compilation result summarizing device, apparatus and computer readable storage medium.
In order to solve the technical problems, the invention provides the following technical scheme:
a Jenkins compilation result summarizing method comprises the following steps:
analyzing the received Jenkins compiling result summarizing request to obtain target compiling result keywords of the target item corresponding to the Jenkins compiling result summarizing request;
modifying preset compiling result collecting scripts according to the target compiling result keywords, and executing the modified compiling result collecting scripts to perform compiling result collecting operations on the target items to obtain target item compiling results;
and outputting the target item compiling result.
In a specific embodiment of the present invention, parsing a received Jenkins compilation result summary request to obtain target compilation result keywords of a target item corresponding to the Jenkins compilation result summary request includes:
analyzing the received Jenkins compiling result summarizing request to obtain a target data driving file of a target item corresponding to the Jenkins compiling result summarizing request; the target data driving file comprises a target project name, target project responsible person information and a target version library type;
modifying the preset compiling result collecting script according to each target compiling result keyword, executing the modified compiling result collecting script to carry out compiling result collecting operation on the target item, and obtaining a target item compiling result, wherein the method comprises the following steps:
determining a target script execution path according to the target project name and the target project responsible person information in the target data driving file;
determining a target import version library according to the type of the target version library in the target data driving file;
and executing a preset compiling result collection script to carry out compiling result collection operation on the target project according to the target script execution path and the target merging version library to obtain the compiling result of the target project.
In an embodiment of the present invention, outputting the target item compilation result includes:
and outputting the library version number in the target project compiling result according to a target version number format corresponding to the target merging version library.
In an embodiment of the present invention, outputting the target item compilation result includes:
and outputting the compiling result of the target item in a preset Jenkins compiling result summary table mode.
A Jenkins compilation result summarizing device comprises:
the request analysis module is used for analyzing the received Jenkins compiling result summarizing request to obtain each target compiling result keyword of the target item corresponding to the Jenkins compiling result summarizing request;
the compiling result obtaining module is used for modifying a preset compiling result collecting script according to each target compiling result keyword and executing the modified compiling result collecting script to carry out compiling result collecting operation on the target item to obtain a target item compiling result;
and the compiling result output module is used for outputting the compiling result of the target item.
In a specific embodiment of the present invention, the request parsing module is a module that parses a received Jenkins compilation result summarizing request to obtain a target data driver file of a target item corresponding to the Jenkins compilation result summarizing request; the target data driving file comprises a target project name, target project responsible person information and a target version library type;
the compiling result obtaining module comprises:
the path obtaining submodule is used for determining a target script execution path according to the target project name and the target project responsible person information in the target data driving file;
the version library determining submodule is used for determining a target merging version library according to the type of the target version library in the target data driving file;
and the compiling result obtaining sub-module is used for executing a preset compiling result collecting script to carry out compiling result collecting operation on the target project according to the target script execution path and the target merging version library to obtain the compiling result of the target project.
In a specific embodiment of the present invention, the compiling result output module is a module that outputs the library version number in the target item compiling result according to a target version number format corresponding to the target merge version library.
In a specific embodiment of the present invention, the compiling result output module is a module that outputs the compiling result of the target item in a form of a preset Jenkins compiling result summary table.
A Jenkins compilation result summarizing device comprising:
a memory for storing a computer program;
and the processor is used for realizing the steps of the Jenkins compiling result summarizing method when the computer program is executed.
A computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the Jenkins compilation result summarization method as previously described.
Analyzing the received Jenkins compiling result summarizing request by applying the method provided by the embodiment of the invention to obtain each target compiling result keyword of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result; and outputting a target item compiling result. The compiling result collection script is used for automatically summarizing the target item compiling results of the target items, and compared with the existing mode that each content in the compiling results of each item is manually checked one by a user, the compiling result checking efficiency of the items is greatly improved, and the error rate is greatly reduced.
Correspondingly, embodiments of the present invention further provide a Jenkins compilation result summarizing device, equipment, and a computer-readable storage medium corresponding to the Jenkins compilation result summarizing method, which have the above technical effects and are not described herein again.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts.
FIG. 1 is a flowchart illustrating an implementation of a method for summarizing Jenkins compilation results according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating another embodiment of a method for summarizing Jenkins compilation results according to the present invention;
FIG. 3 is a block diagram illustrating a Jenkins compilation result summarizing device according to an embodiment of the present invention;
fig. 4 is a block diagram of a Jenkins compilation result summarizing device according to an embodiment of the present invention.
Detailed Description
In order that those skilled in the art will better understand the disclosure, the invention will be described in further detail with reference to the accompanying drawings and specific embodiments. It is to be understood that the described embodiments are merely exemplary of the invention, and not restrictive of the full scope of the invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
The first embodiment is as follows:
referring to fig. 1, fig. 1 is a flowchart illustrating an implementation of a method for summarizing Jenkins compilation results according to an embodiment of the present invention, where the method may include the following steps:
s101: analyzing the received Jenkins compiling result summarizing request to obtain target compiling result keywords of the target item corresponding to the Jenkins compiling result summarizing request.
When the compiling result of a certain project realized by Jenkins automatic compiling needs to be summarized, a Jenkins compiling result summarizing request can be sent to a Jenkins compiling result summarizing center, and the Jenkins compiling result summarizing request comprises target compiling result keywords of corresponding target projects, such as project names, project principal information, project version library types, last compiling numbers, last compiling results, last compiling failure numbers, last compiling success numbers, version numbers of last incorporated version libraries, last incorporated code personnel names and other keywords. And the Jenkins compiling result summarizing center receives the Jenkins compiling result summarizing request, analyzes the Jenkins compiling result summarizing request and obtains target compiling result keywords of the target item corresponding to the Jenkins compiling result summarizing request.
S102: and modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result.
Compiling result collection scripts for compiling results of certain types of items can be compiled in advance, after target compiling result keywords of target items corresponding to Jenkins compiling result summarizing requests are obtained through analysis, modification operations can be performed on the preset compiling result collection scripts according to the target compiling result keywords, for example, the version numbers of item version libraries in the preset compiling result collection scripts are modified, so that compiling result collection scripts corresponding to the target item compiling results needing summarizing of the target items are obtained, and compiling result collection operations are performed on the target items through the modified compiling result collection scripts, so that the target item compiling results are obtained.
S103: and outputting a target item compiling result.
And after the modified compiling result collecting script is executed to carry out compiling result collecting operation on the target item, and the compiling result of the target item is output after the compiling result of the target item is obtained. Therefore, automatic summarization of the target project compiling results of the target projects is achieved, a user does not need to manually check compiling result contents corresponding to certain compiling result keywords one by one, project compiling result checking efficiency is greatly improved, and error rate is greatly reduced.
Analyzing the received Jenkins compiling result summarizing request by applying the method provided by the embodiment of the invention to obtain each target compiling result keyword of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result; and outputting a target item compiling result. The compiling result collection script is used for automatically summarizing the target item compiling results of the target items, and compared with the existing mode that each content in the compiling results of each item is manually checked one by a user, the compiling result checking efficiency of the items is greatly improved, and the error rate is greatly reduced.
It should be noted that, based on the first embodiment, the embodiment of the present invention further provides a corresponding improvement scheme. In the following embodiments, steps that are the same as or correspond to those in the first embodiment may be referred to each other, and corresponding advantageous effects may also be referred to each other, which are not described in detail in the following modified embodiments.
Example two:
referring to fig. 2, fig. 2 is a flowchart of another implementation of a method for summarizing Jenkins compilation results in an embodiment of the present invention, where the method may include the following steps:
s201: analyzing the received Jenkins compilation result summarizing request to obtain a target data drive file of the target item corresponding to the Jenkins compilation result summarizing request.
The target data driving file comprises a target project name taskName, a target project responsible person information owner and a target version library type repository.
Only minor differences exist in the compilation result collection scripts required for the compilation of project results for different projects in a certain class of projects, namely, differences exist only in the target project name, target project principal information, and target version library type. Therefore, after receiving the Jenkins compilation result summarizing request, the target data drive file including the target project name, the target project principal information and the target version library type only needs to be analyzed from the Jenkins compilation result summarizing request.
S202: and determining an execution path of the target script according to the target project name and the target project responsible person information in the target data driving file.
Because different project names and project responsible person information correspond to different script execution paths, after the target data drive file comprising the target project name, the target project responsible person information and the target version library type is obtained through analysis, the target script execution path can be determined according to the target project name and the target project responsible person information in the target data drive file.
S203: and determining a target merging version library according to the type of the target version library in the target data driving file.
The version library types related to the project compiling result summarization generally comprise an svn version library and a git version library, and after a target data driving file comprising a target project name, target project principal information and a target version library type is obtained through analysis, a target import version library can be determined according to the target version library type in the target data driving file.
svn is an abbreviation of subversion, is a version control system of an open source code, and is used for realizing shared resources and finally centralized management by adopting efficient management of a branch management system, namely jointly developing the same project by a plurality of persons.
git is an open source distributed version control system that can handle very small to very large project version management efficiently and at high speed.
S204: and according to the target script execution path and the target merging version library, executing a preset compiling result collection script to carry out compiling result collection operation on the target item to obtain a target item compiling result.
The unified compiling result collecting script can be compiled according to compiling result summary contents corresponding to other compiling result keywords except for the target project name, the target project responsible person information and the target version library type which are changed according to different projects. After the target script execution path and the target import version library are obtained, a preset compiling result collection script is executed to carry out compiling result collection operation on the target item according to the target script execution path and the target import version library to obtain a target item compiling result. Therefore, adaptation application of different projects can be quickly realized only by modifying the data driving file without modifying the script, quick transplantation of different projects is facilitated, and the requirement on the program editing capacity of a user is lowered.
S205: and outputting the compiling result of the target item in a preset Jenkins compiling result summary table mode.
A Jenkins compilation result summary table can be preset, and after the target project compilation result is obtained, the target project compilation result can be output in a preset Jenkins compilation result summary table mode.
In one embodiment of the present invention, outputting the target item compilation result includes:
and outputting the library version number in the target project compiling result according to a target version number format corresponding to the target merging version library.
The target project compiling result comprises a library version number, and the library version number in the target project compiling result can be output according to a target version number format corresponding to the target import version library after the target project compiling result is obtained because the formats displayed by the version numbers of the git library code and the svn library code are different.
In a specific example application, see table 1, where table 1 includes data driver files corresponding to a plurality of items, that is, taskanme _ owner.
TABLE 1
| taskName | ower | repository |
| taskName1 | Andy | git |
| taskName2 | Frank | svn |
| … | … | … |
| taskNameN | Tina | git |
the taskName _ owner.csv file is used as a test input file and describes all project names, project principal information and version base types of the Jenkins, wherein the project names, the project principal information and the version base types need to summarize project compiling results currently.
As shown in Table 2, line 2 in the csv file indicates that the task name of the item in Jenkins is tasName 1, the responsible person of the item is Andy, and the code of the item is stored in the git library. The 3 rd row in the csv file indicates that the task name of the project in Jenkins is tasName 2, the project responsible person of the project is rank, and the code of the project is stored in the svn library.
According to the input file taskName _ owner.csv, the following automatic information collection is carried out line by line:
1) splicing a path url recording the overall compiling result page of the project by using the task name taskName;
allurl＝”http://x.x.x.x:x/jenkins/job/$taskName/api/json”
2) capturing the content of url in the step 1) by using a curl command, and storing the content in an all.
Curl–X GET$allurl–user$jenkins_user:$jenkins_password>all.json
3) Json looks up the number following the lastdial string from the all.json file, which is the last compilation number lastdial number;
substring＝`cat all.json|grep-Po'(lastBuild.*)'`
lastBuildnumber＝`echo$substring|grep-Po'(？<＝number":)[0-9]+'|sed-n'1p'`
4) searching a number behind a last compiling failure number lastFaildBunild character string from an all.json file, wherein the number is lastFaildBunild;
substring＝`cat all.json|grep-Po'(lastFailedBuild.*)'`
lastFailedBuild＝`echo$substring|grep-Po'(？<＝number":)[0-9]+'|sed-n'1p'`
5) searching a number behind a last compiling success number lastsuccess built character string from an all.
substring＝`cat all.json|grep-Po'(lastSuccessfulBuild.*)'`
lastSuccessfulBuildnumber＝`echo$substring|grep-Po'(？<＝number":)[0-9]+'|sed-n'1p'`
6) Splicing the url of the last compiling result page by using the taskname and the lastboldnumber;
lastBuildurl＝"http://
x.x.x.x:x/jenkins/job/$taskname/$lastBuildnumber/api/json"
7) grabbing the content of url in step 6 by using a curl command, and storing the content in lastpointer.
curl-X GET$lastBuildurl--user
$jenkins_user:$jenkins_password>lastBuild.json
8) Json looks up the display behind the result character, which is the result of the last compilation (SUCCESS or FAILURE);
result＝`cat lastBuild.json|grep-Po'(？<＝result":")[A-Za-z]+'`
9) searching numbers behind last-time-merged svn/git version number revision characters from lastbuild.json, namely the version number compiled at the last time, and because the formats of the version numbers of the git library and svn library codes displayed in lastbuild.json are different, the two libraries need to be separately analyzed;
if (code use svn library)
{
revision＝`cat lastBuild.json|grep-Po'(？<＝revision":)[0-9]+'|sed-n'1p'`
}
else if (code use git library)
{
substring＝`cat lastBuild.json|grep-Po'(？<＝revision":).*+'|sed-n'1p'`
revision＝`echo$substring|grep-Po'(？<＝:")[0-9a-z]+'|sed-n'1p'`
}
10) Json searches for the number following the commit id character, which is the version number of the last incorporated code;
commitId＝`cat lastBuild.json|grep-Po'(？<＝commitId":")[0-9a-z]+'|sed-n'1p'`
11) json searches for the number following the fuslname character of the person name who entered the code last time, namely the person name who entered the code last time;
fullName＝`cat lastBuild.json|grep-Po'(？<＝fullName":")[A-Za-z]+'|sed-n'1p'`
as shown in table 2, the compiling results of the above items are summarized respectively.
TABLE 2
Corresponding to the above method embodiment, the embodiment of the present invention further provides a Jenkins compilation result summarizing device, and the Jenkins compilation result summarizing device described below and the Jenkins compilation result summarizing method described above may be referred to each other correspondingly.
Referring to fig. 3, fig. 3 is a block diagram of a Jenkins compilation result summarizing device in an embodiment of the present invention, where the device may include:
the request analysis module 31 is configured to analyze the received Jenkins compilation result summary request to obtain target compilation result keywords of the target item corresponding to the Jenkins compilation result summary request;
a compiling result obtaining module 32, configured to modify the preset compiling result collecting script according to each target compiling result keyword, and execute the modified compiling result collecting script to perform compiling result collecting operation on the target item, so as to obtain a target item compiling result;
and a compiling result output module 33 for outputting the compiling result of the target item.
Analyzing the received Jenkins compiling result summarizing request by applying the method provided by the embodiment of the invention to obtain each target compiling result keyword of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result; and outputting a target item compiling result. The compiling result collection script is used for automatically summarizing the target item compiling results of the target items, and compared with the existing mode that each content in the compiling results of each item is manually checked one by a user, the compiling result checking efficiency of the items is greatly improved, and the error rate is greatly reduced.
In a specific embodiment of the present invention, the request parsing module 31 is a module that parses the received Jenkins compilation result summarizing request to obtain a target data driver file of a target item corresponding to the Jenkins compilation result summarizing request; the target data driving file comprises a target project name, target project responsible person information and a target version library type;
the compilation result obtaining module 32 includes:
the path obtaining submodule is used for determining a target script execution path according to the target project name and the target project responsible person information in the target data driving file;
the version base determining submodule is used for determining a target merging version base according to the type of the target version base in the target data driving file;
and the compiling result obtaining submodule is used for inputting the target script execution path and the target into the version library, executing a preset compiling result collecting script and carrying out compiling result collecting operation on the target item to obtain a target item compiling result.
In a specific embodiment of the present invention, the compiling result output module 33 is a module that outputs the library version number in the target item compiling result according to a target version number format corresponding to the target import version library.
In an embodiment of the present invention, the compiling result output module 33 is a module that outputs the compiling result of the target item in a form of a preset Jenkins compiling result summary table.
Corresponding to the above method embodiment, referring to fig. 4, fig. 4 is a schematic diagram of a Jenkins compilation result summarizing device provided by the present invention, where the device may include:
a memory 41 for storing a computer program;
the processor 42, when executing the computer program stored in the memory 41, may implement the following steps:
analyzing the received Jenkins compiling result summarizing request to obtain target compiling result keywords of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result; and outputting a target item compiling result.
For the introduction of the device provided by the present invention, please refer to the above method embodiment, which is not described herein again.
Corresponding to the above method embodiment, the present invention further provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, can implement the following steps:
analyzing the received Jenkins compiling result summarizing request to obtain target compiling result keywords of the target item corresponding to the Jenkins compiling result summarizing request; modifying the preset compiling result collecting script according to each target compiling result keyword, and executing the modified compiling result collecting script to perform compiling result collecting operation on the target item to obtain a target item compiling result; and outputting a target item compiling result.
The computer-readable storage medium may include: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.
For the introduction of the computer-readable storage medium provided by the present invention, please refer to the above method embodiments, which are not described herein again.
The embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same or similar parts among the embodiments are referred to each other. The device, the apparatus and the computer-readable storage medium disclosed in the embodiments correspond to the method disclosed in the embodiments, so that the description is simple, and the relevant points can be referred to the description of the method.
The principle and the implementation of the present invention are explained in the present application by using specific examples, and the above description of the embodiments is only used to help understanding the technical solution and the core idea of the present invention. It should be noted that, for those skilled in the art, it is possible to make various improvements and modifications to the present invention without departing from the principle of the present invention, and those improvements and modifications also fall within the scope of the claims of the present invention.
Claims (8)
1. A Jenkins compilation result summarizing method is characterized by comprising the following steps:
analyzing the received Jenkins compiling result summarizing request to obtain a target data driving file of a target item corresponding to the Jenkins compiling result summarizing request; the target data driving file comprises a target project name, target project responsible person information and a target version library type;
determining a target script execution path according to the target project name and the target project responsible person information in the target data driving file;
determining a target import version library according to the type of the target version library in the target data drive file;
according to the target script execution path and the target merging version library, executing a preset compiling result collection script to carry out compiling result collection operation on the target project to obtain a target project compiling result;
and outputting the target item compiling result.
2. The method of claim 1, wherein outputting the target item compilation result comprises:
and outputting the library version number in the target project compiling result according to a target version number format corresponding to the target merging version library.
3. The method for summarizing Jenkins compilation results according to any one of claims 1 to 2, wherein outputting the target item compilation result comprises:
and outputting the compiling result of the target item in a preset Jenkins compiling result summary table mode.
4. A Jenkins compiling result summarizing device is characterized by comprising:
the request analysis module is used for analyzing the received Jenkins compilation result summarizing request to obtain a target data driving file of a target item corresponding to the Jenkins compilation result summarizing request; the target data driving file comprises a target project name, target project responsible person information and a target version library type;
a compiling result obtaining module for determining a target script execution path according to the target project name and the target project responsible person information in the target data driving file; determining a target import version library according to the type of the target version library in the target data driving file; according to the target script execution path and the target merging version library, executing a preset compiling result collection script to carry out compiling result collection operation on the target project to obtain a target project compiling result;
and the compiling result output module is used for outputting the compiling result of the target item.
5. The Jenkins compilation result summarizing device according to claim 4, wherein the compilation result output module is specifically a module that outputs a library version number in the target item compilation result according to a target version number format corresponding to the target import version library.
6. The Jenkins compilation result summarizing device according to any one of claims 4 to 5, wherein the compilation result outputting module is a module that outputs the compilation result of the target item in a form of a preset Jenkins compilation result summary table.
7. A Jenkins compilation result summarizing device, comprising:
a memory for storing a computer program;
a processor for implementing the steps of the Jenkins compilation result summarizing method as claimed in any one of claims 1 to 3 when executing said computer program.
8. A computer-readable storage medium, having stored thereon a computer program which, when executed by a processor, performs the steps of the Jenkins compilation result summarization method according to any one of claims 1 to 3.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911332528.8A CN111090436B (en) | 2019-12-22 | 2019-12-22 | Jenkins compiling result summarizing method, device and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911332528.8A CN111090436B (en) | 2019-12-22 | 2019-12-22 | Jenkins compiling result summarizing method, device and equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111090436A CN111090436A (en) | 2020-05-01 |
| CN111090436B true CN111090436B (en) | 2022-05-10 |
Family
ID=70395467
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911332528.8A Active CN111090436B (en) | 2019-12-22 | 2019-12-22 | Jenkins compiling result summarizing method, device and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111090436B (en) |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104375937A (en) * | 2014-11-19 | 2015-02-25 | 福建亿榕信息技术有限公司 | Continuous integration method and system of automated testing results |
| CN110489126B (en) * | 2019-08-08 | 2021-09-10 | 腾讯科技（深圳）有限公司 | Compiling task execution method and device, storage medium and electronic device |
| CN110597721A (en) * | 2019-09-11 | 2019-12-20 | 四川长虹电器股份有限公司 | Automatic interface pressure testing method based on pressure testing script |
-
2019
- 2019-12-22 CN CN201911332528.8A patent/CN111090436B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN111090436A (en) | 2020-05-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9256582B2 (en) | Conversion of a presentation to Darwin Information Typing Architecture (DITA) | |
| US7490167B2 (en) | System and method for platform and language-independent development and delivery of page-based content | |
| US9092443B2 (en) | Dynamic generation of target files from template files and tracking of the processing of target files | |
| US20080162542A1 (en) | Dynamic generation of target files from template files and tracking of the processing of target files | |
| CN101171571A (en) | Apparatus for analysing and organizing artifacts in a software application | |
| US11593342B2 (en) | Systems and methods for database orientation transformation | |
| US7305629B2 (en) | Consolidation of computer documentation | |
| US9928288B2 (en) | Automatic modeling of column and pivot table layout tabular data | |
| US20020078071A1 (en) | Comment driven processing | |
| AU2009238294A1 (en) | Data transformation based on a technical design document | |
| CN112035443B (en) | Big data execution method, system, equipment and storage medium based on Linux platform | |
| US20230021259A1 (en) | Methods and systems for building search service application | |
| JP2012113706A (en) | Computer-implemented method, computer program, and data processing system for optimizing database query | |
| CN113971037A (en) | Application processing method and device, electronic equipment and storage medium | |
| US7530075B2 (en) | System and method for employing object-based pipelines | |
| CN108319466A (en) | A kind of restoration methods and device of configuration information | |
| CN110716804A (en) | Method and device for automatically deleting useless resources, storage medium and electronic equipment | |
| CN114003269A (en) | Component processing method and device, electronic equipment and storage medium | |
| CN111414168B (en) | Web application development method and device based on mind map and electronic equipment | |
| CN113377342B (en) | Project construction method and device, electronic equipment and storage medium | |
| CN111090436B (en) | Jenkins compiling result summarizing method, device and equipment | |
| CN112181410A (en) | View layer code generation method and device, electronic equipment and storage medium | |
| CN115759029A (en) | Document template processing method and device, electronic equipment and storage medium | |
| CN112699011A (en) | Method and device for counting incremental code coverage rate, electronic equipment and storage medium | |
| CN111125063A (en) | Method and device for rapidly verifying data migration among clusters |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |