Assembly line automatic patch making method and system based on low-code SDK (Software Development Kit)

Abstract

The invention relates to the technical field of low-code application development and continuous integration / continuous deployment, and provides an assembly line automatic patch making method and system based on a low-code SDK (Software Development Kit). The method comprises the steps that an SDK tool is adopted, a specified project is compiled, and a metadata file is obtained; compiling the metadata file under the specified project, and packaging to generate a corresponding metadata packet; extracting a deliverable in the metadata packet; generating a pom file according to maven dependency in a specified project; pushing the pom file, the metadata packet and the jar packet in the deliverable to a specified product warehouse according to the version number of the specified project; and obtaining changes of the configuration files of the two version branches through the assembly line, pulling the products of the corresponding versions from the product warehouse, packaging the pulled products according to the path structure, and generating an incremental patch file. According to the invention, the working efficiency is obviously improved, and the possibility of human errors is reduced.

Description

Technical Field

[0001] The present invention relates to the technical field of low-code application development and continuous integration / continuous deployment (CI / CD), and particularly relates to a method and system for automatically generating patches for a pipeline based on a low-code SDK. Background Art

[0002] The statements in this part only provide background technical information related to the present invention and do not necessarily constitute prior art.

[0003] With the development of low-code platforms, the demand for rapid iteration and efficient patch release is increasing. However, most of the existing solutions focus on the automation of single links in the front end or back end, and there are still significant gaps in the full-process automation. At the same time, there is no solution for the dependency relationships between multiple low-code projects, resulting in only single-project compilation and push.

[0004] The existing technical defects are mainly manifested as excessive manual operations and low automation levels, resulting in low efficiency and unstable quality. The root cause of these problems lies in the lack of a complete set of automated toolchains to cover all links from code changes to patch release.

[0005] Although some automation functions are provided in the current market, they still have deficiencies in terms of flexibility and adaptability, especially in multi-repository dependency management and multi-module dependencies of low-code projects. Moreover, the existing solutions do not solve the key technical problems unique to low-code platforms, such as mixed compilation of metadata and source code, multi-dimensional artifact dependency relationship management, and automated version alignment. Summary of the Invention

[0006] To solve the technical problems existing in the above background art, the present invention provides a method and system for automatically generating patches for a pipeline based on a low-code SDK. The present invention has developed an SDK (Software Development Kit) tool designed for low-code applications. This SDK tool can be used to provide capabilities such as low-code application compilation, packaging, extraction, and pushing metadata artifacts during the pipeline CI process; through version difference analysis and pipeline automation, efficient generation and deployment of low-code application patches are achieved.

[0007] To achieve the above object, the present invention adopts the following technical solutions: The first aspect of the present invention provides a method for automatically generating patches for a pipeline based on a low-code SDK.

[0008] A method for automatically generating patches for a pipeline based on a low-code SDK includes: Map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, and judge the type of the incoming path. If it is a project path, execute the command operation on a single project; if it is a business object path, according to the dependency relationship between projects, sort all projects under the business object in the order of execution, so as to execute the command operation according to the sort. Use the SDK tool to compile the specified project to obtain a metadata file; compile the metadata file under the specified project and package it to generate a corresponding metadata package; extract the deliverables from the metadata package; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project. Obtain the changes of the configuration files of two version branches through the pipeline, so as to pull the corresponding version of the artifacts from the artifact repository, and package the pulled artifacts according to the path structure to generate an incremental patch file.

[0009] Further, the method of using the SDK tool to compile the specified project to obtain a metadata file includes: using the SDK tool to obtain the specified project, assembling the metadata header node information according to the basic information of the project, so as to obtain the SU information from the gspproject.json file and the project inter-dependency relationship from the mdproj file; assembling the manifest file according to the SU information and the project inter-dependency relationship; and scanning the metadata folder under the specified project directory to obtain all the metadata files of the project.

[0010] Further, the method of compiling the metadata file under the specified project and packaging it to generate a corresponding metadata package includes: calling the local Maven through the MavenInvoker to parse the pom file to obtain module information; verifying whether the project structure is correct, obtaining the project inter-dependency relationship, compiling the code in the order of project inter-dependency, and packaging it to generate a corresponding metadata package.

[0011] Further, the method of generating a pom file according to the maven dependencies in the specified project includes: obtaining the maven dependencies of the project in the mdproj file, excluding the project dependencies, and generating a pom file according to the remaining maven dependencies.

[0012] Further, push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project; the method includes: selecting a code branch, running a pipeline, and injecting the parameter PUBLISH_VERSION to specify the version number released by the specified project; the pipeline automatically compiles and packages the project to generate jar packages, metadata packages, and npm packages, and pushes them to the target artifact repository, where the metadata package is pushed to the artifact repository in the form of a zip package.

[0013] Further, the SDK tool runs independently and is integrated into the CI / CD toolchain. There is a low-code project CI template in the CI / CD toolchain, and the pipeline scripts of each low-code project repository directly reference the low-code project CI template.

[0014] Further, obtain the changes to the configuration files of two version branches through the pipeline; the method includes: submitting all configuration modifications to the repository and selecting the corresponding patch version branch to run the pipeline; when running the pipeline, according to the input private key, whether to generate a patch, the old version branch, and the new version branch, obtain the content of the two branches, and automatically compare the changes to the configuration files of the two version branches.

[0015] The second aspect of the present invention provides a pipeline automation patch-making system based on a low-code SDK.

[0016] A pipeline automation patch-making system based on a low-code SDK includes: A command parsing and dependency relationship recognition module, which is configured to: map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, judge the type of the incoming path, if it is a project path, execute the command operation on a single project; if it is a business object path, according to the dependency relationship between projects, sort the execution order of all projects under the business object, and execute the command operation according to the sorting. A primary pipeline module, which is configured to: use the SDK tool to compile the specified project to obtain metadata files; compile the metadata files under the specified project, package them to generate corresponding metadata packages; extract the deliverables from the metadata packages; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project. A secondary pipeline module, which is configured to obtain the changes to the configuration files of two version branches through the pipeline, pull the corresponding version of the artifacts from the artifact repository, package the pulled artifacts according to the path structure, and generate an incremental patch file.

[0017] A third aspect of the present invention provides a computer device, which includes: a processor adapted to execute a computer program; a computer-readable storage medium having stored therein a computer program, which when executed by the processor, implements the steps in the method for automatically making patches in a pipeline based on a low-code SDK as described in the first aspect above.

[0018] A fourth aspect of the present invention provides a computer-readable storage medium having stored therein a computer program, which is adapted to be loaded and executed by a processor to implement the steps in the method for automatically making patches in a pipeline based on a low-code SDK as described in the first aspect above.

[0019] Compared with the prior art, the beneficial effects of the present invention are as follows: The present invention provides a method and system for automatically making patches in a pipeline based on a low-code SDK. The method includes: mapping the obtained input command to a CLI command; based on the CLI command, using an SDK tool to determine the incoming path of the CLI command, and judging the type of the incoming path. If it is a project path, execute command operations on a single project; if it is a business object path, according to the dependency relationship between projects, perform a sorting of the execution sequence for all projects under the business object, so as to execute command operations according to the sorting; using the SDK tool to compile a specified project to obtain a metadata file; compiling the metadata file under the specified project and packaging it to generate a corresponding metadata package; extracting the deliverables in the metadata package; generating a pom file according to the maven dependencies in the specified project; pushing the pom file, the metadata package, and the jar packages in the deliverables to a specified artifact repository according to the version number of the specified project; obtaining the changes in the configuration files of two version branches through a pipeline, pulling the corresponding version of the artifacts from the artifact repository, and packaging the pulled artifacts according to the path structure to generate an incremental patch file. The present invention adopts the method of a low-code SDK tool and a pipeline, and executes low-code SDK tool commands through predefined templates and scripts, automatically completing the whole process from code submission to artifact release, solving the problems of low efficiency and easy errors in traditional manual patch making, significantly improving work efficiency, and reducing the possibility of human errors. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] The specification drawings forming a part of the present invention are used to provide a further understanding of the present invention. The schematic embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute an improper limitation to the present invention.

[0021] Figure 1 is a flowchart of the method for automatically making patches in a pipeline based on a low-code SDK shown in an embodiment of the present invention; Figure 2 It is a flowchart of another embodiment of the method for automatically generating patches based on the low-code SDK shown in the embodiments of the present invention; Figure 3 It is a flowchart of patch generation shown in the embodiments of the present invention; Figure 4 It is a schematic diagram of the dependency relationship shown in the embodiments of the present invention; Figure 5 It is a schematic diagram of the SDK tool architecture shown in the embodiments of the present invention; Figure 6 It is a flowchart of patch generation shown in the embodiments of the present invention; Figure 7 It is a structural diagram of the system for automatically generating patches based on the low-code SDK shown in the embodiments of the present invention; Figure 8 It is a structural diagram of the computer device shown in the embodiments of the present invention. Detailed implementation manners

[0022] The present invention will be further described below in conjunction with the drawings and embodiments.

[0023] It should be noted that the following detailed descriptions are all illustrative and are intended to provide further descriptions of the present invention. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by those of ordinary skill in the technical field to which the present invention belongs.

[0024] It should be noted that the terms used herein are only for describing specific implementation manners and are not intended to limit the exemplary embodiments according to the present invention. As used herein, unless the context clearly indicates otherwise, the singular form is also intended to include the plural form. In addition, it should be understood that when the terms "comprising" and / or "including" are used in this specification, they indicate the presence of features, steps, operations, devices, components, and / or combinations thereof.

[0025] As introduced in the background art, the low-code development platform simplifies and accelerates the application development process. With the popularization of DevOps practices, continuous integration (CI) and continuous deployment (CD) have become an indispensable part of the modern software development life cycle. The traditional CI / CD pipeline mainly focuses on the automation process of native development. In order to enable the low-code platform to better adapt to the modern software delivery mode, it is necessary to develop tools and plugins corresponding to low-code applications so that they can be seamlessly embedded into the existing CI / CD environment, which can further unleash the potential of the low-code platform and help enterprises maintain a leading position in the fierce market competition.

[0026] However, currently in low-code platforms, the generation of patches relies on manual operations, manual version comparison, and file collection, including steps such as modifying configuration files, compiling projects, and packaging metadata. These processes are not only time-consuming but also error-prone. Moreover, the manual process is inefficient and prone to problems such as version control chaos and omission of key files, which affect the quality and release speed of patches. Low-code projects often involve multiple artifact repositories (such as Maven, NPM), and existing solutions cannot flexibly handle multi-repository dependencies. Existing solutions also cannot efficiently handle multi-project dependency relationships and mixed compilation (metadata and source code). These problems are due to the lack of a unified and automated tool to manage and optimize the entire patch-making process and the lack of a unified standardized process for metadata compilation and artifact pushing, which makes developers spend a lot of time and effort to ensure that each step is correctly executed.

[0027] To solve the above problems, the present invention provides a method and system for automatically making patches in a pipeline based on a low-code SDK. The technical solutions of the present invention will be described in detail through several embodiments as follows: Figure 1 is a flowchart of a method for automatically making patches in a pipeline based on a low-code SDK shown in an embodiment of the present invention; referring to Figure 1 , the method includes: Map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, and judge the type of the incoming path. If it is a project path, execute command operations on a single project; if it is a business object path, according to the dependency relationship between projects, perform a sorting of the execution sequence for all projects under the business object, so as to execute command operations according to the sorting. Use the SDK tool to compile the specified project to obtain metadata files; compile the metadata files under the specified project, package them to generate corresponding metadata packages; extract the deliverables from the metadata packages; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project. Obtain the changes of the configuration files of two version branches through the pipeline, so as to pull the corresponding version of the artifacts from the artifact repository, package the pulled artifacts according to the path structure, and generate an incremental patch file.

[0028] The present invention adopts the method of a low-code SDK tool and a pipeline, and executes low-code SDK tool commands through predefined templates and scripts to automatically complete the whole process from code submission to artifact release, reducing manual intervention.

[0029] Figure 2 is a flowchart of another embodiment of a method for automatically making patches in a pipeline based on a low-code SDK shown in an embodiment of the present invention; referring toFigure 2 , the present invention adopts the UBML SDK toolchain and a two-stage pipeline architecture: In the development stage, developers submit the metadata, source code, configuration data, etc. in the low-code application to the gitlab repository of the code hosting platform.

[0030] Among them, the two-stage pipeline architecture is specifically as follows: The first-stage pipeline: The "UBML SDK" tool is mainly responsible for the compilation, packaging, extraction, and pushing operations of the low-code project, and pushes the compiled artifacts to the artifact repository in the form of version management. The second-stage pipeline: By making a patch plugin, comparing branch differences, pulling artifacts, and making incremental patches. The low-code SDK tool completes the front-end and back-end compilation, packaging, and pushing of the low-code project, realizing the automatic conversion from source code to artifacts.

[0031] In this embodiment, the low-code SDK tool is specifically: Based on the Spring Shell framework, a low-code project command-line tool is developed, which can run independently and be integrated into the existing CI / CD toolchain to complete tasks such as compilation, packaging, extraction, and pushing of the low-code project.

[0032] In the process of implementing the first-stage pipeline, the command for the compilation operation can be igix build metadata_project, using the build instruction to compile the specified metadata project and generate the corresponding resource metadata and multilingual metadata.

[0033] In some embodiments, the command for the compilation operation can also be igix packmd metadata_project, using the packmd instruction to compile the metadata under the specified project and package it to generate the corresponding metadata package.

[0034] In this embodiment, in the process of implementing the first-stage pipeline, the command for the packaging operation can be igix compilemetadata_project maven_path, using the compile instruction, adopting the specified maven configuration file to compile the generated code project and package it to generate the corresponding jar package.

[0035] In this embodiment, in the process of implementing the first-stage pipeline, the command for the extraction operation can be igix extractmetadata_project, using the extract instruction to extract the files after compilation and packaging, including jar packages, js scripts, metadata packages, resource metadata files, dbo, etc.

[0036] In this embodiment, during the implementation of the first-level pipeline, the command for the push operation can be igix pushmetadata_project repoId maven_path mdpkg_version. Using the push instruction, the metadata package and the corresponding jar package are pushed to the selected remote repository according to the version number of the current code project.

[0037] For the above compilation, packaging, extraction, and push commands, when passing the low-code project path, the operations of compilation, packaging, extraction, and push are performed on a single path. When there are multiple projects under a business object and the business object path is passed, the dependency relationships between the multiple projects under the business object will be recognized, and the command execution order will be sorted out according to the dependency relationships. The projects will be compiled, packaged, extracted, and pushed in sequence.

[0038] The implementation process of the pipeline automation patching method based on the low-code SDK in this embodiment may include: (1) Command parsing: The SDK tool uses the @ShellMethod annotation to define commands, parameters, and options, and automatically maps them to CLI commands that can be executed in the terminal. Each command method is defined using the @ShellMethod annotation, and each method is registered as an available CLI command. When the user enters a command in the terminal, the input is parsed and the corresponding method is matched.

[0039] (2) Dependency relationship recognition: Figure 3 is the flowchart of patch generation shown in the embodiment of the present invention; refer to Figure 3 , the SDK tool will recognize the path passed in the command and determine whether it is a project path. If it is a project path, operations will be performed on a single project, but if it is a business object path, all project paths under the business object will be obtained, and all project dependencies will be traversed and obtained according to the mdproj file. The directed graph is used to represent the inter-project dependency relationships, and the execution order is sorted out according to the dependency relationships, and the command operations are executed in sequence.

[0040] Figure 4 is the schematic diagram of the dependency relationship shown in the embodiment of the present invention; refer to Figure 4 , the constructed directed graph includes projects A, B, C, D, and E, and the dependency relationships are as shown in the figure.

[0041] The SDK tool realizes the automatic parsing of project dependency relationships through directed graph modeling, and compiles the low-code projects in the order of the dependency relationships, realizing automatic parsing and optimization of the command execution order.

[0042] (3) Compile metadata: The SDK tool obtains the low-code project object, assembles the metadata header node information according to the basic information of the project such as name and version, reads the SU information from the gspproject.json file, obtains the project dependencies from the mdproj file, etc., and assembles the manifest file based on this information. Then, it scans the metadata folder under the project directory, obtains all metadata files under the project, and packs and compresses them into an mdpkg file.

[0043] (4) Compile the code project: The SDK tool calls the local Maven through the MavenInvoker, parses the pom file to obtain module information, then verifies whether the project structure is correct, obtains the dependencies, compiles the code in the order of dependencies, and generates a jar package and stores it in the target directory.

[0044] (5) Extract deliverables: The SDK tool traverses the generation paths of various deliverables, obtains all generated deliverables, and copies the deliverables to the corresponding publish directory.

[0045] (6) Push artifacts: The SDK tool first obtains the maven dependencies of the project in the mdproj file, and also needs to exclude the project dependencies. It generates a pom file based on the remaining maven dependencies, prepares the artifacts to be pushed, and uses the Maven Deploy plugin to push the pom file, the corresponding jar package, and the metadata package to the corresponding artifact repository.

[0046] Figure 5 is a schematic diagram of the SDK tool architecture shown in the embodiments of the present invention; referring to Figure 5 , the SDK tool includes a presentation layer, a service layer, a model layer, and a document library. Among them, the presentation layer includes WebIDE, a metadata compiler, and a low-code project tool. The service layer includes Restful API and Spring Shell. The model layer includes various metadata implementation elements and a metadata framework. The various metadata implementation elements include: From SPI extension, Form serializer, BE event, VO SPI extension, BESPI extension, BE serializer, VO event, etc. The metadata framework includes: metadata CRUD, serialization / deserialization, metadata event, metadata SPI, metadata compilation, project packaging, reference management, etc. The document library includes a metadata library, a business entity library, examples, and documents.

[0047] In this embodiment, the SDK tool runs independently and is integrated into the existing CI / CD toolchain. A low-code project CI template is provided in the CI / CD toolchain, and the low-code project CI template includes: ① providing a low-code application CI script, and based on the pipeline job extension mechanism, presetting the low-code application project CI template to reduce duplicate configurations and maintain simplicity and maintainability; ② the low-code application project can quickly configure the pipeline in the form of an extended template to complete the compilation, packaging, pushing, etc. of metadata. ③ uploading the low-code project compilation pipeline template to a public location, such as an artifact repository. The pipeline scripts of each low-code project repository can directly reference these template files. If the process changes later, only the template files need to be modified to ensure the consistency and maintainability of the configuration.

[0048] In this embodiment, executing the low-code project CI pipeline according to the low-code project CI template includes: inputting the low-code project CI template file and defining global variables; pushing the official repositories of the jar package and the metadata package; pushing the snapshots of the jar package and the metadata package; building the backend project; integrating the backend project compilation template in the template file; and the variable is the path of the backend project in the repository.

[0049] Specifically, after uploading the code to the repository, select the code branch, run the pipeline, and inject the parameter PUBLISH_VERSION to specify the version to be released; the pipeline will automatically compile and package the project, generate the jar package, the metadata package, and the npm package, and push them to the target repository, where the metadata package is pushed to the artifact repository in the form of a zip package.

[0050] Various artifacts, such as metadata packages, jar packages, npm packages, etc., have their own version management mechanisms, and multi-dimensional version control is achieved through configuration files such as pom.xml / web.yaml. The present invention supports various types of artifact repositories, such as maven repositories and npm repositories, and artifacts can be pulled from multiple different artifact repositories when pulling artifacts. Thus, the deliverables of multiple repositories and multiple projects can be made into patches, and generating patches is more flexible.

[0051] In this embodiment, the multi-dimensional version of the artifact includes: pom.xml file and web.yaml file.

[0052] Among them, the pom.xml file: maintains its own component list, and the version number requirement is <properties / >As defined, this part mainly maintains the own Jar packages and metadata lists of each module, as well as the version information of the artifacts. These artifacts can come from different artifact repositories and can also be the artifact products compiled and packaged from different source code repositories through the pipeline. web.yaml file: The web.yaml is mainly used to identify the npm packages to be placed in the front end, including the name, repository address, version information, and target path.

[0053] In this embodiment, the patch configuration file includes the patch.xml file and the CHANGELOG.yaml.

[0054] Among them, patch.xml file: In the patch.xml file, the list of artifacts included in the patch and the storage paths of each jar package, metadata package, and preset file in the patch are clearly specified. CHANGELOG.yaml: In the CHANGELOG.yaml file, patch information needs to be added, such as the patch name, number, etc. The pipeline will make patches according to the latest patch information in the file.

[0055] Figure 6 is the flowchart of patch generation shown in the embodiment of the present invention; refer to Figure 6 , the patch-making pipeline includes: submitting all configuration modifications to the repository and selecting the corresponding patch version branch to run the pipeline. When running the pipeline, the following parameters need to be input. The pipeline will obtain the contents of the two branches, automatically compare the changes in the configuration files of the two version branches, and pull the corresponding version artifacts from the artifact repository according to these changes. The pulled artifacts will be packaged according to the path structure defined in patch.xml to generate an incremental patch file. Modifying the artifact version in the patch version branch can align the artifact version with the patch version. The present invention has the ability to automatically identify patch requirements and can automatically generate incremental patch files according to different code branches.

[0056] Specifically, the input parameters include: GIT_SSH_PRIVATE_KEY: The Git private key used to access the repository.

[0057] ENABLE_CAF_PATCH_GENERATION: Whether to generate a patch, set to true.

[0058] CAF_GEN_PATCH_OLD_REF: The old version branch.

[0059] CAF_GEN_PATCH_NEW_REF: The new version branch.

[0060] The above combination Figure 1A detailed introduction to the method for automatically generating patches for pipelines based on the low-code SDK provided by the embodiments of the present invention is given. Next, the system for automatically generating patches for pipelines based on the low-code SDK provided by the embodiments of the present invention will be introduced with reference to the accompanying drawings.

[0061] Figure 7 FIG. is a schematic structural diagram of a system for automatically generating patches for pipelines based on the low-code SDK shown in the embodiments of the present invention. Referring to Figure 7 , the system of the present invention includes: A command parsing and dependency relationship recognition module, which is configured to: map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, judge the type of the incoming path, if it is a project path, execute the command operation on a single project; if it is a business object path, according to the dependency relationship between projects, sort the execution order of all projects under the business object, so as to execute the command operation according to the sort order. A primary pipeline module, which is configured to: use the SDK tool to compile a specified project to obtain a metadata file; compile the metadata file under the specified project and package it to generate a corresponding metadata package; extract the deliverables from the metadata package; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to a specified artifact repository according to the version number of the specified project. A secondary pipeline module, which is configured to: obtain the changes of the configuration files of two version branches through the pipeline, pull the corresponding version of the artifacts from the artifact repository, and package the pulled artifacts according to the path structure to generate an incremental patch file.

[0062] In some embodiments, the primary pipeline module is specifically configured to: use the SDK tool to obtain a specified project, assemble the metadata header node information according to the basic information of the project, so as to obtain the SU information from the gspproject.json file and the dependency relationship between projects from the mdproj file; assemble the manifest file according to the SU information and the dependency relationship between projects; and scan the metadata folder under the specified project directory to obtain all the metadata files of the project.

[0063] In some embodiments, the primary pipeline module is further specifically configured to: call the local Maven through the MavenInvoker, parse the pom file to obtain the module information; verify whether the project structure is correct, obtain the dependency relationship between projects, and compile the code in the order of project dependencies to package and generate a corresponding metadata package.

[0064] In some embodiments, the first-level pipeline module is further specifically configured to: obtain the maven dependencies of the project in the mdproj file, exclude the project dependencies, and generate a pom file based on the remaining maven dependencies.

[0065] In some embodiments, the first-level pipeline module is further specifically configured to: select a code branch, run the pipeline, and inject the parameter PUBLISH_VERSION to specify the version number of the specified project release; the pipeline automatically compiles and packages the project to generate a jar package, a metadata package, and an npm package, and pushes them to the target artifact repository, where the metadata package is pushed to the artifact repository in the form of a zip package.

[0066] In some embodiments, the SDK tool runs independently and is integrated into the CI / CD tool chain. A low-code project CI template is provided in the CI / CD tool chain, and the pipeline scripts of each low-code project repository directly reference the low-code project CI template.

[0067] In some embodiments, the second-level pipeline module is specifically configured to: submit all configuration modifications to the repository and select the corresponding patch version branch to run the pipeline; when running the pipeline, according to the input private key, whether to generate a patch, the old version branch, and the new version branch, obtain the content of the two branches, and automatically compare the changes in the configuration files of the two version branches.

[0068] According to the embodiment of the present invention, the pipeline automation patch-making system based on the low-code SDK can correspond to executing the method described in the embodiment of the present invention, and the above and other operations and / or functions of each module of the pipeline automation patch-making system based on the low-code SDK are respectively for implementing Figure 1 the corresponding processes of each method in, and for the sake of brevity, will not be described in detail here.

[0069] See Figure 8 the structural diagram of the computer device shown. The computer device includes a processor, a communication interface, and a computer-readable storage medium. Among them, the processor, the communication interface, and the computer-readable storage medium can be connected through a bus or other means. Among them, the communication interface is used to receive and send data. The computer-readable storage medium can be stored in the memory of the computer device. The computer-readable storage medium is used to store a computer program. The computer program includes program instructions, and the processor is used to execute the program instructions stored in the computer-readable storage medium. The processor (or CPU (Central Processing Unit, central processor)) is the computing core and control core of the computer device, and is adapted to implement one or more instructions. Specifically, it is adapted to load and execute one or more instructions to implement the corresponding steps in the embodiment of the pipeline automation patch-making method based on the low-code SDK.

[0070] This embodiment provides a computer-readable storage medium (Memory). A computer-readable storage medium is a memory device in a computer device and is used to store programs and data. It can be understood that the computer-readable storage medium here can include both the built-in storage medium in the computer device and, of course, the extended storage medium supported by the computer device. The computer-readable storage medium provides a storage space, and this storage space stores the processing system of the computer device. Moreover, one or more instructions suitable for being loaded and executed by a processor are also stored in this storage space. These instructions can be one or more computer programs (including program codes). It should be noted that the computer-readable storage medium here can be a high-speed RAM memory or a non-volatile memory, such as at least one disk memory; optionally, it can also be at least one computer-readable storage medium located far from the aforementioned processor.

[0071] In one embodiment, one or more instructions are stored in the computer-readable storage medium; the processor loads and executes one or more instructions stored in the computer-readable storage medium to implement the corresponding steps in the above-mentioned embodiment of the method for automatically making patches based on the low-code SDK pipeline.

[0072] Those skilled in the art should understand that the embodiments of the present invention can be provided as a method, a system, or a computer program product. Therefore, the present invention can take the form of a hardware embodiment, a software embodiment, or an embodiment combining software and hardware aspects. Moreover, the present invention can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk memories and optical memories, etc.) containing computer-usable program codes.

[0073] The present invention is described with reference to the flowcharts and / or block diagrams of methods, apparatuses (systems), and computer program products according to the embodiments of the present invention. It should be understood that each flow and / or block in the flowchart and / or block diagram can be implemented by computer program instructions, and the combination of the flows and / or blocks in the flowchart and / or block diagram can also be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing devices generate means for implementing the functions specified in one Figure 1 one flow or multiple flows and / or blocks Figure 1 one block or multiple blocks.

[0074] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to work in a specific manner, such that the instructions stored in the computer-readable memory produce a manufacture including an instruction device that implements the functions specified in one process Figure 1 one process or multiple processes and / or blocks Figure 1 specified in one block or multiple blocks.

[0075] These computer program instructions can also be loaded onto a computer or other programmable data processing device, such that a series of operational steps are performed on the computer or other programmable device to produce a computer-implemented process, and thus the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in one process Figure 1 one process or multiple processes and / or blocks Figure 1 specified in one block or multiple blocks.

[0076] Those of ordinary skill in the art can understand that all or part of the processes of implementing the methods in the above embodiments can be completed by instructing relevant hardware through a computer program. The said program can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above methods. Among them, the said storage medium can be a magnetic disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM), etc.

[0077] The above are only the preferred embodiments of the present invention and are not intended to limit the present invention. For those skilled in the art, the present invention can have various changes and modifications. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included within the protection scope of the present invention.

Claims

1. A method for automatically making patches for a pipeline based on a low-code SDK, characterized in that, Including: Map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, and judge the type of the incoming path. If it is a project path, execute command operations on a single project; If it is a business object path, according to the dependency relationship between projects, sort all projects under the business object in the order of execution, so as to execute command operations in accordance with the sorting; Use the SDK tool to compile the specified project and obtain the metadata file; Compile the metadata file under the specified project and package it to generate the corresponding metadata package; Extract the deliverables from the metadata package; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project; Obtain the changes of the configuration files of two version branches through the pipeline, so as to pull the corresponding version of the artifacts from the artifact repository, and package the pulled artifacts according to the path structure to generate an incremental patch file.

2. The method for automatically making patches for a pipeline based on a low-code SDK according to claim 1, wherein The method of using the SDK tool to compile the specified project and obtain the metadata file includes: using the SDK tool to obtain the specified project, assembling the metadata header node information according to the basic information of the project, so as to obtain the SU information from the gspproject.json file and the project dependency relationship from the mdproj file; assembling the manifest file according to the SU information and the project dependency relationship; and scanning the metadata folder under the specified project directory to obtain all the metadata files of the project.

3. The method for automatically making patches for a pipeline based on a low-code SDK according to claim 1, wherein The method of compiling the metadata file under the specified project and packaging it to generate the corresponding metadata package includes: calling the local Maven through the MavenInvoker, parsing the pom file to obtain the module information; verifying whether the project structure is correct, and obtaining the project dependency relationship, compiling the code in the order of project dependencies, and packaging it to generate the corresponding metadata package.

4. The method for automatically making patches for a pipeline based on a low-code SDK according to claim 1, wherein The method of generating a pom file according to the maven dependencies in the specified project includes: obtaining the maven dependencies of the project in the mdproj file, excluding the project dependencies, and generating a pom file according to the remaining maven dependencies.

5. The method for automatically making patches for a pipeline based on a low-code SDK according to claim 1, wherein The method of pushing the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project includes: selecting the code branch, running the pipeline, and injecting the parameter PUBLISH_VERSION to specify the version number released by the specified project; the pipeline automatically compiles and packages the project to generate jar packages, metadata packages, and npm packages, and pushes them to the target artifact repository, where the metadata package is pushed to the artifact repository in the form of a zip package.

6. The method for automatically generating patches for a pipeline based on a low-code SDK according to claim 1, characterized in that The SDK tool runs independently and is integrated into the CI / CD tool chain. There is a low-code project CI template in the CI / CD tool chain, and the pipeline scripts of each low-code project repository directly reference the low-code project CI template.

7. The method for automatically making patches for a pipeline based on a low-code SDK according to claim 1, wherein, Obtaining the changes of the configuration files of two version branches through the pipeline; the method includes: submitting all configuration modifications to the repository and selecting the corresponding patch version branch to run the pipeline; when running the pipeline, according to the input private key, whether to generate a patch, the old version branch, and the new version branch, obtain the content of the two branches, and automatically compare the changes of the configuration files of the two version branches.

8. A pipeline automation patching system based on a low-code SDK, characterized in that, Including: A command parsing and dependency relationship recognition module, which is configured to: map the obtained input command to a CLI command; based on the CLI command, use the SDK tool to determine the incoming path of the CLI command, judge the type of the incoming path, and if it is a project path, execute the command operation on a single project; If it is a business object path, according to the dependency relationship between projects, sort the execution order of all projects under the business object, and execute the command operation according to the sort. A primary pipeline module, which is configured to: use the SDK tool to compile the specified project and obtain the metadata file; Compile the metadata file under the specified project and package it to generate the corresponding metadata package; Extract the deliverables from the metadata package; generate a pom file according to the maven dependencies in the specified project; push the pom file, the metadata package, and the jar packages in the deliverables to the specified artifact repository according to the version number of the specified project; A secondary pipeline module, which is configured to: obtain the changes of the configuration files of two version branches through the pipeline, pull the corresponding version of the artifacts from the artifact repository, and package the pulled artifacts according to the path structure to generate an incremental patch file.

9. A computer device, characterized in that a processor, suitable for executing a computer program; a computer-readable storage medium, in which a computer program is stored, and when the computer program is executed by the processor, the steps in the method for automatically making a patch based on a low-code SDK according to any one of claims 1-7 are implemented.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, and the computer program is suitable for being loaded and executed by the processor to perform the steps in the method for automatically making a patch based on a low-code SDK according to any one of claims 1-7.

Images