const { gpt, gptweb } = require("./API/gpt"); const { dalle } =…
- User
User: const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { RateLimiterMemory } = require('rate-limiter-flexible'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv');
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';
// Настройки для ограничений по IP const rateLimiter = new RateLimiterMemory({ points: 20, // разрешается 10 запросов duration: 1, // за 1 секунду blockDuration: 60 // время блокировки в секундах });
// Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 });
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; const userHeaders = req.headers; // Проверяем Origin if (!checkOrigin(userHeaders.origin, ws)) { return; // Если отклонено, выходим из обработчика } // Увеличиваем общий счетчик подключений stats.totalConnections++; console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin); console.log('Общее количество подключений:', stats.totalConnections); // Инициализируем состояние клиента, если его еще нет if (!clientActions[userId]) { clientActions[userId] = { actions: [], // Массив для хранения действий connected: true, // Статус подключения }; // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); } ws.on('message', (message) => { // Проверяем, является ли сообщение экземпляром Buffer if (Buffer.isBuffer(message)) message = message.toString(); try { // Преобразуем строку JSON обратно в объект message = JSON.parse(message); //Получаем историю чата из запроса let messages = message.messages; console.log('До обработки:', messages); // Выполняем валидацию сообщений 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); } console.log('После обработки:', messages); // Увеличиваем общий счетчик запросов stats.totalRequests++; rateLimiter.consume(userIP) .then(() => { // Используем Bottleneck для управления количеством запросов limiters[userId].schedule(() => { // Отправка запроса на сервер чата return call(messages, ws); }).catch(error => { //console.error('Rate limit exceeded, message ignored:', error); const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." }; // Отправка ответа клиенту sendMessage(ws, response); }); }) .catch(() => { // Увеличиваем счетчик блокировок по IP stats.totalIPBlocks++; const response = { code: 2, message: "Вы временно заблокированы за превышение лимита запросов." }; // Отправка ответа клиенту sendMessage(ws, response); }); } catch (error) { console.error('Error parsing JSON:', error); const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; console.log(response); // Отправка ответа клиенту sendMessage(ws, response); } }); ws.on('close', () => { clientActions[userId].connected = false; // Обновление статуса подключения delete clientActions[userId]; // Удаление состояния клиента delete limiters[userId]; // Удаление ограничителя для данного клиента console.log('Client ',userId, ' disconnected'); });});
async function call(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages); //throw new Error("Намеренная ошибка для тестирования catch"); gpt4o({ messages: messages, markdown: false }, (result) => { try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); let response = { code: 2, message: "Произогла ошибка. Попробуйте еще раз." }; // Отправка ответа клиенту sendMessage(ws, response); } }); } catch (error) { console.error('Error:', error); let response = { code: 2, message: "Произогла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Запускаем планировщик для статистики scheduleDailyReset();
// Очистка старых соединений раз в минуту (по желанию) setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен } }); }, 60 * 1000); // Очистка каждые 60 секунд
function checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Недопустимый домен. Соединение разорвано: ', origin); socket.close(); // Закрываем соединение, если домен не разрешен return false; // Возвращаем false для индикатора отклонения } return true; // Возвращаем true, если домен разрешен }
// Отправляет ответ клиенту function sendMessage(ws, message) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(message)); } else { console.warn(
Trying to send message to a closed WebSocket connection.); } }// Удаление из массива сообщений не соответствующих схеме function validateMessages(messages) { // Определяем схему для сообщений const schema = { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'], additionalProperties: false };
// Фильтруем массив, оставляя только корректные сообщения return messages.filter(message => ajv.validate(schema, message));}
console.log('WebSocket сервер запущен через порт 3000');
Необходимо дополнительно для каждого клиента хранить время последнего сообщения от него в clientActions Assistant: того чтобы хранить время последнего сообщения от каждого клиента в объекте
clientActions, вам нужно будет внести изменения в код обработчика сообщения. Мы можем добавить новое поле, например,lastMessageTime, в объектclientActionsдля каждого клиента и обновлять его каждый раз, когда клиент отправляет сообщение.Внесем необходимые изменения в этом коде:
- Добавляем новое поле
lastMessageTimeпри инициализации клиента. - Обновляем это поле каждый раз, когда клиент отправляет сообщение.
Вот необходимые изменения в вашем коде:
// Инициализируем состояние клиента, если его еще нет if (!clientActions[userId]) { clientActions[userId] = { actions: [], // Массив для хранения действий connected: true, // Статус подключения lastMessageTime: new Date() // Время последнего сообщения }; // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); } ws.on('message', (message) => { // Проверяем, является ли сообщение экземпляром Buffer if (Buffer.isBuffer(message)) message = message.toString(); try { // Преобразуем строку JSON обратно в объект message = JSON.parse(message); // Получаем историю чата из запроса let messages = message.messages; console.log('До обработки:', messages); // Выполняем валидацию сообщений 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); } // Обновляем время последнего сообщения от клиента clientActions[userId].lastMessageTime = new Date(); console.log('После обработки:', messages); // Увеличиваем общий счетчик запросов stats.totalRequests++; rateLimiter.consume(userIP) .then(() => { // Используем Bottleneck для управления количеством запросов limiters[userId].schedule(() => { // Отправка запроса на сервер чата return call(messages, ws); }).catch(error => { const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." }; // Отправка ответа клиенту sendMessage(ws, response); }); }) .catch(() => { // Увеличиваем счетчик блокировок по IP stats.totalIPBlocks++; const response = { code: 2, message: "Вы временно заблокированы за превышение лимита запросов." }; // Отправка ответа клиенту sendMessage(ws, response); }); } catch (error) { console.error('Error parsing JSON:', error); const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; console.log(response); // Отправка ответа клиенту sendMessage(ws, response); } });Теперь у вас будет поле
lastMessageTimeдля каждого клиента, которое обновляется каждый раз, когда клиент отправляет сообщение. Это позволит вам отслеживать время последнего сообщения от каждого пользователя. User: Теперь перепиши эту часть// Очистка старых соединений раз в минуту (по желанию) setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен } }); }, 60 * 1000); // Очистка каждые 60 секунд
удаляй пользователя если соединение закрыто и последнее сообщение было больше часа назад Assistant: изменить логику очистки пользователей в том коде, который вы предоставили, вам нужно будет проверять не только состояние соединения, но и время последнего сообщения. Если соединение закрыто и последнее сообщение было отправлено более часа назад, пользователь будет удалён из
clientActions.Вот как можно переписать эту часть кода:
// Очистка старых соединений раз в минуту setInterval(() => { const currentTime = new Date(); Object.keys(clientActions).forEach(userId => { const clientAction = clientActions[userId]; if (!clientAction.connected && (currentTime - clientAction.lastMessageTime) > 60 * 60 * 1000) { // Если соединение закрыто и время последнего сообщения больше часа, удаляем пользователя из памяти delete clientActions[userId]; console.log(`Пользователь ${userId} удален из памяти.`); } }); }, 60 * 1000); // Очистка каждые 60 секундОбъяснение изменений:
- Сохраняем текущее время: Мы создаем переменную
currentTimeдля хранения текущего времени. - Проверяем условия: Внутри
forEachпроверяем, соответствует ли условие:!clientAction.connected(соединение закрыто) и(currentTime - clientAction.lastMessageTime) > 60 * 60 * 1000(последнее сообщение было более часа назад). - Удаляем пользователя: Если оба условия соблюдены, мы удаляем пользователя из
clientActionsи выводим в консоль сообщение об удалении.
С этими изменениями ваш сервер теперь будет правильно очищать старые соединения, которые были отключены более часа назад. User: Правильно ли я понимаю, если пользователь отключится, например перезагрузит страницу, то таймеры rateLimiter и Bottleneck будут сброшены и временный бан, если он был обнулится? Assistant: , вы правильно понимаете. Если пользователь отключается (например, перезагружает страницу), то объект
clientActions, который хранит состояние клиента, будет очищен. Это включает в себя:-
Объекты
rateLimiterиBottleneck: Поскольку вы удаляете пользователя изclientActions, также будет удалён и соответствующий объектBottleneckи все связанные с ним временные параметры для ограничения частоты запросов. Это означает, что при следующем подключении пользователя начинается новый лимит на количество запросов, и все таймеры и истечения срока действия обнуляются. -
Временные блокировки: Если пользователь был временно заблокирован (например, за превышение лимита запросов) и отключился, эта временная блокировка будет сброшена, когда он вновь подключится. Это происходит потому, что механизмы ограничения запросов зависят от текущего состояния объекта, который будет создан заново при новом подключении.
Если вы хотите сохранить состояние на случай отключений и перезагрузок, вам потребуется реализовать другую логику, например, хранить статистику о лимитах запросов и временных блокировках в более устойчивом хранилище, например, в базе данных, чтобы сохранять данные даже после разрывов соединения. User: А если не удалять пользователя из clientActions и limiters при его отключении? Assistant: вы решите не удалять пользователя из
clientActionsиlimitersпри его отключении, это приведет к следующему поведению:1. Сохранение состояния пользователя:
- Состояние пользователя, включая время последнего сообщения, ограничения по количеству запросов и все предыдущие данные, будут сохранены. При повторном подключении пользователь может восстановить свое состояние, что может быть полезно с точки зрения управления сеансами.
2. Проблемы с освобождением ресурсов:
- Если пользователь отключится и не будет удален, это может привести к утечкам памяти. Объекты, связанные с данным пользователем (например,
BottleneckиrateLimiter), будут сохраняться в памяти даже после отключения, что может повлиять на общую производительность сервера, особенно если количество подключений велико.
3. Сохранение ограничений по запросам:
- Ограничения, установленные пользователю посредством
BottleneckиrateLimiter, будут сохраняться. Если пользователь отключается, но не удаляется, при повторном подключении он останется со всеми своими предыдущими ограничениями. Это может привести к путанице, если они выпадут за пределы временных рамок, поскольку у пользователя будет возможность продолжить с состоянием, которое может не соответствовать текущему времени или ограничениям.
4. Временные блокировки:
- Если пользователь был временно заблокирован за превышение лимита запросов и остался в
clientActions, то при восстановлении соединения его блокировка все еще будет действовать. Это может быть полезно, если вы хотите сохранить механизмы безопасности, но может создавать путающую пользовательскую жизнецикл.
Рекомендация
Если вы решите не удалять пользователя из
clientActionsиlimiters, вам нужно будет добавлять дополнительные проверки, чтобы гарантировать, что клиентские состояния не ведут к нежелательному поведению. В частности, вам следует:- Проверять состояния пользователей по истечении определенного времени и очищать их, если они не активны. Это можно реализовать с помощью периодических проверок.
- Обновлять логику временного блокирования и ограничения до повторного подключения, чтобы гарантировать, что состояние пользователя всегда актуально.
- Настроить таймеры для мониторинга состояния активности пользователей, чтобы увеличить производительность и избежать утечек памяти.
Таким образом, вам нужно взвесить плюсы и минусы сохранения состояния пользователя между подключениями и потенциальные проблемы с ресурсами и ограничениями. User: Ограничения, установленные пользователю посредством Bottleneck и rateLimiter, будут сохраняться. Если пользователь отключается, но не удаляется, при повторном подключении он останется со всеми своими предыдущими ограничениями. Это может привести к путанице, если они выпадут за пределы временных рамок, поскольку у пользователя будет возможность продолжить с состоянием, которое может не соответствовать текущему времени или ограничениям.
Не понял. Какие могут быть проблемы? Таймер ведь не сервере. Он будет продолжать работать и после переподключения клиента, а когда закончится клиент снова сможет отправлять сообщения Assistant: правы, таймеры в
BottleneckиrateLimiterуже существуют на стороне сервера и будут продолжать работать даже после отключения клиента. Однако, необходимо учитывать несколько моментов:1. Состояние
BottleneckиrateLimiter:- Bottleneck функционирует как очередь задач с контролем частоты запросов. Когда клиент отключается, все его текущие задачи и лимиты остаются в памяти. Если они в этот момент находятся в состоянии задержки, по факту клиент не будет иметь возможность отправлять новые запросы, но состояние
Bottleneckпродолжает считать количество выполненных и ожидающих запросов. - RateLimiter также сохраняет состояние, включая количество разрешённых вызовов за определённый период времени. Это означает, что по возвращении клиента, он может обнаружить, что все его квоты использованы, и ему будет отказано в дальнейших запросах, несмотря на то, что он был отключён какое-то время.
2. Неоднозначные результаты после переподключения:
- Если клиент был временно заблокирован из-за превышения лимитов, а затем отключился (например, закрыл вкладку), и потом снова подключился, он может понять, что не может отправить сообщения, хотя прошло время, необходимое для разблокировки. Это может вызвать путаницу, так как пользователь ожидает, что после перезагрузки приложения он сможет взаимодействовать с ним, но в действительности его прежние ограничения продолжают действовать.
- Если клиент остаётся в
clientActions, это также может создать условия, когда на сервере не будет достаточно информации о реальных условиях использования. Например, если клиент должен был уже восстановить свои права на отправку сообщений, но из-за того, что состояние не обновилось, он всё ещё считается под ограничением.
3. Утечки памяти и ресурсоёмкость:
- Хранение информации в памяти для неактивных пользователей может привести к проблемам с производительностью, особенно при большом количестве пользователей. Если состояние не очищается, объекты
BottleneckиrateLimiterмогут занимать значительное количество памяти.
4. Как избежать проблем:
- Вы можете внедрить механизм, который будет периодически проверять состояние каждого пользователя, например, раз в несколько минут, и очищать состояние для тех, кто неактивен более заданного времени. Вы также можете использовать таймеры для отслеживания времени последнего взаимодействия с каждым клиентом.
- Если состояние пользователя сохраняется между переподключениями, рассмотрите возможность добавления логики, которая обновит временные данные при переподключении. Например, при повторном подключении клиента следует проверять и сбрасывать состояние
BottleneckиrateLimiterв соответствии с фактическим временем и условиями.
Таким образом, в общем, существуют потенциальные сложности при приостановке и восстановлении применения ограничений для клиентов, однако если вы скорректируете свою логику таким образом, чтобы избежать путаницы, то это может работать без существенных проблем. User: RateLimiter также сохраняет состояние, включая количество разрешённых вызовов за определённый период времени. Это означает, что по возвращении клиента, он может обнаружить, что все его квоты использованы, и ему будет отказано в дальнейших запросах, несмотря на то, что он был отключён какое-то время.
как могут быть использованы квоты, если он отключен и не отправляет сообщения? Assistant:
- Добавляем новое поле
- Assistant
Вы правы, и я приношу свои извинения за путаницу в объяснении. Давайте проясним, как работают
RateLimiterиBottleneckв контексте отключения пользователя:Как работает
RateLimiter?-
Мониторинг:
RateLimiterотслеживает количество запросов, отправленных клиентом, за определённый временной период. Например, если у вас установлен лимит в 20 запросов в минуту, это означает, что клиент может отправить максимум 20 запросов в течение 60 секунд. -
Отключение клиента: Когда клиент отключается, он больше не может отправлять запросы, и, следовательно, не использует "квоты"
RateLimiter. Во время отключения, его квоты не уменьшаются, и состояниеRateLimiterдля данного клиента не изменяется, кроме того, что если запросы уже были отправлены, они будут учтены. -
При повторном подключении: Если клиент возвращается через какое-то время (например, даже через час), его состояние в
RateLimiterсохранится. Если в его квоте уже использовался максимальный лимит на время, которое клиент отсутствовал, то клиент может столкнуться с отказами от сервера из-за превышения лимита.
Как работает
Bottleneck?-
Очередь:
Bottleneckуправляет очередностью задач и позволяет фиксировать, сколько задач может выполняться одновременно, а также контролирует минимальный интервал между запросами. -
Удаление после отключения: Если клиент отключен, то все его текущие задачи, которые еще могут находиться в очереди, также будут удерживать состояние
Bottleneck. Но она не будет активна до тех пор, пока клиент не восстановит соединение. -
К временному нарушению правил: Если клиент был временно заблокирован, и находится в состоянии
Bottleneck, то время с момента блокировку также растянется до повторного подключения.
Ключевой момент
Таким образом, когда клиент отключается, он не использует квоты, но их состояние все еще сохраняется в
RateLimiterиBottleneck. Если пользователь отключен на значительное время (долгое время) и его состояние не очищается, это может привести к путанице при повторном подключении, если предыдущие квоты или задачи всё ещё сохранены.Рекомендации
- Очистка состояния: Возможно, для избежания путаницы будет разумно удалять пользователя из системы или сбрасывать состояние
RateLimiterиBottleneckчерез некоторое время, если клиент не проявляет активности. Таким образом, при повторном подключении пользователю будет предоставлено новое, чистое состояние. - Логирование и уведомления: Пользователь должен быть осведомлён о текущем состоянии своих запросов после переподключения, чтобы избежать недосказанности или путаницы о их доступных квотах.
Надеюсь, это проясняет, как работают квоты в контексте отключения и повторного подключения клиента. Если у вас есть дополнительные вопросы, не стесняйтесь спрашивать!
-