Software construction method, system, device, medium and program product

Abstract

The present disclosure provides a software construction method, which relates to the technical field of computers. The software construction method is applied to a software construction system. The software construction system comprises a plurality of software construction modules. The software construction modules are correspondingly arranged with operating systems. The underlying architectures of the operating systems corresponding to at least two software construction modules are different. The software construction modules are used to construct software installation packages. Different software construction modules construct software installation packages for different operating systems. The software construction method comprises the following steps: obtaining a construction instruction. The construction instruction comprises target software to be constructed, code library information, and an operating system. The construction instruction is sent to a software construction module according to the operating system. The construction instruction is configured to enable the software construction module to execute an installation package construction step configured in the software construction module, so as to construct a software installation package based on the code library information. The present disclosure also provides a software construction system, a device, a medium, and a program product.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and more specifically to a software construction method, system, electronic device, storage medium, and program product. Background Technology

[0002] With the development of the times, financial services are no longer deployed solely on Windows-based platforms, but are gradually migrating to platforms based on other operating systems, thereby freeing themselves from dependence on Windows. Other operating systems could include Kylin OS and UOS.

[0003] Currently, most mainstream software is developed based on the Windows operating system. However, the underlying architecture of the Kylin OS and UOS operating system is different from that of the Windows operating system. This makes software developed based on the Windows operating system unsuitable for the Kylin OS and UOS operating system. In order to install and deploy the software on the Kylin OS and UOS operating system, developers need to repeatedly develop the code, which results in a large workload. Summary of the Invention

[0004] In view of the above problems, this disclosure provides a software construction method, system, electronic device, storage medium and program product.

[0005] According to a first aspect of this disclosure, a software construction method is provided, applied to a software construction system, wherein the software construction system includes multiple software construction modules, at least one of the software construction modules is configured to correspond to at least one operating system, at least two of the software construction modules correspond to operating systems with different underlying architectures, at least one software construction module is used to build a software installation package for its corresponding operating system, and different software construction modules build the software installation package for different operating systems; the software construction method includes:

[0006] Obtain build instructions, which include the target software to be built, the code library information of the target software, and the operating system running the target software;

[0007] According to the operating system running the target software, the build command is sent to the software build module that is configured corresponding to the operating system;

[0008] The build instruction is configured to cause the software build module to execute the installation package build step configured in the software build module according to the build instruction, so as to build a software installation package for the operating system corresponding to the software build module based on the code library information.

[0009] According to an embodiment of this disclosure, the code library information includes address information of the code library used to build the target software, at least one of the software building modules includes a first module group, the first module group includes at least one of the software building modules, and the operating system corresponding to the software building module in the first module group is a first underlying architecture.

[0010] In the first module group, at least one of the software building modules is configured with an installation package building step including:

[0011] Based on the address information, obtain the first code library used to build the target software;

[0012] The first code library obtained is translated into a low-level language to obtain the target file;

[0013] The target files are packaged according to the method matching the first module group to generate the software installation package.

[0014] According to embodiments of this disclosure, packaging the target file according to a method matching the first module group to generate the software installation package includes:

[0015] Obtain the first resource that matches the first module group;

[0016] The target file is packaged using the first resource to generate the software installation package;

[0017] In the first module group, the packaging specifications of different software building modules are different.

[0018] According to embodiments of this disclosure, packaging the target file according to a method matching the first module group to generate the software installation package includes:

[0019] Based on the target software and the operating system running the target software, obtain first operation permissions;

[0020] Grant the first operation permission to the software installation package;

[0021] Wherein, the first operation permission is configured to: enable the operating system to grant the target software a second operation permission when the target software is installed through the software installation package; the second operation permission is configured to: enable the operating system running the target software to allow the target software to perform the expected functions.

[0022] According to embodiments of this disclosure, packaging the target file according to a method matching the first module group to generate the software installation package includes:

[0023] Obtain the first signature based on the operating system running the target software;

[0024] Assign the first signature to the software installation package;

[0025] The first signature is configured to enable the operating system to pass installation verification when installing the target software through the software installation package.

[0026] According to embodiments of this disclosure, at least one of the software building modules further includes a second module group, the second module group including at least one of the software building modules, and the operating system corresponding to the software building modules in the second module group is a second underlying architecture, which is different from the first underlying architecture.

[0027] In the second module group, at least one of the software building modules is configured with an installation package building step that includes:

[0028] Based on the address information, obtain the second code library used to build the target software;

[0029] Obtain the second resource that matches the second module group;

[0030] The second resource is used to package the second code library to generate the software installation package;

[0031] The first resource is different from the second resource.

[0032] According to embodiments of this disclosure, the software construction method further includes:

[0033] Record the build progress of the target software based on the processing node where the build instruction is located;

[0034] In response to a query command, the system provides feedback on the build progress of the target software; and / or, when the build command includes a repeat build command, the system provides feedback on the build progress of the target software.

[0035] According to embodiments of this disclosure, the software building system includes multiple message queues, and at least one of the software building modules is configured with at least one of the message queues.

[0036] The step of sending the build instructions to the software build module corresponding to the operating system running the target software includes:

[0037] The target message queue is determined from at least one of the message queues based on the operating system running the target software;

[0038] The build instruction is sent to the software build module corresponding to the target message queue through the target message queue.

[0039] A second aspect of this disclosure provides a software building system, comprising a plurality of software building modules and a build management module, wherein at least one of the software building modules is configured to correspond to at least one operating system, at least two of the software building modules correspond to operating systems with different underlying architectures, at least one of the software building modules is used to build a software installation package for its corresponding operating system, and different software building modules build the software installation package for different operating systems; the build management module includes:

[0040] The first acquisition unit is used to acquire a build instruction, the build instruction including the target software to be built, the code library information of the target software, and the operating system running the target software;

[0041] The first processing unit is configured to send the build instructions to the software build module that is configured to correspond to the operating system running the target software, based on the operating system of the target software.

[0042] The build instruction is configured to cause the software build module to execute the installation package build step configured in the software build module according to the build instruction, so as to build a software installation package for the operating system corresponding to the software build module based on the code library information.

[0043] A third aspect of this disclosure provides an electronic device comprising: one or more processors; and a memory for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors perform the software construction method described above.

[0044] A fourth aspect of this disclosure also provides a computer-readable storage medium having executable instructions stored thereon, which, when executed by a processor, cause the processor to perform the software construction method described above.

[0045] The fifth aspect of this disclosure also provides a computer program product, including a computer program that, when executed by a processor, implements the software construction method described above.

[0046] The above one or more embodiments have the following advantages or benefits:

[0047] The software construction method of this disclosure allows developers to automatically generate a software installation package compatible with the Kylin OS (or UOS OS, or Windows OS) simply by providing the target software's codebase information and the operating system on which it runs. This enables cross-operating system installation and deployment of the target software. Furthermore, the software installation package generation process requires no manual intervention, significantly reducing development costs. More importantly, when implementing cross-operating system installation and deployment of the target software, developers only need to complete the code development once, avoiding repetitive development work and greatly improving development efficiency. Attached Figure Description

[0048] The foregoing contents, as well as other objects, features, and advantages of this disclosure, will become clearer from the following description of embodiments with reference to the accompanying drawings, in which:

[0049] Figure 1 The illustrations depict application scenarios of software construction methods, apparatus, electronic devices, storage media, and program products according to embodiments of the present disclosure.

[0050] Figure 2 A flowchart illustrating a software construction method according to an embodiment of the present disclosure is shown schematically;

[0051] Figure 3 One of the flowcharts illustrating the installation package building steps according to an embodiment of the present disclosure is shown schematically;

[0052] Figure 4 This schematically illustrates a flowchart of packaging target files according to an embodiment of the present disclosure;

[0053] Figure 5 A flowchart illustrating the granting of permissions according to an embodiment of this disclosure is shown schematically;

[0054] Figure 6 A flowchart illustrating a signature according to an embodiment of this disclosure is shown schematically;

[0055] Figure 7 A second flowchart illustrating the installation package construction steps according to an embodiment of the present disclosure is shown schematically.

[0056] Figure 8 A flowchart illustrating the recording of the construction progress according to an embodiment of the present disclosure is shown schematically;

[0057] Figure 9 A flowchart illustrating a forwarding construction instruction according to an embodiment of the present disclosure is shown schematically;

[0058] Figure 10 A schematic diagram illustrating the structure of a software building system according to an embodiment of the present disclosure is shown.

[0059] Figure 11 A block diagram schematically illustrates an electronic device suitable for implementing a software construction method according to an embodiment of the present disclosure. Detailed Implementation

[0060] The embodiments of the present disclosure will now be described with reference to the accompanying drawings. However, it should be understood that these descriptions are exemplary only and are not intended to limit the scope of the disclosure. In the following detailed description, numerous specific details are set forth to provide a thorough understanding of the embodiments of the present disclosure for ease of explanation. However, it will be apparent that one or more embodiments may be practiced without these specific details. Furthermore, descriptions of well-known structures and techniques are omitted in the following description to avoid unnecessarily obscuring the concepts of the present disclosure.

[0061] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit this disclosure. The terms “comprising,” “including,” etc., as used herein indicate the presence of the stated features, steps, operations, and / or components, but do not exclude the presence or addition of one or more other features, steps, operations, or components.

[0062] All terms used herein (including technical and scientific terms) have the meanings commonly understood by those skilled in the art, unless otherwise defined. It should be noted that the terms used herein are to be interpreted in a manner consistent with the context of this specification, and not in an idealized or overly rigid way.

[0063] When using expressions such as "at least one of A, B, and C", they should generally be interpreted in accordance with the meaning that is commonly understood by a person skilled in the art (e.g., "a system having at least one of A, B, and C" should include, but is not limited to, a system having A alone, a system having B alone, a system having C alone, a system having A and B, a system having A and C, a system having B and C, and / or a system having A, B, and C, etc.).

[0064] It should be noted that the software construction methods, apparatuses, electronic devices, storage media, and program products provided in the embodiments of this disclosure relate to the field of computer technology. The software construction methods, apparatuses, electronic devices, storage media, and program products provided in the embodiments of this disclosure can be applied to the financial field or any field other than the financial field. For example, the software construction methods, apparatuses, electronic devices, storage media, and program products provided in the embodiments of this disclosure can be applied to software development in the financial field. This disclosure does not limit the application areas of the software construction methods, apparatuses, electronic devices, storage media, and program products.

[0065] In the technical solution disclosed herein, the collection, storage, use, processing, transmission, provision, disclosure, and application of user personal information comply with the provisions of relevant laws and regulations, necessary confidentiality measures have been taken, and there is no violation of public order and good morals.

[0066] This disclosure provides a software building method applied to a software building system. The software building system includes multiple software building modules, at least one software building module is associated with at least one operating system, and at least two software building modules correspond to operating systems with different underlying architectures. At least one software building module is used to build a software installation package for its associated operating system, and different software building modules build software installation packages for different operating systems. The software building method includes: obtaining a build instruction, which includes a target software to be built, code library information of the target software, and the operating system running the target software; sending the build instruction to the software building module associated with the operating system according to the operating system running the target software; wherein the build instruction is configured to cause the software building module to execute an installation package building step configured in the software building module, thereby building a software installation package for the operating system associated with the software building module based on the code library information.

[0067] The software construction method of this disclosure allows developers to automatically generate a software installation package compatible with the Kylin OS (or UOS OS, or Windows OS) simply by providing the target software's codebase information and the operating system on which it runs. This enables cross-operating system installation and deployment of the target software. Furthermore, the software installation package generation process requires no manual intervention, significantly reducing development costs. More importantly, when implementing cross-operating system installation and deployment of the target software, developers only need to complete the code development once, avoiding repetitive development work and greatly improving development efficiency.

[0068] Figure 1 The illustrations depict application scenarios of software construction methods, apparatus, electronic devices, storage media, and program products according to embodiments of the present disclosure, such as... Figure 1 As shown, application scenario 100 according to this embodiment may include terminal devices 101, 102, and 103, network 104, and server 105. Network 104 is used as a medium to provide a communication link between terminal devices 101, 102, and 103 and server 105. Network 104 may include various connection types, such as wired or wireless communication links or fiber optic cables, etc.

[0069] Users can use terminal devices 101, 102, and 103 to interact with server 105 via network 104 to receive or send messages, etc. Various communication client applications can be installed on terminal devices 101, 102, and 103, such as shopping applications, web browser applications, search applications, instant messaging tools, email clients, social media platform software, etc. (for example only).

[0070] Terminal devices 101, 102, and 103 can be various electronic devices with displays and web browsing capabilities, including but not limited to smartphones, tablets, laptops, and desktop computers.

[0071] Server 105 can be a server that provides various services, such as a backend management server that supports websites browsed by users using terminal devices 101, 102, and 103 (for example only). The backend management server can analyze and process data such as received user requests, and feed back the processing results (such as web pages, information, or data obtained or generated according to user requests) to the terminal devices.

[0072] It should be noted that the software construction method provided in this disclosure embodiment can generally be executed by server 105. Correspondingly, the software construction apparatus provided in this disclosure embodiment can generally be located in server 105. The software construction method provided in this disclosure embodiment can also be executed by a server or server cluster that is different from server 105 and capable of communicating with terminal devices 101, 102, 103 and / or server 105. Correspondingly, the software construction apparatus provided in this disclosure embodiment can also be located in a server or server cluster that is different from server 105 and capable of communicating with terminal devices 101, 102, 103 and / or server 105.

[0073] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0074] The following will be based on Figure 1 The described scene, through Figure 2 The software construction method of the disclosed embodiments will be described in detail.

[0075] This disclosure provides a software building method applied to a software building system. The software building system includes multiple software building modules, at least one software building module is configured to correspond to at least one operating system, at least two software building modules correspond to operating systems with different underlying architectures, at least one software building module is used to build a software installation package for the operating system it is configured to correspond to, and different software building modules build software installation packages for different operating systems.

[0076] In the embodiments disclosed herein, "software" may include desktop software or mobile software applied to a computer. For clarity, "software" in the following embodiments may specifically refer to desktop software.

[0077] In this embodiment, software building modules can be configured one-to-one with operating systems, so that each software building module independently generates a software installation package for its corresponding operating system. Some software building modules may share the same underlying architecture as their corresponding operating systems. For example, multiple software building modules may include: a first software building module corresponding to the Kylin operating system, a second software building module corresponding to the UOS operating system, and a third software building module corresponding to the Windows operating system. The Kylin and UOS operating systems use an arm64 architecture, while the Windows operating system uses an x86 architecture. The first software building module is used to build a software installation package for the Kylin operating system, the second software building module is used to build a software installation package for the UOS operating system, and the third software building module is used to build a software installation package for the Windows operating system.

[0078] It should be noted that, for clarity, the embodiments of this disclosure use Kylin OS, UOS OS and Windows OS as examples for illustration, but this does not constitute a limitation on the types of operating systems in the embodiments of this disclosure. It is understood that in other embodiments, the operating system may also include other operating systems, such as Mac OS.

[0079] Figure 2 A flowchart illustrating a software construction method according to an embodiment of the present disclosure is shown, such as... Figure 2 As shown, the software construction method of this embodiment includes steps S210 to S220.

[0080] It should be noted that, although Figure 2 The steps in the diagram are shown sequentially as indicated by the arrows; however, these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise explicitly stated herein, there is no strict order constraint on the execution of these steps, and they can be executed in other orders. Moreover, at least some of the steps in the diagram may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least a portion of the sub-steps or stages of other steps.

[0081] In step S210, a build instruction is obtained, which includes the target software to be built, the code library information of the target software, and the operating system for running the target software.

[0082] In this embodiment of the disclosure, during the code development phase of the target software, developers can determine the required code libraries based on the expected functionality of the target software, thereby obtaining the code library information for the target software. The code library may include assemblies compiled into DLLs, providing a method for encapsulating code in a single file. For example, a custom control can be selected from one project, a component from another, and a form from yet another project, and then these can be encapsulated into a file to obtain a code library containing the aforementioned functionalities.

[0083] In addition to providing code repository information, developers also need to determine which operating system the target software is for, that is, the operating system on which the target software will run (hereinafter referred to as the target operating system).

[0084] Optionally, the operating system running the target software in the build instructions may include one or more.

[0085] In one example, for a target software, an operating system, such as the Kylin OS, can be specified in the build instructions.

[0086] In another example, for a target software, three operating systems can be specified simultaneously in the build instructions. These three operating systems could be, for example, Kylin OS, UOS, and Windows OS.

[0087] In step S220, based on the operating system running the target software, a build instruction is sent to the software build module corresponding to that operating system. The build instruction is configured to cause the software build module to execute the installation package build steps configured within that module, thereby building a software installation package for the operating system corresponding to that module based on code repository information.

[0088] As mentioned earlier, the operating system for running the target software can include one or more components in the build instructions. In one example, when the operating system for running the target software includes only one component, the build instructions can be forwarded to the software build module corresponding to that operating system. For instance, when the operating system for running the target software is specified as Kylin OS in the build instructions, the build instructions can be forwarded to the first software build module to generate the corresponding software installation package.

[0089] In another example, when the target software runs on multiple operating systems, the build instructions can be forwarded simultaneously or sequentially to the corresponding software build modules for each operating system, thereby generating software installation packages for each operating system. For instance, when the build instructions specify the target software as running Kylin OS, UOS OS, and Windows OS simultaneously, the build instructions can be forwarded to the first, second, and third software build modules respectively, thereby generating software installation packages for each operating system in the first, second, and third software build modules.

[0090] In this embodiment of the disclosure, during the installation package building step, the code library required to build the target software can be downloaded based on the code library information, and then operations such as packaging can be performed based on the downloaded code library to generate a software installation package.

[0091] Optionally, the installation package building step in each software building module can be configured to target its corresponding operating system, thereby enabling each software building module to generate a software installation package that can run on that operating system. For example, the installation package building steps in different software building modules may differ in at least part; for instance, different software building modules may use different resources during packaging, and / or adopt different packaging specifications, etc.

[0092] The software construction method of this disclosure allows developers to automatically generate a software installation package compatible with the Kylin OS (or UOS OS, or Windows OS) simply by providing the target software's codebase information and the operating system on which it runs. This enables cross-operating system installation and deployment of the target software. Furthermore, the software installation package generation process requires no manual intervention, significantly reducing development costs. More importantly, when implementing cross-operating system installation and deployment of the target software, developers only need to complete the code development once, avoiding repetitive development work and greatly improving development efficiency.

[0093] The following will combine Figures 2 to 9 The software construction method of the present disclosure embodiments will be further described.

[0094] In some specific embodiments, the code library information includes address information of the code library used to build the target software, at least one software building module includes a first module group, the first module group includes at least one software building module, and the operating system corresponding to the software building module in the first module group is a first underlying architecture.

[0095] In this embodiment, the software construction method can be implemented based on Node.js + Vue + Electron technology, where Electron is a cross-platform desktop software development framework based on web front-end technology. Developers can use Node.js to process the data logic of the target software, while the page effects can be supported by Vue technology, and Electron can integrate the two technologies.

[0096] Compared to traditional C#, Vue offers richer and more diverse page rendering effects in terms of color and layout. Furthermore, it allows for rapid project setup, effectively reducing upfront development work. As an open-source technology, Vue offers some protection against technical restrictions.

[0097] In this embodiment of the disclosure, the user can issue build commands through a visual interface, such as a browser, which can be implemented using Vue + Node.js. When issuing a build command, the user can provide the address information of the code repository to generate code repository information. Correspondingly, the user can also provide the operating system, etc., for running the target software through the browser.

[0098] In this embodiment of the disclosure, the software building module in the first module group can build software installation packages for an operating system using the arm64 underlying architecture. For example, the software building module in the first module group includes the first software building module and the second software building module mentioned above, which are respectively the Kylin operating system and the UOS operating system that build software installation packages.

[0099] Figure 3 One of the flowcharts illustrating the installation package building steps according to an embodiment of the present disclosure is shown schematically, such as Figure 3 As shown, in the first module group, the installation package building steps configured in at least one software building module include steps S231 to S233.

[0100] In step S231, the first code library for building the target software is obtained based on the address information.

[0101] In this embodiment of the disclosure, after obtaining the build instructions, the address information can be parsed from them. Optionally, the corresponding git repository can be found through the address information and the corresponding content can be downloaded to obtain the first code repository.

[0102] In step S232, the obtained first code library is translated into a low-level language to obtain the target file.

[0103] In this embodiment, since the software building module in the first module group builds software installation packages using an operating system with an arm64 underlying architecture, a customized packaging method is needed to meet the requirements of these operating systems. Therefore, the first code library needs to be translated into a low-level language to achieve a customized packaging method. The low-level language can refer to a language that a computer can directly recognize, such as assembly language and machine language.

[0104] In step S233, the target files are packaged according to the method matching the first module group to generate a software installation package.

[0105] In this embodiment, due to the differences between the Kylin operating system (or UOS operating system) and the Windows operating system, the resources used by the software build module for the Kylin operating system (or UOS operating system) are different from those used by the software build module for the Windows operating system when building the software installation package. This difference is mainly reflected in the Electron packaging resources. Since both the Kylin and UOS operating systems are derived from the same underlying system (Debian), the corresponding software build modules can use the same resources to build the software installation package.

[0106] Figure 4 A flowchart illustrating the packaging of target files according to an embodiment of the present disclosure is shown, such as... Figure 4 As shown, in some specific embodiments, step S233 includes steps S2331 and S2332.

[0107] In step S2331, a first resource matching the first module group is obtained.

[0108] In this embodiment, the same first resource is configured for the software building modules in the first module group. The first resource may include, for example, packaging tools and instruction sets adapted to both the Kylin and UOS operating systems. That is, for both the Kylin and UOS operating systems, the corresponding software building modules can use the same packaging tools and instruction sets to build the software installation package.

[0109] In step S2332, the target file is packaged using the first resource to generate a software installation package. Within the first module group, different software build modules have different packaging specifications. These specifications may include, for example, file naming conventions, installation methods, and path configuration methods.

[0110] In this embodiment of the disclosure, electron-builder can be used to perform translation and packaging. For example, electron-builder can be used to translate the binary executable file (i.e., machine language) of the corresponding Kylin operating system (or UOS operating system) to obtain the target file, and then generate a software installation package according to the packaging specifications of the corresponding Kylin operating system (or UOS operating system).

[0111] In some specific embodiments, the software installation package generated by the software building module in the first module group can be packaged in the following directory format:

[0112] The top-level directories are DEBIAN and opt. opt is the simulated installation directory, where executable binary files are stored. After the final software installation package is completed, the target software's file path will be the path configured in the simulated installation directory. For example, the UOS operating system requires software to be installed in the opt / apps / directory. If the simulated installation directory's file path is configured as opt / apps / com / demo, then after installation, the target software can be found in / opt / apps / com / demo.

[0113] In DEBIAN, you can store files such as control, preinst, postinst, prerm, and postm. The control file records information such as the software name, author, and software description. Its content format is similar to a properties file, but a colon is used instead of an equals sign. Preinst is a script that runs before unpacking the software installation package. Postinst is a script that runs after unpacking the software installation package. Prerm is a script that runs before the uninstallation operation. Postrm is a script that runs after uninstalling the software.

[0114] In some specific implementations, the software installation package may encounter situations where files cannot be read or written correctly during installation. This involves permission management in the Kylin and UOS operating systems. To resolve this issue, appropriate permission configuration is required during packaging.

[0115] Figure 5 A flowchart illustrating the granting of permissions according to embodiments of this disclosure is shown, such as Figure 5 As shown, in some specific embodiments, step S233 includes steps S2333 and S2334.

[0116] In step S2333, first operating permissions are obtained based on the target software and the operating system running the target software.

[0117] In step S2334, a first operation permission is granted to the software installation package. The first operation permission is configured to enable the operating system to grant the target software a second operation permission when installing the target software via the software installation package. The second operation permission is configured to enable the operating system running the target software to allow the target software to perform its intended functions.

[0118] In this embodiment of the disclosure, operation permissions may include, for example, read, write, and modify permissions. Exemplarily, the first operation permission is no greater than the maximum operation permission required by DEBIAN; for example, the first operation permission is less than or equal to 775. It should be noted that in this embodiment of the disclosure, the first operation permission and the second operation permission are merely distinguished by naming; they can be the same. For example, after granting operation permission A (i.e., the first operation permission) to a software installation package, the target software installed under the Kylin operating system (or UOS operating system) will also be granted permission A (i.e., the second operation permission).

[0119] In some specific embodiments, in order to adapt to the requirements of the UOS operating system and the Kylin operating system for software installation packages, corresponding signature configuration is also required during packaging.

[0120] Figure 6 A flowchart illustrating a signature according to an embodiment of this disclosure is shown, such as Figure 6 As shown, in some specific embodiments, step S233 includes steps S2335 and S2336.

[0121] In step S2335, the first signature is obtained based on the operating system running the target software.

[0122] In step S2336, a first signature is assigned to the software installation package. The first signature is configured to enable the operating system to pass installation verification when installing the target software via the software installation package.

[0123] In this disclosed embodiment, the UOS operating system requires the software installation package to be signed; otherwise, the installation will fail. Currently, the signing can be obtained from the official UOP website.

[0124] The Kylin operating system can decide whether to sign based on the actual situation. For example, if it is necessary to use some product dependency packages of the Kylin operating system, it needs to be signed; otherwise, it can be left unsigned.

[0125] In some specific implementations, the dpkg naming convention can be used for packaging.

[0126] In some specific embodiments, multiple software building blocks can be deployed on a server (hereinafter also referred to as a build server) or a server cluster. When multiple software building blocks are deployed on a server cluster, different software building blocks can be deployed on different servers.

[0127] In this embodiment of the disclosure, when deploying software build modules on a build server, the project can be built in the following ways. Tools can be used to quickly build the project; for example, the Vue CLI can be used to facilitate rapid setup.

[0128] For example, the following steps can be performed sequentially to build the project:

[0129] First, install the Vue scaffolding.

[0130] Next, create a project. Follow the prompts to select the Vue version and other information to create a simple project.

[0131] Next, navigate to the project root directory and import electron-builder to perform compilation and packaging operations.

[0132] Optionally, electron-builder and electron are generally selected from the latest version to ensure stable operation.

[0133] Finally, check in the project root directory (the directory where package.json is located) to see if the project runs normally.

[0134] As mentioned earlier, the resources used by the software building modules corresponding to the Kylin operating system (or UOS operating system) are different from those used by the software building modules corresponding to Windoss. Therefore, when building a project, you can download the relevant resources through the corresponding channels.

[0135] In some specific embodiments, at least one software building module further includes a second module group, which includes at least one software building module. The operating system corresponding to the software building module in the second module group has the same underlying architecture. The operating system corresponding to the software building module in the first module group and the operating system corresponding to the software building module in the second module group are both the second underlying architecture, which is different from the first underlying architecture.

[0136] In this embodiment of the disclosure, the software building module in the second module group can build a software installation package for an operating system using the x86 underlying architecture. For example, the software building module in the second module group includes the third software building module mentioned above, which is a software installation package built for the Windows operating system.

[0137] Figure 7 A second flowchart illustrating the installation package building steps according to an embodiment of the present disclosure is shown, such as... Figure 7 As shown, in some specific embodiments, in the second module group, the installation package building step configured in at least one software building module includes steps S234 to S236.

[0138] In step S234, the second code library for building the target software is obtained based on the address information.

[0139] In this embodiment of the disclosure, after obtaining the build instructions, the address information can be parsed from them. Optionally, the corresponding git repository can be found through the address information and the relevant content can be downloaded to obtain the second code repository.

[0140] In step S235, a second resource matching the second module group is obtained. The first resource is different from the second resource.

[0141] In embodiments of this disclosure, the second resource may include, for example, a packaging tool adapted to the Windows operating system, an instruction set, etc.

[0142] In step S236, the second code library is packaged using the second resource to generate a software installation package.

[0143] In this embodiment of the disclosure, since the packaging system of the Windows operating system is relatively complete, the second code library can be directly packaged using the second resource without the need to translate it into a low-level language.

[0144] It should be noted that any undetailed descriptions of the embodiments disclosed herein can be found in the foregoing embodiments, and therefore will not be repeated here.

[0145] Figure 8 A flowchart illustrating the recording of the build progress according to an embodiment of this disclosure is shown, such as Figure 8 As shown, in some specific embodiments, the software construction method further includes steps S310 to S330.

[0146] In step S310, the build progress of the target software is recorded according to the processing node where the build instruction is located. For example, the build progress may include: preparing, building, build successful, build failed, system busy, and system does not currently support this type of build, etc.

[0147] In this embodiment of the disclosure, the build progress can be stored in a MySQL database, with the default initial state being "Preparing".

[0148] In step S320, in response to the query command, the construction progress of the target software is reported.

[0149] In this embodiment of the disclosure, after a user issues a command, they can first determine whether the command is a build command or a query command. If it is a query command, step S320 can be executed to provide feedback on the current build progress. If it is a build command, step S330 can be executed.

[0150] In step S330, when the build instructions include repetitive build instructions, the build progress of the target software is fed back.

[0151] For example, a build instruction can use the operating system running the target software, codebase information, and the time the build instruction was issued as a primary key. This primary key can then be used to determine whether it is a duplicate build instruction. For instance, if the MySQL database has a primary key that matches the current build instruction, the build instruction is determined to be a duplicate build instruction; otherwise, it is determined to be a non-duplicate build instruction.

[0152] In some specific embodiments, when the build instruction is a non-repeating instruction, it can be further determined whether the server where the software build module receiving the build instruction is located (i.e., the build server) is at full load. If it is at full load, a system busy message is returned to the user interaction page, prompting the user to try again later. If it is not at full load, step S210 described above is executed, and the corresponding build progress is recorded.

[0153] Optionally, steps S210 and S220 can be executed by a build management module deployed on a central server, which can run on a Linux system.

[0154] In this embodiment of the disclosure, the operating system running the target software can be identified based on the primary key parsed in the build instruction, thereby determining which software build module to send the build instruction to. In this embodiment of the disclosure, a message queue can be used to forward the build instruction, thereby achieving high concurrency.

[0155] In some specific embodiments, the software building system includes multiple message queues, and at least one software building module is configured with at least one message queue. Figure 9 A flowchart illustrating a forwarding build instruction according to an embodiment of this disclosure is shown, such as Figure 9 As shown, step S220 includes steps S221 and S222.

[0156] In step S221, the target message queue is determined from at least one message queue based on the operating system running the target software.

[0157] In step S222, the build instruction is sent to the software build module corresponding to the target message queue through the target message queue.

[0158] In this embodiment, message queues can be configured in a one-to-one correspondence with software building modules. For example, the first software building module is configured with message queue X1, the second software building module with message queue X2, and the third software building module with message queue X3. When the primary key in the build instruction is identified, and the operating system of the target software is determined to be the Kylin operating system, message queue X1 can be identified as the target message queue, and the build instruction is then sent to message queue X1 for forwarding to the first software building module. When the primary key in the build instruction is identified, and the operating system of the target software is determined to be the UOS operating system, message queue X2 can be identified as the target message queue, and the build instruction is then sent to message queue X2 for forwarding to the second software building module. When the primary key in the build instruction is identified, and the operating system of the target software is determined to be the Windows operating system, message queue X3 can be identified as the target message queue, and the build instruction is then sent to message queue X3 for forwarding to the third software building module.

[0159] Optionally, when the primary key in the build instruction is identified and it is determined that the operating system running the target software includes multiple operating systems, such as Kylin OS, UOS OS, and Windows OS, message queues X1, X2, and X3 can be identified as target message queues. The build instruction is then sent to message queues X1, X2, and X3, and then forwarded to the first software build module, the second software build module, and the third software build module through these three message queues to build the corresponding software installation package.

[0160] In some specific embodiments, after the build command is sent to the target message queue, the build progress can be recorded in the waiting queue.

[0161] In some specific embodiments, after the build command is sent to the target message queue, the operating system in the build command can be verified. For example, it can be determined whether the operating system in the build command is consistent with the operating system corresponding to the software build module of the target message queue. If so, no intervention is required. If not, the build progress can be recorded in the waiting queue and the system does not support it at this time.

[0162] In some specific implementations, the message queue can be a ZooKeeper queue. By leveraging the first-in, first-out (FIFO) characteristic of ZooKeeper queues, build instructions can be forwarded according to their arrival time, preventing excessive concurrency from causing system crashes.

[0163] For example, a user can initiate a command through a browser. Once the command reaches the central server, the central server identifies whether it's a query or a build command. If it's a query, it checks the build progress and returns the result. If it's a build command, it further determines whether it's a duplicate build command. If so, it checks the build progress and returns the result; otherwise, it identifies the operating system running the target software based on the build command and saves the build command in the corresponding ZooKeeper queue (i.e., the target message queue). The ZooKeeper queue distributes the build command to the corresponding build server according to the first-in, first-out (FIFO) principle. The software build module deployed on the build server executes the installation package build steps according to the build command, that is, it downloads the code repository from the corresponding Git repository and performs operations such as packaging to generate the software installation package. Finally, a download link for the software installation package can be provided on the browser page for the user to download and install. Throughout this process, all relevant information can be recorded in a MySQL database.

[0164] Based on the above-described software construction method, this disclosure also provides a software construction system. The following will combine... Figure 10 The system is described in detail.

[0165] Figure 10 A schematic diagram illustrating the structure of a software building system according to embodiments of the present disclosure is shown, such as... Figure 10 As shown, the software building system 1000 of this embodiment includes multiple software building modules 1010 and a build management module 1020. At least one software building module 1010 is associated with at least one operating system, and at least two software building modules 1010 correspond to operating systems with different underlying architectures. At least one software building module 1010 is used to build a software installation package for its associated operating system, and different software building modules 1010 build software installation packages for different operating systems. The build management module 1020 includes a first acquisition unit 1021 and a first processing unit 1022.

[0166] The first acquisition unit 1021 is used to acquire build instructions, which include the target software to be built, the code library information of the target software, and the operating system for running the target software. In one embodiment, the first acquisition unit 1021 can be used to execute step S210 described above, which will not be repeated here.

[0167] The first processing unit 1022 is used to send build instructions to the software build module 1010 corresponding to the operating system running the target software, based on the operating system of the target software. In one embodiment, the first processing unit 1022 can be used to execute the step S220 described above, which will not be repeated here.

[0168] The build instruction is configured to cause the software build module 1010 to execute the installation package build steps configured in the software build module 1010 according to the build instruction, so as to build a software installation package for the operating system corresponding to the software build module 1010 based on the code library information.

[0169] The software building system of this disclosure allows developers to automatically generate a software installation package compatible with the Kylin OS (or UOS OS, or Windows OS) simply by providing the target software's codebase information and the operating system running it. This enables cross-operating system installation and deployment of the target software. Furthermore, the software installation package generation process requires no manual intervention, significantly reducing development costs. More importantly, when implementing cross-operating system installation and deployment of the target software, developers only need to complete the code development once, avoiding repetitive development work and greatly improving development efficiency.

[0170] According to embodiments of this disclosure, any plurality of modules in the first acquisition unit 1021 and the first processing unit 1022 can be combined into one module, or any one of the modules can be split into multiple modules. Alternatively, at least a portion of the functionality of one or more of these modules can be combined with at least a portion of the functionality of other modules and implemented in one module. According to embodiments of this disclosure, at least one of the first acquisition unit 1021 and the first processing unit 1022 can be at least partially implemented as hardware circuitry, such as a field-programmable gate array (FPGA), a programmable logic array (PLA), a system-on-a-chip, a system-on-a-substrate, a system-on-package, an application-specific integrated circuit (ASIC), or implemented by any other reasonable means of integrating or packaging the circuitry, or implemented in any one of software, hardware, and firmware methods, or in a suitable combination of any of these. Alternatively, at least one of the first acquisition unit 1021 and the first processing unit 1022 can be at least partially implemented as a computer program module, which, when run, can perform corresponding functions.

[0171] In some specific embodiments, the code library information includes address information of the code library used to build the target software, and at least one software building module 1010 includes a first module group, the first module group includes at least one software building module 1010, and the operating system configured corresponding to the software building module 1010 in the first module group is a first underlying architecture.

[0172] In the first module group, at least one software building module 1010 includes a second acquisition unit, a translation unit, and a first packaging unit.

[0173] The second acquisition unit is used to acquire the first code library for building the target software based on the address information.

[0174] The translation unit is used to translate the acquired first code library into a low-level language to obtain the target file.

[0175] The first packaging unit is used to package the target files according to a method that matches the first module group to generate a software installation package.

[0176] In some specific embodiments, the first packaging unit is specifically used to perform the following steps:

[0177] Obtain the first resource that matches the first module group.

[0178] The target files are packaged using the first resource to generate a software installation package.

[0179] In the first module group, the packaging specifications of different software building modules 1010 are different.

[0180] In some specific embodiments, the first packaging unit is specifically used to perform the following steps:

[0181] Obtain first-level access based on the target software and the operating system running the target software.

[0182] Grant first access permissions to the software installation package.

[0183] The first operation permission is configured to grant the target software a second operation permission when the operating system installs the target software via a software installation package. The second operation permission is configured to enable the operating system running the target software to allow the target software to perform its intended functions.

[0184] In some specific embodiments, the first packaging unit is specifically used to perform the following steps:

[0185] Obtain the first signature based on the operating system running the target software.

[0186] Give the software installation package a first signature.

[0187] The first signature configuration is to enable the operating system to pass the installation verification when installing the target software through the software installation package.

[0188] In some specific embodiments, at least one software building module 1010 further includes a second module group, which includes at least one software building module 1010. The operating system corresponding to the software building module 1010 in the second module group is a second underlying architecture, which is different from the first underlying architecture.

[0189] In the second module group, at least one software building module 1010 includes a second acquisition unit, a third acquisition unit, and a second packaging unit.

[0190] The second acquisition unit is used to acquire a second code library for building the target software based on the address information.

[0191] The third acquisition unit is used to acquire the second resource that matches the second module group.

[0192] The second packaging unit is used to package the second code library using the second resources to generate a software installation package.

[0193] The first resource is different from the second resource.

[0194] In some specific embodiments, the software building system further includes a recording module for performing the following steps:

[0195] Record the build progress of the target software based on the processing node where the build command is located.

[0196] In response to a query command, provide feedback on the build progress of the target software. And / or, when the build command includes a repeat build command, provide feedback on the build progress of the target software.

[0197] In some specific embodiments, the software building system includes multiple message queues, and at least one software building module 1010 is configured with at least one message queue.

[0198] The first processing unit 1022 is specifically used to perform the following steps:

[0199] Based on the operating system running the target software, determine the target message queue from at least one message queue.

[0200] The build command is sent to the software build module 1010 that is configured with respect to the target message queue.

[0201] The software building system using embodiments of this disclosure eliminates the need for manual intervention in the software installation package generation process, significantly reducing development costs. More importantly, when implementing cross-operating system installation and deployment of target software, developers only need to complete code development once, avoiding repetitive development work and thus greatly improving development efficiency.

[0202] Figure 11 A block diagram schematically illustrates an electronic device suitable for implementing a software construction method according to embodiments of the present disclosure, such as... Figure 11 As shown, an electronic device 1100 according to an embodiment of the present disclosure includes a processor 1101, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1102 or a program loaded from a storage portion 1108 into a random access memory (RAM) 1103. The processor 1101 may include, for example, a general-purpose microprocessor (e.g., a CPU), an instruction set processor and / or an associated chipset and / or a special-purpose microprocessor (e.g., an application-specific integrated circuit (ASIC)), etc. The processor 1101 may also include onboard memory for caching purposes. The processor 1101 may include a single processing unit or multiple processing units for performing different actions of the method flow according to an embodiment of the present disclosure.

[0203] RAM 1103 stores various programs and data required for the operation of electronic device 1100. Processor 1101, ROM 1102, and RAM 1103 are interconnected via bus 1104. Processor 1101 performs various operations of the method flow according to embodiments of the present disclosure by executing programs in ROM 1102 and / or RAM 1103. It should be noted that the programs may also be stored in one or more memories other than ROM 1102 and RAM 1103. Processor 1101 may also perform various operations of the method flow according to embodiments of the present disclosure by executing programs stored in said one or more memories.

[0204] According to embodiments of this disclosure, the electronic device 1100 may further include an input / output (I / O) interface 1105, which is also connected to a bus 1104. The electronic device 1100 may also include one or more of the following components connected to the I / O interface 1105: an input section 1106 including a keyboard, mouse, etc.; an output section 1107 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 1108 including a hard disk, etc.; and a communication section 1109 including a network interface card such as a LAN card, modem, etc. The communication section 1109 performs communication processing via a network such as the Internet. A drive 1110 is also connected to the I / O interface 1105 as needed. A removable medium 1111, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on the drive 1110 as needed so that computer programs read from it can be installed into the storage section 1108 as needed.

[0205] This disclosure also provides a computer-readable storage medium, which may be included in the device / apparatus / system described in the above embodiments; or it may exist independently and not assembled into the device / apparatus / system. The computer-readable storage medium carries one or more programs, which, when executed, implement the software construction method according to the embodiments of this disclosure.

[0206] According to embodiments of this disclosure, the computer-readable storage medium may be a non-volatile computer-readable storage medium, such as including, but not limited to: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this disclosure, the computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. For example, according to embodiments of this disclosure, the computer-readable storage medium may include ROM 1102 and / or RAM 1103 and / or one or more memories other than ROM 1102 and RAM 1103 described above.

[0207] Embodiments of this disclosure also include a computer program product comprising a computer program containing program code for performing the methods shown in the flowchart. When the computer program product is run on a computer system, the program code is used to enable the computer system to implement the software construction methods provided in the embodiments of this disclosure.

[0208] When the computer program is executed by the processor 1101, it performs the functions defined in the system / apparatus of this disclosure embodiments. According to embodiments of this disclosure, the systems, apparatuses, modules, units, etc., described above can be implemented by computer program modules.

[0209] In one embodiment, the computer program may rely on a tangible storage medium such as an optical storage device or a magnetic storage device. In another embodiment, the computer program may also be transmitted and distributed in the form of signals over a network medium, and may be downloaded and installed via the communication section 1109, and / or installed from the removable medium 1111. The program code contained in the computer program can be transmitted using any suitable network medium, including but not limited to: wireless, wired, etc., or any suitable combination thereof.

[0210] In such an embodiment, the computer program can be downloaded and installed from a network via communication section 1109, and / or installed from removable medium 1111. When the computer program is executed by processor 1101, it performs the functions defined in the system of this disclosure embodiment. According to embodiments of this disclosure, the systems, devices, apparatuses, modules, units, etc., described above can be implemented by computer program modules.

[0211] According to embodiments of this disclosure, program code for executing the computer programs provided in embodiments of this disclosure can be written in any combination of one or more programming languages. Specifically, these computational programs can be implemented using high-level procedural and / or object-oriented programming languages, and / or assembly / machine languages. Programming languages ​​include, but are not limited to, languages ​​such as Java, C++, Python, "C", or similar programming languages. The program code can execute entirely on the user's computing device, partially on the user's device, partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0212] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, and combinations of blocks in a block diagram or flowchart, may be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0213] Those skilled in the art will understand that the features described in the various embodiments and / or claims of this disclosure can be combined or combined in various ways, even if such combinations or combinations are not explicitly described in this disclosure. In particular, the features described in the various embodiments and / or claims of this disclosure can be combined or combined in various ways without departing from the spirit and teachings of this disclosure. All such combinations and / or combinations fall within the scope of this disclosure.

[0214] The embodiments of this disclosure have been described above. However, these embodiments are for illustrative purposes only and are not intended to limit the scope of this disclosure. Although various embodiments have been described above, this does not mean that the measures in the various embodiments cannot be used advantageously in combination. The scope of this disclosure is defined by the appended claims and their equivalents. Various substitutions and modifications can be made by those skilled in the art without departing from the scope of this disclosure, and all such substitutions and modifications should fall within the scope of this disclosure.

Claims

1. A software construction method, applied to a software construction system, characterized in that, The software building system includes multiple software building modules, at least one of the software building modules is configured to correspond to at least one operating system, at least two of the software building modules correspond to operating systems with different underlying architectures, at least one software building module is used to build a software installation package for its corresponding operating system, and different software building modules build software installation packages for different operating systems; the software building method includes: Obtain build instructions, which include the target software to be built, the code library information of the target software, and the operating system running the target software; According to the operating system running the target software, the build command is sent to the software build module set up corresponding to the operating system; The build instruction is configured to cause the software build module to execute the installation package build step configured in the software build module according to the build instruction, so as to build a software installation package for the operating system corresponding to the software build module based on the code library information.

2. The software construction method according to claim 1, characterized in that, The code library information includes address information of the code library used to build the target software. The software building system includes a first module group, which includes at least one software building module. The operating system corresponding to the software building module in the first module group is a first underlying architecture. In the first module group, at least one of the software building modules is configured with an installation package building step including: Based on the address information, obtain the first code library used to build the target software; The first code library obtained is translated into a low-level language to obtain the target file; The target files are packaged according to the method matching the first module group to generate the software installation package.

3. The software construction method according to claim 2, characterized in that, The step of packaging the target file according to a method matching the first module group to generate the software installation package includes: Obtain the first resource that matches the first module group; The target file is packaged using the first resource to generate the software installation package; In the first module group, the packaging specifications of different software building modules are different.

4. The software construction method according to claim 2, characterized in that, The step of packaging the target file according to a method matching the first module group to generate the software installation package includes: Based on the target software and the operating system running the target software, obtain first operation permissions; Grant the first operation permission to the software installation package; Wherein, the first operation permission is configured to: enable the operating system to grant the target software a second operation permission when the target software is installed through the software installation package; the second operation permission is configured to: enable the operating system running the target software to allow the target software to perform the expected functions.

5. The software construction method according to claim 2, characterized in that, The step of packaging the target file according to a method matching the first module group to generate the software installation package includes: Obtain the first signature based on the operating system running the target software; Assign the first signature to the software installation package; The first signature is configured to enable the operating system to pass installation verification when installing the target software through the software installation package.

6. The software construction method according to claim 3, characterized in that, The software building system further includes a second module group, which includes at least one software building module. The operating system corresponding to the software building module in the second module group is a second underlying architecture, which is different from the first underlying architecture. In the second module group, at least one of the software building modules is configured with an installation package building step that includes: Based on the address information, obtain the second code library used to build the target software; Obtain the second resource that matches the second module group; The second resource is used to package the second code library to generate the software installation package; The first resource is different from the second resource.

7. The software construction method according to any one of claims 1 to 6, characterized in that, The software construction method further includes: Record the build progress of the target software based on the processing node where the build instruction is located; In response to a query command, the system provides feedback on the build progress of the target software; and / or, when the build command includes a repeat build command, the system provides feedback on the build progress of the target software.

8. The software construction method according to any one of claims 1 to 6, characterized in that, The software building system includes multiple message queues, and at least one of the software building modules is configured with at least one of the message queues. The step of sending the build instructions to the software build module corresponding to the operating system running the target software includes: The target message queue is determined from at least one of the message queues based on the operating system running the target software; The build instruction is sent to the software build module corresponding to the target message queue through the target message queue.

9. A software construction system, characterized in that, It includes multiple software build modules and a build management module. At least one of the software build modules is configured to correspond to at least one operating system. At least two of the software build modules correspond to operating systems with different underlying architectures. At least one software build module is used to build a software installation package for its corresponding operating system. Different software build modules build software installation packages for different operating systems. The build management module includes: The first acquisition unit is used to acquire a build instruction, the build instruction including the target software to be built, the code library information of the target software, and the operating system running the target software; The first processing unit is configured to send the build instructions to the software build module corresponding to the operating system running the target software, based on the operating system of the software. The build instruction is configured to cause the software build module to execute the installation package build step configured in the software build module according to the build instruction, so as to build a software installation package for the operating system corresponding to the software build module based on the code library information.

10. An electronic device, characterized in that, include: One or more processors; Storage device for storing one or more programs. When the one or more programs are executed by the one or more processors, the one or more processors perform the software construction method according to any one of claims 1 to 8.

11. A computer-readable storage medium, characterized in that, It stores executable instructions that, when executed by a processor, cause the processor to perform the software construction method according to any one of claims 1 to 8.

12. A computer program product, characterized in that, It includes a computer program that, when executed by a processor, implements the software construction method according to any one of claims 1 to 8.

Images