CN115080443A

CN115080443A - RPA remote debugging method, device, equipment and medium

Info

Publication number: CN115080443A
Application number: CN202210805787.3A
Authority: CN
Inventors: 饶玉田; 黄创盛
Original assignee: Northking Information Technology Co ltd
Current assignee: Northking Information Technology Co ltd
Priority date: 2022-07-08
Filing date: 2022-07-08
Publication date: 2022-09-20

Abstract

The embodiment of the invention discloses a method, a device, equipment and a medium for remote debugging based on RPA. The method is applied to a designer and comprises the following steps: sending flow file data to be debugged to an execution machine through a preset named pipeline, wherein the flow file data comprises at least one component to be debugged; sending a debugging instruction to an execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged; and acquiring information of the component to be debugged to be operated or being operated from the execution machine, and executing debugging function operation according to the information of the component to be debugged. According to the technical scheme, cross-process debugging can be realized by a single machine, and cross-machine and cross-remote network remote debugging can also be realized; the limitation of the debugging of the RPA is effectively solved.

Description

RPA remote debugging method, device, equipment and medium

Technical Field

The invention relates to the technical field of computers, in particular to a method, a device, equipment and a medium for remote debugging based on RPA.

Background

In the course of the actual use of RPA products, debugging of the process operation is generally required in order to debug and verify whether the newly developed process can be executed according to the expected target.

Some existing small parts of RPA products have debugging flow functions, but are only limited to debugging in a designer or a local cross-process environment. In order to reduce the consumption of system hardware resources, some RPA manufacturers separate the design and execution functions of the designers of RPA products to reduce the consumption of hardware resources and improve the stability, but if the execution machine of the execution flow is not local but at the server or far beyond thousand miles, the functional requirement of remote debugging is born.

Disclosure of Invention

The invention provides a method, a device, equipment and a medium for remote debugging based on RPA, which can not only realize cross-process debugging by a single machine, but also realize cross-machine and cross-remote network remote debugging; the limitation of the debugging of the RPA is effectively solved.

According to an aspect of the present invention, there is provided a method for remote debugging based on RPA, the method being performed by a designer, and the method including:

sending flow file data to be debugged to an execution machine through a preset named pipeline, wherein the flow file data comprises at least one component to be debugged;

sending a debugging instruction to an execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged;

and acquiring information of the component to be debugged to be operated or being operated from the execution machine, and executing debugging function operation according to the information of the component to be debugged.

Optionally, after obtaining information of the component to be debugged about to run or running from the execution machine, the method further includes:

judging whether predefined breakpoint information exists in the information of the component to be debugged;

if yes, entering a pause state;

otherwise, sending a continuous debugging instruction to the execution machine.

Optionally, the executing the debugging function operation according to the information of the component to be debugged includes:

acquiring information execution exception instructions of the components to be debugged from the execution machine;

judging whether the abnormity is ignored and continuing to execute;

and if so, sending a continuous debugging instruction to the execution machine.

Optionally, the debug instruction includes a suspend, resume, single step skip, retry, ignore, and abort debug instruction when exception.

Optionally, the method further includes:

an AutoResetEvent object is used to control the running and pausing.

According to another aspect of the present invention, there is provided a method for RPA-based remote debugging, the method being performed by an execution machine and comprising:

monitoring whether a flow task is to be executed or not;

receiving flow file data to be debugged sent by a designer through a pre-configured named pipeline, wherein the flow file data comprises at least one component to be debugged;

receiving a debugging instruction sent by a designer to start loading flow file data to be debugged and execute the component to be debugged;

and sending information of the component to be debugged to be operated or being operated to the designer, and executing according to a debugging instruction sent by the received designer.

Optionally, the sending information of the component to be debugged to be about to run or running to the designer, and executing according to the received debugging instruction sent by the designer, includes:

when the execution of the information with the debugging component is abnormal, an abnormal instruction is sent to a designer;

and executing according to the received continued debugging instruction sent by the designer.

Optionally, the method further includes: the debug instruction comprises retry and ignore;

the retry and the ignored debug instructions are performed by a code launch technique.

According to another aspect of the present invention, there is provided an apparatus for RPA-based remote debugging, configured in a designer, including:

the system comprises a flow file sending module, a debugging module and a debugging module, wherein the flow file sending module is used for sending flow file data to be debugged to an execution machine through a preset named pipeline, and the flow file data comprises at least one component to be debugged;

the debugging instruction sending module is used for sending a debugging instruction to the execution machine so as to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged;

and the component information acquisition module is used for acquiring the information of the component to be debugged to be operated or being operated from the execution machine and executing debugging function operation according to the information of the component to be debugged.

According to another aspect of the present invention, there is provided an apparatus for RPA-based remote debugging, configured in an execution machine, including:

the monitoring module is used for monitoring whether the process task is to be executed or not;

the system comprises a flow file receiving module, a debugging module and a debugging module, wherein the flow file receiving module is used for receiving flow file data to be debugged, which is sent by a designer, through a pre-configured named pipeline, and the flow file data comprises at least one component to be debugged;

the debugging instruction receiving module is used for receiving a debugging instruction sent by the designer so as to start loading the flow file data to be debugged and execute the component to be debugged;

and the debugging instruction execution module is used for sending information of the component to be debugged to be operated or being operated to the designer and executing according to the received debugging instruction sent by the designer.

According to another aspect of the present invention, there is provided an electronic apparatus including:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to enable the at least one processor to perform a method for RPA-based remote debugging according to any of the embodiments of the present invention.

According to another aspect of the present invention, there is provided a computer-readable storage medium storing computer instructions for causing a processor to implement the method for RPA-based remote debugging according to any of the embodiments of the present invention when executed.

According to the technical scheme of the embodiment of the invention, the flow file data to be debugged is sent to the execution machine through a preset named pipeline, wherein the flow file data comprises at least one component to be debugged; sending a debugging instruction to an execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged; and acquiring information of the component to be debugged to be operated or being operated from the execution machine, and executing debugging function operation according to the information of the component to be debugged. According to the technical scheme, cross-process debugging can be realized by a single machine, and cross-machine and cross-remote network remote debugging can also be realized; the limitation of the debugging of the RPA is effectively solved.

It should be understood that the statements in this section do not necessarily identify key or critical features of the embodiments of the present invention, nor do they necessarily limit the scope of the invention. Other features of the present invention will become apparent from the following description.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.

Fig. 1 is a flowchart of a method for RPA-based remote debugging according to an embodiment of the present invention;

fig. 2 is a flowchart of a method for RPA-based remote debugging according to a second embodiment of the present invention;

fig. 3 is a schematic structural diagram of an apparatus for RPA-based remote debugging according to a third embodiment of the present invention;

fig. 4 is a schematic structural diagram of an apparatus for RPA-based remote debugging according to a fourth embodiment of the present invention;

fig. 5 is a schematic structural diagram of an electronic device according to a fifth embodiment of the present invention.

Detailed Description

In order to make those skilled in the art better understand the technical solutions of the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

Example one

Fig. 1 is a flowchart of a RPA-based remote debugging method according to an embodiment of the present invention, where the present embodiment is applicable to a case of remotely debugging an RPA, and the method may be performed by an RPA-based remote debugging apparatus, where the RPA-based remote debugging apparatus may be implemented in a form of hardware and/or software, and the RPA-based remote debugging apparatus may be configured in an electronic device with data processing capability. As shown in fig. 1, the method includes:

s110, sending the flow file data to be debugged to an execution machine through a preset named pipeline, wherein the flow file data comprises at least one component to be debugged.

The technical solution of the present embodiment may be executed by a designer. The RPA refers to robot Process Automation (robot Process Automation), and is software or a platform for implementing workflow Automation by simulating and enhancing an interactive Process between a human and a computer according to a preset program and executing a large-batch and repeatable task based on a certain rule. The English name of the designer is RPAStudio, and the flow designer uses the client to design the flow for execution on the RPA execution machine, so that the engineering management, debugging and publishing of the flow can be supported. The english name of the execution machine is Robot, which is a program body that finally executes code or flow scripts to complete the desired operations. In the embodiment, the AutoResetEvent object of the NET Framework is used on two sides of the designer and the execution machine respectively and used for controlling the operation and suspension of the designer and the execution machine.

Among them, Named Pipes are also called Named Pipes (Named Pipes), which is a simple inter-process communication (IPC) mechanism. Named pipes provide interprocess communication between a pipe server and one or more pipe clients. Named pipes can support full-duplex communication, message-based communication, and client emulation across networks and multiple server instances, through which the connection process can use its own set of permissions on remote servers. The named pipe in this embodiment may be configured by the designer in advance according to the identification information of the remote execution machine. The identification information may include IP information and port information of the execution machine. For example, since a common designer debugging configuration defaults to local debugging, remote debugging can be performed by modifying the configuration and inputting relevant information such as a remote execution machine IP. The designer may communicate with the execution engine through a named pipe. The technical scheme of the embodiment uses a named pipe technology as a communication carrier of data or commands between a designer and an execution machine, thereby achieving the purpose of communication between local machines or cross networks.

The process file data may be a text file in xml format with xml as suffix, which is a segment of process processing logic combined by one or more components. The process file data to be debugged may be understood as the process file data to be debugged. The process file data may include at least one component to be debugged. A component can be understood as the smallest logical unit of flow execution, encapsulated by simple or complex business logic code. The component to be debugged may be understood as at least one component to be debugged contained in the flow file to be debugged.

In this embodiment, the designer sends flow file data to be debugged including at least one component to be debugged to the execution machine through a pre-configured named pipeline.

And S120, sending a debugging instruction to the execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged.

The debugging instruction may be an instruction for causing the execution machine to perform debugging, that is, for instructing the execution machine to load the flow file data to be debugged and execute the component to be debugged included in the flow file data. The debug instruction in this embodiment may include instructions such as suspend, resume, single step skip, retry, ignore, and abort debug instruction when exception.

In this embodiment, the designer sends a debugging instruction to the execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged.

S130, obtaining the information of the component to be debugged to be operated or being operated from the execution machine, and executing debugging function operation according to the information of the component to be debugged.

The information of the component to be debugged can be information of the component to be run or running. Component information may include attributes, names, states, identifications, fields, and variables, among other information. Specifically, the information such as the attribute and the name in the component information may be original information in the process file; the state, identification, variable, and the like in the component information may be information generated by executing the component according to the execution debug instruction. The debugging function operation can be understood as executing operation of the designer according to a debugging function preset in the component information, and can also be carried out according to actual requirements to send debugging instructions for debugging; illustratively, if predefined breakpoint information exists in the to-be-debugged component information acquired by the designer from the execution machine, which indicates that a breakpoint is hit, the designer enters a suspended state. In addition, in this embodiment, the designer may also end the flow operation of the execution machine by actively ending the debugging by sending a forced end instruction to the execution machine.

In this embodiment, the designer acquires information of a component to be debugged to be operated or running from the execution machine, and executes a debugging function operation according to the information of the component to be debugged.

In this embodiment, optionally, after obtaining information of a component to be debugged about to run or running from the execution machine, the method further includes: judging whether predefined breakpoint information exists in the information of the component to be debugged; if yes, entering a pause state; otherwise, sending a continuous debugging instruction to the execution machine.

The breakpoint information may be predefined interrupt information in the information of the component to be debugged. The breakpoint information is for the purpose of hitting a breakpoint. In this embodiment, the information of the component to be debugged may also be predefined according to actual requirements.

The execution machine of the embodiment sends information of a component to be debugged to be operated or being operated to a designer and enters a waiting state, after the designer acquires the information of the component to be debugged to be operated or being operated from the execution machine, whether the information of the component to be debugged has predefined breakpoint information is judged, and if the predefined breakpoint information exists, the designer enters a pause state and waits for a debugging person to click to continue or end an instruction; otherwise, it can also be understood that breakpoint information does not exist, and the debugging personnel sends a continuous debugging instruction or other debugging instructions such as single step to the execution machine. In addition, the designer may also display current values for various attributes, fields, variables, etc. of the current component information.

According to the scheme, the purpose of hitting the breakpoint can be achieved through the predefined breakpoint information, and therefore debugging of a designer and an execution machine is facilitated.

In this embodiment, optionally, the executing the debugging function operation according to the information of the component to be debugged includes: acquiring information execution exception instructions of the components to be debugged from the execution machine; judging whether the abnormity is ignored and continuing to execute; and if so, sending a continuous debugging instruction to the execution machine.

Wherein, the execution exception instruction may be an instruction issued by the execution machine when the execution machine executes a component encountering an exception.

In the embodiment, if the execution of the execution machine encounters an exception in a certain component, the execution machine sends an exception instruction to the designer, and the designer acquires information of the component to be debugged from the execution machine and executes the exception instruction; and judging whether the exception can be ignored and continuing, if the exception can be ignored, sending a continuation instruction to the execution machine by the designer, and continuing to execute the next component by the execution machine. If the exception can not be ignored, the designer sends an ending instruction to the execution machine, and the process debugging is ended. In the embodiment, the abnormity can be judged according to a preset judgment mode of the service, and can be set according to actual requirements; for example, an exception error currently executed will not result in an error in the program or flow, indicating that the exception is negligible.

According to the scheme, through the arrangement, the function of judging whether the abnormity is interrupted or not is achieved by increasing abnormity capture in the operation methods of all the assemblies and uniformly redirecting to a common error processing method.

In this embodiment, optionally, the debug instruction includes a pause, resume, single step skip, retry, ignore, and abort debug instruction when exception occurs.

The debug instructions in this embodiment may include suspend, resume, single step skip, retry, ignore, and abort instructions. In addition, in the embodiment, the debugging function of ignoring errors and retrying can be achieved by intercepting and replacing the code execution logic with errors encountered during the component operation through a code reflection technology.

Through the arrangement, various debugging functions can be effectively realized after the RPA process design is finished.

In this embodiment, optionally, the method further includes: an AutoResetEvent object is used to control the running and pausing.

Wherein, the AutoResetEvent object can be an AutoResetEvent object of a NET Framework in the RPA. The AutoResetEvent object of the NET Framework is used for controlling the operation and suspension of the designer and the execution machine.

By the arrangement, the operation and pause of the designer and the execution machine are more conveniently controlled.

Example two

Fig. 2 is a flowchart of a RPA-based remote debugging method according to a second embodiment of the present invention, where the present embodiment is applicable to a case of remotely debugging an RPA, and the method may be performed by an RPA-based remote debugging apparatus, where the RPA-based remote debugging apparatus may be implemented in a form of hardware and/or software, and the RPA-based remote debugging apparatus may be configured in an electronic device with data processing capability. As shown in fig. 2, the method includes:

and S210, monitoring whether the flow task is to be executed.

The technical scheme of the embodiment can be executed by an execution machine. The english name of the execution machine is Robot, which is the program body that finally executes the code or flow script to accomplish the desired operation. In the embodiment, the AutoResetEvent object of the NET Framework is used on two sides of the designer and the execution machine respectively and used for controlling the operation and suspension of the designer and the execution machine.

The flow task to be executed may be a flow task to be executed. The flow task to be executed may be a flow task to be executed issued by a debugger through a designer. In this embodiment, the remote designer is in a startup standby state, and can circularly monitor whether a flow task is to be executed and issued through the monitor port.

S220, receiving flow file data to be debugged sent by a designer through a pre-configured named pipeline, wherein the flow file data comprises at least one component to be debugged.

Among them, named pipes are a simple inter-process communication (IPC) mechanism. Named pipes provide interprocess communication between a pipe server and one or more pipe clients. Named pipes can support full-duplex communication, message-based communication, and client emulation across networks and multiple server instances, through which the connection process can use its own set of permissions on remote servers. The named pipe in this embodiment may be configured by the designer in advance based on the identification information of the remote execution machine. The identification information may include IP information and port information of the execution machine. For example, since a common designer debugging configuration defaults to local debugging, remote debugging can be performed by modifying the configuration and inputting relevant information such as a remote execution machine IP. The designer may communicate with the execution engine through a named pipe. The technical scheme of the embodiment uses a named pipe technology as a communication carrier of data or commands between a designer and an execution machine, thereby achieving the purpose of communication between local machines or cross networks.

The process file data may be a text file in xml format with xml as suffix, which is a segment of process processing logic combined by one or more components. The process file data to be debugged may be understood as process file data to be debugged. The process file data may include at least one component to be debugged. A component can be understood as the smallest logical unit of flow execution, encapsulated by simple or complex business logic code. The component to be debugged may be understood as at least one component to be debugged contained in the flow file to be debugged.

In the embodiment, the execution machine receives flow file data including at least one component to be debugged, which is sent by the designer, through a pre-configured named pipeline.

And S230, receiving a debugging instruction sent by the designer to start loading the flow file data to be debugged and execute the component to be debugged.

The debugging instruction may be an instruction for debugging the execution machine, that is, for starting loading the flow file data to be debugged and executing the component to be debugged. The debug instruction in this embodiment may include instructions such as suspend, resume, single step skip, retry, ignore, and abort debug instruction when exception occurs.

In this embodiment, the execution machine receives a debugging instruction sent by the designer to start loading the data of the flow file to be debugged and execute the component to be debugged.

S240, sending information of the component to be debugged to be operated or being operated to the designer, and executing according to a debugging instruction sent by the received designer.

The information of the component to be debugged can be information of the component to be run or running. Component information may include attributes, names, states, identifications, fields, and variables. Specifically, the information such as the attribute and the name in the component information may be original information in the process file; the state, identification, variables, and the like in the component information may be information generated by executing the component according to the execution debug instruction. In this embodiment, the execution machine executes according to the debug instruction sent by the receiving designer. In this embodiment, the execution machine determines whether the flow ends according to the component execution end flag, and if the flow ends, sends an end instruction to the designer, and the designer finishes debugging after receiving the end instruction.

In this embodiment, the execution machine sends information of a component to be debugged to be operated or being operated to the designer, and executes the debugging according to a debugging instruction sent by the received designer.

According to the technical scheme of the embodiment of the invention, whether the flow task is to be executed or not is monitored; receiving flow file data to be debugged sent by a designer through a pre-configured named pipeline, wherein the flow file data comprises at least one component to be debugged; receiving a debugging instruction sent by a designer to start loading flow file data to be debugged and execute the component to be debugged; and sending information of the component to be debugged to be operated or being operated to the designer, and executing according to a debugging instruction sent by the received designer. According to the technical scheme, cross-process debugging can be realized by a single machine, and cross-machine and cross-remote network remote debugging can also be realized; the limitation of the debugging of the RPA is effectively solved.

In this embodiment, optionally, the sending information of the component to be debugged to be run or running to the designer, and executing according to the received debugging instruction sent by the designer, includes: when the execution of the information with the debugging component is abnormal, an abnormal instruction is sent to a designer; and executing according to the received continued debugging instruction sent by the designer.

Wherein, the exception instruction may be an instruction issued by the execution machine when the execution machine executes a component encountering an exception.

In the embodiment, if the execution of the execution machine encounters an exception in a certain component, the execution machine sends an exception instruction to the designer; and then executing according to the continue debugging instruction sent by the receiving designer. In this embodiment, the designer may also send an end instruction to the execution machine, and at this time, when the process debugging is ended, the execution machine is not executed any more. In this embodiment, if the execution flow of the execution machine is finished, the execution machine enters an idle state, and continues to monitor and wait for the next task.

In this embodiment, optionally, the method further includes: the debug instruction comprises retry and ignore;

the retry and the ignored debug instructions are performed by a code reflection technique.

The received debug instruction may include retry and ignore, and may also include other debug instructions. Code reflection technology may be understood as code reflection technology performed by code in an execution machine. The execution machine in the embodiment can intercept and replace the code execution logic which encounters an error when the component runs by using a code reflection technology to achieve the debugging function of ignoring the error and retrying. By the arrangement, the code execution logic which encounters an error can be intercepted, and the debugging function of ignoring and retrying is facilitated.

EXAMPLE III

Fig. 3 is a schematic structural diagram of an apparatus for RPA-based remote debugging according to a third embodiment of the present invention. The apparatus is configured in a designer, as shown in fig. 3, and includes:

a flow file sending module 310, configured to send flow file data to be debugged to an execution machine through a pre-configured named pipeline, where the flow file data includes at least one component to be debugged;

a debugging instruction sending module 320, configured to send a debugging instruction to the execution machine to instruct the execution machine to load the flow file data to be debugged and execute the component to be debugged;

the component information obtaining module 330 is configured to obtain information of a component to be debugged that is about to run or is running from the execution machine, and execute a debugging function operation according to the information of the component to be debugged.

Optionally, the apparatus further comprises:

the breakpoint information judging module is used for judging whether the information of the component to be debugged has the predefined breakpoint information or not after the information of the component to be debugged which is about to run or is running is obtained from the execution machine; if yes, entering a pause state; otherwise, sending a continuous debugging instruction to the execution machine.

Optionally, the component information obtaining module 330 is specifically configured to:

judging whether the abnormity is ignored and continuing to execute;

and if so, sending a continuous debugging instruction to the execution machine.

Optionally, the method further includes: and the control module is used for controlling the running and the suspension by using the AutoResetEvent object.

The device based on RPA remote debugging provided by the embodiment of the invention can execute the method based on RPA remote debugging provided by any embodiment of the invention, and has corresponding functional modules and beneficial effects of the execution method.

Example four

Fig. 4 is a schematic structural diagram of an apparatus for RPA-based remote debugging according to a fourth embodiment of the present invention. The apparatus is configured to an execution machine, and as shown in fig. 4, the apparatus includes:

a monitoring module 410, configured to monitor whether a process task is to be executed;

a flow file receiving module 420, configured to receive, through a pre-configured named pipeline, flow file data to be debugged sent by a designer, where the flow file data includes at least one component to be debugged;

a debugging instruction receiving module 430, configured to receive a debugging instruction sent by a designer, so as to start loading flow file data to be debugged and execute the component to be debugged;

and the debugging instruction execution module 440 is configured to send information of the component to be debugged to be operated or being operated to the designer, and execute the debugging instruction according to the received debugging instruction sent by the designer.

Optionally, the debug instruction executing module 440 is specifically configured to:

and executing according to the continued debugging instruction sent by the receiving designer.

Optionally, the method further includes: and the retry and ignore debugging module is used for carrying out retry and ignore debugging instructions through a code transmitting technology.

EXAMPLE five

Fig. 5 is a schematic structural diagram of an electronic device according to a fifth embodiment of the present invention. The electronic device 10 is intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The electronic device may also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smart phones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be exemplary only, and are not meant to limit implementations of the inventions described and/or claimed herein.

As shown in fig. 5, the electronic device 10 includes at least one processor 11, and a memory communicatively connected to the at least one processor 11, such as a Read Only Memory (ROM)12, a Random Access Memory (RAM)13, and the like, wherein the memory stores a computer program executable by the at least one processor, and the processor 11 can perform various suitable actions and processes according to the computer program stored in the Read Only Memory (ROM)12 or the computer program loaded from a storage unit 18 into the Random Access Memory (RAM) 13. In the RAM 13, various programs and data necessary for the operation of the electronic apparatus 10 can also be stored. The processor 11, the ROM 12, and the RAM 13 are connected to each other via a bus 14. An input/output (I/O) interface 15 is also connected to the bus 14.

A number of components in the electronic device 10 are connected to the I/O interface 15, including: an input unit 16 such as a keyboard, a mouse, or the like; an output unit 17 such as various types of displays, speakers, and the like; a storage unit 18 such as a magnetic disk, an optical disk, or the like; and a communication unit 19 such as a network card, modem, wireless communication transceiver, etc. The communication unit 19 allows the electronic device 10 to exchange information/data with other devices via a computer network such as the internet and/or various telecommunication networks.

The processor 11 may be a variety of general and/or special purpose processing components having processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), various specialized Artificial Intelligence (AI) computing chips, various processors running machine learning model algorithms, a Digital Signal Processor (DSP), and any suitable processor, controller, microcontroller, or the like. Processor 11 performs the various methods and processes described above, such as the RPA-based remote debugging method.

In some embodiments, the RPA-based remote debugging method may be implemented as a computer program tangibly embodied in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program may be loaded and/or installed onto the electronic device 10 via the ROM 12 and/or the communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the RPA-based remote debugging method described above may be performed. Alternatively, in other embodiments, processor 11 may be configured by any other suitable means (e.g., by way of firmware) to perform the RPA-based remote debugging method.

Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuitry, Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), system on a chip (SOCs), load programmable logic devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which may be special or general purpose, receiving data and instructions from, and transmitting data and instructions to, a storage system, at least one input device, and at least one output device.

A computer program for implementing the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the computer programs, when executed by the processor, cause the functions/acts specified in the flowchart and/or block diagram block or blocks to be performed. A computer program can execute entirely on a machine, partly on a machine, as a stand-alone software package partly on a machine and partly on a remote machine or entirely on a remote machine or server.

In the context of the present invention, a computer-readable storage medium may be a tangible medium that can contain, or store a computer program for use by or in connection with an instruction execution system, apparatus, or device. A computer readable storage medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. Alternatively, the computer readable storage medium may be a machine readable signal medium. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

To provide for interaction with a user, the systems and techniques described here can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which a user can provide input to the electronic device. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form, including acoustic, speech, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), Wide Area Networks (WANs), blockchain networks, and the internet.

The computing system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The server can be a cloud server, also called a cloud computing server or a cloud host, and is a host product in a cloud computing service system, so that the defects of high management difficulty and weak service expansibility in the traditional physical host and VPS service are overcome.

It should be understood that various forms of the flows shown above may be used, with steps reordered, added, or deleted. For example, the steps described in the present invention may be executed in parallel, sequentially, or in different orders, and are not limited herein as long as the desired results of the technical solution of the present invention can be achieved.

The above-described embodiments should not be construed as limiting the scope of the invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may be made, depending on design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for remote debugging based on RPA, which is executed by a designer and comprises the following steps:

2. The method of claim 1, after obtaining information of the component to be debugged about to run or running from the execution machine, further comprising:

if yes, entering a pause state;

otherwise, sending a continuous debugging instruction to the execution machine.

3. The method according to claim 1, wherein the performing debugging function operations according to the information of the component to be debugged comprises:

judging whether the abnormity is ignored and continuing to execute;

and if so, sending a continuous debugging instruction to the execution machine.

4. The method of claim 1, wherein the debug instructions comprise pause, continue, single step skip, single step jump, retry, ignore, and abort debug instructions upon exception.

5. The method of claim 1, further comprising:

an AutoResetEvent object is used to control the running and pausing.

6. A method for remote debugging based on RPA, wherein the method is executed by an execution machine and comprises:

monitoring whether a flow task is to be executed or not;

7. The method of claim 6, wherein sending information of the component to be debugged to be run or running to the designer and executing according to the debugging instruction sent by the designer comprises:

8. The method of claim 6, further comprising: the debug instruction includes retry and ignore;

9. An apparatus for remote debugging based on RPA, configured in a designer, comprising:

10. An apparatus for remote debugging based on RPA, configured in an execution machine, comprising:

the debugging instruction receiving module is used for receiving a debugging instruction sent by the designer so as to start loading the data of the flow file to be debugged and execute the component to be debugged;

and the debugging instruction execution module is used for sending the information of the component to be debugged to be operated or being operated to the designer and executing according to the received debugging instruction sent by the designer.

11. An electronic device, characterized in that the electronic device comprises:

at least one processor; and

the memory stores a computer program executable by the at least one processor to enable the at least one processor to perform the RPA-based remote debugging method of any of claims 1-5 or claims 6-8.

12. A computer-readable storage medium storing computer instructions for causing a processor to perform the method for RPA-based remote debugging of any of claims 1-5 or claims 6-8 when executed.