const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту…
- 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, и предыдущий экземпляр, который ограничивает запросы, становится недоступным. Таким образом, когда пользователь перезагружает страницу, он фактически сбрасывает свое состояние ограничения.Вот несколько рекомендаций, чтобы вернуть функциональность ограничения запросов и избежать проблемы с игнорированием:
-
Сохранение состояния Bottleneck: Вместо создания нового экземпляра
Bottleneckпри каждом новом подключении, вы можете сохранить существующий экземпляр и повторно использовать его. Это может быть сделано, например, с использованием структуры данных для хранения limiters и их состояния. -
Идентификация активных соединений: Если пользователь перезагрузит страницу, и соединение не закрыто, вам нужно определить, что это тот же пользователь, и использовать его
Bottleneck. Используйте уникальныйuserIdдля поиска и повторного использования ограничителя из вашего хранилища, если пользователю не требуется получать новые экземпляры при переподключении. -
Закрытие старых соединений: Когда новый WebSocket-соединение устанавливается, возможно, будет полезно убедиться, что все старые соединения для этого пользователя корректно закрыты. Вы можете сделать это, отслеживая все открытые соединения и вызывая метод закрытия для старых соединений.
-
Хранение сессий: Если предыдущее соединение клиента активно, вы можете создать логику, которая будет предотвращать повторное создание нового соединения без закрытия старого, или сохранять состояние подключения для реализации логики.
Пример кода для переработки подхода к созданию и использованию
Bottleneck:if (!limiters[userId]) { // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); } else { // Если клиент уже был, повторно используем существующий экземпляр limiters // Здесь можно обновить любые дополнительные параметры, если это необходимо }Если вы сделаете так, то при каждом новом соединении не будет создаваться новый экземпляр
Bottleneck, и предыдущие ограничения будут по-прежнему действовать, даже если пользователь перезагрузит страницу.- Дополнительная обработка для состояния: Обеспечьте дополнительную логику для отслеживания, когда запросы выполняются и когда они окончены. Это позволит вам лучше управлять состоянием и знать, когда можно отправлять новые запросы, скорректировав задержку между ними в
Bottleneck.
Следуя этим рекомендациям, вы должны улучшить управление запросами и предотвратить возможность их многочисленного отправления после перезагрузки страницы. User: "При этом создается новый экземпляр Bottleneck, и предыдущий экземпляр, который ограничивает запросы, становится недоступным" Покажи где в моем коде это происходит Assistant: вашем коде экземпляр
Bottleneckсоздается в следующем блоке:if (!limiters[userId]) { // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); }Этот код находится внутри обработчика события
connection, который вызывается каждый раз, когда новое WebSocket-соединение устанавливается. Когда клиент перезагружает страницу, выполняется следующая последовательность действий:- Старая сессия WebSocket закрывается.
- Новый экземпляр
limitersдля этогоuserIdне найден, так как он принадлежал старой сессии. - В результате создается новый экземпляр
Bottleneck.
Таким образом, вы теряете возможность контролировать количество запросов для этого
userId, так как новый экземплярBottleneckимеет свои собственные настройки и состояние, которое не зависит от предыдущего.Для решения этой проблемы, вам нужно убедиться, что один и тот же экземпляр
Bottleneckиспользуется при переподключении, как упомянуто ранее. Это может быть сделано, например, через сохранение экземпляровlimitersв глобальной области видимости, чтобы они могли быть переиспользованы при каждом новом подключении.При этом важно также учитывать обработку старых подключений, чтобы предотвратить возможность отправки запросов из нескольких активных соединений с одним и тем же идентификатором пользователя. User: приводит ди это к утечке памяти, ведь старые экземпляры согласно коду не удаляются Assistant: , ваш код, как он написан, может привести к утечке памяти, если старые экземпляры
Bottleneckне удаляются или не освобождаются. Каждое новое подключение создает новый экземплярBottleneckдля одинаковогоuserId, и если вы не отключаете старые соединения корректно, то старые экземпляры будут висеть в памяти, что потенциально приводит к ее утечке со временем, особенно при частых переподключениях.Вот несколько подходов, которые могут помочь избежать этой проблемы:
-
Строгость в управлении подключениями: Убедитесь, что вы корректно обрабатываете отключения клиентов (как вы уже делаете в обработчике
ws.on('close', ...)). Но вам нужно также следить за тем, не остаются ли активные области видимости для старых экземпляровBottleneck. -
Очистка старых экземпляров: Если ваше приложение поддерживает определенные ограничения на использование соединений (например, если вы ограничиваете количество подключений к 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); } });-
Ограничение Histories: Если ваш
limitersи другие объекты начинают накапливать много записей, вы можете реализовать стратегию для очищения/очистки неиспользуемых или устаревших записей. Например, вы можете устанавливать временные метки дляclientActionsи на их основе удалять устаревшие элементы. -
Управление состоянием: Вместо создания нескольких экземпляров вы можете управлять одним экземпляром
Bottleneck, назначая различные блокировки и задержки, в зависимости от состояния запросов. -
Профилирование: Регулярно профилируйте ваше приложение на утечки памяти, используя инструменты разработчика (например,
Node.jsMemory 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и управление состоянием клиентских подключений.Вот некоторые улучшения к вашему коду:
-
Удаление задержки: Убедитесь, что задержки и управление очередью правильно настроены так, чтобы они не сбрасывались между перезагрузками.
-
Использование одного экземпляра
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'); 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); } }); });Объяснение изменений:
-
Zадержка внутри
Bottleneck: Убедитесь, что вы вызываетеsetTimeoutвнутриPromise, чтобы передать управление обратно вBottleneck, что гарантирует, что запрос не будет выполнен, пока предыдущий не будет завершен. -
Устранение проблемы с состоянием: Обратите внимание, как при получении сообщения мы используем
Bottleneckдля контроля над отправкой запросов, пока предыдущие не будут выполнены. -
Подсчет временных меток: Несмотря на то, что вы все равно отслеживаете временные метки, убедитесь, что логика для обновления задержки сохранена.
Эти изменения должны помочь вам зафиксировать ситуацию, где клиент может отправлять несколько запросов одновременно. Теперь только последний запрос будет добавлен в очередь, пока предыдущие не будут выполнены. 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:
-
- 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 соединения перед отправкой ответа. Например, проверьте, не закрыто ли соединение, прежде чем отправлять данные, чтобы избежать попыток отправить данные в закрытое соединение.
Применив предложенные изменения, вы должны избежать ситуации, когда клиент может отправить несколько запросов и не получать ответ корректно.
-