An automated delivery system and method for application products

Abstract

This application provides an automated delivery system and method for application artifacts. After receiving customized requests from users on an aPaaS webpage, the system encapsulates these requests into HTTPS request packets and sends them to a relay server. This triggers a pre-defined CI / CD pipeline task on the GitLab server. The relay server then injects the HTTPS request packets into the GitLab server to generate the corresponding application. The execution result is fed back to the aPaaS webpage via a Webhook mechanism. The aPaaS webpage then receives download commands from users and downloads the corresponding application artifacts from the GitLab server's pipeline artifact library via the GitLab API. This addresses the problem of GitLab servers struggling to implement complex user customization logic and real-time component linkage through a graphical interface, resulting in a poor user experience.

Description

Technical Field

[0001] This application relates to the field of information technology, and in particular to an automated delivery system and method for application products. Background Technology

[0002] Existing CI / CD (Continuous Integration / Continuous Delivery) platforms, such as GitLab Server, can significantly improve software delivery efficiency by automating build, testing, and deployment processes. However, the inventors' research revealed that existing GitLab Server pipeline parameters typically only support string or simple data type injection, lacking the ability to dynamically upload and transfer customized files. GitLab Server struggles to implement complex user-customized logic and real-time component interaction through a graphical interface, resulting in a poor user experience. Summary of the Invention

[0003] The purpose of this application is to provide an automated delivery system and method for application products, thereby solving the problem that GitLab servers struggle to implement complex user-customized logic and real-time component linkage through a graphical interface, resulting in a poor user experience. The specific technical solution is as follows:

[0004] In a first aspect, this application provides an automated delivery system for application products, the system comprising: an aPaaS webpage, a relay server, and a GitLab server;

[0005] The aPaaS webpage is used to receive customized requests input by the user; encapsulate the customized requests into an HTTPS request data packet; and send the HTTPS request data packet to a relay server; the customized requests include structured parameters and unstructured files;

[0006] The relay server is used to receive the HTTPS request data packet; and send the HTTPS request data packet to the GitLab server via the GitLab API to trigger the preset CI / CD pipeline task of the GitLab server.

[0007] The GitLab server is used to respond to the HTTPS request data packet and execute pipeline tasks; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is executed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism.

[0008] The relay server is also used to receive and parse Webhook data to obtain the pipeline execution result; and forward the pipeline execution result to the aPaaS webpage;

[0009] The aPaaS webpage is also used to receive a download instruction initiated by the user and send the download instruction to the relay server when the pipeline execution result indicates that the task has been successfully executed.

[0010] The relay server is also used to respond to the download command by downloading the corresponding application product from the pipeline product library of the GitLab server through the GitLab API, and forwarding the downloaded application product to the aPaaS webpage for users to download.

[0011] In one possible implementation, the relay server is further configured to temporarily store the downloaded application products locally after downloading them from the pipeline product library of the GitLab server, and clean up the locally stored application products according to a preset cleanup strategy after forwarding the application products to the aPaaS webpage, wherein the cleanup strategy includes at least one of the following:

[0012] The application product will be automatically deleted after the storage time reaches a preset threshold.

[0013] Delete the application artifact immediately after confirming that it has been successfully forwarded to the aPaaS webpage;

[0014] When the local storage space usage exceeds a preset threshold, the earliest application artifacts are deleted in order of storage time.

[0015] In one possible implementation, the aPaaS webpage is also used for:

[0016] Receive the pipeline execution results synchronized by the relay server;

[0017] If the pipeline execution result indicates that the task was successfully executed, the web page interface will be dynamically updated to display a prompt message including the packaging success status and the application artifact download entry;

[0018] If the pipeline execution result indicates that the task execution failed, the reason for the failure and the re-trigger option will be displayed.

[0019] In one possible implementation, the GitLab server executes the pipeline tasks via one or more GitLab Runners deployed on a separate build server; the build server is pre-configured with an application packaging environment, which includes at least one of Xcode and Node.js.

[0020] The pipeline task includes a preset packaging script, which is configured as follows:

[0021] Receive customized parameters and files injected by the relay server;

[0022] Based on the customized parameters and files, the application source code is configured to be replaced and resources are updated.

[0023] The application packaging environment is invoked to perform compilation and build operations, generating a customized App installation package as a pipeline product.

[0024] In one possible implementation, the relay server is deployed as a network proxy gateway, the aPaaS webpage communicates with the relay server via the public network, and the relay server communicates with the GitLab server via the intranet, so as to achieve secure isolation between external users and the internal build environment.

[0025] A second aspect of this application provides an automated delivery method for application products, applied to an automated delivery system for application products, the system comprising: an aPaaS webpage, a relay server, and a GitLab server;

[0026] The method includes:

[0027] The system receives customized requirements input by the user through the aPaaS webpage; encapsulates the customized requirements into an HTTPS request data packet; and sends the HTTPS request data packet to a relay server. The customized requirements include structured parameters and unstructured files.

[0028] The relay server receives the HTTPS request data packet; the GitLab API sends the HTTPS request data packet to the GitLab server to trigger the GitLab server's preset CI / CD pipeline task.

[0029] The GitLab server responds to the HTTPS request data packet and executes the pipeline task; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is completed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism.

[0030] The relay server receives and parses the Webhook data to obtain the execution result; then forwards the execution result to the aPaaS webpage.

[0031] The relay server receives and parses the Webhook data to obtain the pipeline execution result; and forwards the pipeline execution result to the aPaaS webpage.

[0032] When the pipeline execution result indicates that the task has been successfully executed, the aPaaS webpage receives the download instruction initiated by the user and sends the download instruction to the relay server.

[0033] In response to the download command, the relay server downloads the corresponding application product from the GitLab server's pipeline product library via the GitLab API, and forwards the downloaded application product to the aPaaS webpage for users to download.

[0034] In one possible implementation, the method further includes:

[0035] After downloading application products from the pipeline product library of the GitLab server via the relay server, the downloaded application products are temporarily stored locally. After forwarding the application products to the aPaaS webpage, the locally stored application products are cleaned up according to a preset cleanup strategy. The cleanup strategy includes at least one of the following: automatically deleting the application products after the storage time reaches a preset threshold; or deleting the application products immediately after confirming that they have been successfully forwarded to the aPaaS webpage.

[0036] When the local storage space usage exceeds a preset threshold, the earliest application artifacts are deleted in order of storage time.

[0037] In one possible implementation, the method further includes:

[0038] The aPaaS webpage receives the pipeline execution results synchronized by the relay server; if the pipeline execution result indicates that the task was executed successfully, the webpage interface is dynamically updated to display a prompt message including the packaging success status and the application artifact download entry; if the pipeline execution result indicates that the task failed, the reason for the failure and the re-trigger option are displayed.

[0039] In one possible implementation, the GitLab server executes the pipeline tasks via one or more GitLab Runners deployed on a separate build server; the build server is pre-configured with an application packaging environment, which includes at least one of Xcode and Node.js.

[0040] The pipeline task includes a preset packaging script, which is configured as follows:

[0041] Receive customized parameters and files injected by the relay server;

[0042] Based on the customized parameters and files, the application source code is configured to be replaced and resources are updated.

[0043] The application packaging environment is invoked to perform compilation and build operations, generating a customized App installation package as a pipeline product.

[0044] In one possible implementation, the relay server is deployed as a network proxy gateway, the aPaaS webpage communicates with the relay server via the public network, and the relay server communicates with the GitLab server via the intranet, so as to achieve secure isolation between external users and the internal build environment.

[0045] Another aspect of the application embodiments also provides an electronic device, including:

[0046] Memory, used to store computer programs;

[0047] A processor, used to execute programs stored in memory, implements an automated delivery method for any of the above-mentioned application products.

[0048] In another aspect of the embodiments of this application, a computer-readable storage medium is provided, which stores a computer program that, when executed by a processor, implements an automated delivery method for any of the above-described application products.

[0049] In another aspect of the embodiments of this application, a computer program product containing instructions is also provided, which, when run on a computer, causes the computer to execute an automated delivery method for any of the above-described application products.

[0050] Beneficial effects of the embodiments in this application:

[0051] This application provides an automated delivery system and method for application artifacts. The system includes: an aPaaS webpage, a relay server, and a GitLab server. The aPaaS webpage receives customized requirements input by the user; encapsulates the customized requirements into an HTTPS request data packet; and sends the HTTPS request data packet to the relay server. The customized requirements include structured parameters and unstructured files. The relay server receives the HTTPS request data packet and sends it to the GitLab server via the GitLab API to trigger a preset CI / CD pipeline task on the GitLab server. The GitLab server responds to the HTTPS request data packet and executes the pipeline task. If the pipeline task executes successfully, a customized application artifact is generated and stored in the pipeline artifact library. After the pipeline task is completed, a pipeline execution result containing the execution status is sent to the relay server via a Webhook mechanism. The relay server is further configured to receive and parse Webhook data to obtain the pipeline execution result; and forward the pipeline execution result to the aPaaS webpage; the aPaaS webpage is further configured to receive a download instruction initiated by the user when the pipeline execution result indicates that the task has been successfully executed, and send the download instruction to the relay server; the relay server is further configured to respond to the download instruction, download the corresponding application product from the pipeline product library of the GitLab server through the GitLab API, and forward the downloaded application product to the aPaaS webpage for the user to download. The proposed solution, after receiving customized user input on the aPaaS webpage, encapsulates it into an HTTPS request data packet and sends it to a relay server. This triggers a pre-defined CI / CD pipeline task on the GitLab server, which then injects the HTTPS request data packet into the GitLab server to generate the corresponding app. The execution result is then fed back to the aPaaS webpage via a Webhook mechanism. The aPaaS webpage then receives the user's download command, downloads the corresponding application artifact from the GitLab server's pipeline artifact library via the GitLab API, and forwards the downloaded application artifact to the aPaaS webpage for user download. This allows for the generation of an app based on the user's customized input, solving the problem of GitLab servers struggling to implement complex user customization logic and real-time component interaction through a graphical interface, resulting in a poor user experience.

[0052] Of course, implementing any product or method of this application does not necessarily require achieving all of the advantages described above at the same time. Attached Figure Description

[0053] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other embodiments can be obtained based on these drawings.

[0054] Figure 1 A schematic diagram of a structure for an automated delivery system of application products provided in an embodiment of this application;

[0055] Figure 2 An interactive diagram of an automated delivery system for application products provided in an embodiment of this application;

[0056] Figure 3 A flowchart illustrating an automated delivery method for application products provided in an embodiment of this application;

[0057] Figure 4 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0058] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art based on this application are within the scope of protection of this application.

[0059] The first aspect of this application provides an automated delivery system for application products, see [link to relevant documentation]. Figure 1 , Figure 1 This is a schematic diagram of an automated delivery system for application products provided in an embodiment of this application. The system includes: an aPaaS webpage (Application Platform as a Service, a cloud platform for rapidly building applications through low-code or model-driven methods) 101, a relay server 102, and a GitLab server (an integrated platform for managing the entire software development lifecycle, including code hosting, CI / CD (continuous integration / continuous delivery), and project management) 103.

[0060] The aPaaS webpage 101 is used to receive customized requests input by the user; encapsulate the customized requests into an HTTPS (Hypertext Transfer Protocol Secure) request data packet; and send the HTTPS request data packet to a relay server; the customized requests include structured parameters and unstructured files;

[0061] The relay server 102 is used to receive the HTTPS request data packet; and send the HTTPS request data packet to the GitLab server through the GitLab API (a programming interface provided by GitLab) to trigger the CI / CD pipeline task preset by the GitLab server.

[0062] The GitLab server 103 is used to respond to the HTTPS request data packet and execute pipeline tasks; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is executed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook (web hook in web development) mechanism.

[0063] The relay server 102 is also used to receive and parse Webhook data to obtain the pipeline execution result; and forward the pipeline execution result to the aPaaS webpage;

[0064] The aPaaS webpage 101 is also used to receive a download instruction initiated by the user and send the download instruction to the relay server when the pipeline execution result indicates that the task has been successfully executed.

[0065] The relay server 102 is also used to respond to the download command by downloading the corresponding application product from the pipeline product library of the GitLab server through the GitLab API, and forwarding the downloaded application product to the aPaaS webpage for users to download.

[0066] In this embodiment, when the aPaaS webpage receives customized requests input by the user, these requests may include, but are not limited to, the App (application) name, icon, launch image, version number, and selected packaging platform. The aPaaS webpage can encapsulate the received customized requests into an HTTPS request data packet and then send the HTTPS request data packet to a relay server. The customized requests may include structured parameters and unstructured files. Specifically, when encapsulating the HTTPS request data packet, existing solutions can be referenced.

[0067] During the app generation process, after receiving the HTTPS request data packet, the relay server can call the GitLab API to inject the HTTPS request data packet into the internal GitLab server to trigger the execution of a pre-configured packaging pipeline. The GitLab server is configured with Xcode (an integrated development environment) or Node.js (a service interface) as the app packaging environment. The GitLab server can receive and respond to the HTTPS request data packet, generate the app installation package, and then send Webhook data to the relay server via a Webhook mechanism to trigger the pre-set CI / CD pipeline task on the GitLab server. The Webhook data includes the execution result. In one example, the GitLab server pipeline is executed by a server with Git Runner installed, which is configured with Xcode, Node.js, and other relevant app packaging environments.

[0068] GitLab server 103 responds to the HTTPS request data packet and executes the pipeline task. If the pipeline task executes successfully, it generates customized application artifacts and stores them in the pipeline artifact repository. After the pipeline task execution is completed, it sends the pipeline execution result, including the execution status, to the relay server via a webhook mechanism. Specifically, the packaging script for the pipeline execution project, combined with injected customized parameters and files, generates a customized App installation package (pipeline artifacts / Artifacts (various output files summarizing the software development process)). Furthermore, after the pipeline execution is completed (or in progress), the GitLab server can also notify the relay server of the pipeline execution result via a webhook mechanism. This webhook is a lightweight, callback-based communication mechanism that allows the system to proactively send notifications when specific events occur, enabling real-time data interaction.

[0069] The relay server receives and parses the Webhook data to obtain the pipeline execution result, and then forwards the pipeline execution result to the aPaaS webpage. After the APP is generated, the relay server can receive and parse the Webhook data to obtain the execution result, and then forward the execution result to the aPaaS webpage. In actual use, this execution result can be information indicating successful or unsuccessful execution.

[0070] When the pipeline execution result indicates successful task execution, the aPaaS webpage receives the user-initiated download command and sends it to the relay server. After sending this information to the aPaaS webpage, it can parse and display it. Thus, after viewing the prompt information, the user can enter the download command through the aPaaS webpage.

[0071] In response to the download command, the relay server downloads the corresponding application artifact from the GitLab server's pipeline artifact library via the GitLab API, and forwards the downloaded application artifact to the aPaaS webpage for user download. In this application, after receiving the download command input by the user, the aPaaS webpage can send the download command to the relay server. The relay server then receives and responds to the download command, downloading the corresponding app from the GitLab server via the GitLab API.

[0072] As can be seen, the system of this application embodiment can encapsulate the user's customized input into an HTTPS request data packet and send it to a relay server after the aPaaS webpage receives the customized request. This triggers the pre-set CI / CD pipeline task of the GitLab server, which then injects the HTTPS request data packet into the GitLab server to generate the corresponding APP. The execution result is fed back to the aPaaS webpage through a Webhook mechanism. The aPaaS webpage receives the user's download instruction, downloads the corresponding application product from the GitLab server's pipeline product library through the GitLab API, and forwards the downloaded application product to the aPaaS webpage for the user to download. This enables the generation of corresponding APPs based on the user's customized input, solving the problem that GitLab server is difficult to implement complex user customization logic and real-time component linkage through a graphical interface, resulting in a poor user experience.

[0073] In one possible implementation, the relay server is further configured to temporarily store the downloaded application products locally after downloading them from the GitLab server's pipeline product library, and clean up the locally stored application products according to a preset cleanup strategy after forwarding them to the aPaaS webpage. The cleanup strategy includes at least one of the following: automatically deleting the application products after their storage time reaches a preset threshold; deleting them immediately after confirming that they have been successfully forwarded to the aPaaS webpage; and deleting the earliest application products in storage time order when local storage space usage exceeds a preset threshold. Specifically, "local" in this embodiment can refer to the location of the aPaaS webpage, and the specific storage location in actual use can be set according to user needs. In one example, after the webpage displays "Packaging successful," the user triggers a product download command. After receiving the download command, the relay server can call the GitLab API to download the application products from the GitLab server's pipeline products and store them locally.

[0074] In one possible implementation, the aPaaS webpage is further used to: receive pipeline execution results synchronized by the relay server; if the pipeline execution result indicates successful task execution, dynamically update the webpage interface to display a prompt message including a successful packaging status and an application artifact download entry; if the pipeline execution result indicates task failure, display the failure reason and a re-trigger option. The execution result in this embodiment may include execution success or failure information. After receiving this execution success or failure information on the webpage, it can display the information so that the user can input relevant commands based on the displayed information. In one example, the relay server parses Webhook data and synchronously updates the pipeline execution result (such as "packaging successful / failed") to the aPaaS webpage, achieving real-time feedback on the user's page.

[0075] In one possible implementation, the GitLab server executes the pipeline tasks through one or more GitLab Runners deployed on a separate build server. The build server is pre-configured with an application packaging environment, including at least one of Xcode and Node.js. The pipeline tasks include preset packaging scripts configured to: receive customized parameters and files injected by the relay server; perform configuration replacements and resource updates on the application source code based on the customized parameters and files; and invoke the application packaging environment to perform compilation and build operations, generating a customized App installation package as the pipeline output. In another possible implementation, the relay server is deployed as a network proxy gateway. The aPaaS webpage communicates with the relay server via the public network, and the relay server communicates with the GitLab server via the intranet, thereby achieving secure isolation between external users and the internal build environment. In this embodiment, after the aPaaS webpage receives the execution result, it parses the result. If the result indicates that packaging is incomplete, the generation can be considered a failure. The HTTPS request data packet is then re-injected into the GitLab server on the intranet via the GitLab API to generate the app. In actual use, this loop can be monitored. If the number of loop iterations is reached without successful generation, the loop can be terminated, and the HTTPS request data packet will no longer be injected into the GitLab server on the intranet via the GitLab API. A generation failure message can be displayed. The user-inputted customization requirements received by the aPaaS webpage include: App name, icon, launch image, version number, and one or more of the selected packaging platform. In actual use, this information can be set according to the user's actual needs. For example, an ODM (Original Design Manufacturer) App customization webpage built on the aPaaS system receives user-inputted customization requirements, including but not limited to App name, icon, launch image, version number, and selected packaging platform. The obtained user requirements (including structured parameters and unstructured files) are then encapsulated into an HTTPS request data packet.

[0076] To illustrate the solutions of the embodiments of this application, the following description is provided in conjunction with a specific example. (See [link to example]). Figure 2 , Figure 2 An interaction diagram for an automated delivery system of application products provided in this application embodiment includes:

[0077] 1. User Requirement Acquisition and Parameter Encapsulation: The ODMApp customization webpage, built on an aPaaS system, receives user-inputted customization requirements, including but not limited to App name, icon, splash screen, version number, and selected packaging platform. The acquired user requirements (including structured parameters and unstructured files) are then encapsulated into an HTTPS request data packet.

[0078] 2. Pipeline Triggering and Intranet Proxy: After receiving an HTTPS request, the relay server securely injects the encapsulated custom parameters into the GitLab server by calling the GitLab API, thereby triggering the execution of the pre-configured packaging pipeline (CI script).

[0079] 3. App Building and Artifact Generation: The GitLab pipeline is executed by a server with Git Runner (a component for automating build, test, and deployment tasks) installed. This server is configured with an app packaging environment such as Xcode and Node.js. The pipeline executes the project's packaging script, and, combined with injected custom parameters and files, generates a customized app installation package (pipeline artifacts).

[0080] 4. Status Feedback and Webpage Synchronization: After the GitLab server completes (or is in the process of) the pipeline execution, it notifies the relay server of the pipeline execution result via a Webhook mechanism. The relay server parses the Webhook data and synchronously updates the pipeline execution result (such as "packaging successful / failed") to the aPaaS webpage, enabling real-time feedback to the user's page.

[0081] 5. Product Download Transfer and Local Storage: After the webpage displays "Packaging Successful," the user triggers a product download command. Upon receiving the download command, the transfer server calls the GitLab API to download the product from the GitLab server pipeline and store it locally.

[0082] 6. Secure distribution and final delivery: The relay server sends the locally stored product to the web page, ultimately allowing users to receive the customized App installation package.

[0083] A second aspect of this application provides an automated delivery method for application products, applied to an automated delivery system for application products, the system comprising: an aPaaS webpage, a relay server, and a GitLab server;

[0084] See Figure 3 , Figure 3 A flowchart illustrating an automated delivery method for application products provided in this application embodiment, the method comprising:

[0085] Step S31: Receive user-inputted customization requirements through the aPaaS webpage; encapsulate the customization requirements into an HTTPS request data packet; send the HTTPS request data packet to the relay server; the customization requirements include structured parameters and unstructured files;

[0086] Step S32: Receive the HTTPS request data packet through the relay server; send the HTTPS request data packet to the GitLab server through the GitLab API to trigger the preset CI / CD pipeline task of the GitLab server;

[0087] Step S33: The GitLab server responds to the HTTPS request data packet and executes the pipeline task; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is completed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism.

[0088] Step S34: Receive and parse the Webhook data through the relay server to obtain the execution result; forward the execution result to the aPaaS webpage;

[0089] Step S35: Receive and parse Webhook data through the relay server to obtain the pipeline execution result; and forward the pipeline execution result to the aPaaS webpage;

[0090] Step S36: If the pipeline execution result indicates that the task has been successfully executed, the aPaaS webpage receives the download instruction initiated by the user and sends the download instruction to the relay server.

[0091] Step S37: In response to the download command, the relay server downloads the corresponding application product from the pipeline product library of the GitLab server via the GitLab API, and forwards the downloaded application product to the aPaaS webpage for the user to download.

[0092] In one possible implementation, the method further includes:

[0093] After downloading application products from the pipeline product library of the GitLab server via the relay server, the downloaded application products are temporarily stored locally. After forwarding the application products to the aPaaS webpage, the locally stored application products are cleaned up according to a preset cleanup strategy. The cleanup strategy includes at least one of the following: automatically deleting the application products after the storage time reaches a preset threshold; or deleting the application products immediately after confirming that they have been successfully forwarded to the aPaaS webpage.

[0094] When the local storage space usage exceeds a preset threshold, the earliest application artifacts are deleted in order of storage time.

[0095] In one possible implementation, the method further includes:

[0096] The aPaaS webpage receives the pipeline execution results synchronized by the relay server; if the pipeline execution result indicates that the task was executed successfully, the webpage interface is dynamically updated to display a prompt message including the packaging success status and the application artifact download entry; if the pipeline execution result indicates that the task failed, the reason for the failure and the re-trigger option are displayed.

[0097] In one possible implementation, the GitLab server executes the pipeline tasks via one or more GitLab Runners deployed on a separate build server; the build server is pre-configured with an application packaging environment, which includes at least one of Xcode and Node.js.

[0098] The pipeline task includes a preset packaging script, which is configured as follows:

[0099] Receive customized parameters and files injected by the relay server;

[0100] Based on the customized parameters and files, the application source code is configured to be replaced and resources are updated.

[0101] The application packaging environment is invoked to perform compilation and build operations, generating a customized App installation package as a pipeline product.

[0102] In one possible implementation, the relay server is deployed as a network proxy gateway, the aPaaS webpage communicates with the relay server via the public network, and the relay server communicates with the GitLab server via the intranet, so as to achieve secure isolation between external users and the internal build environment.

[0103] As can be seen, the method of this application embodiment can encapsulate the user's customized input into an HTTPS request data packet and send it to a relay server after the aPaaS webpage receives the customized request. This triggers the pre-set CI / CD pipeline task of the GitLab server, thereby injecting the HTTPS request data packet into the GitLab server through the relay server to generate the corresponding APP. The execution result is fed back to the aPaaS webpage through a Webhook mechanism. The aPaaS webpage then receives the user's download instruction, downloads the corresponding application product from the GitLab server's pipeline product library through the GitLab API, and forwards the downloaded application product to the aPaaS webpage for the user to download. This enables the generation of corresponding APPs based on the user's customized input, solving the problem that GitLab server is difficult to implement complex user customization logic and real-time component linkage through a graphical interface, resulting in a poor user experience.

[0104] In another aspect of the embodiments of this application, an electronic device is also provided, see [link to relevant documentation]. Figure 4 ,include:

[0105] Memory 401 is used to store computer programs;

[0106] When processor 402 executes a program stored in memory, it implements the following:

[0107] The system receives customized requirements input by the user through the aPaaS webpage; encapsulates the customized requirements into an HTTPS request data packet; and sends the HTTPS request data packet to a relay server. The customized requirements include structured parameters and unstructured files.

[0108] The relay server receives the HTTPS request data packet; the GitLab API sends the HTTPS request data packet to the GitLab server to trigger the GitLab server's preset CI / CD pipeline task.

[0109] The GitLab server responds to the HTTPS request data packet and executes the pipeline task; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is completed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism.

[0110] The relay server receives and parses the Webhook data to obtain the execution result; then forwards the execution result to the aPaaS webpage.

[0111] The relay server receives and parses the Webhook data to obtain the pipeline execution result; and forwards the pipeline execution result to the aPaaS webpage.

[0112] When the pipeline execution result indicates that the task has been successfully executed, the aPaaS webpage receives the download instruction initiated by the user and sends the download instruction to the relay server.

[0113] In response to the download command, the relay server downloads the corresponding application product from the GitLab server's pipeline product library via the GitLab API, and forwards the downloaded application product to the aPaaS webpage for users to download.

[0114] The communication bus mentioned in the above electronic devices can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. This communication bus can be divided into address bus, data bus, control bus, etc. For ease of illustration, only one thick line is used to represent it in the diagram, but this does not mean that there is only one bus or one type of bus.

[0115] The communication interface is used for communication between the aforementioned electronic devices and other devices.

[0116] The memory may include random access memory (RAM) or non-volatile memory (NVM), such as at least one disk storage device. Optionally, the memory may also be at least one storage device located remotely from the aforementioned processor.

[0117] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0118] In another embodiment provided in this application, a computer-readable storage medium is also provided, which stores a computer program that, when executed by a processor, implements an automated delivery method for any of the above-described application products.

[0119] In another embodiment provided in this application, a computer program product containing instructions is also provided, which, when run on a computer, enables the computer to implement an automated delivery method for any of the above-described application products.

[0120] In the above embodiments, implementation can be achieved entirely or partially through software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented entirely or partially in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that integrates one or more available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a solid-state drive (SSD), etc.

[0121] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0122] The various embodiments in this specification are described in a related manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. Related parts can be found in the descriptions of the system embodiments.

[0123] The above description is merely a preferred embodiment of this application and is not intended to limit the scope of protection of this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application are included within the scope of protection of this application.

Claims

1. An automated delivery system for application products, characterized by, The system includes: an aPaaS webpage, a relay server, and a GitLab server; The aPaaS webpage is used to receive customized requirements input by the user; encapsulate the customized requirements into an HTTPS request data packet; and send the HTTPS request data packet to a relay server; the customized requirements include structured parameters and unstructured files; the customized requirements include one or more of the following: APP name, icon, launch image, version number, and selected packaging platform; the aPaaS webpage is an ODM App customization webpage built on the aPaaS system. The relay server is used to receive the HTTPS request data packet; and send the HTTPS request data packet to the GitLab server via the GitLab API to trigger the preset CI / CD pipeline task of the GitLab server. The GitLab server is used to respond to the HTTPS request data packet and execute pipeline tasks; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is executed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism. The relay server is also used to receive and parse Webhook data to obtain the pipeline execution result; and forward the pipeline execution result to the aPaaS webpage; The aPaaS webpage is also used to receive a download instruction initiated by the user and send the download instruction to the relay server when the pipeline execution result indicates that the task has been successfully executed. The relay server is also used to respond to the download command by downloading the corresponding application product from the pipeline product library of the GitLab server through the GitLab API, and forwarding the downloaded application product to the aPaaS webpage for users to download. The GitLab server executes the pipeline tasks through one or more GitLab Runners, which are deployed on a separate build server; the build server is pre-configured with an application packaging environment, which includes at least one of Xcode and Node.js. The pipeline task includes a preset packaging script, which is configured as follows: Receive customized parameters and files injected by the relay server; Based on the customized parameters and files, the application source code is configured to be replaced and resources are updated. The application packaging environment is invoked to perform compilation and build operations, generating a customized App installation package as a pipeline product; The relay server is deployed as a network proxy gateway. The aPaaS webpage communicates with the relay server through the public network, and the relay server communicates with the GitLab server through the intranet, so as to achieve secure isolation between external users and the internal build environment. The aPaaS webpage is also used for: Receive the pipeline execution results synchronized by the relay server; If the pipeline execution result indicates that the task was successfully executed, the web page interface will be dynamically updated to display a prompt message including the packaging success status and the application artifact download entry; If the pipeline execution result indicates that the task execution failed, the reason for the failure and the re-trigger option will be displayed.

2. The system according to claim 1, characterized in that, The relay server is further configured to temporarily store the downloaded application products locally after downloading them from the pipeline product library of the GitLab server, and clean up the locally stored application products according to a preset cleanup strategy after forwarding the application products to the aPaaS webpage, wherein the cleanup strategy includes at least one of the following: The application product will be automatically deleted after the storage time reaches a preset threshold. Delete the application artifact immediately after confirming that it has been successfully forwarded to the aPaaS webpage; When the local storage space usage exceeds a preset threshold, the earliest application artifacts are deleted in order of storage time.

3. An automated delivery method of an application product, characterized by, An automated delivery system for application products, the system comprising: an aPaaS webpage, a relay server, and a GitLab server; The method includes: The aPaaS webpage receives user-inputted customization requirements; encapsulates the customization requirements into an HTTPS request data packet; and sends the HTTPS request data packet to a relay server. The customization requirements include structured parameters and unstructured files. The customization requirements include one or more of the following: APP name, icon, launch image, version number, and selected packaging platform. The aPaaS webpage is an ODM App customization webpage built on the aPaaS system. The relay server receives the HTTPS request data packet; the GitLab API sends the HTTPS request data packet to the GitLab server to trigger the GitLab server's preset CI / CD pipeline task. The GitLab server responds to the HTTPS request data packet and executes the pipeline task; if the pipeline task is executed successfully, a customized application artifact is generated and stored in the pipeline artifact library; and after the pipeline task is completed, the pipeline execution result containing the execution status is sent to the relay server through the Webhook mechanism. The relay server receives and parses the Webhook data to obtain the execution result; then forwards the execution result to the aPaaS webpage. The relay server receives and parses the Webhook data to obtain the pipeline execution result; and forwards the pipeline execution result to the aPaaS webpage. When the pipeline execution result indicates that the task has been successfully executed, the aPaaS webpage receives the download instruction initiated by the user and sends the download instruction to the relay server. In response to the download command, the relay server downloads the corresponding application product from the GitLab server's pipeline product library via the GitLab API, and forwards the downloaded application product to the aPaaS webpage for users to download. The GitLab server executes the pipeline tasks through one or more GitLab Runners, which are deployed on a separate build server. The build server is pre-configured with an application packaging environment, which includes at least one of Xcode and Node.js. The pipeline task includes a preset packaging script, which is configured as follows: Receive customized parameters and files injected by the relay server; Based on the customized parameters and files, the application source code is configured to be replaced and resources are updated. The application packaging environment is invoked to perform compilation and build operations, generating a customized App installation package as a pipeline product; The relay server is deployed as a network proxy gateway. The aPaaS webpage communicates with the relay server through the public network, and the relay server communicates with the GitLab server through the intranet, so as to achieve secure isolation between external users and the internal build environment. The aPaaS webpage receives the pipeline execution results synchronized by the relay server; if the pipeline execution result indicates that the task was executed successfully, the webpage interface is dynamically updated to display a prompt message including the packaging success status and the application artifact download entry; if the pipeline execution result indicates that the task failed, the reason for the failure and the re-trigger option are displayed.

4. The method of claim 3, wherein, The method further includes: After downloading application products from the pipeline product library of the GitLab server via the relay server, the downloaded application products are temporarily stored locally. After forwarding the application products to the aPaaS webpage, the locally stored application products are cleaned up according to a preset cleanup strategy. The cleanup strategy includes at least one of the following: automatically deleting the application products after the storage time reaches a preset threshold; or deleting the application products immediately after confirming that they have been successfully forwarded to the aPaaS webpage. When the local storage space usage exceeds a preset threshold, the earliest application artifacts are deleted in order of storage time.

5. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor, when executing a program stored in memory, implements the method of any one of claims 3-4.

6. A computer-readable storage medium, characterized in that, The computer-readable storage medium contains a computer program that, when executed by a processor, implements the method described in any one of claims 3-4.

Images