CN111045919A

CN111045919A - Method, device, background server, storage medium and system for debugging program

Info

Publication number: CN111045919A
Application number: CN201910630684.6A
Authority: CN
Inventors: 陈璐; 李艺; 王一帆; 李延凯
Original assignee: Huakong Tsingjiao Information Technology Beijing Co Ltd
Current assignee: Huakong Tsingjiao Information Technology Beijing Co Ltd
Priority date: 2019-07-12
Filing date: 2019-07-12
Publication date: 2020-04-21
Anticipated expiration: 2039-07-12
Also published as: CN111045919B

Abstract

The embodiment of the application provides a method, a device, a background server, a storage medium and a system for debugging a program. The method aims to more accurately and quickly locate the abnormal position in the program when writing the program based on the ciphertext. The method is applied to a background server in a program debugging system, and comprises the following steps: receiving a program segment execution request sent by the middle server, wherein the program segment execution request carries a target program segment in a program to be debugged; responding to the program segment execution request, under the condition that the target program segment comprises a partial program and a result display function, executing the partial program to obtain a value of a ciphertext variable, then executing the result display function, and converting the value of the ciphertext variable to obtain a plaintext result; and sending the plaintext result to the middle station server so as to send the plaintext result to the client through the middle station server.

Description

Method, device, background server, storage medium and system for debugging program

Technical Field

The embodiment of the application relates to the technical field of data processing, in particular to a method, a device, a background server, a storage medium and a system for debugging a program.

Background

In the context of writing a ciphertext-based program, variables in the program are encrypted. When a developer writes a program by using programming software, the developer usually debugs a section of program after writing the program. The specific debugging method comprises the following steps: and determining whether the section of program is abnormal or not by executing the section of program and observing a plaintext result of a ciphertext variable output after the program is executed. If the program has an exception, the developer needs to look at the code line by line so as to locate the exception position.

In the case of a shorter program, the developer may be able to locate the exception location from a small number of lines of code with less effort. However, in general, the length of the program is long, and the number of code lines in the program is huge. Therefore, in general, a developer needs to pay more labor to locate an abnormal position from a huge number of code lines, which causes low debugging efficiency, affects programming efficiency, and is difficult to ensure the correctness of codes in a program.

Disclosure of Invention

The embodiment of the application provides a method, a device, a background server, a storage medium and a system for debugging a program, and aims to more accurately and more quickly locate an abnormal position in the program when writing the program based on a secret text.

A first aspect of an embodiment of the present application provides a method for debugging a program, which is applied to a background server in a program debugging system, where the program debugging system further includes a client and a middle server, the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the method comprises the following steps:

receiving a program segment execution request sent by the middle server, wherein the program segment execution request is sent to the middle server by the client and carries a target program segment in a program to be debugged, and the target program segment is any one of a plurality of program segments obtained after the client splits the program to be debugged according to received breakpoint setting information;

responding to the program segment execution request, under the condition that the target program segment comprises a partial program and a result display function, executing the partial program to obtain a value of a ciphertext variable, then executing the result display function, and converting the value of the ciphertext variable to obtain a plaintext result;

and sending the plaintext result to the middle station server so as to send the plaintext result to the client through the middle station server.

Optionally, the background server comprises a plurality of computing nodes and a plurality of data nodes; receiving a program segment execution request sent by the middle station server, wherein the program segment execution request comprises:

a target computing node in the plurality of computing nodes receives a program segment execution request sent by the middle server, wherein the target computing node is distributed by the middle server for the program to be debugged;

wherein sending the plaintext result to the middle station server comprises:

the target computing node sends value prompt information to the middle station server;

a target data node in the plurality of data nodes receives a value taking request sent by the middle station server, wherein the value taking request is sent by the middle station server in response to the value taking prompt message, and the target data node is distributed by the middle station server for the program to be debugged;

and the target data node responds to the value taking request, obtains the program segment execution result from the target computing node and sends the program segment execution result to the middle server.

Optionally, receiving a program segment execution request sent by the middle station server includes:

receiving a program segment execution request which is sent by the middle platform server and carries a first identifier, and storing the first identifier, wherein the first identifier is configured for the program to be debugged by the middle platform server;

sending the plaintext result to the middle station server, so as to send the plaintext result to the client through the middle station server, including:

combining the first identifier with the plaintext result to obtain a plaintext result carrying the first identifier;

and sending the plaintext result carrying the first identifier to the middle station server, so that the middle station server determines the client corresponding to the first identifier according to the first identifier, and then sends the plaintext result carrying the first identifier to the determined client.

Optionally, the method further comprises:

obtaining a state result representing the self running state;

and sending the state result to the middle station server, so that the middle station server combines the state result with the plaintext result to obtain a calculation result, and then sending the calculation result to the client.

Optionally, the method further comprises:

receiving a second identifier sent by the middle server, wherein the second identifier is an identifier of a target data set bound by the middle server for a ciphertext variable in the program to be debugged;

and initializing the value of the ciphertext variable in the program to be debugged by using the numerical value in the target data set.

Optionally, the method further comprises:

under the condition that the target program segment is a calculation program, executing the calculation program to obtain a null value result, and sending the null value result to the middle station server so as to send the null value result to the client through the middle station server;

and under the condition that the target program segment is an exit program, executing the exit program to obtain a null value result, and sending the null value result to the middle server so as to send the null value result to the client through the middle server.

A second aspect of the embodiments of the present application provides a device for debugging a program, which is applied to a background server in a program debugging system, where the program debugging system further includes a client and a middle server, the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the device comprises:

a receiving module, configured to receive a program segment execution request sent by the middle server, where the program segment execution request is sent to the middle server by the client and carries a target program segment in a program to be debugged, and the target program segment is any one of multiple program segments obtained after the client splits the program to be debugged according to received breakpoint setting information;

the execution module is used for responding to the program segment execution request, under the condition that the target program segment comprises a partial program and a result display function, executing the partial program to obtain a ciphertext variable value, then executing the result display function, and converting the ciphertext variable value to obtain a plaintext result; and the number of the first and second groups,

and the sending module is used for sending the plaintext result to the middle station server so as to send the plaintext result to the client through the middle station server.

Optionally, the background server comprises a plurality of computing nodes and a plurality of data nodes;

the first receiving module includes:

a first receiving submodule, configured to receive, by a target computing node in the multiple computing nodes, a program segment execution request sent by the middlebox server, where the target computing node is allocated by the middlebox server for the program to be debugged;

the first transmitting module includes:

the first sending submodule is used for sending value-taking prompt information to the middle station server through the target computing node;

a second receiving submodule, configured to receive, by a target data node in the multiple data nodes, a value taking request sent by the middle station server, where the value taking request is sent by the middle station server in response to the value taking prompt information, and the target data node is allocated by the middle station server to the program to be debugged;

and the first obtaining submodule is used for responding to the value taking request through the target data node, obtaining the program segment execution result from the target computing node and sending the program segment execution result to the middle station server.

Optionally, the first receiving module includes:

a third receiving submodule, configured to receive a program segment execution request carrying a first identifier sent by the middle server, and store the first identifier, where the first identifier is configured for the program to be debugged by the middle server;

the first transmitting module includes:

combining the sub-modules: the plaintext result carrying the first identifier is obtained by combining the first identifier with the plaintext result;

and the second sending submodule is used for sending the plaintext result carrying the first identifier to the middle station server, so that the middle station server determines the client corresponding to the first identifier according to the first identifier, and then sends the plaintext result carrying the first identifier to the determined client.

Optionally, the apparatus further comprises:

the acquisition module is used for acquiring a state result representing the running state of the acquisition module;

and the second sending module is used for sending the state result to the middle station server so that the middle station server combines the state result with the plaintext result to obtain a calculation result, and then the calculation result is sent to the client.

Optionally, the apparatus further comprises:

a second receiving module, configured to receive a second identifier sent by the middlebox server, where the second identifier is an identifier of a target data set bound by the middlebox server for a ciphertext variable in the program to be debugged;

and the initialization module is used for initializing the value of the ciphertext variable in the program to be debugged by using the numerical value in the target data set.

Optionally, the execution module of the apparatus is further configured to:

A third aspect of embodiments of the present application provides a computer-readable storage medium, on which a computer program is stored, which, when executed by a processor, implements the steps in the method according to the first aspect of the present application.

A fourth aspect of the embodiments of the present application provides a backend server, including a memory, a processor, and a computer program that is stored in the memory and is executable on the processor, where the processor executes the computer program to implement the steps of the method according to the first aspect of the present application.

A fifth aspect of an embodiment of the present application provides a program debugging system, including: the system comprises a client, a middle server and a background server, wherein the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the background server is configured to perform the steps of the method according to the first aspect of the present application.

By adopting the method for debugging the program, the middle platform server receives the target program segment in the multiple program segments of the program to be debugged sent by the client, and then sends the target program segment to the background server for execution. And under the condition that the target program segment comprises a result display function, the background server successively executes a part of programs and the result display function to obtain the value of the ciphertext variable and convert the value of the ciphertext variable into a plaintext result, and the middle server obtains the plaintext result from the background server and transfers the plaintext result to the client.

In a program scene based on cipher text, by executing the method for debugging the program provided by the embodiment of the application, each program segment in a plurality of program segments of the program to be debugged can be tested independently, and a plaintext result after the program segment is executed can be obtained under the condition that the program segment includes a result display function, a middle server obtains the plaintext result from a background server and transfers the plaintext result to a client, and a program developer can judge the correctness of the small segment of the program segment according to the plaintext result. Therefore, the method provided by the embodiment of the application is beneficial to positioning the abnormal position from the whole program to be debugged more quickly and accurately, so that the programming efficiency is improved, and the code correctness in the program is ensured.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the description of the embodiments of the present application will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art that other drawings can be obtained according to these drawings without inventive exercise.

FIG. 1 is a flow chart of a method for debugging a program according to an embodiment of the present application;

FIG. 2 is a diagram of a program debugging system according to an embodiment of the present application;

FIG. 3 is an example of a program to be debugged according to an embodiment of the present application;

FIG. 4 is a diagram of a program debugging system according to another embodiment of the present application;

FIG. 5 is a flow chart of a method for debugging a program according to another embodiment of the present application;

FIG. 6 is a flow chart of a method for debugging a program according to another embodiment of the present application;

FIG. 7 is a diagram of a program debugging system according to another embodiment of the present application;

FIG. 8 is a schematic diagram illustrating the operation of a target compute node according to another embodiment of the present application;

fig. 9 is a schematic diagram of an apparatus for debugging a program according to an embodiment of the present application.

Detailed Description

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the embodiments described below are some, but not all, embodiments of the present application. 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 application.

The applicant found that in the related art, in the context of writing a ciphertext-based program, variables in the program are typically encrypted by an encryption function. When a developer debugs a program, the plaintext result calculated in the last step in the program can be obtained only after the whole program is completely executed, that is, the plaintext data of the ciphertext variable can be checked only after the whole program is completely executed. If an exception exists in the program, developers are difficult to accurately and quickly locate the exception position in the program, the programming efficiency is influenced, and the correctness of codes in the program is difficult to ensure.

Based on the above findings, the applicant has proposed some solutions to the above problems, and aims to more accurately and quickly locate an abnormal position in a program when writing a ciphertext-based program.

Referring to fig. 1, fig. 1 is a flowchart of a method for debugging a program according to an embodiment of the present application. The method is applied to a background server in a program debugging system, and referring to fig. 2, fig. 2 is a schematic diagram of the program debugging system according to an embodiment of the present application. As shown in fig. 2, the program debugging system includes a client, a middle server, and a background server. The number of the clients can be one or more, each client is in communication connection with the middle server, and the middle server is in communication connection with the background server.

As shown in fig. 1 and 2, the method comprises the steps of:

step S11: and receiving a program segment execution request sent by the middle server, wherein the program segment execution request is sent to the middle server by the client and carries a target program segment in the program to be debugged, and the target program segment is any one of a plurality of program segments obtained after the client splits the program to be debugged according to the received breakpoint setting information.

In this embodiment, the client refers to software that can interact with a user, and can segment a program to be debugged into multiple program segments according to breakpoint setting information input by the user. For example, the client may be a jupyter notebook, Ipython, or other programming software.

In this embodiment, the target program segment received by the background server may be: the client-side sequentially sends the program segments to one program segment of the middle server according to the front-back sequence of the program segments.

Referring to fig. 3, fig. 3 is an example of a program to be debugged according to an embodiment of the present application. Taking the program shown in fig. 3 as an example, a developer writes the program in a ciphertext-based scenario by using a client, so that variables a1, a2, a3, a4, and a5 in the program are encrypted. As shown in fig. 3, the developer encrypts the variables using encryption functions such as pp.sint (), pp.iarr (), and the like. The developer inputs breakpoint setting information to the client, and the client divides the program into a plurality of program segments according to the breakpoint setting information. As shown in FIG. 3, for example, the program is divided into five program segments, i.e., in [5], in [6], in [7], in [8] and in [9], where in [5], in [6], etc. are displayed as one UI element on the screen of the client, so that the user can more quickly distinguish the position of each breakpoint. It should be understood that the encryption functions shown in fig. 3, such as pp.sint (), pp.iarr (), etc., are merely exemplary of a variety of alternative encryption functions and are not intended to limit the present application.

When debugging the program to be debugged shown in fig. 3, the middle server receives the program segments in [5], in [6], in [7], in [8], in [9], and the like sent by the client in sequence, and transfers the received program segments to the background server. Specifically, the middle server receives the in 5 program segment sent by the client, and transfers the in 5 program segment to the background server for execution. After the in 5 program segment is debugged, the middle server receives the in 6 program segment sent by the client and transfers the in 6 program segment to the background server for execution, so as to start debugging the in 6 program segment.

Step S12: and responding to the program segment execution request, under the condition that the target program segment comprises a partial program and a result display function, executing the partial program to obtain a value of a ciphertext variable, then executing the result display function, and converting the value of the ciphertext variable to obtain a plaintext result.

In this embodiment, a part of the program is used to calculate the ciphertext variable, thereby obtaining the value of the ciphertext variable; the result display function is used for converting the value of the ciphertext variable into a plaintext result.

Taking the in [6] program segment in the program to be debugged shown in fig. 3 as an example, where res, a1, and a2 are all ciphertext variables, the background server calculates the value of the ciphertext variable res by executing the code "res ═ a1 × a 2", and then converts the value of the ciphertext variable res into a plaintext result by executing the code "pp. It should be understood that the debug _ recent () function shown in fig. 3 is only one example of a variety of optional result presentation functions and is not intended to limit the present application.

Step S13: and sending the plaintext result to the middle station server so as to send the plaintext result to the client through the middle station server.

In the method including steps S11 to S13, the information interaction between the middle station server and the client may be performed based on an HTTP Protocol, and the information interaction between the middle station server and the background server may be performed based on a GRPC Protocol (Google Remote procedure call Protocol). It should be understood that the information interaction protocol used among the client, the middle server and the background server is not limited to the above examples, and the above examples should not be construed as limiting the present application.

Under the program scene based on the ciphertext, by executing the method comprising the steps S11 to S13, each program segment in a plurality of program segments of the program to be debugged can be tested independently, and in the case that the program segment comprises a result display function, a plaintext result after the program segment is executed can be obtained, the middle server obtains the plaintext result from the background server and transfers the plaintext result to the client, and the program developer can judge the correctness of the small segment of program segment according to the plaintext result. Therefore, the method provided by the embodiment of the application is beneficial to positioning the abnormal position from the whole program to be debugged more quickly and accurately, so that the programming efficiency is improved, and the code correctness in the program is ensured.

Referring to fig. 4, fig. 4 is a schematic diagram of a program debugging system according to another embodiment of the present application. The background server of the program debugging system may include a plurality of computing nodes and a plurality of data nodes, and for simplifying the drawing, only one computing node (taking the computing node as a target computing node for example) and one data node (taking the data node as a target data node for example) are schematically shown in fig. 4.

The target computing node is used for executing codes of the target program segment, and the target data node is used for temporarily storing program segment execution results of the target computing node, such as plaintext results. The plurality of computing nodes may be distributed among a plurality of computers, and the plurality of data nodes may be distributed among a plurality of computers. The same computer may include at least one computing node, and may also include at least one data node. In the above case, the background server may be understood as a sum of a plurality of computers.

In the case where the background server includes a plurality of computing nodes and a plurality of data nodes, referring to fig. 5, fig. 5 is a flowchart of a method for debugging a program according to another embodiment of the present application.

As shown in fig. 4 and 5, the method includes the steps of:

step S51: and receiving a program segment execution request sent by the middle server by a target computing node in the plurality of computing nodes, wherein the target computing node is distributed by the middle server for the program to be debugged.

Considering that the middle server may face multiple clients simultaneously and perform parallel processing on respective programs to be debugged of the multiple clients, after each program to be debugged is allocated with a target computing node by the middle server, not only can parallel computing be realized, but also debugging efficiency is improved, and running stability inside the background server can be ensured.

In this embodiment, the middlebox server selects at least one computing node in an available state from the plurality of computing nodes of the background server, and determines the selected computing node as a target computing node to be allocated to the program to be debugged. The available state refers to a computing node which is not in a shutdown or downtime state.

Illustratively, each computing node periodically sends heartbeat information to the middle station server, and the middle station server receives and stores the heartbeat information sent by each computing node, wherein the heartbeat information represents the state of the computing node. For example, when the intermediate server does not receive heartbeat information of a certain computing node for a plurality of times, it indicates that the computing node is powered off or down, the intermediate server may update the state of the computing node from an available state to an unavailable state, and when the computing node is allocated for a subsequent program to be debugged, the computing node in the unavailable state is not allocated to the program to be debugged.

In this embodiment, taking the program to be debugged shown in fig. 3 as an example, the 12 th computing node of the 50 computing nodes of the background server is used as a target computing node, and is allocated to the program to be debugged by the middle server. When the middle server receives a program segment execution request carrying the in 6 program segment sent by the client, the middle server sends the in 6 program segment to the 12 th computing node for execution.

S52: and the target computing node sends value-taking prompt information to the middle station server.

In this embodiment, the target computing node sends the value-taking prompt message to the middle station server after executing the target program segment.

S53: and receiving a value taking request sent by the middle station server by a target data node in the plurality of data nodes, wherein the value taking request is sent by the middle station server in response to the value taking prompt message, and the target data node is distributed by the middle station server for the program to be debugged.

In this embodiment, the middle station server receives the value-taking prompt message sent by the target computing node, and indicates that the target computing node has obtained a program segment execution result, that is, a plaintext result, and then sends a value-taking request to the target data node.

In this embodiment, the allocated target data node is used to temporarily store the program segment execution result obtained after the target computing node executes the target program segment.

S54: and the target data node responds to the value taking request, obtains the program segment execution result from the target computing node and sends the program segment execution result to the middle server.

In this embodiment, the target data node sends the program segment execution result to the middleware server, and thus sends the program segment execution result to the client through the middleware server.

In this embodiment, the target data node responds to the value taking request sent by the middlebox server, and determines a target computing node serving the same program to be debugged from a plurality of computing nodes in the background server through computing node identification information sent by the middlebox server in advance, so that the target data node can communicate with the target computing node to obtain a program segment execution result. Wherein, the computing node identification information may be an IP address, a port number, etc. of the computing node. The information of the computing node identification of each computing node is stored in the middle-stage server, and the computing node identification information acquired by the target data node may be information carried by the configuration information when the middle-stage server sends the configuration information to the target data node after the target computing node and the target data node are allocated to the program to be debugged. Or the computer identification information may also be information carried by the value taking request when the middle station server sends the value taking request to the target data node.

In this embodiment, the background server sends the plaintext result to the middle server by executing steps S51 to S54. And in steps S51 to S54, the target computing node and the target data node cooperate with each other in a division manner, wherein the target computing node is used for executing the target program segment, and the target data node is used for temporarily storing the program segment execution result and interacting with the middle server, so that the program segment execution result is returned to the middle server. Under the condition that the target computing node and the target data node are in work sharing and cooperation, the parallel performance of the program debugging system is improved, the debugging efficiency is improved, and the stability of the background server is enhanced.

The method comprises the steps of considering that a middle server can face a plurality of clients at the same time and conduct parallel processing aiming at programs to be debugged of the clients. In order to enable the middlebox server to distinguish a plurality of programs to be debugged that are processed in parallel, in this embodiment, the middlebox server may configure a first identifier for each program to be debugged, where the first identifiers of the programs to be debugged are different from each other. In view of the above, please refer to fig. 6, fig. 6 is a flowchart of a method for debugging a program according to another embodiment of the present application.

As shown in fig. 6, the method comprises the steps of:

s61: and receiving a program segment execution request which is sent by the middle platform server and carries a first identifier, and storing the first identifier, wherein the first identifier is configured for the program to be debugged by the middle platform server.

In this embodiment, the configuration of the first identifier for the program to be debugged by the middlebox server may be regarded as a preparation work executed by the middlebox server before the program debugging system debugs the program to be debugged. Taking the program to be debugged shown in fig. 3 as an example, the middlebox server configures a first identifier for the program to be debugged in advance, and then the program debugging system starts to debug program segments in [5] to in [9] respectively.

For example, before the client debugs the program to be debugged through the middle server and the background server, the client may send a debugging request to the middle server in advance, and the middle server responds to the debugging request, so as to configure the first identifier for the program to be debugged of the client.

Or exemplarily, before the client debugs the program to be debugged through the middle server and the background server, the client sends a data set binding request to the middle server in advance, and aims to enable the middle server to respond to the data set binding request, so as to send a data set list to the client, enable the client to bind a data set for a ciphertext variable in the program to be debugged according to the data set list, and initialize the ciphertext variable according to the bound data set when the background server executes the program segment. The middle server responds to the data set binding request, so that the first identifier can be configured for the program to be debugged of the client.

The method comprises the steps that the middle server configures a first identifier for a program to be debugged in advance, so that when the middle server performs information interaction with a client or a background server later, the middle server can determine which specific program to be debugged in a plurality of programs to be debugged according to received information sent by the client or the background server. Therefore, when the middlebox server performs information interaction with the client or the background server, each piece of interaction information may carry the first identifier of the corresponding program to be debugged, as in step S61 above.

S62: and combining the first identifier with the plaintext result to obtain a plaintext result carrying the first identifier.

In this embodiment, before step S62, the background server needs to respond to the program segment execution request sent by the middle server, and when the target program segment includes the partial program and the result display function, execute the partial program to obtain the value of the ciphertext variable, then execute the result display function, and convert the value of the ciphertext variable to obtain the plaintext result.

S63: and sending the plaintext result carrying the first identifier to the middle station server, so that the middle station server determines the client corresponding to the first identifier according to the first identifier, and then sends the plaintext result carrying the first identifier to the determined client.

Taking the program to be debugged shown in fig. 3 as an example, when the background server includes a plurality of computing nodes and a plurality of data nodes, and each program to be debugged is allocated with a corresponding target computing node and a corresponding target data node, assuming that the first identifier configured for the program to be debugged by the middle server is ts0021, after the middle server sends the first identifier ts0021 to the client, the preparation process of the middle server before the program debugging is completed is represented. After receiving the first identifier ts0021, the client starts to send the program segments in [5] to in [9] to the middle server one by one, so that the program segments are transferred to the background server through the middle server to be executed. Taking the program segment in [6] as an example, the client sends a program segment execution request carrying the first identifier ts0021 and the program segment in [6] to the middle server.

After receiving the program segment execution request, the middle server determines a target computing node corresponding to the first identifier ts0021 in the multiple computing nodes of the background server according to the first identifier ts0021 carried by the middle server. The middle server sends the first identifier ts0021 and the program segment in [6] to the target computing node. And after the target computing node executes the program segment in [6], sending value-taking prompt information to the middle station server. And the middle server responds to the value prompt message and sends a value request to the target data node corresponding to the first identifier ts 0021. And the target data node responds to the value taking request, acquires a program segment execution result carrying the first identifier ts0021 from the target computing node, and stores the program segment execution result. And the middle server acquires the program segment execution result carrying the first identifier ts0021 from the target data node, and determines the corresponding program to be debugged according to the first identifier ts0021, so as to determine the client corresponding to the program to be debugged. And the middle server sends the program segment execution result to the client.

It should be understood that the present application is not limited to the above examples. For example, after the middle server receives a program segment execution request carrying the first identifier ts0021 and the program segment in [6], and determines a target computing node corresponding to the first identifier ts0021 in a plurality of computing nodes of the middle server according to the first identifier ts0021, the middle server may send the program segment in [6] to the target computing node. After receiving the value-taking prompt message sent by the target computing node, the middle-station server can send the value-taking request carrying the first identifier ts0021 to the corresponding target data node. And the target data node responds to the value taking request, acquires a program segment execution result from the target computing node, and returns the program segment execution result and the first identifier ts0021 carried by the value taking request to the middle server. And the middle server determines the corresponding program to be debugged according to the first identifier ts0021, so as to determine the client corresponding to the program to be debugged. And the middle server sends the program segment execution result to the client.

It is considered that before debugging the program to be debugged, the ciphertext variable in the program to be debugged needs to be initialized. One possible implementation is: the ciphertext variable is initialized manually. Another possible implementation is: the debugging method is executed through a background server to improve debugging efficiency. Specifically, the background server may initialize the ciphertext variable by performing the following steps:

s12-1: receiving a second identifier sent by the middle server, wherein the second identifier is an identifier of a target data set bound by the middle server for a ciphertext variable in the program to be debugged;

s12-2: and initializing the value of the ciphertext variable in the program to be debugged by using the numerical value in the target data set.

The process that the middle server binds the target data set for the ciphertext variable in the program to be debugged in advance may be: taking the program to be debugged shown in fig. 3 as an example, the client sends a data set query request to the middlebox server. The middle server responds to the data set query request, sends a data set list to the client, and the client receives and displays the data set list to developers. And the client receives the binding information input by the developer and forms a data set binding request according to the binding information. Assuming that a developer selects 3 ten thousand artificial resource data sets with the second identifier sjj006 in the data set list and binds the data sets to the ciphertext variable a1 in the program to be debugged shown in fig. 3, at least the second identifier sjj006 is carried in the data set binding request. The client sends the data set binding request to the central station server, and the central station server binds the ciphertext variable a1 with 3 ten thousand artificial resource data sets according to the second identifier sjj006 carried by the data set binding request.

The process of binding the target data set for the ciphertext variable in the program to be debugged in advance by the middle station server may be regarded as: and the program debugging system prepares the middle-stage server before debugging the program to be debugged.

After the foreground server binds the target data set for the ciphertext variable in the program to be debugged in advance, the background server may perform steps S12-1 and S12-2 during the running of the target program segment in step S12, i.e., in response to the program segment execution request of the foreground server. In step S12-1, the second identifier sent by the middle station server may be information carried in the program segment execution request sent by the middle station server. The background server stores the value of each data set, and in step S12-2, the background server determines the corresponding data set according to the received second identifier, and assigns a value to the ciphertext variable using the value of the data set.

Following the above example, when the target computing node corresponding to the program to be debugged shown in fig. 3 executes the target program segment, the second identifier sjj006 corresponding to the ciphertext variable a1 is obtained, and a corresponding data node is determined according to the second identifier sjj006, where the data node stores a specific value of 3 ten thousand artificial resource data sets. The target computing node reads the specific values of the 3 ten thousand artificial data sets, thereby initializing the ciphertext variable a 1.

The background server executes the steps, so that a developer can directly utilize the existing data set of the program debugging system or the data set derived from other databases. On one hand, the debugging efficiency can be improved, and the labor cost is reduced; on the other hand, the data sets can comprise a plurality of numerical values, and the data sets comprising the plurality of numerical values are used for initializing the ciphertext variables, so that the initial values of the ciphertext variables are relatively random, the false detection risk caused by single detection data can be effectively reduced, and the detection accuracy is improved.

It is considered that the background server may cause the state of the background server to change in the case where an error code exists in the target program segment when the background server executes the target program segment. Therefore, the state result for representing the running state of the background server can reflect the correctness of the target program segment to a certain extent. Based on the above consideration, the background server may further include the following steps:

obtaining a state result representing the self running state; and sending the state result to the middle station server, so that the middle station server combines the state result with the plaintext result to obtain a calculation result, and then sending the calculation result to the client.

For example, the running state characterizing the background server may be: the target computing node executes the error code in the target program segment, so that the communication between the target computing node and the middle station server is disconnected, for example, the GRPC connection between the target data node and the middle station server is disconnected. Or, the operation state of the characterization background server may also be: and the target computing node cannot match the corresponding data set from the data node according to the second identifier corresponding to the ciphertext variable.

The background server enables the middle platform server to combine the state result with the plaintext result to obtain a calculation result by sending the state result to the middle platform server, so that the calculation result is sent to the client, developers can more comprehensively master the execution condition of the target program segment, and the abnormal position can be more accurately positioned from the program to be debugged.

Considering that the middle server may face multiple clients at the same time, parallel processing is performed on the programs to be debugged of the multiple clients, and the program segment execution results of the target program segments of the programs to be debugged are stored at the same time. Since the variable names of the ciphertext variables in each target program segment may overlap, in order to avoid confusion of program segment execution results when the variable names of a plurality of ciphertext variables are the same, the middlebox server may set a storage area for storing the plaintext result for the program to be debugged, where the storage area is not overlapped with a storage area for storing plaintext results corresponding to other programs to be debugged.

For example, the staging server may set a storage area for the program to be debugged in advance before debugging all program segments of the program to be debugged. Taking the program to be debugged shown in fig. 3 as an example, the middle server sets a storage area for the program to be debugged in advance, and then starts to debug the program segments in [5] to in [9] one by one.

The above embodiment is based on the case where the result presentation function is included in the target program segment. While some program segments in the program to be debugged may not include result presentation functions.

For example, in the case that the target program segment is a calculation program, the background server executes the calculation program to obtain a null result, and sends the null result to the middle server, so as to send the null result to the client through the middle server.

For example, when the target program segment is an exit program, the background server executes the exit program to obtain a null result, and sends the null result to the middle server, so as to send the null result to the client through the middle server. In addition, after the target computing node executes the exit program, the corresponding relation with the program to be debugged can be released. Similarly, the target data node may also release the corresponding relationship with the program to be debugged.

Referring to fig. 7, fig. 7 is a schematic structural diagram of a program debugging system according to another embodiment of the present application, and fig. 7 illustrates an information interaction process among a client, a middle server, and a background server in the foregoing embodiments. In fig. 7, the middlebox server can be divided into a first middlebox and a second middlebox. The first middle station is mainly responsible for information interaction with the client. And the second middle station is mainly responsible for interacting with a target computing node and a target data node of the background server under the condition that the target program segment comprises a part of program and a result display function, so as to obtain the execution result of the program segment. And the second middle station sends the program segment execution result to the first middle station after acquiring the program segment execution result, so that the program segment execution result is transferred to the client through the first middle station.

As shown in fig. 7, the client sends a data set query request to the first central station, and the first central station queries a data set list stored in the first central station in response to the data set query request, and returns the data set list to the client. And the client displays the data set list to the developer and forms a data set binding request according to the selection information input by the developer, wherein the data set binding request carries a second identifier of the data set selected by the developer. And then, the first middle desk allocates a target computing node for the program to be debugged of the client from the plurality of computing nodes of the background server, and allocates a target data node for the program to be debugged of the client from the plurality of data nodes of the background server.

As shown in fig. 7, in order to distinguish respective programs to be debugged of multiple clients, the first console configures a first identifier for each program to be debugged of a client. In addition, the first middle station sends initialization information to the second middle station, so that the second middle station allocates a storage space for the program to be debugged, and the second middle station establishes communication connection, such as grpc long connection, with the target data node. And after the initialization is completed, the second intermediate station sends first response execution information to the first intermediate station to represent that the initialization is executed.

As shown in fig. 7, the first middle station further sends the first configuration information to the target computing node, so that the target computing node performs configuration, and returns the second response execution information, which represents that the target computing node has completed configuration. The first configuration information may include an IP address or a port number of the target data node. And the first middle station also sends second configuration information to the target data node to configure the target data node, and returns third response execution information to represent that the target data node is configured completely. The second configuration information may include an IP address or a port number of the target computing node. And then, the first middle station returns the configured first identifier to the client, and the preparation work of the middle station server is represented to be completed.

The above interaction process can be regarded as a preparation process of the middle server before debugging the program to be debugged. Thereafter, as shown in fig. 7, the client starts to send program segment execution requests to the first middle station, where each program segment execution request sent by the client carries not only the target program segment but also the first identifier. And under the condition that the target program segment is a calculation program, the first intermediate station transfers the target program segment to the corresponding target calculation node and receives a null value result obtained after the target calculation node executes the target program segment. The first middle station returns the null result to the client.

And under the condition that the target program segment comprises the result showing function, the first middle station sends the target program segment to the target computing node. And after the target computing node executes the target program segment and obtains a plaintext result, sending value-taking prompt information to the second middle station. And the second intermediate station responds to the value prompt message and sends a first value request to the target data node. And the target data node responds to the first value taking request, sends a second value taking request to the target computing node so as to obtain a plaintext result, and returns the plaintext result to the second middle station. And the second middle station stores the plaintext result and splices the plaintext result with a state result representing the running state of the background server. And the second middle station sends the spliced plaintext result to the first middle station, so that the first middle station transfers the plaintext result to the client.

And under the condition that the target program segment is the exit program, the first intermediate station transfers the target program segment to the corresponding target computing node and receives a null value result obtained after the target computing node executes the target program segment. The first middle station returns the null result to the client.

Referring to fig. 8, fig. 8 is a schematic diagram illustrating an operation of a target computing node according to another embodiment of the present application. As shown in fig. 8, the target computing node may specifically include an operation module, and the operation module performs information interaction with the middle server based on the GRPC protocol. After receiving first configuration information sent by the middle server, the running module initializes a task corresponding to the program to be debugged in response to the first configuration information, and creates a code execution thread run _ code, which initializes a task engine.

Thereafter, as shown in fig. 8, the running module of the target computing node successively receives the program segment execution request carrying the target program segment sent by the middle station server. The operation module puts the received target program segment into a waiting queue code _ q, releases a has _ code signal to a code execution thread run _ code, and represents that a new target program segment waiting for execution is received, so that the thread run _ code can acquire the target program segment from the queue code _ q for execution. The code execution thread run _ code responds to the has _ code signal, and immediately acquires and executes the target program segment if the code execution thread run _ code is currently in an idle state. And waiting if the code execution thread run _ code is currently executing another target program segment, and acquiring the target program segment from the queue code _ q for execution after the code execution thread run _ code finishes executing the other target program segment. And after the target program segment is executed, releasing a code _ done signal to the operation module, representing that the target program segment is executed completely, and informing the operation module that the execution result of the program segment can be returned. The code execution thread run _ code then re-executes the newly received target program segment.

As shown in fig. 8, when the target program segment code received by the run module is the exit program quit, the code execution thread run _ code ends the wait loop after executing the exit program quit, and ends the task engine taskengine.

Based on the same inventive concept, an embodiment of the present application provides a device for debugging a program. Referring to fig. 9, fig. 9 is a schematic diagram of an apparatus for program debugging according to an embodiment of the present application. The device for debugging the program is applied to a background server in a program debugging system, the program debugging system further comprises a client and the background server, the client is in communication connection with the middle platform server, and the middle platform server is in communication connection with the background server. As shown in fig. 9, the apparatus of the debugging program includes:

a receiving module 91, configured to receive a program segment execution request sent by the middle server, where the program segment execution request is sent by the client to the middle server and carries a target program segment in a program to be debugged, and the target program segment is any one of multiple program segments obtained after the client splits the program to be debugged according to the received breakpoint setting information;

an execution module 92, configured to respond to the program segment execution request, execute a part of the program to obtain a value of a ciphertext variable when the target program segment includes the part of the program and a result display function, then execute the result display function, and convert the value of the ciphertext variable to obtain a plaintext result; and the number of the first and second groups,

a sending module 93, configured to send the plaintext result to the middle station server, so as to send the plaintext result to the client through the middle station server.

the first receiving module includes:

the first transmitting module includes:

Optionally, the first receiving module includes:

the first transmitting module includes:

Optionally, the apparatus further comprises:

Optionally, the execution module of the apparatus is further configured to:

Based on the same inventive concept, another embodiment of the present application provides a computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, implements the steps in the method according to any of the above-mentioned embodiments of the present application.

Based on the same inventive concept, another embodiment of the present application provides a backend server, including a memory, a processor, and a computer program stored on the memory and executable on the processor, where the processor executes the computer program to implement the steps in the method according to any of the above embodiments of the present application.

Based on the same inventive concept, another embodiment of the present application provides a program debugging system, including: the system comprises a client, a middle server and a background server, wherein the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the background server is configured to perform the steps of the method according to any of the embodiments described above.

For the device embodiment, since it is basically similar to the method embodiment, the description is simple, and for the relevant points, refer to the partial description of the method embodiment.

The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.

As will be appreciated by one of skill in the art, embodiments of the present application may be provided as a method, apparatus, or computer program product. Accordingly, embodiments of the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing terminal to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing terminal to cause a series of operational steps to be performed on the computer or other programmable terminal to produce a computer implemented process such that the instructions which execute on the computer or other programmable terminal provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

While preferred embodiments of the present application have been described, additional variations and modifications of these embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including the preferred embodiment and all such alterations and modifications as fall within the true scope of the embodiments of the application.

Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or terminal that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or terminal. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or terminal that comprises the element.

The method, the device, the background server, the storage medium and the system for debugging the program provided by the application are introduced in detail, and a specific example is applied in the text to explain the principle and the implementation of the application, and the description of the embodiment is only used for helping to understand the method and the core idea of the application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.

Claims

1. A method for debugging a program is characterized in that the method is applied to a background server in a program debugging system, the program debugging system further comprises a client and a middle server, the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the method comprises the following steps:

2. The method of claim 1, wherein the backend server comprises a plurality of compute nodes and a plurality of data nodes; receiving a program segment execution request sent by the middle station server, wherein the program segment execution request comprises:

wherein sending the plaintext result to the middle station server comprises:

3. The method of claim 1, wherein receiving the program segment execution request sent by the middle station server comprises:

4. The method of claim 1, further comprising:

obtaining a state result representing the self running state;

5. The method of claim 1, further comprising:

6. The method of claim 1, further comprising:

7. A device for debugging a program is characterized by being applied to a background server in a program debugging system, wherein the program debugging system further comprises a client and a middle server, the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the device comprises:

8. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 6.

9. A backend server comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor, when executing the computer program, implements the steps of the method according to any one of claims 1 to 6.

10. A program debugging system, comprising: the system comprises a client, a middle server and a background server, wherein the client is in communication connection with the middle server, and the middle server is in communication connection with the background server; the backend server is configured to perform the steps of the method according to any one of claims 1 to 6.