What is long and short polling in backend system?

In modern backend systems, handling long-running processes efficiently is key to maintaining seamless user experiences. Polling is a technique where the client periodically checks the server for updates or the status of a task. Polling can be broadly categorized into two types: short polling and long polling, each serving distinct purposes. This blog will explore these concepts, their use cases, pros, cons, and implementations.

What is Short Polling?

Short polling is a frequent and straightforward mechanism to check the status of a process. The client periodically sends a request to the server to ask, "Is the task complete?" The server responds with the current status, which may often be incomplete. This cycle continues until the task finishes.

How It Works

1. A client sends a request to start a long-running task.

2. The server immediately returns a unique job ID without processing the task.

3. The client periodically polls the server using the job ID to check the task's status.

4. The server responds with the progress or final result.

Short Polling Example

Server Code (Node.js with Express):

const express = require('express');
const app = express();

let jobs = {}; // Store job progress

app.use(express.json());

// Submit a job
app.post('/submit', (req, res) => {
    const jobId = Date.now().toString(); // Simple unique ID
    jobs[jobId] = 0; // Initialize job progress to 0%
    simulateJobProgress(jobId);
    res.json({ jobId });
});

// Check job status
app.get('/status', (req, res) => {
    const { jobId } = req.query;
    if (jobs[jobId] !== undefined) {
        res.json({ progress: jobs[jobId] });
    } else {
        res.status(404).json({ error: 'Job not found' });
    }
});

// Simulate job progress
function simulateJobProgress(jobId) {
    let progress = 0;
    const interval = setInterval(() => {
        progress += 10;
        jobs[jobId] = progress;
        if (progress >= 100) {
            clearInterval(interval);
        }
    }, 3000); // Update progress every 3 seconds
}

app.listen(3000, () => console.log('Server running on port 3000'));

Client Code (Polling Logic):

async function pollStatus(jobId) {
    while (true) {
        const response = await fetch(`http://localhost:3000/status?jobId=${jobId}`);
        const data = await response.json();
        console.log(`Job Progress: ${data.progress}%`);
        if (data.progress === 100) {
            console.log('Job Complete!');
            break;
        }
        await new Promise(res => setTimeout(res, 5000)); // Wait 5 seconds before next poll
    }
}

// Example usage
fetch('http://localhost:3000/submit', { method: 'POST' })
    .then(res => res.json())
    .then(data => pollStatus(data.jobId));

Explanation of the short polling Code

1. Server Code:

• The server defines two endpoints:
  • /submit (POST): This endpoint creates a job by assigning it a unique jobId. The job's progress starts at 0%, and a helper function (simulateJobProgress) updates its progress in increments of 10% every 3 seconds. The server immediately responds to the client with the jobId.
  • /status (GET): The client periodically sends this request with a jobId to check the job's progress. The server retrieves the progress associated with the jobId and returns it to the client.
• Job Simulation: The simulateJobProgress function uses a timer to increment the job's progress until it reaches 100%. This simulates a long-running background process.

2. Client Code:

• The client first submits a job by calling the /submit endpoint and retrieves the jobId.
• It then repeatedly sends requests to the /status endpoint every 5 seconds using a loop. Each request checks the job's progress until it reaches 100%. Once the job is complete, the loop ends.

What is Long Polling?

Long polling aims to reduce the chattiness of short polling by keeping the client’s connection open until the server has a response ready. Unlike short polling, the server delays its response until the requested data or event becomes available.

Long Polling Example

Server Code (Node.js with Express)

const express = require('express');
const app = express();

let jobs = {};

app.use(express.json());

// Submit a job
app.post('/submit', (req, res) => {
    const jobId = Date.now().toString();
    jobs[jobId] = 0; // Initialize job progress
    simulateJobProgress(jobId);
    res.json({ jobId });
});

// Long poll for job status
app.get('/status', async (req, res) => {
    const { jobId } = req.query;

    // Wait until job completes or timeout occurs
    const waitForCompletion = () => new Promise((resolve) => {
        const interval = setInterval(() => {
            if (jobs[jobId] === 100) {
                clearInterval(interval);
                resolve({ progress: 100 });
            }
        }, 1000); // Check every second
        setTimeout(() => {
            clearInterval(interval);
            resolve({ progress: jobs[jobId] || 0 });
        }, 10000); // Timeout after 10 seconds
    });

    const status = await waitForCompletion();
    res.json(status);
});

// Simulate job progress
function simulateJobProgress(jobId) {
    let progress = 0;
    const interval = setInterval(() => {
        progress += 10;
        jobs[jobId] = progress;
        if (progress >= 100) {
            clearInterval(interval);
        }
    }, 3000); // Update progress every 3 seconds
}

app.listen(3000, () => console.log('Server running on port 3000'));

Client Code (Long Polling Logic):

async function longPollStatus(jobId) {
    while (true) {
        const response = await fetch(`http://localhost:3000/status?jobId=${jobId}`);
        const data = await response.json();
        console.log(`Job Progress: ${data.progress}%`);
        if (data.progress === 100) {
            console.log('Job Complete!');
            break;
        }
    }
}

// Example usage
fetch('http://localhost:3000/submit', { method: 'POST' })
    .then(res => res.json())
    .then(data => longPollStatus(data.jobId));

long polling code Explanation

1. Server Code:

• Similar to short polling, the server has two endpoints:
  • /submit (POST): This works the same way as in short polling. It creates a job with a jobId, initializes its progress to 0%, and simulates the progress using the simulateJobProgress function.
  • /status (GET): In long polling, when the client requests the job's status, the server does not respond immediately. Instead, it waits until:
    • The job's progress reaches 100%.
    • Or a timeout (10 seconds) occurs if the job is not yet complete.
  • This is achieved using a helper function (waitForCompletion) that periodically checks the job's status and resolves the request only when the job is complete or the timeout expires.

2. Client Code:

• The client submits a job to the /submit endpoint to get a jobId.
• It sends a request to the /status endpoint and waits for the server to respond. Unlike short polling, the client does not loop or repeatedly send requests. The connection remains open until the server provides the status. If the job is not complete, the client sends a new request after the timeout.

Comparison: Short Polling vs. Long Polling

Conclusion

Both short and long polling have their unique advantages and tradeoffs. For simpler use cases or where network congestion isn’t a concern, short polling suffices. However, for resource-intensive applications, long polling is a better choice, offering efficiency and scalability. By understanding the nuances and implementing these strategies effectively, developers can create backend systems that are both robust and responsive.