Configuration file generation method and equipment

Abstract

The invention relates to a configuration file generation method and equipment, and the method comprises the steps: obtaining a plurality of predefined nodes which represent deployment steps of a target application program respectively; and obtaining a dependency relationship among the plurality of nodes, and generating a configuration file for deploying the target application program based on the plurality of nodes and the dependency relationship. A configuration file for deploying a target application program can be generated based on a plurality of nodes and a dependency relationship by acquiring a plurality of predefined nodes and the dependency relationship among the plurality of nodes. Since the plurality of nodes respectively represent the deployment steps of the target application program, by obtaining the plurality of nodes of the target application program and the dependency relationship among the nodes, a user can more intuitively perform operation, and the generation efficiency of the configuration file can be improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a configuration file generation method and device. Background Art

[0002] With the popularity of cloud computing and microservice architecture, application deployment has become increasingly complex. In the software development and operation and maintenance process, application deployment often requires processing complex configuration files.

[0003] In related technologies, the deployment of applications usually relies on manually written configuration files, which requires users to master specific scripting languages ​​and grammatical rules. This is difficult for non-professionals, resulting in low configuration file generation efficiency in related technologies. Summary of the Invention

[0004] The present application provides a configuration file generation method and device.

[0005] According to a first aspect of the present application, a configuration file generation method is provided, the method comprising:

[0006] Acquire a plurality of predefined nodes, wherein the plurality of nodes respectively represent deployment steps of a target application;

[0007] Obtain dependency relationships between the multiple nodes, and generate a configuration file for deploying the target application based on the multiple nodes and the dependency relationships.

[0008] By obtaining multiple predefined nodes and the dependencies between them, a configuration file for deploying the target application can be generated based on the multiple nodes and the dependencies. Because the multiple nodes represent the deployment steps of the target application, obtaining the multiple nodes of the target application and the dependencies between them allows for more intuitive user operations, thereby improving the efficiency of generating the configuration file.

[0009] Optionally, the method further includes:

[0010] receiving a component selection operation from a user in a component library, and generating a plurality of nodes based on the component selection operation;

[0011] Configuration information input by a user for each node is received, and the multiple nodes are updated based on the configuration information to obtain the predefined multiple nodes.

[0012] The embodiment can generate multiple nodes by receiving user selection operations in the component library, and can update each node by receiving user input configuration operations for each node, so that the user can flexibly configure each node in a visual manner.

[0013] Optionally, obtaining the dependency relationship between the multiple nodes includes:

[0014] receiving a user's connection operation on the plurality of nodes displayed on the canvas;

[0015] Based on the connection operation, edge connections are performed on the multiple nodes; wherein the edge connections represent dependency relationships between the nodes.

[0016] By accepting user connections on the canvas, you can create edge connections between nodes. This allows you to intuitively reflect the dependencies between nodes and the execution order of the target application's deployment steps. Users can flexibly adjust edge connections between nodes, significantly improving the efficiency of configuration file generation.

[0017] Optionally, generating a configuration file for deploying the target application based on the multiple nodes and the dependency relationships includes:

[0018] Extracting node data corresponding to the plurality of nodes and edge data corresponding to the dependency relationships;

[0019] A configuration file is generated based on the node data and the edge data.

[0020] The embodiment extracts node data corresponding to multiple nodes and edge data corresponding to the dependency relationship, so that a configuration file can be generated based on the node data and edge data. By automatically generating the configuration file, the user's manual writing workload can be reduced, and the generated file can be ensured to meet the requirements of the target platform, thereby improving accuracy and consistency.

[0021] Optionally, extracting the node data corresponding to the plurality of nodes and the edge data corresponding to the dependency relationships includes:

[0022] Traversing the nodes displayed on the canvas;

[0023] Isolated nodes that do not meet preset conditions are removed from the nodes to obtain a target node, and node data corresponding to the target node and edge data corresponding to the dependency relationship between the target nodes are extracted.

[0024] The nodes in the memory can be traversed. Since the nodes represent the deployment steps of the target application, there needs to be an association relationship between the nodes. In this way, isolated nodes that have no edge connection relationship with other nodes can be removed, thereby improving the accuracy and effectiveness of the edge data.

[0025] Optionally, the node data includes: node identification, description and execution conditions.

[0026] Optionally, the edge data includes: a source node identifier, a target node identifier, and a dependency condition.

[0027] Optionally, the method further includes:

[0028] Receive attribute information set by the user for each node and each edge;

[0029] The nodes and the edges are displayed on a canvas based on the attribute information.

[0030] Node and edge attributes can be set, including but not limited to color, shape, and label, to better display information. These nodes and edges can be rendered into interactive workflow diagrams using relevant visualization engines. Interactive operations such as dragging nodes, modifying attributes, and dynamically adding or removing nodes and edges allow users to adjust and optimize workflows in real time.

[0031] Optionally, the method further includes:

[0032] Receive user adjustment operations on the nodes or the edges, and adjust the nodes or the edges based on the adjustment operations; wherein the adjustment operations include at least one of the following: node movement, attribute information modification, node addition, node deletion, edge addition and edge deletion.

[0033] Through user interaction design, data synchronization, extensibility, and visual feedback, the system provides intuitive interactions such as drag-and-drop component libraries, node parameter forms, and wire operations. It supports deleting nodes and edges, as well as undoing / redoing operations, to enhance the user experience. Furthermore, the node or edge state in the canvas can be synchronized with the in-memory data model in real time. Custom node or edge types support more complex scenarios, such as conditional branching or parallel steps. Instant feedback, such as highlighting and error prompts, is provided during user operations, improving the efficiency of configuration file generation.

[0034] According to a second aspect of the present application, a configuration file generating device is provided, the device comprising:

[0035] A node acquisition module, configured to acquire a plurality of predefined nodes, each of which represents a deployment step of a target application;

[0036] The configuration file generation module is used to obtain the dependency relationship between the multiple nodes and generate a configuration file for deploying the target application based on the multiple nodes and the dependency relationship.

[0037] According to a third aspect of the present application, an electronic device is provided, comprising: a memory and a processor, wherein a computer program is stored in the memory, and the processor implements the above method when executing the program.

[0038] According to a fourth aspect of the present application, a computer-readable storage medium is provided, on which a computer program is stored, and when the program is executed by a processor, the above-mentioned method of the present application is implemented.

[0039] According to a fifth aspect of the present application, a computer program product is provided, comprising a computer program, wherein the computer program implements the above method of the present application when executed by a processor. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] Further details, features and advantages of the present application are disclosed in the following description of exemplary embodiments in conjunction with the accompanying drawings, in which:

[0041] Figure 1 A flowchart of a configuration file generation method provided by an exemplary embodiment of the present application;

[0042] Figure 2 A flowchart of a configuration file generation method provided by another exemplary embodiment of the present application;

[0043] Figure 3 A schematic block diagram of functional modules of a configuration file generating device provided by an exemplary embodiment of the present application;

[0044] Figure 4 A structural block diagram of an electronic device provided by an exemplary embodiment of the present application;

[0045] Figure 5 A structural block diagram of a computer system provided for an exemplary embodiment of the present application. DETAILED DESCRIPTION

[0046] The following describes embodiments of the present application in more detail with reference to the accompanying drawings. Although certain embodiments of the present application are shown in the accompanying drawings, it should be understood that the present application can be implemented in various forms and should not be construed as limited to the embodiments described herein. Instead, these embodiments are provided to provide a more thorough and complete understanding of the present application. It should be understood that the drawings and embodiments of the present application are for illustrative purposes only and are not intended to limit the scope of protection of the present application.

[0047] It should be understood that the various steps described in the method embodiments of the present application can be performed in different orders and / or in parallel. In addition, the method embodiments may include additional steps and / or omit the steps shown. The scope of the present application is not limited in this respect.

[0048] The term "including" and its variations used in this document are open inclusions, that is, "including but not limited to". The term "based on" means "based at least in part on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one other embodiment"; the term "some embodiments" means "at least some embodiments". The relevant definitions of other terms will be given in the description below. It should be noted that the concepts of "first", "second", etc. mentioned in this application are only used to distinguish different devices, modules or units, and are not used to limit the order or interdependence of the functions performed by these devices, modules or units.

[0049] It should be noted that the modifications of "one" and "multiple" mentioned in this application are illustrative rather than restrictive. Those skilled in the art should understand that unless otherwise clearly indicated in the context, they should be understood as "one or more".

[0050] The names of the messages or information exchanged between multiple devices in the embodiments of the present application are only used for illustrative purposes and are not used to limit the scope of these messages or information.

[0051] It is understandable that before using the technical solutions disclosed in the embodiments of this application, the type, scope of use, usage scenarios, etc. of the personal information involved in this application should be informed to the user and the user's authorization should be obtained in an appropriate manner in accordance with relevant laws and regulations.

[0052] For example, in response to receiving a user's active request, a prompt message is sent to the user to clearly inform the user that the operation requested will require the acquisition and use of the user's personal information. Thus, based on the prompt message, the user can independently choose whether to provide personal information to the electronic device, application, server, storage medium, or other software or hardware that performs the operation of the technical solution of this application.

[0053] As an optional but non-limiting implementation method, in response to receiving the user's active request, the method of sending a prompt message to the user can be, for example, a pop-up window, and the pop-up window can present the prompt message in text form. In addition, the pop-up window can also carry a selection control for the user to choose "agree" or "disagree" to provide personal information to the electronic device. It is understandable that the above notification and user authorization process are only illustrative and do not constitute a limitation on the implementation method of this application. Other methods that meet relevant laws and regulations can also be applied to the implementation method of this application.

[0054] In order to improve the efficiency of generating configuration files, the embodiment of the present application can generate application configuration files based on the AntV G6 visualization engine, and display application components and their dependencies through a graphical interface. Users can operate intuitively to generate accurate and effective configuration files. Figure 1 As shown, Figure 1 The flowchart of the configuration file generation method provided in the embodiment of the present application may specifically include the following steps:

[0055] Step S11: Initialize the canvas and basic configuration.

[0056] In the embodiment, AntV G6 is a graph visualization engine that helps developers build their own graph analysis applications or graph editor applications by providing a series of elegantly designed and easy-to-use graph visualization solutions.

[0057] You can initialize the AntVG6 canvas, including canvas creation, layout, and interaction. Through canvas creation, you can create a G6 diagram instance on the page, configure the container and canvas size, and enable interactive features such as dragging nodes or scaling the canvas. Through layout selection, you can use automatic layout to automatically arrange nodes to ensure a clear process display. Through interactive mode, you can accept user operations such as dragging components and connecting lines to build processes, and also accept user operations such as panning and scaling the canvas.

[0058] Step S12: adding component library and nodes.

[0059] In an embodiment, each step involved in the installation process of the target application can be defined as a node, with each node containing information such as the step name, description, and execution conditions. For example, each node needs to correspond to a unique ID (identity document), type, label (such as "download file"), and user-entered parameters such as a file URL (uniform resource locator) or target path, etc., to implement node data binding.

[0060] In this embodiment, components for installation steps can be pre-populated in a page sidebar or toolbar, such as downloading files, decompressing files, and installing dependencies for the target application to be installed. Components can be added to the canvas by receiving user actions such as dragging or clicking, thereby implementing component library design. Each node corresponds to an installation step, and node types, such as rectangle or circle, style, and icon, can be defined to distinguish different functions corresponding to different nodes.

[0061] Step S13: node parameter configuration.

[0062] In an embodiment, a user click operation on a node may be received, and a form or sidebar may be displayed to receive specific parameters input by the user for that step. In an embodiment, the user input parameters may be received through an input box or a drop-down menu. In this way, the user input parameters can be saved in the node's data model as a basis for subsequent generation of a configuration file.

[0063] Step S14: dependency connection.

[0064] In an embodiment, each node can be connected with an edge based on the dependency relationship between the application installation steps to represent the order and dependency relationship between the steps. This can achieve dependency connection, i.e., edge creation.

[0065] Specifically, by receiving the user's anchor operation of dragging the node or using the connection control to create an edge, the dependency relationship between steps is expressed, such as triggering "decompression" after "download completion".

[0066] The embodiment can also perform dependency verification, verifying the legitimacy of connections, such as prohibiting circular dependencies or duplicate connections, and highlighting the connection effects in real time. Furthermore, it can record edge information: each edge needs to record the source node ID, target node ID, and possible labels, such as "execute on success."

[0067] In this embodiment, attributes can also be set for nodes and edges, i.e., attributes can be set for each node and edge, including but not limited to color, shape, and label, to better display information. The AntV G6 engine can be used to render these nodes and edges into an interactive workflow diagram. Interactive operations such as dragging nodes, modifying attributes, and dynamically adding or deleting nodes and edges allow users to adjust and optimize workflows in real time.

[0068] Step S15: data extraction and verification.

[0069] In this embodiment, all nodes and edge data in the canvas can be traversed to extract the following information: node data and edge data. Node data can include: ID, type, label, and user-entered parameters. Edge data can include: source node ID, target node ID, and dependency conditions (such as labels).

[0070] Verifying the validity of nodes and edges on the canvas includes checking for isolated nodes, circular dependencies, and required parameters. Isolated node checking ensures that all nodes have at least one incoming or outgoing edge (except for the start / end nodes). Circular dependency checking uses a topological sorting algorithm to check for loops. Required parameter checking ensures that parameters for key steps are complete (such as the URL for the download step).

[0071] Step S16: Generate a JSON configuration file.

[0072] In one embodiment, the API (application programming interface) provided by G6 can be used to extract node and edge data from the graph and generate JSON, that is, convert the extracted data into JSON format. The JSON data is converted into a text file, and a download button can be provided or it can be automatically saved to a server.

[0073] The embodiments of the present application can provide intuitive interactions such as dragging component libraries, node parameter forms, and line operations through user interaction design, data synchronization, scalability, and visual feedback. It supports deleting nodes and edges, and undoing / redoing operations to enhance the user experience. It can also synchronize the node or edge state in the canvas with the data model in memory in real time. It supports more complex scenarios such as conditional branches or parallel steps by customizing node or edge types. It can provide immediate feedback such as highlighting and error prompts (such as invalid connections) during user operations.

[0074] Through the above steps, users can intuitively design the installation process, and the system automatically generates a structured JSON configuration file to support the subsequent deployment of the target application.

[0075] Based on the above embodiments, the present application also provides a configuration file generation method, which can be applied to a terminal, such as Figure 2 As shown, the method may include the following steps:

[0076] In step S210 , a plurality of predefined nodes are obtained.

[0077] The multiple nodes respectively represent deployment steps of the target application.

[0078] In an embodiment, each step involved in the target application installation process may be defined as a node, and each node includes information such as a step name, a description, and an execution condition.

[0079] In the embodiment, each node is defined by receiving configuration information input by the user. Each node needs to record a unique ID, type, label, and user-input parameters such as a file URL or a target path.

[0080] In step S220 , the dependency relationships among the multiple nodes are obtained, and a configuration file for deploying the target application is generated based on the multiple nodes and the dependency relationships.

[0081] In this embodiment, a node represents a deployment step of a target application, and multiple nodes have a deployment order and dependencies between them. Therefore, the dependency relationship between nodes represents the deployment order and dependencies between the nodes. For example, if the target application is deployed in the first step through node 1, node 2 represents the second step of deployment of the target application. Node 2 may also need to utilize the data in node 1 and needs to be deployed based on node 1, forming a dependency relationship between nodes 1 and 2, including the deployment order and data dependency.

[0082] In an embodiment, the AntV G6 visualization engine in the above embodiment can be used to receive multiple nodes created by the user on the canvas and connect each node through edge connections to represent the dependency relationship between the nodes. Then, a configuration file can be automatically generated by extracting the data corresponding to the nodes and the dependency relationships.

[0083] By obtaining multiple predefined nodes and the dependencies between them, a configuration file for deploying the target application can be generated based on the multiple nodes and the dependencies. Because the multiple nodes represent the deployment steps of the target application, obtaining the multiple nodes of the target application and the dependencies between them allows for more intuitive user operations, thereby improving the efficiency of generating the configuration file.

[0084] Based on the above embodiment, in another embodiment provided in this application, the method may further include the following steps:

[0085] In step S230, a component selection operation of a user in a component library is received, and a plurality of nodes are generated based on the component selection operation.

[0086] In an embodiment, a user may call a corresponding component in a component library. Thus, when a user's calling operation in the component library is received, a node instance may be generated through a corresponding function, that is, multiple nodes may be obtained.

[0087] For example, users can drag or click to select the desired component in the component library, such as a database, API interface, or compute node. This automatically generates corresponding node instances on the canvas based on the selected component type and assigns a unique identifier to each node. Nodes can also be assigned default properties, such as node name, node type, and node coordinate position, and stored in memory or a temporary data structure. Nodes are dynamically rendered on the canvas through visual rendering, and basic interactive functions such as selection, movement, and deletion are provided.

[0088] In step S240 , configuration information input by the user for each node is received, and multiple nodes are updated based on the configuration information to obtain multiple predefined nodes.

[0089] In the embodiment, the user may input corresponding configuration information for each node. Thus, by receiving the configuration information input by the user for each node, each node is updated to obtain a plurality of predefined nodes.

[0090] For example, a user clicks a node and enters specific configuration parameters, such as database connection information, API address, or calculation logic, through a form, sidebar, or pop-up window. The user-entered values ​​are associated with the node attributes, the node data model in memory is updated, and the validity of key parameters (such as IP format or required fields) is verified. Error prompts or highlighted feedback are provided, and the node's visual status is updated (such as node color changes and label updates) to reflect the configuration's effectiveness.

[0091] The embodiment can generate multiple nodes by receiving user selection operations in the component library, and can update each node by receiving user input configuration operations for each node, so that the user can flexibly configure each node in a visual manner.

[0092] Based on the above embodiment, in another embodiment provided by the present application, in the process of obtaining the dependency relationship between multiple nodes, the above step S220 may further specifically include the following steps:

[0093] In step S221 , a user connection operation on multiple nodes displayed on the canvas is received.

[0094] In step S222, based on the connection operation, edge connections are performed on multiple nodes, wherein edge connections represent dependency relationships between nodes.

[0095] In this embodiment, by receiving user connection operations on multiple real-world nodes on the canvas, edge connections can be created between the nodes. This edge connection method can intuitively reflect the dependencies between nodes and reflect the execution order of the deployment steps of the target application. Users can flexibly adjust the edge connections between nodes, thereby significantly improving the efficiency of configuration file generation.

[0096] Based on the above embodiment, in another embodiment provided by the present application, in the process of generating a configuration file for a deployment target application based on multiple nodes and dependency relationships, the above step S220 may further specifically include the following steps:

[0097] In step S223 , node data corresponding to the plurality of nodes and edge data corresponding to the dependency relationships are extracted.

[0098] In step S224 , a configuration file is generated based on the node data and the edge data.

[0099] In an embodiment, the node data includes: the node's identification, description, and execution conditions. The edge data may include: the source node identification, the target node identification, and dependency conditions.

[0100] In an embodiment, the basic data of each node can be extracted, including basic information such as a unique identifier, component type, and coordinate position, which is used to uniquely identify the position and type of the node in the topology map. In addition, the business attributes of the node, such as database connection information and API endpoints, can also be extracted. These must be bound to the data field of the node through a user-configured form or interface, and dynamic expansion can be supported. Node data can specifically include three types, namely static configuration (including configuration parameters manually entered by the user), dynamic interface acquisition (which can be obtained through a remote API), and model data association (which can be mapped across model fields). The data source type and association rules must be clearly recorded.

[0101] In this embodiment, edge data must include metadata such as the starting node ID (source), the ending node ID (target), the connection type (such as data flow, control flow) and the transmission protocol to ensure the traceability of the dependency relationship.

[0102] In an embodiment, node and edge data can be assembled into a complete configuration file in a standard format (such as JSON), including a metadata layer, a node layer, and an edge layer. The metadata layer includes system-level attributes such as version number and timestamp, the node layer includes the complete attribute set of all nodes, and the edge layer includes the connection and configuration data of all dependencies.

[0103] The embodiment extracts node data corresponding to multiple nodes and edge data corresponding to the dependency relationship, so that a configuration file can be generated based on the node data and edge data. By automatically generating the configuration file, the user's manual writing workload can be reduced, and the generated file can be ensured to meet the requirements of the target platform, thereby improving accuracy and consistency.

[0104] In an embodiment, when extracting node data corresponding to multiple nodes and edge data corresponding to dependency relationships, each node displayed on the canvas can be traversed, and isolated nodes that do not meet a preset condition can be removed to obtain a target node. The node data corresponding to the target node and edge data corresponding to the dependency relationships between the target nodes can then be extracted. The preset condition can be a node that has no edge connections to other nodes.

[0105] Specifically, the nodes in the memory can be traversed. Since the nodes represent the deployment steps of the target application, there needs to be an association relationship between the nodes. In this way, isolated nodes that have no edge connection relationship with other nodes can be removed, thereby improving the accuracy and effectiveness of the edge data.

[0106] In the embodiment provided in the present application, attribute information set by the user for each node and each edge may also be received, and each node and each edge may be displayed on the canvas based on the attribute information.

[0107] In this embodiment, node and edge attributes can also be set, i.e., attributes such as color, shape, and label can be set for each node and edge to better display information. A visualization engine can be used to render these nodes and edges into an interactive workflow diagram. Interactive operations such as dragging nodes, modifying attributes, and dynamically adding or deleting nodes and edges allow users to adjust and optimize workflows in real time.

[0108] In the embodiments provided herein, user adjustment operations on nodes or edges may also be received, and adjustments may be made to the nodes or edges based on the adjustment operations. The adjustment operations may include at least one of the following: node movement, attribute information modification, node addition, node deletion, edge addition, and edge deletion.

[0109] The embodiments of the present application can provide intuitive interactions such as dragging component libraries, node parameter forms, and line operations through user interaction design, data synchronization, scalability, and visual feedback. It supports deleting nodes and edges, and undoing / redoing operations to enhance the user experience. It can also synchronize the node or edge state in the canvas with the data model in memory in real time. It supports more complex scenarios such as conditional branches or parallel steps by customizing node or edge types. It can provide immediate feedback such as highlights and error prompts (such as invalid edge connections) during user operations to improve the efficiency of generating configuration files.

[0110] In the case of dividing each functional module according to each function, an embodiment of the present application provides a configuration file generation device, which can be a server, a terminal, or a chip applied to the server. Figure 3 This is a schematic block diagram of the functional modules of a configuration file generating device provided by an exemplary embodiment of the present application. Figure 3 As shown, the configuration file generating device includes:

[0111] A node acquisition module 31 is configured to acquire a plurality of predefined nodes, each of which represents a deployment step of a target application;

[0112] The configuration file generating module 32 is configured to obtain the dependency relationships between the plurality of nodes and generate a configuration file for deploying the target application based on the plurality of nodes and the dependency relationships.

[0113] In another embodiment provided in the present application, the apparatus further includes:

[0114] A node generation module is used to receive a component selection operation from a user in a component library and generate a plurality of nodes based on the component selection operation;

[0115] The node updating module is configured to receive configuration information input by a user for each node, and update the plurality of nodes based on the configuration information to obtain the plurality of predefined nodes.

[0116] In another embodiment provided by the present application, the configuration file generating module is specifically configured to:

[0117] receiving a user's connection operation on the plurality of nodes displayed on the canvas;

[0118] Based on the connection operation, edge connections are performed on the multiple nodes; wherein the edge connections represent dependency relationships between the nodes.

[0119] In another embodiment provided by the present application, the configuration file generating module is further configured to:

[0120] Extracting node data corresponding to the plurality of nodes and edge data corresponding to the dependency relationships;

[0121] A configuration file is generated based on the node data and the edge data.

[0122] In another embodiment provided by the present application, the configuration file generating module is further configured to:

[0123] Traversing the nodes displayed on the canvas;

[0124] Isolated nodes that do not meet preset conditions are removed from the nodes to obtain a target node, and node data corresponding to the target node and edge data corresponding to the dependency relationship between the target nodes are extracted.

[0125] In another embodiment provided by the present application, the node data includes: an identification, a description, and an execution condition of the node.

[0126] In another embodiment provided by the present application, the edge data includes: a source node identifier, a target node identifier, and a dependency condition.

[0127] In another embodiment provided in the present application, the apparatus further includes:

[0128] An attribute information receiving module, configured to receive attribute information set by a user for each node and each edge;

[0129] A display module is configured to display the nodes and the edges on a canvas based on the attribute information.

[0130] In another embodiment provided in the present application, the apparatus further includes:

[0131] An adjustment operation receiving module, configured to receive a user's adjustment operation on each node or each edge;

[0132] An adjustment module is used to adjust the nodes or edges based on the adjustment operation; wherein the adjustment operation includes at least one of the following: node movement, attribute information modification, node addition, node deletion, edge addition and edge deletion.

[0133] An embodiment of the present application also provides an electronic device, comprising: at least one processor; a memory for storing instructions executable by the at least one processor; wherein the at least one processor is configured to execute the instructions to implement the above method disclosed in the embodiment of the present application.

[0134] Figure 4 This is a schematic diagram of the structure of an electronic device provided by an exemplary embodiment of the present application. Figure 4 As shown, the electronic device 1800 includes at least one processor 1801 and a memory 1802 coupled to the processor 1801. The processor 1801 can execute corresponding steps in the above method disclosed in the embodiment of the present application.

[0135] The processor 1801 can also be referred to as a central processing unit (CPU), which can be an integrated circuit chip with signal processing capabilities. Each step in the above method disclosed in the embodiment of the present application can be completed by hardware integrated logic circuits in the processor 1801 or software instructions. The processor 1801 can be a general-purpose processor, a digital signal processor (DSP), an ASIC (Application Specific Integrated Circuit), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in the embodiment of the present application can be directly implemented as being executed by a hardware decoding processor, or by a combination of hardware and software modules in the decoding processor. The software module can be located in the memory 1802, such as a random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. The processor 1801 reads the information in the memory 1802 and, in conjunction with its hardware, completes the steps of the above method.

[0136] In addition, when various operations / processes according to the present application are implemented by software and / or firmware, they can be transmitted from a storage medium or a network to a computer system with a dedicated hardware structure, such as Figure 5 The computer system 1900 shown is installed with the programs constituting the software. When the various programs are installed, the computer system can perform various functions, including the functions described above. Figure 5 A structural block diagram of a computer system provided for an exemplary embodiment of the present application.

[0137] Computer system 1900 is intended to represent various forms of digital electronic computer devices, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. Electronic devices can also represent various forms of mobile devices, such as cellular phones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely examples and are not intended to limit the implementation of the present application described and / or claimed herein.

[0138] like Figure 5 As shown, computer system 1900 includes a computing unit 1901, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 1902 or a computer program loaded from a storage unit 1908 into a random access memory (RAM) 1903. Various programs and data required for the operation of computer system 1900 may also be stored in RAM 1903. Computing unit 1901, ROM 1902, and RAM 1903 are connected to each other via a bus 1904. An input / output (I / O) interface 1905 is also connected to bus 1904.

[0139] Several components within computer system 1900 are connected to I / O interface 1905, including an input unit 1906, an output unit 1907, a storage unit 1908, and a communication unit 1909. Input unit 1906 can be any type of device capable of inputting information into computer system 1900. Input unit 1906 can receive input numeric or character information and generate key input signals related to user settings and / or function control of an electronic device. Output unit 1907 can be any type of device capable of presenting information and may include, but is not limited to, a display, a speaker, a video / audio output terminal, a vibrator, and / or a printer. Storage unit 1908 may include, but is not limited to, a magnetic disk or an optical disk. Communication unit 1909 allows computer system 1900 to exchange information / data with other devices over a network, such as the Internet, and may include, but is not limited to, a modem, a network card, an infrared communication device, a wireless communication transceiver and / or chipset, such as a Bluetooth™ device, a WiFi device, a WiMax device, a cellular communication device, and / or the like.

[0140] The computing unit 1901 may be a variety of general and / or special processing components with processing and computing capabilities. Some examples of the computing unit 1901 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various dedicated artificial intelligence (AI) computing chips, various computing units for running machine learning model algorithms, digital signal processors (DSPs), and any appropriate processors, controllers, microcontrollers, etc. The computing unit 1901 performs the various methods and processes described above. For example, in some embodiments, the above-mentioned method disclosed in the embodiments of the present application may be implemented as a computer software program, which is tangibly contained in a machine-readable medium, such as a storage unit 1908. In some embodiments, part or all of the computer program may be loaded and / or installed on an electronic device via ROM 1902 and / or communication unit 1909. In some embodiments, the computing unit 1901 may be configured to perform the above-mentioned method disclosed in the embodiments of the present application by any other appropriate means (e.g., by means of firmware).

[0141] An embodiment of the present application also provides a computer-readable storage medium, wherein, when the instructions in the computer-readable storage medium are executed by a processor of an electronic device, the electronic device is enabled to execute the above method disclosed in the embodiment of the present application.

[0142] The computer-readable storage medium in the embodiment of the present application can be a tangible medium, which can contain or store a program for use by an instruction execution system, device or equipment or used in combination with an instruction execution system, device or equipment. The above-mentioned computer-readable storage medium can include but is not limited to electronic, magnetic, optical, electromagnetic, infrared or semiconductor systems, devices or equipment, or any suitable combination of the above. More specifically, the above-mentioned computer-readable storage medium can include an electrical connection based on one or more lines, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device or any suitable combination of the above.

[0143] The computer-readable medium may be included in the electronic device, or may exist independently without being incorporated into the electronic device.

[0144] An embodiment of the present application further provides a computer program product, including a computer program, wherein when the computer program is executed by a processor, the method disclosed in the embodiment of the present application is implemented.

[0145] In an embodiment of the present application, the computer program code for the operation of performing the present application can be written with one or more programming languages ​​or their combination, and above-mentioned programming language includes but is not limited to object-oriented programming language, such as Java, Smalltalk, C++, also comprises conventional procedural programming language, such as " C " language or similar programming language.Program code can be executed on user's computer completely, partly on user's computer, execute as an independent software package, partly on user's computer, partly on remote computer, or execute completely on remote computer or server.In the situation relating to remote computer, remote computer can be connected to user's computer by the network (comprising local area network (LAN) or wide area network (WAN)) of any type, perhaps, can be connected to external computer.

[0146] The flow charts and block diagrams in the accompanying drawings illustrate the possible architecture, functions and operations of the systems, methods and computer program products according to various embodiments of the present application. In this regard, each box in the flow chart or block diagram can represent a module, program segment or a part of code, and the module, program segment or a part of code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order than that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented by a dedicated hardware-based system that performs the specified function or operation, or can be implemented by a combination of dedicated hardware and computer instructions.

[0147] The modules, components, or units described in the embodiments of the present application may be implemented in software or hardware. The names of the modules, components, or units do not necessarily limit the modules, components, or units themselves.

[0148] The functions described above herein may be performed at least in part by one or more hardware logic components. For example, and without limitation, exemplary hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chip (SOCs), complex programmable logic devices (CPLDs), and the like.

[0149] The above descriptions are merely some embodiments of the present application and an illustration of the technical principles employed. Those skilled in the art should understand that the scope of disclosure involved in this application is not limited to the technical solutions formed by a specific combination of the above-mentioned technical features, but also encompasses other technical solutions formed by any combination of the above-mentioned technical features or their equivalents without departing from the above-mentioned disclosed concepts. For example, a technical solution formed by replacing the above-mentioned features with (but not limited to) technical features with similar functions disclosed in this application.

[0150] Although some specific embodiments of the present application have been described in detail by way of example, it should be understood by those skilled in the art that the above examples are for illustration only and are not intended to limit the scope of the present application. It should be understood by those skilled in the art that the above examples may be modified without departing from the scope and spirit of the present application. The scope of the present application is defined by the appended claims.

Claims

1. A configuration file generation method, characterized in that: The method comprises: Acquire a plurality of predefined nodes, wherein the plurality of nodes respectively represent deployment steps of a target application; Obtain dependency relationships between the multiple nodes, and generate a configuration file for deploying the target application based on the multiple nodes and the dependency relationships.

2. The method according to claim 1, characterized in that The method further comprises: receiving a component selection operation from a user in a component library, and generating a plurality of nodes based on the component selection operation; Configuration information input by a user for each node is received, and the multiple nodes are updated based on the configuration information to obtain the predefined multiple nodes.

3. The method according to claim 1, characterized in that The obtaining of the dependency relationship between the multiple nodes includes: receiving a user's connection operation on the plurality of nodes displayed on the canvas; Based on the connection operation, edge connections are performed on the multiple nodes; wherein the edge connections represent dependency relationships between the nodes.

4. The method according to claim 3, characterized in that The generating, based on the multiple nodes and the dependency relationships, a configuration file for deploying the target application comprises: Extracting node data corresponding to the plurality of nodes and edge data corresponding to the dependency relationships; A configuration file is generated based on the node data and the edge data.

5. The method according to claim 4, characterized in that The extracting node data corresponding to the plurality of nodes and edge data corresponding to the dependency relationships includes: Traversing each node displayed on the canvas; Isolated nodes that do not meet preset conditions are removed from the nodes to obtain a target node, and node data corresponding to the target node and edge data corresponding to the dependency relationship between the target nodes are extracted.

6. The method according to claim 5, characterized in that The node data includes: node identification, description and execution conditions.

7. The method according to claim 5, characterized in that The edge data includes: a source node identifier, a target node identifier, and dependency conditions.

8. The method according to claim 3, characterized in that The method further comprises: Receive attribute information set by users for each node and each edge; The nodes and the edges are displayed on a canvas based on the attribute information.

9. The method according to claim 3, characterized in that The method further comprises: Receive user adjustment operations on each node or each edge, and adjust each node or each edge based on the adjustment operations; wherein the adjustment operations include at least one of the following: node movement, attribute information modification, node addition, node deletion, edge addition and edge deletion.

10. An electronic device, characterized in that: include: at least one processor; a memory for storing the at least one processor-executable instruction; The at least one processor is configured to execute the instructions to implement the method according to any one of claims 1 to 9.

Images