CN111274122A - Method, device and storage medium for debugging process - Google Patents
Method, device and storage medium for debugging process Download PDFInfo
- Publication number
- CN111274122A CN111274122A CN201811484873.9A CN201811484873A CN111274122A CN 111274122 A CN111274122 A CN 111274122A CN 201811484873 A CN201811484873 A CN 201811484873A CN 111274122 A CN111274122 A CN 111274122A
- Authority
- CN
- China
- Prior art keywords
- command
- pseudo terminal
- reading
- operation result
- processing task
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 190
- 238000012545 processing Methods 0.000 claims abstract description 34
- 238000007639 printing Methods 0.000 claims description 5
- 238000010586 diagram Methods 0.000 description 17
- 238000004891 communication Methods 0.000 description 8
- 238000004458 analytical method Methods 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 230000005236 sound signal Effects 0.000 description 4
- 238000012423 maintenance Methods 0.000 description 2
- 238000007792 addition Methods 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3636—Software debugging by tracing the execution of the program
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The disclosure provides a method, a device and a storage medium for debugging a process, which are used for solving the problem that the process can be debugged only by interrupting the running of the process in the related art. The method comprises the following steps: writing the received command aiming at the target process into a pre-established socket port; reading the command through an input processing task, so that a command analyzer acquires, analyzes and runs the command from a pseudo terminal of the target process; and reading the operation result of the command from the pseudo terminal through an output processing task. The method and the device can conveniently and quickly debug and manage the process in real time.
Description
Technical Field
The present invention relates to the field of operating system technologies, and in particular, to a method and an apparatus for debugging a process, and a storage medium.
Background
Modern mainstream operating systems such as Linux and Windows are separated from user states by adopting a kernel state, support multiple processes and have independent process spaces. The application software developed on the basis runs in the process space of the application software once executed. In order to debug an application program, a program developer must use a special debugger, such as gdb and attach, to a thread to be debugged to obtain information such as a current variable value and a stack call relation in the process space. Because gdb needs to interrupt program operation and has the expenses of memory occupation and the like, the method is not suitable for simple debugging and maintenance in the commercial environment of the current network. In view of this, it is necessary to consider that a portable and fast method is implemented to obtain the running state and the relevant field information corresponding to the process without affecting the normal running of the program.
Disclosure of Invention
The invention provides a method, a device and a storage medium for debugging a process, which are used for solving the problem that the process can be debugged only by interrupting the running of the process in the related art.
According to a first aspect of the present invention, there is provided a method for debugging a process, comprising: writing the received command aiming at the target process into a pre-established socket port; reading the command from the socket port through an input processing task, so that a command parser acquires, parses and runs the command from a pseudo terminal of the target process; and reading the operation result of the command from the pseudo terminal through an output processing task.
Optionally, the method further comprises: receiving a pseudo terminal list query command; and outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises pseudo terminals of accessible service processes.
Optionally, the method further comprises: after the operation result of the command is read from the pseudo terminal by an output processing task, the operation result is written into the socket port, or the operation result is printed to a console.
Optionally, the method further comprises: before writing a received command aiming at a target process into a pre-established socket port, establishing the pseudo terminal for the target process; and redirecting the standard writing/reading I/O of the target process to the slave end of the pseudo terminal.
Optionally, the command parser parses the command, including: accessing the symbol table of the target process through a preset calling interface; and resolving the command into an expression according to the symbol table.
According to a second aspect of the present invention, an apparatus for debugging a process, comprises: the first writing module is used for writing the received command aiming at the target process into a pre-established socket port; the first reading module is used for reading the command from the socket port through an input processing task so as to enable a command parser to obtain, parse and run the command from a fake terminal of the target process; and the second reading module is used for reading the operation result of the command from the pseudo terminal through an output processing task.
Optionally, the apparatus further comprises: the receiving module is used for receiving a pseudo terminal list inquiry command; and the output module is used for outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises the pseudo terminals of the accessible service processes.
Optionally, the apparatus further comprises: and the second writing module is used for writing the operation result into the socket port or printing the operation result to the console after the operation result of the command is read from the pseudo terminal through the output processing task.
Optionally, the apparatus further comprises: the creating module is used for creating the pseudo terminal for the target process before writing the received command aiming at the target process into a pre-created socket port; and the redirection module is used for redirecting the standard write/read I/O of the target process to the slave end of the pseudo terminal.
Optionally, the command parser comprises: the access module is used for accessing the symbol table of the target process through a preset calling interface; and the analysis module is used for analyzing the command into an expression according to the symbol table.
According to a third aspect of the present disclosure, there is provided an apparatus for debugging a process, including: a processor; a memory for storing processor-executable instructions; when executed by a processor, perform the following:
writing the received command aiming at the target process into a pre-established socket port; reading the command from the socket port through an input processing task, so that a command parser acquires, parses and runs the command from a pseudo terminal of the target process; and reading the operation result of the command from the pseudo terminal through an output processing task.
According to a fourth aspect of the present disclosure, there is provided a non-transitory computer readable storage medium having instructions which, when executed by a processor, enable the processor to perform a method of debugging a process according to the first aspect of the present disclosure.
The invention has the following beneficial effects:
the method for debugging the process of the embodiment of the invention establishes connection with the management process through the preset socket port, receives the command input by the user through the input processing task, writes the command input by the user into the socket port, and reads the operation result of the command from the socket port, thereby realizing the operations of executing the debugging command inside the process, controlling the trend of the program, checking the memory information of the process space, starting and stopping the management thread, checking the state of the thread and the like, and being capable of conveniently and rapidly debugging and managing the process in real time.
Drawings
FIG. 1 is a flow diagram illustrating a method of debugging a process in accordance with an illustrative embodiment;
FIG. 2 is a flow diagram illustrating a method of debugging a process in accordance with an illustrative embodiment;
FIG. 3 is a flow diagram illustrating a method of debugging a process in accordance with an illustrative embodiment;
FIG. 4 is an overall architecture diagram of Ushell, shown in accordance with an exemplary embodiment;
FIG. 5 is a schematic diagram illustrating a user input command in a Ushell agent module, according to an exemplary embodiment;
FIG. 6 is a schematic diagram illustrating the output of a business process in a Ushell proxy module in accordance with an illustrative embodiment;
FIG. 7 is a schematic diagram illustrating a redirection module in accordance with an illustrative embodiment;
FIG. 8 is a schematic diagram of a command parsing module shown in accordance with an exemplary embodiment;
FIG. 9 is a block diagram illustrating an apparatus for debugging a process in accordance with an illustrative embodiment;
FIG. 10 is a block diagram illustrating an apparatus to debug a process in accordance with an example embodiment.
Detailed Description
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.
The invention provides a tool which can conveniently carry out real-time debugging management on each process, is called unified Shell (hereinafter referred to as Ushell), and can carry out real-time debugging and management on each process. For example, a user may log in a management interface of the Ushell server by using a Ushell client tool or directly through telnet, view a currently running process and states of the processes, further switch to a Shell of any process, execute a specified debugging command, view an execution state and memory information inside the process, start and stop or create any thread, and manage the user process. The method for debugging provided by the invention can be executed by a Ushell tool.
FIG. 1 is a flow diagram illustrating a method of debugging a process, as shown in FIG. 1, according to an exemplary embodiment, the method comprising the steps of:
step 101: writing the received command aiming at the target process into a pre-established socket port;
in the initialization phase, a socket port (Ushell socket) can be created as the output direction of the Ushell client, and all externally input commands can come from the socket port and can be read by the input processing task.
Wherein a command for a target process may be entered by a user based on the Ushell client, the command may be a string.
Step 102: reading the command from the socket port through an input processing task, so that a command parser acquires, parses and runs the command from a pseudo terminal of the target process;
wherein the dummy terminal may be created at a process initialization stage.
In step 102, the socket port may establish a connection with the Ushell agent module of the management process, so that the command parser may obtain the command at a slave end of its own pseudo terminal by executing an input processing task to read the command from the socket port. The Ushell agent module resides in a management process, and is responsible for collecting, publishing and managing each process and managing Ushell pseudo terminal information of the process on a designated port. The Ushell agent module can also issue a service process pseudo terminal list for connection to the user. For example, the Ushell agent module receives a connection request initiated by a user, authenticates and authenticates a remote user, generates a session after the authentication is passed, and forwards a remote input to a corresponding application process, reads an output from the application process, and writes the output into the session.
Step 103: and reading the operation result of the command from the pseudo terminal through an output processing task.
In step 103, the execution result of the command may be read from the master (master) of the pseudo terminal by running the output processing task.
The method for debugging the process of the embodiment of the invention establishes connection with the management process through the preset socket port, receives the command input by the user through the input processing task, writes the command input by the user into the socket port, and reads the operation result of the command from the socket port, thereby realizing the operations of executing the debugging command in the process, controlling the trend of the program, checking the memory information of the process space, starting and stopping the management thread, checking the state of the thread and the like, and conveniently realizing the real-time debugging and management of the process. The tool can provide great convenience for the development and maintenance of application software.
Fig. 2 is a flowchart illustrating a method for debugging a process according to an exemplary embodiment, where as shown in fig. 2, the method may further include, on the basis of fig. 1:
step 201: receiving a pseudo terminal list query command;
for example, a user may enter a pseudo terminal list query command through the Ushell client.
Step 202: and outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises pseudo terminals of accessible service processes.
Wherein, steps 201-202 can be executed before or after any of steps 101-103, and fig. 2 only shows one case that step 201 and step 202 are executed before step 101.
After inputting the pseudo terminal list to the user, the user checks the list to know the service process available for connection, so as to input a command through the Ushell client, after receiving the command, the user can read and output the content corresponding to the command from the specified pseudo terminal according to the command, and the content is presented to the user, for example, can be displayed to the user through the client.
Fig. 3 is a flowchart illustrating a method for debugging a process according to an exemplary embodiment, where as shown in fig. 3, the method may further include, on the basis of fig. 1: step 301: after the operation result of the command is read from the pseudo terminal by an output processing task, the operation result is written into the socket port, or the operation result is printed to a console. When the operation result is written into the socket port, the operation result can be read from the socket port, and in addition, the operation result can be displayed on a screen for a user to check.
In an implementation manner, the method for debugging a process provided by the present invention may further include:
before writing a received command aiming at a target process into a pre-established socket port, establishing the pseudo terminal for the target process; and redirecting the standard writing/reading I/O of the target process to the slave end of the pseudo terminal.
In one implementation, the command parser parsing the command may include: accessing the symbol table of the target process through a preset calling interface; and resolving the command into an expression according to the symbol table.
In order to facilitate understanding of the method for debugging the process according to the embodiment of the present invention, the method is briefly described below based on the overall architecture of Ushell in conjunction with fig. 4.
The user accesses the Ushell proxy module through Telnet by means of a Ushell client tool or a direct use terminal, after the user passes authentication, a command input by the user is redirected to a shell of an execution process, such as an application process A and an application process B shown in FIG. 4, the command is analyzed by an analyzer in the application process A or the application process B to complete the execution of the command, an output result of the command is redirected to a slave end of the pseudo terminal, and the output result is written into a socket port and returned to the user.
FIG. 5 is a diagram illustrating user input commands in a Ushell proxy module, according to an example embodiment, where console users log in to Ushell from a serial port, and Socket users include users who log in through a Ushell client tool and telnet. All users can be managed in a user session table in a unified way, the user session table can be arranged in a user session management module, and the command input by the remote user can be completed through the cooperation of the session table and the Target table and then is sent to the appointed business process. Fig. 6 is a schematic diagram illustrating an output of a business process in the Ushell agent module according to an exemplary embodiment, where, as shown in fig. 6, the output of the business process is uniformly received by a readtarget task in the management process agent and is sent to a specified user according to information recorded in a session table.
FIG. 7 is a diagram illustrating a redirection module residing on a management process and respective business processes that may act as an intermediary between the communication command parser and the Ushell proxy, according to an example embodiment. In the process initialization stage, the method is responsible for storing and setting terminal attributes, a pseudo terminal (pseudo terminal of a command parser) can be created, and a slave end of the pseudo terminal is set as the current standard I/O; creating a socket (Ushell socket) port as the output direction of Ushell; all inputs can be read from the Ushell socket by an input processing task; the default output direction can be Ushell socket, and the output processing task can transfer between the pseudo terminal and the Ushell socket. When the user software runs in a steady state, the redirection module can be responsible for receiving inputs in all directions, including a serial console, a User Datagram Protocol (UDP) direction and a Telnet direction, and outputting the standard output of the process to the console for printing or forwarding the standard output of the process to a management process in the form of a user software message.
After the process initialization is completed, the workflow may include, in steady state operation:
the command character string input by the user is forwarded by the Ushell agent module and written to the Ushell socket.
The input processing task reads the command string at the Ushell client.
The command parser obtains a command at a slave end of the pseudo terminal, parses and runs the command. Because the current standard I/O of the process is the slave of the pseudo terminal, the output result of the command execution (also referred to as command execution result for short) is also written to the slave of the pseudo terminal.
And the output processing task reads the output result of the command at the master end of the pseudo terminal and writes the output result of the command to the Ushell socket according to the current output direction.
The Ushell agent module reads the output result of the command from the Ushell socket of the business process, and returns the output result to the user through the writing socket or directly prints the output result to the console.
FIG. 8 is a diagram illustrating a command parsing module according to an exemplary embodiment, and as shown in FIG. 8, the command parsing module may contain an internal shell task and a C-language expression parsing engine (which is an example of a parser). The internal shell task resides in the management process and each application process, and is responsible for continuously reading an input debugging command from a slave end of the pseudo terminal and delivering the debugging command to the resolver module for resolving and executing. The analyzer resides in the management process and each application process, and is responsible for analyzing the character string of the debugging command, and the symbol table is used to analyze the C language expression of the inputted debugging command line. The C language engine can use Lex and Yacc to do lexical analysis and syntax analysis to the expression respectively, and the command parsing module needs to access the symbol table of the process when working, so as to provide a calling interface of the symbol table. The internal shell task is mainly used for reading an expression character string (for example, a command input by a user) from a standard input for language resolution, and a symbol table is used for searching addresses of related symbols in a memory. The result of the expression execution can be directly output to the standard for printing. The parser provides a function for parsing a debug command expression, which can be used to check whether a command input by a user conforms to a syntax specification and to determine whether a debug command is a debug function or a variable. However, when this function or variable is actually executed, it depends on a symbol table, which records the real address of the symbol. The symbol table of the process can be extracted by reading the Executable and Linkable Format (ELF) file of the process itself when the process is initialized. The symbol table of the dynamic library may obtain the dynamic library name and the loaded base address referred by the Process by reading/proc/PID (Process Identification)/maps file, and finally calculate the real address of the symbol by combining the symbol offset obtained from the library file. The symbol table of the process is stored in the form of a global table, the symbol table of the dynamic library is stored in the form of a shared memory and shared among the processes, and the symbol table is the basis for analyzing the debugging command expression of the user.
The management process and the application process are logical concepts, and are designed to support a multi-process architecture. The management process may be the general entry of the business process, the process responsible for starting and managing the applications. Physically, the management process and the application process are combinable.
Fig. 9 is a block diagram illustrating an apparatus for debugging a process according to an exemplary embodiment, where, as shown in fig. 9, the apparatus 90 includes:
a first writing module 91, configured to write the received command for the target process into a socket port created in advance;
a first reading module 92, configured to read the command from the socket port through an input processing task, so that a command parser obtains, parses, and runs the command from a pseudo terminal of the target process;
and a second reading module 93, configured to read a running result of the command from the pseudo terminal through an output processing task.
The apparatus 90 may further include any one or more of the above-mentioned Ushell agent module, command parsing module, and redirection module, or may further include any one or more sub-modules for implementing the functions implemented by these modules, based on the structure shown in fig. 9.
In one implementation, the apparatus for debugging a process may further include: the receiving module is used for receiving a pseudo terminal list inquiry command; and the output module is used for outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises the pseudo terminals of the accessible service processes.
In one implementation, the apparatus for debugging a process may further include: and the second writing module is used for writing the operation result into the socket port or printing the operation result to the console after the operation result of the command is read from the pseudo terminal through the output processing task.
In one implementation, the apparatus for debugging a process may further include: the creating module is used for creating the pseudo terminal for the target process before writing the received command aiming at the target process into a pre-created socket port; and the redirection module is used for redirecting the standard write/read I/O of the target process to the slave end of the pseudo terminal.
In one implementation, the command parser may include: the access module is used for accessing the symbol table of the target process through a preset calling interface; and the analysis module is used for analyzing the command into an expression according to the symbol table.
FIG. 10 is a block diagram illustrating an apparatus to debug a process in accordance with an example embodiment. As shown in fig. 10, the apparatus 900 may include: a processor 901, a memory 902, multimedia components 903, input/output (I/O) interfaces 904, and communications components 905.
The processor 901 is configured to control the overall operation of the apparatus 900, so as to complete all or part of the steps in the method for debugging a process. The memory 902 is used to store various types of data to support operation of the device 900, such as instructions for any application or method operating on the device 900, as well as application-related data, such as contact data, messaging, pictures, audio, video, and so forth. The Memory 902 may be implemented by any type of volatile or non-volatile Memory device or combination thereof, such as Static Random Access Memory (SRAM), electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic Memory, flash Memory, magnetic disk or optical disk. The multimedia component 903 may include a screen and an audio component. Wherein the screen may be, for example, a touch screen and the audio component is used for outputting and/or inputting audio signals. For example, the audio component may include a microphone for receiving external audio signals. The received audio signal may further be stored in the memory 902 or transmitted through the communication component 905. The audio assembly also includes at least one speaker for outputting audio signals. The I/O interface 904 provides an interface between the processor 901 and other interface modules, such as a keyboard, mouse, buttons, etc. These buttons may be virtual buttons or physical buttons. The communication component 905 is used for wired or wireless communication between the apparatus 900 and other devices. Wireless communication, such as Wi-Fi, bluetooth, Near Field Communication (NFC), 2G, 3G, or 4G, or a combination of one or more of them, so that the corresponding communication component 905 may include: Wi-Fi module, bluetooth module, NFC module.
In an exemplary embodiment, the apparatus 900 may be implemented by one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components for performing the above-described method of debugging a process.
In another exemplary embodiment, a non-transitory computer readable storage medium, such as a memory 902, is also provided that includes program instructions executable by a processor 901 of the apparatus 900 to perform the above-described method of debugging a process.
Although the preferred embodiments of the present invention have been disclosed for illustrative purposes, those skilled in the art will appreciate that various modifications, additions and substitutions are possible, and the scope of the invention should not be limited to the embodiments described above.
Claims (10)
1. A method of debugging a process, comprising:
writing the received command aiming at the target process into a pre-established socket port;
reading the command from the socket port through an input processing task, so that a command parser acquires, parses and runs the command from a pseudo terminal of the target process;
and reading the operation result of the command from the pseudo terminal through an output processing task.
2. The method of claim 1, further comprising:
receiving a pseudo terminal list query command;
and outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises pseudo terminals of accessible service processes.
3. The method of claim 1, further comprising:
after the operation result of the command is read from the pseudo terminal by an output processing task, the operation result is written into the socket port, or the operation result is printed to a console.
4. The method of claim 1, further comprising:
before writing a received command aiming at a target process into a pre-established socket port, establishing the pseudo terminal for the target process;
and redirecting the standard writing/reading I/O of the target process to the slave end of the pseudo terminal.
5. The method of any of claims 1 to 4, wherein the command parser parses the command, comprising:
accessing the symbol table of the target process through a preset calling interface;
and resolving the command into an expression according to the symbol table.
6. An apparatus for debugging a process, comprising:
the first writing module is used for writing the received command aiming at the target process into a pre-established socket port;
the first reading module is used for reading the command from the socket port through an input processing task so as to enable a command parser to obtain, parse and run the command from a fake terminal of the target process;
and the second reading module is used for reading the operation result of the command from the pseudo terminal through an output processing task.
7. The apparatus of claim 6, further comprising:
the receiving module is used for receiving a pseudo terminal list inquiry command;
and the output module is used for outputting the pseudo terminal list according to the query command, wherein the pseudo terminal list comprises the pseudo terminals of the accessible service processes.
8. The apparatus of claim 6, further comprising:
and the second writing module is used for writing the operation result into the socket port or printing the operation result to the console after the operation result of the command is read from the pseudo terminal through the output processing task.
9. An apparatus for debugging a process, comprising:
a processor;
a memory for storing processor-executable instructions;
when executed by a processor, perform the following:
writing the received command aiming at the target process into a pre-established socket port;
reading the command from the socket port through an input processing task, so that a command parser acquires, parses and runs the command from a pseudo terminal of the target process;
and reading the operation result of the command from the pseudo terminal through an output processing task.
10. A non-transitory computer readable storage medium having instructions therein which, when executed by a processor, enable the processor to perform the method of any of claims 1 to 5.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811484873.9A CN111274122A (en) | 2018-12-05 | 2018-12-05 | Method, device and storage medium for debugging process |
| PCT/CN2019/118575 WO2020114217A1 (en) | 2018-12-05 | 2019-11-14 | Process debugging method and apparatus, and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811484873.9A CN111274122A (en) | 2018-12-05 | 2018-12-05 | Method, device and storage medium for debugging process |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111274122A true CN111274122A (en) | 2020-06-12 |
Family
ID=70974491
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811484873.9A Pending CN111274122A (en) | 2018-12-05 | 2018-12-05 | Method, device and storage medium for debugging process |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN111274122A (en) |
| WO (1) | WO2020114217A1 (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130290475A1 (en) * | 2012-04-25 | 2013-10-31 | Akiri Solutions, Inc. | Shared access to a remotely running application |
| CN103577209A (en) * | 2012-08-06 | 2014-02-12 | 浙江大华技术股份有限公司 | Embedded equipment-based application program remote on-line debugging method and device |
| CN106325982A (en) * | 2015-06-23 | 2017-01-11 | 中兴通讯股份有限公司 | shell processing method and device |
| CN107908576A (en) * | 2017-12-08 | 2018-04-13 | 上海市共进通信技术有限公司 | The method for realizing re-direction applications program standard output control |
-
2018
- 2018-12-05 CN CN201811484873.9A patent/CN111274122A/en active Pending
-
2019
- 2019-11-14 WO PCT/CN2019/118575 patent/WO2020114217A1/en active Application Filing
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130290475A1 (en) * | 2012-04-25 | 2013-10-31 | Akiri Solutions, Inc. | Shared access to a remotely running application |
| CN103577209A (en) * | 2012-08-06 | 2014-02-12 | 浙江大华技术股份有限公司 | Embedded equipment-based application program remote on-line debugging method and device |
| CN106325982A (en) * | 2015-06-23 | 2017-01-11 | 中兴通讯股份有限公司 | shell processing method and device |
| CN107908576A (en) * | 2017-12-08 | 2018-04-13 | 上海市共进通信技术有限公司 | The method for realizing re-direction applications program standard output control |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2020114217A1 (en) | 2020-06-11 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR102497463B1 (en) | Mini-program execution method, mini-program execution device, electronic device and storage medium | |
| CN109885311B (en) | Application program generation method and device | |
| CN109918055B (en) | Application program generation method and device | |
| CN109542506B (en) | System capable of flexibly configuring interface and rapidly delivering service | |
| CN108959199B (en) | Log highlighting method and device, storage medium and android terminal | |
| CN108287894B (en) | Data processing method, device, computing equipment and storage medium | |
| WO2016095570A1 (en) | Debugging method and apparatus for embedded system, and storage medium | |
| CN109831351B (en) | Link tracking method, device, terminal and storage medium | |
| CN111831538A (en) | Debugging method, device and storage medium | |
| US20190034195A1 (en) | Systems and methods for providing patchable rom firmware | |
| CN110187986B (en) | Command management method, system, device and computer readable storage medium | |
| CN112783748B (en) | Program debugging method, device, equipment and computer readable storage medium | |
| CN111930472B (en) | Code debugging method and device, electronic equipment and storage medium | |
| WO2020211360A1 (en) | Mock test method and system, electronic device, and computer non-volatile readable storage medium | |
| CN114356521A (en) | Task scheduling method and device, electronic equipment and storage medium | |
| CN113923008A (en) | Malicious website interception method, device, equipment and storage medium | |
| CN113485927A (en) | Test data generation method, device, equipment and storage medium | |
| CN111488286B (en) | Method and device for independently developing Android modules | |
| CN110825370B (en) | Mobile terminal application development method, device and system | |
| CN110838929B (en) | System error checking method and system error checking device | |
| CN111274122A (en) | Method, device and storage medium for debugging process | |
| CN116132344A (en) | Container service debugging method and device based on K8s cluster and electronic equipment | |
| CN115599669A (en) | Debugging method and device of microservice, electronic equipment and readable storage medium | |
| CN112631949B (en) | Debugging method and device, computer equipment and storage medium | |
| CN115118587A (en) | Method and device for creating connector |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| WD01 | Invention patent application deemed withdrawn after publication |
Application publication date: 20200612 |
|
| WD01 | Invention patent application deemed withdrawn after publication |