CN112527382A - Method for deploying pipeline engine system, method and device for continuous integration - Google Patents
Method for deploying pipeline engine system, method and device for continuous integration Download PDFInfo
- Publication number
- CN112527382A CN112527382A CN202011472000.3A CN202011472000A CN112527382A CN 112527382 A CN112527382 A CN 112527382A CN 202011472000 A CN202011472000 A CN 202011472000A CN 112527382 A CN112527382 A CN 112527382A
- Authority
- CN
- China
- Prior art keywords
- pipeline
- engine system
- configuration
- continuous integration
- tasks
- 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.)
- Granted
Links
- 230000010354 integration Effects 0.000 title claims abstract description 113
- 238000000034 method Methods 0.000 title claims abstract description 65
- 230000002452 interceptive effect Effects 0.000 claims abstract description 49
- 230000002085 persistent effect Effects 0.000 claims description 18
- 238000001514 detection method Methods 0.000 claims description 16
- 238000012360 testing method Methods 0.000 claims description 16
- 238000010276 construction Methods 0.000 claims description 14
- 238000009877 rendering Methods 0.000 claims description 14
- 238000012545 processing Methods 0.000 claims description 11
- 238000004590 computer program Methods 0.000 claims description 10
- 238000012216 screening Methods 0.000 claims description 10
- 238000009434 installation Methods 0.000 claims description 7
- 239000010979 ruby Substances 0.000 claims description 6
- 229910001750 ruby Inorganic materials 0.000 claims description 6
- 238000007689 inspection Methods 0.000 claims description 5
- 238000004519 manufacturing process Methods 0.000 claims description 4
- 230000003993 interaction Effects 0.000 claims 1
- 238000010586 diagram Methods 0.000 description 9
- 238000007726 management method Methods 0.000 description 8
- 230000000007 visual effect Effects 0.000 description 5
- 238000011161 development Methods 0.000 description 4
- 230000002159 abnormal effect Effects 0.000 description 2
- 230000001419 dependent effect Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000001914 filtration Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000003287 optical effect Effects 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/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Image Generation (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a method for deploying a pipeline engine system, a continuous integration method, a device, equipment and a medium, wherein the method for deploying the pipeline engine system comprises the following steps: acquiring basic information of a project to be continuously integrated; generating a configuration file corresponding to a continuous integration pipeline of the project in a code management warehouse Gitlab based on the language type; and generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile. The steps or tasks of the continuous integration pipeline can be modified in a mode of directly deleting or adding the steps or tasks in the interactive interface, and the problems that the gitlab-ci.yml file is extremely complex and easy to make mistakes when the steps and the tasks in the pipeline are more are solved.
Description
Technical Field
The present invention relates to the field of project integration technologies, and in particular, to a method for deploying a pipeline engine system, a method and an apparatus for persistent integration, a device, and a medium.
Background
In software projects, the integration stage is usually at the end, and if a problem occurs, the delivery cannot be carried out on time, and the problem can be solved by utilizing continuous integration. In the continuous integration processing, a developer uploads the written source code to a continuous integration server, and the continuous integration server compiles, tests, packages and the like the source code.
In the conventional technology, when continuous integration is performed, a developer writes a configuration file to describe the execution steps of the whole integration pipeline, and the steps of the continuous integration process of each project are different. When an engineer needs to adjust or add processing steps and tasks, different configuration files need to be written. At present, when a Pipeline is defined based on a Gitlab CI (continuous integration System), a Gitlab-ci.yml script file is directly edited, and once more steps and tasks are involved in the Pipeline, the Pipeline directly becomes extremely complex and easy to make mistakes.
Disclosure of Invention
The technical problem to be solved by the invention is to overcome the defect that the gitlab-ci.yml script is easy to make mistakes when a plurality of steps and tasks are involved in the prior art, and provide a method for deploying a pipeline engine system, a method, a device, equipment and a medium for continuous integration.
The invention solves the technical problems through the following technical scheme:
in a first aspect, the present invention provides a method of deploying a pipeline engine system, the method comprising:
acquiring basic information of a project to be continuously integrated; wherein the basic information includes a language type;
generating a configuration file corresponding to the continuous integration pipeline of the project in a code management warehouse Gitlab based on the language type; wherein the persistent integration pipeline comprises a plurality of different steps, each step corresponding to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks;
generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile; the pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
Preferably, the step of generating a configuration file corresponding to the continuous integration pipeline of the project in the code management repository Gitlab based on the language type includes:
acquiring the inclusion relation between each step and each task in the continuous integration processing of the project from the basic information;
and generating a configuration file comprising a plurality of configuration subfiles based on the inclusion relation.
Preferably, the step of generating a pipeline engine system including a pipeline interactive interface according to the configuration subfile includes:
analyzing a configuration file containing an html rule through an ERB template of Ruby language to generate a configuration subfile to be rendered;
rendering the configuration sub-file based on HTML and Javascript to generate a plurality of pipeline interactive interfaces;
and combining all the pipeline interactive interfaces to generate the pipeline engine system.
Preferably, the step of rendering the configuration subfile based on HTML and Javascript and generating a plurality of pipeline interactive interfaces includes:
and presenting the encrypted data in the configuration subfile in a hidden form on the pipeline interactive interface.
Preferably, the language types include node.js and Java; JS, if the language type is node, the steps comprise code dependence installation, code detection and code generation, wherein the code detection comprises tasks of testing, language inspection and product release construction; the code generation includes tasks of code quality scanning and image construction.
In a second aspect, the present invention provides an apparatus for deploying a pipeline engine system, the apparatus comprising:
the acquisition module is used for acquiring basic information of the project to be continuously integrated; wherein the basic information includes a language type;
the configuration file generation module is used for generating a configuration file corresponding to the continuous integration production line of the project in a code management warehouse Gitlab based on the language type; wherein the persistent integration pipeline comprises a plurality of different steps, each step corresponding to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks;
the engine system generating module is used for generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile; the pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
Preferably, the configuration file generating module includes:
a relationship acquisition unit configured to acquire, from the basic information, an inclusion relationship between each step and each task in the continuous integration processing of the item;
and the configuration file generating unit is used for generating a configuration file comprising a plurality of configuration subfiles based on the inclusion relation.
Preferably, the engine system generating module includes:
the parsing unit is used for parsing the configuration subfile containing the html rule through an ERB template of Ruby language to generate a configuration subfile to be rendered;
the rendering unit is used for rendering the configuration subfile based on HTML and Javascript and generating a plurality of pipeline interactive interfaces;
and the combination unit is used for combining all the pipeline interactive interfaces to generate the pipeline engine system.
Preferably, the rendering unit is specifically configured to:
and presenting the encrypted data in the configuration subfile in a hidden form on the pipeline interactive interface.
Preferably, the language types include node.js and Java; JS, if the language type is node, the steps comprise code dependence installation, code detection and code generation, wherein the code detection comprises tasks of testing, language inspection and product release construction; the code generation includes tasks of code quality scanning and image construction.
In a third aspect, the present invention provides a method of persistent integration, the method comprising:
determining the language type of the target item;
pushing code of the target item to a pipeline engine system generated by the method of the first aspect;
screening out a target continuous integration pipeline of the target item in the pipeline engine system according to the language type;
performing a persistent integration operation on the target item based on the target persistent integration pipeline.
In a fourth aspect, the present invention provides a continuously integrated apparatus, comprising:
the determining module is used for determining the language type of the target item;
a pushing module, configured to push the code of the target item to a pipeline engine system generated by the method according to the first aspect;
the screening module is used for screening a target continuous integration pipeline of the target item in the pipeline engine system according to the language type;
and the execution module is used for executing continuous integration operation on the target item based on the target continuous integration pipeline.
In a fifth aspect, the invention provides an electronic device comprising a processor, a memory, and a computer program stored on the memory and executable on the processor, the computer program, when executed by the processor, implementing the method of deploying a pipeline engine system according to any of the first aspects or performing the method of continuous integration according to the third aspect.
In a sixth aspect, the invention provides a computer readable storage medium having stored thereon a computer program which, when executed by a processor, carries out the steps of the method of deploying a pipeline engine system according to any of the first aspects, or carries out the steps of the method of continuous integration according to the third aspect.
The positive progress effects of the invention are as follows: the method and the device for deploying the pipeline engine system based on the Gitlab CI are characterized in that a configuration file corresponding to a continuous integration pipeline comprising steps and tasks is generated according to a preset language type, the configuration file is rendered to generate the engine system comprising a pipeline interactive interface, the steps or the tasks of the continuous integration pipeline can be modified in a mode of directly deleting or adding the interactive interface, and the problems that the steps and the tasks in the pipeline are more, the steps-ci.yml files are directly modified, and the problems that the steps-ci.yml files are abnormal and complex and errors are easy to occur are solved.
Drawings
Fig. 1 is a first flowchart of a method for deploying a pipeline engine system according to embodiment 1 of the present invention.
Fig. 2 is a second flowchart of a method for deploying a pipeline engine system according to embodiment 1 of the present invention.
Fig. 3 is a first interface schematic diagram of a pipeline interactive interface according to embodiment 1 of the present invention.
Fig. 4 is a second interface schematic diagram of the pipeline interactive interface in embodiment 1 of the present invention.
Fig. 5 is a third interface schematic diagram of the pipeline interactive interface in embodiment 1 of the present invention.
Fig. 6 is a fourth interface schematic diagram of a pipeline interactive interface according to embodiment 1 of the present invention.
Fig. 7 is a block diagram of an apparatus for deploying a pipeline engine system according to embodiment 2 of the present invention.
Fig. 8 is a flowchart of a method of persistent integration according to embodiment 3 of the present invention.
Fig. 9 is a block diagram of a continuously integrated device according to embodiment 4 of the present invention.
Fig. 10 is a schematic diagram of a hardware structure of an electronic device according to embodiment 5 of the present invention.
Detailed Description
The invention is further illustrated by the following examples, which are not intended to limit the scope of the invention.
Example 1
The present embodiment provides a method for deploying a pipeline engine system, as shown in fig. 1, the method for deploying a pipeline engine system of the present embodiment includes:
step S11, acquiring basic information of the project to be continuously integrated; wherein the basic information includes a language type.
And step S12, generating a configuration file corresponding to the continuous integration pipeline of the project in the code management warehouse Gitlab based on the language type. The continuous integration pipeline comprises a plurality of different steps, each step corresponds to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks.
And step S13, generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile. The pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
Wherein the language type comprises node.JS and Java; JS, if the language type is node, the steps include code dependence installation, code detection and code generation, wherein the code detection includes tasks of testing, language inspection and product release construction; code generation includes the tasks of code quality scanning and image construction.
Continuous integration refers to the work that members of a development team often integrate project updates, and periodically integrate developed codes into a system, so as to discover errors integrated in a project as early as possible. Continuous integration is a process that continues repeatedly from encoding, building, code scanning, security auditing, to automated testing. And adding the newly developed part into the continuous integration pipeline by a developer, and configuring and testing the newly developed part step by step according to the program of the continuous integration pipeline until the integration is completed.
In this embodiment, the basic information of the project to be continuously integrated is obtained, where the basic information may include a language type corresponding to the project, and the language type is a development language, for example, Java language and node.
And establishing configuration files corresponding to continuous integration pipelines corresponding to different language types in a code management warehouse Gitlab based on the language types. For example, the configuration file of the persistent integration pipeline of project a developed in Java language is a first configuration file, the configuration file of the persistent integration pipeline of project B developed in node. After the configuration files are modularized, each configuration file comprises a plurality of configuration subfiles, in other words, the first configuration file comprises a plurality of first configuration subfiles, the second configuration file comprises a plurality of second configuration subfiles, and the third configuration file comprises a plurality of third configuration subfiles, wherein each configuration subfile has different corresponding tasks.
In a possible implementation manner, the second configuration file includes a second configuration subfile a, a second configuration subfile B, a second configuration subfile C, a second configuration subfile D, a second configuration subfile E, a second configuration subfile F, a second configuration subfile G, and a second configuration subfile H. The second configuration subfile A corresponds to a code installation dependent task, the second configuration subfile B corresponds to a code detection task, the second configuration subfile C corresponds to a code generation task, the second configuration subfile D corresponds to a test task, the second configuration subfile E corresponds to a language check task, the second configuration subfile F corresponds to a release product construction task, the second configuration subfile G corresponds to a code quality scanning task, and the second configuration subfile H corresponds to a mirror image construction task.
And after splicing all the configuration subfiles, generating a pipeline engine system comprising pipeline interactive interfaces, wherein each pipeline interactive interface displays each step contained in each continuous integration pipeline and tasks contained in each step. And the user can modify the processing flow of each continuous integration pipeline through preset keys such as New addition, Delete and the like through the pipeline interactive interface.
In this embodiment, as shown in fig. 2, step S12 includes:
step S121, acquiring an inclusion relationship between each step and each task in the continuous integration process of the item from the basic information.
Step S122, generating a configuration file comprising a plurality of configuration subfiles based on the containing relation.
And acquiring the relation between each step and each task in the continuous integration processing, wherein each task corresponds to one configuration subfile, a plurality of different configuration subfiles are combined into one step, and a configuration file containing the configuration subfiles corresponding to all the tasks is constructed.
Illustratively, as shown in the schematic views of the visual interfaces of fig. 3 to fig. 5, three steps of Install, verifylandblue and sonarand Image are set, and an Install task is configured for the Install step, a Test (Test), a link (grammar check) and Build (release product Build) task is configured for verifylandblue, and a Sonar (code quality scan) and Image (mirror Build) task is configured for sonarand Image.
In this embodiment, as shown in fig. 2, step S13 includes:
step S131, the configuration file containing the html rule is analyzed through an ERB template of the Ruby language, and a configuration subfile to be rendered is generated.
And S132, rendering the configuration sub-file based on HTML and Javascript, and generating a plurality of pipeline interactive interfaces.
And step S133, combining all the pipeline interactive interfaces to generate a pipeline engine system.
In step S132, the encrypted data in the configuration subfile is presented in a hidden form on the pipeline interactive interface.
Analyzing yml files configured with HTML rules in a code management warehouse Gitlab through an ERB template of Ruby language, converting the content of the yml files into a json type data format, and generating a pipeline interactive interface by Javascript and HTML rendering.
As shown in FIG. 6, the deployment pipeline engine system is an interface diagram for executing the continuous integration operation on the project, and the inclusion relationship between each step or task in the continuous integration process of each project can be visually shown by using the visual interface. When new steps are deleted or added in the visual interfaces of the fig. 3, 4 and 5, the execution of the configuration file corresponding to the continuous integration pipeline is not influenced. The problem that the gitlab-ci.yml file is modified directly when steps or tasks of a continuous integration pipeline are modified, the process is extremely complex and errors are prone to occurring is solved.
It should be noted that, after being subjected to preset processing, the encrypted data in the configuration file is rendered and then displayed in a hidden form, so that the security of the general tasks in each continuous integration pipeline is ensured.
The method comprises the steps of generating a configuration file corresponding to a continuous integration pipeline containing steps and tasks according to a preset language type, rendering the configuration file to generate an engine system containing a pipeline interactive interface, and modifying the steps or the tasks of the continuous integration pipeline in a mode of directly deleting or adding the interactive interface, so that the problems that the steps and the tasks in the pipeline are more, the steps and the tasks in the pipeline are directly modified, and a Gitlab-ci.yml script file is extremely complex and easy to make mistakes are solved; the security of the general task in the continuous integration production line is ensured by hiding the encrypted data in the configuration file.
Example 2
As shown in fig. 7, the present embodiment provides an apparatus for deploying a pipeline engine system, which specifically includes: the system comprises an acquisition module 110, a configuration file generation module 120 and an engine system generation module 130, wherein the configuration file generation module 120 comprises a relationship acquisition unit 121 and a configuration file generation unit; the engine system generating module 130 includes a parsing unit 131, a rendering unit 132, and a combining unit 133.
The acquiring module 110 is configured to acquire basic information of an item to be continuously integrated; wherein the basic information includes a language type.
A configuration file generation module 120, configured to generate a configuration file corresponding to a continuous integration pipeline of a project in a code management repository Gitlab based on a language type; the continuous integration pipeline comprises a plurality of different steps, each step corresponds to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks.
The engine system generating module 130 is used for generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile; the pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
Wherein the language type comprises node.JS and Java; JS, if the language type is node, the steps include code dependence installation, code detection and code generation, wherein the code detection includes tasks of testing, language inspection and product release construction; code generation includes the tasks of code quality scanning and image construction.
Continuous integration refers to the work that members of a development team often integrate project updates, and periodically integrate developed codes into a system, so as to discover errors integrated in a project as early as possible. Continuous integration is a process that continues repeatedly from encoding, building, code scanning, security auditing, to automated testing. And adding the newly developed part into the continuous integration pipeline by a developer, and configuring and testing the newly developed part step by step according to the program of the continuous integration pipeline until the integration is completed.
In this embodiment, the obtaining module 110 obtains basic information of a project to be continuously integrated, where the basic information may include a language type corresponding to the project, and the language type is a development language, for example, Java language and node.
The configuration file generating module 120 establishes configuration files corresponding to the continuous integration pipelines corresponding to different language types in the code management repository Gitlab based on the language type. For example, the configuration file of the persistent integration pipeline of project a developed in Java language is a first configuration file, the configuration file of the persistent integration pipeline of project B developed in node. After the configuration files are modularized, each configuration file comprises a plurality of configuration subfiles, in other words, the first configuration file comprises a plurality of first configuration subfiles, the second configuration file comprises a plurality of second configuration subfiles, and the third configuration file comprises a plurality of third configuration subfiles, wherein each configuration subfile has different corresponding tasks.
In a possible implementation manner, the second configuration file includes a second configuration subfile a, a second configuration subfile B, a second configuration subfile C, a second configuration subfile D, a second configuration subfile E, a second configuration subfile F, a second configuration subfile G, and a second configuration subfile H. The second configuration subfile A corresponds to a code installation dependent task, the second configuration subfile B corresponds to a code detection task, the second configuration subfile C corresponds to a code generation task, the second configuration subfile D corresponds to a test task, the second configuration subfile E corresponds to a language check task, the second configuration subfile F corresponds to a release product construction task, the second configuration subfile G corresponds to a code quality scanning task, and the second configuration subfile H corresponds to a mirror image construction task.
After all the configuration subfiles are spliced, the engine system generation module 130 generates a pipeline engine system including pipeline interactive interfaces, each pipeline interactive interface displaying each step included in each continuous integration pipeline and a task included in each step. And the user can modify the processing flow of each continuous integration pipeline through preset keys such as New addition, Delete and the like through the pipeline interactive interface.
In this embodiment, the configuration file generating module 120 includes:
a relationship acquisition unit 121 configured to acquire, from the basic information, an inclusion relationship between each step and each task in the continuous integration process of the item.
A configuration file generating unit 122, configured to generate a configuration file including a plurality of configuration subfiles based on the inclusion relationship.
An engine system generation module 130 comprising:
the parsing unit 131 is configured to parse the configuration subfile containing the html rule through an ERB template of the Ruby language, and generate a configuration subfile to be rendered.
And the rendering unit 132 is configured to render the configuration subfile based on the HTML and the Javascript, and generate a plurality of pipeline interactive interfaces.
And the combining unit 133 is configured to combine all pipeline interactive interfaces to generate a pipeline engine system.
The rendering unit 132 is further configured to render the encrypted data in the configuration subfile in a hidden form in the pipeline interactive interface.
It should be noted that, after being subjected to preset processing, the encrypted data in the configuration file is rendered and then displayed in a hidden form, so that the security of the general tasks in each continuous integration pipeline is ensured.
The method comprises the steps of generating a configuration file corresponding to a continuous integration pipeline comprising steps and tasks according to a preset language type, rendering the configuration file to generate an engine system comprising a pipeline interactive interface, and modifying the steps or tasks of the continuous integration pipeline in a mode of directly deleting or adding interactive interfaces, so that the problems that the steps and tasks in the pipeline are more, the steps and tasks are directly modified, and the problem that a Gitlab-ci.yml file is extremely complex and easy to make mistakes is solved; the security of the general task in the continuous integration production line is ensured by hiding the encrypted data in the configuration file.
Example 3
In this embodiment, a method for continuous integration is provided, as shown in fig. 8, the method includes:
and step S21, determining the language type of the target item.
Step S22, pushing the codes of the target items to the pipeline engine system; wherein the pipeline engine system is generated by the method of embodiment 1.
And step S33, screening out the target continuous integration pipeline of the target item in the pipeline engine system according to the language type.
And step S34, executing the continuous integration operation on the target item based on the target continuous integration pipeline.
When code quality detection or application image generation needs to be performed on a target project, the language type of the target project is acquired, the target project is pushed into a pipeline engine system generated according to the method of embodiment 1, and then the workflow of the pipeline of the target project is determined according to the language type. Js, the workflow of the pipeline may be to install code dependencies, run unit tests, grammar detection for code, build deployment artifacts, scan code quality, generate images, etc. And executing corresponding integration operation according to the workflow of the defined pipeline.
The method for continuous integration is characterized in that a workflow of a continuous integration pipeline constructed in a preset pipeline engine system is executed according to a preset language type, the pipeline engine system can directly modify steps and tasks of the workflow through a visual interface, and the problems that a gitlab-ci.yml script file is abnormal, complex and easy to make mistakes when the steps and the tasks in the pipeline are more are solved.
Example 4
In this embodiment, a continuously integrated device is provided, as shown in fig. 9, the device includes: a determination module 210, a push module 220, a filtering module 230, and an execution module 240.
The determining module 210 is configured to determine a language type of the target item.
The pushing module 220 is configured to push a code of the target item to the pipeline engine system; wherein the pipeline engine system is generated by the method of embodiment 1.
And the screening module 230 is used for screening the target continuous integration pipeline of the target item in the pipeline engine system according to the language type.
And the execution module 240 is used for executing the continuous integration operation on the target item based on the target continuous integration pipeline.
When code quality detection or application image generation is required to be performed on a target item, the determining module 210 obtains a language type of the target item, the pushing module 220 pushes the target item to the pipeline engine system generated according to the method in embodiment 1, and then the screening module 230 determines a workflow of a pipeline of the target item according to the language type. For example, for node.js applications, the workflow of the pipeline may be to install code dependencies, run unit tests, perform syntax detection on codes, construct deployment products, scan code quality, generate images, and the like, and execute corresponding persistent integration operations according to the workflow of the defined pipeline.
The continuous integration device executes the workflow of a continuous integration pipeline constructed in a preset pipeline engine system according to a preset language type, and the pipeline engine system can directly modify the steps and tasks of the workflow through a visual interface, so that the problems that a gitlab-ci.yml script file is abnormally complex and is easy to make mistakes when the steps and tasks in the pipeline are more are solved.
Example 5
The present embodiment provides an electronic device, which may be represented in the form of a computing device (for example, may be a server device), including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor may implement the method for deploying the pipeline engine system according to embodiment 1 or the method for continuously integrating according to embodiment 3 when executing the computer program.
Fig. 10 shows a schematic diagram of a hardware structure of the present embodiment, and as shown in fig. 10, the electronic device 9 specifically includes:
at least one processor 91, at least one memory 92, and a bus 93 for connecting the various system components (including the processor 91 and the memory 92), wherein:
the bus 93 includes a data bus, an address bus, and a control bus.
The processor 91 executes various functional applications and data processing such as the method of deploying the pipeline engine system of embodiment 1 or the method of continuous integration of embodiment 3 of the present invention by running the computer program stored in the memory 92.
The electronic device 9 may further communicate with one or more external devices 94 (e.g., a keyboard, a pointing device, etc.). Such communication may be through an input/output (I/O) interface 95. Also, the electronic device 9 may communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the Internet) via the network adapter 96. The network adapter 96 communicates with the other modules of the electronic device 9 via the bus 93. It should be understood that although not shown in the figures, other hardware and/or software modules may be used in conjunction with the electronic device 9, including but not limited to: microcode, device drivers, redundant processors, external disk drive arrays, RAID (disk array) systems, tape drives, and data backup storage systems, etc.
It should be noted that although in the above detailed description several units/modules or sub-units/modules of the electronic device are mentioned, such a division is merely exemplary and not mandatory. Indeed, the features and functionality of two or more of the units/modules described above may be embodied in one unit/module, according to embodiments of the application. Conversely, the features and functions of one unit/module described above may be further divided into embodiments by a plurality of units/modules.
Example 6
The present embodiment provides a computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the method of deploying a pipeline engine system of embodiment 1 or the steps of the method of continuous integration of embodiment 3.
More specific examples, among others, that the readable storage medium may employ may include, but are not limited to: a portable disk, a hard disk, random access memory, read only memory, erasable programmable read only memory, optical storage device, magnetic storage device, or any suitable combination of the foregoing.
In a possible implementation, the invention can also be implemented in the form of a program product comprising program code for causing a terminal device to carry out the steps of the method of deploying the pipeline engine system of embodiment 1 or the steps of the method of continuous integration of embodiment 3, when said program product is run on said terminal device.
Where program code for carrying out the invention is written in any combination of one or more programming languages, the program code may be executed entirely on the user device, partly on the user device, as a stand-alone software package, partly on the user device and partly on a remote device or entirely on the remote device.
While specific embodiments of the invention have been described above, it will be appreciated by those skilled in the art that this is by way of example only, and that the scope of the invention is defined by the appended claims. Various changes and modifications to these embodiments may be made by those skilled in the art without departing from the spirit and scope of the invention, and these changes and modifications are within the scope of the invention.
Claims (10)
1. A method for deploying a pipeline engine system, the method comprising:
acquiring basic information of a project to be continuously integrated; wherein the basic information includes a language type;
generating a configuration file corresponding to the continuous integration pipeline of the project in a code management warehouse Gitlab based on the language type; wherein the persistent integration pipeline comprises a plurality of different steps, each step corresponding to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks;
generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile; the pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
2. The method of deploying a pipeline engine system according to claim 1, wherein the step of generating a configuration file corresponding to the continued integration pipeline of the project in a code management repository Gitlab based on the language type comprises:
acquiring the inclusion relation between each step and each task in the continuous integration processing of the project from the basic information;
and generating a configuration file comprising a plurality of configuration subfiles based on the inclusion relation.
3. The method of deploying a pipeline engine system according to claim 1, wherein the step of generating a pipeline engine system including a pipeline interactive interface based on the configuration subfile comprises:
analyzing a configuration file containing an html rule through an ERB template of Ruby language to generate a configuration subfile to be rendered;
rendering the configuration sub-file based on HTML and Javascript to generate a plurality of pipeline interactive interfaces;
and combining all the pipeline interactive interfaces to generate the pipeline engine system.
4. The method of deploying a pipeline engine system of claim 3, wherein the step of rendering the configuration subfiles based on HTML and Javascript, generating a plurality of pipeline interaction interfaces comprises:
and presenting the encrypted data in the configuration subfile in a hidden form on the pipeline interactive interface.
5. The method of deploying a pipeline engine system of claim 1, wherein the language types include node.js and Java; JS, if the language type is node, the steps comprise code dependence installation, code detection and code generation, wherein the code detection comprises tasks of testing, language inspection and product release construction; the code generation includes tasks of code quality scanning and image construction.
6. An apparatus for deploying a pipeline engine system, the apparatus comprising:
the acquisition module is used for acquiring basic information of the project to be continuously integrated; wherein the basic information includes a language type;
the configuration file generation module is used for generating a configuration file corresponding to the continuous integration production line of the project in a code management warehouse Gitlab based on the language type; wherein the persistent integration pipeline comprises a plurality of different steps, each step corresponding to a plurality of tasks, the configuration file comprises a plurality of configuration subfiles, and different configuration subfiles correspond to different tasks;
the engine system generating module is used for generating a pipeline engine system containing a pipeline interactive interface according to the configuration subfile; the pipeline interactive interface is used for displaying a plurality of tasks corresponding to each continuous integration pipeline, and adding or deleting at least one task according to a preset instruction.
7. A method of persistent integration, the method comprising:
determining the language type of the target item;
pushing code for the target item to a pipeline engine system generated by the method of claim 1;
screening out a target continuous integration pipeline of the target item in the pipeline engine system according to the language type;
performing a persistent integration operation on the target item based on the target persistent integration pipeline.
8. An apparatus for continuous integration, the apparatus comprising:
the determining module is used for determining the language type of the target item;
a push module for pushing code of the target item to a pipeline engine system generated by the method of claim 1;
the screening module is used for screening a target continuous integration pipeline of the target item in the pipeline engine system according to the language type;
and the execution module is used for executing continuous integration operation on the target item based on the target continuous integration pipeline.
9. An electronic device comprising a processor, a memory, and a computer program stored on the memory and executable on the processor, the computer program, when executed by the processor, implementing a method of deploying a pipeline engine system according to any of claims 1-5, or performing a method of persistent integration according to claim 7.
10. A computer-readable storage medium, having stored thereon a computer program which, when executed by a processor, carries out the steps of the method of deploying a pipeline engine system according to any of claims 1-5, or carries out the steps of the method of continued integration according to claim 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011472000.3A CN112527382B (en) | 2020-12-14 | 2020-12-14 | Method for deploying pipeline engine system, and method and device for continuous integration |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011472000.3A CN112527382B (en) | 2020-12-14 | 2020-12-14 | Method for deploying pipeline engine system, and method and device for continuous integration |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112527382A true CN112527382A (en) | 2021-03-19 |
| CN112527382B CN112527382B (en) | 2023-12-12 |
Family
ID=74999803
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011472000.3A Active CN112527382B (en) | 2020-12-14 | 2020-12-14 | Method for deploying pipeline engine system, and method and device for continuous integration |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112527382B (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113434264A (en) * | 2021-07-14 | 2021-09-24 | 上海浦东发展银行股份有限公司 | Intelligent processing method, device, equipment and storage medium for task components |
| CN113590485A (en) * | 2021-08-02 | 2021-11-02 | 瀚高基础软件股份有限公司 | Multi-management system integration method and computer readable storage medium |
| CN114546473A (en) * | 2022-02-23 | 2022-05-27 | 北京金堤科技有限公司 | Method and device for automatically and integrally deploying service, electronic equipment and storage medium |
| CN116931965A (en) * | 2023-09-18 | 2023-10-24 | 无锡雪浪数制科技有限公司 | Integrated stream processing method, device, electronic equipment and storage medium |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120180024A1 (en) * | 2011-01-07 | 2012-07-12 | International Business Machines Corporation | Synchronizing development code and deployed executable versioning within distributed systems |
| CN104423960A (en) * | 2013-09-10 | 2015-03-18 | 阿里巴巴集团控股有限公司 | Continuous project integration method and continuous project integration system |
| US10120670B1 (en) * | 2018-03-28 | 2018-11-06 | Capital One Services, Llc | Systems and methods for building generic CI/CD pipelines |
| CN111488136A (en) * | 2020-04-07 | 2020-08-04 | 携程旅游网络技术（上海）有限公司 | Continuous integration and continuous delivery method, system, device and storage medium |
| CN112068874A (en) * | 2020-07-30 | 2020-12-11 | 深圳市优必选科技股份有限公司 | Software project continuous integration method and device, terminal equipment and storage medium |
-
2020
- 2020-12-14 CN CN202011472000.3A patent/CN112527382B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120180024A1 (en) * | 2011-01-07 | 2012-07-12 | International Business Machines Corporation | Synchronizing development code and deployed executable versioning within distributed systems |
| CN104423960A (en) * | 2013-09-10 | 2015-03-18 | 阿里巴巴集团控股有限公司 | Continuous project integration method and continuous project integration system |
| US10120670B1 (en) * | 2018-03-28 | 2018-11-06 | Capital One Services, Llc | Systems and methods for building generic CI/CD pipelines |
| CN111488136A (en) * | 2020-04-07 | 2020-08-04 | 携程旅游网络技术（上海）有限公司 | Continuous integration and continuous delivery method, system, device and storage medium |
| CN112068874A (en) * | 2020-07-30 | 2020-12-11 | 深圳市优必选科技股份有限公司 | Software project continuous integration method and device, terminal equipment and storage medium |
Non-Patent Citations (1)
| Title |
|---|
| 单雅辉;刘青凯;杨章;田鸿运;邹勇刚;: "一种面向数值模拟软件的持续集成平台", 计算机辅助工程, no. 03 * |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113434264A (en) * | 2021-07-14 | 2021-09-24 | 上海浦东发展银行股份有限公司 | Intelligent processing method, device, equipment and storage medium for task components |
| CN113590485A (en) * | 2021-08-02 | 2021-11-02 | 瀚高基础软件股份有限公司 | Multi-management system integration method and computer readable storage medium |
| CN114546473A (en) * | 2022-02-23 | 2022-05-27 | 北京金堤科技有限公司 | Method and device for automatically and integrally deploying service, electronic equipment and storage medium |
| CN116931965A (en) * | 2023-09-18 | 2023-10-24 | 无锡雪浪数制科技有限公司 | Integrated stream processing method, device, electronic equipment and storage medium |
| CN116931965B (en) * | 2023-09-18 | 2023-11-17 | 无锡雪浪数制科技有限公司 | Integrated stream processing method, device, electronic equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112527382B (en) | 2023-12-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112527382B (en) | Method for deploying pipeline engine system, and method and device for continuous integration | |
| US11487539B2 (en) | Systems and methods for automating and monitoring software development operations | |
| US8549483B1 (en) | Engine for scalable software testing | |
| US9009183B2 (en) | Transformation of a system change set from machine-consumable form to a form that is readily consumable by a human | |
| US8584079B2 (en) | Quality on submit process | |
| US7526759B2 (en) | Debugging prototyped system solutions in solution builder wizard environment | |
| US8881109B1 (en) | Runtime documentation of software testing | |
| US11733975B1 (en) | System and method for migrating legacy software to a system common architecture | |
| US8091066B2 (en) | Automated multi-platform build and test environment for software application development | |
| CN108845940B (en) | Enterprise-level information system automatic function testing method and system | |
| US8285662B2 (en) | Framework for delta analysis during automated builds | |
| KR20130135271A (en) | Code clone notification and architectural change visualization | |
| JP2003256202A (en) | Compatibility check support program, compatibility check support method and compatibility check support device | |
| US20140059513A1 (en) | Creation and Uploading of Archives for Software Projects to Submission Portal | |
| CN111881054B (en) | User interface automatic test method, system, equipment and storage medium | |
| CN111813382A (en) | Intangible asset management system and method | |
| US7886277B2 (en) | System and method for error checking of failed I/O open calls | |
| CN109299124B (en) | Method and apparatus for updating a model | |
| CN113535567B (en) | Software testing method, device, equipment and medium | |
| US11301245B2 (en) | Detecting bias in artificial intelligence software by analysis of source code contributions | |
| CN112328473A (en) | Code automation integration test method and device and electronic equipment | |
| CN111611173A (en) | System and method applied to micro-service engineering interface document detection | |
| CN115543391B (en) | Application platform upgrading method and device, electronic equipment and readable storage medium | |
| Whitener et al. | The ERSDT Software Quality Assurance Plan Practices and Development Environment Setup for RASCAL 5 | |
| CN114860597A (en) | Method, device, equipment and storage medium for determining code coverage rate |
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 |