Automatic iteration upgrading device and method for low-code enterprise application

Abstract

The invention discloses a low-code enterprise application automatic iteration upgrading device and method, relates to the technical field of enterprise application development and operation and maintenance, and particularly relates to a method for modeling an event stream through a low-code application visual modeling development tool module set, storing the event stream to an event data storage library through a modeling event auditing service, and updating the event data storage library. A database upgrading script file and an upgrading patch code file are generated through the code generation tool module and submitted to the existing code version control tool module, and an application service package is constructed through the existing application integration construction deployment tool module; and in combination with the upgrading engine module and the upgrading transaction coordination service module, realizing consistent upgrading and backspacing of multiple micro-service applications in a production environment. According to the method, automatic upgrading and refined rollback of the low-code enterprise application in the full life cycle are achieved, and the reliability and controllability of a system in a complex scene are improved.

Description

Technical Field

[0001] This invention relates to the field of enterprise application development and maintenance technology, and in particular to a low-code enterprise application automated iterative upgrade device, and also to an upgrade method for the aforementioned low-code enterprise application automated iterative upgrade device. Background Technology

[0002] With the continuous expansion of enterprise application systems and the rapid changes in business needs, low-code application systems undergo frequent version iterations. Traditional software upgrade methods typically rely on manually writing upgrade scripts or using database comparison tools to generate difference scripts, which presents the following problems: Firstly, most existing methods focus on the database level, generating upgrade statements by comparing the database structures of the old and new versions. They lack business semantic awareness and the ability to handle complex dependencies, often resulting in uncontrollable generated scripts, high risk of destructive operations, and difficulty in rollback. Secondly, for application scenarios with distributed and microservice architectures, existing tools cannot guarantee collaborative upgrades across services and modules, which can easily lead to inconsistent dependencies or interface failures, thereby affecting the overall availability of the system. Third, current solutions generally lack standardized rollback mechanisms. Once an error occurs during the upgrade process, it usually has to be checked and corrected manually, which leads to high maintenance costs and potential data risks.

[0003] Therefore, there is an urgent need for an automatic iterative upgrade solution that is closely integrated with the low-code platform development process, can automatically generate upgrade and rollback scripts, and is adapted to microservice architecture. Summary of the Invention

[0004] The technical problem to be solved by this invention is to address the shortcomings of existing technologies by providing an automated iterative upgrade device for low-code enterprise applications. By establishing a complete event-driven and version management mechanism, it enables automated upgrades of low-code applications from modeling and code generation to production environment deployment. During the visual modeling and development process on the low-code platform, it collects action event flow data generated by user operations in real time, using this data as the basis for incremental changes in the application design phase. During application release and iterative upgrades, it automatically generates corresponding upgrade scripts and rollback scripts based on the event flow data, thereby achieving smooth upgrades and rapid recovery of application versions.

[0005] Another technical problem to be solved by the present invention is to provide an upgrade method for the above-mentioned low-code enterprise application automated iterative upgrade device.

[0006] The technical problem to be solved by this invention is achieved through the following technical solution. This invention is a low-code enterprise application automated iterative upgrade device, comprising a low-code application visual modeling and development tool module, a modeling event auditing service module, an event data repository, a code generation tool module, a database upgrade script file module, an upgrade patch code file module, a code version control tool module based on existing mature open-source products, an application integration, build, and deployment tool module based on existing mature open-source products, an upgrade engine module, and an upgrade transaction coordination service module. The Low-Code Application Visual Modeling Development Tool Module provides developers with a visual modeling environment and allows them to submit event data for modeling operations. The modeling event audit service module is used to receive and record the event data, and save the recorded incremental event data to the event data repository; The event data repository is used to store incremental event stream data provided by the modeling event auditing service module; The code generation tool module is used to load incremental event stream data from the event data repository and generate database upgrade scripts and upgrade patch code based on the event stream data; The database upgrade script file module is used to store the database upgrade scripts generated by the code generation tool module; The upgrade patch code file module is used to store the upgrade patch code generated by the code generation tool module; The code version control tool module uses existing technology products to maintain the version history of the application project and supports pulling and submitting the latest code; The application integration build and deployment tool module uses existing technology products to pull the latest code version of the code version control tool module and build and generate the various service packages of the application, deploy them to the production environment, execute the application startup command, and trigger the upgrade process of each microservice; The upgrade engine module is deployed in each application service package in the production environment. It is used to identify the current application version when the service starts and perform upgrade operations according to the database upgrade script file and upgrade patch code file. The upgrade transaction coordination service module is used to register upgrade transactions, coordinate and ensure the consistency of upgrades for multiple application services, and trigger rollback when the upgrade fails.

[0007] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, a low-code enterprise application automated iterative upgrade method includes the following steps: (1) Collect and store modeling event flow data in the visualization low-code development process; (2) Generate database upgrade script files and upgrade patch code files based on the incremental data of the modeling event stream; (3) Merge the generated script files and patch code files with other code in the application project and submit them to the version control system; (4) Build the various service packages of the application and deploy them to the production environment; (5) When starting each application service in the production environment, perform a global consistency upgrade or rollback on the low-code application.

[0008] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, the event stream data exists in the form of an event sequence and is used to record various operations in the process of visual low-code modeling and development, so as to support the upgrade script and patch code to accurately replay or roll back any granularity of metadata changes.

[0009] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, the code generation tool generates a database upgrade script that is compatible with the format of a general database version management tool, so as to achieve portable upgrades across database platforms.

[0010] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, the upgrade patch code is rendered in reverse through event data into user operation instructions that can be re-executed in the production environment, which is used to automatically restore or complete the application configuration and metadata without human intervention.

[0011] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, in the database script file and patch code file, design and develop operation event data for each user and generate its corresponding reverse rollback operation code.

[0012] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, when an error or exception occurs during the upgrade process, a rollback mechanism is triggered to execute rollback operation code to revert the application database to the state before the upgrade.

[0013] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, before performing the upgrade in the production environment, the current version number and the version number to be upgraded are compared, and the decision on whether to continue the upgrade operation is made based on the comparison result.

[0014] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, according to the file execution record, only the database upgrade script file and patch code file that have not been executed are executed, and they are executed in the order of the globally unique serial number of the file. After the upgrade is successful, the newly executed file is added to the file execution record for saving.

[0015] The technical problem to be solved by the present invention can also be further achieved through the following technical solution: For the low-code enterprise application automated iterative upgrade method described above, the service cluster first competes for a global upgrade lock before performing the upgrade, so as to avoid multiple service instances from performing parallel upgrades, which would lead to upgrade failure.

[0016] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. This invention establishes a direct link between the low-code development process and the application upgrade process, enabling the generation of event stream data that can be used for iterative upgrades during the application design phase. This avoids the traditional method's reliance on library structure comparison, which makes it difficult to fully capture user operations and business logic changes during the visual development process, leading to problems such as data loss, service conflicts, or difficulty in rollback during the upgrade process. 2. This invention provides overall upgrade support for database structure, business metadata and application configuration data, ensuring cross-service consistency in a microservice architecture. At the same time, this invention has a built-in standardized rollback mechanism that can immediately trigger automatic rollback when the upgrade fails, which significantly reduces manual intervention and operation and maintenance risks, and ensures the high availability and data consistency of the system. 3. This invention improves the speed of enterprise application iteration while also enhancing the stability and security of the upgrade process, making it particularly suitable for enterprise-level low-code platforms in complex scenarios. Attached Figure Description

[0017] Figure 1 This is the overall flowchart of the present invention; Figure 2 This is a diagram illustrating the overall architecture of the present invention; Figure 3 This is a schematic diagram of the code generation mechanism of the present invention; Figure 4 This is a flowchart of the global consistency upgrade process of the present invention; The diagram is marked as follows: 110. Visual modeling and development tools for low-code applications; 120. Modeling event auditing service; 130. Event data repository; 140. Code generation tools; 141. Database upgrade script file; 142. Upgrade patch code file; 150. Code version control tools, using existing technology products such as Git; 160. Use application integration build and deployment tools, and adopt existing technology products, such as Jenkins; 170. Upgrade the engine; 180. Cross-service upgrade transaction coordination service. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0019] As shown in Figure 1, a method for automatic iterative upgrades of low-code enterprise applications mainly includes the following steps: S1 first collects and stores event stream data generated by the low-code visual modeling development tool during the application design process. This event stream data records various operations performed by developers when designing the application, including modification information on data models, page components, business logic, and service interfaces, ensuring that the complete design process can be traced back to later. S2 generates database upgrade script files and patch code files based on the collected incremental event data. These files are automatically generated by the code generation tool by parsing the event data. They can cover many aspects such as database structure changes, application logic adjustments, and service interface updates. At the same time, corresponding rollback scripts are also generated to restore the original state in case of upgrade failure. S3 generates script files and patch code files which are submitted to the version control system and merged and managed in a unified manner with other source code in the application project. This process ensures version traceability and consistency during application iteration and upgrades. S4 invokes the application integration build and deployment tool to build the application's various service modules based on the latest version of the source code and upgrade scripts, and deploys the generated service packages to the production environment. This process can support the construction and deployment of multiple services under a microservice architecture, ensuring consistency and collaboration between different services.

[0020] S5: When services in the production environment start, the system executes the upgrade engine to perform globally consistent execution of the generated upgrade scripts and patch code. During execution, if an upgrade failure is detected, the system will automatically restore to the initial state according to the pre-generated rollback script, thereby ensuring system stability and data integrity. For a detailed flowchart of this step, please refer to [link to flowchart]. Figure 4 .

[0021] Through the above steps, this invention achieves full automation of low-code enterprise applications from design and modeling to production environment upgrades, and has the ability to quickly roll back in case of upgrade failure, making it suitable for reliable iterative upgrade scenarios of complex enterprise applications.

[0022] like Figure 2 As shown, the overall architecture of a low-code enterprise application automatic iteration and upgrade device includes: During the application modeling process, low-code application developers use the low-code application visual modeling development tool 110 to perform application design and configuration operations; this tool collects user operation behavior data in real time and submits it to the modeling event auditing service in the form of event streams.

[0023] The modeling event audit service 120 is responsible for parsing and verifying the event data generated by user operations and storing it in the event data repository 130. The event data repository saves all historical operation data during the application development process, providing basic support for the subsequent generation of upgrade and rollback scripts.

[0024] When developers need to release the application, code generation tool 140 is invoked. The tool loads event stream data added since the last release from the modeling event auditing service, parses these events chronologically, and generates corresponding database upgrade script files 141 and upgrade patch code files 142. These files contain not only upgrade logic but also rollback logic, ensuring recovery capabilities in case of upgrade failure. Subsequently, the generated script files and patch code files are added to the application code project directory and submitted to the code version control tool 150. The code version control tool uses existing mature technology products to maintain historical versions of the application source code and upgrade scripts, ensuring that differences between versions are controllable and traceable.

[0025] After code version control is completed, the application integration build and deployment tool 160 is triggered. This tool, also based on existing mature technology products, is responsible for pulling the latest code from the code version control tool 150, integrating it with the upgrade engine 170 for unified building, and generating a complete application service package. The application integration build and deployment tool will build each microservice in the application one by one, and mark the generated application service package with a unified version identifier. After the build is completed, the application integration build and deployment tool will automatically deploy the application service package to the production environment.

[0026] In the production environment, the upgrade engine 170 and the cross-service upgrade transaction coordination service 180 work together to ensure the consistency and reliability of the upgrade process. When the service starts, the upgrade engine compares the current service version with the latest global version number and attempts to acquire the global upgrade lock. The upgrade transaction coordination service schedules the upgrade order of each service according to the dependencies between microservices to ensure that the cross-service upgrade process satisfies consistency and atomicity. If any service upgrade fails during the execution process, the upgrade transaction coordination service will notify all services to perform a rollback operation to restore the system to its initial state. If all upgrades are completed successfully, all services will synchronously enter the new version, completing the application iteration upgrade.

[0027] Through the above architecture design, this invention achieves full-process automation driven by low-code design and development event flow, from application design, event storage, code generation, version control, integration and building to production deployment and upgrade rollback. It solves the problem of difficulty in unified management and consistency assurance for iterative upgrades of low-code enterprise applications in complex scenarios.

[0028] Figure 3 The following is an example of the application upgrade code generation mechanism of this invention: First, users perform application design and modification operations through the low-code application modeling and development tool 110; for example, when a user modifies the attribute value of a data entity in the interface, this operation is recorded as structured (JSON in the example in the figure) action event stream data; In the specific implementation process, the captured action event data includes event type, attribute name, values ​​before and after modification, data type, display name, etc. For example, when a user changes the "staffName" field from fullName to staffName and adjusts the field length from 150 to 255, this action will be recorded as the corresponding event object.

[0029] Subsequently, the code generation tool 140 parses and processes the event object, and automatically generates the corresponding database upgrade script file 141 and upgrade patch code file 142 according to the changes. The system will automatically generate the following in the database upgrade script file: Update script: Used to change the database table field name from fullName to staffName; Update script: Used to change the database field length from 150 to 255; Rollback script: Used to restore the field name to fullName; Rollback script: Used to restore the field length to 150; At the same time, the system will generate the following in the upgrade patch file: Upgrade code: Used to modify the field definitions of application property objects to adapt to the updated fields in the database; Rollback code: Used to restore the original definition of the changed value of the property object, thereby ensuring the consistency between application logic and database state.

[0030] In addition, for data that needs to be deleted, a backup should be made during the update process to facilitate restoration during rollback. After a successful update, the backup data is cleaned up during the transaction commit phase.

[0031] Through the above mechanism, this invention realizes the generation of event-driven automated upgrade and rollback scripts in a low-code platform, which not only reduces the workload of manually writing scripts, but also ensures the consistency and traceability of database structure and application logic during the iteration process.

[0032] Figure 4 The following is a flowchart of the global consistency upgrade process of the present invention, as shown in the figure: In a production environment, the application upgrade transaction coordination service 180 is responsible for coordinating the execution of upgrade transactions according to the dependency order between different services in a microservice application architecture scenario, recording the application version information of the last upgrade, and ensuring the consistency and atomicity of cross-service upgrades.

[0033] When the application service starts, the upgrade engine 170 first requests the application version information of the last upgrade from the cross-service upgrade transaction coordination service 180 and compares it with the application version of this service. If they match, the upgrade continues. If the version of this service is too low, an exception is reported and the log is printed to terminate the operation. If the version of this service is too high, it attempts to acquire a global upgrade mutex lock in the current application cluster to ensure that only one application node in the current cluster is executing the upgrade task. After successfully acquiring the lock, the upgrade engine 170 scans all database upgrade script files 141 and upgrade patch code files 142 within the application package. Simultaneously, it submits the current version number to request the cross-service upgrade transaction coordination service 180 to initiate or join the global upgrade transaction. It also retrieves records of database upgrade script files 141 and upgrade patch code files 142 that have been successfully executed in previous upgrade processes from the cross-service upgrade transaction coordination service 180. Based on the globally unique serial number of the file, it compares and filters out database upgrade script files 141 and upgrade patch code files 142 that have not been executed in the current application service package. If there are no unexecuted database upgrade script files 141 and upgrade patch code files 142, it notifies the cross-service upgrade transaction coordination service 180 that the local upgrade transaction is complete and waits for the cross-service upgrade transaction coordination service 180 to notify that the global upgrade transaction is complete before continuing to start the application. If there are unexecuted database upgrade script file 141 and upgrade patch code file 142, the upgrade engine 170 will wait for the cross-service upgrade transaction coordinator 180 to issue an execution notification before executing the database upgrade script file 141 and upgrade patch code file 142 in the order of the globally unique sequence number. If an exception occurs, the execution will be rolled back in reverse order, and then the cross-service upgrade transaction coordinator 180 will be notified of the upgrade failure, terminating the application execution. If all files are executed successfully, the upgrade engine 170 will submit a list of files that were successfully executed in this upgrade to the cross-service upgrade transaction coordinator 180 and notify the cross-service upgrade transaction coordinator 180 that the upgrade is complete. Then, it will wait for the cross-service upgrade transaction coordinator 180 to notify that the global upgrade transaction has ended before performing the final cleanup task and restarting the application.

[0034] Upon receiving the first service's transaction request, the cross-service upgrade transaction coordination service 180 establishes a global upgrade transaction context, maintains the transaction state of each service, and waits for all services within the application to join the global upgrade transaction. Then, it sends upgrade execution instructions to all services, and the upgrade engines 170 within each service begin executing the upgrade files. After all services have completed their upgrades, the cross-service upgrade transaction coordination service 180 sends a notification to end the global upgrade transaction. Each service performs cleanup tasks and resumes its process. If any service upgrade fails, the cross-service upgrade transaction coordination service 180 sends a global upgrade transaction rollback notification, and each service begins executing rollback tasks to restore its initial state.

Claims

1. A low-code enterprise application automated iterative upgrade device, characterized in that: This includes modules for low-code application visual modeling and development tools, modeling event auditing services, event data repositories, code generation tools, database upgrade script files, upgrade patch code files, code version control tools based on existing mature open-source products, application integration, build and deployment tools based on existing mature open-source products, upgrade engine modules, and upgrade transaction coordination services. The Low-Code Application Visual Modeling Development Tool Module provides developers with a visual modeling environment and allows them to submit event data for modeling operations. The modeling event auditing service module is used to receive and record the event data and save the recorded incremental event data to the event data repository; The event data repository is used to store incremental event stream data provided by the modeling event auditing service module; The code generation tool module is used to load incremental event stream data from the event data repository and generate database upgrade scripts and upgrade patch code based on the event stream data; The database upgrade script file module is used to store the database upgrade scripts generated by the code generation tool module; The upgrade patch code file module is used to store the upgrade patch code generated by the code generation tool module; The code version control tool module uses existing technology products to maintain the version history of the application project and supports pulling and submitting the latest code; The application integration build and deployment tool module uses existing technology products to pull the latest code version of the code version control tool module, build and generate various service packages of the application, deploy them to the production environment, execute the application startup command, and trigger the upgrade process of each microservice; The upgrade engine module is deployed in each application service package in the production environment. It is used to identify the current application version when the service starts and to perform upgrade operations according to the database upgrade script file and upgrade patch code file. The upgrade transaction coordination service module is used to register upgrade transactions, coordinate and ensure the consistency of upgrades for multiple application services, and trigger rollback when the upgrade fails.

2. A method for automated iterative upgrades of low-code enterprise applications, characterized in that: This method employs the low-code enterprise application automated iterative upgrade device described in claim 1, and includes the following steps: (1) Collect and store modeling event flow data in the visualization low-code development process; (2) Generate database upgrade script files and upgrade patch code files based on the incremental data of the modeling event stream; (3) Merge the generated script files and patch code files with other code in the application project and submit them to the version control system; (4) Build the various service packages of the application and deploy them to the production environment; (5) When starting each application service in the production environment, perform a global consistency upgrade or rollback on the low-code application.

3. The method for automated iterative upgrades of low-code enterprise applications according to claim 2, characterized in that: The event stream data exists in the form of an event sequence and is used to record various operations in the visual low-code modeling development process. It supports the precise replay or rollback of metadata changes of any granularity by upgrade scripts and patch code.

4. The method for automated iterative upgrades of low-code enterprise applications according to claim 2, characterized in that: The code generation tool generates database upgrade scripts that are compatible with the format of common database version management tools, enabling portable upgrades across database platforms.

5. The method for automated iterative upgrades of low-code enterprise applications according to claim 2, characterized in that: The upgrade patch code is rendered in reverse through event data into user operation instructions that can be re-executed in the production environment, which is used to automatically restore or complete application configuration and metadata without human intervention.

6. The method for automated iterative upgrades of low-code enterprise applications according to claim 2, characterized in that: In the database script file and patch code file, design and develop operation event data for each user, and generate the corresponding reverse rollback operation code.

7. The method for automated iterative upgrades of low-code enterprise applications according to claim 6, characterized in that: When an error or exception occurs during the upgrade process, the rollback mechanism is triggered to execute rollback operation code, which will revert the application database to its state before the upgrade.

8. The method for automated iterative upgrade of low-code enterprise applications according to claim 2, characterized in that: Before performing an upgrade in the production environment, the current version number and the version number to be upgraded are compared, and a decision is made on whether to continue the upgrade operation based on the comparison results.

9. The method for automated iterative upgrade of low-code enterprise applications according to claim 2, characterized in that: Based on the file execution record, only database upgrade script files and patch code files that have not been executed before are executed, and they are executed in the order of the globally unique serial number of the files. After the upgrade is successful, the newly executed files are added to the file execution record for saving.

10. The method for automated iterative upgrade of low-code enterprise applications according to claim 2, characterized in that: Before performing an upgrade, the service cluster first competes for a global upgrade lock to prevent multiple service instances from upgrading in parallel, which could lead to upgrade failure.

Images