WO2023051034A1

WO2023051034A1 - Terminal code incremental compilation method, system, apparatus, server, and storage medium

Info

Publication number: WO2023051034A1
Application number: PCT/CN2022/110947
Authority: WO
Inventors: 齐祥
Original assignee: 中兴通讯股份有限公司
Priority date: 2021-09-30
Filing date: 2022-08-08
Publication date: 2023-04-06
Also published as: CN115878121A

Abstract

The present application relates to a terminal code incremental compilation method, a system, an apparatus, a server, and a storage medium. The terminal code incremental compilation method comprises: acquiring a compilation task by means of a front-end configuration interface (101); according to the compilation task, determining a target compilation server matching the compilation task from among multiple compilation server clusters (102); and sending the compilation task to the matching target compilation server, so that the target compilation server obtains a file to be compiled from a distributed file storage system so as to perform incremental compilation of code (103). The multiple compilation server clusters are server clusters of different platforms, and the compilation server clusters share the distributed file storage system.

Description

Terminal code incremental compilation method, system, device, server and storage medium

Cross References to Related Applications

This application is based on a Chinese patent application with application number 202111162661.0 and a filing date of September 30, 2021, and claims the priority of this Chinese patent application. The entire content of this Chinese patent application is hereby incorporated by reference into this application.

technical field

The embodiments of the present application relate to the computer field, and in particular to a terminal code incremental compilation method, system, device, server and storage medium.

Background technique

In the process of mobile phone software development, a large amount of code is involved. When software needs a baseline upgrade, when software requirements change, or when there are unresolved bugs in the software, developers make extensive changes to the code.

In the process of compiling the code, R&D personnel often download the code on a fixed large-capacity compiler. After the code download is completed, the R&D personnel manually merge the incremental code, and then perform incremental compilation.

However, the hardware and software resources of the compiler selected by the R&D personnel may not match the requirements for hardware and software resources in the actual compilation process, that is, it is difficult to reasonably allocate hardware and software resources. Moreover, manually incorporating incremental code for compilation may cause a certain waste of human resources.

Contents of the invention

The main purpose of the embodiments of the present application is to provide a terminal code incremental compilation method, system, device, server and storage medium, which can rationally schedule software and hardware resources and save human resources.

In order to achieve the above purpose, the embodiment of the present application provides a terminal code incremental compilation method, including: obtaining the compilation task through the front-end configuration interface; according to the compilation task, determining the compilation task in multiple compilation server clusters A matching target compiling server; sending the compiling task to the matching target compiling server, for the target compiling server to obtain the file to be compiled from the distributed file storage system according to the compiling task for incremental compiling of the code; Wherein, the multiple compiling server clusters are server clusters of different platforms, and the compiling server clusters share the distributed file storage system.

In order to achieve the above purpose, the embodiment of the present application also provides a terminal code incremental compilation system, including: a distributed resource scheduling server, a compilation server cluster, and a distributed file storage system; the distributed resource scheduling server is used to configure an interface for obtaining a compiling task, determining a target compiling server matching the compiling task in a plurality of compiling server clusters according to the compiling task, and sending the compiling task to the matching target compiling server; the compiling The target compilation server in the server cluster is used to obtain the files to be compiled from the distributed file storage system according to the compilation task to perform incremental compilation of the code; the distributed file storage system is used to transmit the files to be compiled to the The target server; wherein, the compilation server clusters share the distributed file storage system; the multiple compilation server clusters are server clusters of different platforms.

In order to achieve the above purpose, the embodiment of the present application also provides a terminal code incremental compilation device, including: a configuration module, used to obtain compilation tasks through the front-end configuration interface; a distribution module, according to the compilation tasks, in multiple compilation Determine the target compilation server that matches the compilation task in the server cluster; the scheduling module sends the compilation task to the matched target compilation server for the target compilation server to download from the distributed file storage system according to the compilation task Acquire the files to be compiled to perform incremental compilation of the code; wherein, the multiple compilation server clusters are server clusters of different platforms, and the compilation server clusters share the distributed file storage system.

To achieve the above purpose, an embodiment of the present application further provides a server, including: at least one processor; and a memory connected to the at least one processor in communication; wherein, the memory stores information that can be used by the at least one processor An instruction executed by a processor, the instruction is executed by the at least one processor, so that the at least one processor can execute the above terminal code incremental compilation method.

To achieve the above object, an embodiment of the present application further provides a computer-readable storage medium storing a computer program, and implementing the above terminal code incremental compilation method when the computer program is executed by a processor.

Description of drawings

One or more embodiments are exemplified by pictures in the accompanying drawings, and these exemplifications are not intended to limit the embodiments.

Fig. 1 is a flowchart of a method for incrementally compiling terminal codes according to one embodiment of the present application;

FIG. 2 is a schematic diagram of a device for incrementally compiling terminal codes according to an embodiment of the present application;

Fig. 3 is a schematic diagram of a user configuration interface provided in an embodiment of the present application;

FIG. 4 is a schematic diagram of a terminal code incremental compilation device provided in an embodiment of the present application;

Fig. 5 is a schematic structural diagram of a server according to another embodiment of the present application.

Detailed ways

In order to make the purpose, technical solutions and advantages of the embodiments of the present application clearer, the embodiments of the present application will be described in detail below with reference to the accompanying drawings. However, those of ordinary skill in the art can understand that in each embodiment of the application, many technical details are provided for readers to better understand the application. However, even without these technical details and various changes and modifications based on the following embodiments, the technical solutions claimed in this application can also be realized. The division of the following embodiments is for the convenience of description, and should not constitute any limitation to the specific implementation of the present application, and the embodiments can be combined and referred to each other on the premise of no contradiction.

An embodiment of the present application relates to a terminal code incremental compilation method, which can be applied to a server, but is not limited thereto. The terminal code incremental compilation method in this embodiment includes: obtaining a compilation task through a front-end configuration interface; according to the compilation task, determining a target compilation server that matches the compilation task in a plurality of compilation server clusters; The compilation task is sent to the matching target compilation server for the target compilation server to obtain the files to be compiled from the distributed file storage system according to the compilation task for incremental compilation of the code; wherein, the multiple compilation server clusters It is a server cluster of different platforms, and the compilation server cluster shares the distributed file storage system.

In this embodiment, the compilation task is obtained through the front-end configuration interface, and the target server that matches the compilation task is determined in multiple server clusters according to the compilation task, so that there is no need for the R&D personnel to determine the server that needs to log in and log in remotely to compile. The R&D personnel only need to It is necessary to configure the compilation task to realize incremental compilation and save human resources. The target server in the embodiment of this application will automatically obtain the compiled code from the distributed storage system according to the compilation task and perform incremental compilation to realize the automatic scheduling of the server. , which makes the allocation of server resources more reasonable. Multiple server clusters are server clusters of different platforms, which conforms to the characteristics of multi-platform compilation of mobile phone software development, facilitates code maintenance and reduces maintenance costs.

The implementation details of this embodiment are described in detail below, and the following content is only implementation details provided for easy understanding, and is not necessary for implementing this solution.

The specific flow of the terminal code incremental compilation method of this embodiment can be shown in Figure 1, including:

Step 101, obtain compilation tasks through the front-end configuration interface.

In some embodiments, resource tags are carried in the compilation task. Nodes are servers in a compilation server cluster. Compiler server clusters can include multiple server clusters of different platforms, as shown in Figure 2, including Qualcomm platform clusters, MTK platform clusters, and Zhanrui platform clusters. Cluster servers on different platforms have different software and hardware resources, and resource labels represent The software and hardware resources required for incremental compilation, such as a certain compilation server cluster where the required compilation server is located, the number of CPU cores required for compilation, memory resources, etc. The resource tag may be a tag of a compiling server cluster, and each compiling server cluster may be configured with servers with different hardware resources.

Exemplarily, the server provides developers with a visual user configuration interface, as shown in the schematic diagram of the project configuration interface shown in Figure 3, to configure the projects involved in the compilation, which may include the following configuration items:

Searchfilter: gerrit web page query conditions.

Mergedfileter: the single number in the merge state.

CodeMode: Indicates the update code mode. The Dailybuild mode indicates that the code is updated based on the daily build code + the current searchfilter code; the Latest mode indicates that the code is updated after repo sync + the current searchfilter code based on the daily build code.

BuildMode: If AP is selected, it means that only the AP side is compiled; if Modem is selected, it means that only the Modem side is built.

Node: A resource label representing the software and hardware required for the compilation task, such as Qualcomm (qualcomm) label, mtk label, and Zhanrui (sprd) label.

NeedVersionFile: Indicates whether the version file needs to be uploaded to ftp for download after the incremental compilation is completed.

NeedOut: Indicates whether to keep the out directory before incremental compilation. If the value is Yes, it indicates that the ot directory is retained before incremental compilation. If the value is No, it indicates that the out directory is deleted before incremental compilation.

CompileProject: Characterizes the name of the project to be compiled.

The above configuration items are just examples, and can be set according to requirements in actual application.

The front-end configuration interface can also provide configurations such as task management, resource management, log management, and plug-in management. The server can be managed based on the configuration, and the compilation server cluster can be automatically scheduled.

1. Task management, including compilation task operation, compilation task execution configuration, compilation task trigger mode, compilation task execution status, etc.

1) Compile task operation: provide configuration functions such as adding, editing, and deleting tasks, obtaining task running status, task starting, suspending, pausing, and re-executing.

2) Compilation task execution configuration: Provide configuration functions including selection of execution process stages, corresponding manifest file, version type, task timeout control, compilation task failure retry, task failure alarm, etc.

3) Compilation task triggering mode: may include a scheduled task (Cron) mode, a task-dependent mode, and an execution mode of directly invoking an application programming interface (api) to trigger a task.

4) Compilation task execution status: success (success), failure (fail), abort (abort), etc.

2. Resource management: Add, edit and delete compilation server label information.

3. Log management: display of log information during incremental compilation.

4. Plug-in management: dynamically configure and upload plug-in dependent packages through the plug-in configuration service, complete the addition and modification of plug-ins, and meet rich and flexible business needs.

Step 102, according to the compiling task, determine a target compiling server matching the compiling task in multiple compiling server clusters. For example, the compiling task is matched with the server with the distributed resource scheduling engine in FIG. 2 , so as to allocate the target compiling server for the compiling task. The server with the distributed resource scheduling function is the same as the server with the continuous integration engine.

In some embodiments, according to the resource tag carried by the compiling task, the target server meeting the resource tag requirement is obtained. For example, if the resource tag carried by the compilation task is: qualcomm, then the target server that meets the resource tag requirement is a Qualcomm server. In this embodiment, the resource tag can be carried in the compilation task, which simplifies the configuration of the task by the R&D personnel and further reduces the labor cost. Moreover, the selection of the target server according to the software and hardware resources represented by the resource tag is in line with the requirements of different software projects when compiling. The demand for software and hardware resources improves compilation efficiency.

As shown in Figure 2, the distributed resource management engine includes the following functions.

1) Console configuration management includes: configure and compile server resources through configuration files, such as yaml and json, such as platform information, project information, CPU, memory, hard disk information, etc.

2) Access: Send the task conversion of the console to the scheduler, and register the task with the registration center.

3) Scheduler: Receives the scheduled tasks issued by the access, splits and distributes the tasks, finds the executor in the registration center, then sends the task to the executor for execution, and registers with the registration center at the same time.

4) Executor: Receive scheduling tasks and report the status to the registration center.

5) Registration center: synchronization and coordination of machine and task status.

Step 103 , sending the compiling task to the matching target compiling server, so that the target compiling server can obtain the file to be compiled from the distributed file storage system according to the compiling task to perform incremental compiling of the code. Wherein, the multiple compiling server clusters are server clusters of different platforms, and the compiling server clusters share the distributed file storage system.

In some embodiments, the target server obtains the file to be compiled from the distributed storage system according to the compilation task, and uses a generalized incremental compilation script to incrementally compile the compiled file, wherein the generalized incremental compilation script uses a shared library model. This embodiment uses a generalized incremental compilation script in the shared library mode, which is convenient for each platform to perform incremental compilation using the generalized incremental compilation script, facilitates code maintenance, and reduces maintenance costs.

In some embodiments, the file to be compiled is incrementally compiled in a container in the target compilation server, and the compilation environment of the container is consistent with the compilation environment configured for the file to be compiled. In order to avoid conflicts caused by installing different compilation environments on the same physical machine, such as installing the three compilation environments of Qualcomm, MTK, and Zhanrui, there will be conflicts. In the traditional compilation method, one compilation environment is often installed on a pure physical machine, for example The Zhanrui server is installed with the Zhanrui platform, and the Qualcomm server is installed with the Gaotong platform. This method will lead to low utilization of server resources. Therefore, when scheduling in this embodiment, the mirror server pulls the image and generates one or more containers for expansion. Quantitative compilation, the use of container technology will not cause conflicts on the one hand, on the other hand, different compilation environments can be enabled in the same server through containers, improving resource reuse.

An exemplary reference is shown in Figure 2. Install different platforms to divide the compilation server cluster into Qualcomm platform cluster and Zhanrui platform cluster. When scheduling, the mirror server pulls the image (image) and generates one or more containers for incremental compilation. .

In some embodiments, the first type of files in the distributed file storage system are transferred after being merged into the second type of files; the first type of files are files whose capacity is smaller than the first preset value, and the second type of files are files whose capacity reaches The file of the second default value. This embodiment avoids reading and writing operations of a large number of small files. In this embodiment, cache data is set to analyze small files for cache processing, and merge processing is performed after reaching the standard value of large files, so as to avoid IO read and write operations of a large number of small files.

In some embodiments, the code base file in the distributed file storage system is separated from the compilation process file, and the file to be compiled is obtained by duplicating the code base file and incremental code. Specifically, the code base file and the compilation process file are separated by stacking the file system. In this embodiment, a stacked file system is used to save a clean compilation environment, so that developers can compile simultaneously based on the same code base file.

In some embodiments, the compiled files of the distributed file storage system are deleted after the incremental compilation is completed. In traditional incremental compilation, developers will generate a large number of compilation process files after the first incremental compilation. When incremental compilation is performed again, the environment must be manually cleaned before incremental compilation can be performed again. Therefore, in this embodiment, the code base file and the compilation process file can be automatically cleaned up after the compilation is completed, that is, the environment is cleaned up, saving human resources, and, by stacking the file system Separate the code base file and the compilation process file to avoid a large number of compiled files from polluting the environment, and it is convenient for multiple people to perform incremental compilation at the same time. For example, stacked files can be divided into three layers, the base layer A can store the basic code file fileA, the change layer B can store fileB, and the C layer can store files: fileA and fileB, and the compilation server can call the C layer The files are incrementally compiled, and the files generated during the incremental compilation process can be put into the B layer at the same time. After the incremental compilation is completed, the files in the B layer and the C layer can be cleared.

Exemplarily, as shown in FIG. 2, the distributed file system may include the following parts:

1) The metadata service is used to record the metadata in the compilation server cluster, such as node information, SSD information, volume information, etc.

2) File access interface: responsible for providing external file read and write, delete, create and other operation functions.

3) Storage node cluster: responsible for storing basic code files and compiling process files.

4) Cache data analysis: A large number of small files will be generated for the mobile phone software version, so the cache data is set to analyze small files for caching processing, and then merge processing after reaching the standard value of large files to avoid IO read and write operations of a large number of small files. Wherein, the small file is the first type of file, the large file is the second type of file, and the standard value is the second preset value.

5) Stacked file system: separate code base files and compilation process files. By stacking the file system, a large number of compiled files can be avoided from polluting the environment, and it is convenient for multiple people to perform incremental compilation at the same time.

In the following, the compilation process is described by taking the code management tool as gerrit as an example.

The incremental compilation process of the mobile phone software version is as follows:

1. Set compilation task related parameters in the continuous integration engine startup task

2. Use the distributed resource scheduling engine to allocate compilation resources and determine the target compilation server.

3. The program downloads relevant generalized incremental compilation scripts from the code library according to the shared library information set in the compilation task.

4. Find the corresponding storage resources according to the project information and platform information in the compilation task filled in by R&D.

(1) Build and compile the full version every night, and store the code and compilation process files in the corresponding storage cluster according to the stored project information and platform information tags.

(2) During the incremental compilation every day, the basic code will be retrieved from the corresponding storage cluster according to the project information and platform information resource tags.

5. Update the incremental code according to the review document number (Merged Chang-Id, mergeid) of the Merge state in the set gerrit, and the review document number (Open Chang-Id, openid) of the Open state, using the cherry-pick function of gerrit Merge the incremental code into the basic environment of the corresponding label storage cluster. Among them, gerrit mergeid and openid can uniquely determine the incremental code.

6. According to the review document number (Merged Chang-Id, mergeid) of the Merge state, the review document number (Open Chang-Id, openid) of the Open state, and the manifest file information of the local code, determine whether the incremental code is consistent with the local code environment , whether there is a conflict with the local:

If the environment is consistent and there are no conflicts, compile normally. The compilation process is carried out in the stacked file system on the storage server. Clean up compiled code files in the stack file system;

If the environment is consistent and there is a conflict, exit the compilation;

If the environment is inconsistent, exit compilation.

In some embodiments, as shown in FIG. 2 , the monitoring system can monitor distributed scheduling machines, compilation server clusters, and distributed storage clusters, and monitor information such as CPU, memory, hard disk, and network.

Compared with the traditional method of manually downloading a full set of codes on a fixed compiler machine, incorporating incremental codes, and then repeatedly cleaning up the local environment after compilation, the terminal code incremental compilation system proposed in this embodiment uses a distributed file system to ensure that a large number of mobile phone basic codes and The storage of compilation process files fully and rationally uses different types of idle server resources in the network through automatic scheduling technology, and uses highly versatile incremental compilation scripts using shared library mode to reduce maintenance costs, and R&D personnel only need to use their own You need to select the corresponding configuration items, and you don’t need to care about the code storage location. The stacked file system in the distributed file system separates the compiled files from the code base files to ensure a clean compilation environment. The location of the compiler can realize multiple platforms such as Qualcomm and MTK. , Incremental compilation of the Zhanrui platform saves manpower and can realize reasonable resource scheduling. In addition, this embodiment separates computing and storage, and the distributed file storage system is used for storage. The compilation server cluster and distributed resource scheduling server perform Calculation, easy to increase or decrease the maintenance of the machine.

Another embodiment of the present application relates to an incremental compilation system. The implementation details of the terminal incremental compilation system of this embodiment are described in detail below. The following content is only the implementation details provided for the convenience of understanding, and is not necessary for the implementation of this solution. , FIG. 2 is a schematic diagram of the incremental compilation system described in this embodiment.

The terminal incremental compilation system includes: distributed resource scheduling server, compilation server cluster, distributed file storage system, distributed resource scheduling server communicates with each server in the compilation server cluster, and each server in the compilation server cluster and distributed file storage System communication connection.

The distributed resource scheduling server can provide users with a visual front-end configuration interface, obtain compilation tasks through the front-end configuration interface, determine the target compilation server that matches the compilation task in multiple compilation server clusters according to the compilation task, and send the compilation task to Matching target build server.

The target compilation server in the compilation server cluster is used to obtain the file to be compiled from the distributed file storage system according to the compilation task to perform incremental compilation of the code.

The target server in the compilation server cluster is also used to determine the compilation environment according to the compilation task, start a container matching the compilation environment, and perform incremental compilation in the container.

The distributed file storage system is used to transfer the files to be compiled to the target server.

In some embodiments, the distributed file storage system is also used to separate the code base file and the compiled file through the stacked file system, and obtain the file to be compiled by copying the code contact file and incremental code.

In some embodiments, the distributed file storage system is also used to delete the compilation process files after the incremental compilation is completed.

In some embodiments, the distributed file storage system is also used to cache the first type of files in the distributed file storage system, and the cached first type of files are merged into the second type of files and then transmitted. The first type of files is the capacity For files smaller than the first preset value, the second type of files are files whose capacity reaches the second preset value.

The remaining details of the distributed resource scheduling server, compilation server cluster, and distributed file storage system in this embodiment are substantially the same as those in the above-mentioned method embodiment, and will not be repeated in this embodiment.

Compared with the traditional method of manually downloading a full set of codes on a fixed compiler machine, combining them with incremental codes, and then repeatedly cleaning up the local environment after compiling, the terminal code incremental compilation system proposed in this embodiment guarantees a large number of mobile phone basic codes and compilations through a distributed file system. For the storage of process files, the stacked file system in the distributed file system is used to separate the compiled files from the code base files to ensure a clean compilation environment, and the automatic scheduling technology in the distributed resource scheduling server is used to fully and rationally use different types of idle resources in the network Server resources, use the universal and incremental compilation scripts in the shared library mode to reduce maintenance costs, and R&D personnel only need to select the corresponding configuration items according to their own needs, without caring about the code storage location and the location of the compiler. Incremental compilation of multi-platforms such as Qualcomm, MTK, and Zhanrui platforms is realized, which saves manpower and enables reasonable resource scheduling. In addition, this embodiment separates computing and storage, uses distributed file storage systems for storage, and compiles server clusters Computing with the distributed resource scheduling server, which is convenient for the increase and decrease of the machine maintenance.

Another embodiment of the present application relates to a terminal code incremental compilation device. The details of the scheduling system in this embodiment are described in detail below. The following content is only the implementation details provided for the convenience of understanding, and is not necessary for the implementation of this embodiment. 4 is a schematic diagram of the terminal code incremental compilation device described in this embodiment, including: a configuration module 401, used to obtain compilation tasks through the front-end configuration interface; a distribution module 402, according to the compilation tasks, in multiple compilation server clusters Determine the target compilation server that matches the compilation task; the scheduling module 403 sends the compilation task to the matching target compilation server for the target compilation server to retrieve from the distributed file storage system according to the compilation task Acquire the files to be compiled to perform incremental compilation of the code; wherein, the multiple compilation server clusters are server clusters of different platforms, and the compilation server clusters share the distributed file storage system.

In some embodiments, the allocating module 402 is further configured to acquire a target server that satisfies the resource label requirement according to the resource label carried by the compiling task.

In some embodiments, the files of the first type in the distributed file storage system in the scheduling module 403 are transferred after being merged into files of the second type; the files of the first type are files whose capacity is smaller than the first preset value, and the files of the second type The file is a file whose capacity reaches the second preset value.

In some embodiments, the distributed file storage system in the scheduling module 403 includes a stacked file system, and the code base files and compilation process files of the stacked file system are separated.

In some embodiments, the compilation process files of the distributed file storage system in the scheduling module 403 are deleted after the incremental compilation is completed.

In some embodiments, the file to be compiled is incrementally compiled in a container in the target compilation server, and the compilation environment of the container is consistent with the compilation environment configured for the file to be compiled.

It is not difficult to find that this embodiment is a system embodiment corresponding to the above method embodiment, and this embodiment can be implemented in cooperation with the above method embodiment. The relevant technical details and technical effects mentioned in the above embodiments are still valid in this embodiment, and will not be repeated here to reduce repetition. Correspondingly, the relevant technical details mentioned in this embodiment can also be applied in the above embodiments.

It is worth mentioning that all the modules involved in this embodiment are logical modules. In practical applications, a logical unit can be a physical unit, or a part of a physical unit, or multiple physical units. Combination of units. In addition, in order to highlight the innovative part of the present application, units that are not closely related to solving the technical problem proposed in the present application are not introduced in this embodiment, but this does not mean that there are no other units in this embodiment.

Another embodiment of the present application relates to an electronic device, as shown in FIG. 5 , including: at least one processor 501; and a memory 502 communicatively connected to the at least one processor 501; wherein, the memory 502 stores Instructions that can be executed by the at least one processor 501, the instructions are executed by the at least one processor 501, so that the at least one processor 501 can execute the terminal code incremental compilation method in the foregoing embodiments.

Wherein, the memory and the processor are connected by a bus, and the bus may include any number of interconnected buses and bridges, and the bus connects one or more processors and various circuits of the memory together. The bus may also connect together various other circuits such as peripherals, voltage regulators, and power management circuits, all of which are well known in the art and therefore will not be further described herein. The bus interface provides an interface between the bus and the transceivers. A transceiver may be a single element or multiple elements, such as multiple receivers and transmitters, providing means for communicating with various other devices over a transmission medium. The data processed by the processor is transmitted on the wireless medium through the antenna, further, the antenna also receives the data and transmits the data to the processor.

The processor is responsible for managing the bus and general processing, and can also provide various functions, including timing, peripheral interface, voltage regulation, power management, and other control functions. Instead, memory can be used to store data that the processor uses when performing operations.

Another embodiment of the present application relates to a computer-readable storage medium storing a computer program. The above method embodiments are implemented when the computer program is executed by the processor.

That is, those skilled in the art can understand that all or part of the steps in the method of the above-mentioned embodiments can be completed by instructing related hardware through a program, the program is stored in a storage medium, and includes several instructions to make a device ( It may be a single-chip microcomputer, a chip, etc.) or a processor (processor) to execute all or part of the steps of the methods described in the various embodiments of the present application. The aforementioned storage media include: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), magnetic disk or optical disc, etc., which can store program codes. .

In the embodiment of this application, the compilation task is obtained through the front-end configuration interface, and the target server matching the compilation task is determined in multiple server clusters according to the compilation task, so that there is no need for the R&D personnel to determine the server that needs to log in and log in remotely to compile. Personnel only need to configure the compilation task to realize incremental compilation and save human resources. The target server in the embodiment of this application will automatically obtain the compiled code from the distributed storage system according to the compilation task and perform incremental compilation to realize the server's Automatic scheduling makes the allocation of server resources more reasonable. Multiple server clusters are server clusters of different platforms, which conforms to the characteristics of multi-platform compilation of mobile phone software development, facilitates code maintenance and reduces maintenance costs.

Those of ordinary skill in the art can understand that the above-mentioned embodiments are specific examples for realizing the application, and in practical applications, various changes can be made to it in form and details without departing from the principles and principles of the application. scope.

Claims

A terminal code incremental compilation method, comprising:

Obtain compilation tasks through the front-end configuration interface;

According to the compiling task, determine a target compiling server matching the compiling task in multiple compiling server clusters;

Sending the compiling task to the matching target compiling server for the target compiling server to obtain the file to be compiled from the distributed file storage system according to the compiling task for incremental compiling of the code;

Wherein, the multiple compiling server clusters are server clusters of different platforms, and the compiling server clusters share the distributed file storage system.
The terminal code incremental compilation method according to claim 1, wherein, according to the compilation task, determining a target server matching the compilation task in a plurality of server clusters includes:

According to the resource tag carried by the compilation task, obtain the target server that meets the resource tag requirement.
The terminal code incremental compilation method according to claim 1, wherein the files of the first type in the distributed file storage system are transferred after being merged into files of the second type; The second type of file is a file whose capacity reaches the second preset value.
The terminal code incremental compilation method according to any one of claims 1 to 3, wherein the distributed file storage system includes a stacked file system, and the code base file and the compilation process file of the stacked file system are separated.
The terminal code incremental compilation method according to claim 4, wherein the compilation process files of the distributed file storage system are deleted after the incremental compilation is completed.
The terminal code incremental compilation method according to any one of claims 1 to 3, wherein the file to be compiled is incrementally compiled in a container in the target compilation server, and the compilation environment of the container is the same as that of the to-be-compiled file. The compilation environment of the compilation file configuration is consistent.
A terminal code incremental compilation system, wherein the terminal code incremental compilation system includes: a distributed resource scheduling server, a compilation server cluster, and a distributed file storage system;

The distributed resource scheduling server is used to obtain the compilation task through the front-end configuration interface, determine the target compilation server matching the compilation task in multiple compilation server clusters according to the compilation task, and send the compilation task to to said matching target compilation server;

The target compilation server in the compilation server cluster is used to obtain the file to be compiled from the distributed file storage system according to the compilation task to perform incremental compilation of the code;

The distributed file storage system is used to transmit the file to be compiled to the target server; wherein, the compilation server cluster shares the distributed file storage system; the multiple compilation server clusters are servers of different platforms cluster.
A terminal code incremental compilation device, comprising:

The configuration module is used to obtain compilation tasks through the front-end configuration interface;

An allocation module, according to the compilation task, determines a target compilation server that matches the compilation task in multiple compilation server clusters;

A dispatching module that sends the compiling task to the matching target compiling server, so that the target compiling server can obtain the file to be compiled from the distributed file storage system according to the compiling task to perform incremental compiling of the code; wherein, The multiple compiling server clusters are server clusters of different platforms, and the compiling server clusters share the distributed file storage system.
A server comprising:

at least one processor; and,

a memory communicatively coupled to the at least one processor; wherein,

The memory stores instructions executable by the at least one processor, the instructions are executed by the at least one processor, so that the at least one processor can perform the operation described in any one of claims 1 to 6 The terminal code incremental compilation method described above.
A computer-readable storage medium storing a computer program, wherein, when the computer program is executed by a processor, the terminal code incremental compilation method according to any one of claims 1 to 6 is realized.