CN116431194A

CN116431194A - Construction method, device, equipment and storage medium for continuous integration task

Info

Publication number: CN116431194A
Application number: CN202210002990.7A
Authority: CN
Inventors: 黄友昆
Original assignee: Tencent Cyber Tianjin Co Ltd
Current assignee: Tencent Cyber Tianjin Co Ltd
Priority date: 2022-01-04
Filing date: 2022-01-04
Publication date: 2023-07-14

Abstract

The embodiment of the application discloses a method, a device, equipment and a storage medium for constructing a continuous integration task, which can be applied to the technical field of computers and the technical field of blockchains. The method comprises the following steps: acquiring project cache information and first pipeline configuration information, wherein the first pipeline configuration information corresponds to at least one first continuous integration task; determining the item cache information as a first bottom file directory corresponding to the first pipeline configuration information, and constructing a first work directory corresponding to each first continuous integration task based on the first bottom file directory; and constructing each first continuous integration task based on the first work catalogue corresponding to each first continuous integration task and the first pipeline configuration information. By adopting the embodiment of the application, the construction efficiency of the continuous integration task can be improved, and the applicability is high.

Description

Construction method, device, equipment and storage medium for continuous integration task

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a storage medium for constructing a persistent integration task.

Background

Continuous integration is a software development practice, i.e. team development members often integrate their work, usually at least once a day per member, meaning that multiple integration may occur per day. Each integration is verified by automatically building a continuous integration task, including code compilation, release, automated testing, etc., to discover integration errors as early as possible.

In the prior art, in the case that a pipeline corresponds to a plurality of continuous integration tasks, a great deal of time is consumed for constructing each continuous integration task. And the construction of continuous integration tasks corresponding to different pipelines is independently carried out, and time is further consumed under the condition that continuous integration tasks corresponding to a plurality of pipelines are required to be constructed.

Therefore, how to efficiently construct continuous integration tasks becomes a problem to be solved.

Disclosure of Invention

The embodiment of the application provides a method, a device, equipment and a storage medium for constructing a continuous integration task, which can improve the construction efficiency of the continuous integration task and have high applicability.

In one aspect, an embodiment of the present application provides a method for constructing a persistent integration task, where the method includes:

acquiring project cache information and first pipeline configuration information, wherein the first pipeline configuration information corresponds to at least one first continuous integration task;

determining the item cache information as a first bottom file directory corresponding to the first pipeline configuration information, and constructing a first work directory corresponding to each first continuous integration task based on the first bottom file directory;

and constructing each first continuous integration task based on the first work catalogue corresponding to each first continuous integration task and the first pipeline configuration information.

In another aspect, an embodiment of the present application provides a construction apparatus for continuous integration tasks, where the apparatus includes:

the information acquisition module is used for acquiring project cache information and first pipeline configuration information, and the first pipeline configuration information corresponds to at least one first continuous integration task;

the catalog construction module is used for determining the item cache information as a first bottom file catalog corresponding to the first pipeline configuration information, and constructing a first work catalog corresponding to each first continuous integration task based on the first bottom file catalog;

and the task construction module is used for constructing each first continuous integration task based on the first work catalogue corresponding to each first continuous integration task and the first pipeline configuration information.

Optionally, when each first persistent integration task is built based on the first work directory corresponding to the first persistent integration task and the first pipeline configuration information, the task building module is configured to:

determining project code submission records corresponding to each first continuous integration task based on the first pipeline configuration information;

determining target project cache information corresponding to the project code submitting records from a first work catalog corresponding to each first continuous integration task;

And constructing each first continuous integration task based on the project code submitting record corresponding to each first continuous integration task and the target project caching information.

Optionally, the catalog construction module is further configured to:

executing each first continuous integration task and determining an execution result corresponding to each first continuous integration task;

and updating the first work catalogue corresponding to each first continuous integration task based on the execution result corresponding to each first continuous integration task.

Optionally, the catalog construction module is further configured to:

and responding to the code modification request for each first continuous integration task, and modifying the item cache information in the first work catalogue corresponding to each first continuous integration task based on the code modification request.

Optionally, the catalog construction module is further configured to:

updating the first bottom file directory based on the execution result corresponding to each first continuous integration task;

and updating the first bottom-layer file directory based on the updated first working directory.

Optionally, the information acquisition module is further configured to:

acquiring second pipeline configuration information, wherein the second pipeline configuration information corresponds to at least one second continuous integration task;

The catalog construction module is further configured to:

determining a second bottom file directory corresponding to the second pipeline configuration information from the first bottom file directory and first work directories corresponding to the first continuous integration tasks;

constructing a second working catalog corresponding to each second continuous integration task based on the second bottom file catalog;

the task building module is further configured to:

and constructing each second continuous integration task based on the second work catalogue corresponding to each second continuous integration task and the second pipeline configuration information.

Optionally, when determining a second bottom file directory corresponding to the second pipeline configuration information from the first bottom file directory and the first working directory corresponding to each of the first continuous integration tasks, the directory construction module is configured to:

if the item cache information in the first bottom-layer file directory includes the item cache information corresponding to the second pipeline configuration information, determining the first bottom-layer file directory as a second bottom-layer file directory corresponding to the second pipeline configuration information;

and if a target first working directory comprising the item cache information corresponding to the second pipeline configuration information exists in the first working directory corresponding to the first continuous integration task, determining the target first working directory as a second bottom file directory corresponding to the second pipeline configuration information.

In another aspect, an embodiment of the present application provides an electronic device, including a processor and a memory, where the processor and the memory are connected to each other;

the memory is used for storing a computer program;

the processor is configured to execute the construction method of the continuous integration task provided by the embodiment of the application when the computer program is called.

In another aspect, embodiments of the present application provide a computer readable storage medium storing a computer program that is executed by a processor to implement the method for constructing the continuous integration task provided by the embodiments of the present application.

In another aspect, embodiments of the present application provide a computer program product, where the computer program product includes a computer program or computer instructions that, when executed by a processor, implement a method for implementing the continuous integration task provided in the embodiments of the present application.

In the embodiment of the application, because each continuous integration task corresponding to each pipeline is constructed through the corresponding working catalog, construction and execution processes among the continuous integration tasks corresponding to each pipeline are not mutually influenced, so that construction efficiency of the continuous integration tasks can be improved, execution efficiency and stability of the continuous integration tasks are improved, and applicability is high.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

Fig. 1 is a flow chart of a method for constructing a continuous integration task according to an embodiment of the present application;

FIG. 2 is a schematic diagram of a scenario for determining a working catalog provided in an embodiment of the present application;

FIG. 3 is a code schematic flow chart of a method for constructing a continuous integration task provided in an embodiment of the present application;

FIG. 4 is a schematic diagram of the time spent building a working catalog provided by an embodiment of the present application;

FIG. 5 is a schematic structural diagram of a construction device for continuous integration tasks provided in an embodiment of the present application;

fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

The following description of the embodiments of the present application will be made clearly and fully with reference to the accompanying drawings, in which it is evident that the embodiments described are only some, but not all, of the embodiments of the present application. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are within the scope of the present disclosure.

The method for constructing the continuous integration task provided by the embodiment of the application can be applied to the field of software development, such as a continuous integration system or a server with continuous integration service in the scenes of game development, system development, application development and the like, and is not limited.

The server may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server providing cloud computing service, which is not limited herein.

The construction method of the continuous integration task provided by the embodiment of the application can continuously integrate related system or project function codes in the fields of artificial intelligence, intelligent traffic, automatic driving, internet of things and the like so as to complete testing, publishing, deployment and the like of the corresponding system or function.

For example, based on the method for constructing the continuous integration task provided by the embodiment of the application, the continuous integration task corresponding to each pipeline in the development stage of the automatic driving system can be constructed. For another example, based on the method for constructing the continuous integration task provided in the embodiment of the present application, the continuous integration task corresponding to the implementation code of the related neural network function involved in the machine learning process may be constructed, which is not limited herein.

The machine learning is a multi-field interdisciplinary, and relates to a plurality of disciplines such as probability theory, statistics, approximation theory, convex analysis, algorithm complexity theory and the like. It is specially studied how a computer simulates or implements learning behavior of a human to acquire new knowledge or skills, and reorganizes existing knowledge structures to continuously improve own performance. Machine learning is the core of artificial intelligence, a fundamental approach to letting computers have intelligence, which is applied throughout various areas of artificial intelligence.

Referring to fig. 1, fig. 1 is a flow chart of a method for constructing a continuous integration task according to an embodiment of the present application. The construction method for the continuous integration task provided by the embodiment of the application specifically comprises the following steps:

step S11, acquiring item cache information and first pipeline configuration information.

The pipeline in the embodiment of the application refers to a series of tasks executed on a continuous integrated system, and the tasks comprise the whole process from code submission, continuous integrated task construction, deployment, testing and release, and provide visualization and timely feedback for teams. Wherein a pipeline divides the process into different stages and can execute a plurality of continuous integration tasks in parallel.

In some possible embodiments, the item cache information may be obtained before a pipeline begins.

The project cache information includes project codes, project dependency packages and other cache information needed for building the continuous integration task, which can be specifically determined based on actual application scene requirements without limitation. Wherein, the project dependent package refers to a program package on which continuous integration tasks are dependent.

The project cache information may include project codes corresponding to the current pipeline, project dependent packages, and other cache information required for constructing each continuous integration task corresponding to the current pipeline, or may include all project codes, corresponding project dependent packages, and other code cache information required for constructing all continuous integration tasks, which may be specifically determined based on actual application scenario requirements, without limitation.

The project cache information may be obtained from a local cache, or may be obtained from a code server, a database, a cloud storage space and a blockchain based on a remote pulling manner, and may be specifically determined based on actual application scene requirements, which is not limited herein.

The database can be considered as an electronic filing cabinet, namely a place for storing electronic files, and can be used for caching information of items in the application. Blockchains are novel application modes of computer technologies such as distributed data storage, point-to-point transmission, consensus mechanisms, encryption algorithms, and the like. Blockchains are essentially a de-centralized database, which is a string of data blocks that are generated in association using cryptographic methods. In this application, each data block in the blockchain may store item cache information. Cloud storage is a new concept which extends and develops in the concept of cloud computing, and refers to that a large number of storage devices (storage devices are also called storage nodes) of different types in a network are combined to work cooperatively through application software or application interfaces through functions of cluster application, grid technology, distributed storage file systems and the like to jointly store project cache information. The code server may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server for providing cloud computing service, which is not limited herein.

In some possible embodiments, after the item cache information is acquired, pipeline configuration information corresponding to the current pipeline may be acquired, and for convenience of description, the pipeline configuration information corresponding to the current pipeline is hereinafter referred to as first pipeline configuration information.

The first pipeline configuration information may be used to configure execution sequence, execution environment, supported services, and other relevant configuration information of each continuous integration task corresponding to the current pipeline, that is, based on the first pipeline configuration information, the configuration information of each continuous integration task corresponding to the current pipeline may be determined, or based on the first pipeline configuration information, at least one continuous integration task that needs to be executed by the current pipeline may be determined. For convenience of description, each continuous integration task corresponding to the first pipeline configuration information is hereinafter referred to as a first continuous integration task.

The first continuous integration tasks corresponding to the first pipeline configuration information may be concurrent continuous integration tasks, or continuous integration tasks performed at different times and configured by the first pipeline configuration information, which may be specifically determined based on actual application scenario requirements, and are not limited herein.

The pipeline configuration information may be determined through a user configuration interface or by receiving a user's configuration file, without limitation.

For example, when the runtime environment for the persistent integration task needs to execute on a container basis, the first pipeline configuration information may be generated by asserting a docker: dind services illustrate that operations such as building container mirroring (dockerbuild) or logging in container mirroring warehouse (dockerlogin) are needed in the building process of continuous integration tasks. A cache retention mechanism may also be provided for the container by asserting a docker-with-cache service.

For example, the first pipeline configuration information may specify that a gate-actions function needs to be used during construction of the persistent integration task by asserting a gate-actions service, may specify that a code copy operation is supported in a different data capacity scenario, may specify that a terraform operation status needs to be used during construction of the persistent integration task by asserting an operator-for-status service, and may specify that a code repository, such as an intranet code repository, needs to be accessed during construction of the persistent integration task by asserting a ssh-agent-for-oa service.

It should be specifically noted that the service declared by the first pipeline configuration information is only an example, and may be specifically determined based on the actual application scenario requirement, which is not limited herein.

Step S12, determining the item cache information as a first bottom file directory corresponding to the first pipeline configuration information, and constructing a first work directory corresponding to each first continuous integration task based on the first bottom file directory.

In some possible embodiments, after the item cache information is obtained, the item cache information may be used as a lower file directory (lowerdir) corresponding to the first pipeline configuration information, which is hereinafter referred to as a first lower file directory for convenience of description. Or an empty file directory may be created first, and the obtained item cache information may be stored in the file directory, so that the file directory is used as a first bottom file directory corresponding to the first pipeline configuration information.

Further, a first working directory corresponding to each first persistent integration task may be constructed based on the first underlying file directory. The continuous integration tasks corresponding to each pipeline may correspond to the same working catalog, that is, the first continuous integration tasks may correspond to the same first working catalog, where the first working catalog includes item cache information required for constructing the first continuous integration tasks.

Specifically, an empty directory may be created as an upper directory (upper), and item cache information corresponding to each first persistent integration task and needing modification in the first bottom file directory is written into the upper directory based on copy-on-write (copy-on-write), and further sorted into a first working directory corresponding to each first persistent integration task. And the item cache information which corresponds to each first continuous integration task and does not need to be modified in the first bottom file directory can be directly read based on a copy-on-write mechanism.

Alternatively, each persistent integration task corresponding to each pipeline may correspond to a different work directory, i.e., each first persistent integration task may correspond to an independent first work directory, where each first work directory includes item cache information required for building the corresponding first persistent integration task.

Specifically, an empty directory may be created as an upper directory (upper) for each first persistent integration task, the item cache information corresponding to the first persistent integration task and needing modification in the first bottom file directory is written into the upper directory corresponding to the first persistent integration task based on a copy-on-write mechanism, and the upper directory corresponding to the first persistent integration task is further sorted into a working directory (merge) corresponding to the first persistent integration task. The information of the first underlying file directory, which corresponds to the first persistent integration task and does not need to be modified, may be directly read from the first underlying file directory based on a copy-on-write mechanism.

The sorting of the upper-layer directory includes, but is not limited to, modifying, deleting, etc. the item cache information in the upper-layer directory, which may be specifically implemented through a file service system (such as an overlay fs), which is not limited herein.

For each first continuous integration task, when it is determined that the first continuous integration task needs to be built based on the first pipeline configuration information, the first work catalogue corresponding to the first continuous integration task may be determined, that is, the first work catalogues corresponding to different first continuous integration tasks may be determined at different times.

For example, when two concurrent first persistent integration tasks need to be built, an upper-layer directory may be created for each first persistent integration task, and a first work directory corresponding to each first persistent integration task may be obtained based on a copy-on-write mechanism and a corresponding first bottom-layer directory. For other first continuous integration tasks corresponding to the first pipeline configuration information, the corresponding first working catalog can be determined when the first continuous integration task needs to be constructed.

Referring to fig. 2, fig. 2 is a schematic view of a scenario for determining a working directory according to an embodiment of the present application. As shown in fig. 2, the item cache information may be pulled by a local acquisition or a remote acquisition, and the item cache information is used as an underlying file directory (lowerdir) corresponding to the pipeline configuration information.

Further, if each persistent integration task corresponding to the pipeline configuration information corresponds to a different working directory, an empty directory may be created as an upper directory (upperdir) for each persistent integration task corresponding to the pipeline configuration information. For each continuous integration task, the item cache information which corresponds to the continuous integration task and needs to be modified in the bottom layer file directory can be written into the corresponding upper layer directory based on copy-on-write mechanism, and then the corresponding upper layer directory is arranged into a work directory (merge) corresponding to the continuous integration task. The information of the item cache corresponding to the first continuous integration task in the bottom file directory without modification can be directly read from the bottom file directory based on a copy-on-write mechanism.

The process of determining the item cache information as the bottom file directory and determining the working directory corresponding to each continuous integration task based on the bottom file directory may be implemented through a file service system (such as an overlay fs) or may be implemented through a preconfigured function code, which is not limited herein.

And S13, constructing each first continuous integration task based on the first work catalogue corresponding to each first continuous integration task and the first pipeline configuration information.

Specifically, for each first continuous integration task, the project code submission record corresponding to the first continuous integration task may be determined based on the first pipeline configuration information, that is, the work area of the first continuous integration task in the project code may be determined based on the first pipeline configuration information. And determining target project cache information corresponding to the project code submitting record from the first work catalogue corresponding to the first continuous integration task, namely determining target project cache information required by the first continuous integration task from the project codes of the first work catalogue corresponding to the first continuous integration task, such as determining partial project codes required by the first continuous integration task, project dependency package required by executing the first continuous integration task and other code information.

Further, for each first persistent integration task, after determining corresponding target item cache information from the first persistent integration task based on the first pipeline configuration information, the first persistent integration task may be constructed based on the target item cache information. The first continuous integration task is constructed based on the part of project codes required by the first continuous integration task, project dependency packages required by the first continuous integration task, and the like, so that the first continuous integration task can be executed to complete corresponding test requirements.

The method for constructing the continuous integration task according to the embodiment of the present application is further described below with reference to fig. 3, and fig. 3 is a code schematic flowchart of the method for constructing the continuous integration task according to the embodiment of the present application, where the method for constructing the continuous integration task shown in fig. 3 is performed based on a distributed version control system (taking a git distributed version control system as an example). When the continuous integration task is first constructed, initialization (gitinit) may be performed to clear interference of irrelevant codes to the continuous integration task, and then project cache information (git-cache) may be remotely obtained from a code server based on a gitfetch operation, where the code server is a server that may be used to access codes and has a distributed version control function for the codes, and is not limited herein.

Further, the switch to main code may be based on the gatcheckout master instruction to build an underlying file directory (lowerdir) corresponding to all persistent integration tasks corresponding to the pipeline configuration file based on the item cache information. And, for each continuous integration task, while creating an empty directory (empty) for the continuous integration task as an upper directory (upper), the relevant item cache information in the bottom file directory can be written into the upper directory through copy-on-write mechanism to obtain a working directory (merge) corresponding to each continuous integration task. The item cache information in each upper directory is covered by the corresponding working directory, and the working directory can be regarded as an installation directory of the file service system.

The upper-level directory and the working directory may be stored in a temporary file system (tmpfs), and each continuous integration task may correspond to the same working directory, or each continuous integration task may correspond to a different working directory, which may be specifically determined based on the actual application scenario requirements, and is not limited herein.

Further, for each continuous integration task, the submission record of the project cache information in the work directory corresponding to the continuous integration task can be checked through the gatcheckokout instruction so as to switch to the project code submission record specified by the pipeline configuration information for the continuous integration task. And determining target item cache information corresponding to the project code submitting record from the first working catalog corresponding to the continuous integration task, and merging the target item cache information corresponding to the project code submitting record in a working area (workspace) corresponding to the continuous integration task through a git-merge instruction so as to be used for constructing the continuous integration task.

In some possible implementations, the first pipeline configuration information may indicate a cache scenario to which the construction method of the continuous integration task is applicable by declaring a data volume configuration. For example, copy-on-write is stated to illustrate that operations such as reading, writing, changing (adding, modifying, deleting) and the like can be performed on the project cache information corresponding to each continuous integration task based on a copy-on-write mechanism, and merging is performed after the continuous integration task is constructed and executed successfully, so that the construction method of the continuous integration task is illustrated to be suitable for a consistent cache scene.

For another example, copy-on-write-overlapping is stated to indicate that operations such as reading, writing, changing (adding and modifying) can be performed on the item cache information corresponding to each continuous integration task based on the copy-on-write mechanism, and merging is performed after the continuous integration task is constructed and executed successfully, so that the construction method of the continuous integration task is stated to be suitable for the stackable cache scene.

For another example, copy-on-write-immutable is stated to illustrate that the copy-on-write-immutable can read, write and change (add) the item cache information corresponding to each continuous integration task based on the copy-on-write mechanism, and merge after the continuous integration task is constructed and executed successfully, so that the construction method of the continuous integration task is suitable for the unchangeable cache scene.

For another example, by declaring copy-on-write-read-only, it is described that read-only and change (new addition) operations can be performed on the item cache information corresponding to each persistent integration task based on the copy-on-write mechanism, and discarding is performed after the persistent integration task is constructed and executed successfully.

In some possible embodiments, after each first persistent integration task corresponding to the first pipeline configuration information is constructed, each first persistent integration task may be performed based on the related service declared by the first pipeline configuration information and other configuration information.

For example, the execution time corresponding to each first continuous integration task may be determined based on the first pipeline configuration information, and then the first continuous integration task is executed at the integration time corresponding to each first continuous integration task.

Further, for each first continuous integration task, an execution result of the first continuous integration task may be obtained, and a first working directory corresponding to the first continuous integration task is updated based on the execution result corresponding to the first continuous integration task.

For example, for each first continuous integration task, the relevant codes and the like in the first working directory corresponding to the first continuous integration task may be updated based on the execution result corresponding to the first continuous integration task, where the updating manner includes, but is not limited to, deleting part of codes, modifying part of codes, adding part of codes and the like, and may be specifically determined based on the actual application scenario requirements, which is not limited herein.

Because the different first continuous integration tasks are built by the corresponding first working catalogues, when the plurality of first continuous integration tasks are executed concurrently, the execution processes of the different first continuous integration tasks are not interfered with each other, and the corresponding first working catalogues can be updated based on the execution results of the different first continuous integration tasks, so that the execution of other first continuous integration tasks is not influenced.

In some possible embodiments, for each first persistent integration task, when the first persistent integration task is constructed based on the first working directory and the first pipeline configuration information corresponding to the persistent integration task, the code modification request for the first persistent integration task may also be responded, and the item cache information in the first working directory corresponding to the first persistent integration task is modified based on the code modification request, so that the modified item cache information better meets the actual requirement of the first persistent integration task.

The modification manner of the first working directory also includes, but is not limited to, deleting a part of code, modifying a part of code, adding a part of code, etc., which may be specifically determined based on the actual application scenario requirement, and is not limited herein.

Optionally, for each first persistent integration task, after determining the corresponding target item cache information from the first work directory corresponding to the first persistent integration task, the code modification request for the target item cache information may be responded to, so as to modify the target item cache information based on the code modification request.

Likewise, the way to modify the target item cache information includes, but is not limited to, deleting part codes, modifying part codes, adding part codes, etc., which can be specifically determined based on the actual application scenario requirements, and is not limited thereto

In some possible embodiments, after determining the execution result corresponding to each first persistent integration task, the first underlying file directory may be updated based on the execution result corresponding to each first persistent integration task. Namely, the item cache information in the first bottom-layer file directory can be updated through the execution result of each first continuous integration task, such as updating item codes, updating item dependency packages and the like. Optionally, after determining the execution result of one first continuous integration task, the first bottom file directory may be updated while executing other first continuous integration tasks, so as to improve update efficiency.

After the execution of each first continuous integration task is completed and the execution result is stable, the original project cache information can be updated based on the updated first bottom file directory without testing each first continuous integration task corresponding to the first pipeline configuration information.

Optionally, after updating the corresponding first working directory based on the execution result corresponding to each first continuous integration task, the first underlying file directory may be updated based on the updated first working directory corresponding to each first continuous integration task.

For example, when each of the first persistent integration tasks corresponds to the same first working directory, after the first working directory is updated based on the execution result corresponding to each of the first persistent integration tasks, the updated first working directory may be stored as newly added item cache information in the first underlying file directory, so that updating of the item cache information in the first underlying file directory is achieved based on the updated first working directory.

For example, when each of the first persistent integration tasks corresponds to a different first working directory, after updating the corresponding first working directory based on the execution result corresponding to each of the first persistent integration tasks, each of the updated first working directories may be stored as newly added item cache information in the first underlying file directory, so that updating of the item cache information in the first underlying file directory may be implemented based on the updated first working directory corresponding to each of the persistent integration tasks.

After the first bottom file directory is updated based on the updated first working directory corresponding to each first continuous integration task and each first continuous integration task is executed, the first working directory corresponding to each first continuous integration task can be discarded, so that consumption of memory resources by the first working directory is reduced.

The process of updating the corresponding first working directory based on the execution result of each first continuous integration task, the process of updating the first bottom file directory based on the execution result of each first continuous integration task, and the process of updating the first bottom file directory based on the updated first working directory corresponding to each first continuous integration task may be implemented based on a file service system (e.g., overlay fs), which is not described herein.

In some possible embodiments, in the case that the obtained item cache information or the item cache information in the first underlying file directory only includes the item code corresponding to the current pipeline, the item dependency package, and other cache information required for building each persistent integration task corresponding to the current pipeline, for the concurrent pipeline corresponding to the current pipeline or other pipelines (for convenience of description, hereinafter referred to as a second pipeline) after the current pipeline, when the persistent integration task corresponding to the second pipeline needs to be built, pipeline configuration information corresponding to the second pipeline (for convenience of description, hereinafter referred to as second pipeline configuration information) may be obtained first, where the second pipeline configuration information also corresponds to at least one persistent integration task (for convenience of description, hereinafter referred to as a second persistent integration task) of the second pipeline.

Further, based on the second pipeline configuration information, determining whether the item cache information in the first bottom file directory corresponding to the first pipeline configuration information includes the item cache information required by the second pipeline configuration information, that is, based on the second pipeline configuration information, determining whether the first bottom file directory includes the item code, the item dependency package and other cache information required by constructing each second continuous integration task corresponding to the second pipeline configuration information.

If so, the first bottom file directory corresponding to the first pipeline configuration information can be determined to be a second bottom file directory corresponding to the second pipeline configuration information, and further, a work directory corresponding to each second continuous integration task (for convenience of description, hereinafter referred to as a second work directory) is constructed based on the second bottom file directory, so that for each second continuous integration task, the second continuous integration task can be constructed based on the second work directory corresponding to the second continuous integration task and the second pipeline configuration information.

Optionally, in the case that the obtained item cache information or the item cache information in the first underlying file directory only includes all item codes, corresponding item dependency packages, and other cache information required for building all continuous integration tasks, when each second continuous integration task corresponding to the second pipeline needs to be built, the first underlying file directory corresponding to the first pipeline configuration information may be directly determined as the second underlying file directory corresponding to the second pipeline configuration information, and further, a second work directory corresponding to each second continuous integration task may be built based on the second underlying file directory, so that for each second continuous integration task, the second continuous integration task may be built based on the second work directory corresponding to the second continuous integration task and the second pipeline configuration information.

Based on the above, under the condition that the subsequent pipeline or other concurrent pipelines of the current pipeline need to use the same item cache information as the first bottom file directory in the process of constructing the corresponding continuous integration task, the bottom file directory corresponding to the first pipeline configuration information can be directly multiplexed, so that the corresponding item cache information is not acquired again, the total consumption of the subsequent continuous integration task constructing is reduced, and the construction efficiency of the continuous integration task is improved.

For each second continuous integration task, the implementation process of constructing the second continuous integration task based on the second working catalog and the second pipeline configuration information corresponding to the second continuous integration task is the same as the implementation manner of constructing the corresponding first continuous integration task based on the first working catalog and the first pipeline configuration information corresponding to each first continuous integration task, and each second continuous integration task may respectively correspond to different second working catalogues or may also correspond to the same second working catalog, which is not described herein again.

In some possible embodiments, when determining the second bottom-layer file directory corresponding to each second continuous integration task, the determination may also be based on the work directories corresponding to continuous integration tasks corresponding to other pipelines. Specifically, if there is a working directory including the item cache information required for the second pipeline configuration information, the working directory may be directly determined as the second underlying file directory corresponding to the second pipeline.

For example, in the case that each of the first persistent integration tasks corresponds to the same first working directory, if the first working directory includes the item cache information required by the second pipeline configuration information, the first working directory may be determined as the second underlying file directory corresponding to the second pipeline configuration information. Under the condition that each first continuous integration task corresponds to a different first working catalog respectively, a target first working catalog including item cache information required by the second pipeline configuration new information can be determined from each first working catalog, and the target first working catalog is determined to be a second bottom file catalog corresponding to the second pipeline configuration information.

Based on the above, in the process of constructing the continuous integration task corresponding to any pipeline, if any working directory of other pipelines includes the item cache information required for constructing the continuous integration task corresponding to the pipeline, the working directory can be directly reused as the bottom file directory, so that the construction efficiency of the continuous integration task is improved.

In some possible embodiments, before the second work catalogue corresponding to each first continuous integration task is built based on the first bottom file catalogue and the second work catalogue corresponding to each second continuous integration task is built based on the second bottom file catalogue, if the corresponding item cache information needs to be updated, the corresponding first bottom file catalogue or the corresponding second bottom file catalogue is directly updated, so that the time consumed for re-acquiring the item cache information is reduced.

The effect of the method for constructing the continuous integration task provided in the embodiment of the present application is further described below with reference to fig. 4. Fig. 4 is a schematic diagram of time spent building a working catalog according to an embodiment of the present application. In the prior art, for each pipeline, each continuous integration task is constructed, item codes need to be pulled once, and the continuous integration task is constructed with a large code volume and takes a long time. And when the continuous integration tasks corresponding to other pipelines are constructed, project codes need to be pulled again to ensure the normal operation of the pipelines, so that longer time is further consumed.

Based on the construction method of the continuous integration task provided by the embodiment of the application, under the condition that the total project cache information is 8GB, after the assembly line configuration information is submitted for the first time, the time consumption for acquiring all project cache information to construct the work catalogue corresponding to each continuous integration task is 7s. When the pipeline configuration information is submitted each time thereafter, the bottom file directory corresponding to the pipeline configuration file at this time can be determined based on the bottom file directories corresponding to other pipelines or the working directories corresponding to the continuous integration tasks before the bottom file directory, and all item cache information does not need to be acquired again, so that the time consumed for constructing the working directories corresponding to each continuous integration task when the pipeline configuration information is submitted each time thereafter is smaller than the time consumed for constructing the working directories for the first time, and the construction efficiency of the continuous integration tasks is improved.

According to the construction method for the continuous integration tasks, which is provided by the embodiment of the application, because each continuous integration task corresponding to each pipeline is constructed through the corresponding working catalog, construction and execution processes among the continuous integration tasks corresponding to each pipeline are not affected, so that the construction and execution of each continuous integration task corresponding to each pipeline can be carried out concurrently, and construction and execution efficiency of the continuous integration tasks is further improved. Meanwhile, as the bottom file catalogue or the working catalogue corresponding to the previous pipeline or the concurrent pipeline can be reused at the moment of constructing the continuous integration task corresponding to each pipeline, the number of times of repeatedly acquiring the project cache information can be reduced, the acquisition time can be shortened, the construction efficiency and the stability of the continuous integration task can be improved, the consumption of memory resources can be greatly reduced, and the applicability is high.

Referring to fig. 5, fig. 5 is a schematic structural diagram of a construction device for continuous integration tasks according to an embodiment of the present application. The device for constructing the continuous integration task provided by the embodiment of the application comprises the following steps:

an information obtaining module 51, configured to obtain item cache information and first pipeline configuration information, where the first pipeline configuration information corresponds to at least one first continuous integration task;

The catalog construction module 52 is configured to determine the item cache information as a first bottom file catalog corresponding to the first pipeline configuration information, and construct a first work catalog corresponding to each of the first continuous integration tasks based on the first bottom file catalog;

the task construction module 53 is configured to construct each first persistent integration task based on the first work directory corresponding to the first persistent integration task and the first pipeline configuration information.

In some possible embodiments, when constructing each of the first persistent integration tasks based on the first work directory corresponding to the first persistent integration task and the first pipeline configuration information, the task construction module 53 is configured to:

In some possible embodiments, the catalog construction module 52 is further configured to:

In some possible embodiments, the information obtaining module 51 is further configured to:

The catalog construction module 52 is further configured to:

the task construction module 53 is further configured to:

In some possible embodiments, when determining the second bottom file directory corresponding to the second pipeline configuration information from the first bottom file directory and the first working directory corresponding to each of the first continuous integration tasks, the directory construction module 52 is further configured to:

and if a target first working directory comprising the item cache information corresponding to the second pipeline configuration information exists in the first working directory corresponding to each first continuous integration task, determining the target first working directory as a second bottom file directory corresponding to the second pipeline configuration information.

In a specific implementation, the implementation manner provided by each step in fig. 1 may be executed by the device for constructing a continuous integration task through each built-in functional module, and specifically, the implementation manner provided by each step may be referred to, which is not described herein again.

According to the continuous integration task constructing device provided by the embodiment of the application, as each continuous integration task corresponding to each pipeline is constructed through the corresponding working catalog, construction and execution processes among the continuous integration tasks corresponding to each pipeline are not affected, so that the construction and execution of each continuous integration task corresponding to each pipeline can be carried out concurrently, and construction and execution efficiency of the continuous integration tasks is further improved. Meanwhile, as the bottom file catalogue or the working catalogue corresponding to the previous pipeline or the concurrent pipeline can be reused at the moment of constructing the continuous integration task corresponding to each pipeline, the number of times of repeatedly acquiring the project cache information can be reduced, the acquisition time can be shortened, the construction efficiency and the stability of the continuous integration task can be improved, the consumption of memory resources can be greatly reduced, and the applicability is high.

Referring to fig. 6, fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present application. As shown in fig. 6, the electronic device 600 in the present embodiment may include: processor 601, network interface 604 and memory 605, in addition, the electronic device 600 may further include: a user interface 603, and at least one communication bus 602. Wherein the communication bus 602 is used to enable connected communications between these components. The user interface 603 may include a Display screen (Display), a Keyboard (Keyboard), and the optional user interface 603 may further include a standard wired interface, a wireless interface, among others. The network interface 604 may optionally include a standard wired interface, a wireless interface (e.g., WI-FI interface). The memory 604 may be a high-speed RAM memory or a non-volatile memory (NVM), such as at least one disk memory. The memory 605 may also optionally be at least one storage device located remotely from the processor 601. As shown in fig. 6, an operating system, a network communication module, a user interface module, and a device control application may be included in the memory 605, which is one type of computer-readable storage medium.

In the electronic device 600 shown in fig. 6, the network interface 604 may provide network communication functions; while the user interface 603 is primarily an interface for providing input to the user; and processor 601 may be used to invoke a device control application stored in memory 605 to implement:

In some possible embodiments, the processor 601 is configured to:

In some possible embodiments, the above processor 601 is further configured to:

In some possible embodiments, the processor 601 is configured to:

It should be appreciated that in some possible embodiments, the above-described processor 601 may be a central processing unit (central processing unit, CPU), which may also be other general purpose processors, digital signal processors (digital signal processor, DSP), application specific integrated circuits (application specific integrated circuit, ASIC), off-the-shelf programmable gate arrays (field-programmable gate array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or the like. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The memory may include read only memory and random access memory and provide instructions and data to the processor. A portion of the memory may also include non-volatile random access memory. For example, the memory may also store information of the device type.

In a specific implementation, the electronic device 600 may execute, through each functional module built in the electronic device, an implementation manner provided by each step in fig. 1, and specifically, the implementation manner provided by each step may be referred to, which is not described herein again.

The embodiments of the present application further provide a computer readable storage medium, where a computer program is stored and executed by a processor to implement the method provided by each step in fig. 1, and specifically refer to the implementation manner provided by each step, which is not described herein.

The computer readable storage medium may be the construction device for continuous integration task provided in any of the foregoing embodiments or an internal storage unit of the electronic device, for example, a hard disk or a memory of the electronic device. The computer readable storage medium may also be an external storage device of the electronic device, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) card, a flash card (flash card) or the like, which are provided on the electronic device. The computer readable storage medium may also include a magnetic disk, an optical disk, a read-only memory (ROM), a random access memory (randomaccess memory, RAM), or the like. Further, the computer-readable storage medium may also include both an internal storage unit and an external storage device of the electronic device. The computer-readable storage medium is used to store the computer program and other programs and data required by the electronic device. The computer-readable storage medium may also be used to temporarily store data that has been output or is to be output.

The present embodiments provide a computer program product comprising a computer program or computer instructions which, when executed by a processor, provide a method for constructing a continuous integration task.

The terms "first," "second," and the like in the claims and specification and drawings of this application are used for distinguishing between different objects and not for describing a particular sequential order. Furthermore, the terms "comprise" and "have," as well as any variations thereof, are intended to cover a non-exclusive inclusion. For example, a process, method, system, article, or electronic device that comprises a list of steps or elements is not limited to the list of steps or elements but may, alternatively, include other steps or elements not listed or inherent to such process, method, article, or electronic device. Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the present application. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments. The term "and/or" as used in this specification and the appended claims refers to any and all possible combinations of one or more of the associated listed items, and includes such combinations.

Those of ordinary skill in the art will appreciate that the elements and algorithm steps described in connection with the embodiments disclosed herein may be embodied in electronic hardware, in computer software, or in a combination of the two, and that the elements and steps of the examples have been generally described in terms of function in the foregoing description to clearly illustrate the interchangeability of hardware and software. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.

The foregoing disclosure is only illustrative of the preferred embodiments of the present application and is not to be construed as limiting the scope of the claims, and therefore, equivalent variations in terms of the claims are intended to be included herein.

Claims

1. A method of constructing a continuous integration task, the method comprising:

determining the item cache information as a first bottom file directory corresponding to the first pipeline configuration information, and constructing a first working directory corresponding to each first continuous integration task based on the first bottom file directory;

2. The method of claim 1, wherein constructing each first persistent integration task based on the first work directory corresponding to the first persistent integration task and the first pipeline configuration information comprises:

3. The method according to claim 1, wherein the method further comprises:

4. The method according to claim 1, wherein the method further comprises:

and responding to a code modification request for each first continuous integration task, and modifying the item cache information in the first work catalogue corresponding to each first continuous integration task based on the code modification request.

5. A method according to claim 3, further comprising at least one of:

6. The method according to claim 1, wherein the method further comprises:

And constructing each second continuous integration task based on a second work directory corresponding to each second continuous integration task and the second pipeline configuration information.

7. The method of claim 6, wherein determining a second underlying file directory corresponding to the second pipeline configuration information from the first underlying file directory and a first working directory corresponding to each of the first persistent integration tasks, comprises:

if the item cache information in the first bottom-layer file directory comprises the item cache information corresponding to the second pipeline configuration information, determining the first bottom-layer file directory as a second bottom-layer file directory corresponding to the second pipeline configuration information;

8. A build device for continuous integration tasks, the device comprising:

the information acquisition module is used for acquiring project cache information and first pipeline configuration information, wherein the first pipeline configuration information corresponds to at least one first continuous integration task;

9. An electronic device comprising a processor and a memory, the processor and the memory being interconnected;

the memory is used for storing a computer program;

the processor is configured to perform the method of any of claims 1 to 7 when the computer program is invoked.

10. A computer readable storage medium, characterized in that the computer readable storage medium stores a computer program, which is executed by a processor to implement the method of any one of claims 1 to 7.