KR101612682B1 - Method, system and computer program product for sequencing asynchronous messages in a distributed and parallel environment - Google Patents

Abstract

The present invention relates to a system and computer-implemented method for sequencing distributed asynchronous messages in a distributed and parallel system having a plurality of inbound handlers forming an inbound handler layer and a plurality of outbound handlers forming an outbound handler layer Wherein the input message comprises a sequence correlation value that identifies a sequence comprising an input message, wherein the input message comprises a sequence correlation value that is input from any inbound handler among the plurality of inbound handlers, Receiving a message; Checking a sequence state of the sequence in the shared sequence repository; Determining whether the incoming message is the next message to be processed to maintain the order of the message in the sequence; and determining that either of the outbound handlers whose sequence status is in the outbound handler layer is the current And if the input message is determined to be the next message to be processed in the sequence, the input message is passed to the shared queue store and then processed by the outbound handler available in the outbound handler layer for processing Retrieve the message; - the sequence state indicates that at least one of the outbound handlers in the outbound handler layer is currently processing the message of the sequence; Or the shared queue store already contains a message to be processed in the sequence; Or if the input message is determined not to be the next message to be processed in the sequence, the input message is stored in the memory of the shared overflow store to maintain further processing.

Description

METHOD, SYSTEM AND COMPUTER PROGRAM PRODUCT SEQUENCING ASYNCHRONOUS MESSAGES IN A DISTRIBUTED AND PARALLEL ENVIRONMENT FIELD OF THE INVENTION [0001]

The present invention relates generally to data and information processing in communication systems, and more particularly, to a method, apparatus, and system for processing asynchronous messages in a sequence in a distributed and parallel processing environment.

Using a distributed software architecture, in a service call or event processing, the transmission of the message may be synchronous or asynchronous. This message is completely distributed and multicast separated by recipients, where each multicast message is handled independently of each other.

Figure 1 illustrates synchronously transferring a message or service call between two systems, a calling system 110 on one side and a remote system 120 on the other side, where the calling system 110 Control the message processing order. In this case, the calling system 110 waits for the results of the remote processing, and eventually the caller is the master of the messages regarding the order of the messages that are actually processed in the server system or remote system.

Transferring (111) the first message A from the calling system 110 is processed at the remote system 120 and then processed message A 121 is returned to the calling system 110. When the processed message A is received, the calling system 110 may begin to send (113) the second message B to the remote system 120. The second message B is processed in the remote system 120, and the processed message B 123 is returned to the calling system 110.

In this illustrative flow chart, chronological processing of a synchronous call or message between the calling system 110 and the remote system 120 is performed by the server system or the remote system 120, (112) occurs before processing (114) the second message B.

2 depicts asynchronously transferring a message or service call between a calling system 210 and a server system or remote system 220 where the calling system 210 sends a service call or message to a server system or remote system 220 220, which processes the message based on its own scheduling. The client system or calling system 210 loosely controls message processing timing.

Transferring (211) the first message A from the calling system 210 is processed in the remote system 220. In the meantime, the calling system 210 initiates (213) the second message B to the remote system 220. The second message B can then be processed in the remote system 220 and it can not be determined whether the processed message B is returned to the calling system 210 before the message A is processed.

In this illustrative flow chart, processing the asynchronous call or message chronologically between the calling system 210 and the remote system 220 is a process 212 of processing the first message A by the server system or the remote system 220 (214) of the second message B at the same time. The second message B may be processed before the first message A to potentially affect the relevance of the sequence including the messages A and B. [

3 is an exemplary flow chart illustrating service invocation or parallel processing of messages in a distributed system. In a distributed system, service calls or messages are processed in parallel by instantiation and / or multithreading to comply with resilience and scalability requirements. In this figure, instances 1, 2, 3, ..., and n (310-1, 310-2, ..., and 310-n) of the process system are in a message queue with inbound sequences, 0.0 > 1, < / RTI > 2, 3 and 4 in step 340 of FIG.

Parallelized processing does not guarantee the order in which successive service calls or messages are processed and completed. However, service calls or message processes are often strongly required to perform in sequence between correlated events or messages.

In the example shown in FIG. 3, message 1 is processed in instance 2, message 2 is processed in instance 3, message 3 is processed in instance 1, and message 4 is processed in instance 3, Since message processing order is not adjusted, message 2 is processed first, then message 1 is processed, then message 4 is processed, and finally message 3 is processed. This is inconsistent with the transaction processing order.

In this figure, the sequence refers to the order in which service calls or messages are carried and / or processed by the distributed system. This order is typically driven by business processes or industry standards. Failure to take this sequence into account can result in improper processing, or in the worst case, stored functional data can be irretrievably corrupted, also known as database corruption.

4 is an exemplary flow chart illustrating parallel processing of asynchronous calls or messages in a distributed processing system resulting in a risk of de-ordering messages and corrupted data processing sequences.

In a synchronous environment, sequencing is guaranteed by a sender (emitter) system or a paging system, which initiates messages one by one to the remote system, effectively controlling the sequence flow between correlated messages.

When the dispatcher system or the calling system 410 has to process the asynchronous and distributed processes, the remote system 420 can not determine the termination of the message processing, making this sequencing impossible. FIG. 4 illustrates the risk of sending (413) a second message B after transmitting (411) the first message A from the calling system 410 to the remote system 420. Processing 414 the second message B begins before processing 412 of processing 414 the first message A. [ Thus, message processing can be reversed, resulting in improper processing, and, in the worst case, irreparably compromised stored function data or database corruption.

Thus, the present invention aims at mitigating the aforementioned problems and avoiding irreparably damaging stored functional data or damaging any database.

In one embodiment, the present invention provides a distributed and parallel system comprising a plurality of inbound handlers forming an inbound handler layer and a plurality of outbound handlers forming an outbound handler layer, A computer-implemented method for sequencing distributed asynchronous messages, the method comprising the following steps performed on at least one data processor:

Receiving an incoming message from any inbound handler among a plurality of inbound handlers, the input message including a sequence correlation value identifying a sequence comprising an input message; ;

Checking a sequence state of a sequence in a shared sequence storage;

Determining whether the incoming message is the next message to be processed in order to maintain the order of the message in the sequence

If the sequence state indicates that none of the outbound handlers in the outbound handler layer are currently processing messages in the sequence and the input message is determined to be the next message to be processed in the sequence, Retrieve the message by forwarding it to the repository and then using the outbound handler available for further processing;

If the sequence state indicates that at least one of the outbound handlers in the outbound handler layer is currently processing a message in the sequence; Or the shared queue store already contains a message to be processed in the sequence; Or if the input message is determined not to be the next message to be processed in the sequence, the input message is stored in the memory of the shared overflow store to maintain further processing.

Thus, a distributed and parallel system comprises an inbound handler arranged in parallel with each other in an inbound handler layer that receives messages belonging to a large number of sequences; And a storage layer that includes a shared sequence store, a queue store, and a shared overflow store, and receives a message from the inbound handler and stores the message in memory. The sequence repository may include an overflow repository. Distributed and parallel systems further include outbound handlers that are arranged in parallel with each other in the outbound handler layer and adapted to retrieve messages from a shared queue store for processing while ensuring that the system correctly sequenced messages in each sequence. The outbound handler is configured to receive the message, process the message, and forward the message to the correct recipient.

Overflow storage and sequence storage are shared by inbound and outbound handlers. These depots are commonly used by parallel inbound handlers and parallel outbound handlers.

Thus, the present invention provides a solution for maintaining a sequence of messages belonging to the same sequence while paralleling several sequences in a distributed environment. Furthermore, separating the inbound handler from the outbound handler can isolate the throughput of the sender from the throughput of the receiver. Furthermore, the number of inbound handlers and the number of outbound handlers are highly scalable independently. Additionally, the present invention avoids the creation of affinities between sequences and inbound / outbound handlers, allowing any inbound / outbound handler to handle messages of any sequence. Thus, the present invention provides strong resilience, because some handlers or outbound handlers will not affect message processing if they are outaged.

The method according to the invention may further comprise any of the following additional features and steps:

In one embodiment, the step of determining whether the incoming message is the next message to be processed to maintain the order of the message in the sequence,

Determining a message rank indicating a sequence of input messages in the sequence,

Comparing the message ranking to a sequence ranking that defines a ranking of the next message to be processed in the sequence,

Determining that the message is the next message to be processed to maintain the order of the message in the sequence if the message ranking is equal to the sequence rank,

If the message ranking exceeds the sequence rankings, the message is determined not to be the next message to be processed in order to maintain the order of the messages.

Messages that are included in a sequence and require to be processed in a particular order may have message ranking numbers referred to herein as message ranks. Message ranking limits the order of messages in a sequence. The message may have a message ranking by the originator of the message or by a third party. The message ranking may be assigned by the system according to the order of arrival of the messages in the sequence.

Sequence ranking, as understood herein, defines the message rankings that a message to be processed next, i.e., the next message to be processed, must have in a given sequence.

Preferably, the sequence ranking is indicated in the sequence repository.

In general, processing an outbound handler message means that the outbound handler sends or delivers the message to the recipient.

Advantageously, upon completion of processing of a given sequence of messages in an outbound handler, the sequence rankings of a given sequence are incremented.

Preferably, when the sequence rankings of the sequence are incremented, the method includes checking if the overflow store includes a message with a message ranking, such as an incremented sequence ranking, and then forwarding the message to the queue store .

According to an advantageous embodiment, if the received input message does not have an index indicating the message ranking in the sequence, then the step of determining the message ranking comprises assigning to the input message a message ranking indicating the ranking of the input message in the sequence And storing the assigned message rankings in a sequence repository.

Preferably, the assigned message ranking corresponds to a ranking incremented by one in the ranking of the last message received in any one of the inbound handlers in the sequence in the sequence. Thus, if the incoming message is the earliest message in the sequence, the message ranking is 1. If the message rank of the previous message received at the inbound handler is N, then the message ranking assigned to the newly entered message is N + 1.

In another advantageous embodiment, the input message received at the inbound handler has an index indicating the message ranking in the sequence.

Preferably, when the message ranking exceeds the sequence ranking, the state of the sequence is set to the "pending" state. Thus, a "pending" state means that the overflow storage area includes at least a given sequence of messages, but these or these messages have message ranking that is not equal to the sequence ranking.

In general, a sequence state is set to a "standby" state when none of the outbound handlers is currently processing a message of the sequence and when there is no message of this sequence in the overflow storage area. Generally, a sequence state is set to a "processing" state when at least one of the outbound handlers is currently processing a message of the sequence.

Advantageously, if the queue repository does not contain any messages at all in the sequence of input messages, and if the message ranking of the input messages exceeds the sequence rankings indicated in the sequence repository, the input message is incremented It is stored in the overflow storage until it is equal to the message ranking of the input message.

Thus, if the message has a message ranking by the sender or a third party of the message, and the message ranking exceeds the sequence ranking, the message is stored in the overflow store. When another message with a lower message ranking is processed, the sequence ranking is incremented until the message ranking of the previously stored message is reached. This message may be released from the sequence store, or more precisely from the overflow store, and sent to the queue store if the queue store and inbound handler do not store and process the messages of this sequence.

This does not have message ranking but applies to messages assigned message ranking by the system according to their arrival order.

Advantageously, when a message is successfully processed by an outbound handler, this message is removed from the queue repository.

Advantageously, the outbound handler operates asynchronously, so that the outbound handler can send the message and then send the message before it is available for further processing before receiving an acknowledgment of the response from the recipient of the message .

According to an advantageous embodiment, the outbound handler comprises a delivery process for sending the message to the recipient and an acknowledgment process for receiving an acknowledgment of receipt from the recipient. The forwarding process and the acknowledgment process operate independently, allowing the forwarding process to be immediately available when the message is transmitted.

Advantageously, before receiving the input message and before performing the check step, the method further comprises the steps of: preventing all inbound handlers from receiving other messages of the sequence until the input message is stored in the sequence store or transmitted to the queue store And performing an inbound locking step to perform the inbound locking.

Advantageously, the incoming message may be accepted in the inbound handler while another message of the same sequence is being sent or processed by the outbound handler. The only limited case where you need to wait for an input message to be unlocked is in the following cases:

- If another input message is being stored in the storage tier or is being received by the inbound handler,

- The recipient's response to a message in the sequence is being received and processed by an outbound handler. When the outbound handler receives an answer, i. E. Acknowledgment, from the receiver, the outbound handler locks the sequence and the corresponding ranking, and if so, finds the next message to be sent in the sequence and increments the ranking.

Preferably, the inbound locking step includes locking a mutex dedicated to the sequence, wherein the mutex is stored in the sequence store.

Preferably, upon receiving the input message, the inbound handler checks the sequence correlation value of the sequence of the input message and reads the mutex parameter of the sequence before accepting the input message. The inbound handler accepts an input message if the mutex is not locked. If the mutex is locked, the input message waits for the mutex to be released.

More precisely, the mutex is stored in a sequence register included in the sequence store.

Advantageously, there is only one mutex per sequence in the inbound and outbound handlers. The repository queue in the queue repository ensures that only one message in a given sequence is propagated to the outbound handler until the outbound handler layer completes processing the message in this sequence.

Preferably, the outbound locking step includes locking a mutex dedicated to the sequence, wherein the mutex is stored in the sequence store.

Advantageously, when an outbound handler is available, the outbound handler checks whether the message is available for processing in the queue repository, and then retrieves and processes the message.

Preferably, when an outbound handler is available, the outbound handler checks whether there are any available messages in queue storage 850 to process. If there is a message, this message automatically becomes the correct message to be processed in the given sequence.

In one embodiment, storing the input message in a sequence store, or more accurately, an overflow store, the inbound handler sends an acknowledgment message.

Generally, the acknowledgment message is sent to the sender of the message.

Advantageously, messages with message rankings that exceed the sequence rankings can be overflowed to lock the message sequence in the overflow store, unless the message rankings match the sequence rankings, i.e., the rank of the next message to be processed It is stored in the repository.

Preferably, a message having a message ranking that exceeds the sequence rank is first stored in the overflow store and then discarded from the overflow store after the timeout value assigned to the sequence of messages is reached. Alternatively or additionally, a message having a message ranking that exceeds the sequence rank is first stored in the overflow store and then discarded from the overflow store after the timeout value assigned to the message is reached.

In another embodiment, the present invention is a non-temporary, computer-readable medium comprising software program instructions that, when executed by at least one data processor, cause an operation to execute a method according to the present invention To a non-transient computer-readable medium.

In yet another embodiment,

A distributed and parallel processing system for sequencing asynchronous messages,

- a plurality of inbound handlers comprising at least one data processor, each of the plurality of inbound handlers being configured to independently receive a plurality of input messages belonging to multiple sequences;

- a plurality of outbound handlers, each of which includes at least one data processor, each of the plurality of outbound handlers comprising: an outbound handler configured to independently process and deliver a plurality of input messages; And

- a storage layer comprising at least a memory,

복수의 아웃바운드 핸들러로 전송되도록 준비된 입력 메시지를 저장하는 큐 저장소;

A queue storage for storing input messages prepared for transmission to a plurality of outbound handlers;

시퀀스 저장소를 포함하고,

Contains a sequence repository,

The sequence repository comprising: a sequence state context 802 for maintaining and updating the state of the sequence of the input message; And an overflow store configured to receive the message from the inbound handler and sequentially deliver the message to the queue store,

The system comprising the steps of: determining whether an input message is the next message to be processed in order to maintain the order of the message in the sequence of the message;

If the sequence state indicates that none of the outbound handlers are currently processing the message of the sequence and if the input message is determined to be the next message to be processed in the sequence, Forwarding the message to an available outbound handler for later processing;

The sequence status indicating that at least one of the outbound handlers is currently processing the message of the sequence; Or if the queue repository already contains a message to be processed in the sequence; Or to store the input message in the overflow store to maintain further processing if it is determined that the input message is not the next message to be processed in the sequence, ≪ / RTI >

According to an alternative embodiment, the queue storage and sequence storage of the storage layer are implemented in in-memory data or file-based storage. Alternatively, the queue storage and sequence storage of the storage layer are implemented in a client-server storage database.

Advantageously, checking the sequence status comprises retrieving the status of the sequence based on the sequence correlation value of the sequence.

In another embodiment,

A computer-implemented travel monitoring method for processing asynchronous messages between at least one server application and at least one client application in a parallel environment having a plurality of parallel inbound handlers and a plurality of parallel outbound handlers, The next step carried out on at least one data processor, namely:

Receiving an input message at an inbound handler of one of the plurality of parallel inbound handlers, the input message having a sequence correlation value identifying a sequence comprising the input message;

- checking the sequence state of the sequence in the sequence store;

- determining whether the input message is the next message to be processed to maintain the order of the message in the sequence;

      If the sequence state indicates that none of the outbound handlers in the plurality of parallel outbound handlers are currently processing a message of the sequence and if the input message is determined to be the next message to be processed in the sequence Transferring the input message to a queue repository and then forwarding the input message to an available outbound handler for further processing;

      The sequence status indicating that at least one of the outbound handlers is currently processing the message of the sequence; Or if the queue repository already contains a message to be processed in the sequence; Or storing the input message in an overflow depot to maintain further processing if it is determined that the input message is not the next message to be processed in the sequence,

Characterized in that the message comprises data relating to a passenger and the sequence correlation value comprises data relating to a reference of a traffic service.

The method according to the invention may further comprise any of the following additional features and steps.

Once processed, the message may be received from the outbound handler, such as a travel booking and booking system, an airline inventory system, an airline electronic ticket system, an airport departure control system, an airport operating system, an airline operating system, System. ≪ / RTI >

In one embodiment, the reference to the transportation service includes at least one of a flight number, a date, and a class reservation.

In one embodiment, the message represents either a boarding passenger, a canceled passenger, or an added passenger.

In one embodiment, the sequence timeout value is provided to each input message to remove the input message stored in the overflow storage after reaching a sequence timeout value, wherein the sequence timeout value is determined by the departure time of the flight Triggered, or expired, or expired, of a flight.

In another embodiment, the present invention is a non-transient computer-readable medium comprising software program instructions that, when executed by at least one data processor, execute the software program instructions to perform the method according to the invention To a non-transitory computer-readable medium, characterized in that

In yet another embodiment, the present invention provides a computer-implemented method for sequencing distributed asynchronous messages in a distributed and parallel system having a plurality of inbound handlers and a plurality of outbound handlers comprising at least one processor for processing messages As a method, the method comprises the following steps performed in at least one data processor:

Receiving at the inbound handler the input message having a sequence correlation value identifying a sequence comprising an input message and determining a message ranking indicating the order of the input message in the sequence;

- checking the sequence state of the sequence in the sequence store;

If the sequence state indicates that none of the outbound handlers are currently processing the message of the sequence and if the received input message does not have an index indicating the message ranking in the sequence, Does not yet include the message to be processed in the message, or

Wherein the received input message comprises an index indicating the message ranking in the sequence wherein the message ranking equals the sequence ranking indicated in the sequence repository and defines a ranking of the next message to be processed in the sequence,

Forwarding the input message to a queue repository and then forwarding the input message to an outbound handler available for processing;

The sequence status indicating that at least one of the outbound handlers is currently processing the message of the sequence; Or if the queue repository already contains a message to be processed in the sequence; Or if the received input message has an index indicating the message ranking in the sequence, where the message ranking exceeds the displayed sequence rankings in the sequence store and defines the ranking of the next message to be processed in the sequence) And storing the input message in an overflow depot to maintain additional processing.

The foregoing and other aspects of embodiments of the present invention will become more apparent from the following detailed description when read in conjunction with the accompanying drawings, in which:
Figure 1A is an exemplary flow chart illustrating chronologically processing synchronous calls or messages between a calling system and a remote system;
2 is an exemplary flow chart illustrating chronologically processing an asynchronous call or message between a calling system and a remote system;
3 is an exemplary flow chart illustrating processing of a call or message in parallel in a distributed processing system;
4 is an exemplary flow chart illustrating parallel processing of asynchronous calls or messages in a distributed processing system that may result in a risk of compromising data beyond the message processing order;
5 is an exemplary block diagram of high level sequence management in a centralized and shared sequence context in accordance with the present invention.
6 is an exemplary flow chart illustrating a process for identifying a sequence in a transmission and processing channel according to the present invention;
Figure 7 illustrates an exemplary asynchronous and distributed processing system in accordance with the present invention.
8A illustrates an exemplary step of a sequencing process in which an inbound handler according to the invention receives a first message in sequence A. FIG.
Figure 8b illustrates another exemplary step in the sequencing process in which an inbound handler according to the present invention receives a second message in sequence A;
FIG. 8C illustrates another exemplary step in a sequencing process in which an outbound handler according to the present invention processes a first message in sequence A. FIG.
Figure 8d shows another exemplary step of a sequencing process in which an outbound handler according to the present invention processes a first message in sequence A;
Figure 8E illustrates exemplary steps of a sequencing process in which sequences are reordered in accordance with the present invention.

While the following detailed description has been given in the context of application to the travel industry, it is not intended to limit the application examples, and the invention is applicable to all types of data processing as well as travel products such as hotel rooms, vehicle rental, railway tickets, .

In accordance with the present invention, either by providing an index that explicitly indicates the rank of each message in the sequence, or by sending an implicit message sequentially, and then sending the next message in the given sequence By waiting for an acknowledgment, the processing order of messages in the asynchronous and parallel environment is defined by the sender or calling system of the message.

The present invention aims at ensuring that simultaneous and independent processes take into account the sequencing order of processing a given set of messages defined in a sequence.

In this regard, a method, apparatus and system for sequencing a distributed asynchronous message according to the present invention performs a variety of actions as described below and described in more detail below with reference to the drawings.

Each message or service call belonging to a given sequence is tagged to actually represent the particular sequence to which it belongs, by definition of the interface.

The ranking of a message or service call in a sequence of messages may,

명시적으로 적절한 인터페이스를 통해 메시지 또는 서비스 호출의 발송자/송신자에 의해 제공되거나(예를 들어, 메시지는 그 시퀀스 내 메시지의 랭킹을 한정하는 색인을 포함하는 필드를 포함한다), 또는

Provided by the sender / sender of the message or service call explicitly through the appropriate interface (e.g., the message includes a field containing an index that defines the ranking of messages in the sequence), or

암시적으로 시퀀스에서 메시지 또는 서비스 호출이 시간 외에(overtime) 수신된 순차 순서(sequential order)를 사용하는 것에 의해 제공된다.

Implicitly, a message or service call in a sequence is provided by using a sequential order received over time.

If sequence and message ranking or service call sequence is identified, the sequence should be properly managed.

Figure 5 shows an exemplary block diagram of high level sequence management in a centralized and shared sequence context. In this figure, the main features and major steps of the system are shown in detail.

The asynchronous and distributed processing system includes an inbound handler 510 that receives an input message 501 and an outbound handler 530 that is configured to process and deliver the message. The system includes an overflow storage area 540 that can store messages received from an inbound handler if the processing of this message 501 needs to be withhed so that the order of the sequence to which the message 501 belongs is retained .

The system includes a plurality of parallel inbound handlers 510 and a plurality of parallel outbound handlers 530, and FIG. 5 is simplified for ease of understanding.

An inbound handler may be referred to as an acceptor or acceptor process. Thus, an inbound handler layer comprising a plurality of inbound handlers may be referred to as a receptor layer.

An outbound handler may be referred to as a processor or a forwarding process. Thus, an outbound handler layer comprising a plurality of outbound handlers may be referred to as a transport layer.

The inbound handler 510 may specifically include receiving an message from a sender such as a publisher; Validating the integrity of the message; Performing sequence locking and state verification; Storing a message in one of two zones (i.e., a queue repository or an overflow zone); And responding to the sender.

According to an advantageous embodiment, the outbound handler 530 consists of two processes: a first process and a second process. The first process is referred to as a delivery process 531 and includes the act of obtaining a message from the store queue; Transmitting the message to a recipient via a communication channel; And quitting to be available for another process.

The second process is referred to as an acknowledgment process 532 and includes receiving an acknowledgment of receipt from a recipient; Performing a sequence management such as placing the next message in the corresponding sequence, if any, in a storage queue; So as to perform an operation of suspending it so as to be usable in another process.

Thus, the transport layer formed by the outbound handler 532 is asynchronous and can conform to high scalability requirements. In this way, the system is independent of the recipient's latency. More precisely, this means that the outbound handler can retrieve and forward the message of the first sequence and then retrieve and forward the other message of the second sequence before receiving the acknowledgment that the message of the first sequence has been delivered it means. Thus, the outbound handler can handle messages asynchronously from many sequences, thereby increasing the number of messages the system can route while maintaining the correct order in each sequence.

In accordance with the present invention, a converged and shared sequence context is implemented in which the state machine is used for each sequence. Each time an input message 501 is received by the inbound handler 510, the corresponding sequence context state is checked 520. [ According to one embodiment, if there is no corresponding sequence context, this is dynamically generated transparently. Thus, the present invention is completely dynamic in this respect as it does not require that the sequence be predefined in the system. Further, if the message does not have an index indicating its rank in the sequence, the message ranking is assigned to the message according to the arrival order of the message.

시퀀스 상태가 아웃바운드 핸들러 층이 시퀀스의 그 다음 메시지를 기다리고 있는 것을 표시하는 경우, 즉, 시퀀스 상태가 "대기(waiting)" 상태인 경우, 입력 메시지(501)는 아웃바운드 핸들러(530)에 의해 표준 거동에 따라 정상적으로 처리(522)되고(이때, 메시지는 비동기 처리에 이용가능하다); 또는

If the sequence state indicates that the outbound handler layer is waiting for the next message in the sequence, i. E. The sequence state is in the "waiting" state, the incoming message 501 is sent by the outbound handler 530 Normally processed 522 according to the standard behavior (at this time, the message is available for asynchronous processing); or

시퀀스 상태가 시퀀스의 메시지가 이미 현재 처리되고 있는 것을 표시하는 경우, 즉, 시퀀스 상태가 "처리" 상태인 경우, 입력 메시지(501)는 차후 처리(524)를 위해 특정 시퀀스 오버플로우 저장소 영역(540)에 저장된다. 오버플로우 저장소 영역(540)은 입력 메시지의 순서가 상실되지 않는 방식으로 구조화되고/색인된다. 이런 방식으로, 입력 메시지(501)는 추가적인 처리를 위해 유지되고, 이 메시지는 (시퀀스에서 벗어나서) 즉시 처리에 이용가능하지 않다.

If the sequence state indicates that the message of the sequence is currently being processed, that is, if the sequence state is a "processing" state, the input message 501 may be stored in a particular sequence overflow storage area 540 ). The overflow storage area 540 is structured and / or indexed in such a way that the order of the input messages is not lost. In this way, the input message 501 is maintained for further processing, and this message is not available for immediate processing (out of sequence).

The outbound handler layer receives the message to be processed according to the standard behavior and the message is in fact in the correct sequence ranking.

When message 501 is processed, the outbound handler layer waits for the next message to be processed in sequence in overflow storage area 540. If such a message is found, it is pushed to the outbound handler layer according to standard processes. If no message is found, the sequence status is reset to the "standby" state.

The order of each message in the sequence is maintained. The sequence repository defines a sequence ranking that indicates the ranking of the next message to be processed in order to preserve the order of the messages in the sequence. Sequence ranking is incrementally updated each time processing of a message is completed. Thus, the sequence ranking can be viewed as a counter.

Any input message that does not match the sequence ranking, i.e., the ranking of the next message to be processed, is stored in the overflow storage area 540 until the correct message to be processed is received by the inbound handler 510. This means that the insertion / removal operations in the overflow storage area 540 are performed taking into account the ranking of the sequences and the ranking of each message.

Since the message is stored in the overflow storage area 540 pending the turn to be processed in the sequence, it may not happen that the sequence is unlocked by the next message in the sequence. Although this situation does not occur very often, the present invention places an indicator in the context of the sequence to indicate a dynamic way to take action on the sequence when the indicator is considered expired, for example, to discard an expired message or an expired sequence It provides a dynamic way to take action.

Advanced Queuing이 대표적인 예이다. Message Oriented Middleware (MOM), referred to as MOM, provides sequencing features by avoiding the use of parallel processing (ie they force only one de-queuing consumer) . Thus, they sacrifice scalability and ensure sequencing. Oracle

Advanced Queuing is a good example.

Some other MOMs (e.g., MQ-Series) provide sequencing features based on correlators, but require that sequence messages be treated as logically grouped together. In addition, the group size should be limited and the MOM may require additional constraints on the de-queuing process.

The distributed and parallel processing according to the present invention provides strict sequencing while maintaining parallel processing and scalability, and the message or service call is correlated or processed by the dequeue process without requiring specific constraints on this approach. Through the high scale possibilities and resiliency of the method, apparatus and system of the present invention,

메시지를 포스팅(posted)하고 공정이 수신확인을 기다리지 않고, 다른 공정(수신확인 공정)이 수신확인을 수신하는 일을 담당하여, 매우 많은 메시지 처리량에 대처(coping with)할 수 있는,"포스팅 및 중지"원리를 사용하여 완전히 비동기식 전달 공정을 구현할 수 있고; 및

Message, which can cope with a very large amount of message processing, by taking charge of receiving an acknowledgment from another process (acknowledgment process), without waiting for the acknowledgment of the process. Quot; stop "principle can be used to implement a completely asynchronous transfer process; And

완전히 분산공정을 구현하고 시퀀스와 인바운드/아웃바운드 핸들러 사이에 친화성(affinity)을 제거하여, 이에 의해 임의의 인바운드/아웃바운드 핸들러가 임의의 시퀀스의 메시지를 핸들링할 수 있다.

By implementing a fully distributed process and eliminating affinity between the sequence and the inbound / outbound handler, any inbound / outbound handler can handle messages of any sequence.

A routine approach to addressing message sequencing may be to revert to a mono processing architecture, which results in large and often unacceptable constraints on resilience and scalability. Conversely, the present invention can provide the full benefit of distributed and parallel processing at two levels, inbound handler level and outbound handler level, while ensuring sequencing, as long as the cardinality in the sequence is high. This means that the present invention can fully exploit the advantages of parallel sequence processing only if the system has to cope with a large number of sequences in parallel.

There are no prerequisites for the storage area and the dequeue process:

인바운드 핸들러 층에서 메시지 수용(acceptance)의 큐잉 공정 및 아웃바운드 핸들러 층에서 메시지 처리의 큐잉 공정은 이것이 본 발명에 따라 가능할 수 있을 때 시퀀스 보존을 지원할 필요가 없다;

The queuing process of message acceptance at the inbound handler layer and the queuing process of message processing at the outbound handler layer need not support sequence preservation when this may be possible according to the present invention;

메시지의 병렬 저장소 및 병렬 검색(즉, 큐잉/큐잉 해제)이 완전히 보존된다;

Parallel storage and parallel retrieval of messages (ie queuing / dequeuing) is completely preserved;

비-제한적인 실시예에 따라, 큐 저장소 그 자체는 노드(node)에 국부적일 수 있는 반면, 오버플로우 저장소 영역은 전체적으로 유지되는데, 즉, 모든 아웃바운드 핸들러에 의해 공유된다. 오버플로우 저장소는, 임의의 노드가 주어진 시퀀스를 처리하여 고유한 오버플로우 영역에 액세스하여 이 저장소에 실제 큐잉하고 큐잉 해제할 수 있으므로 공유될 필요가 있다. 큐 저장소가 모든 아웃바운드 핸들러에 의해 공유되지 않는 경우, 이 큐 저장소는 단일 아웃바운드 핸들러에 전용되거나 또는 복수의 아웃바운드 핸들러에 전용될 수 있다. 큐 저장소가 모든 아웃바운드 핸들러에 의해 공유되지 않는 경우에, 각 메시지는 단 하나의 국부 큐 저장소에 의해 수신된다.

According to a non-limiting embodiment, the queue storage itself may be local to the node, while the overflow storage area is maintained globally, i. E., Shared by all outbound handlers. An overflow store needs to be shared because any node can process a given sequence to access a unique overflow area and actually queue and dequeue to that store. If the queue repository is not shared by all outbound handlers, this queue repository can be dedicated to a single outbound handler or dedicated to multiple outbound handlers. If the queue repository is not shared by all outbound handlers, each message is received by only one local queue repository.

메시지는 변경된 상태로 오버플로우 영역에 놓일 수 있어서 예외 큐(exception queue)가 필요치 않으므로 거부된 메시지를 저장하는 것은 더 쉽다.

It is easier to store the rejected message because the message can be placed in the overflow area with the changed state, so no exception queue is needed.

According to the method, apparatus and system of the present invention, the message sequence is processed in distributed and parallel mode by performing identification of the sequence and identification of the message rankings in this sequence. In addition to identification, the sequence must be managed and reordered, including sequence locking and timeout. This aspect is described in more detail below.

Identification of Sequences

In the flow of a message or event sharing a given transport channel, each correlated message set is required to be explicitly limited in terms of the sequence to be considered. 6 illustrates an exemplary flow diagram of a process for identifying a sequence in a transmission and processing channel 620 between a dispatching system 610 and a processing system 630. As shown in FIG.

A dedicated parameter is provided for each messaging primitive involved in a given transmission. This dedicated parameter is a sequence identifier, also referred to as a sequence correlation value. This parameter is usually a set of alphanumeric values by the sending system of the message. This parameter is used by each associated component to actually identify a message belonging to the same sequence. For example, messages 1 to 4 are parsed in transport channel 620 and identified as messages (# 1, ..., # 4). These correlated and aligned messages share the same transport channel 620, but these messages do not follow each other in succession. Thus, these messages are intertwined with messages belonging to other sequences in the transport channel 620.

Sequence correlation parameters are defined in a manner that ensures that they are not shared by separate collision processes in a given transmission and processing chain. In this context, it is essential to have strict uniqueness. Preferably, this definition of the sequence correlation parameter is responsible for performing business processes using the system.

Identifying Message Ranking in Sequences

Messages requiring to be processed in a particular order can be classified into two categories:

시퀀스 내 순서 또는 랭킹이 메시지가 생성될 때 알려지고, 그리고 바람직하게는 메시지의 총 수가 메시지 생성 시간에 알려지는 제1 종류의 메시지(여기서, 생성 공정은 전송 프리미티브에서 특정 메시지 랭킹 번호를 각 메시지에 할당할 수 있다. 이 메시지 랭킹 번호는 이후 최종 처리를 수행할 때까지 전체 체인의 일부로 각 공정에 의해 운반 및 저장된다); 및

A first type of message in which a sequence or ranking in a sequence is known when a message is generated and preferably a total number of messages is known at a message generation time, This message ranking number is then carried and stored by each process as part of the overall chain until the final processing is performed); And

시퀀스 내 순서가 발생 시간에 결정되는 제2 종류의 메시지(이 제2 종류의 메시지의 처리는 일반적으로 증분적이어서, 공정에서 각 새로운 메시지(또는 이벤트)가 시퀀스에서 이전의 메시지의 공정의 결과를 변경한다는 것을 의미한다. 이런 측면에서, 메시지의 발송 시스템은 주어진 시퀀스에서 메시지의 메시지 랭킹 번호도 알지 못하고, 시퀀스에서 메시지의 총 개수도 알지 못한다).

A second type of message in which the order in the sequence is determined at the time of occurrence (the processing of this second type of message is generally incremental so that each new message (or event) in the process will result in a process of the previous message in the sequence In this respect, the message dispatching system does not know the message ranking number of the message in a given sequence, nor does it know the total number of messages in the sequence).

For brevity, in the present description, the message ranking number of a message in a given sequence is referred to as message ranking.

Core Sequence Management

As shown in FIG. 7, exemplary asynchronous and distributed processing systems include

인바운드 핸들러 층을 형성하는 복수의 인바운드 핸들러(710, 720, ..., 740)(여기서, 인바운드 핸들러는 입력 메시지(711 , 721 , 731 및 741)를 수신하고, 이 메시지를 큐 저장소(750)에 각각 저장하고, 및 이 입력 메시지(711 , 721 , 731 및 741)를 잘 수신하였다는 것을 발송 시스템으로 수신확인할 수 있다);

A plurality of inbound handlers 710,720 ... 740 that form an inbound handler layer where the inbound handler receives incoming messages 711,721,731 and 741 and sends this message to the queue store 750, And can confirm receipt of this input message 711, 721, 731 and 741 to the dispatching system that they have been well received);

아웃바운드 핸들러 층을 형성하는 복수의 아웃바운드 핸들러(760, 770, ..., 790)(여기서, 각 아웃바운드 핸들러는 큐 저장소(750)로부터 메시지를 검색하고 이 메시지를 처리하도록 구성된다. 아웃바운드 핸들러는 처리된 메시지를 애플리케이션으로 전달하는 일을 또한 담당한다)를 포함한다.

A plurality of outbound handlers 760, 770, ..., 790 (each outbound handler is configured to retrieve messages from queue storage 750 and process the messages) The bound handler is also responsible for passing the processed message to the application).

An inbound handler may also be referred to as a receptor or receptor process. Outbound handlers may also be referred to as processors or forwarding processes.

8A illustrates an improvement of the embodiment of FIG. 7 that illustrates exemplary steps of a sequencing process of a first message of sequence A received by an inbound handler from a dispatch system. In this improvement, an additional component, referred to as sequence store 800, is provided between a plurality of inbound handlers 810, 820, ..., 840 and a plurality of outbound handlers 860, 870, ..., Lt; / RTI > layer. The sequence store 800 may include,

단 하나의 핸들러만이 한번에 주어진 시퀀스에서 (또는 동일한 시퀀스 상관 값을 갖는) 메시지를 처리하는 것을 보장하기 위해 뮤텍스(Mutex)라고도 언급되는 중앙 집중화된 또는 공통 및 공유된 시퀀스 뮤텍스(804)(여기서, 임의의 경쟁 시도는 먼저 오는 것에 먼저 서비스하는 모델에서 서비스될 수 있다);

A centralized or common and shared sequence mutex 804, also referred to as a mutex (here, a mutex), to ensure that only a single handler processes a message in a given sequence at once (or with the same sequence correlation value) Any competition attempt may be serviced in a model that is serviced first to come first);

모든 공정들 사이에 공유된 시퀀스 상태를 유지하기 위해 스테이터스(Status)라고도 지칭되는 중앙 집중화된 또는 공통 및 공유된 시퀀스 스테이터스 컨텍스트(802)(여기서, 시퀀스는 그 시퀀스 상관 값에 의해 고유하게 식별된다. 이 스테이터스는 주어진 시퀀스에서 각 이벤트에 대해,

A centralized or common and shared sequence status context 802, also referred to as a Status, to maintain a shared sequence state between all processes (where the sequence is uniquely identified by its sequence correlation value). This status indicates that for each event in a given sequence,

o "standby" state, which means that the next incoming message can be queued for delivery; And

o It is also possible to determine the behavior of applying the "transfer" state, which means that the next input message is retained); And

복수의 아웃바운드 핸들러에 의해 처리될 그 다음 메시지만이 이들 아웃바운드 핸들러에 액세스가능하도록 보장하고 다른 메시지는 이 오버플로우 저장소에서 "펜딩"하기 위해 오버플로우 또는 오버플로우 저장소 영역이라고도 지칭되는 중앙 집중화된 또는 공통 및 공유된 오버플로우 저장소(806)(여기서, 오버플로우 저장소는 현재 시퀀스 상태에 대해 전달되도록 준비가 되지 않은 색인된 및 정렬된 시퀀스 메시지를 위한 저장소이다.)를 포함한다.

It is ensured that only the next message to be processed by the plurality of outbound handlers is accessible to these outbound handlers, and the other message is a centralized < RTI ID = 0.0 > Or a common and shared overflow store 806, where the overflow store is a store for indexed and ordered sequence messages that are not ready to be delivered for the current sequence state.

These three component statuses 802, mutex 804 and overflow storage 806, which are context processing information, are the same characteristics as the queue storage 850. This information,

- implemented in memory data or file-based storage if all distributed processes are running on the same node, or

- It can be implemented in the client-server repository database (s) if the distributed process is running on multiple nodes and the server system is a remote system.

The maximum correspondence between the storage layer and the standard message store can be obtained by implementing all in a common RDBMS engine sharing a unique transaction.

Depending on the method, apparatus and system of the present invention,

큐 저장소(850)는 복수의 인바운드 핸들러와 복수의 아웃바운드 핸들러 사이에 메시지를 교환할 수 있게 하고, 시퀀스 저장소(800)와 독립적으로 동작하고;

The queue store 850 allows messages to be exchanged between a plurality of inbound handlers and a plurality of outbound handlers, and operates independently of the sequence store 800;

시퀀스 저장소(800)의 오버플로우 저장소(806)는 복수의 인바운드 핸들러(810, 820, ..., 840)와 복수의 아웃바운드 핸들러(860, 870, ..., 890) 사이에 메시지를 시퀀싱으로 교환하는 것을 보장한다.

The overflow store 806 of the sequence store 800 is responsible for sequencing messages between a plurality of inbound handlers 810, 820, ..., 840 and a plurality of outbound handlers 860, 870, ..., . ≪ / RTI >

8A illustrates a sequencing process of an input message of the present invention:

시퀀스 상관 값 "A"에 속하는 메시지(801-1)는 인바운드 핸들러(810)에 의해 수신된다;

A message 801-1 belonging to the sequence correlation value "A " is received by the inbound handler 810;

이 인바운드 핸들러(810)는 시퀀스 "A"의 뮤텍스(804)를 록킹(812)하여 임의의 인바운드 핸들러 또는 아웃바운드 핸들러가 시퀀스 상관 값 "A"를 갖는 다른 메시지를 처리하지 못하게 한다;

This inbound handler 810 locks (812) the mutex 804 of sequence "A " to prevent any inbound handler or outbound handler from processing other messages having the sequence correlation value" A ";

이 인바운드 핸들러(810)는 시퀀스가 존재하지 않거나 또는 시퀀스가 "대기" 상태에 있는 시퀀스 "A"의 중심 상태 컨텍스트(802)를 체크(814)한다;

The inbound handler 810 checks (814) the central state context 802 of the sequence "A " where the sequence does not exist or the sequence is in a" standby "state;

이 인바운드 핸들러(810)는 시퀀스 "A"의 상태 컨텍스트(802)를 "처리" 상태로 설정(814)한다. 본 발명은 이전에 수신된 메시지의 랭킹에 1 증분한 랭킹과 같은 메시지 랭킹을 입력 메시지에 할당한다. 입력 메시지가 이 시퀀스에서 제일 앞에 있는 것이므로, 메시지에 할당된 메시지 랭킹은 1로 설정된다. 메시지 랭킹은 바람직하게는 시퀀스 저장소(800)에 저장되고, 보다 정확하게는 시퀀스 컨텍스트(802)에 저장된다. 인바운드 핸들러(810)는 바람직하게는 메시지(851)를 큐 저장소(850)에 저장(816)한다; 및

This inbound handler 810 sets (814) the state context 802 of sequence "A" The present invention assigns a message ranking to an incoming message, such as a ranking that is incremented by one in ranking the previously received message. Since the input message is first in this sequence, the message ranking assigned to the message is set to one. The message ranking is preferably stored in the sequence store 800, and more precisely in the sequence context 802. The inbound handler 810 preferably stores (816) the message 851 in the queue store 850; And

이 인바운드 핸들러(810)는 메시지 발송자에 수신확인을 송신하고, 시퀀스 "A"의 뮤텍스(804)를 해제하고, 임의의 다른 입력 메시지를 수신할 준비를 한다.

This inbound handler 810 sends an acknowledgment to the message originator, releases the mutex 804 of sequence "A ", and is ready to receive any other incoming message.

Figure 8b shows the next steps in the sequencing process where another input message is received by the system:

시퀀스 "A"에 속하는 제2 메시지(801-2)가 인바운드 핸들러(820)에 의해 수신된다;

A second message 801-2 belonging to the sequence "A " is received by the inbound handler 820;

이 인바운드 핸들러(820)는 시퀀스 "A"의 뮤텍스(804)를 록킹(822)하여 임의의 인바운드 핸들러(810, 830 또는 840) 또는 아웃바운드 핸들러가 시퀀스 "A" 내 다른 메시지를 처리하지 못하게 한다;

This inbound handler 820 locks 822 the sequence 804 of the sequence "A" to prevent any inbound handler 810, 830 or 840 or outbound handler from processing other messages in the sequence "A";

이 인바운드 핸들러(820)는 시퀀스 "A"의 중심 상태 컨텍스트(802)를 체크(824)하는데, 여기서 시퀀스 상태는 "처리" 상태이다. 메시지가 임의의 아웃바운드 핸들러에 이용가능하게 만들어질 수 없으므로, 인바운드 핸들러(820)는 메시지(807)를 오버플로우 저장소(806)에 저장(826)한다.

This inbound handler 820 checks 824 the central state context 802 of sequence "A ", where the sequence state is a" processing "state. Since the message can not be made available to any outbound handler, the inbound handler 820 stores 826 the message 807 in the overflow store 806.

A message ranking corresponding to one increment in the message ranking of the input message previously is assigned to the input message. Since the message rank of the previous message was 1, the message rank assigned to the input message is 2. Furthermore, the present invention increments the sequence ranking that defines the ranking of the next message to be processed in this sequence. Thus, if multiple messages from the same sequence are stored in the sequence store 800, the system can identify the correct message to be delivered to the queue store 850 via its message ranking. The correct message is a message with a message ranking corresponding to the sequence ranking defined in the sequence. Advantageously, this applies when the input message has a message rank assigned by the sender and when the ranking of the incoming message is assigned according to the order in which it arrives at the inbound handler.

인바운드 핸들러(820)는 메시지 발송자에 수신확인을 송신하고, 시퀀스 "A"의 뮤텍스를 해제하고 임의의 다른 입력 메시지를 수신할 준비를 한다.

The inbound handler 820 sends an acknowledgment to the message sender, releases the mutex of sequence "A " and is ready to receive any other incoming message.

Figure 8c shows the following steps of a sequencing process in which a message stored in a queue in a queue repository is dequeued to one of the outbound handlers for processing:

아웃바운드 핸들러(870)들 중 하나는 큐 저장소(850)로부터 시퀀스 "A"의 메시지(851)를 검색(871)한다. 본 발명으로 인해, 이 메시지는 자동적으로, 처리되어야 하는 시퀀스의 그 다음 메시지이다. 그리하여 그 랭킹은 처리된 마지막 메시지의 랭킹에 1증분을 한 것이다. 이 예시적인 실시예에서, 큐 저장소에 저장된 메시지는 시퀀스 A에서 제일 앞에 있는 것이므로, 그 랭킹은 필연적으로 "1"이다;

One of the outbound handlers 870 retrieves (871) a message 851 of sequence "A " from the queue store 850. Due to the present invention, this message is automatically the next message in the sequence to be processed. Thus, the ranking is one increment to the rank of the last message processed. In this exemplary embodiment, since the messages stored in the queue repository are first in the sequence A, the ranking is inevitably "1 ";

아웃바운드 핸들러(870)는 수신자로 더 전달하기 전에 랭킹 "1"을 갖는 메시지를 관련 수신자 또는 다른 라우팅 수단으로 전달(873)한다. 메시지가 단계(873)에서 송신되었다면, 아웃바운드 핸들러(870)는 다른 처리에 이용가능하다. 이 아웃바운드 핸들러는 수신자로부터 수신의 수신확인을 아직 수신하지 못하였으나 여전히 동작할 수 있다. 예를 들어, 아웃바운드 핸들러(870)는 다른 시퀀스에 속하는 다른 메시지를 검색하고 송신하여, 비동기식 전달을 달성하여 처리량을 개선시킬 수 있다. 또한 이 아웃바운드 핸들러는 임의의 메시지에 대해 임의의 발송자로부터 수신의 수신확인을 수신할 수 있다. 그리하여, 아웃바운드 핸들러가 실행할 수 있는 메시지 및 처리의 개수는 단계(873)에서 송신된 메시지의 발송자의 응답 시간에 의해 제한되지 않는다.

Outbound handler 870 passes 873 the message with the ranking "1 " to the associated recipient or other routing means before further forwarding to the recipient. If a message was sent in step 873, the outbound handler 870 is available for other processing. This outbound handler has not yet received acknowledgment of receipt from the receiver, but can still operate. For example, the outbound handler 870 can retrieve and send other messages belonging to another sequence to achieve asynchronous delivery, thereby improving throughput. The outbound handler can also receive an acknowledgment of receipt from any sender for any message. Thus, the number of messages and processes that the outbound handler is capable of executing is not limited by the response time of the sender of the message sent in step 873.

수신자는 아웃바운드 핸들러(870)의 전달 공정(8701)으로부터 단계(873)에서 송신된 메시지를 수신한다. 이에 응답하여, 수신자는 수신확인 메시지를 시스템으로 송신한다. 동일한 아웃바운드 핸들러(870)의 수신확인 공정(8702) 또는 다른 아웃바운드 핸들러(860)의 수신확인 공정(8602)은 수신확인 메시지를 수신한다. 이것은 도 8c에 도시된 단계(874)에 대응한다.

The recipient receives the message sent in step 873 from the delivery process 8701 of the outbound handler 870. [ In response, the receiver sends an acknowledgment message to the system. The acknowledgment process 8702 of the same outbound handler 870 or the acknowledgment process 8602 of the other outbound handler 860 receives an acknowledgment message. This corresponds to step 874 shown in FIG. 8C.

Figure 8d shows the next steps in the sequencing process where the next message stored in the overflow storage area 806 is passed to the queue store 850 before being forwarded to one of the outbound handlers for processing. The steps shown in FIG. 8D are triggered by receiving 875 an acknowledgment message at the inbound handler of the system.

아웃바운드 핸들러(860)는 상태 컨텍스트(802)에서 시퀀스 랭킹을 체크(862)하여 수신확인된 메시지의 시퀀스 내에서 처리되어야 하는 그 다음 메시지의 랭킹을 결정한다. 시퀀스 랭킹은 "2"로 설정되므로, 아웃바운드 핸들러(860)는 오버플로우 저장소 영역(806)으로부터 메시지 랭킹 "2"를 가지는 시퀀스 "A"의 메시지(807)를 검색(809)한다. 이 메시지(807)는 큐 저장소(850)에 저장될 수 있고, 모든 아웃바운드 핸들러에 이용가능하게 만들어질 수 있다. 상태 컨텍스트(802)는 "처리" 상태에 유지된다. 시퀀스 랭킹은 증분되어 "3"으로 설정되고, 이에 의해 처리될 그 다음 메시지는 "3"과 같은 메시지 랭킹을 가지는 것임을 표시한다;

Outbound handler 860 checks (862) the sequence rankings in state context 802 to determine the ranking of the next message to be processed within the sequence of acknowledged messages. The outbound handler 860 retrieves 809 a message 807 of the sequence "A" having the message ranking "2" from the overflow storage area 806 since the sequence ranking is set to "2". This message 807 may be stored in the queue store 850 and made available to all outbound handlers. The state context 802 is maintained in the "processing" state. The sequence ranking is incrementally set to "3 ", indicating that the next message to be processed has a message ranking of" 3 ";

아웃바운드 핸들러(860)는 종료하고, 큐 저장소(850)에 저장된 다른 메시지를 처리할 준비를 한다.

The outbound handler 860 terminates and is ready to process other messages stored in the queue store 850.

그리고 공정은, 입력 메시지의 전체 시퀀스가 처리되고 전달될 때까지 계속된다.

The process then continues until the entire sequence of input messages has been processed and delivered.

The process described above in FIGS. 8A-8D is the same regardless of whether the input message was received with or without a sequence index indicating the ranking of the messages in the sequence. If this ranking is provided, this ranking is used as the ranking of the sequencing; Otherwise, this ranking is generated by the inbound handler based on the receiving order in the same sequence.

Sequence re-arrangement

In addition to the processes previously described above in Figures 8A-8D, where input messages are received by the inbound handler in strict sequence order, the same process is also implemented to process the received messages out of sequence. The only real precondition is that the message sender provides an index for each message in the same sequence, which indicates the ranking in the sequence for each message.

As previously described, the present invention increments the sequence ranking that defines the ranking of the next message to be processed in this sequence. When queue storage 850 is able to receive messages from a given sequence, the sequence ranking is checked. Only messages with message ranks, such as sequence rankings, are delivered to the queue store 850. If a message with a message ranking, such as a sequence rank, is not in the overflow area 806 of the sequence store 800, then processing of this sequence is suspended until a message with the correct ranking is received from the inbound handler. Thus, the sequence ranking acts like a counter that displays a message to be processed. Preferably, the sequence ranking is stored in the sequence store 800.

8E shows the steps of the sequencing process of the re-ordered input message 801:

In addition to the above-described processes performed by the plurality of inbound handlers 810, ..., 840, additional steps may occur for re-arrangement driven by index order:

메시지의 색인에 의해 표시된 메시지의 랭킹은 시퀀스 순서를 유지하기 위해 처리할 그 다음 메시지의 랭킹과 비교된다. 시퀀스 순서를 유지하기 위해 처리할 그 다음 메시지의 이 랭킹은 바람직하게는 시퀀스 저장소에서 증분적으로 업데이트된 시퀀스 랭킹에 의해 표시된다.

The ranking of the message indicated by the index of the message is compared with the ranking of the next message to be processed to maintain the sequence order. This ranking of the next message to be processed in order to maintain the sequence order is preferably indicated by the sequence rankings incrementally updated in the sequence repository.

메시지의 랭킹이 시퀀스 랭킹과 일치(818)하면, 입력 메시지(815)는 큐 저장소(850)에 저장되어, 복수의 아웃바운드 핸들러에 이용가능하게 된다. 시퀀스 상태는 처리 상태로 설정된다. 처리할 시퀀스 랭킹은 증분되고 전술된 공정이 적용된다.

If the ranking of the message matches 818 the sequence rankings, the input message 815 is stored in the queue store 850 and made available to a plurality of outbound handlers. The sequence state is set to the processing state. The sequence rankings to be processed are incremented and the above-described process is applied.

색인에 의해 표시된 메시지의 랭킹이 시퀀스 랭킹(819)을 넘는다면, 메시지(813)는 오버플로우 저장소(806)에 저장된다. 시퀀스 상태(802)는 "펜딩" 상태로 설정된다. 이 메시지는 사실상 처리되지 않는다. 처리될 예상된 메시지 랭킹을 갖는 메시지가 인바운드 핸들러에 의해 수신될 때 시퀀싱이 재개된다. 이 경우에 인바운드 핸들러가 대응하는 메시지를 큐 저장소에 저장하고 시퀀스 상태를 "처리" 상태로 설정한다.

If the ranking of the message indicated by the index exceeds the sequence ranking 819, the message 813 is stored in the overflow store 806. The sequence state 802 is set to the "pending" state. This message is not actually processed. Sequencing resumes when a message with the expected message rank to be processed is received by the inbound handler. In this case, the inbound handler stores the corresponding message in the queue repository and sets the sequence state to the "processing" state.

8A to 8D, when the outbound handler eventually processes a message, the outbound handler looks for a message in the overflow store 806 with a message ranking that matches the sequence rankings Ranking indicates the ranking of the next message to be processed to maintain the sequence order). If a message is found, this message is stored in queue storage 850; If a message is not found, the sequence state is set to the "pending" state (if the message in this sequence is in the overflow region but has a ranking that is not equal to the sequence ranking) Area) is set to the "standby" state.

Sequence Locking and Timeout Management

As described above, messages received in a given sequence are stored in overflow storage 806, unless their message ranking is consistent with what is being processed. This results in a situation in which the entire sequence is locked, unless the next expected message to be processed is received by the inbound handler.

In certain embodiments, the invention ensures that this locking situation is time-limited, even if this is required by the process. This process also defines the total sequence timeout value expressed in duration (seconds, minutes, days, ...).

In another embodiment, the sequence context 802 may comprise an absolute time value defined by a sequence timeout. Each time an inbound handler or an outbound handler accesses a given sequence context record (meaning that it is processing a message belonging to a sequence that is an indication of the operation of the sequence), this absolute time value is the current system time and sequence And is updated with the sum of the timeout duration.

In yet another embodiment, a timeout sequence collector may be implemented to regularly wake up and scan the entire list of sequence contexts. In this particular implementation, an expired sequence is detected for that sequence duration. This process achieves the selection using the sequence timeout value.

Depending on the implementation, the method, apparatus and system according to the invention,

오버플로우 저장소(806) 및 시퀀스 컨텍스트(802)에서 임의의 대응하는 메시지를 소거하고;

Clear any corresponding messages in the overflow store 806 and the sequence context 802;

특정 시퀀스 만료 이벤트에서 적절한 처리와 로깅(logging)을 수행할 수 있는데: 이 만료 이벤트는,

You can perform proper processing and logging at specific sequence expiration events:

o Ignore item (s) while waiting to be delivered or synchronized, such as taking items in order,

o An alarm may be generated.

The present invention can be widely applied in processing data. However, it is particularly appropriate to:

메시징 서버, 예를 들어, 아마데우스 메시징 서버(Amadeus Messaging Server: AMS), 여기서 애플리케이션이 지속하는 메시징을 처리하여, 회사 및 보다 구체적으로 소프트웨어 회사의 인프라스트럭처에서 허브로 작용하는 것. 부킹 또는 예약 산업에서, AMS는 예약 시스템 및 출발 제어 시스템 모두로 사용될 수 있다. 시퀀싱은 모든 텔레타이프 트래픽(Teletype traffic)에 시행된다. 텔레타이프 메시지는 통상 TTY로 언급된다. TTY 유형 B는 주어진 기능 컨텍스트에 대해 엄격한 처리 순서로 비동기식 채널을 통해 메시지를 교환하는 항공사 산업 표준이다. 예를 들어, 제1 메시지는 탑승 승객 리스트를 포함하고, 제2 리스트는 억제된 승객 리스트를 포함하고, 제3 리스트는 추가된 승객 리스트를 포함한다. 이들 승객 리스트는 엄격한 순서로 추종되어야 한다.

A messaging server, for example Amadeus Messaging Server (AMS), where the application handles persistent messaging, acting as a hub in the company and more specifically in the software company's infrastructure. In the bookkeeping or booking industry, the AMS can be used both as a reservation system and as a departure control system. Sequencing is performed on all teletype traffic. The teletype message is usually referred to as TTY. TTY Type B is an airline industry standard that exchanges messages over asynchronous channels in strict processing order for a given functional context. For example, the first message includes the boarding passenger list, the second list includes the suppressed passenger list, and the third list includes the added passenger list. These passenger lists must be followed in strict sequence.

다른 애플리케이션 필드는 예를 들어 보장된 비동기식 전달을 구현하기 위해 다수의 애플리케이션에 의해 사용된 미들웨어 소프트웨어 성분인 OTF 하이 레벨 프레임워크(OTF high-level framework: OHF)이다. OHF로 시퀀싱하는 주요 사용은 쿠폰 데이터베이스(coupon database: CDB)와 전자 티켓팅 애플리케이션 사이에 발생하는 동기화이다. 종종 많은 변경이 제한된 시간 기간 내에 단일 쿠폰에 이루어질 수 있다. 이들 변경은 동기화를 유지하기 위하여 올바른 순서로 전자 티켓 애플리케이션 또는 쿠폰 데이터베이스로 전달되어야 한다.

The other application field is, for example, an OTF high-level framework (OHF), a middleware software component used by a number of applications to implement guaranteed asynchronous delivery. The main use for sequencing with OHF is the synchronization that occurs between the coupon database (CDB) and the electronic ticketing application. Often many changes can be made to a single coupon within a limited time period. These changes must be delivered to the electronic ticket application or coupon database in the correct order to maintain synchronization.

While the foregoing detailed description has been described basically in the context of a travel solution provided by an airline or airline company, those skilled in the art will appreciate that embodiments of the present invention are not limited to use with airline only, It will be understood that the invention can be adapted for use with travel types and travel providers of the type, for example non-limiting examples, such as vessels, trains, passenger cars, bus travel providers and hotels.

The foregoing detailed description provides illustrative and non-limiting examples of various methods, apparatus, and software for implementing exemplary embodiments of the present invention. However, it will be apparent to those skilled in the art that various modifications and variations will be apparent to those skilled in the art in view of the foregoing description, when read in conjunction with the accompanying drawings and the appended claims. It is contemplated by one of ordinary skill in the art to use other similar or equivalent processes or algorithms and data representations, merely as examples. Furthermore, the various names used in the different elements, functions, and algorithms (e.g.,, etc.) are for illustration purposes only and are not intended to limit the invention in any way, It can be mentioned with an appropriate name. Modifications similar to all such modifications to the teachings of the present invention are within the scope of embodiments of the invention.

Further, some of the features of the exemplary embodiments of the present invention may be used without using corresponding other features. Thus, the foregoing detailed description is to be understood as merely illustrative of the principles, teachings and embodiments of the present invention, and is not to be construed as limiting the invention.

Embodiments of the various techniques described herein may be implemented in digital electronic circuitry, in computer hardware, or in handheld electronic device hardware, in firmware, software, or a combination thereof. An embodiment may be implemented in a program or software product, i. E. An information carrier, e.g., a machine-readable storage device, or by a data processing device, e.g., a programmable processor, computer, May be embodied in a computer program product tangibly embodied in a signal to be propagated to control the computer system. A program, such as the computer program (s) described above, may be written in any form of programming language, including a compiled or interpreted language, and may be a stand-alone program or module, component, subroutine, And may be deployed in any form including units. The programs may be deployed to run on multiple computers or tablets that are distributed on a single computer or tablet, or on a single site or across multiple sites and interconnected by a communications network or wireless network.

Processors suitable for executing computer programs include, by way of example, general purpose and special purpose microprocessors, and any one or more processors of any kind of digital computer, tablet, or electronic device. In general, a processor may receive instructions and data from a read-only memory or a random access memory, or both. An element of a computer may include at least one processor for executing instructions and one or more memory devices for storing instructions and data. Generally, a computer or electronic device includes one or more mass storage devices that store data, for example, a magnetic disk, a magneto-optical disk, or an optical disk, that contains or receives data from, Or to perform operations.

This embodiment may include a back-end component, e.g., as a data server, or may include a middleware component, e.g., an application server, or a front-end component, For example, a client computer with a graphical user interface or web browser with which the user can interact with the implementation, or a computing system including any combination of such backend, middleware, or front end components. The components may be interconnected by any form or medium of digital data communication, for example, a communications network, a wireless network, or a telecommunications network. Examples of communication or telecommunication networks include a local area network (LAN) and a wide area network (WAN), such as the Internet or a wireless network, for example a Wifi network.

Although specific features of the described implementations have been illustrated herein, many alterations, substitutions, changes, and equivalent substitutions can now occur to those of ordinary skill in the art. It is, therefore, to be understood that the appended claims are intended to cover all such modifications and changes as fall within the true spirit and scope of the embodiments of the invention.

Claims (28)

1. A method for sequencing asynchronous messages in a distributed system having a plurality of inbound handlers and a plurality of outbound handlers,
Receiving, by a processor of the inbound handler of one of the inbound handlers, an input message having a sequence correlation value, the sequence correlation value identifying a sequence associated with an incoming message;
Checking, by the processor, a sequence state of the sequence in a sequence repository;
Determining, by the processor, a message rank indicating a sequence of the input message in the sequence:
Comparing, by the processor, the message ranking with a sequence ranking defining a ranking of a next message to be processed for the sequence;
Determining, by the processor, that the message is the next message to be processed to maintain the order of the message in the sequence if the message ranking is equal to the sequence ranking;
Determining, by the processor, that the message is not the next message to be processed to maintain the order of the message in the sequence if the message ranking is not equal to the sequence rankings;
If the sequence state indicates that the outbound handler is not currently processing one of the messages of the sequence and if it is determined that the input message is the next message to be processed for the sequence, Delivering the input message to a queue repository and then forwarding the input message to one of the outbound handlers available for processing; And
If the sequence state indicates that at least one of the outbound handlers in the plurality of outbound handlers is currently processing one of the messages of the sequence, or if one of the messages of the sequence waiting for the queue repository to be processed has already been received Storing the input message in the memory of the overflow store to keep it for further processing by the processor if it is determined that the input message is not the next message to be processed for the sequence
Wherein the asynchronous message is a sequence of asynchronous messages. The method according to claim 1,
Further comprising, upon completion of processing one of the messages of the sequence, incrementing a sequence rank of the sequence by the processor. 3. The method of claim 2,
Determining, by the processor, that a given message in the overflow storage comprises a message ranking, such as the incremented sequence ranking; And
And forwarding, by the processor, the given message to the queue repository. The method according to claim 1,
Assigning, by the processor, a message ranking assigned to the input message, the assigned message ranking indicating a ranking of the input message in the sequence; And
Further comprising, by the processor, storing the assigned message rankings in the sequence repository. 5. The method of claim 4,
Wherein the assigned message ranking corresponds to a ranking of one increment in message rank of the last message received at any one of the inbound handlers for the sequence. The method according to claim 1,
If the queue store does not include any message for the sequence of input messages and if the message ranking of the input message is greater than the sequence rankings displayed in the sequence store, Further comprising storing the input message in the overflow depot until it is equal to the message rank of the message queue of the asynchronous message. The method according to claim 1,
Further comprising: receiving, by the processor, an index with the input message,
Wherein the index indicates a message ranking of the input message within the sequence. The method according to claim 1,
Processing one of the messages by one of the outbound handlers; And
And removing the message from the queue repository. ≪ Desc / Clms Page number 19 > The method according to claim 1,
Wherein the outbound handler operates asynchronously so that one of the outbound handlers can send one of the messages and send the message to another process before sending the message and receiving acknowledgment of the response from the recipient of the message Wherein the asynchronous message can be made available. The method according to claim 1,
Providing, by the processor, a delivery process associated with one of the outbound handlers, the delivery process being configured to send one of the messages to a recipient;
Providing, by the processor, an acknowledgment process associated with the outbound handler, the acknowledgment process being configured to receive an acknowledgment from the recipient; And
Further comprising configuring the delivery process and the acknowledgment process to operate independently of each other. The method according to claim 1,
In response to receiving the input message, causing the inbound handler to not receive any message associated with the sequence until the input message is stored in one of the sequence repository and the queue repository Further comprising the steps of: < RTI ID = 0.0 > a < / RTI > 12. The method of claim 11,
Storing, by the processor, a mutex in the sequence store, the mutex being associated with the sequence; And
Further comprising locking the mutex by the processor to prevent the inbound handler from receiving any message associated with the sequence. The method according to claim 1,
Determining, by the processor, that one of the messages in the queue repository is available for processing;
Retrieving, by the processor, the message from the queue repository; And
Further comprising, by the processor, processing the message with one of the outbound handlers. The method according to claim 1,
Storing, by the processor, a mutex in the sequence store, the mutex being associated with the sequence; And
Further comprising locking the mutex by the processor such that another outbound handler does not process any messages associated with the sequence while the input message is being processed by one of the outbound handlers. How to sequence an asynchronous message. 15. The method of claim 14,
Checking, by the processor, the queue repository to determine whether the mutex is locked for a sequence of the input message; And
Further comprising retrieving the input message from the queue repository if the mutex is not locked. The method according to claim 1,
Further comprising the step of sending an acknowledgment message from one of said inbound handlers by said processor upon storing said input message in one of said sequence repository or said overflow repository. . The method according to claim 1,
Wherein one of the messages having a message ranking greater than the sequence ranking is stored in the overflow store to lock the message in the overflow store while the message ranking of the message is not equal to the sequence ranking. A method for sequencing asynchronous messages in a distributed system. The method according to claim 1,
Storing, by the processor, one of the messages in the overflow store, the message ranking of the message being greater than the sequence ranking;
Assigning, by the processor, a timeout value to one of the message and the sequence; And
Further comprising, when the timeout value is reached, discarding the message from the overflow store by the processor. 1. A non-transitory computer readable medium comprising software program instructions, comprising instructions for executing the software program instructions by at least one data processor to perform operations comprising the execution of the method of claim 1, Readable medium. A distributed processing system for sequencing asynchronous messages,
A plurality of inbound handlers including at least one data processor, each of the plurality of inbound handlers configured to independently receive a plurality of input messages relating to various sequences;
A plurality of outbound handlers including at least one data processor, each of the plurality of outbound handlers being configured to independently process and forward a plurality of input messages; And
The storage layer comprising at least a memory,
A queue storage for storing an input message ready for transmission to the plurality of outbound handlers,
Contains a sequence repository,
Wherein the sequence repository comprises:
A sequence state context for maintaining and updating a state for each sequence of the input message;
An overflow store configured to receive a message from the inbound handler and to sequentially deliver the message to the queue store,
The system determines if the incoming message is the next message to be processed to maintain the order of the message in its sequence and performs the following steps performed with the at least one data processor:
If the sequence state indicates that the outbound handler is not currently processing one of the messages of the sequence and if it is determined that the input message is the next message to be processed for the sequence, Delivering the input message to the queue repository and then forwarding the input message to one of the outbound handlers available for processing; And
If the sequence state indicates that at least one of the outbound handlers in the plurality of outbound handlers is currently processing one of the messages of the sequence, or if one of the messages of the sequence waiting for the queue repository to be processed has already been received Storing the input message in the memory of the overflow store to keep it for further processing by the processor if it is determined that the input message is not the next message to be processed for the sequence
And to perform the asynchronous message sequencing. 21. The method of claim 20,
Wherein the queue storage and sequence storage of the storage layer are implemented in one of an in-memory data or a file-based storage. 1. A computer-implemented travel monitoring method for processing a plurality of messages between at least one server application having a plurality of inbound handlers and a plurality of outbound handlers and at least one client application,
Receiving, by a processor of the inbound handler of one of the inbound handlers, an input message having a sequence correlation value, the sequence correlation value identifying a sequence associated with an input message;
Checking, by the processor, a sequence state of the sequence in a sequence repository;
Determining, by the processor, whether the input message is the next message to be processed to maintain the order of the message in the sequence;
If the sequence state indicates that the outbound handler is not currently processing one of the messages of the sequence and if it is determined that the input message is the next message to be processed for the sequence, Delivering the input message to a queue repository and then forwarding the input message to one of the outbound handlers available for processing; And
If the sequence state indicates that at least one of the outbound handlers in the plurality of outbound handlers is currently processing one of the messages of the sequence, or if one of the messages of the sequence waiting for the queue repository to be processed has already been received Storing the input message in the memory of the overflow store to keep it for further processing by the processor if it is determined that the input message is not the next message to be processed for the sequence and,
Wherein the plurality of messages comprises data associated with at least one passenger of a transportation service and wherein the sequence correlation value comprises data related to the transportation service. 23. The method of claim 22,
In response to processing a particular message in the plurality of messages, cause the processor to send the particular message from one of the outbound handlers to a travel reservation system of a transportation service, a travel booking system of a transportation service, , An electronic ticketing system of the transportation service, a departure control system of the transportation service, or a combination thereof. 23. The method of claim 22,
Wherein the data related to the transportation service comprises a flight number, a date, a class reservation, or a combination thereof. 23. The method of claim 22,
Wherein the plurality of messages comprises data relating to at least one passenger, at least one canceled passenger, at least one additional passenger, or any combination thereof. 23. The method of claim 22,
Providing, by the processor, a sequence timeout value for a particular message in the plurality of messages;
Removing, by the processor, the particular message from the overflow store when an associated sequence timeout value for the particular message is reached; And
Wherein the processor is further configured to initiate a time elapsed from the sequence timeout value from a departure time of the flight, an expiration of the flight offer, a promotion expiration, or any combination thereof, . 29. A computer readable medium comprising software program instructions for causing the at least one data processor to execute the software program instructions to perform operations comprising the execution of the method of claim 22. A computer implemented method for sequencing asynchronous messages distributed in a distributed system having a plurality of inbound handlers and a plurality of outbound handlers including at least one processor for processing messages,
Receiving, at one of the inbound handlers, an input message with a sequence correlation value identifying a sequence comprising an input message by a processor, and determining a message ranking indicating the order of the input message in the sequence;
Checking, by the processor, a sequence state of the sequence in a sequence repository;
If the outbound handler indicates that the outbound handler is not currently processing one of the messages of the sequence, and if the received message does not have any index indicating the message ranking in the sequence, If the received message does not include any message to be processed for the sequence, or if the received input message has a message ranking in the sequence, the message ranking is the same as the sequence rankings indicated in the sequence store and the next message to be processed for the sequence - defining, by the processor, the input message to the queue repository, and then, by the processor, send one of the outbound handlers to be available for processing Lt; RTI ID = 0.0 > A step; And
Wherein the sequence state indicates that at least one of the outbound handlers in the plurality of outbound handlers is currently processing one of the messages of the sequence, or if the queue repository indicates one of the messages to be processed for the sequence The message ranking is greater than the sequence rankings indicated in the sequence repository and defines the ranking of the next message to be processed for the sequence, And if so, storing, by the processor, the input message in an overflow store to hold for further processing.

Images