CN113568825B - Program flow debugging method, device, equipment and storage medium - Google Patents
Program flow debugging method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN113568825B CN113568825B CN202110574485.5A CN202110574485A CN113568825B CN 113568825 B CN113568825 B CN 113568825B CN 202110574485 A CN202110574485 A CN 202110574485A CN 113568825 B CN113568825 B CN 113568825B
- Authority
- CN
- China
- Prior art keywords
- node
- sub
- nodes
- data
- flow
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 139
- 238000003860 storage Methods 0.000 title claims abstract description 12
- 230000008569 process Effects 0.000 claims abstract description 28
- 238000013515 script Methods 0.000 claims description 40
- 230000006870 function Effects 0.000 claims description 27
- 238000004590 computer program Methods 0.000 claims description 16
- 238000012545 processing Methods 0.000 claims description 13
- 238000000354 decomposition reaction Methods 0.000 claims description 4
- 238000009826 distribution Methods 0.000 claims description 3
- 230000005856 abnormality Effects 0.000 abstract description 3
- 238000010586 diagram Methods 0.000 description 8
- 230000009471 action Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012360 testing method Methods 0.000 description 3
- 230000002159 abnormal effect Effects 0.000 description 2
- 238000013480 data collection Methods 0.000 description 2
- 238000001514 detection method Methods 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000009530 blood pressure measurement Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 230000001737 promoting effect Effects 0.000 description 1
- 238000012163 sequencing technique Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3409—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment for performance assessment
- G06F11/3414—Workload generation, e.g. scripts, playback
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3632—Software debugging of specific synchronisation aspects
Abstract
The embodiment of the application provides a program flow debugging method, device, equipment and storage medium, and relates to the technical field of computers, wherein the method comprises the following steps: the execution of the process is decomposed into a plurality of nodes and the connection relation of the nodes, the process is advanced according to the connection relation, when the process is advanced to a certain node, the execution data of the nodes are collected through the node sub-process, and the collected execution data are visually displayed, so that each node is transparent to a developer, the execution condition and performance of each node are known, when the abnormality occurs, the developer can conveniently and quickly position the error position according to the collected execution information, the error checking is timely carried out, and the time spent for on-line error checking is reduced. And through the collected execution information, developers can quickly reappear the input data of the error node to realize breakpoint debugging.
Description
Technical Field
The embodiment of the application relates to the technical field of computers, in particular to a program flow debugging method, a device, equipment and a storage medium.
Background
Currently, when a developer completes a functional flow after developing, the program needs to be tested. When an error occurs in the debugging process, a developer often takes a lot of time to locate a position where a problem really occurs, breakpoint debugging is difficult, and reproduction can only be attempted by logging and reissuing. In addition, in the debugging process, developers cannot visually check the real-time running process of the program, cannot test the performance of the program and the like.
Disclosure of Invention
The embodiment of the application provides a program flow debugging method, device, equipment and storage medium, and aims to solve the technical problems that the existing flow debugging method is long in time consumption for locating an error position, difficult in breakpoint debugging, incapable of being visually checked and incapable of testing performance.
An embodiment of the present application provides a program flow debugging method, where the method includes:
decomposing a program flow into a plurality of nodes and connection relations of the plurality of nodes, and marking an initial node in the plurality of nodes;
configuring node sub-flows of each node for the plurality of nodes, wherein the types of the node sub-flows comprise: command sub-process, parse sub-process, index sub-process;
inputting initialization parameters to the initial node to enable the nodes to advance according to the connection relation, and executing self functions by the node when advancing to any node in the nodes,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
and after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format.
Optionally, configuring a node sub-flow of each node for the plurality of nodes, including:
configuring a node sub-flow of each node for the plurality of nodes, including:
aiming at the plurality of nodes, analyzing the node sub-flow needing to be configured according to the function of each node;
selecting a target script corresponding to each node sub-process in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on the node.
Optionally, the method further comprises:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on the different threads.
A second aspect of an embodiment of the present application provides a program flow debugging device, where the device includes:
the decomposition module is used for decomposing the program flow into a plurality of nodes and connection relations of the nodes, and marking the initial node in the nodes;
the node configuration module is configured to configure node sub-flows of each node for the plurality of nodes, and the types of the node sub-flows include: command sub-process, parse sub-process, index sub-process;
a pushing module, configured to input an initialization parameter to the initial node, so that the plurality of nodes perform pushing according to the connection relationship, and when pushing to any node in the plurality of nodes, the node performs a self function, and,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
and after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format.
Optionally, the node configuration module includes:
the analysis submodule is used for analyzing the node sub-flow required to be configured according to the function of each node aiming at the plurality of nodes;
the selection sub-module is used for selecting target scripts corresponding to the sub-processes of each node in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and the configuration submodule configures the target script on the node.
Optionally, the apparatus further includes:
and the distribution module is used for distributing the plurality of nodes on different threads according to the connection relation so as to enable the plurality of nodes to process on the different threads.
A third aspect of the embodiments of the present application provides a readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the method as described in the first aspect of the present application.
A fourth aspect of the present application provides an electronic device, including a memory, a processor, and a computer program stored on the memory and executable on the processor, where the processor implements the steps of the method described in the first aspect of the present application when the processor executes the computer program.
By adopting the program flow debugging method provided by the application, the execution of the flow is decomposed into the connection relation between a plurality of nodes and the nodes, the flow is propelled according to the connection relation, the execution data of the nodes are collected through the node sub-flow when the flow is propelled to a certain node, and the collected execution data are visually displayed, so that each node is transparent to a developer, the execution condition and performance of each node are known, when an abnormality occurs, the developer can conveniently and rapidly locate the error position according to the collected execution information, the error is timely detected, and the time spent for on-line error detection is reduced. And through the collected execution information, developers can quickly reappear the input data of the error node to realize breakpoint debugging.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the description of the embodiments of the present application will be briefly described below, it being obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flowchart of a program flow debugging method according to an embodiment of the present application;
fig. 2 is a schematic functional block diagram of a program flow debugging device according to an embodiment of the present application.
Detailed Description
The following description of the embodiments of the present application will be made clearly and fully with reference to the accompanying drawings, in which it is evident that the embodiments described are some, but not all, of the embodiments of the present application. All other embodiments, which can be made by one of ordinary skill in the art based on the embodiments herein without making any inventive effort, are intended to be within the scope of the present application.
Referring to fig. 1, fig. 1 is a flowchart of a program flow debugging method according to an embodiment of the present application.
As shown in fig. 1, the method comprises the steps of:
step S110, decomposing the program flow into a plurality of nodes and connection relations of the plurality of nodes, and marking the initial node in the plurality of nodes.
The program is operated according to a preset program flow, and the preset program flow is divided into a plurality of nodes and connection relations among the nodes. A node represents a step of the program flow, the program flow is decomposed into a plurality of steps to execute, each step has a respective function, different requirement points can be realized, and each step is used as a node in the debugging process.
After the decomposition process, a traffic flow is defined, wherein each node represents a portion of the traffic flow that the user wants to be transparent.
For example, for an item selection process, when a user clicks on a certain type of item, the process that may be involved includes: acquiring the type of commodity in the database, acquiring historical order data of a user, sequencing or prompting the acquired type of commodity data, and displaying sales promotion activities of all the commodities. Obviously, this process can be functionally: and acquiring commodity data, commodity ordering and sales promotion displaying, and decomposing the commodity data, the commodity ordering and the sales promotion displaying into different nodes.
After the nodes are decomposed, the starting node is marked, and the starting node is the starting position of the flow or the node connected with the node at the upper stage, cannot be pushed by data output by the node, and can only be started by depending on external input, so that the starting node is marked for convenient subsequent use.
The nodes have connection relations, and the connection relations represent the triggering sequence and the triggering conditions of the nodes. The trigger sequence specifies the trigger direction of the node, the trigger condition indicates under which condition the previous node triggers the next node, the trigger condition may be manual trigger or automatic trigger, for example, for a part of simple nodes, the trigger condition may be set to be automatic trigger, when the previous node collects data/collected data to meet the requirement, that is, the next node is automatically triggered, for a complex node, the trigger condition may be set to be manual trigger, and only when the user clicks, the next node is triggered.
Step S120, for the plurality of nodes, configuring a node sub-flow of each node, where a type of the node sub-flow includes: command sub-process, parse sub-process, index sub-process.
For the decomposed nodes, configuring node sub-flows of each node, wherein the types of the node sub-flows comprise: command sub-process, parse sub-process, index sub-process. The method includes the steps that when transparency of nodes is required to be achieved, execution data of all the nodes are required to be collected, the data collection process is divided into three basic sub-processes, the command sub-processes are used for collecting the execution data of the nodes, the analysis sub-processes are used for reading the data collected by the command sub-processes, standardized processing is conducted on the data, the index sub-processes are used for reading the standardized data, and the standardized data are visually displayed according to a preset format.
Preferably, for the plurality of nodes, configuring a node sub-flow of each node includes:
aiming at the plurality of nodes, analyzing the node sub-flow needing to be configured according to the function of each node;
selecting a target script corresponding to each node sub-process in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on the node.
In order to analyze the node sub-flow configured by the node and collect and display the execution data of the node, the implementation of the process in this embodiment is divided into three basic sub-flows, namely a command sub-flow, an analysis sub-flow and an index sub-flow. The data acquisition method is different according to the node sub-flow which needs to be configured according to the node function analysis, and the corresponding analysis sub-flow and index sub-flow are also different because the data acquired by each node are different. Each node selects a corresponding sub-flow according to the self condition.
In this embodiment, the node sub-flow is implemented by using a script, that is, the node sub-flow is written as a script in advance. Script refers to an executable file written according to a certain format by using a specific descriptive language in the field of computers, and is generally simple in use because of the simple grammar and structure of the Script, and the Script generally takes "interpretation" of a program which is easy to modify as an operation mode, without "compiling", so that the development capacity of the Script is better than the operation performance. A script can connect various existing components to accomplish related tasks, and communication between script and program components written in other languages is powerful, which can bond service components together.
The script can adopt a JavaScript, lua, shell, regex, sql, go format and the like, provides a more convenient deployment mode for developers focusing on different languages, and is convenient for the developers in different languages to acquire data.
The script is adopted to collect data, so that manual operation is not needed, the workload of operation and maintenance personnel is reduced, the performance bottleneck of the existing data collection method can be broken through, and high-frequency and high-efficiency collection is supported.
The scripts of the nodes come from a pre-established knowledge base, the scripts are accumulated in a knowledge base mode, operation and maintenance personnel can write the possibly used scripts according to actual conditions and store the possibly used scripts in the knowledge base, the knowledge base of the application can accumulate the scripts written in the debugging process besides the pre-written scripts, namely the scripts generated in the pre-written and debugging process are accumulated in the knowledge base of the application, and the application can be quickly adapted to any asset through the accumulated scripts.
The script can also be customized by a developer according to the requirements, the command, the index and the analysis data script, and then the script is configured on the node, so that the script of a knowledge base is not used, and the flexible configuration of the acquisition task is realized.
Step S130, inputting initialization parameters to the initial node to enable the nodes to advance according to the connection relationship, and when advancing to any node of the nodes, the node performs its own function, and,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
and after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format.
Initialization parameters, which are parameters that need to be input for the program flow to run, such as the commodity type in the above example, are input to the start node. After the initial node receives the parameters and executes the function of the node, the node of the next stage is pushed according to the connection relation, after the node of the next stage is pushed, the node of the next stage connected with the node is pushed according to the connection relation after the function of the node of the next stage is executed, and all stages of nodes are gradually pushed until all the nodes are executed. The process is executed, and the process advances step by connecting relations such as clicking events by the user, and feeds back the part execution events to the user, so that the user can know what happens to each part. After the execution of the service flow is completed, various abnormal information generated in the result and the result can be collected and fed back to the user.
After the node is pushed, the function contained in the node is executed, and the sub-process is instructed to collect the execution data of the node, wherein the execution data comprises an execution result, execution time, outlet data and inlet data.
And after the command sub-process collects the data, notifying and analyzing the sub-process, reading the data collected by the command sub-process by the analyzing sub-process, and carrying out standardized processing on the data.
And after the analysis sub-process finishes processing the data, notifying an index sub-process, reading the standardized data by the index sub-process, and visually displaying the standardized data according to a pre-configured format.
And splicing the collected execution information into the environment, uniformly informing the user, ensuring that the operation result of each step is transparent to the user, and recording error information into the environment when abnormal information occurs, so that the user can conduct error checking in time.
By the method, the program flow can be subjected to pressure measurement, so that the information of each node of the program flow becomes transparent.
Preferably, the method further comprises:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on the different threads.
The parallel nodes can be distributed on different threads, and the commodity selection flow of the previous example is exemplified, and the commodity selection flow is assumed to be that when a user clicks a certain type of commodity, the type of commodity is obtained from the acquisition database, the historical order data of the user is obtained in parallel to sort or prompt the commodity, the result is output, the sales promotion of each commodity is obtained, and the sales promotion is displayed below the commodity column. In this process, there are two parallel nodes after acquiring the commodity data node: and acquiring historical data of the user for sorting, and acquiring promotional activity data for display.
For this type of parallel nodes, they can be allocated on different threads, and thread is the minimum unit that the operating system can perform operation scheduling. In most cases, it is included in a process, which is the actual unit of operation in the process. A thread refers to a single sequential control flow in a process. By distributing the nodes on different threads, each thread executes different tasks in parallel, and the execution throughput rate of the program and the execution efficiency of the program are improved.
By adopting the program flow debugging method provided by the application, the execution of the flow is decomposed into the connection relation between a plurality of nodes and the nodes, the flow is propelled according to the connection relation, the execution data of the nodes are collected through the node sub-flow when the flow is propelled to a certain node, and the collected execution data are visually displayed, so that each node is transparent to a developer, the execution condition and performance of each node are known, when an abnormality occurs, the developer can conveniently and rapidly locate the error position according to the collected execution information, the error is timely detected, and the time spent for on-line error detection is reduced. And through the collected execution information, developers can quickly reappear the input data of the error node to realize breakpoint debugging.
In addition, when the program flow is expanded and the nodes are expanded to increase the integrity of the instance, the execution information of the nodes is already known, so that for newly developed and expanded nodes, the information of the known nodes can be directly utilized to realize quick verification of whether the newly added nodes are correct or not. In addition, compared with the existing program debugging method, after a new program flow is configured, deployment personnel can test whether the flow is effective or not more quickly.
Based on the same inventive concept, an embodiment of the present application provides a program flow debugging device. Referring to fig. 2, fig. 2 is a schematic functional block diagram of a program flow debugging device according to an embodiment of the present application.
As shown in fig. 2, the apparatus includes:
a decomposition module 210, configured to decompose a program flow into a plurality of nodes and connection relationships of the plurality of nodes, where a starting node is marked in the plurality of nodes;
the node configuration module 220 is configured to configure, for the plurality of nodes, a node sub-flow of each node, where a type of the node sub-flow includes: command sub-process, parse sub-process, index sub-process;
a pushing module 230, configured to input an initialization parameter to the initial node, so that the plurality of nodes perform pushing according to the connection relationship, and when pushing to any node of the plurality of nodes, the node performs a self function, and,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
and after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format.
Preferably, the node configuration module 220 includes:
the analysis submodule is used for analyzing the node sub-flow required to be configured according to the function of each node aiming at the plurality of nodes;
the selection sub-module is used for selecting target scripts corresponding to the sub-processes of each node in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and the configuration submodule configures the target script on the node.
Preferably, the apparatus further comprises:
and the distribution module is used for distributing the plurality of nodes on different threads according to the connection relation so as to enable the plurality of nodes to process on the different threads.
Based on the same inventive concept, another embodiment of the present application provides a readable storage medium, on which a computer program is stored, which when executed by a processor, implements the steps of the program flow debugging method according to any one of the embodiments of the present application.
Based on the same inventive concept, another embodiment of the present application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and capable of running on the processor, where the processor executes the steps in the program flow debugging method according to any one of the foregoing embodiments of the present application.
For the device embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and reference is made to the description of the method embodiments for relevant points.
In this specification, each embodiment is described in a progressive manner, and each embodiment is mainly described by differences from other embodiments, and identical and similar parts between the embodiments are all enough to be referred to each other.
It will be apparent to those skilled in the art that embodiments of the present application may be provided as a method, apparatus, or computer program product. Accordingly, the present embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present application may take the form of a computer program product on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.
Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing terminal device to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal device, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
While preferred embodiments of the present embodiments have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. It is therefore intended that the following claims be interpreted as including the preferred embodiments and all such alterations and modifications as fall within the scope of the embodiments of the present application.
Finally, it is further noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or terminal that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or terminal. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article or terminal device comprising the element.
The foregoing has described in detail the methods, apparatuses, devices and storage medium for debugging program flow provided in the present application, and specific examples are applied to illustrate the principles and embodiments of the present application, where the foregoing examples are only used to help understand the methods and core ideas of the present application; meanwhile, as those skilled in the art will have modifications in the specific embodiments and application scope in accordance with the ideas of the present application, the present description should not be construed as limiting the present application in view of the above.
Claims (6)
1. A program flow debugging method, the method comprising:
decomposing a program flow into a plurality of nodes and connection relations of the plurality of nodes, and marking an initial node in the plurality of nodes;
configuring node sub-flows of each node for the plurality of nodes, wherein the types of the node sub-flows comprise: command sub-process, parse sub-process, index sub-process;
inputting initialization parameters to the initial node to enable the nodes to advance according to the connection relation, and executing self functions by the node when advancing to any node in the nodes,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format;
the configuring node sub-flows of each node for the plurality of nodes includes:
aiming at the plurality of nodes, analyzing the node sub-flow needing to be configured according to the function of each node;
selecting a target script corresponding to each node sub-process in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on the node.
2. The method according to claim 1, wherein the method further comprises:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on the different threads.
3. A program flow debugging device, the device comprising:
the decomposition module is used for decomposing the program flow into a plurality of nodes and connection relations of the nodes, and marking the initial node in the nodes;
the node configuration module is configured to configure node sub-flows of each node for the plurality of nodes, and the types of the node sub-flows include: command sub-process, parse sub-process, index sub-process;
a pushing module, configured to input an initialization parameter to the initial node, so that the plurality of nodes perform pushing according to the connection relationship, and when pushing to any node in the plurality of nodes, the node performs a self function, and,
the command sub-process collects execution data of a node while the node performs its own function,
after the data is collected by the command sub-process, the analysis sub-process reads the data collected by the command sub-process, performs standardized processing on the data,
after the data is processed by the index sub-process, reading the standardized data, and visually displaying the standardized data according to a pre-configured format;
the node configuration module comprises:
the analysis submodule is used for analyzing the node sub-flow required to be configured according to the function of each node aiming at the plurality of nodes;
the selection sub-module is used for selecting target scripts corresponding to the sub-processes of each node in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and the configuration submodule configures the target script on the node.
4. A device according to claim 3, characterized in that the device further comprises:
and the distribution module is used for distributing the plurality of nodes on different threads according to the connection relation so as to enable the plurality of nodes to process on the different threads.
5. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the steps of the method according to any one of claims 1 to 2.
6. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the steps of the method according to any of claims 1 to 2 when executing the computer program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110574485.5A CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110574485.5A CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113568825A CN113568825A (en) | 2021-10-29 |
| CN113568825B true CN113568825B (en) | 2024-03-15 |
Family
ID=78161578
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110574485.5A Active CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113568825B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114201149B (en) * | 2022-02-18 | 2022-05-31 | 北京阿丘科技有限公司 | Operation flow generation method, device and system and computer readable storage medium |
| CN114462900B (en) * | 2022-04-13 | 2022-07-29 | 云智慧（北京）科技有限公司 | Method, device and equipment for splitting service active node |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130166886A1 (en) * | 2008-11-24 | 2013-06-27 | Ruchira Sasanka | Systems, apparatuses, and methods for a hardware and software system to automatically decompose a program to multiple parallel threads |
| CN105302549A (en) * | 2015-09-29 | 2016-02-03 | 莱诺斯科技(北京)有限公司 | Multiple-language-supporting test process generating, debugging and executing system |
| CN107194549A (en) * | 2017-05-05 | 2017-09-22 | 南京南瑞继保电气有限公司 | The visual presentation method that a kind of energy efficiency indexes are decomposed |
| CN107818043A (en) * | 2016-09-13 | 2018-03-20 | 东华软件股份公司 | Method and apparatus for program debugging |
| CN112817720A (en) * | 2021-01-30 | 2021-05-18 | 北京奇保信安科技有限公司 | Visual workflow scheduling method and device and electronic equipment |
-
2021
- 2021-05-25 CN CN202110574485.5A patent/CN113568825B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130166886A1 (en) * | 2008-11-24 | 2013-06-27 | Ruchira Sasanka | Systems, apparatuses, and methods for a hardware and software system to automatically decompose a program to multiple parallel threads |
| CN105302549A (en) * | 2015-09-29 | 2016-02-03 | 莱诺斯科技(北京)有限公司 | Multiple-language-supporting test process generating, debugging and executing system |
| CN107818043A (en) * | 2016-09-13 | 2018-03-20 | 东华软件股份公司 | Method and apparatus for program debugging |
| CN107194549A (en) * | 2017-05-05 | 2017-09-22 | 南京南瑞继保电气有限公司 | The visual presentation method that a kind of energy efficiency indexes are decomposed |
| CN112817720A (en) * | 2021-01-30 | 2021-05-18 | 北京奇保信安科技有限公司 | Visual workflow scheduling method and device and electronic equipment |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113568825A (en) | 2021-10-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US6658649B1 (en) | Method, apparatus and article of manufacture for debugging a user defined region of code | |
| CN107704392B (en) | Test case processing method and server | |
| US7895565B1 (en) | Integrated system and method for validating the functionality and performance of software applications | |
| US8589884B2 (en) | Method and system for identifying regression test cases for a software | |
| US8074204B2 (en) | Test automation for business applications | |
| US7178135B2 (en) | Scope-based breakpoint selection and operation | |
| US20140165040A1 (en) | Test script generation for application image validation | |
| CN113568825B (en) | Program flow debugging method, device, equipment and storage medium | |
| US20120116561A1 (en) | Program testing apparatus, method of testing a program, and program testing program | |
| CN103049371A (en) | Testing method and testing device of Android application programs | |
| US20180089071A1 (en) | Method and system for testing software based system | |
| US20110307865A1 (en) | User interface inventory | |
| CN110928772A (en) | Test method and device | |
| CN110347085B (en) | Automated test system, method, vehicle, and computer-readable medium | |
| CN106227654B (en) | A kind of test platform | |
| Roehm et al. | Monitoring user interactions for supporting failure reproduction | |
| JP2000122886A (en) | Program production system of semiconductor testing device | |
| Kranzlmüller et al. | Event graph visualization for debugging large applications | |
| CN102760086A (en) | Data detection control method and device based on flexible testing technology | |
| US9218388B1 (en) | Declarative cluster management | |
| US9244814B1 (en) | Enriched log viewer | |
| Ibrahim et al. | Sena TLS-Parser: a software testing tool for generating test cases | |
| Köckerbauer et al. | Scalable parallel debugging with g-Eclipse | |
| US9268675B2 (en) | Computerized system and method for auditing software code | |
| GB2537341A (en) | The sequenced common action and flow representation automation model (SCAFRA) |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |