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 clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';
// Настройки для ограничений по IP const rateLimiter = new RateLimiterMemory({ points: 20, // разрешается 10 запросов duration: 1, // за 1 секунду blockDuration: 60 // время блокировки в секундах });
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; // Если отклонено, выходим из обработчика } console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin); // Инициализируем состояние клиента, если его еще нет 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); //Получаем историю чата из запроса messages = message.messages; 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(() => { 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); }}
console.log('WebSocket сервер запущен через порт 3000');
// Очистка старых соединений раз в минуту (по желанию) setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен } }); }, 60000); // Очистка каждые 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.); } }Оцени код. Что еще добавить? Assistant: од представляет собой довольно хорошо структурированный WebSocket-сервер, который управляет подключениями клиентов и ограничивает частоту запросов на основе различных методов (таких как Bottleneck и RateLimiter). Однако существует несколько улучшений, которые можно было бы добавить для повышения читаемости, надёжности и функциональности:
Улучшения кода
-
Улучшение обработки ошибок:
- Обработка ошибок может быть более детализированной. Например, вы могли бы логировать не только общие сообщения об ошибках, но и конкретные данные, вызвавшие ошибки.
- Также полезно использовать специальные классы ошибок для различного типа ошибок (например,
RateLimitError,ConnectionErrorи т.д.).
-
Добавление логирования:
- Возможно, стоит добавлять более детализированное логирование, чтобы легче было отслеживать проблемы, такие как количество подключений, количество обработанных запросов и время обработки запросов.
-
Управление состоянием клиента:
- При отключении клиента лучше не удалять состояние сразу. Вместо этого можно сохранить информацию о том, когда пользователь отключился, для возможной последующей обработки (например, повторная инициализация при новом подключении).
-
Поддержка разных типов сообщений:
- Если ваше приложение должно поддерживать несколько типов сообщений, можно использовать более сложную структуру для определения и обработки различных типов сообщений (например, запросы на управление пользователем, запросы на отправку сообщений и т.д.).
-
Кэширование:
- Если запросы одного и того же пользователя содержат дублирующие данные, можно реализовать систему кэширования, чтобы уменьшить нагрузку на сервер и сократить время ожидания.
-
Планировщик задач:
- По желанию можно добавить планировщик задач для обработки фоновых задач, таких как периодические отчеты о состоянии соединений или пользовательской активности.
-
Валидация данных:
- Перед обработкой входящих сообщений целесообразно убедиться, что они соответствуют некоторым ожиданиям (например, что сообщения содержат необходимые поля).
-
Конфигурационные параметры:
- Задать параметры, такие как предел запросов и временные рамки, через конфигурационный файл, чтобы их можно было легко изменять.
-
Тестирование:
- Написание юнит-тестов и интеграционных тестов поможет обеспечить надёжность и сделать код более удобным в поддержке.
-
Безопасность:
- Рассмотрите возможность добавления дополнительных мер безопасности, таких как аутентификация клиентов и защита от атак, таких как DDoS.
- Усовершенствование структуры:
- Код можно структурировать более модульно. Рассмотрите возможность разделения на отдельные файлы (например, обработка сообщений, логирование, маршрутизация и т.д.).
- Документация:
- Добавьте комментарии и документацию к вашему коду, чтобы объяснить неочевидные части кода и его структуру.
Пример структуры для улучшения
Вот как можно было бы реализовать еще несколько из предложенных изменений в отдельном файле, например, для управления ошибками:
// error-handler.js class RateLimitError extends Error { constructor(message) { super(message); this.name = "RateLimitError"; } } // Пример использования function handleError(error, ws) { if (error instanceof RateLimitError) { sendMessage(ws, { code: 2, message: error.message }); } else { sendMessage(ws, { code: 2, message: "Общая ошибка. Попробуйте еще раз." }); } }В целом, ваш код уже выглядит довольно хорошо, но, соблюдая эти рекомендации, вы можете сделать его еще более эффективным, устойчивым и удобным в использовании. User: Управление состоянием клиента:
При отключении клиента лучше не удалять состояние сразу. Вместо этого можно сохранить информацию о том, когда пользователь отключился, для возможной последующей обработки (например, повторная инициализация при новом подключении).
Сделай так:
При отключении надо в clientActions записать время отключения, соответственно при подключении инициализировать его там же. Кроме того надо изменить периодическую очистку
setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен } }); }, 60000); // Очистка каждые 60 секунд
при длительном отсутствии, например сравнивать текущее время с временем отключения, надо удалять запись из clientActions Assistant: реализовать управление состоянием клиента, как вы описали, мы можем модифицировать код следующим образом. Мы добавим логику для хранения времени отключения пользователя и изменим процесс очищения записей из
clientActions.Вот как можно это сделать:
- Модификация структуры данных клиента: Добавим поле для хранения времени отключения.
- Запись времени отключения: При отключении клиента сохраняем текущее время.
- Изменение периодической очистки: Вместо мгновенного удаления записи клиента на основе его статуса, будем проверять, прошло ли определённое время с момента отключения.
Вот предлагаемый код с внесенными изменениями:
const clientActions = {}; // ... ваш существующий код инициализации WebSocket ... 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; if (!checkOrigin(userHeaders.origin, ws)) { return; } console.log('Client connected with user ID:', userId, 'Domain -', userHeaders.origin); // Инициализация состояния клиента if (!clientActions[userId]) { clientActions[userId] = { actions: [], connected: true, disconnectTime: null // Добавляем поле для времени отключения }; limiters[userId] = new Bottleneck({ maxConcurrent: 1, minTime: 1000, highWater: 0 }); } ws.on('message', (message) => { // ... ваш существующий код обработки сообщений ... }); ws.on('close', () => { clientActions[userId].connected = false; clientActions[userId].disconnectTime = Date.now(); // Записываем текущее время отключения console.log('Client', userId, 'disconnected'); }); }); // Изменение интервала очистки setInterval(() => { const currentTime = Date.now(); const thresholdTime = 60000; // 60 секунд, например Object.keys(clientActions).forEach(userId => { const client = clientActions[userId]; // Проверяем, отключен ли клиент и прошло ли больше thresholdTime с момента его отключения if (!client.connected && (currentTime - client.disconnectTime > thresholdTime)) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен более 60 секунд } }); }, 60000); // Очистка каждые 60 секунд // ... ваш существующий код других функций ... function checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Invalid domain. Connection closing:', origin); socket.close(); return false; } return 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.`); } }Объяснение изменений:
-
Добавлено поле
disconnectTime: В структуре состояния клиента теперь хранится время отключения. -
Запись времени отключения: В обработчике события
closeмы теперь записываем текущее время отключения вdisconnectTime. -
Очистка неактивных клиентов: Мы изменили логику очистки в
setInterval(), чтобы проверять разницу между текущим временем и временем отключения. Если клиент был отключен более 60 секунд, запись о нем удаляется изclientActions.
С помощью этих изменений вы сможете отслеживать, когда пользователи отключаются, и управлять состоянием более эффективно. User: а что происходит если клиент переподключается, но запись о нем еще есть в clientActions с состоянием connected false Assistant: клиент переподключается, а запись о нем всё еще существует в
clientActionsсо состояниемconnected: false, то это может привести к тем, что состояния и действия текущего подключения будут конфликтовать с прежним состоянием.Чтобы избежать путаницы и обеспечить правильное управление состоянием, можно сделать следующее:
-
Проверка существующей записи при переподключении: Когда новый экземпляр клиента подключается, мы можем проверить, существует ли уже запись о данном пользователе. Если запись есть и находится в состоянии
connected: false, то стоит обновить состояние для этой записи, установивconnected: trueи сбросивdisconnectTime. -
Обновление состояния клиента: При переподключении можно использовать уже существующую запись (а не создавать новую) и обновить её состояние.
Вот как можно изменить обработчик
connection, чтобы учесть случаи переподключения: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; if (!checkOrigin(userHeaders.origin, ws)) { return; } console.log('Client connected with user ID:', userId, 'Domain -', userHeaders.origin); // Проверка на существование состояния клиента if (!clientActions[userId]) { // Если записи нет, создаем новую clientActions[userId] = { actions: [], connected: true, disconnectTime: null // Добавляем поле для времени отключения }; limiters[userId] = new Bottleneck({ maxConcurrent: 1, minTime: 1000, highWater: 0 }); } else { // Если запись существует, просто обновляем состояние clientActions[userId].connected = true; clientActions[userId].disconnectTime = null; // Обнуляем время отключения console.log('Client reconnected, updated state:', clientActions[userId]); } ws.on('message', (message) => { // ... ваш существующий код обработки сообщений ... }); ws.on('close', () => { clientActions[userId].connected = false; clientActions[userId].disconnectTime = Date.now(); // Записываем текущее время отключения console.log('Client', userId, 'disconnected'); }); });Объяснение изменений:
-
Проверка существования состояния клиента: Перед созданием нового состояния проверяем, существует ли уже запись о клиенте. Если она есть, просто обновляем её.
-
Обновление состояния: Устанавливаем
connected: trueи сбрасываемdisconnectTimeдля свежего соединения. Это позволяет поддерживать корректное состояние клиента при переподключении.
Преимущества:
-
Корректное управление состоянием: Это изменение предотвращает наличие нескольких записей для одного и того же клиента и поддерживает правильное состояние
connected. -
Упрощение логики: Упрощается логика обработки, так как все действия клиента ведутся по одной записи.
Используя этот подход, вы сможете без проблем управлять состояниями клиентов, включая случаи переподключения. User: Управление состоянием клиента:
При отключении клиента лучше не удалять состояние сразу. Вместо этого можно сохранить информацию о том, когда пользователь отключился, для возможной последующей обработки (например, повторная инициализация при новом подключении).
Зачем это? Assistant: охранение информации о том, когда пользователь отключился, для возможной последующей обработки имеет несколько важных целей и преимуществ:
-
Улучшение пользовательского опыта:
- Если информация о времени отключения сохраняется, то при следующем подключении клиента можно восстановить контекст сеанса. Например, можно продолжить диалог с того места, где клиент остановился, что создает более плавный и последовательный пользоватеский опыт.
-
Управление состоянием:
- Иногда состояние клиента может включать в себя важные данные, такие как активные действия, незавершенные проекты или текущие вопросы. Сохранение этого состояния позволяет избежать его потери при временных отключениях.
-
Оптимизация ресурсов:
- Когда вы не удаляете состояние клиента сразу, это может помочь в управлении ресурсами и нагрузкой на сервер. Например, если у вас есть логи или кэшированные ответы, связанные с состоянием клиента, вы сможете быстрее предоставлять эти данные при восстановлении подключения.
-
Аналитика и журналирование:
- Сохранение времени отключения может помочь в анализе поведения пользователей. Например, можно отслеживать, как долго клиенты остаются отключенными, и использовать эти данные для улучшения сервиса.
-
Обработка ошибок и восстановление:
- Если клиент сталкивается с проблемами, такими как временные отключения сети, информация о времени и состоянии отключения поможет в диагностике и восстановлении сеанса без необходимости начинать всё сначала.
-
Безопасность и контроль доступа:
- В некоторых случаях, знания о времени отключения могут быть использованы для управления доступом пользователя. Например, если пользователь отключается на длительное время, система может блокировать его доступ для безопасности, но при этом хранить информацию о его предыдущем состоянии.
-
Упрощение логики очистки:
- Вместо немедленного удаления всех данных о клиенте, можно создать более гибкую логику для удаления пользователей на основе их активности. Это уменьшит количество операций по созданию и удалению, что может быть особенно важно для масштабируемых приложений.
В сумме, такое управление состоянием становится особенно полезным в ситуациях, когда работа с клиентом подразумевает сложные взаимодействия и долгосрочные сессии. Это помогает создать более отзывчивую и персонализированную среду, что может значительно повысить удовлетворенность пользователей. User: Но пользователь не увидит разницы, ведь на сервере не хранится история его общения, все переписки с чатом хранятся только у клиента Assistant: история общения между клиентом и сервером полностью хранится только на стороне клиента и не сохраняется на сервере, то действительно, сохранение времени отключения на сервере не позволит непосредственно восстановить контекст общения или историю взаимодействия с чат-ботом. Тем не менее, этот подход все равно может быть полезным в ряде сценариев:
-
Технические ограничения клиента:
- В некоторых случаях, особенно если клиент может столкнуться с сбоями в работе или потерей данных (например, если приложение не сохраняет состояние при перезагрузке), информация о времени последнего отключения может помочь в диагностике проблем и улучшении стабильности приложения.
-
Сессии:
- При повторном подключении клиент может отправить запрос на восстановление состояния, если он таковое поддерживает. Зная, когда клиент отключился, сервер мог бы, например, управлять определенными временными ограничениями для операций (например, лимитом времени для завершения заданий).
-
Поддержка временных ограничений:
- Если сервер будет знать, как долго клиент не подключался, он сможет ограничить его действия (например, понижение уровня доступа к определенным функциям или ресурсам) на основании времени отключения.
-
Сбор статистики и аналитика:
- Сервер может собирать статистику о времени, когда пользователи чаще отключаются или переподключаются, что может помочь в улучшении механизма обслуживания или в выявлении проблем в работе.
-
Упрощение управление подключениями:
- С сохранением состояния (например, времени отключения) можно больше структурировать управление результатами заданий или запланированных задач в задаче. Это может помочь в дальнейшем улучшении сервиса.
-
Возможные будущие улучшения:
- Сохранение времени отключения может быть использовано, если в будущем вы решите дополнить функциональность, например, сохранить и управлять сессиями пользователей, что улучшит взаимодействие с клиентом и позволит восстанавливать разговор по запросу.
-
Улучшение безопасности:
- Хранение информации о времени отключения может служить для улучшения безопасности системы, позволяя контролировать активность клиентов и мониторить необычную активность (например, слишком частые переподключения).
Заключение
Даже если данные о взаимодействии чата на клиенте не хранятся, информация о времени отключения может быть использована на сервере для других целей. Тем не менее, если ваша система действительно не требует такой информации, можно рассмотреть возможность упрощения кода и управления состоянием клиента, чтобы избежать избыточного кода. Все зависит от ваших бизнес-потребностей и архитектуры системы. User: я вижу только одну причину сделать так - для статистики Assistant:
-
- Assistant
Вы правы, основная причина сохранять информацию о времени отключения клиента на сервере — это сбор статистики. Вот несколько конкретных аспектов, в которых эта информация может быть полезна:
Причины собирать статистику о времени отключения клиента
-
Анализ пользовательского поведения:
- Можно отслеживать, в какие моменты времени пользователи чаще всего отключаются и переподключаются. Это поможет понять, какие часы или дни являются наиболее активными для нашего сервера.
-
Улучшение качества обслуживания:
- Статистика отключений может предоставить информацию о частоте сбоев или проблем, с которыми сталкиваются пользователи. Если много клиентов отключаются в определенные временные рамки, это может указывать на проблемы с производительностью или доступностью сервера.
-
Определение времени активных сессий:
- Полученные данные могут использоваться для анализа средней продолжительности сеансов. Это может помочь в оптимизации спроса на серверные ресурсы и в планировании масштабирования системы.
-
Поиск узких мест:
- Если вы заметите, что время между отключением и повторным подключением увеличивается, это может сигнализировать о проблемах в вашей архитектуре или интерфейсе, на которые стоит обратить внимание.
-
Анализ эффективности функций:
- Отслеживание, как долго пользователи остаются подключенными, и как часто они отключаются, может помочь понять, фиксируется ли их интерес к функциям продукта. Если пользователи отключаются вскоре после выполнения определенных действий, это может потребовать дополнительного внимания.
-
Мониторинг нагрузки на сервер:
- Зная время отключения, вы можете лучше прогнозировать и управлять ресурсами вашего сервера в зависимости от ожиданий нагрузки.
-
Планирование обновлений и улучшений:
- Зная, сколько времени пользователи обычно проводят в вашем приложении и когда они отключаются, вы можете планировать обновления в неактивный для пользователей период.
Заключение
Хотя сохранение этой информации в первую очередь служит для статистики, оно может также помогать в управлении производительностью и улучшении сервиса. Если вы решите не хранить время отключений из-за простоты, это тоже вполне допустимо. Все зависит от ваших специфических бизнес-целей и требований к проекту.
-