EIP – Polling Consumer

Post by: syed hussain in All Integration Design Patterns

Summary

A polling consumer design pattern is a software architecture pattern commonly used in messaging systems, where a client application polls a message queue or a data source periodically to check for new messages or data.

In this pattern, the client continuously sends requests to the server or message queue, asking if there are any new messages available. If there are no messages available, the client waits for a certain period of time and then sends another request. This polling process continues until the client receives a new message or data.

The advantage of this pattern is that it is relatively simple to implement and can be used in situations where real-time communication is not essential or when network conditions make it difficult to maintain an open connection. However, it can be inefficient in terms of resource utilization and can lead to unnecessary network traffic if the polling interval is too short.

In contrast, a push-based architecture, where the server or message queue pushes messages to the client as they become available, can be more efficient and scalable, but may require more complex implementation and infrastructure support.

C# Implementation of Polling Consumer

using System;
using System.Messaging;

class Program
{
    static void Main(string[] args)
    {
        string queueName = ".\\Private$\\MyQueue";
        MessageQueue queue = new MessageQueue(queueName);

        while (true)
        {
            Message message = queue.Receive(TimeSpan.FromSeconds(1));

            if (message != null)
            {
                Console.WriteLine($"Received message: {message.Body}");
            }
            else
            {
                Console.WriteLine("No messages received.");
            }
        }
    }
}

In this example, the MessageQueue class is used to connect to a message queue with the name MyQueue located on the local machine. The while loop continuously polls the queue every 1 second using the Receive method, which blocks until a message is available or until the timeout is reached. If a message is received, its body is printed to the console. If no message is received within the timeout period, the loop continues and tries again.

JavaScript Implementation

function pollForMessages() {
  setInterval(() => {
    fetch('/api/messages')
      .then(response => {
        if (!response.ok) {
          throw new Error('Network response was not ok');
        }
        return response.json();
      })
      .then(data => {
        if (data.length > 0) {
          console.log('New messages received:', data);
        } else {
          console.log('No new messages.');
        }
      })
      .catch(error => {
        console.error('Error polling for messages:', error);
      });
  }, 5000); // Poll every 5 seconds
}

pollForMessages();

In this example, the setInterval function is used to poll the server every 5 seconds. The fetch function is used to make an HTTP GET request to the /api/messages endpoint, which returns an array of messages in JSON format. If there are new messages, they are logged to the console. If there are no new messages, a message is logged indicating this. If there is an error while polling for messages, the error is logged to the console.

Tags:
30 Mar 2023
0