WO2017016130A1

WO2017016130A1 - Message processing method and device

Info

Publication number: WO2017016130A1
Application number: PCT/CN2015/096709
Authority: WO
Inventors: 吕冬冬
Original assignee: 中兴通讯股份有限公司
Priority date: 2015-07-30
Filing date: 2015-12-08
Publication date: 2017-02-02
Also published as: CN106411684B; CN106411684A

Abstract

Provided are a message processing method and device. The method comprises: a first layer node receives a first message and stores the first message, wherein the first layer node comprises one or more first nodes; the first layer node processes the first message to generate a second message, and sends the second message to a second layer node, wherein the second layer node comprises one or more second nodes, and each of the first nodes in the first layer node corresponds to one or more second nodes; after having received the second message, the second layer node processes the second message, and feeds back a processing result to the first layer node; and in the case where the processing result is a processing failure, the first layer node acquires the stored first message and reprocesses the first message. By means of the present invention, the problem of low message processing efficiency in the case where a mistake occurs is solved, and the message processing efficiency in the case where a mistake occurs is improved.

Description

Message processing method and device

Technical field

The present invention relates to the field of data processing, and in particular to a message processing method and apparatus.

Background technique

The flow computing framework solves the problem with real-time data streams relative to the batch computing framework. Storm is a distributed real-time computing system that can process streaming data simply and reliably. Storm can be applied to real-time analysis, online machine learning, continuous computing, Remote Procedure Call Protocol (RPC) calls, and Extract-Transform-Load (ETL). Storm has the characteristics of scalability, fault tolerance, and high reliability of data processing.

Message reliability in streaming computing means that every message (Tuple) sent from the data source is guaranteed to be fully processed. A Tuple in Storm is completely processed: this Tuple and all Tuples generated by this Tuple are successfully processed. A Tuple will be considered to have failed processing if the message was not successfully processed within the time specified by timeout.

The existing message reliability scheme mainly guarantees message reliability by introducing Acker components and by XOR algorithm. Specifically, the task of the Acker component is to track a source from a Spout (Spout refers to a message source in a Storm application. In general, Spout reads data from an external data source and then converts it into source data inside Topology) The processing of all Tuples in the Tuple tree to which each message Id is bound. If these Tuples are not fully processed within the maximum timeout period set by the user, Acker will tell Spout that the message processing failed. Instead, it will tell Spout that the message is processed successfully. It will call the fail and ack methods in Spout respectively.

However, the Acker component manages the message confirmation signals of all components, and the Acker quantity cannot be dynamically adjusted according to the amount of real-time data, which is easy to cause Acker to be idle or single point of failure. In addition, in the case of an error, the message source needs to re-process the message from the root node, and the message processing efficiency is low.

Summary of the invention

The embodiment of the invention provides a message processing method and device, so as to at least solve the problem that the efficiency of message processing is low in the case of occurrence of an error in the related art.

According to an embodiment of the present invention, a message processing method is provided, including: a first layer node receives a first message, and stores the first message, where the first layer node includes one or more first nodes; The first layer node processes the first message, generates a second message, and sends the second message to the second layer node, where the second layer node includes one or more second nodes, Each of the first layer nodes corresponds to one or more second nodes; after receiving the second message, the second layer node processes the second message, and the The layer node returns a processing result; if the processing result is a processing failure, the first layer node acquires the stored a message and reprocessing the first message.

In the embodiment of the present invention, after the first layer node receives the first message and stores the first message, the method further includes: adding a record of the first message; wherein the first layer node Acquiring the stored first message includes: the first layer node queries the record, and obtains the stored first message.

In the embodiment of the present invention, before the first layer node receives the first message and stores the first message, the method further includes: the root node encapsulating the received data into a plurality of the first messages, and storing The plurality of the first messages; the root node adding a plurality of records of the first message.

In the embodiment of the present invention, the method further includes: the root node sending the first message to the first layer node, starting a timer to start timing; receiving the first before the timer expires The message of successful processing returned by the layer 1 node determines that the first message processing is successful; receives the message that the processing returned by the first layer node fails, or does not receive the message before the timer expires The message that the processing of the first layer node is successful is to query the record of the first message that fails to be processed, obtain the first message that is queried, and resend the first message that is obtained to the first layer node.

In the embodiment of the present invention, after the first layer node re-processes the first message, the method further includes: regenerating the second message, and sending the regenerated second message to the second layer node; The first layer node returns a message that the first message processing fails to the root node, in a case that the processing result of the regenerated second message is still a processing failure.

In the embodiment of the present invention, the method further includes: the second layer node stores the second message; processing the second message, generating a third message, and sending the third message to the third layer node a third message, wherein the third layer node includes one or more third nodes, and each of the second layer nodes corresponds to one or more third nodes; the third layer node receiving station After the third message is processed, the third message is processed, and the processing result is returned to the second layer node; if the processing result of the third message is processing failure, the second layer node acquires And storing the second message, and processing the second message again, regenerating the third message, and sending the regenerated third message to the third layer node.

In the embodiment of the present invention, the method further includes: when the processing result of the regenerated third message is still a processing failure, the second layer node returns the first layer to the first layer node Two messages failed to process the message.

According to another embodiment of the present invention, a message processing apparatus is provided, including: a first storage unit, disposed on a first layer node, configured to receive a first message, and store the first message, the first The first layer node includes one or more first nodes; the first processing unit is disposed on the first layer node, configured to process the first message, generate a second message, and send the second message to the second layer node The second message, wherein the second layer node includes one or more second nodes, each of the first layer nodes corresponds to one or more second nodes; and the second processing unit, Provided on the second layer node, configured to receive the second message, process the second message, and return a processing result to the first layer node; the first processing unit is further configured to If the processing result is that the processing fails, the stored first message is obtained, and the first message is processed again.

In the embodiment of the present invention, the device further includes: a first recording unit, disposed on the first layer node, and configured Adding a record of the first message after receiving the first message at the first layer node, and storing the first message; wherein the first processing unit includes: an obtaining module, configured to query the record, Obtaining the stored first message.

In the embodiment of the present invention, the device further includes: a second storage unit, configured on the root node, configured to receive the first message before the first layer node, and store the received data before storing the first message Encapsulating into the plurality of the first messages, storing the plurality of the first messages; the second recording unit, disposed on the root node, is configured to add a plurality of records of the first message.

In the embodiment of the present invention, the device further includes: a sending unit, configured to be sent on the root node, configured to send the first message to the first layer node, start a timer to start timing; determine a unit, set Setting, on the root node, a message that the processing returned by the first layer node is successful before the timer expires, determining that the first message processing is successful; the sending unit is further configured to be in Receiving a message that the processing returned by the first layer node fails, or not receiving a message that the processing returned by the first layer node is successful before the timer expires, and querying the first message that the processing fails. Recording, obtaining the first message that is queried, and resending the first message obtained to the first layer node.

In the embodiment of the present invention, the first processing unit is further configured to: after reprocessing the first message, regenerate the second message, and send the regenerated second message to the second layer node; The device further includes: a first returning unit, disposed on the first layer node, configured to return to the root node if the processing result of the regenerated second message is still processing failure The message that the first message processing failed.

In the embodiment of the present invention, the device further includes: a third storage unit, configured to be configured to store the second message on the second layer node; and a third processing unit, configured to be in the second layer node And configured to process the second message, generate a third message, and send the third message to the third layer node, where the third layer node includes one or more third nodes, Each of the second nodes corresponds to one or more third nodes; the fourth processing unit is disposed on the third layer node, and is configured to receive the third message Processing the message, and returning the processing result to the second layer node; the third processing unit is further configured to: when the processing result of the third message is a processing failure, the second layer node acquires the stored The second message, and processing the second message again, regenerating the third message, and sending the regenerated third message to the third layer node.

In the embodiment of the present invention, the device further includes: a second returning unit, configured to be disposed on the second layer node, where the processing result of the regenerated third message is still a processing failure, Returning the message that the second message processing failed to the first layer node.

In the case that the second layer node fails to process the second message, the first layer node acquires the pre-stored first message, and re-processes the first message, so as to regenerate the second message and send it to the second layer. The node and the second layer node can process the regenerated second message without re-processing the message from the root node, thereby solving the problem that the message processing efficiency is low in the case of an error, and the error is improved. The efficiency of message processing in the case.

DRAWINGS

The drawings described herein are intended to provide a further understanding of the invention, and are intended to be a part of the invention. In the drawing:

1 is a flow chart of a message processing method according to an embodiment of the present invention;

2 is a schematic diagram of layer-by-layer feedback in accordance with an alternative embodiment of the present invention;

3 is a schematic diagram of error retransmission in accordance with an alternative embodiment of the present invention;

4 is a block diagram showing the structure of a message processing apparatus according to an embodiment of the present invention.

detailed description

The invention will be described in detail below with reference to the drawings in conjunction with the embodiments. It should be noted that the embodiments in the present application and the features in the embodiments may be combined with each other without conflict.

It is to be understood that the terms "first", "second" and the like in the specification and claims of the present invention are used to distinguish similar objects, and are not necessarily used to describe a particular order or order.

In this embodiment, a message processing method is provided, which can be used for message processing of a streaming computing framework.

FIG. 1 is a flowchart of a method at a message according to an embodiment of the present invention. As shown in FIG. 1, the process includes the following steps:

Step S102, the first layer node receives the first message, and stores the first message, where the first layer node includes one or more first nodes;

Step S104: The first layer node processes the first message, generates a second message, and sends a second message to the second layer node, where the second layer node includes one or more second nodes, and the first layer node Each first node corresponds to one or more second nodes;

Step S106: After receiving the second message, the second layer node processes the second message, and returns a processing result to the first layer node.

Step S108: If the processing result is that the processing fails, the first layer node acquires the stored first message, and re-processes the first message.

The first layer node and the second layer node may be intermediate nodes of message processing, wherein the second layer node is a downstream node of the first layer node.

Through the above steps, in the case that the second layer node fails to process the second message, the first layer node acquires the pre-stored first message, and re-processes the first message, so as to regenerate the second message to be sent to The second layer node, the second layer node can process the regenerated second message, and does not need to re-process the message from the root node, thereby solving the problem that the message processing efficiency is low in the case of an error, and the problem is improved. The efficiency of message processing in the event of an error.

Preferably, the first node and the second node, and the third node and the like mentioned later may be Bolt. The Bolt is a component of the Storm application for message processing. Bolt can perform any operations such as filtering, function operations, merging, and writing to the database.

Preferably, the first message is stored, which may be a message buffer (Buffer) set on the first layer node, used to cache the sent message, and used for message processing failure retransmission. The second layer node may also store the second message when receiving the second message, so as to obtain the stored second message when the downstream node message processing fails.

Preferably, after the first layer node receives the first message and stores the first message, the method further includes: adding a record of the first message; wherein the first layer node acquiring the stored first message comprises: the first layer node Query the record to get the first message stored.

After receiving the first message and storing the first message, the first layer node may add a record of the first message, so that when the first message is obtained, it may be acquired based on the record. Further preferably, a message confirmation module (Ack module) can be used to add a record to the message. Optionally, the Ack module may also feed back the message processing situation to the upstream message source and receive the downstream node feedback message.

The record form of the message may be an identity identifier set according to a predefined rule, such as a serial number, etc., which is not limited herein.

Preferably, before the first layer node receives the first message and stores the first message, the method further includes: the root node encapsulates the received data into a plurality of first messages, and stores a plurality of first messages; A record of the first message.

In this embodiment, the root node may be a Spout, the root node reads data from the message source, generates an independent message unit, and forwards the message to a plurality of first layer nodes, and the message processed by the first layer node may also pass other Several nodes are processed. The root node may separately send a first message to each of the plurality of first layer nodes, and add a corresponding record, so that when the first layer node fails to process, the corresponding message is obtained from the stored message based on the record, and Sent to the first level node.

Preferably, the method further includes: the root node sends a first message to the first layer node, starts a timer to start timing; and receives a message that the processing returned by the first layer node is successful before the timer expires, and determines the first message processing. Successfully; receiving a message that the processing returned by the first layer node fails, or receiving a message that the processing of the first layer node returns successfully before the expiration of the timer, querying the record of the first message that failed to be processed, and obtaining The first message that is queried will resend the first message obtained to the first layer node.

If the root node receives the successful message of the sent message during the timer period, it indicates that the corresponding message processing is successful. When the message that the message is successfully processed or the message that failed the process is received after the timeout expires, the source data is restored from the cache for retransmission.

Preferably, after the first layer node re-processes the first message, the method further includes: regenerating the second message, and sending the regenerated second message to the second layer node; wherein, in the regenerated second message If the processing result is still processing failure, the first layer node returns a message that the first message processing fails to the root node.

In this embodiment, when the second layer node fails to process the second message, the second message is regenerated and is sent to the second layer. The node resends the regenerated second message so that the second layer node pair reprocesses, and if the processing fails again, the first layer node returns a message that the processing failed to the root node.

Preferably, the method further includes: the second layer node stores the second message; processes the second message, generates a third message, and sends a third message to the third layer node, where the third layer node includes one or more a third node, each second node of the second layer node corresponds to one or more third nodes; after receiving the third message, the third layer node processes the third message and returns the processing result to the second layer node If the processing result of the third message is that the processing fails, the second layer node acquires the stored second message, and re-processes the second message, regenerates the third message, and sends the regenerated message to the third layer node. Third message.

If the second layer node further includes a third layer node, the second layer node processes the second message and generates a third message, which is sent to the third layer node. In the case that the third layer node fails to process the third message, the second layer node acquires the second message, and regenerates the third message and retransmits, so that the third layer node reprocesses. In this way, when the processing of the third layer node fails, it is not necessary to repeat the processing from the root node, and only the second message is reprocessed from the second layer node, which greatly improves the efficiency of message processing in the case of an error.

Further preferably, the method further comprises: in the case that the processing result of the regenerated third message is still the processing failure, the second layer node returns a message that the second message processing fails to the first layer node.

If the processing result is still processing failure after the third message is reprocessed, the second layer node returns a message that the processing fails to the first layer node. This makes it possible to report to the root node when the message processing fails.

The embodiments of the present invention are described below with specific applications.

Spout reads data from the message source, generates a separate message unit, and forwards the message to several Bolt processes. The Bolt-processed message may also be processed by several other Bolts. Both Spout and Bolt contain the Buffer module and the Ack module. The data is buffered in the buffer before the message is processed and recorded in the Ack module. After the data processing is completed, the processing result is fed back to the upstream data source through the Ack module.

The message processing method of the streaming framework includes the following steps:

first step:

The Spout processes the source data and distributes the message generated by the source data to the downstream Bolt. The generated message is stored in the buffer buffer and the timer is started. The Ack module in Spout adds a record to the message.

The second step:

Bolt receives upstream messages and processes the data. If the Bolt still has a downstream module, the Ack module records the message to be sent and stores the upstream message in the cache. On the contrary, after the data processing is completed, the Ack module feeds back the ack_msg message to the upstream to indicate that the message processing is successful, and the message processing fails to feed back the fail_msg message.

third step:

After receiving the ack_msg message of all downstream Bolt feedback corresponding to a message, Bolt deletes the strip in the cache. And feed back ack messages to the upstream Bolt or Spout. If a fail message is received, the corresponding message is restored from the cache and reprocessed.

the fourth step:

If Spout receives the ack message of the sent message within the period of the timer, it indicates that the corresponding message is processed successfully. When the ack message corresponding to the outgoing message is received or the fail message is received at the time of expiration, the source data is restored from the cache for retransmission.

Specifically, the above steps can be implemented in the following manner:

For the first step:

Spout encapsulates the collected data into a number of messages Tuple. As shown in Figure 2, the messages with the id numbers msg_0 and msg_1 are generated, and the Tuple is sent to the Bolt to start the timer.

Spout caches the tuple to be sent to its own buffer, and ack adds a record to the message. The record format is (msg_0), (msg_1).

For the second step:

Bolt accepts the message Tuple from the upstream Bolt or Spout, serial number is parent_id, caches the data, and processes the data. The processing result is divided into two cases: generating a new Tuple, or not generating a new Tuple after processing.

For the first case, after processing the message from the upstream component successfully, the Ack module in Bolt adds the record (parent_id, msg_id) and stores the message from the upstream into the cache. The parent_id indicates the id number of the Tuple sent upstream to the Bolt. The Bolt may generate multiple new messages from the upstream Tuple. The id numbers are msg_id_1, msg_id_2...msg_id_n. The msg_id in the record is updated to an exclusive OR value between each message id number, that is, msg_id=msg_id_1^msg_id_2...^msg_id_i^...^msg_id_n, and msg_id_i is the id number of each message, which are all 64-bit random sequences. Message records are usually implemented using data structures such as HashMap.

As shown in Figure 2, two Bolts downstream of Spout process messages with id msg_0 and msg_1, generate messages msg_2, msg_3, and msg_4, and add records to their respective caches (msg_0, msg_2^msg_3), (msg_1, msg_4). . If the message fails to be processed, the processing failure message fail_msg is fed back to the upstream component, and the id number of the message that failed to be processed is included in the fail_msg.

The confirmation of the message uses the XOR algorithm:

The upstream component processes the message with the id number parent_id, and generates messages with the id numbers msg_id_1, msg_id_2, ..., msg_id_n, distributes the generated message to the downstream component for processing, and adds the message record (parent_id, msg_id_1^msg_id_2...^ Msg_id_n). After the processing of the msg_id_i is completed, the downstream component feeds back to the upstream (parent_id, msg_id_i), and upstream finds the record corresponding to the parent_id msg_id=msg_id_1^msg_id_2...^msg_id_n, XOR_id and msg_id_i, and assigns the result to msg_id. After all messages have been processed, the XOR result is 0, so that the message generated by the parent_id message is processed.

In the second case, after processing the Bolt that does not generate a new message, the acknowledgment message ack_msg or the failure message fail_msg is sent to the message source of the parent_id, and the format of the message data part is confirmed as (parent_id, msg_id).

As shown in the last layer of Bolt in FIG. 2, after processing the messages msg_2, msg_3, and msg_4, the ack_msg message is respectively fed back to the upstream, indicating that the respective message processing is completed.

For the third step:

After Bolt or Spout receives the acknowledgement message ack_msg from the downstream Bolt, the Ack module queries the record corresponding to the parent_id in the ack message, and XORs the record with the msg_id of ack_msg. If the XOR result is 0, it indicates that the message corresponding to the parent_id has been completely processed, and the feedback of the parent_id message to the upstream is continued.

After the Bolt downstream of the Spout receives the confirmation message in Figure 2, the message record (msg_0, msg_2^msg_3) is found, and the recorded value msg_2^msg_3 is XORed with the values msg_2 and msg_3 in the received confirmation message, respectively. If it is 0, it indicates that the message msg_0 is processed successfully, and the cache of msg_0 is deleted. Similarly, the msg_4 in the record (msg_1, msg_4) is XORed with the value msg_4 in the downstream ack_msg message, and the result is 0, indicating that the msg_1 process is completed.

If Bolt or Spout receives the processing failure message fail_msg from the downstream Bolt, the message that failed processing is restored from the cache to reprocess the retransmission. If the downstream continues to return fail_msg, the retransmission is stopped, and the fail_msg message is continuously fed back to the upstream.

The specific process is shown in Figure 3. The msg_2 processing fails, the fail_msg message is sent to the Bolt, and the Bolt query record is reprocessed from the cache recovery message msg_0, and the messages msg_2 and msg_3 are generated and retransmitted separately. The downstream component continues to reprocess msg_2 and msg_3, and the processing succeeds in layer-by-layer feedback.

For the fourth step:

Each Bolt component repeats the above process, and continuously feeds back the processing result to the upstream until Spout receives the feedback message from the downstream Bolt, and receiving ack_msg indicates that the message processing is successful.

That is, the Bolt downstream of the Spout in FIG. 2 receives the acknowledgment signal of all the messages and sends ack_msg to the Spout, and the Spout receives the message confirming that the message is processed and deletes the cache.

Within the waiting time T, if Spout does not receive the ack_msg of the message, or receives the fail_msg message of the downstream feedback, it indicates that the message processing fails, and the corresponding message is restored from the buffer for retransmission or abandonment.

Through the description of the above embodiments, those skilled in the art can clearly understand that the method according to the above embodiment can be implemented by means of software plus a necessary general hardware platform, and of course, by hardware, but in many cases, the former is A better implementation. Based on such understanding, the technical solution of the present invention, which is essential or contributes to the prior art, may be embodied in the form of a software product stored in a storage medium (such as ROM/RAM, disk, The optical disc includes a number of instructions for causing a terminal device (which may be a cell phone, a computer, a server, or a network device, etc.) to perform the methods described in various embodiments of the present invention.

Compared with the existing solution, the embodiment ensures the reliability of the message by means of layer-by-layer feedback, and reduces the overload or the node idle because the number of Acker nodes cannot be dynamically adjusted. At the same time, the processing nodes of each layer are provided with a cache, which reduces the number of times of message retransmission and reprocessing in the event of an error. Improve network efficiency and reduce network overhead.

In the embodiment, a message processing device is also provided, which is used to implement the above-mentioned embodiments and preferred embodiments, and has not been described again. As used hereinafter, the terms "unit", "module" may perform a predetermined function. A combination of software and/or hardware. Although the apparatus described in the following embodiments is preferably implemented in software, hardware, or a combination of software and hardware, is also possible and contemplated.

4 is a structural block diagram of a message processing apparatus according to an embodiment of the present invention. As shown in FIG. 4, the apparatus includes: a first storage unit 202, a first processing unit 204, and a second processing unit 206.

The first storage unit 202 is disposed on the first layer node, configured to receive the first message, and store the first message. The first layer node includes one or more first nodes.

The first processing unit 204 is disposed on the first layer node, configured to process the first message, generate a second message, and send the second message to the second layer node. The second layer node includes one or more second nodes, and each of the first layer nodes corresponds to one or more second nodes.

The second processing unit 206 is disposed on the second layer node, and is configured to process the second message after receiving the second message, and return the processing result to the first layer node.

The first processing unit 204 is further configured to acquire the stored first message and reprocess the first message if the processing result is a processing failure.

The first node included in the first layer node and the second node included in the second layer node may be intermediate nodes of message processing, wherein the second layer node is a downstream node of the first layer node.

Preferably, the first layer node and the second layer node, and the third layer node and the like mentioned later may all be Bolt, which is a component for message processing in the Storm application, and the Bolt may perform filtering, Function operations, merges, writes to the database, and so on.

Preferably, the device further includes: a first recording unit, disposed on the first layer node, configured to: after receiving the first message at the first layer node, and storing the first message, adding a record of the first message; A processing unit includes: an acquisition module configured to query the record to obtain the stored first message.

After receiving the first message and storing the first message, the first layer node may add a record of the first message, so that when the first message is obtained, it may be acquired based on the record. The first recording unit may be a message confirmation module (Ack module) for adding a record to the message. The record form of the message may be an identity identifier set according to a predefined rule, such as a serial number, etc., which is not limited herein.

Preferably, the device further includes: a second storage unit, disposed on the root node, configured to encapsulate the received data into a plurality of first messages before the first layer node receives the first message and stores the first message, Storing a plurality of first messages; a second recording unit, disposed on the root node, configured to add a record of the plurality of first messages.

Preferably, the device further comprises: a sending unit, configured on the root node, configured to send a first message to the first layer node, start a timer to start timing; determine a unit, set on the root node, and set to expire at the timer Before receiving the message of successful processing returned by the first layer node, it is determined that the first message processing is successful; the sending unit is further configured to receive the message that the processing returned by the first layer node fails, or before the timer expires After receiving the message that the processing of the first layer node is successful, the queried first message of the processing failure is obtained, and the first message that is queried is obtained, and the obtained first message is sent to the first layer node again.

Preferably, the first processing unit is further configured to: after reprocessing the first message, regenerate the second message, and send the regenerated second message to the second layer node; wherein the device further comprises: the first return unit And being set on the first layer node, and being set to return a message that the first message processing fails to the root node if the processing result of the regenerated second message is still processing failure.

In this embodiment, when the second layer node fails to process the second message, the second message is regenerated and the regenerated second message is resent to the second layer node, so that the second layer node reprocesses If the processing fails again, the first layer node returns a message that the processing failed to the root node.

Preferably, the device further includes: a third storage unit, disposed on the second layer node, configured to store the second message; the third processing unit, configured on the second layer node, configured to process the second message to generate a third message, and sending a third message to the third layer node; the fourth processing unit is set on the third layer node, configured to receive the third message, process the third message, and return to the second layer node Processing the result; the third processing unit is further configured to: when the processing result of the third message is that the processing fails, the second layer node acquires the stored second message, and reprocesses the second message to regenerate the third message. The regenerated third message is sent to the layer 3 node.

Preferably, the apparatus further includes: a second returning unit, disposed on the second layer node, configured to return the second message to the first layer node if the processing result of the regenerated third message is still processing failure Handling failed messages.

Embodiments of the present invention also provide a storage medium. Optionally, in the embodiment, the foregoing storage medium may be configured to store program code for performing the following steps:

Step S1, the first layer node receives the first message, and stores the first message;

Step S2: The first layer node processes the first message, generates a second message, and sends a second message to the second layer node;

Step S3: After receiving the second message, the second layer node processes the second message, and returns a processing result to the first layer node.

In step S4, if the processing result is that the processing fails, the first layer node acquires the stored first message and re-processes the first message.

With the above code, in the case that the second layer node fails to process the second message, the first layer node acquires the pre-stored first message, and re-processes the first message, so as to regenerate the second message to be sent to The second layer node, the second layer node can process the regenerated second message, and does not need to re-process the message from the root node, thereby solving the problem that the message processing efficiency is low in the case of an error, and the problem is improved. The efficiency of message processing in the event of an error.

Optionally, in this embodiment, the foregoing storage medium may include, but not limited to, a USB flash drive, a Read-Only Memory (ROM), a Random Access Memory (RAM), a mobile hard disk, and a magnetic memory. A variety of media that can store program code, such as a disc or a disc.

Optionally, in this embodiment, the processor executes, according to the stored program code in the storage medium, the first layer node receives the first message, and stores the first message; the first layer node processes the first message to generate The second message sends a second message to the second layer node; after receiving the second message, the second layer node processes the second message and returns the processing result to the first layer node; if the processing result is a processing failure Next, the first layer node obtains the stored first message and re-processes the first message.

For example, the specific examples in this embodiment may refer to the examples described in the foregoing embodiments and the optional embodiments, and details are not described herein again.

It will be apparent to those skilled in the art that the various modules or steps of the present invention described above can be implemented by a general-purpose computing device that can be centralized on a single computing device or distributed across a network of multiple computing devices. Alternatively, they may be implemented by program code executable by the computing device such that they may be stored in the storage device by the computing device and, in some cases, may be different from the order herein. The steps shown or described are performed, or they are separately fabricated into individual integrated circuit modules, or a plurality of modules or steps thereof are fabricated as a single integrated circuit module. Thus, the invention is not limited to any specific combination of hardware and software.

The above description is only a preferred embodiment of the present invention, and is not intended to limit the present invention, and is a person skilled in the art. The invention is susceptible to various modifications and changes. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and scope of the present invention are intended to be included within the scope of the present invention.

Industrial applicability

The foregoing technical solution provided by the present invention can be applied to a message processing process. When the second layer node fails to process the second message, the first layer node acquires the pre-stored first message, and re-pairs the first message. The message is processed, so that the second message is regenerated and sent to the second layer node, and the second layer node can process the regenerated second message without re-processing the message from the root node, thereby solving the error. The problem of low efficiency of message processing improves the efficiency of message processing in the event of an error.

Claims

A message processing method includes:

The first layer node receives the first message, and stores the first message, where the first layer node includes one or more first nodes;

The first layer node processes the first message, generates a second message, and sends the second message to the second layer node, where the second layer node includes one or more second nodes, Each of the first nodes of the first layer node corresponds to one or more second nodes;

After receiving the second message, the second layer node processes the second message, and returns a processing result to the first layer node;

If the processing result is that the processing fails, the first layer node acquires the stored first message, and re-processes the first message.
The method of claim 1 wherein

After the first layer node receives the first message and stores the first message, the method further includes: adding a record of the first message;

The obtaining, by the first layer node, the stored first message includes: the first layer node querying the record, and acquiring the stored first message.
The method of claim 1, wherein before the first layer node receives the first message and stores the first message, the method further comprises:

The root node encapsulates the received data into a plurality of the first messages, and stores the plurality of the first messages;

The root node adds a plurality of records of the first message.
The method of claim 3, wherein the method further comprises:

Sending, by the root node, the first message to the first layer node, and starting a timer to start timing;

Receiving a message that the processing returned by the first layer node is successful before the expiration of the timer, determining that the first message processing is successful;

Receiving a message that the processing returned by the first layer node fails, or not receiving a message that the processing returned by the first layer node is successful before the timer expires, and querying the first message that the processing fails. Recording, obtaining the first message that is queried, and resending the first message obtained to the first layer node.
The method of claim 3, wherein

After the first layer node re-processes the first message, the method further includes: regenerating the second message, and sending the regenerated second message to the second layer node;

Wherein, in the case that the processing result of the regenerated second message is still processing failure, the first layer The node returns a message that the first message processing failed to the root node.
The method of claim 1 wherein the method further comprises:

The second layer node stores the second message;

Processing the second message, generating a third message, and sending the third message to the third layer node, where the third layer node includes one or more third nodes, and the second layer node Each of the second nodes corresponds to one or more third nodes;

After receiving the third message, the third layer node processes the third message, and returns a processing result to the second layer node;

If the processing result of the third message is that the processing fails, the second layer node acquires the stored second message, and re-processes the second message to regenerate the third message. The third layer node sends a regenerated third message.
The method of claim 6 wherein the method further comprises:

And in a case that the processing result of the regenerated third message is still a processing failure, the second layer node returns a message that the second message processing fails to the first layer node.
A message processing device comprising:

a first storage unit, disposed on the first layer node, configured to receive the first message, and store the first message, where the first layer node includes one or more first nodes;

a first processing unit, configured to be configured to process the first message, generate a second message, and send the second message to a second layer node, where the second The layer node includes one or more second nodes, each of the first layer nodes corresponding to one or more second nodes;

a second processing unit, configured to be disposed on the second layer node, configured to process the second message after receiving the second message, and return a processing result to the first layer node;

The first processing unit is further configured to: when the processing result is a processing failure, acquire the stored first message, and re-process the first message.
The device according to claim 8, wherein

The device further includes: a first recording unit, disposed on the first layer node, configured to receive the first message after the first layer node, and after adding the first message, adding the first message recording;

The first processing unit includes: an obtaining module, configured to query the record, and obtain the stored first message.
The apparatus of claim 8 wherein said apparatus further comprises:

a second storage unit, configured to be configured on the root node, configured to: before the first layer node receives the first message, and before storing the first message, encapsulate the received data into a plurality of the first messages, and store the a plurality of said first messages;

a second recording unit, disposed on the root node, configured to add a plurality of records of the first message.
The device of claim 10, wherein the device further comprises:

a sending unit, configured to be sent on the root node, configured to send the first message to the first layer node, and start a timer to start timing;

a determining unit, configured on the root node, configured to receive a message that the processing returned by the first layer node is successful before the timer expires, determining that the first message processing is successful;

The sending unit is further configured to: after receiving the message that the processing returned by the first layer node fails, or not receiving the message that the processing returned by the first layer node is successful before the timer expires, Querying the record of the first message that failed to be processed, obtaining the first message that is queried, and resending the first message obtained to the first layer node.
The device according to claim 10, wherein

The first processing unit is further configured to: after reprocessing the first message, regenerate the second message, and send the regenerated second message to the second layer node;

The device further includes: a first returning unit, disposed on the first layer node, configured to send to the root node if the processing result of the regenerated second message is still processing failure Returning the message that the first message processing failed.
The apparatus of claim 8 wherein said apparatus further comprises:

a third storage unit, disposed on the second layer node, configured to store the second message;

a third processing unit, configured to be configured to process the second message, generate a third message, and send the third message to the third layer node, where the third message is The layer node includes one or more third nodes, and each of the second layer nodes corresponds to one or more third nodes;

a fourth processing unit, configured to be configured to receive the third message, process the third message, and return a processing result to the second layer node;

The third processing unit is further configured to: when the processing result of the third message is a processing failure, the second layer node acquires the stored second message, and re-processes the second message Regenerating the third message, and transmitting the regenerated third message to the layer 3 node.
The device of claim 13 wherein said device further comprises:

a second returning unit, disposed on the second layer node, disposed at the location of the regenerated third message If the result of the processing is still the processing failure, the message that the second message processing fails is returned to the first layer node.