Process processing method and device, server and storage medium

Abstract

The invention provides a process processing method and device, a server and a storage medium. The method comprises the following steps: receiving a task process control request sent by a front end, analyzing the task process control request, and obtaining configuration information of a target task process; generating a corresponding data object according to the configuration information, and storing the data object in a database; if the newly added data object of the database is monitored, determining a corresponding target node according to the data object; and sending a task process execution request to the target node based on the data object, so that the target node executes a corresponding operation on the target task process based on the execution request and feeds back the state of the target task process, and sending the state of the target task process to the front end. And the corresponding task execution request is sent to the target node, the process of the remote node can be effectively deployed, and the state of the process can be obtained, so that a user can timely know the state of the process.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a process processing method, device, server and storage medium. Background Art

[0002] A process is an operation of a program in a computer on a certain data set. It is the basic unit for resource allocation and scheduling in the system and the foundation of the operating system structure. A computer cluster is generally composed of multiple physical nodes, and multiple processes can run on each physical node.

[0003] At present, remote process automation deployment mainly uses the Ansible tool and the systemd module it provides. Ansible is an automation tool written based on the SSH protocol and Python. It first connects to the remote host through the SSH protocol and starts the task process according to the written Playbook and systemd module.

[0004] However, based on the Ansible tool and systemd module management process, Ansible needs to rely on the Python environment of the local host, and the communication between Ansible and the remote host depends on the ssh protocol. If the remote host does not open the ssh protocol or cannot use the ssh protocol, the remote host process cannot be managed. In addition, Ansible lacks the ability to monitor the status of the remote process in real time, and users cannot perceive the current status of the process in time. Summary of the invention

[0005] The present application provides a process processing method, device, server and storage medium to solve the technical problem that the existing deployment method cannot well deploy the process of the remote host and cannot perceive the status of the process.

[0006] In a first aspect, the present application provides a process processing method, comprising:

[0007] Receive a task process control request sent by the front end, parse the task process control request, and obtain configuration information of the target task process, wherein the control request includes: create request, delete request, query request, modify request, and stop request;

[0008] Generate a corresponding data object according to the configuration information, and store the data object in a database;

[0009] If a new data object is detected in the database, a corresponding target node is determined according to the data object;

[0010] Sending a task process execution request to the target node based on the data object, so that the target node performs a corresponding operation on the target task process based on the execution request and feeds back a status of the target task process;

[0011] The state of the target task process is received, and the state of the target task process is sent to the front end.

[0012] Optionally, in the method as described above, determining the corresponding target node according to the data object includes:

[0013] Obtaining a mapping relationship between a preset node identifier and a remote node, and matching the execution node identifier in the data object with the preset node identifier in the mapping relationship;

[0014] A remote node corresponding to a preset node identifier matching the execution node identifier is determined as the target node.

[0015] Optionally, the method as described above further comprises:

[0016] Receive the current status of the target task process fed back by the target node;

[0017] comparing a current state to a desired state in the data object;

[0018] If the current state is inconsistent with the expected state, the task process execution request is resent to the target node based on the data object.

[0019] Optionally, the method as described above further comprises:

[0020] If the expected state change is monitored, the current state of the started target task process is obtained from the target node;

[0021] Compare the current state to the desired state of the change;

[0022] If the current state is inconsistent with the desired state of the change, sending a task process stop request to the target node;

[0023] or,

[0024] If the current state is inconsistent with the expected state of the change, the task process execution request is resent to the target node based on the data object.

[0025] In a second aspect, the present application also provides a process processing method, comprising:

[0026] Receive a task process execution request sent by a server, parse the task process execution request, and obtain a corresponding data object; the server receives a task process control request sent by a front end, parses the task process control request, obtains configuration information of a target task process, generates a corresponding data object according to the configuration information, and stores the data object in a database; after monitoring a newly added data object in the database, determine a corresponding target node according to the data object, and send a task process execution request to the target node based on the data object, wherein the control request includes: a create request, a delete request, a query request, a modify request, and a stop request;

[0027] Based on the execution request, a corresponding operation is performed on the target task process and the state of the target task process is fed back to the server. After receiving the state of the target task process, the server sends the state of the target task process to the front end.

[0028] Optionally, in the method as described above, the performing a corresponding operation on the target task process based on the execution request includes:

[0029] If the expected state in the data object is running, the target task process is started.

[0030] Optionally, the method as described above further comprises:

[0031] If the target task process is started, the identifier of the target task process is added to the process queue.

[0032] In a third aspect, the present application provides a process processing device, including:

[0033] A first transceiver unit, used for receiving a task process control request sent by a front end;

[0034] A first processing unit, configured to parse the task process control request and obtain configuration information of a target task process;

[0035] The first processing unit is further used to generate a corresponding data object according to the configuration information and store the data object in a database;

[0036] The first processing unit is further configured to determine a corresponding target node according to a new data object added to the database if a new data object is monitored;

[0037] The first transceiver unit is further used to send a task process execution request to the target node based on the data object, so that the target node performs a corresponding operation on the target task process based on the execution request and feeds back a status of the target task process;

[0038] The first transceiver unit is further used to receive the state of the target task process and send the state of the target task process to the front end;

[0039] The control request includes: create request, delete request, query request, modify request and stop request.

[0040] In a fourth aspect, the present application further provides a process processing device, including:

[0041] The second transceiver unit is used to receive a task process execution request sent by a server, the server receives a task process control request sent by a front end, parses the task process control request, obtains configuration information of a target task process, generates a corresponding data object according to the configuration information, and stores the data object in a database; after monitoring a newly added data object in the database, determines a corresponding target node according to the data object, and sends a task process execution request to the target node based on the data object, wherein the control request includes: a create request, a delete request, a query request, a modify request, and a stop request;

[0042] A second processing unit is used to parse the task process execution request and obtain a corresponding data object;

[0043] The second processing unit is further configured to perform a corresponding operation on the target task process based on the execution request;

[0044] The second transceiver unit is also used to feed back the state of the target task process to the server, and the server sends the state of the target task process to the front end after receiving the state of the target task process.

[0045] In a fifth aspect, the present application provides a server, including: a processor, a memory and a transceiver;

[0046] Interconnection of processor, memory and transceiver circuits;

[0047] Memory stores computer-executable instructions;

[0048] A transceiver for sending and receiving data;

[0049] The processor executes the computer-executable instructions stored in the memory, so that the processor performs the method as described in the first aspect or the second aspect.

[0050] In a sixth aspect, the present application provides a computer-readable storage medium, wherein the computer-readable storage medium stores computer-executable instructions, and when the computer-executable instructions are executed by a processor, they are used to implement the method described in the first aspect or the second aspect.

[0051] The process processing method, device, server and storage medium provided in the present application receive a task process control request sent by a front end, parse the task process control request, and obtain configuration information of a target task process, wherein the control request includes: a create request, a delete request, a query request, a modify request and a stop request; generate a corresponding data object according to the configuration information, and store the data object in a database; if a new data object is added to the database by monitoring, determine the corresponding target node according to the data object; send a task process execution request to the target node based on the data object, so that the target node performs corresponding operations on the target task process based on the execution request and feedbacks the status of the target task process, receives the status of the target task process, and sends the status of the target task process to the front end. By receiving the task process control request sent by the front end and sending the corresponding task execution request to the target node, the process of the remote node can be effectively deployed, and the status of the process can be obtained so that the user can understand the process status in time. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0053] Figure 1 A schematic diagram of the network architecture of the process processing method provided in this application;

[0054] Figure 2 A flowchart of a process processing method provided for this application;

[0055] Figure 3 A schematic diagram of the structure of a front end, server and node provided for this application;

[0056] Figure 4 A schematic diagram of the structure of a server and node provided for this application;

[0057] Figure 5 A flowchart of another process processing method provided by this application;

[0058] Figure 6 A flowchart of another process processing method provided by this application;

[0059] Figure 7 A schematic diagram of the structure of a process processing device provided by this application;

[0060] Figure 8 A schematic diagram of the structure of another process processing device provided by the present application;

[0061] Fig. 9A block diagram of a server for implementing the process processing method of the present application.

[0062] The above drawings have shown clear embodiments of the present application, which will be described in more detail later. These drawings and text descriptions are not intended to limit the scope of the present application in any way, but to illustrate the concept of the present application to those skilled in the art by referring to specific embodiments. DETAILED DESCRIPTION

[0063] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the following exemplary embodiments do not represent all implementations consistent with the present application. Instead, they are merely examples of devices and methods consistent with some aspects of the present application as detailed in the appended claims.

[0064] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the following exemplary embodiments do not represent all implementations consistent with the present application. Instead, they are merely examples of devices and methods consistent with some aspects of the present application as detailed in the appended claims.

[0065] In order to clearly understand the technical solution of the present application, the solution of the prior art is first introduced in detail.

[0066] At present, remote process automation deployment mainly uses the Ansible tool and the systemd module it provides. Ansible is an automation tool written based on the SSH protocol and Python. It first connects to the remote host through the SSH protocol and starts the task process according to the written Playbook and systemd module.

[0067] However, based on the Ansible tool and systemd module management process, Ansible needs to rely on the Python environment of the local host, and the communication between Ansible and the remote host depends on the ssh protocol. If the remote host does not open the ssh protocol or cannot use the ssh protocol, the remote host process cannot be managed. In addition, Ansible lacks the ability to monitor the status of the remote process in real time, and users cannot perceive the current status of the process in time.

[0068] Therefore, in order to solve the technical problem that the existing deployment method cannot well deploy the process of the remote host and cannot perceive the status of the process, the inventor discovered in the research that the task process control request sent by the front end is received, the task process control request is parsed, and the configuration information of the target task process is obtained. The control request includes a create request, a delete request, a query request, a modify request and a stop request. The corresponding data object is further generated according to the configuration information, and the data object is stored in the database. If a new data object is added to the database, the corresponding target node is determined according to the data object, and a task process execution request is sent to the target node based on the data object. The target node performs corresponding operations on the target task based on the execution request, receives the target task process status, and sends it to the front end. By receiving the task process control request sent by the front end and sending the corresponding task execution request to the target node, the process of the remote node can be effectively deployed and the status of the process can be obtained so that the user can understand the process status in time.

[0069] Therefore, based on the above creative findings, the inventors have proposed a technical solution of the embodiment of the present application. The network architecture and application scenarios of the process processing method provided in the embodiment of the present application are introduced below.

[0070] like Figure 1 As shown, the network architecture corresponding to the process processing method provided in the embodiment of the present application includes: a front end 1, a server 2 and multiple nodes 3, the server 2 is respectively connected to the front end 1 and each node 3 in communication, the server 2 receives the task process control request sent by the front end, parses the task process control request, and obtains the configuration information of the target task process, the control request includes: create request, delete request, query request, modify request and stop request; the server 2 generates a corresponding data object according to the configuration information, and stores the data object in the database; if a new data object is added to the database, the corresponding target node is determined according to the data object; the server 2 sends a task process execution request to the target node based on the data object, the target node performs corresponding operations on the target task process based on the execution request and feedbacks the status of the target task process, the server 2 receives the status of the target task process and sends it to the front end 1, by receiving the task process control request sent by the front end and sending the corresponding task execution request to the target node, the process of the remote node can be effectively deployed, and the status of the process can be obtained, so that the user can understand the process status in time.

[0071] The embodiments of the present application will be described in detail below with reference to the accompanying drawings.

[0072] Figure 2 The following is a flow chart of a process processing method provided by the present application, which is applied to a server. Figure 2 As shown, the method includes:

[0073] Step 201, receiving a task process control request sent by the front end, parsing the task process control request, and obtaining configuration information of the target task process. The control request includes: create request, delete request, query request, modify request and stop request.

[0074] In this embodiment, the execution subject of this application is the server, see Figure 3 An API center is set up on the server, where the API center provides a task process interface for the front end to pass in process control requests, where the task process control requests include: create request, delete request, query request, modify request and stop request.

[0075] Continue to see Figure 3 The front end can be a task process configuration UI (user interface). Users can input configuration information on the front end, thereby triggering a task process control request. The API center provides a task process creation interface for creating a task process. Based on the creation interface, the API center receives the task process creation request sent by the front end, parses the task process creation request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be created. The remote node deploys multiple task processes, each of which has a different purpose.

[0076] Specifically, the API center provides a task process deletion interface for deleting a created task process. Based on the deletion interface, the API center receives a task process deletion request sent by the front end, parses the task process deletion request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be deleted.

[0077] Specifically, the API center provides a task process query interface for querying the current status of the task process. Based on the query interface, the API center receives the task process query request sent by the front end, parses the task process query request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be queried.

[0078] Specifically, the API center provides a task process modification interface for modifying the configuration information of the task process, including parameters, startup commands, expected status, etc. Based on the modification interface, the API center receives the task process modification request sent by the front end, parses the task process modification request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be modified.

[0079] Specifically, the API center provides a task process stop interface for stopping a task process. Based on the stop interface, the API center receives a task process stop request sent by the front end, parses the task process stop request, obtains configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be stopped.

[0080] Step 202: Generate corresponding data objects according to the configuration information, and store the data objects in a database.

[0081] In this embodiment, the API center obtains the configuration information of the target task process and generates a corresponding data object according to the configuration information. Specifically, the API center encapsulates the configuration information into a data object of the task process declaration API; Figure 3 ,The server is also equipped with a database, such as ETCD database. The ETCD database is connected to the API center. The API center further stores the data objects in the ETCD database. As a distributed database, the ETCD database provides the ,information storage and reading functions of process parameters and states for the ,entire framework.

[0082] Among them, the API center encapsulates the configuration information into data objects of the task process declaration API, where the data objects include: resource object version, resource object type (task process), task process command, task process parameters, task process parameters, task process environment variables, task process expected execution node, task process expected state, task process current state, task process current execution node, where, when the task process expected execution node is any, it means that it can run on any node.

[0083] Step 203: If a new data object is detected in the database, a corresponding target node is determined according to the data object.

[0084] Continue to see Figure 3 A controller is set on the server. The controller is used to monitor whether a new data object is added to the database. If the controller monitors that a new data object is added to the database, the controller obtains the new data object and determines the corresponding target node according to the new data object. The target node is one of the remote nodes. The user selects the remote node, that is, the execution node, at the front end and determines the node as the target node.

[0085] Step 204: Send a task process execution request to the target node based on the data object, so that the target node can perform corresponding operations on the target task process based on the execution request and feedback the status of the target task process.

[0086] Continue to see Figure 3The controller sends a task process execution request to the target node by calling grpc. Specifically, the controller generates a grpc call request based on the data object, sends the grpc call request to the grpc server, and the grpc server receives the grpc call request and sends the task process execution request to the target node. An executor is deployed on the target node. The executor is used to receive the process execution request. The target node performs corresponding operations on the target task process based on the execution request and feedbacks the status of the target task process, which includes running, stopped, and completed.

[0087] Step 205, receiving the state of the target task process, and sending the state of the target task process to the front end.

[0088] In this embodiment, the state of the target task process fed back by the target node is received, and the state of the target task process is sent to the front end. The front end receives the state of the target task process and displays the state of the target task process so that the user can understand the process state.

[0089] The present application receives a task process control request sent by a front end, parses the task process control request, obtains configuration information of a target task process, wherein the control request includes a create request, a delete request, a query request, a modify request, and a stop request, further generates a corresponding data object according to the configuration information, stores the data object in a database, and if a new data object is detected in the database, determines the corresponding target node according to the data object, sends a task process execution request to the target node based on the data object, and the target node performs corresponding operations on the target task based on the execution request, receives the target task process status, and sends it to the front end. By receiving the task process control request sent by the front end and sending the corresponding task execution request to the target node, the process of the remote node can be effectively deployed, and the status of the process can be obtained so that the user can understand the status of the process in a timely manner.

[0090] Figure 5 A flowchart of another process processing method provided by the present application, which is applied to a server, such as Figure 5 As shown, the method includes:

[0091] Step 501, receiving a task process control request sent by the front end, parsing the task process control request, and obtaining configuration information of the target task process. The control request includes: create request, delete request, query request, modify request and stop request.

[0092] In this embodiment, the execution subject of this application is the server, see Figure 3An API center is set up on the server, where the API center provides a task process interface for the front end to pass in process control requests, where the task process control requests include: create request, delete request, query request, modify request and stop request.

[0093] Continue to see Figure 3 The front end can be a task process configuration UI (user interface). Users can input configuration information on the front end, thereby triggering a task process control request. The API center provides a task process creation interface for creating a task process. Based on the creation interface, the API center receives the task process creation request sent by the front end, parses the task process creation request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be created. The remote node deploys multiple task processes, each of which has a different purpose.

[0094] Specifically, the API center provides a task process deletion interface for deleting a created task process. Based on the deletion interface, the API center receives a task process deletion request sent by the front end, parses the task process deletion request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be deleted.

[0095] Specifically, the API center provides a task process query interface for querying the current status of the task process. Based on the query interface, the API center receives the task process query request sent by the front end, parses the task process query request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be queried.

[0096] Specifically, the API center provides a task process modification interface for modifying the configuration information of the task process, including parameters, startup commands, expected status, etc. Based on the modification interface, the API center receives the task process modification request sent by the front end, parses the task process modification request, obtains the configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be modified.

[0097] Specifically, the API center provides a task process stop interface for stopping a task process. Based on the stop interface, the API center receives a task process stop request sent by the front end, parses the task process stop request, obtains configuration information of the target task process, and further generates a data object, wherein the target task process is the task process to be stopped.

[0098] Step 502: Generate corresponding data objects according to the configuration information, and store the data objects in a database.

[0099] In this embodiment, the API center obtains the configuration information of the target task process and generates a corresponding data object according to the configuration information. Specifically, the API center encapsulates the configuration information into a data object of the task process declaration API; Figure 3 ,The server is also equipped with a database, such as ETCD database. The ETCD database is connected to the API center. The API center further stores the data objects in the ETCD database. As a distributed database, the ETCD database provides the ,information storage and reading functions of process parameters and states for the ,entire framework.

[0100] Step 503, if a new data object is detected in the database, the mapping relationship between the preset node identifier and the remote node is obtained, and the execution node identifier in the data object is matched with the preset node identifier in the mapping relationship, and the remote node corresponding to the preset node identifier matching the execution node identifier is determined as the target node.

[0101] In this embodiment, a controller is provided on the server, and the controller is used to monitor whether a new data object is added to the database. If the controller monitors that a new data object is added to the database, the controller obtains the new data object and determines the corresponding target node according to the new data object. The target node is one of the remote nodes. The user selects the remote node, i.e., the execution node, at the front end and determines the node as the target node.

[0102] Specifically, the mapping relationship between the preset node identifier and the remote node is obtained, the data object includes the execution node identifier, the execution node identifier is matched with the preset node identifier in the mapping relationship, and the target node is determined according to the matching result. Specifically, the remote node corresponding to the preset node identifier matching the execution node identifier is determined as the target node. An executor is deployed on the remote node, and the executor is used to receive the grpc call request from the controller and further execute the start / stop operation of the target task process. After starting the target task process, the executor adds the started target task process to the process supervision queue of the executor.

[0103] Step 504: Send a task process execution request to the target node based on the data object, so that the target node can perform corresponding operations on the target task process based on the execution request and feedback the status of the target task process.

[0104] In this embodiment, the controller sends a task process execution request to the target node by calling grpc. Specifically, the controller generates a grpc call request based on the data object, and sends the grpc call request to the grpc server. The grpc server receives the grpc call request and sends the task process execution request to the target node. An executor is deployed on the target node. The executor is used to receive the process execution request. The target node performs corresponding operations on the target task process based on the execution request and feedbacks the status of the target task process, which includes running, stopped, and completed once.

[0105] See also Figure 4 , the server sets up the API center, controller and database. The API center is connected to the database, the database is connected to the controller, the server is connected to multiple nodes, and the executor is deployed on each node. The user enters the task process configuration information on the front-end interface and clicks Submit to trigger the task process control request. The server receives the task process control request sent by the front-end. The API center provides an interface for the task process for the front-end to transmit the control request. If the front-end passes in a task process creation request, the API center parses the task process creation request, obtains the configuration information of the target task process, generates the corresponding data object based on the configuration information, and stores the data object in the database; the controller monitors whether the database has new data objects. If the controller monitors the database for new data objects, the controller obtains the new data objects and determines the corresponding target nodes based on the new data objects, such as Figure 4 As shown, node 1 is the target node; the controller generates a grpc call request based on the data object, sends the grpc call request to the grpc server, the grpc server receives the grpc call request, sends a task process execution request to the target node, and the target node performs a create operation on the target task process based on the task process execution request. Process 1 is the target task process, creates process 1, uses process 1 to obtain business data, and feeds back the current status of the target task process.

[0106] Step 505, receiving the state of the target task process, and sending the state of the target task process to the front end.

[0107] In this embodiment, the state of the target task process fed back by the target node is received, and the state of the target task process is sent to the front end. The front end receives the state of the target task process and displays the state of the target task process so that the user can understand the process state.

[0108] Optionally, the method further comprises:

[0109] Receive the current state of the target task process fed back by the target node; compare the current state with the expected state in the data object; if the current state is inconsistent with the expected state, resend the task process execution request to the target node based on the data object.

[0110] In this embodiment, the server receives the current state of the target task process fed back by the target node, and the state includes running (Running), stopped (Stopped), and completed (Completed). The current state of the target task process is compared with the expected state in the data object, and it is determined whether to restart the target task process according to the comparison result, wherein the expected state includes: running (Running), stopped (Stopped), and run once (Once).

[0111] In this embodiment, if the current state of the target task process fed back by the target node is inconsistent with the expected state in the data object, for example, the expected state is running and the current state is stopped, the expected state and the current state are inconsistent, and the target task process needs to be restarted. Specifically, the task process execution request is resent to the target node based on the data object so that the current state of the restarted target task process is consistent with the expected state.

[0112] Optionally, the process processing method further includes:

[0113] If a change in the expected state is monitored, the current state of the started target task process is obtained from the target node; the current state is compared with the changed expected state; if the current state is inconsistent with the changed expected state, a task process stop request is sent to the target node; or, if the current state is inconsistent with the changed expected state, a task process start request is resent to the target node based on the changed data object.

[0114] In this embodiment, if an expected state change is monitored, the current state of the started target task process is obtained from the target node, and the current state is compared with the changed expected state; if the current state is inconsistent with the changed expected state, a task process stop request is sent to the target node to stop the operation of the target task process.

[0115] Alternatively, if the current state is inconsistent with the changed expected state, the task process execution request is resent to the target node based on the data object so that the current state of the restarted target task process is consistent with the changed expected state.

[0116] This application can effectively deploy the process of the remote node by receiving the task process control request sent by the front end and sending the corresponding task execution request to the target node, and can obtain the status of the process so that the user can understand the status of the process in time. And it can keep the current status of the process to the user's expected state.

[0117] Figure 6 A flowchart of another process processing method provided by the present application, which is applied to a server, such as Figure 6 As shown, the method includes:

[0118] Step 601, receiving the task process execution request sent by the server, parsing the task process execution request, and obtaining the corresponding data object. The server receives the task process control request sent by the front end, parses the task process control request, obtains the configuration information of the target task process, and generates the corresponding data object according to the configuration information, and stores the data object in the database; after monitoring the new data object in the database, the corresponding target node is determined according to the data object, and the task process execution request is sent to the target node based on the data object. The control request includes: create request, delete request, query request, modify request and stop request.

[0119] In this embodiment, the execution subject is the target server, that is, the target node, which receives the task process execution request sent by the server, parses the task process execution request, and obtains the corresponding data object, which includes: resource object version, resource object type (task process), task process command, task process parameters, task process parameters, task process environment variables, task process expected execution node, task process expected state, task process current state, task process current execution node, among which, when the task process expected execution node is any, it means that it can run on any node.

[0120] Among them, the server receives the task process control request sent by the front end, and the control request includes: creation request, deletion request, query request, modification request and stop request. The server parses the task process control request and obtains the configuration information of the target task process. The server generates the corresponding data object according to the configuration information and stores the data object in the database; if a new data object is detected in the database, the corresponding target node is determined according to the data object; and the task process execution request is sent to the target node based on the data object.

[0121] Step 602, based on the execution request, a corresponding operation is performed on the target task process and the state of the target task process is fed back to the server. After receiving the state of the target task process, the server sends the state of the target task process to the front end.

[0122] In this embodiment, based on the execution request, corresponding operations are performed on the target task process, such as creating a target task process, deleting a target task process, querying a target task process, modifying a target task process, and stopping a target task process, and the state of the target task is fed back to the server, and the state includes: running (Running), stopped (Stopped), and completed (Completed). The server receives the state of the target task and sends it to the front end, which receives the state of the target task and displays the state of the target task.

[0123] Optionally, performing corresponding operations on the target task process based on the execution request includes:

[0124] If the expected state in the data object is running, the target task process is started.

[0125] In this embodiment, the expected states include: Running, Stopped, and Once. If the expected state in the data object is Running, the target task process is started; if the expected state in the data object is Stopped, the target task process is stopped; if the expected state in the data object is Running Once, the target task process is run once.

[0126] Optionally, the method further comprises:

[0127] If the target task process is started, the identifier of the target task process is added to the process queue.

[0128] In this embodiment, if the target task process is started, the executor of the target node adds the identifier of the target task process to the process queue; if the target task process is stopped, the executor queries whether the identifier of the stopped target task process is in the process queue, removes it from the supervision queue, waits for the server controller to send a new process start request, starts the process again and adds the identifier of the target task process to the process queue.

[0129] The present application can effectively deploy the process of the remote node by receiving the corresponding task execution request sent by the server and then performing the corresponding operation on the target task process, and can also feedback the status of the process so that the user can understand the process status in time.

[0130] Figure 7 A schematic diagram of the structure of a process processing device provided in this application, such as Figure 7 As shown, the process processing device 700 provided in this embodiment includes a first transceiver unit 701 and a first processing unit 702 .

[0131] Among them, the first transceiver unit 701 is used to receive the task process control request sent by the front end. The first processing unit 702 is used to parse the task process control request and obtain the configuration information of the target task process. The first processing unit 702 is also used to generate the corresponding data object according to the configuration information and store the data object in the database. The first processing unit 702 is also used to determine the corresponding target node according to the data object if a new data object is monitored in the database. The first transceiver unit 701 is also used to send a task process execution request to the target node based on the data object, so that the target node can perform corresponding operations on the target task process based on the execution request and feedback the status of the target task process. The first transceiver unit is also used to receive the status of the target task process and send the status of the target task process to the front end; the control request includes: create request, delete request, query request, modify request and stop request.

[0132] Optionally, the first processing unit 702 is also used to obtain a mapping relationship between a preset node identifier and a remote node, and match the execution node identifier in the data object with the preset node identifier in the mapping relationship; and determine the remote node corresponding to the preset node identifier matching the execution node identifier as the target node.

[0133] Optionally, the first transceiver unit 701 is further used to receive the current state of the target task process fed back by the target node. The first processing unit 702 is further used to compare the current state with the expected state in the data object. The first transceiver unit 701 is also used to resend the task process execution request to the target node based on the data object if the current state is inconsistent with the expected state.

[0134] Optionally, the first processing unit 702 is further used to obtain the current state of the started target task process from the target node if the expected state change is monitored. The first processing unit 702 is also used to compare the current state with the changed expected state. The first transceiver unit 701 is also used to send a task process stop request to the target node if the current state is inconsistent with the changed expected state; or, the first transceiver unit 701 is also used to resend the task process execution request to the target node based on the data object if the current state is inconsistent with the changed expected state.

[0135] Figure 8 A structural diagram of another process processing device provided by this application, such as Figure 8 As shown, the process processing device 800 provided in this embodiment includes a second transceiver unit 801 and a second processing unit 802 .

[0136] Among them, the second transceiver unit 801 is used to receive the task process execution request sent by the server, the server receives the task process control request sent by the front end, parses the task process control request, obtains the configuration information of the target task process, and generates the corresponding data object according to the configuration information, and stores the data object in the database; after monitoring the newly added data object in the database, the corresponding target node is determined according to the data object, and the task process execution request is sent to the target node based on the data object. The control request includes: create request, delete request, query request, modify request and stop request;

[0137] The second processing unit 802 is used to parse the task process execution request and obtain the corresponding data object;

[0138] The second processing unit 802 is also used to perform corresponding operations on the target task process based on the execution request and feedback the status of the target task process to the server. After receiving the status of the target task process, the server sends the status of the target task process to the front end.

[0139] Optionally, the second processing unit 802 is further configured to start a target task process if the expected state in the data object is running.

[0140] Optionally, the second processing unit 802 is further configured to add an identifier of the target task process to a process queue if the target task process is started.

[0141] Fig. 9 A block diagram of a server for implementing the process processing method of the present application is shown in FIG. Fig. 9 As shown, the server 900 includes: a memory 901 , a processor 902 and a transceiver 903 .

[0142] The processor 902, the memory 901 and the transceiver 903 are interconnected;

[0143] A transceiver 903, used for sending and receiving data;

[0144] The memory 901 stores computer executable instructions;

[0145] The processor 902 executes the computer-executable instructions stored in the memory 901, so that the processor 902 executes the method provided by any of the above embodiments.

[0146] In an exemplary embodiment, a computer-readable storage medium is further provided, in which computer-executable instructions are stored. The computer-executable instructions are executed by a processor to execute the method in any one of the above embodiments.

[0147] In an exemplary embodiment, a computer program product is also provided, including a computer program, and the computer program is executed by a processor to execute the method in any one of the above embodiments.

[0148] It should be noted that, for the aforementioned method embodiments, for the sake of simplicity, they are all expressed as a series of action combinations, but those skilled in the art should be aware that the present application is not limited by the described order of actions, because according to the present application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily required by the present application.

[0149] It should be further noted that, although the various steps in the flowchart are displayed in sequence according to the indication of the arrows, these steps are not necessarily executed in sequence in the order indicated by the arrows. Unless there is a clear description in this article, the execution of these steps is not strictly limited in order, and these steps can be executed in other orders. Moreover, at least a portion of the steps in the flowchart may include multiple sub-steps or multiple stages, and these sub-steps or stages are not necessarily executed at the same time, but can be executed at different times, and the execution order of these sub-steps or stages is not necessarily to be carried out in sequence, but can be executed in turn or alternately with other steps or at least a portion of the sub-steps or stages of other steps.

[0150] It should be understood that the above-mentioned device embodiments are only illustrative, and the device of the present application can also be implemented in other ways. For example, the division of units / modules in the above-mentioned embodiments is only a logical function division, and there may be other division methods in actual implementation. For example, multiple units, modules or components can be combined, or can be integrated into another system, or some features can be ignored or not executed.

[0151] In addition, unless otherwise specified, each functional unit / module in each embodiment of the present application may be integrated into one unit / module, each unit / module may exist physically separately, or two or more units / modules may be integrated together. The above-mentioned integrated unit / module may be implemented in the form of hardware or in the form of a software program module.

[0152] If the integrated unit / module is implemented in the form of hardware, the hardware may be a digital circuit, an analog circuit, etc. The physical implementation of the hardware structure includes but is not limited to transistors, memristors, etc. If not specifically stated, the processor may be any appropriate hardware processor, such as a CPU, a GPU, an FPGA, a DSP, an ASIC, etc. If not specifically stated, the storage unit may be any appropriate magnetic storage medium or magneto-optical storage medium, such as a resistive random access memory RRAM (Resistive Random Access Memory), a dynamic random access memory DRAM (Dynamic Random Access Memory), a static random access memory SRAM (Static Random-Access Memory), an enhanced dynamic random access memory EDRAM (Enhanced Dynamic Random Access Memory), a high-bandwidth memory HBM (High-Bandwidth Memory), a hybrid memory cube HMC (Hybrid Memory Cube), etc.

[0153] If the integrated unit / module is implemented in the form of a software program module and sold or used as an independent product, it can be stored in a computer-readable memory. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art or all or part of the technical solution, can be embodied in the form of a software product, which is stored in a memory and includes several instructions for a computer device (which can be a personal computer, a server or a network device, etc.) to perform all or part of the steps of the various embodiments of the present application. The aforementioned memory includes: U disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), mobile hard disk, disk or optical disk and other media that can store program codes.

[0154] In the above embodiments, the description of each embodiment has its own emphasis. For parts not described in detail in a certain embodiment, please refer to the relevant description of other embodiments. The technical features of the above embodiments can be combined arbitrarily. In order to make the description concise, all possible combinations of the technical features in the above embodiments are not described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0155] Those skilled in the art will readily appreciate other embodiments of the present application after considering the specification and practicing the invention disclosed herein. The present application is intended to cover any modification, use or adaptation of the present application, which follows the general principles of the present application and includes common knowledge or customary techniques in the art that are not disclosed in the present application. The specification and examples are intended to be exemplary only, and the true scope and spirit of the present application are indicated by the following claims.

[0156] It should be understood that the present application is not limited to the precise structures that have been described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present application is limited only by the appended claims.

Claims

1. A process processing method, characterized in that: The method comprises: Receive a task process control request sent by the front end, parse the task process control request, and obtain configuration information of the target task process, wherein the control request includes: create request, delete request, query request, modify request, and stop request; Generate a corresponding data object according to the configuration information, and store the data object in a database; If a new data object is detected in the database, a corresponding target node is determined according to the data object; Sending a task process execution request to the target node based on the data object, so that the target node performs a corresponding operation on the target task process based on the execution request and feeds back a status of the target task process; The state of the target task process is received, and the state of the target task process is sent to the front end.

2. The method according to claim 1, characterized in that The determining the corresponding target node according to the data object comprises: Obtaining a mapping relationship between a preset node identifier and a remote node, and matching the execution node identifier in the data object with the preset node identifier in the mapping relationship; A remote node corresponding to a preset node identifier matching the execution node identifier is determined as the target node.

3. The method according to claim 1, characterized in that Also includes: Receive the current status of the target task process fed back by the target node; comparing a current state to a desired state in the data object; If the current state is inconsistent with the expected state, the task process execution request is resent to the target node based on the data object.

4. The method according to claim 3, characterized in that Also includes: If the expected state change is monitored, the current state of the started target task process is obtained from the target node; Compare the current state to the desired state of the change; If the current state is inconsistent with the desired state of the change, sending a task process stop request to the target node; or, If the current state is inconsistent with the expected state of the change, the task process execution request is resent to the target node based on the data object.

5. A process processing method, characterized in that: The method comprises: Receive a task process execution request sent by a server, parse the task process execution request, and obtain a corresponding data object; the server receives a task process control request sent by a front end, parses the task process control request, obtains configuration information of a target task process, generates a corresponding data object according to the configuration information, and stores the data object in a database; after monitoring a newly added data object in the database, determine a corresponding target node according to the data object, and send a task process execution request to the target node based on the data object, wherein the control request includes: a create request, a delete request, a query request, a modify request, and a stop request; Based on the execution request, a corresponding operation is performed on the target task process and the state of the target task process is fed back to the server. After receiving the state of the target task process, the server sends the state of the target task process to the front end.

6. The method according to claim 5, characterized in that The performing a corresponding operation on the target task process based on the execution request includes: If the expected state in the data object is running, the target task process is started.

7. The method according to claim 5, characterized in that Also includes: If the target task process is started, the identifier of the target task process is added to the process queue.

8. A process processing device, characterized in that: The device comprises: A first transceiver unit, used for receiving a task process control request sent by a front end; A first processing unit, configured to parse the task process control request and obtain configuration information of a target task process; The first processing unit is further used to generate a corresponding data object according to the configuration information and store the data object in a database; The first processing unit is further configured to determine a corresponding target node according to a new data object added to the database if a new data object is monitored; The first transceiver unit is further used to send a task process execution request to the target node based on the data object, so that the target node performs a corresponding operation on the target task process based on the execution request and feeds back a status of the target task process; The first transceiver unit is further used to receive the state of the target task process and send the state of the target task process to the front end; The control request includes: create request, delete request, query request, modify request and stop request.

9. A process processing device, characterized in that: The device comprises: The second transceiver unit is used to receive a task process execution request sent by a server, the server receives a task process control request sent by a front end, parses the task process control request, obtains configuration information of a target task process, generates a corresponding data object according to the configuration information, and stores the data object in a database; after monitoring a newly added data object in the database, determines a corresponding target node according to the data object, and sends a task process execution request to the target node based on the data object, wherein the control request includes: a create request, a delete request, a query request, a modify request, and a stop request; A second processing unit is used to parse the task process execution request and obtain a corresponding data object; The second processing unit is further configured to perform a corresponding operation on the target task process based on the execution request; The second transceiver unit is also used to feed back the state of the target task process to the server, and the server sends the state of the target task process to the front end after receiving the state of the target task process.

10. A server, characterized in that: include: A processor, and a memory communicatively connected to the processor; The memory stores computer-executable instructions; The processor executes the computer-executable instructions stored in the memory to implement the method according to any one of claims 1 to 7.

11. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer-executable instructions, which are used to implement the method according to any one of claims 1 to 7 when executed by a processor.

Images