Put With Wait for a queued messaging system
Original Publication Date: 2002-Feb-15
Included in the Prior Art Database: 2003-Jun-21
In an asynchronous message queuing solution, it can be advantageous to enable the enqueue operation of a synchronous Put operation to implement a server-controlled wait (timed blocking behaviour) when the enqueue operation cannot be performed immediately. This will be described below. In such systems, it is possible for sending applications to flood the messaging system such that a receiving application cannot keep up. The messages then build up on queues until the queues become full. When this occurs, further Put operations may fail until one or more messages are retrieved from the queue. It can be difficult to provide appropriate messaging behaviour in these circumstances, particularly if there are several queued steps between the sending and receiving applications. One known solution is for the sender to receive a failure response when the queue is full, such that the sender knows that it has to retry the Put operation until it is successful. These retries could be attempted after a time delay. The message may be placed on a dead letter queue after a certain number of unsuccessful retries, so that problem messages are not retried for ever. Nevertheless, if the sender application retries repeatedly, this has the overhead of repeated crossing of the message queueing interface. It has now been recognised that it will often be more efficient for the queue manager program that is attempting to perform the enqueue operation to wait for a timed period in case the enqueue operation can be performed successfully within the defined period. This can be implemented by providing a Put With Wait option for message Put operations. This will not solve problems where the receiving application goes completely offline, and it still leaves the option for a putting application which requires it to push information as fast as possible (by not using the Put With Wait option). However, it permits a very simple programming style for sending applications dynamically to pace their output to the rest of the system. e.g.