Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту…

  1. User

    User: const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Домен const allowedOrigin = 'https://gpt.loc';

    wss.on('connection', (ws, req) => { //console.log('Новое соединение:', req.socket.remoteAddress); const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); // Получаем UUID из URL const userIP = req.socket.remoteAddress; //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString()); const userHeaders = req.headers;

    // Проверяем Origin
    if (!checkOrigin(userHeaders.origin, ws)) {
        return; // Если отклонено, выходим из обработчика
    }
    
    // Если количество подключений с этого IP превышает лимит, закрываем соединение
    if (ipConnectionCount[userIP] >= MAX_CONNECTIONS_PER_IP) {
        console.log(`Превышен лимит подключений для IP: ${userIP}, отказано в соединении.`);
    	stats.totalIPBlocks++;
        ws.close(); // Закрываем соединение
        return; // Выходим из обработчика 
    }
    
    // Увеличиваем счетчик подключений
    currentConnectedClients++;
    
    // Обновляем максимальное количество клиентов, если текущее количество больше 
    if (currentConnectedClients > stats.maxConnectedClients) {
        stats.maxConnectedClients = currentConnectedClients;
        console.log(`Максимальное количество подключенных клиентов: ${stats.maxConnectedClients}`);
    }
    
    // Увеличиваем счетчик подключений для этого IP
    ipConnectionCount[userIP] = (ipConnectionCount[userIP] || 0) + 1;
    
    // Увеличиваем общий счетчик подключений
    stats.totalConnections++;
    
    console.log('Client connected with user ID:', userId, ' and IP:', userIP);
    
    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий 
    		connected: true, // Статус подключения
    		lastRequestTime: new Date(), // Добавляем время последнего запроса 
    		ws: ws,
    		delay: 1000,                // Задержка по умолчанию, например, 1000 мс
    		responseTimes: []			// массив для хранения временных меток (начало и конец 3-х ответов)
        };
    }
    else {
        // обновляем ws при переподключении
        clientActions[userId].connected = true; 
        clientActions[userId].ws = ws;
        // вы можете обновить другие параметры здесь
    }
    
    if (!limiters[userId]) { 
      // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
    	limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
    	    highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    }
    
    ws.on('message', (message) => {
    	// Обновляем время последнего запроса
    	clientActions[userId].lastRequestTime = new Date(); 
    	
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.messages;
    		let model = message.model;
    		let rewrite = message.rewrite;
    		
    		// Выполняем валидацию сообщений
    		messages = validateMessages(messages);
    		
    		// Проверяем, остались ли сообщения после валидации
    		if (messages.length === 0) {
    			const response = { code: 2, message: "Нет валидных сообщений для обработки." };
    			sendMessage(ws, response);
    			return;
    		}
    		
    		// Урезаем последнее сообщение до 2000 символов, если оно от клиента
    		if (messages[messages.length - 1].role === 'user') {
    			messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
    		}
    		
    		// Увеличиваем общий счетчик запросов 
            stats.totalRequests++;
    		
    		// Задержка перед отправкой запроса
    		const responseTimes = clientActions[userId].responseTimes; // Получаем массив responseTimes
    
    		// Проверяем, прошло ли больше 15 секунд с момента окончания последнего ответа
    		if (responseTimes.length === 3) {
    			const lastEndTime = responseTimes[responseTimes.length - 1].end;
    			const currentTime = new Date();
    
    			// Вычисляем разницу во времени
    			const timeSinceLastEnd = currentTime - lastEndTime; // Время в миллисекундах
    
    			if (timeSinceLastEnd > 20000) { // Если прошло больше 15 секунд
    				clientActions[userId].delay = 1000; // Устанавливаем delay на 1 мс
    			}
    		}
    		console.log('Задержка - ', clientActions[userId].delay)
    		// Используем Bottleneck для управления количеством запросов
    		limiters[userId].schedule(() => {
    			// Отправка запроса на сервер чата с задержкой
    			setTimeout(() => {
    				call(messages, model, ws, userId, rewrite);
    			}, clientActions[userId].delay);
    		}).catch(error => {
    			stats.totalIPBlocks++;
    			//console.error('Rate limit exceeded, message ignored:', error);
    			//const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			// Отправка ответа клиенту
    			//sendMessage(ws, response);
    		});
    		
    	} catch (error) {
    			stats.totalWsMessErrors++;
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			// Отправка ответа клиенту
    			sendMessage(ws, response);
    	}
    	
    });
    
    ws.on('close', () => {
    	try {
    		// Проверка, существует ли userId в clientActions
    		if (clientActions[userId]) {
    			clientActions[userId].connected = false; // Обновление статуса подключения
    			
    		}
    		
    		console.log('Client ',userId, ' disconnected'); 
    		// Уменьшаем счетчик подключений для этого IP		
    		if (ipConnectionCount[userIP] !== undefined) {
    			ipConnectionCount[userIP]--;
    			
    			// Если счетчик равен 0, удаляем запись из объекта
    			if (ipConnectionCount[userIP] === 0) {
    				delete ipConnectionCount[userIP];
    			}
    		}
    		// Уменьшаем счетчик при отключении клиента
    		currentConnectedClients = Math.max(currentConnectedClients - 1, 0); 
    	} catch (error) {
    		console.error('Error handling client disconnect:', error);
    	}
    });
    

    });

    Bottleneck контролирует очередь запросов от пользователя, если он отправил запрос и сервер еще генирирует ответ, то второй запрос согласно настройкам игнорируется. Однако это перестает работать, если пользователь перезагрузит страницу, после этого он может отправлять сколько угодно запросов не дожидаясь ответов. userId при этом всегда один и тот же, фронтенд берет его из localstorage. Почему? Assistant: роблема, с которой вы сталкиваетесь, связана с тем, что при перезагрузке страницы WebSocket-соединение обрывается и создается новое. При этом создается новый экземпляр Bottleneck, и предыдущий экземпляр, который ограничивает запросы, становится недоступным. Таким образом, когда пользователь перезагружает страницу, он фактически сбрасывает свое состояние ограничения.

    Вот несколько рекомендаций, чтобы вернуть функциональность ограничения запросов и избежать проблемы с игнорированием:

    1. Сохранение состояния Bottleneck: Вместо создания нового экземпляра Bottleneck при каждом новом подключении, вы можете сохранить существующий экземпляр и повторно использовать его. Это может быть сделано, например, с использованием структуры данных для хранения limiters и их состояния.

    2. Идентификация активных соединений: Если пользователь перезагрузит страницу, и соединение не закрыто, вам нужно определить, что это тот же пользователь, и использовать его Bottleneck. Используйте уникальный userId для поиска и повторного использования ограничителя из вашего хранилища, если пользователю не требуется получать новые экземпляры при переподключении.

    3. Закрытие старых соединений: Когда новый WebSocket-соединение устанавливается, возможно, будет полезно убедиться, что все старые соединения для этого пользователя корректно закрыты. Вы можете сделать это, отслеживая все открытые соединения и вызывая метод закрытия для старых соединений.

    4. Хранение сессий: Если предыдущее соединение клиента активно, вы можете создать логику, которая будет предотвращать повторное создание нового соединения без закрытия старого, или сохранять состояние подключения для реализации логики.

    Пример кода для переработки подхода к созданию и использованию Bottleneck:

    if (!limiters[userId]) {
      // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
      limiters[userId] = new Bottleneck({
        maxConcurrent: 1, // Максимальное количество одновременных задач
        minTime: 1000, // Минимальное время между запросами в миллисекундах
        highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
      });
    } else {
      // Если клиент уже был, повторно используем существующий экземпляр limiters
      // Здесь можно обновить любые дополнительные параметры, если это необходимо
    }
    

    Если вы сделаете так, то при каждом новом соединении не будет создаваться новый экземпляр Bottleneck, и предыдущие ограничения будут по-прежнему действовать, даже если пользователь перезагрузит страницу.

    1. Дополнительная обработка для состояния: Обеспечьте дополнительную логику для отслеживания, когда запросы выполняются и когда они окончены. Это позволит вам лучше управлять состоянием и знать, когда можно отправлять новые запросы, скорректировав задержку между ними в Bottleneck.

    Следуя этим рекомендациям, вы должны улучшить управление запросами и предотвратить возможность их многочисленного отправления после перезагрузки страницы. User: "При этом создается новый экземпляр Bottleneck, и предыдущий экземпляр, который ограничивает запросы, становится недоступным" Покажи где в моем коде это происходит Assistant: вашем коде экземпляр Bottleneck создается в следующем блоке:

    if (!limiters[userId]) { 
        // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
        limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
            highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    }
    

    Этот код находится внутри обработчика события connection, который вызывается каждый раз, когда новое WebSocket-соединение устанавливается. Когда клиент перезагружает страницу, выполняется следующая последовательность действий:

    1. Старая сессия WebSocket закрывается.
    2. Новый экземпляр limiters для этого userId не найден, так как он принадлежал старой сессии.
    3. В результате создается новый экземпляр Bottleneck.

    Таким образом, вы теряете возможность контролировать количество запросов для этого userId, так как новый экземпляр Bottleneck имеет свои собственные настройки и состояние, которое не зависит от предыдущего.

    Для решения этой проблемы, вам нужно убедиться, что один и тот же экземпляр Bottleneck используется при переподключении, как упомянуто ранее. Это может быть сделано, например, через сохранение экземпляров limiters в глобальной области видимости, чтобы они могли быть переиспользованы при каждом новом подключении.

    При этом важно также учитывать обработку старых подключений, чтобы предотвратить возможность отправки запросов из нескольких активных соединений с одним и тем же идентификатором пользователя. User: приводит ди это к утечке памяти, ведь старые экземпляры согласно коду не удаляются Assistant: , ваш код, как он написан, может привести к утечке памяти, если старые экземпляры Bottleneck не удаляются или не освобождаются. Каждое новое подключение создает новый экземпляр Bottleneck для одинакового userId, и если вы не отключаете старые соединения корректно, то старые экземпляры будут висеть в памяти, что потенциально приводит к ее утечке со временем, особенно при частых переподключениях.

    Вот несколько подходов, которые могут помочь избежать этой проблемы:

    1. Строгость в управлении подключениями: Убедитесь, что вы корректно обрабатываете отключения клиентов (как вы уже делаете в обработчике ws.on('close', ...)). Но вам нужно также следить за тем, не остаются ли активные области видимости для старых экземпляров Bottleneck.

    2. Очистка старых экземпляров: Если ваше приложение поддерживает определенные ограничения на использование соединений (например, если вы ограничиваете количество подключений к 1 или 2 на пользователя), вы можете удалять экземпляр Bottleneck для userId, когда пользователь отключается, если они больше не нужны. Это можно сделать следующим образом:

    ws.on('close', () => {
        try {
            if (clientActions[userId]) {
                clientActions[userId].connected = false;
                delete limiters[userId]; // Удаляем экземпляр Bottleneck для этого пользователя при отключении
            }
            // Логика для уменьшения счетчиков подключений и т.д...
        } catch (error) {
            console.error('Error handling client disconnect:', error);
        }
    });
    
    1. Ограничение Histories: Если ваш limiters и другие объекты начинают накапливать много записей, вы можете реализовать стратегию для очищения/очистки неиспользуемых или устаревших записей. Например, вы можете устанавливать временные метки для clientActions и на их основе удалять устаревшие элементы.

    2. Управление состоянием: Вместо создания нескольких экземпляров вы можете управлять одним экземпляром Bottleneck, назначая различные блокировки и задержки, в зависимости от состояния запросов.

    3. Профилирование: Регулярно профилируйте ваше приложение на утечки памяти, используя инструменты разработчика (например, Node.js Memory Profiling) для отслеживания объектов, которые не освобождаются должным образом.

    Следуя этим указаниям, вы сможете избежать утечек памяти, сохраняя при этом адекватный контроль над количеством запросов, которые отправляет клиент. User: Управление состоянием: Вместо создания нескольких экземпляров вы можете управлять одним экземпляром Bottleneck, назначая различные блокировки и задержки, в зависимости от состояния запросов.

    покажи как реализовать это в моем коде Assistant: управления одним экземпляром Bottleneck вместо создания нового при каждом подключении, вы можете изменить структуру кода следующим образом. Мы будем хранить один экземпляр Bottleneck для каждого клиента и управлять состоянием задержки и блокировок внутри этого экземпляра.

    Вот пример, как это можно сделать:

    const clientActions = {};
    const limiters = {}; 
    const allowedOrigin = 'https://gpt.loc'; 
    
    wss.on('connection', (ws, req) => {
        const urlParams = new URLSearchParams(req.url.split('?')[1]);
        const userId = urlParams.get('token'); // Получаем UUID из URL
        const userIP = req.socket.remoteAddress;
    
        if (!checkOrigin(req.headers.origin, ws)) {
            return;
        }
    
        // Проверка лимита подключений по IP
        if (ipConnectionCount[userIP] >= MAX_CONNECTIONS_PER_IP) {
            console.log(`Превышен лимит подключений для IP: ${userIP}, отказано в соединении.`);
            stats.totalIPBlocks++;
            ws.close();
            return;
        }
    
        currentConnectedClients++;
    
        // Обновляем максимальное количество клиентов
        if (currentConnectedClients > stats.maxConnectedClients) {
            stats.maxConnectedClients = currentConnectedClients;
            console.log(`Максимальное количество подключенных клиентов: ${stats.maxConnectedClients}`);
        }
    
        // Увеличиваем счетчик подключений для этого IP
        ipConnectionCount[userIP] = (ipConnectionCount[userIP] || 0) + 1;
        stats.totalConnections++;
        
        console.log('Client connected with user ID:', userId, ' and IP:', userIP);
        
        // Инициализация состояния клиента
        if (!clientActions[userId]) {
            clientActions[userId] = {
                actions: [],
                connected: true,
                lastRequestTime: new Date(),
                ws: ws,
                responseTimes: []
            };
    
            // Создаем экземпляр Bottleneck для клиента только один раз
            limiters[userId] = new Bottleneck({
                maxConcurrent: 1,
                minTime: 1000,
                highWater: 0
            });
        } else {
            // Обновляем ws при переподключении
            clientActions[userId].connected = true; 
            clientActions[userId].ws = ws; 
        }
        
        ws.on('message', (message) => {
            clientActions[userId].lastRequestTime = new Date();
    
            if (Buffer.isBuffer(message))
                message = message.toString(); 
    
            try {
                message = JSON.parse(message); 
                let messages = validateMessages(message.messages);
                let model = message.model;
                let rewrite = message.rewrite;
    
                if (messages.length === 0) {
                    sendMessage(ws, { code: 2, message: "Нет валидных сообщений для обработки." });
                    return;
                }
    
                // Ограничиваем длину последнего сообщения
                if (messages[messages.length - 1].role === 'user') {
                    messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
                }
    
                stats.totalRequests++;
    
                const responseTimes = clientActions[userId].responseTimes;
    
                if (responseTimes.length === 3) {
                    const lastEndTime = responseTimes[responseTimes.length - 1].end;
                    const currentTime = new Date();
                    const timeSinceLastEnd = currentTime - lastEndTime;
    
                    if (timeSinceLastEnd > 20000) {
                        // Сброс задержки, если прошло больше времени
                        clientActions[userId].delay = 1000; 
                    }
                }
    
                console.log('Задержка - ', clientActions[userId].delay);
                
                // Используем один экземпляр Bottleneck для управления запросами
                limiters[userId].schedule(() => {
                    setTimeout(() => {
                        call(messages, model, ws, userId, rewrite);
                    }, clientActions[userId].delay);
                }).catch(error => {
                    stats.totalIPBlocks++;
                    // Обработка превышения лимита запросов
                });
    
            } catch (error) {
                stats.totalWsMessErrors++;
                console.error('Error parsing JSON:', error);
                sendMessage(ws, { code: 2, message: "Произошла ошибка. Попробуйте еще раз." });
            }
        });
    
        ws.on('close', () => {
            try {
                    // Обновление статуса подключения
                if (clientActions[userId]) {
                    clientActions[userId].connected = false;
                    // Здесь можно очистить состояние, если это необходимо
                }
                
                console.log('Client ',userId, ' disconnected'); 
                ipConnectionCount[userIP] = Math.max((ipConnectionCount[userIP] || 0) - 1, 0);
    
                // Если счетчик равен 0, удаляем запись из объекта
                if (ipConnectionCount[userIP] === 0) {
                    delete ipConnectionCount[userIP];
                }
                currentConnectedClients = Math.max(currentConnectedClients - 1, 0); 
            } catch (error) {
                console.error('Error handling client disconnect:', error);
            }
        });
    });
    

    В этом измененном коде мы обеспечиваем создание одного экземпляра Bottleneck для каждого userId, который сохраняется в limiters. Вместо создания нового экземпляра при каждом новом подключении, мы просто используем существующий, если он уже был создан, тем самым поддерживая состояние между подключениями.

    Пользователь также будет продолжать использовать одну и ту же логику для задержки и блокировок, что позволяет избежать утечек памяти и контролировать количество запросов более эффективно. User: Вот что получилось. И этот код не работает. После перезагрузки страницы клиент может отправить второй запрос, пока обрабатывается первый и только последующие ставятся в очередь.

    wss.on('connection', (ws, req) => { //console.log('Новое соединение:', req.socket.remoteAddress); const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); // Получаем UUID из URL const userIP = req.socket.remoteAddress; //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString()); const userHeaders = req.headers;

    // Проверяем Origin
    if (!checkOrigin(userHeaders.origin, ws)) {
        return; // Если отклонено, выходим из обработчика
    }
    
    // Если количество подключений с этого IP превышает лимит, закрываем соединение
    if (ipConnectionCount[userIP] >= MAX_CONNECTIONS_PER_IP) {
        console.log(`Превышен лимит подключений для IP: ${userIP}, отказано в соединении.`);
    	stats.totalIPBlocks++;
        ws.close(); // Закрываем соединение
        return; // Выходим из обработчика 
    }
    
    // Увеличиваем счетчик подключений
    currentConnectedClients++;
    
    // Обновляем максимальное количество клиентов, если текущее количество больше 
    if (currentConnectedClients > stats.maxConnectedClients) {
        stats.maxConnectedClients = currentConnectedClients;
        console.log(`Максимальное количество подключенных клиентов: ${stats.maxConnectedClients}`);
    }
    
    // Увеличиваем счетчик подключений для этого IP
    ipConnectionCount[userIP] = (ipConnectionCount[userIP] || 0) + 1;
    
    // Увеличиваем общий счетчик подключений
    stats.totalConnections++;
    
    console.log('Client connected with user ID:', userId, ' and IP:', userIP);
    
    // Инициализируем состояние клиента, если его еще нет
    /*if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий 
    		connected: true, // Статус подключения
    		lastRequestTime: new Date(), // Добавляем время последнего запроса 
    		ws: ws,
    		delay: 1000,                // Задержка по умолчанию, например, 1000 мс
    		responseTimes: []			// массив для хранения временных меток (начало и конец 3-х ответов)
        };
    }
    else {
        // обновляем ws при переподключении
        clientActions[userId].connected = true; 
        clientActions[userId].ws = ws;
        // вы можете обновить другие параметры здесь
    }
    
    if (!limiters[userId]) { console.log('Новый Bottleneck, ', limiters);
      // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
    	limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
    	    highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    }*/
    
    if (!clientActions[userId]) {
        clientActions[userId] = {
    		actions: [], // Массив для хранения действий 
    		connected: true, // Статус подключения
    		lastRequestTime: new Date(), // Добавляем время последнего запроса 
    		ws: ws,
    		delay: 1000,                // Задержка по умолчанию, например, 1000 мс
    		responseTimes: []			// массив для хранения временных меток (начало и конец 3-х ответов)
        };
    
        // Создаем экземпляр Bottleneck для клиента только один раз
        limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
    	    highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    } else {
        // Обновляем ws при переподключении
        clientActions[userId].connected = true; 
        clientActions[userId].ws = ws; 
    }
    
    ws.on('message', (message) => {
    	// Обновляем время последнего запроса
    	clientActions[userId].lastRequestTime = new Date(); 
    	
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.messages;
    		let model = message.model;
    		let rewrite = message.rewrite;
    		
    		// Выполняем валидацию сообщений
    		messages = validateMessages(messages);
    		
    		// Проверяем, остались ли сообщения после валидации
    		if (messages.length === 0) {
    			const response = { code: 2, message: "Нет валидных сообщений для обработки." };
    			sendMessage(ws, response);
    			return;
    		}
    		
    		// Урезаем последнее сообщение до 2000 символов, если оно от клиента
    		if (messages[messages.length - 1].role === 'user') {
    			messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
    		}
    		
    		// Увеличиваем общий счетчик запросов 
            stats.totalRequests++;
    		
    		// Задержка перед отправкой запроса
    		const responseTimes = clientActions[userId].responseTimes; // Получаем массив responseTimes
    
    		// Проверяем, прошло ли больше 15 секунд с момента окончания последнего ответа
    		if (responseTimes.length === 3) {
    			const lastEndTime = responseTimes[responseTimes.length - 1].end;
    			const currentTime = new Date();
    
    			// Вычисляем разницу во времени
    			const timeSinceLastEnd = currentTime - lastEndTime; // Время в миллисекундах
    
    			if (timeSinceLastEnd > 20000) { // Если прошло больше 15 секунд
    				clientActions[userId].delay = 1000; // Устанавливаем delay на 1 мс
    			}
    		}
    		console.log('Задержка - ', clientActions[userId].delay)
    		// Используем Bottleneck для управления количеством запросов
    		limiters[userId].schedule(() => {
    			// Отправка запроса на сервер чата с задержкой
    			setTimeout(() => {
    				call(messages, model, ws, userId, rewrite);
    			}, clientActions[userId].delay);
    		}).catch(error => {
    			stats.totalIPBlocks++;
    			//console.error('Rate limit exceeded, message ignored:', error);
    			//const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			// Отправка ответа клиенту
    			//sendMessage(ws, response);
    		});
    		
    	} catch (error) {
    			stats.totalWsMessErrors++;
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			// Отправка ответа клиенту
    			sendMessage(ws, response);
    	}
    	
    });
    
    ws.on('close', () => {
    	try {
    		// Проверка, существует ли userId в clientActions
    		if (clientActions[userId]) {
    			clientActions[userId].connected = false; // Обновление статуса подключения
    			//delete clientActions[userId]; // Удаление состояния клиента
    		}
    		// Проверка, существует ли userId в limiters
    		//if (limiters[userId]) {
    		//	delete limiters[userId]; // Удаление ограничителя для данного клиента
    		//}
    		console.log('Client ',userId, ' disconnected'); 
    		
    		// Уменьшаем счетчик подключений для этого IP		
    		if (ipConnectionCount[userIP] !== undefined) {
    			ipConnectionCount[userIP]--;
    			
    			// Если счетчик равен 0, удаляем запись из объекта
    			if (ipConnectionCount[userIP] === 0) {
    				delete ipConnectionCount[userIP];
    			}
    		}
    		// Уменьшаем счетчик при отключении клиента
    		currentConnectedClients = Math.max(currentConnectedClients - 1, 0); 
    	} catch (error) {
    		console.error('Error handling client disconnect:', error);
    	}
    });
    

    }); Assistant: решить проблему с тем, что после перезагрузки страницы клиент может отправить второй запрос до завершения первого, необходимо переосмыслить, как вы используете экземпляры Bottleneck и управление состоянием клиентских подключений.

    Вот некоторые улучшения к вашему коду:

    1. Удаление задержки: Убедитесь, что задержки и управление очередью правильно настроены так, чтобы они не сбрасывались между перезагрузками.

    2. Использование одного экземпляра Bottleneck: Убедитесь, что экземпляр Bottleneck действительно правильно используется и не пересоздается.

    3. Обработка закрытия соединений: Когда клиент отключается, вам нужно правильно управлять состоянием. Если у вас есть возможность, то проверяйте, был ли отправлен ответ на запрос перед тем, как клиент отключается.

    Вот ваш код, обновленный с учетом этих соображений:

    const clientActions = {};
    const limiters = {};
    const allowedOrigin = 'https://gpt.loc'; 
    
    wss.on('connection', (ws, req) => {
        const urlParams = new URLSearchParams(req.url.split('?')[1]);
        const userId = urlParams.get('token');
        const userIP = req.socket.remoteAddress;
    
        if (!checkOrigin(req.headers.origin, ws)) {
            return; 
        }
    
        if (ipConnectionCount[userIP] >= MAX_CONNECTIONS_PER_IP) {
            console.log(`Превышен лимит подключений для IP: ${userIP}, отказано в соединении.`);
            stats.totalIPBlocks++;
            ws.close();
            return; 
        }
        
        currentConnectedClients++;
        
        if (currentConnectedClients > stats.maxConnectedClients) {
            stats.maxConnectedClients = currentConnectedClients;
            console.log(`Максимальное количество подключенных клиентов: ${stats.maxConnectedClients}`);
        }
    
        ipConnectionCount[userIP] = (ipConnectionCount[userIP] || 0) + 1;
        stats.totalConnections++;
        
        console.log('Client connected with user ID:', userId, ' and IP:', userIP);
        
        // Инициализируем состояние клиента, если его еще нет
        if (!clientActions[userId]) {
            clientActions[userId] = {
                actions: [],
                connected: true,
                lastRequestTime: new Date(),
                ws: ws,
                delay: 1000,
                responseTimes: []
            };
            
            // Создаем экземпляр Bottleneck для каждого клиента только один раз
            limiters[userId] = new Bottleneck({
                maxConcurrent: 1,
                minTime: 1000,
                highWater: 0
            });
        } else {
            // Обновляем ws при переподключении
            clientActions[userId].connected = true;
            clientActions[userId].ws = ws;
        }
        
        ws.on('message', (message) => {
            clientActions[userId].lastRequestTime = new Date();
            
            if (Buffer.isBuffer(message)) {
                message = message.toString();
            }
            
            try {
                message = JSON.parse(message);
                let messages = validateMessages(message.messages);
                let model = message.model;
                let rewrite = message.rewrite;
                
                if (messages.length === 0) {
                    const response = { code: 2, message: "Нет валидных сообщений для обработки." };
                    sendMessage(ws, response);
                    return;
                }
                
                // Ограничиваем длину последнего сообщения
                if (messages[messages.length - 1].role === 'user') {
                    messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
                }
                
                stats.totalRequests++;
                
                // Проверяем, прошло ли больше 15 секунд с момента окончания последнего ответа
                const responseTimes = clientActions[userId].responseTimes; 
                if (responseTimes.length === 3) {
                    const lastEndTime = responseTimes[responseTimes.length - 1].end;
                    const currentTime = new Date();
                    const timeSinceLastEnd = currentTime - lastEndTime; 
    
                    if (timeSinceLastEnd > 20000) { 
                        clientActions[userId].delay = 1000; 
                    }
                }
                console.log('Задержка - ', clientActions[userId].delay)
                
                // Используем Bottleneck для управления количеством запросов
                limiters[userId].schedule(() => {
                    // Отправка запроса на сервер чата с задержкой
                    return new Promise((resolve) => {
                        setTimeout(() => {
                            call(messages, model, ws, userId, rewrite);
                            resolve(); // Уведомляем о завершении выполнения
                        }, clientActions[userId].delay);
                    });
                }).catch(error => {
                    stats.totalIPBlocks++;
                    // Здесь обрабатываем превышение лимита запросов, если это нужно
                });
            } catch (error) {
                stats.totalWsMessErrors++;
                console.error('Error parsing JSON:', error);
                const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                sendMessage(ws, response);
            }  
        });
    
        ws.on('close', () => {
            try {
                if (clientActions[userId]) {
                    clientActions[userId].connected = false; 
                }
                
                console.log('Client ', userId, ' disconnected'); 
                if (ipConnectionCount[userIP] !== undefined) {
                    ipConnectionCount[userIP]--;
                    if (ipConnectionCount[userIP] === 0) {
                        delete ipConnectionCount[userIP];
                    }
                }
                currentConnectedClients = Math.max(currentConnectedClients - 1, 0); 
            } catch (error) {
                console.error('Error handling client disconnect:', error);
            }
        });
    });
    

    Объяснение изменений:

    1. Zадержка внутри Bottleneck: Убедитесь, что вы вызываете setTimeout внутри Promise, чтобы передать управление обратно в Bottleneck, что гарантирует, что запрос не будет выполнен, пока предыдущий не будет завершен.

    2. Устранение проблемы с состоянием: Обратите внимание, как при получении сообщения мы используем Bottleneck для контроля над отправкой запросов, пока предыдущие не будут выполнены.

    3. Подсчет временных меток: Несмотря на то, что вы все равно отслеживаете временные метки, убедитесь, что логика для обновления задержки сохранена.

    Эти изменения должны помочь вам зафиксировать ситуацию, где клиент может отправлять несколько запросов одновременно. Теперь только последний запрос будет добавлен в очередь, пока предыдущие не будут выполнены. User: Не помогает клиент отправляет запрос, обновляет страницу и отправляет второй. В итоге приложение пытается отправить ответ в закрытое соединение, а потом отправляет ответ в открытое. Т.е. он все равно принимает два запроса подряд, хотя после перезагрузки и второго запроса должен был сработать cath здесь limiters[userId].schedule(() => { // Отправка запроса на сервер чата с задержкой return new Promise((resolve) => { setTimeout(() => { call(messages, model, ws, userId, rewrite); resolve(); // Уведомляем о завершении выполнения }, clientActions[userId].delay); }); }).catch(error => { stats.totalIPBlocks++; // Здесь обрабатываем превышение лимита запросов, если это нужно }); Assistant:

  2. Assistant

    Чтобы решить проблему с тем, что клиент отправляет несколько запросов подряд после обновления страницы, здесь нужно реализовать дополнительную логику, которая предотвратит возможность отправки данных до того, как предыдущий ответ завершится.

    Вот несколько шагов, которые можно предпринять, чтобы обеспечить правильную работу вашего кода:

    1. Использовать флаг, чтобы отслеживать, отправляется ли запрос в данный момент

    Создайте переменную-флаг внутри clientActions[userId], чтобы определить, находится ли запрос в процессе обработки. Это позволит игнорировать последующие запросы, пока предыдущий обрабатывается.

    2. Изменить код, чтобы правильно обрабатывать состояние

    Вот пример, как это можно сделать:

    wss.on('connection', (ws, req) => {
        const urlParams = new URLSearchParams(req.url.split('?')[1]);
        const userId = urlParams.get('token');
        const userIP = req.socket.remoteAddress;
    
        // Проверим origin и лимиты подключения, аналогично вашему коду...
    
        console.log('Client connected with user ID:', userId, ' and IP:', userIP);
    
        if (!clientActions[userId]) {
            clientActions[userId] = {
                actions: [],
                connected: true,
                lastRequestTime: new Date(),
                ws: ws,
                delay: 1000,
                isProcessing: false, // Флаг, чтобы отслеживать, обрабатывается ли запрос
                responseTimes: []
            };
    
            limiters[userId] = new Bottleneck({
                maxConcurrent: 1,
                minTime: 1000,
                highWater: 0
            });
        } else {
            clientActions[userId].connected = true; 
            clientActions[userId].ws = ws; 
        }
    
        ws.on('message', (message) => {
            // Обновляем время последнего запроса
            clientActions[userId].lastRequestTime = new Date();
    
            if (Buffer.isBuffer(message)) {
                message = message.toString(); 
            }
    
            try {
                message = JSON.parse(message); 
                let messages = validateMessages(message.messages);
                let model = message.model;
                let rewrite = message.rewrite;
    
                if (messages.length === 0) {
                    sendMessage(ws, { code: 2, message: "Нет валидных сообщений для обработки." });
                    return;
                }
    
                // Ограничиваем длину последнего сообщения
                if (messages[messages.length - 1].role === 'user') {
                    messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
                }
    
                stats.totalRequests++;
    
                // Проверяем, если запрос в процессе обработки
                if (clientActions[userId].isProcessing) {
                    console.log("Запрос игнорируется, так как предыдущий всё ещё обрабатывается.");
                    return; // игнорируем новый запрос
                }
    
                clientActions[userId].isProcessing = true; // Устанавливаем флаг на начало обработки
    
                limiters[userId].schedule(() => {
                    return new Promise((resolve) => {
                        setTimeout(() => {
                            call(messages, model, ws, userId, rewrite);
                            clientActions[userId].isProcessing = false; // Сбрасываем флаг после завершения
                            resolve();
                        }, clientActions[userId].delay);
                    });
                }).catch(error => {
                    stats.totalIPBlocks++;
                    console.error('Rate limit exceeded, message ignored:', error);
                    // Обработать превышение лимита
                    // sendMessage(ws, { code: 2, message: "Превышен лимит запросов." });
                });
    
            } catch (error) {
                stats.totalWsMessErrors++;
                console.error('Ошибка разбора JSON:', error);
                sendMessage(ws, { code: 2, message: "Произошла ошибка. Попробуйте еще раз." });
            }
        });
    
        ws.on('close', () => {
            if (clientActions[userId]) {
                clientActions[userId].connected = false; 
                clientActions[userId].isProcessing = false; // Сбрасываем флаг при отключении
            }
            console.log('Client ', userId, ' disconnected');
            // Дополнительная логика для уменьшения счетчиков
        });
    });
    

    Объяснения изменений:

    • Флаг isProcessing: Этот флаг добавлен в clientActions[userId]. Он используется, чтобы определить, обрабатывается ли запрос в данный момент. Если да, новые запросы просто игнорируются.

    • Установка и сброс флага: Флаг устанавливается на true перед началом обработки запроса и возвращается на false, когда запрос завершен.

    Защита от ситуации с закрытым соединением:

    Помимо упомянутого выше улучшения, вы также можете добавить логику, которая будет контролировать состояние WebSocket соединения перед отправкой ответа. Например, проверьте, не закрыто ли соединение, прежде чем отправлять данные, чтобы избежать попыток отправить данные в закрытое соединение.

    Применив предложенные изменения, вы должны избежать ситуации, когда клиент может отправить несколько запросов и не получать ответ корректно.