привет
- User
User: привет Assistant: Привет! Как я могу помочь тебе сегодня? User: напиши историю сша подробно User: //const { gpt, gptweb } = require("./API/gpt"); //const { dalle } = require("./API/dalle"); const { gpt4o } = require("c:/PrivateAPI/API/gpt4o"); //const { gpt3 } = require("./API/gpt3.5"); //const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("c:/PrivateAPI/API/blackbox"); const { qwen } = require("c:/PrivateAPI/API/qwen"); const { gemini } = require("c:/PrivateAPI/API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv'); const axios = require('axios'); const https = require('https'); const redis = require('redis'); const { promisify } = require('util'); const express = require('express'); const cors = require('cors'); // Импортируем cors
// Обработка необработанных исключений (помогут выявить обшибки, которые не обрабатываются блоками try/catch) process.on('uncaughtException', (err) => { console.error('Необработанное исключение:', err); });
process.on('unhandledRejection', (reason, promise) => { console.error('Необработанное отклонение промиса:', reason); });
// Текущее количество подключенных клиентов let currentConnectedClients = 0;
// Текущее количество обрабатываемых запросов let currentGPT4oProcessingRequests = 0; let currentGeminiProcessingRequests = 0; let currentQwenProcessingRequests = 0;
let currentBlackboxProcessingRequests = 0;// Объект для хранения количества подключений по IP const ipConnectionCount = {};
// Максимальное количество подключений с одного IP const MAX_CONNECTIONS_PER_IP = 100;
// Создание и настройка клиента Redis const redisClient = redis.createClient(); // Подключаем клиента Redis redisClient.connect().catch(err => { console.error('Ошибка подключения к Redis:', err); }); redisClient.on('error', (err) => { console.error('Ошибка Redis:', err); });
// Промис-обертка для команды get const getAsync = async (key) => { if (!redisClient.isOpen) { // Проверяем, открыт ли клиент console.error('Клиент Redis не подключён, невозможно выполнить get:', key); return null; // Возвращаем null, если клиент не подключен } try { return await redisClient.get(key); } catch (error) { console.error('Ошибка при получении из Redis:', error); throw error; //throw error чтобы выше поймали } };
// SSL сертификаты const serverOptions = { key: fs.readFileSync('C:\OSPanel\userdata\config\cert_files\gpt.loc-key.pem'), // Приватный ключ cert: fs.readFileSync('C:\OSPanel\userdata\config\cert_files\gpt.loc.pem'), // Сертификат };
// HTTPS сервер const httpsServer = https.createServer(serverOptions);
// Создайте WebSocket-сервер, используя существующий HTTPS сервер const wss = new WebSocket.Server({ server: httpsServer });
// Запустите сервер httpsServer.listen(3000, () => { console.log('HTTPS сервер и WebSocket сервер запущены на порту 3000'); });
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента 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 clientActions[userId].connected = true; 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; // Обновление статуса подключения 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); } });});
// Таймер для проверки клиентов каждые 10 минут setInterval(() => { const currentTime = new Date(); for (const userId in clientActions) { const client = clientActions[userId]; const lastRequestTime = client.lastRequestTime; // Проверяем, прошло ли более 30 минут с последнего сообщения if (lastRequestTime && (currentTime - lastRequestTime) > 24 * 60 * 60 * 1000) { const response = { code: 3, message: "" }; // Отправляем сообщение клиенту if (client.ws) { sendMessage(client.ws, response); // Закрываем соединение client.ws.close(); } } } console.log('Количество активных клиентов - ', Object.keys(clientActions).length); }, 10 * 60 * 1000); // Проверяем каждые 10 минут
// Обновляем временные метки в responseTimes function updateResponseTimes(userId, startTime, endTime) { try { const responseTime = { start: startTime, end: endTime };
// Получаем массив responseTimes const responseTimes = clientActions[userId].responseTimes; // Добавляем новую временную метку responseTimes.push(responseTime); // Удаляем старые временные метки, если их больше трех if (responseTimes.length > 3) { responseTimes.shift(); // Удаляем старую временную метку } // Обновляем задержку на основе средней продолжительности ответов updateClientDelay(userId); console.log(clientActions[userId].responseTimes); } catch (error) { console.error('Ошибка при обновлении временных меток:', error); // Можно добавить дополнительные действия в случае ошибки, например отправить уведомление }}
// Проверяем длительность последних трех ответов и устанавливаем новое значение delay function updateClientDelay(userId) { try { const responseTimes = clientActions[userId].responseTimes;
if (responseTimes.length < 3) { clientActions[userId].delay = 1000; // Устанавливаем delay на 1000 мс return; // Если еще нет ответов, ничего не делаем } // Проверяем, все ли три ответа дольше 15 секунд const allResponsesLongerThan15s = responseTimes.every(time => { const duration = time.end - time.start; // Вычисляем продолжительность return duration > 15000; // Проверяем, больше ли 15 секунд }); // Устанавливаем delay в зависимости от проверки if (allResponsesLongerThan15s) { clientActions[userId].delay = 20000; // Устанавливаем delay на 20000 мс } else { clientActions[userId].delay = 1000; // Устанавливаем delay на 1000 мс } } catch (error) { console.error('Ошибка при обновлении задержки клиента:', error); // Можно добавить дополнительные действия в случае ошибки, например установить задержку по умолчанию clientActions[userId].delay = 1000; // Пример установки по умолчанию }}
// Вызов модели
async function call(messages, model, ws, userId, rewrite){ if (model == 'gpt-4o') return callGPT4o(messages, ws, userId, rewrite); else if (model == 'gemini-pro') return callGemini(messages, ws, userId, rewrite); else if (model == 'qwen') return callQwen(messages, ws, userId, rewrite); else if (model == 'blackbox') return callBlackbox(messages, ws, userId, rewrite); else return callGPT4o(messages, ws, userId, rewrite); }
//============== ФУНКЦИИ API МОДЕЛЕЙ =============================================== //================================================================================== //================================================================================== //==================================================================================
// GPT4o async function callGPT4o(messages, ws, userId, rewrite) { const lastMessageContent = messages[messages.length - 1].content; // Используем только последнее сообщение const cacheKey =
gpt4o:${userId}:${lastMessageContent}; // Создаем ключ кэшана основе сообщения, модели и userId// Записываем время начала ответа const startTime = new Date(); // Пробуем получить ответ из кэша let cachedResponse; try { cachedResponse = await getAsync(cacheKey); } catch (error) { console.error('Ошибка при получении из Redis:', error); // Переходим к запросу по API } if (cachedResponse && !rewrite) { console.log('Отправка ответа из кэша для GPT4o'); // Имитируем задержку перед отправкой ответа из кэша (например, 1 с) setTimeout(() => { sendMessage(ws, JSON.parse(cachedResponse)); // Записываем время окончания ответа const endTime = new Date(); updateResponseTimes(userId, startTime, endTime); }, 1 * 1500); // 2 секунды задержки return; } // Увеличиваем счетчик запросов находящихся в обработке currentGPT4oProcessingRequests++; // Обновляем максимальное количество обрабатываемых запросов, если текущее больше if (currentGPT4oProcessingRequests > stats.maxGPT4oProcessingRequests) { stats.maxGPT4oProcessingRequests = currentGPT4oProcessingRequests; console.log(`Новое максимальное количество одновременно обрабатываемых запросов к GPT4o: ${stats.maxGPT4oProcessingRequests}`); } try {//throw new Error("Намеренная ошибка для тестирования catch"); console.log('Запрос клиента к GPT4o: ', messages[messages.length - 1]); let fullResponse = ""; await new Promise((resolve, reject) => { gpt4o({ messages, markdown: false }, (result) => { if (!result.finish) { fullResponse = result.message || ""; } else { if(fullResponse == '') stats.totalGPT4oLimitStops++; let responseMessage = fullResponse || 'Попробуйте написать позже или выберите другую модель.'; console.log('Ответ GPT4o:', { code: 1, message: responseMessage }); try { // Изменение здесь: используем метод set для установки TTL (в секундах) redisClient.set(cacheKey, JSON.stringify({ code: 1, message: responseMessage }), { EX: 10 * 60 }); } catch (error) { console.error('Ошибка при сохранении в Redis:', error); } resolve({ code: 1, message: responseMessage }); stats.totalGPT4oResponse++; sendMessage(ws, { code: 1, message: responseMessage }); // Записываем время окончания ответа const endTime = new Date(); updateResponseTimes(userId, startTime, endTime); } }); }); } catch (error) { stats.totalGPT4oMessErrors++; console.error('Error:', error); sendMessage(ws, { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }); }finally { // Уменьшаем счетчик независимо от результата currentGPT4oProcessingRequests--; }}
Если на обработку последних 3 сообщений у чата ушло более чем 15 секунд, то устанавливается задержка 20000 мс. Проблема в том, что пользователь может обойти это просто перезагрузив страницу. вебсокет соединение перезапустится и соответственно данные о клиенте будут удалены (ws.on('close', ()...), задержка будет снова равна 1. Как это решить, чтобы задержка сохранялась между переподключениями? может достаточно в исходном коде добавить только одно условие в ws.on('close', ():
ws.on('close', () => { if (clientActions[userId].delay == 1){ try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения delete clientActions[userId]; // Удаление состояния клиента } // Проверка, существует ли userId в limiters if (limiters[userId]) { delete limiters[userId]; // Удаление ограничителя для данного клиента } ... Т.е. если у пользователя стоит задержка в 20 секунд, то не удаляем его из памяти. Тгда задержка будет продолжать действовать, даже если пользователь перезапустит соединение. Assistant: сохранить задержку между переподключениями клиента, можно создать систему, которая будет отслеживать задержки для каждого пользователя даже после закрытия соединения. Один из подходов — это не удалять задержку пользователя, если она больше 1 миллисекунды. Вместо этого можно обновить логику обработки закрытия соединения в событии
ws.on('close', ...), сохраняя информацию о задержке.Вот как можно модифицировать код в обработчике закрытия соединения:
ws.on('close', () => { try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения // Если задержка больше 1, не удаляем клиента из clientActions if (clientActions[userId].delay > 1) { return; // Не удаляем пользователя } delete clientActions[userId]; // Удаление состояния клиента, если задержка 1 } // Проверка, существует ли 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); } });Важные моменты:
-
Не удаляем задержку, если она больше 1: Если задержка больше 1, мы не удаляем объект пользователя из
clientActions. Это позволяет сохранить задержку, когда пользователь переподключается. -
Условия при отключении: Убедитесь, что обработка отключения пользователя производится корректно, чтобы не оставить "мертвые" записи.
-
Проверка задержки: Если задержка после переподключения останется высокой, при новом подключении вы сможете просто использовать старую задержку, не устанавливая ее в 1 мс.
Если пользователь захочет установить новую задержку (например, снова вызвать функцию, которая обновляет задержку), вы можете сделать это, просто переопределив значение задержки в объекте
clientActionsв момент активного использования приложения.Такой подход сделает систему более устойчивой к изменениям состояния соединения и обеспечит большую степень контроля над задержкой между запросами от пользователей. User: А так?
ws.on('close', () => { try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения
// Если задержка 1, удаляем клиента из clientActions if (clientActions[userId].delay == 1) { delete clientActions[userId]; // Удаление состояния клиента, если задержка 1 } } // Проверка, существует ли userId в limiters if (limiters[userId] && clientActions[userId] && clientActions[userId].delay == 1) { 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: е обновление кода на самом деле также является хорошим решением для сохранения состояния задержки пользователя между переподключениями. Позвольте мне предложить небольшие пояснения и рекомендации для вашего кода.
Ваше обновление:
ws.on('close', () => { try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения // Если задержка 1, удаляем клиента из clientActions if (clientActions[userId].delay == 1) { delete clientActions[userId]; // Удаление состояния клиента, если задержка 1 } } // Проверка, существует ли userId в limiters if (limiters[userId] && clientActions[userId] && clientActions[userId].delay == 1) { 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); } });Основные моменты:
-
Условие для удаления состояния: Вы правильно добавили условие, которое проверяет, должна ли быть задержка равна 1, прежде чем удалить клиента из
clientActions. Это позволит сохранять задержку, когда она больше 1 мс. -
Логика для
limiters: Вы также добавили аналогичную проверку дляlimiters, что является хорошей практикой, так как это предотвращает потенциальные сбои, если ограничитель еще активен. -
Упрощение кода: Обратите внимание, что если вы хотите сделать код чуть более читаемым и менее подверженным ошибкам, вы можете вынести логику удаления клиента и ограничителя в отдельные функции.
Общая рекомендация:
Убедитесь, что в вашем приложении есть логика обработки на случай, если пользователь запускает задержку, чтобы ее можно было менять динамически в зависимости от новых взаимодействий. Это даст возможность управлять задержками эффективно и в реальном времени.
Поздравляю, ваше решение будет более устойчивым к переподключениям, и сохранит информацию о задержках. Если у вас будут дополнительные вопросы или вам понадобится помощь с дальнейшими улучшениями, не стесняйтесь спрашивать! User: После обновления страницы не работает Bottleneck. Данные из limiters не удаляются, если задержка 20 секунд, но новые запросы после обновления страницы все равно отправляются, хотя предыдущий (отправленный в прошлом соединении) все еще обрабатывается. Assistant: вините за возникшую проблему. Если после обновления страницы у вас возникают проблемы с
Bottleneck, где новые запросы по-прежнему отправляются, когда предыдущий запрос все еще в обработке, необходимо учитывать несколько моментов, чтобы правильно обработать состояние соединения и запросов.Вот некоторые шаги для улучшения вашей логики:
Возможные решения
-
Инициализация
limitersпри привязке нового WebSocket: При создании нового соединения WebSocket и после его закрытия необходимо инициализировать или восстанавливать состояние вlimitersдля нового соединения. Если пользователь перезагружает страницу, вам необходимо убедиться, что состояние его ограничений правильно устанавливается, чтобы избежать повторных обработок. -
Проверка состояния перед выполнением нового запроса: Перед выполнением нового запроса, проверьте, активно ли уже выполняется обработчик для этого пользователя. Если он в обработке, игнорируйте новый запрос, и вместо этого ожидайте, пока старый запрос не будет завершен.
-
Обновление вашего кода для обработки соединения: Поскольку вы хотите сохранить задержку между переподключениями, вы можете добавить дополнительную проверку перед тем, как отправлять новый запрос, чтобы убедиться, что предыдущий запрос все еще не завершен.
Код для решения
Вот пример кода, который включает вышеописанные рекомендации:
ws.on('message', (message) => { clientActions[userId].lastRequestTime = new Date(); // Скорректируйте логику для проверки, связан ли этот пользователь с текущим активным запросом if (limiters[userId] && clientActions[userId] && currentGPT4oProcessingRequests > 0) { const response = { code: 2, message: "Обработка предыдущего запроса, пожалуйста, подождите." }; sendMessage(ws, response); return; // Игнорируем новое сообщение } // Анализируем сообщение // Ваша существующая логика обрабатывает сообщения... // например, validateMessages и сообщения обработки }); // Вызов модели, где вы осуществляете ограничение запросов async function call(messages, model, ws, userId, rewrite) { // Проверяем состояние запроса для данного пользователя if (currentGPT4oProcessingRequests > 0) { const response = { code: 2, message: "Обработка предыдущего запроса. Пожалуйста, подождите." }; sendMessage(ws, response); return; // Возврат, если предыдущий запрос все еще в обработке } // Ваша логика вызова моделей модели... }Что было добавлено
-
Проверка обработки предыдущего запроса: Это гарантирует, что если предыдущий запрос все еще в обработке, новое сообщение будет игнорироваться, и клиент получит уведомление.
-
Сообщения клиенту: Явное уведомление пользователю о том, что они должны подождать, пока предыдущий запрос не будет завершен.
-
Инициализация логики для состояний при каждом новом соединении: Обращайтесь к
limitersи состоянию клиента, только если они все еще действительны с учетной записью пользователя.
Окончательные замечания
Вам необходимо тщательно протестировать логику после внесения изменений. Это будет касаться поведения при обновлении страницы, обработки запросов и корректного управления состоянием запросов, чтобы избежать конфликтов данных и неправильной логики, особенно с учетом асинхронного программирования.
Если у вас есть дополнительные вопросы или вам нужно больше примеров, не стесняйтесь сообщить! User: дело не в этом. Bottleneck настроен так if (!limiters[userId]) { // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) });
разве эти ограничения не продолжают действовать если переподключить websocet и limiters[userId] не удаляется после отключения первого подключения? Мне надо чтобы продолжал действовать, сейчас не продолжает. СЕйчас если пользователь перезагрузит страницу, то он может отправить второй подряд запрос, пока нет ответа на первый, хотя maxConcurrent: 1, // Максимальное количество одновременных задач Assistant: роблема, с которой вы столкнулись, может быть связана с тем, что при обновлении страницы создаётся новое WebSocket-соединение, которое инициализирует новую экземпляр Bottleneck для
limiters[userId]. Еслиlimiters[userId]не удаляется из вашего объекта, это не означает, что Bottleneck будет отслеживать состояние для нового соединения.Решение
Чтобы обеспечить продолжение ограничения запросов даже после обновления страницы, вам нужно реализовать следующую логику:
-
Проверка активного состояния запросов: Перед тем как инициализировать новый Bottleneck для текущего соединения, проверьте, существует ли уже ограничитель для пользователя. Если он существует, то используйте его, избегая создания нового.
-
Корректное управление состоянием: Не удаляйте экземпляры Bottleneck, если задержка больше 1. Таким образом, они сохранятся даже при переподключении, но вам также нужно обновить логику, чтобы обеспечить, что нет возможности отправить дополнительные запросы, если предыдущий все еще обрабатывается.
Исправленный код
Вот как вы можете изменить вашу логику:
wss.on('connection', (ws, req) => { // ... существующий код ... // Инициализируем состояние клиента, если его еще нет if (!clientActions[userId]) { clientActions[userId] = { actions: [], connected: true, lastRequestTime: new Date(), ws: ws, delay: 1000, responseTimes: [] }; } else { // Проверяем задержку и состояние if (clientActions[userId].delay > 1) { // Если задержка больше 1, устанавливаем новое ws clientActions[userId].ws = ws; } } // Проверяем limiters if (!limiters[userId]) { limiters[userId] = new Bottleneck({ maxConcurrent: 1, minTime: 1000, highWater: 0 }); } ws.on('message', (message) => { // ... аналогичная логика обработки сообщений ... // Задержка перед отправкой запроса limiters[userId].schedule(() => { // Отправка запроса только если предыдущий запрос завершен if (currentProcessingRequests[userId]) { const response = { code: 2, message: "Обрабатывается предыдущий запрос. Пожалуйста, подождите." }; sendMessage(ws, response); return; // Пропустите обработку, если запрос в процессе } // Ваш вызов модели (call) }).catch(error => { // Обработка ошибок }); }); ws.on('close', () => { // ... существующий код ... }); });Что изменено
-
Переподключение с использованием существующего ограничителя: Теперь, если
clientActions[userId]уже существует, мы просто обновляемwsдля данного пользователя, не создавая новый экземпляр Bottleneck. Это позволяет сохранившимся задержкам работать без дополнительных переинициализаций. -
Проверка состояния обработки: Проверка на наличие активного запроса (
currentProcessingRequests[userId]) перед отправкой нового запроса. Если предыдущий запрос всё ещё обрабатывается, игроку отправляется сообщение, что он должен подождать. -
**Логика управления состоянием
**: Необходима правильная обработка того, чтобы управлять, когда запросы находятся в процессе обработки. Вы можете создать объектcurrentProcessingRequests`, который будет отслеживать, обрабатываются ли запросы для каждого пользователя.
Дополнительные рекомендации
- Убедитесь, что вы правильно обновляете состояние
currentProcessingRequestsнаtrueи возвращаете его вfalseпосле завершения обработки запроса. Это поможет синхронизировать состояние между разными соединениями.
Следуя этому подходу, ваш Bottleneck будет правильно работать и ограничивать последовательные запросы, даже если пользователь обновит страницу и установит новое соединение. 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 clientActions[userId].connected = true; 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; // Обновление статуса подключения // Если задержка 1, удаляем клиента из clientActions if (clientActions[userId].delay == 1) { delete clientActions[userId]; // Удаление состояния клиента, если задержка 1 } } // Проверка, существует ли userId в limiters if (limiters[userId] && clientActions[userId] && clientActions[userId].delay == 1) { 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: текущий код действительно учитывает сохранение состояния клиента в случае отключения. Однако проблема, которую вы описываете — возможность отправки нескольких запросов после обновления страницы — скорее всего, связана с тем, что новое соединение WebSocket создает новый экземпляр клиента, включая новый объект
Bottleneck, даже если для идентификатора пользователя уже существует запись вlimiters.Как обеспечить правильную логику после обновления соединения
-
Повторное использование существующего экземпляра
Bottleneck: Если для данногоuserIdуже существует экземплярBottleneck, убедитесь, что ваше новое соединение использует уже созданный экземпляр, а не создает новый. -
Добавьте проверку, чтобы избежать отправки новых запросов: Вам необходимо отслеживать, выполняется ли запрос через
Bottleneck.
Вот как это можно сделать в вашем коде:
Пример кода
wss.on('connection', (ws, req) => { const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); const userIP = req.socket.remoteAddress; // Проверяем Origin if (!checkOrigin(req.headers.origin, ws)) { return; } // Логика увеличения счетчиков и инициализации состояния клиента... // Проверяем, существует ли уже limiters для данного userId if (!limiters[userId]) { limiters[userId] = new Bottleneck({ maxConcurrent: 1, minTime: 1000, highWater: 0 }); } ws.on('message', (message) => { // Ваш код для обработки сообщений... // Используем Bottleneck для управления количеством запросов limiters[userId].schedule(() => { // Проверяем, не обрабатывается ли в данный момент запрос для этого пользователя if (clientActions[userId] && clientActions[userId].processing) { const response = { code: 2, message: "Обрабатывается предыдущий запрос. Пожалуйста, подождите." }; sendMessage(ws, response); return; // Пропустить выполнение запроса, если предыдущий в процессе } // Устанавливаем флаг обработки clientActions[userId].processing = true; // Отправка запроса на сервер чата с задержкой call(messages, model, ws, userId, rewrite).then(() => { // После завершения обработки сбрасываем флаг clientActions[userId].processing = false; }); }).catch(error => { const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." }; sendMessage(ws, response); }); }); ws.on('close', () => { // Ваш код для обработки отключения... }); });Основные рекомендации:
-
Флаг обработки: В
clientActionsдобавьте флагprocessing, который будет указывать, выполняется ли в данный момент запрос для этого клиента. Убедитесь, что этот флаг устанавливается вtrue, когда запрос начинается, и сбрасывается вfalse, когда обработка завершена. -
Проверка состояния перед запросом: В обработчике сообщений перед отправкой нового запроса проверьте, установлен ли флаг
processing. Если флаг установлен, отправьте клиенту сообщение, что предыдущий запрос все еще выполняется, и не отправляйте новый запрос.
Заключение
Такой подход предотвратит отправку новых запросов, пока предыдущий запрос находится в процессе выполнения. Это должно решить вашу проблему с повторной отправкой сообщений после обновления страницы, сохраняя при этом правильную работу ограничений Bottleneck.
Если у вас возникнут дополнительные вопросы или нужна будет помощь с другой частью вашего кода, не стесняйтесь обращаться! User: ws.on('close', () => { try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения
// Если задержка 1, удаляем клиента из clientActions if (clientActions[userId].delay == 1) { delete clientActions[userId]; // Удаление состояния клиента, если задержка 1 } } // Проверка, существует ли userId в limiters if (limiters[userId] && clientActions[userId] && clientActions[userId].delay == 1) { 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); } });надо изменить условие if (clientActions[userId].delay == 1) на другое. Нужно проверять, что последнее сообщение было более 20 секунд назад Assistant: изменить условие в обработчике события
ws.on('close', ...), так что вместо проверки наclientActions[userId].delay == 1у вас будет проверка на время последнего сообщения, вам нужно будет запомнить время последнего сообщения, отправленного от пользователя, и проверить, прошло ли более 20 секунд с этого момента.Вот как можно модифицировать ваш код:
Измененный код
ws.on('close', () => { try { // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения // Проверяем, прошло ли более 20 секунд с последнего сообщения const currentTime = new Date(); const lastRequestTime = clientActions[userId].lastRequestTime; if (currentTime - lastRequestTime > 20 * 1000) { // 20 секунд в миллисекундах delete clientActions[userId]; // Удаление состояния клиента, если прошло более 20 секунд } } // Проверка, существует ли userId в limiters if (limiters[userId] && clientActions[userId] && (currentTime - clientActions[userId].lastRequestTime > 20 * 1000)) { 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); } });Объяснение изменений:
-
Проверка времени последнего сообщения: Вместо проверки на
delay, мы теперь сравниваем текущее время иlastRequestTime, чтобы установить, прошло ли более 20 секунд с момента последнего сообщения. -
Логика удаления
clientActionsиlimiters: Если больше 20 секунд с момента последнего сообщения, мы удаляем соответствующий объект изclientActionsиlimiters. -
Уточнение условий: Убедитесь, что для всех мест кода, где используется
lastRequestTime, это значение правильно обновляется при каждом получении сообщения от клиента.
Этот код будет эффективно управлять состоянием, удаляя клиента из управления через 20 секунд после последнего взаимодействия, что соответствует вашим требованиям. Если у вас есть дополнительные вопросы или пожелания, не стесняйтесь спрашивать! User: Error handling client disconnect: ReferenceError: currentTime is not defined 0|server | at WebSocket. (C:\OSPanel\domains\gpt.loc\chat\API\call.js:248:54) 0|server | at WebSocket.emit (node:events:530:35) 0|server | at WebSocket.emitClose (C:\OSPanel\domains\gpt.loc\chat\API\node_modules\ws\lib\websocket.js:272:10) 0|server | at TLSSocket.socketOnClose (C:\OSPanel\domains\gpt.loc\chat\API\node_modules\ws\lib\websocket.js:1341:15) 0|server | at TLSSocket.emit (node:events:530:35) 0|server | at node:net:337:12 0|server | at Socket.done (node:_tls_wrap:657:7) 0|server | at Object.onceWrapper (node:events:633:26) 0|server | at Socket.emit (node:events:530:35) 0|server | at TCP. (node:net:337:12) Assistant:
-
- Assistant
Ошибка
ReferenceError: currentTime is not definedвозникает из-за того, что переменнаяcurrentTimeне была объявлена или инициализирована в области видимости, когда она используется в обработчикеws.on('close', ...).Чтобы исправить эту ошибку, убедитесь, что вы инициализируете переменную
currentTimeперед тем, как использовать ее. Вот исправленный код:Исправленный код
ws.on('close', () => { try { // Получаем текущее время const currentTime = new Date(); // Проверка, существует ли userId в clientActions if (clientActions[userId]) { clientActions[userId].connected = false; // Обновление статуса подключения // Проверяем, прошло ли более 20 секунд с последнего сообщения const lastRequestTime = clientActions[userId].lastRequestTime; if (currentTime - lastRequestTime > 20 * 1000) { // 20 секунд в миллисекундах delete clientActions[userId]; // Удаление состояния клиента, если прошло более 20 секунд } } // Проверка, существует ли userId в limiters if (limiters[userId] && (clientActions[userId] && (currentTime - clientActions[userId].lastRequestTime > 20 * 1000))) { 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); } });Изменения, внесенные в код:
-
Получение текущего времени: Переменная
currentTimeинициализируется в начале обработчикаws.on('close', ...), что позволяет избежать ошибкиReferenceError. -
Логика проверки задержки: Убедитесь, что логика удаления пользователя и ограничения по-прежнему работает правильно после этой модификации.
Теперь код должен работать корректно, без вызова исключений. Если у вас будут еще вопросы или возникнут другие проблемы, не стесняйтесь обращаться!
-