A method, device and equipment for processing application files

Abstract

The present invention provides a method, device and equipment for processing application files, the method comprising: obtaining the original code corresponding to the installation package file of the target type application; triggering the code compilation task of the target tool to compile the target code to obtain the target compiled file of the target code; triggering the target packaging node corresponding to the application of the target tool to generate a packaging instruction; according to the packaging instruction, storing the target compiled file in the target file according to the dependency rule; triggering the target packaging node to generate an installation package generation instruction; according to the installation package generation instruction, performing installation package file production processing on the target file to obtain the target installation package file of the target application; testing the target installation package file to obtain the test result; after the test result indicates that the test is passed, generating the installation package file of the target version of the target application. The present invention can automatically generate the installation package of the application, and improve the efficiency of the installation package generation.

Description

Technical Field

[0001] The present invention relates to the technical field of computer information processing, and in particular to a method, device and equipment for processing application files. Background Art

[0002] In the traditional application development process, build compilation, packaging, and testing tasks need to be performed manually; this is not only inefficient but also prone to human errors.

[0003] Insufficient automation: developers are required to manually write build scripts and configure various dependencies and installation parameters. This not only reduces efficiency but also increases the risk of errors and cannot meet the needs of complex projects.

[0004] Long build and test cycles: Lack of efficient build, packaging, and testing mechanisms leads to project delays or reduced delivery quality. Inability to fully utilize multi-core processors or distributed computing resources limits the speed of build and test.

[0005] Inconvenient software package distribution: The format and distribution method of the software package are different for different platforms and operating systems; cross-platform distribution is not supported, and the installation package lacks necessary configuration options and customization functions. Summary of the invention

[0006] The technical problem to be solved by the present invention is to provide a method, device and equipment for processing application files, which can automatically generate an installation package of the application, thereby improving the efficiency and flexibility of generating the application installation package.

[0007] In order to solve the above technical problems, the technical solution of the present invention is as follows:

[0008] A method for processing an application file, comprising:

[0009] Obtain the target code corresponding to the installation package file of the target type of application;

[0010] Triggering a code compilation task of a target tool to compile the target code to obtain a target compilation file of the target code;

[0011] Triggering a target packaging node of the target tool corresponding to the application program to generate a packaging instruction;

[0012] According to the packaging instruction, storing the target compiled file into the target file according to the dependency rule;

[0013] Trigger the target packaging node to generate an installation package generation instruction;

[0014] According to the installation package generation instruction, the target file is processed for installation package file production to obtain a target installation package file of the target application program;

[0015] Testing the target installation package file to obtain a test result;

[0016] After the test result indicates that the test is passed, an installation package file of the target version of the target application is generated.

[0017] Optionally, triggering a code compilation task of a target tool to compile the target code to obtain a target compiled file of the target code includes:

[0018] Get the configuration information of the pipeline task of the target tool;

[0019] According to the configuration information of the pipeline task, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compilation file of the target code.

[0020] Optionally, according to the configuration information of the pipeline task, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compiled file of the target code, including:

[0021] Acquire dependent files of the target application according to the configuration information of the pipeline task;

[0022] According to the dependency files of the target application, the code compilation task of the target tool is triggered periodically to compile the target code to obtain the target compiled file of the target code.

[0023] Optionally, according to the packaging instruction, storing the target compiled file into a target file according to a dependency rule includes:

[0024] According to the packaging instruction, obtain the project configuration file of the dependent rule;

[0025] Automatically download the required dependency rules from the local repository or remote central repository according to the project configuration file of the dependency rules;

[0026] The target compiled file is stored in the target file of the target tool according to the dependency rule.

[0027] Optionally, performing installation package file production processing on the target file according to the installation package generation instruction to obtain a target installation package file of the target application program includes:

[0028] According to the installation package generation instruction, obtaining a packaging script corresponding to the target application from the target packaging node;

[0029] According to the packaging script, the target file is packaged and processed into an installation package file to obtain a target installation package file of the target application program.

[0030] Optionally, after obtaining the target installation package file of the target application, the following is further included:

[0031] Generate a packaging task isolation number;

[0032] The target installation package files of multiple versions are isolated through the packaging task isolation number.

[0033] Optionally, the target installation package file is tested to obtain a test result, including:

[0034] Deploy the target installation package file in the test environment of the target virtual machine;

[0035] In the test environment of the target virtual machine, the target installation package file is tested to obtain a test result.

[0036] An embodiment of the present invention further provides a device for processing application files, comprising:

[0037] An acquisition module, used to acquire the target code corresponding to the installation package file of the target type of application;

[0038] A processing module is used to trigger the code compilation task of the target tool to compile the target code and obtain the target compiled file of the target code; trigger the target packaging node corresponding to the application of the target tool to generate a packaging instruction; according to the packaging instruction, store the target compiled file into the target file according to the dependency rule; trigger the target packaging node to generate an installation package generation instruction; according to the installation package generation instruction, perform installation package file production processing on the target file to obtain the target installation package file of the target application; test the target installation package file to obtain a test result; after the test result indicates that the test is passed, generate the installation package file of the target version of the target application.

[0039] An embodiment of the present invention further provides a computing device, comprising: a processor and a memory storing a computer program, wherein the computer program implements the above method when executed by the processor.

[0040] An embodiment of the present invention further provides a computing device readable storage medium, wherein the computing device readable storage medium stores a program, and when the program is executed by a processor, the method described above is implemented.

[0041] The above technical solution of the present invention has at least the following technical effects:

[0042] The above scheme of the present invention obtains the target code corresponding to the installation package file of the target type application; triggers the code compilation task of the target tool to compile the target code to obtain the target compiled file of the target code; triggers the target packaging node corresponding to the application of the target tool to generate a packaging instruction; according to the packaging instruction, the target compiled file is stored in the target file according to the dependency rule; triggers the target packaging node to generate an installation package generation instruction; according to the installation package generation instruction, the target file is processed to make the installation package file to obtain the target installation package file of the target application; tests the target installation package file to obtain the test result; after the test result indicates that the test is passed, the installation package file of the target version of the target application is generated. Thus, the automatic generation of the installation package of the application is realized, and the pipeline function of the target tool is used, combined with the scripting language and the packaging tool, to realize the automatic generation of the installation package. At the same time, by configuring the timing trigger, the correctness of the code before packaging is ensured. At the same time, cross-platform support is available: for different operating systems and / or applications installed on the operating system, different packaging tools and configurations are used to ensure that the generated installation package can adapt to the target platform. Configure multiple nodes in the target tool to generate installation packages for different operating systems, thus achieving cross-platform automated packaging. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] Figure 1 is a schematic diagram of a method for processing application files of the present invention;

[0044] Figure 2 It is a module schematic diagram of the application file processing device of the present invention. DETAILED DESCRIPTION

[0045] The exemplary embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. Although the exemplary embodiments of the present invention are shown in the accompanying drawings, it should be understood that the present invention can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided in order to enable a more thorough understanding of the present invention and to enable the scope of the present invention to be fully communicated to those skilled in the art.

[0046] like Figure 1 As shown, an embodiment of the present invention provides a method for processing an application file, comprising:

[0047] Step 11, obtaining the target code corresponding to the installation package file of the target type of application; the target type here can be a variety of different operating system types or different application types installed in the operating system, wherein the operating system and / or the application need to write the target code corresponding to the installation package file before making the installation package;

[0048] Step 12, triggering a code compilation task of a target tool to compile the target code to obtain a target compiled file of the target code; here, the target tool may be any software and / or hardware tool that supports cross-platform compilation, such as Jenkins CI, an automation server for reliably building, testing and deploying projects;

[0049] Step 13, triggering the target packaging node corresponding to the application of the target tool to generate a packaging instruction; here, first deploy an environment node machine and at least one packaging node of the target type (i.e., the target packaging node) in the target tool, wherein the environment node is used to install and configure the production environment of the installation package, and the at least one target packaging node is used to produce the installation package of the type of operating system or application, respectively, and the environment node creates a work project, and realizes the association drive with multiple target packaging nodes through a script; there can also be multiple packaging nodes of each target type;

[0050] Step 14, according to the packaging instruction, the target compiled file is stored in the target file according to the dependency rule; here, each target packaging node stores the target compiled file in the target file according to the packaging instruction received by each target node and the dependency rule of each application file, wherein the dependency rule may include multiple dependencies, such as a library of an application file and a software tool development data package, etc.;

[0051] Step 15, triggering the target packaging node to generate an installation package generation instruction;

[0052] Step 16, according to the installation package generation instruction, the target file is processed for installation package file production to obtain the target installation package file of the target application program; here, the target file can be processed for installation package file production by a packaging tool of a target packaging node, for example, the packaging tool inno setup of the Window system, the containerized application Docker, etc.;

[0053] Step 17, testing the target installation package file to obtain a test result;

[0054] Step 18: after the test result indicates that the test has passed, generate an installation package file of the target version of the target application.

[0055] In this embodiment, before obtaining the target code corresponding to the installation package file of the target type of application, the build tool can be configured to prepare the node machine environment: Jenkins environment node machine (one): install and configure the Jenkins environment, and create a job, and implement the driver associated with the packaging node machine through pipeline + python script. The target packaging nodes include: Windows packaging nodes (multiple): install and configure the .exe installation package (Windows platform) to make the installation package node machine, and deploy NSIS. Linux packaging node machines (multiple): install and configure the .deb and .rpm installation packages (Linux platform) to make the node machine, and configure pkg-buildpackage and rpmbuild. Windows digital signature node machine (one): Install and configure the Python runtime environment and digital signature environment; Different platforms have different ways of building installation packages. The corresponding installation packages are created by running the installation package creation script on the packaging node: The Windows installation package (setup.exe) is created using the NSIS tool; the data directory is used to store program files; the libs directory is used to store dependent files related to the runtime environment; NSIS_Unicode is a tool for creating installation packages; Suwellreadersetup.nsi is an nsis script used to install the production process; package.bat is used to start the nsis tool; the created installation packages include: Linux-Debian installation package (.deb), Linux-RPM installation package (.rpm), etc.

[0056] In an optional embodiment of the present invention, step 12 may include:

[0057] Step 121, obtaining configuration information of the pipeline task of the target tool;

[0058] Step 122, according to the configuration information of the pipeline task, regularly trigger the code compilation task of the target tool to compile the target code to obtain the target compiled file of the target code.

[0059] In this embodiment, the pipeline task of the target tool is triggered to obtain its configuration information, which includes the timing configuration information of the timer. For example, "* / 5 * * * *" means checking the code every 5 minutes. It can also be set as a code submission trigger, that is, the build is automatically triggered each time the code is submitted to the warehouse.

[0060] When compiling the target code, for Maven projects: add the "Invoke top-level Maventargets" step, enter the build command in "Goals", such as "clean install", and let Jenkins execute Maven commands to compile, test, and package the project.

[0061] For Gradle projects: Add an "Execute shell" or "Execute batch command" step and enter the corresponding Gradle build command, such as "gradle build", depending on the operating system.

[0062] For other project types: According to the specific technology stack and build tools, configure the corresponding build commands and parameters to compile the target code.

[0063] In an optional embodiment of the present invention, step 122 may include:

[0064] Step 1221, obtaining dependent files of the target application according to the configuration information of the pipeline task;

[0065] Step 1222: According to the dependency files of the target application, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compiled file of the target code.

[0066] In this embodiment, the dependency files of the target application are obtained through the pipeline task instance script, the dependency files are stored in the libs directory, and the program files are stored in the data directory; multiple dependencies are stored in the dependency files, such as libraries of program files, software development kits, etc. When the target code is compiled, the target code is compiled according to the dependencies, so that the subsequent installation package can support the dependency relationship of the program files.

[0067] In an optional embodiment of the present invention, step 13 may include:

[0068] Step 131, triggering the target packaging node of the target tool corresponding to the application program to generate a packaging instruction.

[0069] In this embodiment, in the environment of the target tool, multiple target packaging nodes are arranged, for example, the first packaging node is used to generate packaging instructions for a Linux-Debian installation package (.deb), the second packaging node is used to generate packaging instructions for a Linux-RPM installation package (.rpm), and the third packaging node is used to generate packaging instructions for a Windows installation package (setup.exe); the target tool uses distributed construction and packaging of multiple target packaging nodes, and automatically matches node machines through pipeline scripts; different construction tasks are executed on different machines, greatly shortening the construction time.

[0070] In an optional embodiment of the present invention, step 14 may include:

[0071] Step 141, obtaining a project configuration file of a dependency rule according to the packaging instruction;

[0072] Step 142, automatically downloading required dependency rules from a local warehouse or a remote central warehouse according to the project configuration file of the dependency rules;

[0073] Step 143: store the target compiled file into the target file of the target tool according to the dependency rule.

[0074] In this embodiment, according to the packaging instruction, a project configuration file (pom.xml file or build.gradle file or package.json file or requirements.txt file) of the dependency rule is obtained;

[0075] Automatically download the required dependencies from the local repository or remote Maven central repository according to the project configuration file (pom.xml file or build.gradle file or package.json file or requirements.txt file) of the dependency rules;

[0076] The target compiled file is stored in the target file of the target tool according to the dependency rule.

[0077] In specific implementation, in the process of making the installation package, the processing of dependencies is usually completed by the build tools and package management tools used by the project, and the target tool will call these tools to perform corresponding operations.

[0078] The following are the specific ways that target tools handle dependencies in different scenarios:

[0079] Maven-based Java projects, Maven configuration: In Java projects, Maven is usually used to manage dependencies. The project's pom.xml file defines the various dependencies required by the project, including libraries, plug-ins, etc.

[0080] When configuring a Maven project in the target tool, add the "Invoke top-level Maven targets" build step. When the target tool executes a Maven command (such as mvn clean install), Maven will automatically download the required dependencies from the local repository or the remote Maven central repository based on the pom.xml file. If there is no corresponding dependency in the local repository, Maven will download it from the remote repository and store it in the local repository for subsequent use.

[0081] Configure the Java or Kotlin project of Gradle in the target tool. Gradle configuration: Gradle projects use build.gradle (Groovy syntax) or build.gradle.kts (Kotlin syntax) files to manage dependencies. Add the "Execute shell" (Linux system) or "Execute batch command" (Windows system) step in the target tool task to execute the Gradle build command, such as gradle build. Gradle will download the required dependencies from the specified repository (such as Maven Central Repository, JCenter, etc.) according to the dependency configuration in the build.gradle file. Gradle will also cache the downloaded dependencies locally to increase the speed of subsequent builds.

[0082] Configure an npm-based JavaScript project in the target tool. npm configuration: In JavaScript projects, use the package.json file to manage dependencies. Add the "Execute shell" or "Executebatch command" step in the target tool task to execute the npm install command. npm will download the required dependency packages from the npm official repository or other custom repositories based on the dependency list in the package.json file and install them into the project's node_modules directory.

[0083] Configure a pip-based Python project in the target tool. Pip configuration: Python projects usually use requirements.txt files to manage dependencies. Add an "Execute shell" or "Executebatch command" step to the target tool task and execute the pip install -r requirements.txt command. Pip will download and install the required Python packages from the Python Package Index (PyPI) or other custom sources based on the dependency information in the requirements.txt file.

[0084] Containerized project (Docker) in the target tool, Dockerfile settings: For containerized projects, use Dockerfile to define the container build process, which will include the steps for installing dependencies. Add the "Execute shell" step in the target tool task and execute the docker build command to build the Docker image. During the build process, Docker will perform operations such as dependency installation according to the instructions of the Dockerfile. The target tool can push the built image to the container image repository for subsequent deployment.

[0085] In an optional embodiment of the present invention, step 15 may include:

[0086] Step 151, triggering the target packaging node to generate an installation package generation instruction.

[0087] In this embodiment, the installation package generation tool of the target packaging node is triggered. Specifically, NSIS_Unicode is a tool for creating an installation package, Suwellreadersetup.nsi is an nsis script used to install the production process, and package.bat is used to start the nsis tool. In this way, the corresponding installation package generation instructions are automatically generated through the packaging tools of the distributed target packaging nodes, so that the installation package can be generated more efficiently.

[0088] In an optional embodiment of the present invention, step 16 may include:

[0089] Step 161, obtaining a packaging script corresponding to the target application from the target packaging node according to the installation package generation instruction;

[0090] Step 162: According to the packaging script, the target file is packaged into an installation package file to obtain a target installation package file of the target application.

[0091] In this embodiment, a packaging script is written according to project requirements, such as using NSIS to make a Windows installation package, or using dpkg-buildpackage and rpmbuild to make Debian and RPM packages.

[0092] Linux Debian package creation script, configure packaging steps: add packaging commands in the build steps of the target tool, and call the packaging script on each packaging node machine to create the installation package.

[0093] Parallel execution, packaging tasks of the target tool, and configuration support for the ability to run multiple tasks in parallel.

[0094] Furthermore, in order to optimize the size of the installation package, program file optimization can be performed: strip the binary program files of the Linux installation package, which significantly reduces the size. Review the library file compilation method, and try to use dynamic loading to reduce static compilation. Formulate dependency rules for installation package files, and copy the required files according to the rules to achieve size reduction and correctness of runtime dependencies. Develop auxiliary tools - installation package file difference comparison, realize installation package file change statistics, and generate reports; it is easy to find problems early and ensure version quality.

[0095] In an optional embodiment of the present invention, in step 162, after obtaining the target installation package file of the target application, the method further includes:

[0096] Step 163, generating a packaging task isolation number;

[0097] Step 164, isolating target installation package files of multiple versions through the packaging task isolation number.

[0098] In this embodiment, the BUILD_NUMBER of the target tool is used to separate each packaging task to ensure the correctness of the installation package version dependency and the version quality. For example, swci_win is the task name on the target tool and the build number 599 is used to isolate each version production.

[0099] In an optional embodiment of the present invention, step 17 may include:

[0100] Step 171, deploying the target installation package file in the test environment of the target virtual machine;

[0101] Step 172: testing the target installation package file in the test environment of the target virtual machine to obtain a test result.

[0102] In this embodiment, the application installation package is transferred to the virtual machine, for example, the application installation package is stored in a shared folder, both the virtual machine and the host have access rights, the installation package is read and run in the virtual machine, the installation is completed according to the prompts, the application installation package is tested through the virtual machine, and a comprehensive test is performed without affecting the host system to ensure the compatibility and stability of the application;

[0103] Set output directory: Specify the output directory of the packaged installation package to ensure that the target tool can save the installation package to the correct location (on the FTP server). Through the automated script and the target tool's build process, the installation package can be automatically produced and output.

[0104] The specific implementation process of the above embodiment of the present invention is described below:

[0105] Step 111: Prepare the environment to install the target tool. Prepare the environment: Ensure that JDK has been installed on the server and that the environment variables have been configured.

[0106] Step 112, target tool environment configuration, access Jenkins: access the Jenkins web interface in a browser, unlock the target tool: unlock the target tool using the initial administrator password, which is generated and saved on the server during the installation process. Install plug-ins: install necessary plug-ins as required, such as the Git plug-in for code management and the Maven plug-in for code packaging. Configure global tools: configure global tools such as JDK to ensure that Jenkins can call these tools for building and packaging.

[0107] Step 113, create a project and configure the build process, create a new project: create a new project in the target tool, select Pipeline project (i.e. pipeline project). Configure build steps: define build steps, write pipeline scripts (including compilation, packaging, etc.). Develop the pipeline script for Jenkins packaging tasks; create packaging tasks for the target tool.

[0108] Step 114, make an installation package and write a packaging script: Write a packaging script according to project requirements, such as using NSIS to make a Windows installation package, or using dpkg-buildpackage and rpmbuild to make Debian and RPM packages. Configure the packaging step: Add a packaging command to the build step of the target tool, and call the packaging script on each packaging node machine to make the installation package.

[0109] Step 115, installation package testing.

[0110] Step 116, set the output directory: specify the output directory of the packaged installation package to ensure that the target tool can save the installation package to the correct location (on the FTP server).

[0111] The above-mentioned embodiment of the present invention realizes the automatic generation of the installation package through the automated installation package generation process: utilizing the pipeline function of the target tool, combining scripting languages ​​(such as Groovy, Shell, etc.) and packaging tools (such as NSIS, dpkg-buildpackage, rpmbuild, etc.). By configuring the timing trigger of the target tool, the correctness of the code before packaging is ensured. Cross-platform support: for different operating systems (such as Windows, Linux, etc.), different packaging tools and configurations are used to ensure that the generated installation package can adapt to the target platform. Multiple nodes are configured in the target tool, which are responsible for the generation of installation packages for different operating systems respectively, to realize cross-platform automated packaging. By configuring the notification settings of the target tool, the compilation and packaging results are fed back in real time.

[0112] The above method of the present invention reduces manual intervention: through the combination of automated scripts and configuration files, the installation package production process is fully automated, manual operations are reduced, and the error rate is lowered.

[0113] Improve customization capabilities: Provide flexible configuration options, allowing developers to easily customize the installation package according to user or environment requirements. Ensure the consistency and repeatability of the customization process and reduce maintenance costs.

[0114] Improve integration: Strengthen the integration between Jenkins and installation package creation tools to achieve seamless connection and improve the automation of the overall process. Ensure data integrity and consistency during the build process.

[0115] Enhanced flexibility: Supports multiple installation package formats, including Windows installation packages (setup.exe) and Linux installation packages (.deb and .rpm).

[0116] like Figure 2 As shown, an embodiment of the present invention further provides an application file processing device 20, comprising:

[0117] An acquisition module 21 is used to acquire a target code corresponding to an installation package file of an application of a target type;

[0118] The processing module 22 is used to trigger the code compilation task of the target tool to compile the target code and obtain the target compiled file of the target code; trigger the target packaging node corresponding to the application of the target tool to generate a packaging instruction; according to the packaging instruction, store the target compiled file into the target file according to the dependency rule; trigger the target packaging node to generate an installation package generation instruction; according to the installation package generation instruction, perform installation package file production processing on the target file to obtain the target installation package file of the target application; test the target installation package file to obtain a test result; after the test result indicates that the test is passed, generate the installation package file of the target version of the target application.

[0119] Optionally, triggering a code compilation task of a target tool to compile the target code to obtain a target compiled file of the target code includes:

[0120] Get the configuration information of the pipeline task of the target tool;

[0121] According to the configuration information of the pipeline task, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compilation file of the target code.

[0122] Optionally, according to the configuration information of the pipeline task, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compiled file of the target code, including:

[0123] Acquire dependent files of the target application according to the configuration information of the pipeline task;

[0124] According to the dependency files of the target application, the code compilation task of the target tool is triggered periodically to compile the target code to obtain the target compiled file of the target code.

[0125] Optionally, according to the packaging instruction, storing the target compiled file into a target file according to a dependency rule includes:

[0126] According to the packaging instruction, obtain the project configuration file of the dependency rule;

[0127] Automatically download the required dependency rules from the local repository or remote central repository according to the project configuration file of the dependency rules;

[0128] The target compiled file is stored in the target file of the target tool according to the dependency rule.

[0129] Optionally, performing installation package file production processing on the target file according to the installation package generation instruction to obtain a target installation package file of the target application program includes:

[0130] According to the installation package generation instruction, obtaining a packaging script corresponding to the target application from the target packaging node;

[0131] According to the packaging script, the target file is packaged and processed into an installation package file to obtain a target installation package file of the target application program.

[0132] Optionally, after obtaining the target installation package file of the target application, the following is further included:

[0133] Generate a packaging task isolation number;

[0134] The target installation package files of multiple versions are isolated through the packaging task isolation number.

[0135] Optionally, the target installation package file is tested to obtain a test result, including:

[0136] Deploy the target installation package file in the test environment of the target virtual machine;

[0137] In the test environment of the target virtual machine, the target installation package file is tested to obtain a test result.

[0138] It should be noted that the device is a device corresponding to the above method, and all implementation methods in the above method embodiments are applicable to the embodiments of the device and can achieve the same technical effects.

[0139] The embodiment of the present invention further provides a computing device, comprising: a processor, a memory storing a computer program, wherein when the computer program is executed by the processor, the method described above is executed. All implementations in the above method embodiment are applicable to this embodiment and can achieve the same technical effect.

[0140] The embodiment of the present invention further provides a computer-readable storage medium storing instructions, which, when executed on a computer, enable the computer to execute the above method. All implementations in the above method embodiment are applicable to this embodiment and can achieve the same technical effect.

[0141] Those skilled in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of the present invention.

[0142] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0143] In the embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0144] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0145] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0146] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions for a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as USB flash drives, mobile hard disks, ROM, RAM, magnetic disks, or optical disks.

[0147] In addition, it should be pointed out that in the apparatus and method of the present invention, it is obvious that each component or each step can be decomposed and / or recombined. These decompositions and / or recombinations should be regarded as equivalent schemes of the present invention. Moreover, the steps of performing the above series of processing can naturally be performed in chronological order according to the order of description, but it is not necessary to perform them in chronological order, and some steps can be performed in parallel or independently of each other. For those of ordinary skill in the art, it is understandable that all or any steps or components of the method and apparatus of the present invention can be implemented in hardware, firmware, software or a combination thereof in any computing device (including processors, storage media, etc.) or a network of computing devices, which can be achieved by those of ordinary skill in the art using their basic programming skills after reading the description of the present invention.

[0148] Therefore, the purpose of the present invention can also be achieved by running a program or a group of programs on any computing device. The computing device can be a well-known general device. Therefore, the purpose of the present invention can also be achieved by simply providing a program product containing a program code that implements the method or device. That is to say, such a program product also constitutes the present invention, and the storage medium storing such a program product also constitutes the present invention. Obviously, the storage medium can be any well-known storage medium or any storage medium developed in the future. It should also be pointed out that in the device and method of the present invention, it is obvious that each component or each step can be decomposed and / or recombined. These decompositions and / or recombinations should be regarded as equivalent schemes of the present invention. In addition, the steps of performing the above-mentioned series of processing can naturally be performed in chronological order according to the order of description, but it is not necessary to perform them in chronological order. Some steps can be performed in parallel or independently of each other.

[0149] The above is a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A method for processing an application file, characterized in that: include: Obtain the target code corresponding to the installation package file of the target type of application; Triggering a code compilation task of a target tool to compile the target code to obtain a target compilation file of the target code; Triggering a target packaging node of the target tool corresponding to the application program to generate a packaging instruction; According to the packaging instruction, storing the target compiled file into the target file according to the dependency rule; Trigger the target packaging node to generate an installation package generation instruction; According to the installation package generation instruction, the target file is processed for installation package file production to obtain a target installation package file of the target application program; Testing the target installation package file to obtain a test result; After the test result indicates that the test is passed, an installation package file of the target version of the target application is generated.

2. The method for processing application files according to claim 1, characterized in that: The code compilation task of the target tool is triggered to compile the target code to obtain a target compiled file of the target code, including: Get the configuration information of the pipeline task of the target tool; According to the configuration information of the pipeline task, the code compilation task of the target tool is triggered periodically to compile the target code to obtain a target compilation file of the target code.

3. The method for processing application files according to claim 2, characterized in that: According to the configuration information of the pipeline task, the code compilation task of the target tool is triggered regularly to compile the target code to obtain the target compilation file of the target code, including: Acquire dependent files of the target application according to the configuration information of the pipeline task; According to the dependency files of the target application, the code compilation task of the target tool is triggered periodically to compile the target code to obtain the target compiled file of the target code.

4. The method for processing application files according to claim 1, characterized in that: According to the packaging instruction, storing the target compiled file into the target file according to the dependency rule includes: According to the packaging instruction, obtain the project configuration file of the dependent rule; Automatically download the required dependency rules from the local repository or remote central repository according to the project configuration file of the dependency rules; The target compiled file is stored in the target file of the target tool according to the dependency rule.

5. The method for processing application files according to claim 1, characterized in that: According to the installation package generation instruction, the target file is processed for installation package file production to obtain a target installation package file of the target application, including: According to the installation package generation instruction, obtaining a packaging script corresponding to the target application from the target packaging node; According to the packaging script, the target file is packaged and processed into an installation package file to obtain a target installation package file of the target application program.

6. The method for processing application files according to claim 5, characterized in that: After obtaining the target installation package file of the target application, it also includes: Generate a packaging task isolation number; The target installation package files of multiple versions are isolated through the packaging task isolation number.

7. The method for processing application files according to claim 1, characterized in that: The target installation package file is tested to obtain test results, including: Deploy the target installation package file in the test environment of the target virtual machine; In the test environment of the target virtual machine, the target installation package file is tested to obtain a test result.

8. A device for processing application files, characterized in that: include: An acquisition module, used to acquire the target code corresponding to the installation package file of the target type of application; A processing module, used for triggering a code compilation task of a target tool to compile the target code and obtain a target compiled file of the target code; Triggering a target packaging node of the target tool corresponding to the application to generate a packaging instruction; storing the target compiled file into a target file according to the packaging instruction and the dependency rule; Trigger the target packaging node to generate an installation package generation instruction; perform installation package file production processing on the target file according to the installation package generation instruction to obtain a target installation package file of the target application; The target installation package file is tested to obtain a test result; after the test result indicates that the test is passed, an installation package file of the target version of the target application is generated.

9. A computing device, characterized in that include: A processor and a memory storing a computer program, wherein the computer program implements the method according to any one of claims 1 to 7 when executed by the processor.

10. A computing device readable storage medium, characterized in that: The computing device readable storage medium stores a program, which implements the method according to any one of claims 1 to 7 when executed by a processor.

Images