Cross-operating-system remote debugging method and device, equipment, storage medium and product

Abstract

The invention discloses a cross-operating-system remote debugging method and device, equipment, a storage medium and a product, and relates to the technical field of computers.The cross-operating-system remote debugging method comprises the steps that in response to a remote debugging starting instruction, operating system information of a client side is detected; matching a corresponding operating system capability component according to the operating system information, and executing a remote debugging process on the client; and when the flow exception information returned by the client is received, visually displaying and updating the flow exception information, and dynamically adjusting the remote debugging flow. According to the method, a method for detecting and matching the operating system of the client side is adopted, communication connection across the operating systems is established for remote debugging, when the flow exception information returned by the client side is received, the flow exception information is visually displayed and updated, the remote debugging flow is dynamically adjusted, flow exception repairing and dynamic debugging are achieved, and the debugging efficiency is improved. Therefore, the technical problem of low debugging efficiency of cross-operating system remote debugging is solved.

Description

Technical Field

[0001] This application relates to the field of computer technology, and particularly to a cross-operating system remote debugging method, apparatus, device, storage medium, and product. Background Art

[0002] In modern enterprise production technology, Robotic Process Automation (RPA) simulates the operations of end-users in software systems through technologies such as interface recognition, browser operations, and AI capabilities, automates user operations, and achieves the purpose of replacing IT personnel and reducing costs and increasing efficiency. Among them, the RPA process debugging technology is a key link in realizing efficient automated processes.

[0003] In the related technologies of RPA process debugging, it is usually required that both the design end and the client end run within the same operating system. And when error messages appear in the debugging process, it is necessary to terminate the debugging process or retry the abnormal components by writing code, resulting in low debugging efficiency for cross-operating system remote debugging. Summary of the Invention

[0004] The main purpose of this application is to provide a cross-operating system remote debugging method, apparatus, device, storage medium, and product, aiming to solve the technical problem of low debugging efficiency for cross-operating system remote debugging.

[0005] To achieve the above purpose, this application proposes a cross-operating system remote debugging method, and the method includes:

[0006] In response to a remote debugging start instruction, detect the operating system information of the client;

[0007] According to the operating system information, match the corresponding operating system capability component, and execute a remote debugging process on the client;

[0008] When receiving process exception information returned by the client, visually display and update the process exception information, and dynamically adjust the remote debugging process.

[0009] In one embodiment, the step of matching the corresponding operating system capability component according to the operating system information and executing a remote debugging process on the client includes:

[0010] According to the operating system information, search for the corresponding component version in a preset component library, and determine the corresponding operating system capability component;

[0011] Based on the operating system capability component, establish a remote debugging connection with the client;

[0012] When a user debugging operation is received, parse the user debugging operation into a corresponding remote debugging process and send it to the client for parsing and execution.

[0013] In one embodiment, the steps of visually displaying and updating the process exception information and dynamically adjusting the remote debugging process when the process exception information returned by the client is received include:

[0014] When the process exception information returned by the client is received, visually display and update the process exception information;

[0015] After receiving a user update operation, construct an updated first adjacency list;

[0016] Compare the first adjacency list with the second adjacency list of the remote debugging process before the update, and dynamically adjust the remote debugging process.

[0017] In one embodiment, the steps of comparing the first adjacency list with the second adjacency list of the remote debugging process before the update and dynamically adjusting the remote debugging process include:

[0018] Compare each node of the first adjacency list with the second adjacency list of the remote debugging process before the update to determine node addition and deletion information;

[0019] Based on the node addition and deletion information, update the process node object of the client;

[0020] Compare the detailed attribute information of the nodes with the same name in the adjacency lists before and after the update, and reload the parameters for the nodes with updated attribute information;

[0021] Compare the linked list data of the nodes with the same name before and after the update, and update the successor node association relationship for the nodes with updated linked list data.

[0022] In one embodiment, the steps of visually displaying and updating the process exception information and dynamically adjusting the remote debugging process when the process exception information returned by the client is received further include:

[0023] When the process exception information returned by the client is received, visually display the global variable table in the process exception information;

[0024] When it is detected that the global variable table is updated, send the updated variable information to the client in real time.

[0025] In one embodiment, after the step of matching the corresponding operating system capability components according to the operating system information and performing the remote debugging process on the client, it includes:

[0026] Collect various data generated during the acquisition and debugging process, and perform visual display of the real-time debugging progress;

[0027] Dynamically adjust the remote debugging process according to the received parameter adjustment value;

[0028] If an error message appears in the remote debugging process, perform a process retry operation according to the preset operation decision.

[0029] In addition, to achieve the above object, the present application also proposes a cross-operating system remote debugging device, and the cross-operating system remote debugging device includes:

[0030] A detection module, configured to detect the operating system information of the client in response to a remote debugging start instruction;

[0031] A debugging module, configured to match the corresponding operating system capability components according to the operating system information, and execute a remote debugging process on the client;

[0032] An adjustment module, configured to perform visual display and update on the process exception information when receiving the process exception information returned by the client, and dynamically adjust the remote debugging process.

[0033] In addition, to achieve the above object, the present application also proposes a cross-operating system remote debugging device, and the device includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, and the computer program is configured to implement the steps of the cross-operating system remote debugging method as described above.

[0034] In addition, to achieve the above object, the present application also proposes a storage medium, and the storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium, and when the computer program is executed by a processor, the steps of the cross-operating system remote debugging method as described above are implemented.

[0035] In addition, to achieve the above object, the present application also provides a computer program product, and the computer program product includes a computer program, and when the computer program is executed by a processor, the steps of the cross-operating system remote debugging method as described above are implemented.

[0036] One or more technical solutions proposed by the present application have at least the following technical effects:

[0037] In related technologies, it is required that both the design end and the client end run within the same operating system. And when error messages occur during the debugging process, it is necessary to terminate the debugging process or retry the abnormal component by writing code, resulting in low debugging efficiency for cross-operating-system remote debugging. In contrast, the present application adopts a method of detecting and matching the client operating system, establishing a cross-operating-system communication connection with the client, and remotely debugging the client. When receiving the process abnormal information returned by the client, by visually displaying and updating the process abnormal information, the remote debugging process is dynamically adjusted, realizing no need to interrupt debugging, no need to reconstruct the global process, no need to write code to implement process abnormal repair and dynamic debugging, and improving the debugging efficiency of cross-operating-system remote debugging. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] The accompanying drawings herein are incorporated into the specification and form a part of the specification, showing embodiments consistent with the present application, and are used together with the specification to explain the principles of the present application.

[0039] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings required for use in the description of the embodiments or the prior art. Obviously, for those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0040] Figure 1 It is a schematic flowchart provided for the first embodiment of the cross-operating-system remote debugging method of the present application;

[0041] Figure 2 It is a schematic flowchart provided for the second embodiment of the cross-operating-system remote debugging method of the present application;

[0042] Figure 3 It is a schematic flowchart provided for the third embodiment of the cross-operating-system remote debugging method of the present application;

[0043] Figure 4 It is a schematic flowchart provided for the fourth embodiment of the cross-operating-system remote debugging method of the present application;

[0044] Figure 5 It is a schematic block diagram of the module structure of the cross-operating-system remote debugging device according to the embodiment of the present application;

[0045] Figure 6 It is a schematic diagram of the device structure of the hardware operating environment involved in the cross-operating-system remote debugging method according to the embodiment of the present application.

[0046] The realization of the purpose, functional features and advantages of the present application will be further described in conjunction with the embodiments with reference to the accompanying drawings. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0047] It should be understood that the specific embodiments described herein are only used to explain the technical solutions of the present application and are not used to limit the present application.

[0048] To better understand the technical solutions of the present application, the following will be described in detail in conjunction with the accompanying drawings of the specification and specific implementation manners.

[0049] The main solution of the embodiments of the present application is as follows:

[0050] In response to a remote debugging start instruction, detect the operating system information of the client;

[0051] According to the operating system information, match the corresponding operating system capability components, and execute the remote debugging process on the client;

[0052] When receiving the process exception information returned by the client, visually display and update the process exception information, and dynamically adjust the remote debugging process.

[0053] In this embodiment, the present application takes the cross-operating system remote debugging device as the execution subject. For the convenience of description, it will be hereinafter simply referred to as the "device" for specific description.

[0054] Since cross-operating system debugging is not supported in the prior art, the debugging function is limited to within the same operating system and cannot support RPA process debugging between different operating systems such as Windows and Linux. And there is a lack of dynamic update debugging ability in the related technologies, that is, when a process exception occurs during the debugging process, it is necessary to terminate the debugging process or write code to retry the exception component, which results in low efficiency and lack of flexibility in the debugging process, making the debugging efficiency of cross-operating system remote debugging low.

[0055] The present application provides a solution that can achieve process exception repair and dynamic debugging without interrupting debugging, without reconstructing the global RPA process, and without writing code, significantly improving the debugging efficiency. The present application reduces the debugging threshold for non-technical users by visually displaying the process exception information and the global variable table. By discovering and fixing the possible exception risks in the actual execution process in advance, the execution success rate and implementation efficiency of the RPA process are improved, further promoting the automation and digital transformation of enterprises.

[0056] Based on this, the embodiments of the present application provide a cross-operating system remote debugging method, referring to Figure 1 , Figure 1 is the flow diagram of the first embodiment of the cross-operating system remote debugging method of the present application.

[0057] In this embodiment, the cross-operating system remote debugging method includes steps SS10 to SS30:

[0058] Step SS10: Detect the operating system information of the client in response to a remote debugging start instruction.

[0059] It should be noted that Robotic Process Automation (RPA) is a technology that uses software robots (also known as digital employees) to simulate the operations of human users and automatically execute repetitive business process tasks. RPA technology can work across applications and systems, improving the efficiency and accuracy of business processes.

[0060] The remote debugging is a computer programming technique that allows developers to debug software applications on a remote computer, identify and fix errors in the software. It usually involves running a debugger on the remote machine and controlling and monitoring it on the local machine.

[0061] The operating system (OS) is the core software that manages and controls computer hardware and software resources, provides an interface between the user and the computer, and is responsible for executing the instructions of computer programs. The client is a remote computer or device that runs the RPA process, receives debugging instructions from the designer side, and executes the corresponding RPA process.

[0062] The operating system information is data that identifies a specific operating system version, type, and configuration. The remote debugging start instruction is a command issued by the user to trigger the start of the remote debugging process, instruct the device to prepare the corresponding debugging environment, and establish a connection with the client.

[0063] It can be understood that during the remote debugging process, the detection of operating system information directly affects the feasibility and efficiency of remote debugging. Different operating systems have different system calls, file paths, and user permission models. Therefore, correct detection of operating system information can ensure that the debugging tools and processes can adapt to the target environment and avoid compatibility issues.

[0064] Step SS20: According to the operating system information, match the corresponding operating system capability components and execute the remote debugging process on the client.

[0065] It should be noted that the operating system capability components refer to software modules designed for different operating systems, which contain the functions and instructions required for remote debugging of different operating systems. By matching the capability components, remote debugging of different operating systems between the design end and the client can be achieved. The remote debugging process refers to a series of operations performed on the remote client to identify and fix errors in the software, including but not limited to starting a debugging session, sending and receiving debugging instructions, monitoring the debugging status, etc.

[0066] It is understandable that before remote debugging is started, it is first necessary to obtain the operating system information of the client. This is completed through an automated detection mechanism. Once the operating system information is obtained, the device will select a matching capability component from a preset component library based on this information. The component library is a collection containing components corresponding to various operating systems and is used to support remote debugging of different operating systems. After matching the appropriate capability component, the next step is to establish a remote debugging connection with the client. This may involve configuring network communication protocols, such as using the WebSocket protocol or other remote communication technologies. After the connection is established, the remote debugging process begins to execute. This includes sending debugging instructions to the client, receiving the status and feedback information of the client, and adjusting the debugging strategy as needed.

[0067] In a feasible implementation manner, step SS20 may include:

[0068] According to the operating system information, search for the corresponding component version in the preset component library to determine the corresponding operating system capability component;

[0069] Based on the operating system capability component, establish a remote debugging connection with the client;

[0070] When a user debugging operation is received, parse the user debugging operation into a corresponding remote debugging process and send it to the client for parsing and execution.

[0071] It should be noted that the preset component library refers to a collection storing various operating system capability components, and these components are designed to support remote debugging of different operating systems. The component library is pre-configured by the system and contains a series of capability components optimized for different operating systems. The component version refers to the specific release version of the operating system capability component, corresponding to a specific operating system or a specific version of the operating system. The component version ensures the compatibility between the remote debugging tool and the client operating system. The remote debugging connection refers to the communication link established between the local debugger and the remote client, which allows debugging instructions and data to be transmitted between the two. This connection is achieved through specific communication protocols and network technologies.

[0072] The user debugging operation refers to a series of actions performed by the user during the debugging process, including but not limited to setting breakpoints, stepping through, viewing variables, etc. These operations need to be parsed by the remote debugging system and converted into specific debugging instructions. The remote debugging process refers to converting the user debugging operation into a series of instructions and steps that can be executed on the remote client. This process includes parsing the user operation, generating corresponding debugging instructions, sending the instructions to the client, and executing these instructions on the client.

[0073] Exemplarily, referring to Figure 2, taking the operating system environment where the debugging machine is located as the communication target. When the user starts remote debugging, the remote communicator 301 that sends the debugging instruction identifies the operating system 305 of the client by calling the system detection module 302, and then completes the communication between systems through the call of the capability component 304 matching and the WebSocket module 303.

[0074] It can be understood that when the detected client operating system information is sent to the capability center, and the capability center stores the component versions required for each operating system, the capability center will match the corresponding capability component according to the client operating system information.

[0075] The cross-operating system communication module sends a request at the instruction sending side, which contains communication protocol information, to request to establish a communication connection with the instruction receiving side. After receiving the request, the instruction receiving side returns a status code and switches to the corresponding communication protocol to establish a communication connection between the two sides.

[0076] Through the above steps, obtain the operating system type, obtain the capability components that match the system, and establish two-way remote communication between the two sides across operating systems.

[0077] After establishing two-way remote communication between two machines through the communication protocol, it is possible to support sending debugging instructions from the designer on different operating systems to the client for debugging. For example, sending debugging instructions from the Windows system to the Linux system, or sending debugging instructions from the Linux system to the Windows system.

[0078] Through this process, the present application realizes seamless remote debugging across operating systems, improves the debugging efficiency and success rate of the RPA process. It can not only reduce problems caused by operating system differences, but also speed up the problem-solving speed and improve the overall automation level. In addition, this method also reduces the dependence on professional technical personnel, enabling more non-technical users to participate in the remote debugging process, and further expanding the application scope of the RPA technology.

[0079] Step SS30, when receiving the process exception information returned by the client, visually display and update the process exception information, and dynamically adjust the remote debugging process.

[0080] It should be noted that the process exception information refers to the specific data returned by the client during the remote debugging process, indicating any unexpected status or error encountered during the execution of the RPA process. These information are crucial for diagnosing problems and taking corrective measures. Visual display means presenting complex or abstract data to users in an intuitive way through a graphical interface so that users can more easily understand and analyze these data.

[0081] It is understandable that during remote debugging, the client may return process exception information for various reasons. Such information may include error codes, exception locations, affected variables and statuses, etc. The device first needs to accurately receive this information and display it to the user in an intuitive manner through a graphical interface, enabling the user to quickly locate the problem. After analyzing the exception information, the user may perform some corrective operations, such as adjusting the process logic, modifying parameter values, etc. The device needs to capture these update operations and feedback the updated information to the visual display to ensure that the user always sees the latest process status.

[0082] Based on the user's update operations on the process exception information, the device will dynamically adjust the remote debugging process. This may involve modifying the execution path of the process, reallocating resources, adjusting parameter settings, etc. The purpose of dynamic adjustment is to enable the process to adapt to new conditions, quickly resume normal execution, or optimize execution efficiency.

[0083] In a feasible implementation manner, step SS30 may include:

[0084] When receiving the process exception information returned by the client, perform visual display and update on the process exception information;

[0085] After receiving the user's update operation, construct an updated first adjacency list;

[0086] Compare the first adjacency list with the second adjacency list of the remote debugging process before the update, and dynamically adjust the remote debugging process.

[0087] It should be noted that the process exception information refers to the specific data returned by the client regarding the abnormal execution of the RPA process during remote debugging. This data includes error codes, exception locations, affected variables and statuses, etc., and is used to diagnose and fix problems in the process.

[0088] The visual display refers to presenting complex data and information to the user in an intuitive manner through a graphical interface, enabling the user to more easily understand and analyze this data. The update operation refers to the actions taken by the user to correct errors or exceptions in the RPA process, including modifying the process logic, adjusting parameter values, etc. The first adjacency list refers to the adjacency list of the RPA process reconstructed according to the user's update operation, reflecting the updated process structure, including each node and the connection relationships between them. The second adjacency list refers to the adjacency list of the remote debugging process before the update, recording the structure and the associated status between nodes before the process update, and is used for comparative analysis with the first adjacency list.

[0089] It is understandable that when the client encounters an exception during the execution of the RPA process, the device will receive this exception information. To help users better understand and solve problems, the device visualizes this exception information and allows users to update the exception information. This visual display not only improves the efficiency of problem diagnosis but also lowers the technical threshold for problem-solving.

[0090] After the user analyzes and modifies the exception information, the device needs to construct a new adjacency list based on the user's update operation, that is, the first adjacency list. This adjacency list reflects the changes made by the user to the process, including newly added nodes, deleted nodes, and new connection relationships between nodes.

[0091] To achieve dynamic adjustment of the process, the device compares the updated first adjacency list with the second adjacency list before the update. Through comparative analysis, the device can determine which parts of the process have changed, including the addition, deletion of nodes or modification of attributes, and the change of connection relationships between nodes. Based on this information, the device can dynamically adjust the remote debugging process to reflect the changes made by the user and ensure that the process can be correctly executed according to the updated logic.

[0092] Exemplarily, referring to Figure 3 , this application supports debugging by implementing two-way communication between the designer side and the client side, and sending and receiving debugging instructions between the two parties. The remote debugging function is completed through the parameter management module 402, the real-time monitoring module 403, and the instruction generation and parsing module 404.

[0093] The operation targets are divided into the designer 405 and the client 406. The user designs the process on the designer of the local machine, and the client on the remote machine runs the process. At this time, the user can initiate a remote debugging request from the local designer to the remote client, and the function of remotely debugging the client can be realized on the local designer.

[0094] When the user enables remote debugging, the instruction generation and parsing module 404 is responsible for sending and receiving debugging instructions and performing corresponding parsing and execution.

[0095] The instruction generation and parsing module 404 consists of instruction generation, instruction sending, and instruction parsing. The designer generates corresponding debugging instructions according to the user's debugging operations, and these instructions can include start debugging, next step, next breakpoint, retry, skip, step out, and step over instructions:

[0096] 1. Next step instruction: When starting debugging from the first breakpoint, clicking the next step instruction, the process will go to the adjacent next component of the current breakpoint component for execution.

[0097] 2. Next Breakpoint Instruction: When starting debugging from the first breakpoint, clicking the next breakpoint instruction will cause the process to execute at the next breakpoint. If there is no next breakpoint, the process will execute from the current breakpoint until the end of the process.

[0098] 3. Retry: When starting debugging from the first breakpoint, if the current component debugging fails and the user modifies the component parameters, the user can click the retry instruction, and the debugging will restart from the current faulty component and continue to execute according to the component with the updated parameters.

[0099] 4. Skip: When starting debugging from the first breakpoint, if the current debugging component fails, clicking the skip instruction will cause the process to skip the current faulty component and continue to execute the next component.

[0100] 5. Step Out: When the debugging runs into a nested component, clicking the step out instruction will cause the process to execute the remaining part of the nested component and pause after returning to the next-level component.

[0101] 6. Step Over: When the debugging runs into a nested component, clicking the step over instruction will cause the process to execute within the current nested component and then pause.

[0102] The instruction sending module sends the above-generated instructions to the remote client through the bidirectional communication channel. After receiving the instructions, the client parses them and performs the corresponding operations, and at the same time feeds back the execution results to the designer through the bidirectional communication channel.

[0103] Debugging will be started for the debugging instructions sent by the user in the previous steps. The parameter management module 402 is responsible for creating, updating, and storing all relevant parameters during the debugging process.

[0104] When an exception occurs during the process execution, the client pauses the current process and saves the process context, aggregating the exception cause, exception node, node input parameters, and global variable table. Subsequently, each exception information is fed back to the designer side; the designer side provides a visual parameter display and update interface to display the exception information and process context information, so that parameter information can be modified and updated in real time on the interface without any coding operations, greatly reducing the threshold for exception troubleshooting and process debugging. Business personnel without an IT background can also perform exception debugging and repair; by comparing the flowchart nodes, associations between nodes, node input and output parameters, and global variable tables, the modified nodes are identified and dynamically reconstructed. Compared with the full-load reconstruction of the process, the time and memory resource consumption can be greatly reduced. Since the difficulty of parsing and comparing the node information and node association relationships in the RPA flowchart increases with the complexity of the business process, the efficiency of directly comparing and analyzing the RPA processes before and after modification is relatively low.

[0105] This application proposes a method for comparing the context information of RPA processes based on an adjacency list. An adjacency list is constructed for the RPA flowchart, and then the changes in the process structure and component nodes are compared based on the adjacency list to identify the modification items in the previous step - dynamic modification of the process and perform dynamic updates.

[0106] In a feasible implementation, the steps of dynamically adjusting the remote debugging process by comparing the first adjacency list with the second adjacency list of the remote debugging process before update include:

[0107] Compare each node of the first adjacency list with the second adjacency list of the remote debugging process before update to determine the node addition and deletion information;

[0108] Based on the node addition and deletion information, update the process node object of the client;

[0109] Compare the detailed attribute information of the nodes with the same name in the adjacency lists before and after update, and reload the parameters for the nodes with updated attribute information;

[0110] Compare the linked list data of the nodes with the same name before and after update, and update the successor node association relationship for the nodes with updated linked list data.

[0111] It can be understood that the node addition and deletion information refers to the information of newly added nodes or deleted nodes identified when comparing the first adjacency list and the second adjacency list. These information indicate the changes in the process structure and are crucial for updating the process node object of the client. The process node object refers to the software object representing each node in the RPA process on the client. These objects contain the attributes, behaviors, and association information with other nodes of the nodes. The node detailed attribute information refers to the specific settings and parameters of the nodes, such as input parameters, output parameters, execution conditions, etc. These attribute information are crucial for the correct execution of the nodes and the interaction with other nodes. The linked list data refers to the sequence data used to represent the connection relationship between nodes in the adjacency list. The change in the linked list data reflects the change in the association relationship between nodes. The successor node association relationship refers to the relationship that points to the next execution node after a node is executed. This association relationship defines the execution order and logic of the process.

[0112] Exemplarily, referring to Figure 4 , compare the flowchart nodes, the associations between nodes, the input and output parameters of nodes, and the global variable table, identify and dynamically reconstruct the modified nodes. Compared with the full - scale loading and reconstruction of the process, it can significantly reduce the consumption of time and memory resources. Since the difficulty of parsing and comparing the node information and node association relationships in the RPA flowchart increases with the complexity of the business process, the efficiency of directly comparing and analyzing the RPA processes before and after modification is relatively low.

[0113] This application proposes a method for comparing the context information of RPA processes based on an adjacency list. An adjacency list is constructed for the RPA flow chart, and then the changes in the process structure and component nodes are compared according to the adjacency list, so as to identify the modification items in the previous step - dynamic modification of the process and perform dynamic updates:

[0114] Parse the nodes of the flow chart, and construct an RPA adjacency list according to the order of each node and the branch dependency relationship. Each node in the adjacency list is a component node of the flow chart. Each node stores the information of the successor nodes of the current node in the form of a single linked list. For example, if the component node B is included in the RPA flow chart, and the successor nodes of the component node B include the component node C and the component node D, then the component B is first constructed in the adjacency list, and the information of the component B is stored at the same time, and the component C and the component D are stored in its single linked list;

[0115] Compare the RPA adjacency list from three dimensions: the node list, the node information, and the association between nodes, and analyze the modification items of the flow chart:

[0116] First, for the change situation of the node list, it is necessary to traverse the node lists of the adjacency lists before and after the modification respectively, and compare each node of the two adjacency lists, so as to identify the addition and deletion of nodes in the flow chart. Based on the addition and deletion of nodes in the flow chart, update the process context loaded in the memory on the client side, and dynamically delete or generate process node objects.

[0117] In the previous step a, the addition and deletion of nodes have been identified. For the situation of node modification, it is necessary to further compare the detailed information of the nodes with the same name.

[0118] The comparison of node information needs to analyze the key attributes of the RPA component. For example, compare the basic parameters, input parameters, and output parameters of the RPA component to identify whether each attribute of the node has been updated. If it has not been updated, skip it; if it has been updated, reload the basic parameters, input parameters, or output parameters to achieve dynamic update of the node.

[0119] In the previous steps a and b, the addition, deletion, and modification of a single node have been compared and dynamically updated. However, the RPA flow chart contains association relationships such as order and branches among its nodes. And the difficulty of parsing the node association relationship of the flow chart will increase with the complexity of its process. Here, the linked lists of each node in the adjacency list will be compared and analyzed to identify the changes in the node associations.

[0120] Traverse the node lists of the adjacency lists before and after the modification respectively to obtain the nodes with the same name, and then compare the linked list data under the nodes with the same name. If the linked list data in the nodes with the same name is the same, it is considered that the node has not been modified, and the node is skipped; if there are addition, deletion, or modification situations in the linked list under the nodes with the same name, it is considered that there are changes in the successor nodes of the node, and the successor nodes associated with the node are dynamically updated.

[0121] For example, in the comparison between the modified adjacency list and the initial adjacency list mentioned above, the successor node of component C is changed from component E to component G, the successor node of component D is changed from component F to component F2, and the successor node of component F2 is component G.

[0122] It can be understood that the device determines which nodes in the process are added or deleted by comparing the updated first adjacency list and the second adjacency list before the update, ensuring that the device can accurately identify changes in the process structure.

[0123] Based on the node addition and deletion information, the device will update the process node objects on the client. For the newly added nodes, the device will create new node objects on the client; for the deleted nodes, the device will remove the corresponding node objects, ensuring that the process structure on the client is consistent with the updated process structure.

[0124] The device will compare the detailed attribute information of the nodes with the same name in the adjacency list before and after the update. For the nodes with changed attribute information, the device will reload the parameters, ensuring that the nodes can execute according to the latest attribute settings and maintaining the correctness and effectiveness of the process.

[0125] The device will compare the linked list data of the nodes with the same name before and after the update. For the nodes with changed linked list data, the device will update the associated relationship of their successor nodes. Ensuring that the execution order and logical relationship between nodes are correctly maintained, and the coherence of the process can be maintained even after the process structure changes.

[0126] In a feasible implementation manner, step SS30 may further include:

[0127] Receiving the process exception information returned by the client and visually displaying the global variable table in the process exception information;

[0128] When it is detected that the global variable table is updated, the updated variable information is sent to the client in real time.

[0129] It should be noted that the global variable table refers to a set of variables defined in the RPA process that can be accessed and modified throughout the process or within a specific range, and is usually used to store data across multiple process steps or nodes.

[0130] It is understandable that when the client encounters an exception during the execution of the RPA process, the device will receive this exception information. The device will extract the global variable table in the exception information and display it to the user in an intuitive manner through a graphical interface. This visual display may include information such as the current value, data type, and scope of the variables, enabling the user to quickly locate the problem and make necessary modifications. After analyzing the exception information, the user may modify the variables in the global variable table to correct the problem in the process. The device will detect these update operations and immediately send the updated variable information to the client in real time. This real-time update ensures that the client can receive the latest variable information and perform subsequent operations based on this information. Real-time updating of the global variable table is crucial for ensuring the continuity and consistency of the RPA process. During remote debugging, any modification to the global variables may affect the execution logic and results of the process. Therefore, the device needs to respond quickly to these changes and convey the updated information to the client in a timely manner.

[0131] Exemplarily, the global variable table in the RPA process stores the variable information required for the input and output of each node of the RPA process. When the process execution is abnormal, it supports the user to modify the global variable table to correct the process. This application displays the global variable table in a visual form, and only needs to input through the interface to complete the real-time update of the variable table;

[0132] a. Visual display of the global variable table. When the process execution is abnormal, generate the RPA global variable table information according to the current RPA process context, and at the same time visually display the global variable table in the form of a list;

[0133] b. Modification of the global variable table. The user can modify any variable value in the global variable table, and can also perform addition and deletion operations on the variables;

[0134] Real-time update of the global variable table. The designer side monitors the modification situation of the variable table. When any variable is changed, the changed variable information is sent to the client in real time, and the client updates the variable table in real time.

[0135] Through this process, this application realizes the real-time monitoring and dynamic adjustment of the RPA process, greatly improving the flexibility and robustness of the process. This method can not only quickly respond to exceptions in the process execution, but also optimize the process according to the user's real-time feedback, thereby improving the execution efficiency and success rate of the RPA process. In addition, this dynamic adjustment mechanism also provides a non-technical user with an intuitive and effective means of process modification, further expanding the application scope of the RPA technology and promoting the process of enterprise automation and digital transformation.

[0136] This embodiment provides a cross - operating - system remote debugging method. By detecting and matching the client operating system, a cross - operating - system communication connection with the client is established for remote debugging of the client. When receiving the process exception information returned by the client, through visual display and update of the process exception information, the remote debugging process is dynamically adjusted, realizing remote debugging across operating systems without interrupting the debugging, without reconstructing the global process, without writing code to repair process exceptions and dynamic debugging, thus improving the debugging efficiency of cross - operating - system remote debugging.

[0137] In a feasible implementation manner, after the step of matching the corresponding operating - system capability component according to the operating - system information and performing the remote debugging process on the client, it includes:

[0138] Collect various types of data generated during the debugging process and perform visual display of the real - time debugging progress;

[0139] Dynamically adjust the remote debugging process according to the received parameter adjustment value;

[0140] If an error message appears in the remote debugging process, perform a process retry operation according to the preset operation decision.

[0141] It should be noted that the debugging process data refers to various types of information generated during the remote debugging process, including execution status, execution result, error prompt, etc. These data are crucial for monitoring and analyzing the debugging progress. Real - time debugging progress refers to the ability of the device to immediately reflect the current debugging status and results during the debugging process, which is very important for users to timely understand the debugging situation and make corresponding decisions. The parameter adjustment value refers to the new value after the user modifies the parameters in the RPA process during the remote debugging process. These values may affect the execution logic and results of the process. The error message refers to the signal or data indicating problems detected by the device during the remote debugging process. These messages indicate specific problems that need attention and solution. The preset operation decision refers to the operation or decision that is predefined in the device design to guide the actions to be taken in specific situations, such as automatically retrying the process when encountering a specific error.

[0142] It is understandable that the device continuously collects various types of data during remote debugging, including the execution status of the process, results, and any error messages generated. These data are used to update the visual display of the debugging progress in real time, enabling users to intuitively track the debugging process and make decisions based on the displayed information. During the debugging process, users may adjust the parameters in the RPA process as needed. The device will receive these parameter adjustment values and dynamically adjust the remote debugging process based on these values to ensure that the process can be executed according to the user's intentions. When error messages occur in the remote debugging process, the device will determine whether a process retry operation is required based on preset operation decisions. These preset decisions may include error types, error severity levels, and retry policies set by the user. The system will automatically execute these decisions to reduce user intervention and improve debugging efficiency.

[0143] Exemplarily, referring to Figure 3 , when starting the debugging process, the real-time monitoring module 403 will collect various types of data generated during the debugging process, including messages such as the execution status, execution results, and error messages, to ensure that users can clearly understand the current debugging progress during the debugging process. When users encounter exceptions during the debugging process, the client will immediately send back to the designer end through the channel the abnormal components and the reasons for the exceptions during the debugging process, and the monitoring module will display the transmitted information to the user at the designer end through the result feedback module; users will then adjust the parameters of the faulty components based on the messages returned by the monitoring module, and the adjusted parameters will be returned to the client through the parameter management module.

[0144] When the designer starts debugging, the process file information is transmitted to the client through the two-way communication channel, and the parameter management module 402 initializes all the parameters in the process file during communication. In this way, the file parameters at both ends of the designer and the client are kept consistent, and during the debugging process, users can dynamically adjust the parameters based on the data fed back by the real-time monitoring module. When users encounter abnormal situations during the debugging process, they can perform a process retry operation.

[0145] It is understandable that through this process, the present application realizes real-time monitoring, dynamic adjustment, and intelligent error handling of the RPA process, greatly improving the flexibility, adaptability, and robustness of the process.

[0146] It should be noted that the above examples are only for understanding the present application and do not constitute a limitation on the cross-operating system remote debugging method of the present application. Based on this technical concept, more forms of simple transformations are within the protection scope of the present application.

[0147] The present application also provides a cross-operating system remote debugging device. Please refer to Figure 5 , the cross-operating system remote debugging device includes:

[0148] The detection module 10 is configured to detect the operating system information of the client in response to a remote debugging start instruction;

[0149] The debugging module 20 is configured to match the corresponding operating system capability components according to the operating system information and execute a remote debugging process on the client;

[0150] The adjustment module 30 is configured to, when receiving process exception information returned by the client, visually display and update the process exception information and dynamically adjust the remote debugging process.

[0151] And / or, the debugging module 20 includes:

[0152] The first determination module is configured to find the corresponding component version in a preset component library according to the operating system information and determine the corresponding operating system capability components;

[0153] The first connection module is configured to establish a remote debugging connection with the client based on the operating system capability components;

[0154] The first sending module is configured to, when receiving a user debugging operation, parse the user debugging operation into a corresponding remote debugging process and send it to the client for parsing and execution.

[0155] And / or, the adjustment module 30 includes:

[0156] The first update module is configured to, when receiving process exception information returned by the client, visually display and update the process exception information;

[0157] The first construction module is configured to construct an updated first adjacency list after receiving a user update operation;

[0158] The first comparison module is configured to compare the first adjacency list with the second adjacency list of the remote debugging process before update and dynamically adjust the remote debugging process.

[0159] And / or, the first comparison module includes:

[0160] The second comparison module is configured to compare each node of the first adjacency list with the second adjacency list of the remote debugging process before update to determine node addition and deletion information;

[0161] The second update module is configured to update the process node object of the client based on the node addition and deletion information;

[0162] The third comparison module is configured to compare the detailed attribute information of the nodes with the same name in the adjacency list before and after update and reload the parameters of the nodes with updated attribute information;

[0163] A fourth comparison module, configured to compare the linked list data of nodes with the same name before and after the update, and update the successor node association relationship of the nodes with updated linked list data.

[0164] And / or, the adjustment module 30 further includes:

[0165] A first display module, configured to receive the process exception information returned by the client and visually display the global variable table in the process exception information;

[0166] A second sending module, configured to, when detecting that the global variable table is updated, send the updated variable information to the client in real time.

[0167] And / or, the cross-operating system remote debugging device includes:

[0168] A first acquisition module, configured to acquire various types of data generated during the debugging process and visually display the real-time debugging progress;

[0169] A first adjustment module, configured to dynamically adjust the remote debugging process according to the received parameter adjustment value;

[0170] A first retry module, configured to, if an error message appears in the remote debugging process, perform a process retry operation according to a preset operation decision.

[0171] The cross-operating system remote debugging device provided by the present application adopts the cross-operating system remote debugging method in the above embodiment, and can solve the technical problem of low debugging efficiency in cross-operating system remote debugging. Compared with the prior art, the beneficial effects of the cross-operating system remote debugging device provided by the present application are the same as those of the cross-operating system remote debugging method provided by the above embodiment, and other technical features in the cross-operating system remote debugging device are the same as the features disclosed in the above embodiment method, and will not be elaborated here.

[0172] The present application provides a cross-operating system remote debugging device, and the cross-operating system remote debugging device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein, the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the cross-operating system remote debugging method in the first embodiment above.

[0173] Next, refer to Figure 6, which shows a schematic structural diagram of a cross - operating - system remote debugging device suitable for implementing the embodiments of the present application. The cross - operating - system remote debugging device in the embodiments of the present application may include, but is not limited to, mobile terminals such as mobile phones, tablet computers, laptop computers, digital broadcast receivers, PDAs (Personal Digital Assistants), PMPs (Portable Media Players), in - vehicle terminals (such as in - vehicle navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. Figure 6 The shown cross - operating - system remote debugging device is merely an example and should not impose any limitations on the functions and usage scope of the embodiments of the present application.

[0174] As Figure 6 shown, the cross - operating - system remote debugging device may include a processing device 1001 (such as a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to the program stored in the read - only memory (ROM: Read Only Memory) 1002 or the program loaded from the storage device 1003 into the random access memory (RAM: Random Access Memory) 1004. In the RAM 1004, various programs and data required for the operation of the cross - operating - system remote debugging device are also stored. The processing device 1001, the ROM 1002, and the RAM 1004 are connected to each other through a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Generally, the following systems may be connected to the I / O interface 1006: an input device 1007 including, for example, a touch screen, a touchpad, a keyboard, a mouse, an image sensor, a microphone, an accelerometer, a gyroscope, etc.; an output device 1008 including, for example, a liquid crystal display (LCD: Liquid Crystal Display), a speaker, a vibrator, etc.; a storage device 1003 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 1009. The communication device 1009 can allow the cross - operating - system remote debugging device to communicate with other devices wirelessly or wire - line to exchange data. Although the figure shows a cross - operating - system remote debugging device with various systems, it should be understood that it is not required to implement or have all the shown systems. Instead, more or fewer systems may be implemented or had.

[0175] In particular, according to the embodiments disclosed in the present application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present application include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program contains program codes for executing the methods shown in the flowcharts. In such an embodiment, the computer program can be downloaded and installed from a network through a communication device, or installed from a storage device 1003, or installed from a ROM 1002. When the computer program is executed by a processing device 1001, the above functions defined in the methods of the embodiments disclosed in the present application are executed.

[0176] The cross-operating system remote debugging device provided by the present application adopts the cross-operating system remote debugging method in the above embodiments, and can solve the technical problem of low debugging efficiency in cross-operating system remote debugging. Compared with the prior art, the beneficial effects of the cross-operating system remote debugging device provided by the present application are the same as those of the cross-operating system remote debugging method provided by the above embodiments, and other technical features in the cross-operating system remote debugging device are the same as the features disclosed in the method of the previous embodiment, and will not be elaborated here.

[0177] It should be understood that each part disclosed in the present application can be implemented by hardware, software, firmware or a combination thereof. In the description of the above embodiments, specific features, structures, materials or characteristics can be combined in a suitable manner in any one or more embodiments or examples.

[0178] As described above, the above are only specific embodiments of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art can easily think of changes or substitutions within the technical scope disclosed in the present application, and all should be covered by the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

[0179] The present application provides a computer-readable storage medium, having computer-readable program instructions (i.e., computer programs) stored thereon, and the computer-readable program instructions are used to execute the cross-operating system remote debugging method in the above embodiments.

[0180] The computer-readable storage medium provided by the present application may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or components, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections with one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM) or flash memory, optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the above. In this embodiment, the computer-readable storage medium may be any tangible medium that contains or stores a program, and the program may be used by or in combination with an instruction execution system, device, or component. The program code contained on the computer-readable storage medium may be transmitted using any appropriate medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

[0181] The above computer-readable storage medium may be included in a cross-operating system remote debugging device; or it may exist separately and not be assembled into the cross-operating system remote debugging device.

[0182] The above computer-readable storage medium carries one or more programs. When the one or more programs are executed by the cross-operating system remote debugging device, the cross-operating system remote debugging device is caused to:

[0183] In response to a remote debugging start instruction, detect the operating system information of the client;

[0184] According to the operating system information, match the corresponding operating system capability components and execute a remote debugging process on the client;

[0185] When receiving process exception information returned by the client, visually display and update the process exception information, and dynamically adjust the remote debugging process.

[0186] Computer program code for performing the operations of this application can be written in one or more programming languages or combinations thereof. The above-mentioned programming languages include object-oriented programming languages such as Java, Smalltalk, C++, and also include conventional procedural programming languages such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, executed as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (for example, by using an Internet service provider to connect through the Internet).

[0187] The flowcharts and block diagrams in the accompanying drawings illustrate the possible architectures, functions, and operations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in the flowchart or block diagram may represent a module, a program segment, or a part of the code, and this module, program segment, or part of the code contains one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the blocks may occur in a different order than that marked in the accompanying drawings. For example, two consecutively represented blocks can actually be executed substantially in parallel, and they can sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagram and / or flowchart, and the combination of blocks in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system for performing the specified functions or operations, or can be implemented by a combination of dedicated hardware and computer instructions.

[0188] The modules described in the embodiments of this application can be implemented in software or in hardware. Among them, the name of the module does not constitute a limitation on the unit itself in some cases.

[0189] The readable storage medium provided by this application is a computer-readable storage medium. The computer-readable storage medium stores computer-readable program instructions (i.e., computer programs) for performing the above-mentioned cross-operating system remote debugging method, and can solve the technical problem of low debugging efficiency in cross-operating system remote debugging. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided by this application are the same as those of the cross-operating system remote debugging method provided in the above embodiments, and will not be elaborated here.

[0190] The present application also provides a computer program product, including a computer program which, when executed by a processor, implements the steps of the cross-operating system remote debugging method as described above.

[0191] The computer program product provided by the present application can solve the technical problem of low debugging efficiency in cross-operating system remote debugging. Compared with the prior art, the beneficial effects of the computer program product provided by the present application are the same as those of the cross-operating system remote debugging method provided by the above embodiments, and will not be elaborated here.

[0192] The above are only partial embodiments of the present application, and thus do not limit the patent scope of the present application. Any equivalent structural transformation made under the technical concept of the present application by using the content of the specification and drawings of the present application, or any direct / indirect application in other related technical fields, is included in the patent protection scope of the present application.

Claims

1. A cross - operating - system remote debugging method, characterized in that, The described method includes: Detecting the operating system information of the client in response to a remote debugging start instruction; Matching corresponding operating system capability components according to the operating system information, and executing a remote debugging process on the client; When receiving process exception information returned by the client, visually displaying and updating the process exception information, and dynamically adjusting the remote debugging process.

2. The method according to claim 1, characterized in that, The step of matching corresponding operating system capability components according to the operating system information and executing a remote debugging process on the client includes: Searching for the corresponding component version in a preset component library according to the operating system information to determine the corresponding operating system capability components; Based on the operating system capability components, establishing a remote debugging connection with the client; When receiving a user debugging operation, parsing the user debugging operation into a corresponding remote debugging process and sending it to the client for parsing and execution.

3. The method according to claim 1, characterized in that The step of visually displaying and updating the process exception information and dynamically adjusting the remote debugging process when receiving process exception information returned by the client includes: When receiving process exception information returned by the client, visually displaying and updating the process exception information; After receiving a user update operation, constructing an updated first adjacency list; Comparing the first adjacency list with a second adjacency list of the remote debugging process before the update, and dynamically adjusting the remote debugging process.

4. The method according to claim 3, wherein The step of comparing the first adjacency list with the second adjacency list of the remote debugging process before the update and dynamically adjusting the remote debugging process includes: Comparing each node of the first adjacency list with the second adjacency list of the remote debugging process before the update to determine node addition and deletion information; Based on the node addition and deletion information, updating the process node object of the client; Comparing the detailed attribute information of the nodes with the same name in the adjacency lists before and after the update, and reloading the parameters for the nodes with updated attribute information; Comparing the linked list data of the nodes with the same name before and after the update, and updating the successor node association relationship for the nodes with updated linked list data.

5. The method according to claim 1, characterized in that, The step of visually displaying and updating the process exception information and dynamically adjusting the remote debugging process when receiving process exception information returned by the client further includes: Receiving process exception information returned by the client, and visually displaying the global variable table in the process exception information; When detecting an update to the global variable table, sending the updated variable information to the client in real time.

6. The method according to claim 1, wherein After the step of matching corresponding operating system capability components according to the operating system information and executing a remote debugging process on the client, it includes: Collecting various types of data generated during the debugging process and visually displaying the real-time debugging progress; Dynamically adjusting the remote debugging process according to the received parameter adjustment value; If an error message appears in the remote debugging process, performing a process retry operation according to a preset operation decision.

7. A cross-operating system remote debugging device, characterized in that, The device includes: A detection module for detecting the operating system information of the client in response to a remote debugging start instruction; A debugging module for matching corresponding operating system capability components according to the operating system information and executing a remote debugging process on the client; An adjustment module, configured to visually display and update the process exception information and dynamically adjust the remote debugging process when receiving the process exception information returned by the client.

8. A cross-operating system remote debugging device, characterized in that The device includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, the computer program being configured to implement the steps of the cross-operating system remote debugging method according to any one of claims 1 to 6.

9. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the steps of the cross-operating system remote debugging method according to any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that, The computer program product includes a computer program, and when the computer program is executed by a processor, the steps of the cross-operating system remote debugging method according to any one of claims 1 to 6 are implemented.

Images