Long Polling

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

// 대기 중인 클라이언트들
const waitingClients = new Map();
let clientId = 0;

// Long Polling 엔드포인트
app.get('/api/events', (req, res) => {
    const id = ++clientId;
    const timeout = 30000;  // 30초 타임아웃

    console.log(`클라이언트 ${id} 연결`);

    // 타임아웃 설정
    const timer = setTimeout(() => {
        waitingClients.delete(id);
        res.json({ type: 'timeout', message: 'No new data' });
    }, timeout);

    // 클라이언트 등록
    waitingClients.set(id, { res, timer });

    // 연결 종료 시 정리
    req.on('close', () => {
        clearTimeout(timer);
        waitingClients.delete(id);
        console.log(`클라이언트 ${id} 연결 종료`);
    });
});

// 새 메시지 발행 (모든 대기 클라이언트에게 전송)
app.post('/api/broadcast', express.json(), (req, res) => {
    const message = req.body;

    // 모든 대기 클라이언트에게 메시지 전송
    waitingClients.forEach((client, id) => {
        clearTimeout(client.timer);
        client.res.json({
            type: 'message',
            data: message,
            timestamp: Date.now()
        });
    });

    const count = waitingClients.size;
    waitingClients.clear();

    res.json({ success: true, deliveredTo: count });
});

// 서버 상태 확인
app.get('/api/status', (req, res) => {
    res.json({
        waitingClients: waitingClients.size,
        uptime: process.uptime()
    });
});

app.listen(3000, () => {
    console.log('Long Polling 서버 실행 중 (포트 3000)');
});

from flask import Flask, request, jsonify
import time
import threading
from queue import Queue, Empty

app = Flask(__name__)

# 메시지 큐 (실제로는 Redis Pub/Sub 등 사용)
message_queues = {}
lock = threading.Lock()

@app.route('/api/events')
def long_poll():
    """Long Polling 엔드포인트"""
    client_id = request.args.get('client_id', str(time.time()))
    timeout = 30  # 30초 타임아웃

    # 클라이언트별 큐 생성
    with lock:
        if client_id not in message_queues:
            message_queues[client_id] = Queue()

    queue = message_queues[client_id]

    try:
        # 타임아웃까지 메시지 대기
        message = queue.get(timeout=timeout)
        return jsonify({
            'type': 'message',
            'data': message,
            'timestamp': time.time()
        })
    except Empty:
        # 타임아웃 - 빈 응답 반환
        return jsonify({
            'type': 'timeout',
            'message': 'No new data'
        })

@app.route('/api/broadcast', methods=['POST'])
def broadcast():
    """모든 대기 클라이언트에게 메시지 전송"""
    data = request.json

    delivered = 0
    with lock:
        for client_id, queue in message_queues.items():
            queue.put(data)
            delivered += 1

    return jsonify({
        'success': True,
        'delivered_to': delivered
    })

@app.route('/api/status')
def status():
    """서버 상태 확인"""
    with lock:
        return jsonify({
            'active_clients': len(message_queues)
        })

if __name__ == '__main__':
    app.run(port=3000, threaded=True)