Manufacturing method of installation package and related device

Abstract

The invention discloses a manufacturing method of an installation package and a related device, and relates to the technical field of software engineering. Comprising the steps that a target MakeFile is created, and other instruction items, except for an install instruction item and a unstall instruction item, in the target MakeFile are all empty; obtaining a target compressed package corresponding to the target software; based on the target MakeFile and the target compressed package, constructing an initial project; adding a management script of the target package in the initial project to obtain a target project; and based on the target project, generating a target installation package corresponding to the Kylin Linux operating system. The manufacturing method of the installation package does not depend on source code reconstruction, a large amount of workload for compiling and maintaining complete Makefile in a traditional scheme is omitted, the packaging period is greatly shortened, and meanwhile the compatibility and integrity of the installation package are guaranteed.

Description

TECHNICAL FIELD

[0001] The application relates to the technical field of software engineering, in particular to a method for manufacturing an installation package and a related device. BACKGROUND

[0002] Kirin Linux is a family of open source operating systems based on the Linux kernel and developed by China to meet different scene needs. Its core positioning is to provide stable, secure and controllable computing environments for party and government, military, key industries and individual users through independent adaptation and security optimization, and to promote the coordinated development of domestic software and hardware ecology.

[0003] Currently, in the process of manufacturing an installation package by using a debuild construction tool under the Kirin Linux operating system environment, project construction management needs to rely on Makefile to complete the compilation and construction of the source project, the acquisition and analysis of dependent items, and the signature operation on the source code package to ensure integrity and credibility.

[0004] For a C++ Qt project that indirectly generates Makefile for construction through a.pro project management file, there are two key problems that restrict the packaging process of the debuild tool: first, the generated Makefile cannot be normally recognized by debuild due to environment variable adaptation problems; second, the Makefile does not integrate dependency acquisition logic, resulting in an incomplete installation directory structure in the packaging process. The conventional solution needs to generate a complete Makefile for the project, which not only significantly increases the development workload, but also requires long-term investment of resources to maintain the effectiveness of the file.

[0005] Therefore, it has become one of the technical problems to be solved in the field of software engineering technology to design an installation package construction method that does not depend on source code, skips the process of rebuilding the project using Makefile, and flexibly and quickly completes the manufacturing of the installation package. SUMMARY

[0006] Based on the above problems, the application provides a method for manufacturing an installation package, which does not depend on source code in the process of manufacturing the installation package, skips the process of rebuilding the project using Makefile, and can flexibly and quickly complete the manufacturing of the installation package.

[0007] The embodiments of the application disclose the following technical solutions:

[0008] The first aspect of the application provides a method for manufacturing an installation package, which is applied to a Kirin Linux operating system, and the method comprises the following steps:

[0009] create a target MakeFile; all instruction items in the target MakeFile are empty except for install instruction items and uninstall instruction items;

[0010] obtain a target compressed package corresponding to the target software; the target compressed package includes executable files, dependent library files, resource files, and configuration files required for running the target software;

[0011] construct an initial project based on the target MakeFile and the target compressed package;

[0012] add a management script of the target compressed package in the initial project to obtain a target project; the install instruction item includes calling logic of the management script;

[0013] generate a target installation package corresponding to the Kirin Linux operating system based on the target project.

[0014] In an optional implementation manner, the management script is used to automatically decompress the target compressed package to a preset installation path of the Kirin Linux operating system when the install instruction is executed, and delete the target compressed package after the target compressed package is decompressed.

[0015] In an optional implementation manner, the target compressed package corresponding to the target software is obtained, including:

[0016] obtain an installation directory of the target software after compilation; the installation directory includes executable files, dependent library files, resource files, and configuration files required for running the target software;

[0017] pack the installation directory to generate the target compressed package.

[0018] In an optional implementation manner, the target installation package corresponding to the Kirin Linux operating system is generated based on the target project, including:

[0019] construct a directory structure conforming to a management specification of the Kirin Linux operating system; the directory structure at least includes a debuild directory and an image directory corresponding to a path of the Kirin Linux operating system;

[0020] integrate a target MakeFile, a management script, and a target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure;

[0021] call a packaging tool of the Kirin Linux operating system to generate the target installation package based on the target directory structure.

[0022] The second aspect of the application provides a device for making an installation package, the device comprising:

[0023] a minimum engineering construction module for creating a target MakeFile; all instruction items in the target MakeFile except an install instruction item and an uninstall instruction item are null;

[0024] a target compressed package acquisition module for acquiring a target compressed package corresponding to a target software; the target compressed package comprises executable files, dependent library files, resource files and configuration files required for running the target software;

[0025] an initial engineering acquisition module for constructing an initial engineering based on the target MakeFile and the target compressed package;

[0026] a target engineering construction module for adding a management script of the target compressed package to the initial engineering to obtain a target engineering; the install instruction item comprises calling logic of the management script;

[0027] a target installation package acquisition module for generating a target installation package corresponding to the Kirin Linux operating system based on the target engineering.

[0028] In an optional implementation, the device further comprises:

[0029] a management script configuration module for configuring the management script, so that the management script is used for automatically decompressing the target compressed package to a preset installation path of the Kirin Linux operating system when the install instruction is executed, and deleting the target compressed package after the target compressed package is decompressed.

[0030] In an optional implementation, the target compressed package acquisition module comprises:

[0031] an installation directory acquisition unit for acquiring an installation directory of the target software which has been compiled; the installation directory comprises executable files, dependent library files, resource files and configuration files required for running the target software;

[0032] a target compressed package generation unit for packaging the installation directory to generate the target compressed package.

[0033] In an optional implementation, the target installation package acquisition module comprises:

[0034] A directory structure generation unit is configured to construct a directory structure in compliance with a management specification of the Kirin Linux operating system, the directory structure at least including a debuild directory and an image directory corresponding to a path of the Kirin Linux operating system;

[0035] A target directory structure acquisition unit is configured to integrate a target MakeFile, a management script and a target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure.

[0036] A target installation package generation unit is configured to call a packaging tool of the Kirin Linux operating system to generate the target installation package based on the target directory structure.

[0037] The third aspect of the present application provides a computer readable storage medium, which has a computer program stored thereon, and the program is executed by a processor to implement the steps of the method according to any one of the implementations of the first aspect.

[0038] The fourth aspect of the present application provides an electronic device, which comprises:

[0039] A memory having a computer program stored thereon;

[0040] A processor configured to execute the computer program in the memory to implement the steps of the method according to any one of the implementations of the first aspect.

[0041] Compared with the prior art, the present application has the following beneficial effects:

[0042] The application discloses a method for manufacturing an installation package, and is applied to a Kirin Linux operating system, and the method comprises the following steps: creating a target MakeFile, wherein all instruction items in the target MakeFile are empty except for an install instruction item and an uninstall instruction item; obtaining a target compressed package corresponding to target software; constructing an initial project based on the target MakeFile and the target compressed package; adding a management script of the target compressed package in the initial project to obtain a target project; and generating a target installation package corresponding to the Kirin Linux operating system based on the target project. In the application, a target Makefile is created by introducing an intermediate layer, that is, a minimum project is created, and the installation package is created through the minimum project; since the minimum project only retains the install and uninstall instruction items which are necessary for debuild tool packaging, the defect that a Makefile generated by an original Qt project cannot be recognized due to environment variable adaptation problems is effectively avoided. The construction method is not dependent on source code reconstruction and is only based on the compressed package and the minimum Makefile, so that a large amount of work of writing and maintaining a complete Makefile in a traditional scheme is saved, the packaging period is greatly shortened, and the compatibility and integrity of the installation package are ensured. BRIEF DESCRIPTION OF DRAWINGS

[0043] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings needed to be used in the embodiments or the prior art description. Obviously, the drawings in the following description only constitute some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained without creative labor.

[0044] Figure 1 A flowchart of a method for manufacturing an installation package provided by an embodiment of the present application;

[0045] Figure 2 A code schematic view of a method for manufacturing an installation package provided by an embodiment of the present application;

[0046] Figure 3 A structural schematic view of a manufacturing device for an installation package provided by an embodiment of the present application. DETAILED DESCRIPTION

[0047] The Kirin Linux operating system is a family of open source operating systems based on the Linux kernel and oriented to different scene requirements and developed by China, and is a general term of the family; the core positioning is to provide stable, safe and controllable computing environments for party and government, military, key industries and individual users through self-adaptation and security optimization, and to promote the coordinated development of domestic software and hardware ecology.

[0048] After the system design and simulation software such as GCKontrol completes the transplantation of Kirin Linux platform, the standardized installation package of the platform needs to be created based on the system architecture characteristics (such as adapting Feiteng, Koganpeng and other domestic CPU instruction sets) and software distribution specifications of Kirin Linux.

[0049] Currently, based on the system architecture characteristics and software distribution specifications of Kirin Linux, the method for creating a platform-specific standardized installation package is to use Makefile as the core management carrier. The pulling and adaptation of third-party library dependencies (such as specifying dependency versions, obtaining pre-compiled libraries or source code compilation from private repositories or official sources), the acquisition and standardized deployment logic of project resource files (such as configuration templates, icons, data assets) can be integrated into the Makefile script. Then, through Makefile, dpkg-deb and other tool chains are called to realize the automatic construction of Linux installation package.

[0050] However, this scheme has significant limitations. Specifically, the applicable scenarios of Makefile are limited to the original build system of the project, and not all projects use Makefile as the compilation management tool. For example, Qt projects rely on.pro files, cross-platform projects commonly use CMakeLists.txt, and script-based projects rely on setup.py or package.json. If the Linux installation package production needs to be adapted, a special Makefile needs to be designed and written for these non- Makefile managed projects as project management files. Not only do we need to convert the original project's compilation rules, dependency relationships, resource paths and other logic into Makefile syntax, but we also need to maintain the consistency of the original build file and the new Makefile in subsequent project iterations, which will result in high development and maintenance costs and significantly reduce the installation package production efficiency.

[0051] Therefore, designing an installation package construction method that does not depend on source code, skipping the process of using Makefile to rebuild the project, and thus flexibly and quickly completing the installation package production, has become one of the technical problems to be solved in the field of software engineering technology.

[0052] To solve the above problems, the application discloses a method for making an installation package, which is applied to a Kirin Linux operating system, and the method comprises the following steps: creating a target MakeFile, wherein all instruction items in the target MakeFile except an install instruction item and an uninstall instruction item are empty; obtaining a target compressed package corresponding to target software; constructing an initial project based on the target MakeFile and the target compressed package; adding a management script of the target compressed package in the initial project to obtain a target project; and generating a target installation package corresponding to the Kirin Linux operating system based on the target project. In the application, a target Makefile is created by introducing an intermediate layer, that is, a minimum project is created, and the installation package is created through the minimum project; since the minimum project only retains the install and uninstall instruction items necessary for debuild tool packaging, the defect that the generated Makefile of the original Qt project cannot be recognized due to environment variable adaptation problems is effectively avoided. The construction method based on the compressed package and the minimum Makefile does not depend on source code reconstruction, and a large amount of workload of writing and maintaining a complete Makefile in the traditional scheme is saved, and the packaging period is greatly shortened.

[0053] In order for those skilled in the art to better understand the scheme of the present application, the technical solutions in the embodiments of the present application will be described clearly and completely in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only some of the embodiments of the present application, not all. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application.

[0054] Figure 1 A flowchart of a method for making an installation package provided by an embodiment of the present application is shown in Fig. 1. As shown in Fig. 1, the method for making an installation package disclosed by the present application comprises the following steps. Figure 1

[0055] S101, creating a target MakeFile.

[0056] Since all instruction items in the target MakeFile in the present application except the install instruction item and the uninstall instruction item are empty, the target MakeFile is also called a virtual minimum project.

[0057] S102, obtaining a target compressed package corresponding to target software.

[0058] The target compressed package comprises executable files, dependent library files, resource files and configuration files required for running the target software.

[0059] ​Exemplarily, the target software can be system design and simulation software, such as GCKontrol.

[0060] Exemplarily, the target compressed package corresponding to the target software can be obtained in the following manner. Specifically, first, an installation directory of the target software after compilation is obtained, and the installation directory includes executable files, dependent library files, resource files and configuration files required for running the target software; and then, the installation directory is packaged to generate the target compressed package.

[0061] S103, constructing an initial project based on the target MakeFile and the target compressed package.

[0062] The meaning of this step is to use the target MakeFile and the target compressed package to form an initial project that does not need to be compiled.

[0063] S104, adding a management script of the target compressed package in the initial project to obtain a target project.

[0064] Specifically, the management script of the target compressed package is added in the initial project to obtain the target project. The management script of the target compressed package is configured to automatically decompress the target compressed package to a preset installation path of the Kirin Linux operating system when an install instruction is executed, and to delete the target compressed package after the target compressed package is decompressed.

[0065] The install instruction item includes the calling logic of the management script.

[0066] S105, generating a target installation package corresponding to the Kirin Linux operating system based on the target project.

[0067] In an optional implementation manner, generating the target installation package based on the target project includes the following steps.

[0068] A1, constructing a directory structure conforming to a management specification of the Kirin Linux operating system, and the directory structure at least includes a debuild directory and an image directory corresponding to a path of the Kirin Linux operating system.

[0069] A2, integrating the target MakeFile, the management script and the target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure.

[0070] A3, calling a packaging tool of the Kirin Linux operating system to generate the target installation package based on the target directory structure.

[0071] Figure 2 A code schematic diagram of an installation package manufacturing method provided by an embodiment of the present application. Figure 2The code in is a Makefile script for managing the installation and uninstallation process of a program named "GCKontrol". Figure 2 The installation path prefix of the Makefile script in is / opt / gc / gck, which contains targets such as all, installTarget, install, and uninstall. The all target depends on the installTarget target; the install target creates a specified installation directory and copies the GCKontrol file to the directory; the uninstall target recursively deletes the installation directory and its contents; the.PHONY declaration ensures that the all, install, clean, distclean, and uninstall targets are pseudo-targets, so that the relevant commands can be executed normally even if there are files with the same name; and the overall implementation allows the installation and uninstallation of a program to be conveniently completed using the make command.

[0072] Next, combined with the installation package creation method shown in Figure 1 and Figure 2 , a complete process for creating a deb installation package without exposing C++ source code and without relying on traditional MakeFile project management is introduced. This process mainly consists of four steps, and the overall goal is to package a C++ program and its dependencies into a deb package that can be installed on Debian / Ubuntu systems and others.

[0073] The four steps are as follows:

[0074] B1, write a C++ program.

[0075] This step aims to develop a C++ executable program.

[0076] Exemplarily, a C++ program can be written by calling a Python script, executing a shell command, or linking a shared library example.so.

[0077] It is important to note that writing a C++ program in this step does not rely on MakeFile project management. That is, the way to compile this C++ program can be manual compilation, using cmake, or even script compilation, as long as MakeFile is not used as the main build tool.

[0078] B2, prepare installation files and archive

[0079] After the program is compiled, all the necessary files for running need to be arranged, specifically: a directory named install_Example_Dir is created; the C++ executable program, dependent Python scripts, shell scripts, example.so shared library, and other possible configuration files are all put into the directory, ensuring that the file structure meets the expectations of subsequent installation into the system; and then the install_Example_Dir directory is compressed into a tar.gz archive file for easy subsequent packaging process calling.

[0080] B3, creating a minimum virtual project, that is, creating a minimized MakeFile.

[0081] In combination with the installation package production method shown in Figure 1 and Figure 2 , a minimum virtual project is created, that is, the target MakeFile mentioned in the foregoing embodiments of the application.

[0082] B4, generating a deb package using debuild.

[0083] The entire project is processed using the debuild tool, that is, the debuild reads the configuration files (such as the rule files in the debian / directory) and the target MakeFile in the project; automatically processes the dependencies, packages the files in install_Example_Dir, generates an installation package conforming to the deb standard; and finally outputs a.deb file, which can be installed into the system by the user through the dpkg -i command.

[0084] Through the methods shown in B1-B4, the C++ program and dependencies can be packaged into a standardized deb installation package, facilitating distribution and installation, and avoiding exposure of the C++ source code (only executable files and dependent resources are packaged), while breaking away from the dependence on traditional MakeFile project management, and the process is more flexible.

[0085] Based on the same inventive concept, the application further discloses an installation package production device. In combination with Figure 3 , the installation package production device 300 disclosed by the application comprises:

[0086] A minimum project construction module 301 is configured to create a target MakeFile; all instruction items in the target MakeFile except the install instruction item and the uninstall instruction item are empty;

[0087] A target compressed package acquisition module 302 is configured to acquire a target compressed package corresponding to the target software; the target compressed package comprises executable files, dependent library files, resource files, and configuration files required for running the target software.

[0088] An initial project acquisition module 303 is configured to construct an initial project based on the target MakeFile and the target compressed package.

[0089] A target project construction module 304 is configured to add a management script of the target compressed package in the initial project to obtain a target project; the install instruction item contains calling logic of the management script.

[0090] A target installation package acquisition module 305 is configured to generate a target installation package corresponding to the Kirin Linux operating system based on the target project.

[0091] In an optional implementation, the installation package manufacturing apparatus 300 further comprises:

[0092] A management script configuration module is configured to configure the management script, so that the management script is used to automatically decompress the target compressed package to a preset installation path of the Kirin Linux operating system when the install instruction is executed, and delete the target compressed package after the target compressed package is decompressed.

[0093] In an optional implementation, the target compressed package acquisition module 302 comprises:

[0094] An installation directory acquisition unit is configured to acquire an installation directory in which the target software has been compiled; the installation directory comprises executable files, dependent library files, resource files and configuration files required for running the target software.

[0095] A target compressed package generation unit is configured to package the installation directory to generate the target compressed package.

[0096] In an optional implementation, the target installation package acquisition module 305 comprises:

[0097] A directory structure generation unit is configured to construct a directory structure conforming to a management specification of the Kirin Linux operating system; the directory structure at least comprises a debuild directory and an image directory corresponding to a path of the Kirin Linux operating system.

[0098] A target directory structure acquisition unit is configured to integrate a target MakeFile, a management script and a target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure.

[0099] A target installation package generation unit is configured to call a packaging tool of the Kirin Linux operating system to generate the target installation package based on the target directory structure.

[0100] Based on the installation package production method and device provided in the foregoing embodiments, correspondingly, the application further provides a computer readable storage medium, which has a computer program stored thereon, and the program is executed by a processor to implement part or all steps of the installation package production method mentioned above.

[0101] Based on the installation package production method and device provided in the foregoing embodiments, the application further provides an electronic device, which comprises:

[0102] a memory having a computer program stored thereon;

[0103] a processor configured to execute the computer program in the memory to implement part or all steps of the installation package production method provided in the foregoing embodiments.

[0104] It should be noted that each of the embodiments in the present specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment mainly describes the difference from other embodiments. Especially, for the device embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the related parts can be referred to the part of the description of the method embodiments. The device embodiments described above are only schematic, and the units described as separate components can or can not be physically separated, and the components prompted as units can or can not be physical units, that is, they can be located in one place, or can be distributed on multiple network units. According to the actual needs, part or all of the modules can be selected to achieve the purpose of the present embodiment scheme. Those skilled in the art can understand and implement it without creative labor.

[0105] The above is only a specific embodiment of the present application, but the protection scope of the present application is not limited to this. Any skilled person in the art can easily think of changes or replacements within the technical range disclosed in the present application, which should be covered in the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

Claims

1. A method of manufacturing a mounting package, characterized by, The method is applied to a Linux operating system, and the method comprises: creating a target MakeFile; all instruction items in the target MakeFile except an install instruction item and an uninstall instruction item are empty; obtaining a target compressed package corresponding to target software; the target compressed package comprises executable files, dependent library files, resource files and configuration files required for running the target software; constructing an initial project based on the target MakeFile and the target compressed package; adding a management script of the target compressed package in the initial project to obtain a target project; the install instruction item comprises calling logic of the management script; generating a target installation package corresponding to the Linux operating system based on the target project.

2. The method of claim 1, wherein, The management script is used to automatically decompress the target compressed package to a preset installation path of the Linux operating system when the install instruction is executed, and delete the target compressed package after the target compressed package is decompressed.

3. The method of claim 1, wherein, The method comprises: obtaining an installation directory of the target software after compilation; the installation directory comprises executable files, dependent library files, resource files and configuration files required for running the target software; packing the installation directory to generate the target compressed package.

4. The method of claim 1, wherein, The method comprises: constructing a directory structure conforming to a management specification of the Linux operating system, wherein the directory structure at least comprises a debuild directory and an image directory corresponding to a path of the Linux operating system; integrating a target MakeFile, a management script and a target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure; calling a packaging tool of the Linux operating system to generate the target installation package based on the target directory structure.

5. An apparatus for manufacturing a mounting package, characterized by comprising: The device comprises: a minimum project construction module configured to create a target MakeFile; all instruction items in the target MakeFile except an install instruction item and an uninstall instruction item are empty; a target compressed package obtaining module configured to obtain a target compressed package corresponding to target software; the target compressed package comprises executable files, dependent library files, resource files and configuration files required for running the target software; an initial project obtaining module configured to construct an initial project based on the target MakeFile and the target compressed package; a target project construction module configured to add a management script of the target compressed package in the initial project to obtain a target project; the install instruction item comprises calling logic of the management script; a target installation package obtaining module configured to generate a target installation package corresponding to the Linux operating system based on the target project.

6. The apparatus of claim 5, wherein, The device further comprises: The management script configuration module is configured to configure the management script, so that the management script is used to automatically decompress the target compressed package to a preset installation path of the Kirin Linux operating system when the install instruction is executed, and delete the target compressed package after the target compressed package is decompressed.

7. The apparatus of claim 5, wherein, The target compressed package acquisition module comprises: An installation directory acquisition unit is configured to acquire an installation directory of the target software after the target software is compiled; the installation directory comprises executable files, dependent library files, resource files and configuration files required for running the target software; A target compressed package generation unit is configured to package the installation directory to generate the target compressed package.

8. The apparatus of claim 5, wherein, The target installation package acquisition module comprises: A directory structure generation unit is configured to construct a directory structure conforming to a management specification of the Kirin Linux operating system, and the directory structure at least comprises a debuild directory and an image directory corresponding to a path of the Kirin Linux operating system; A target directory structure acquisition unit is configured to integrate a target MakeFile, a management script and a target compressed package in the target project into the directory structure according to a preset rule to obtain a target directory structure; A target installation package generation unit is configured to call a packaging tool of the Kirin Linux operating system to generate the target installation package based on the target directory structure.

9. A computer-readable storage medium having stored thereon a computer program, characterized in that The program is executed by the processor to implement the steps of the method in any one of claims 1-4.

10. An electronic device, comprising: Comprise: A memory having a computer program stored thereon; A processor configured to execute the computer program in the memory to implement the steps of the method in any one of claims 1-4.

Images