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

const { gpt, gptweb } = require("./API/gpt"); const { dalle } =…

  1. 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);
    
    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий
    		connected: true, // Статус подключения
        };
    }
    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) => {
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.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);
    		}
    		
    		// Увеличиваем общий счетчик запросов
            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');
    });
    

    });

    // GPT4o async function call(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//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]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 1 минуту

    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');

    rateLimiter тут это глобальная переменная. Для каждого клиента, которые подключаются c разных IP будет свое ограничение по IP? Assistant: , ваш код настроен так, чтобы для каждого клиента, который подключается с разных IP, было своё ограничение по количеству запросов. Давайте рассмотрим, как это происходит:

    1. Глобальный экземпляр rateLimiter: В вашем коде вы создаете один общий объект rateLimiter, который использует конструктор RateLimiterMemory. Это означает, что все пользователи будут использовать одно и то же хранилище для ограничений, и, следовательно, ограничения будут применяться ко всем клиентам независимо от их IP.

    2. Уникальность для каждого IP: В вашем обработчике сообщений (внутри ws.on('message', ...)) вы применяете код, который использует rateLimiter.consume(userIP). Это означает, что вы применяете ограничения на основе IP-адреса, что позволяет каждому IP иметь своё собственное ограничение по количеству запросов. Если один IP превышает лимит, пользователь с этого IP будет временно заблокирован, не влияя на других пользователей.

    Таким образом, да, ваше текущее решение позволяет каждому клиенту (или, точнее, каждому уникальному IP-адресу) получать свои индивидуальные лимиты. Однако, если несколько клиентов подключаются с одного и того же IP-адреса, они будут делить один лимит.

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

    const limiters = {}; // Объект для хранения ограничителей по каждому клиенту
    
    // Внутри ws.on('connection', ...)
    if (!limiters[userId]) { 
        limiters[userId] = new RateLimiterMemory({
            points: 20, // разрешается 20 запросов
            duration: 1, // за 1 секунду
            blockDuration: 60 // время блокировки в секундах
        });
    }
    

    Эти изменения дадут каждому уникальному клиенту свои ограничения, основанные на идентификаторе пользователя, и не будут зависеть от IP-адреса. User: console.log("IP-адрес - ", userIP, "Время подключения - ", Date()); Найди ошибку, время подключения должно быть текущее время Assistant: вашем коде вызов Date() возвращает объект Date, который нужно преобразовать в строковое представление, чтобы корректно отобразить время подключения в консоли. Чтобы это сделать, вы можете использовать метод toString() или другие методы форматирования для объектов Date.

    Вы можете изменить строку с возвращаемым временем подключения на следующую:

    console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toString());
    

    Или, если вы хотите получить более сжатый формат времени, вы можете использовать метод toISOString():

    console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
    

    Это создаст строку, представляющую текущее время в удобочитаемом виде или в формате ISO 8601, соответственно. В обоих случаях вы получите актуальное время подключения. User: Какой должна быть посещаемость сайта в среднем чтобы образовалась ситуация когда подключены несколько клиентов с одного IP и с этого IP превышен лимит запросов 20 в секунду, если сайт доступен по всей России Assistant: рассмотреть сценарий, в котором несколько клиентов на одном IP-адресе превышают лимит запросов, установленный на уровне 20 запросов в секунду, нужно учесть несколько факторов:

    1. Характер использования сайта:

    • Временные пики: Если ваш сайт получает значительное количество трафика в определенные моменты времени (например, акции, новостные события), это увеличивает вероятность того, что несколько пользователей подключатся с одного IP.
    • Количество пользователей на сайте: Важно понимать, сколько пользователей фактически используют ваш сайт в одно и то же время. Пользователи могут находиться в разных регионах и даже с разных устройств, но если они используют тот же маршрутизатор (например, в домашних или офисных условиях), они будут иметь один и тот же внешний IP-адрес.

    2. Средний трафик:

    • Количество активных пользователей: Если ваш сайт имеет активную пользовательскую базу, которая превышает несколько сотен человек в секунду, шансы на то, что несколько пользователей будут с одного IP, увеличиваются. Например, если ваш сайт обслуживает 1,000 активных пользователей с одним IP-адресом.
    • Средняя частота запросов: Если каждый пользователь отправляет запросы с частотой 1 раз в 2-3 секунды, 20 запросов в секунду могут быть достигнуты очень быстро, если в сети несколько пользовательских устройств.

    3. Статистика о Интернете:

    • Динамика интернет-пользователей: В России больше 100 миллионов пользователей, и многие из них находятся за NAT (например, в домашние сети, Wi-Fi кафе и офисы), которые делят один IP-адрес. При популярном контенте или при массированном тестировании нагрузки (например, разработка, мониторинг) вы можете столкнуться с ситуацией, когда несколько пользователей с одной и той же NAT используют сайт параллельно.

    Примерные расчеты:

    • Если ваш сайт в среднем привлекает 1,000 уникальных посетителей в час, это будет около 16 уникальных пользователей в минуту (1,000 / 60). Если на 10 пользователей приходится один IP (например, домашние пользователи), это значит, что 10 пользователей могут подключиться одновременно с одного IP-адреса. Если каждый из них активен и делает 1 запрос в секунду, общий лимит в 20 запросов может быть достигнут.

    • В случае, если ваш сайт получает 100,000 посещений в день (что вполне реально даже для небольших сайтов), это будет около 1,000 пользователей в день, при этом 100-500 активными моментами увеличивается вероятность одновременного превышения лимитов.

    Заключение:

    Чтобы свести к минимуму проблемы с превышением лимитов, вы могли бы рассмотреть возможность создания более гибкой системы ограничения запросов или применять разные стратегии, такие как распределенное кэширование, настройка уровня API обработки и использование механизма очередей для обработки запросов. User: Т.е. мой код неэффективен если предполагается что сайт доступен всем в России Assistant: код, в котором используется ограничение на уровне 20 запросов в секунду для каждого IP-адреса, может столкнуться с некоторыми проблемами производительности и доступности, особенно если сайт имеет высокий трафик и множество активных пользователей. Вот основные моменты, которые стоит учитывать:

    1. Ограничение по IP

    Ваше текущее ограничение по IP подразумевает, что все пользователи, подключающиеся с одного IP (например, из одного домашнего роутера, офисной сети или публичной Wi-Fi сети), будут сталкиваться с одним и тем же лимитом. Это может привести к ситуации, когда несколько пользователей, использующих один IP, не смогут сделать больше 20 запросов в секунду, даже если на сайте много свободных ресурсов для обработки запросов.

    2. Распределенные подключения

    В крупных городах и регионах России, особенно в местах с большой плотностью населения (например, офисные здания, колледжи, кафе), несколько пользователей могут подключаться через одну сеть. В таких случаях может возникнуть ситуация, когда пользователи, ожидая ответа от сервера, будут блокироваться из-за ограничения по IP.

    3. Потребительский трафик

    Если ваш сайт ожидает большой трафик (например, миллионы посещений в день), то даже небольшой процент пользователей, подключающихся через один и тот же IP-адрес, может привести к частым превышениям лимитов. В таком случае, пользователи, попадающие в блокировку, могут испытывать негативный опыт, что повлияет на общую удовлетворенность и лояльность к вашему сервису.

    4. Альтернативные решения

    Для повышения эффективности обработки заявок вы можете рассмотреть следующие подходы:

    • Индивидуальные ограничения: Рассмотрите возможность применения индивидуального лимита для каждого уникального пользователя (например, в зависимости от userId, sessionId или токена аутентификации).

    • Групповые и временные ограничения: Настройте временные ограничения на уровне групп пользователей, чтобы обеспечить некоторую гибкость между пользователями, которые могут подключаться с одного и того же IP.

    • Кэширование запросов: Рассмотрите возможность кэширования ответов на часто задаваемые запросы, чтобы снизить нагрузку на сервер и улучшить время отклика.

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

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

    Заключение

    Ваше текущее решение работает, но в условиях большой посещаемости и различных сценариев использования может быть эффективно доработано для улучшения пользовательского опыта. Рассмотрите возможность внесения изменений в архитектуру вашего приложения, чтобы более гибко управлять нагрузкой и запросами пользователей. 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;
    //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
    const userHeaders = req.headers;
    
    // Проверяем Origin
    if (!checkOrigin(userHeaders.origin, ws)) {
        return; // Если отклонено, выходим из обработчика
    }
    
    // Увеличиваем общий счетчик подключений
    stats.totalConnections++;
    
    console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin);
    
    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий
    		connected: true, // Статус подключения
        };
    }
    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) => {
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.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);
    		}
    		
    		// Увеличиваем общий счетчик запросов
            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');
    });
    

    });

    // GPT4o async function call(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//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]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 1 минуту

    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');

    убери из этого кода rate-limiter-flexible и проверки связанные с ним. Оставь ограничения только с помощью Bottleneck Assistant: можете удалить rate-limiter-flexible и связанные с ним проверки из вашего кода, оставив только ограничения, управляемые с помощью Bottleneck. Вот модифицированная версия вашего кода без использования rate-limiter-flexible`:

    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 { 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'; 
    
    // Создайте 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);
        
        // Инициализируем состояние клиента, если его еще нет
        if (!clientActions[userId]) {
            clientActions[userId] = {
                actions: [], // Массив для хранения действий
                connected: true, // Статус подключения
            };
        } 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) => {
            // Проверяем, является ли сообщение экземпляром Buffer
            if (Buffer.isBuffer(message))
                message = message.toString(); 
            try {
                // Преобразуем строку JSON обратно в объект
                message = JSON.parse(message); 
                // Получаем историю чата из запроса
                let messages = message.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);
                }
                
                // Увеличиваем общий счетчик запросов
                stats.totalRequests++;
                
                // Используем Bottleneck для управления количеством запросов
                limiters[userId].schedule(() => {
                    // Отправка запроса на сервер чата
                    return call(messages, ws);
                }).catch(error => {
                    const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
                    // Отправка ответа клиенту
                    sendMessage(ws, response);
                });
            } catch (error) {
                console.error('Error parsing JSON:', error);
                const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
                // Отправка ответа клиенту
                sendMessage(ws, response);
            }
        });
    
        ws.on('close', () => {
            clientActions[userId].connected = false; // Обновление статуса подключения
            delete clientActions[userId]; // Удаление состояния клиента
            delete limiters[userId]; // Удаление ограничителя для данного клиента
            console.log('Client ', userId, ' disconnected');
        });
    });
    
    // GPT4o
    async function call(messages, ws) {
        try {
            let fullResponse = ""; // Переменная для результата
            
            console.log('Запрос клиента:', messages[messages.length - 1]); 
            gpt4o({
                messages: messages,
                markdown: false
            }, (result) => {
                try {
                    if (!result.finish) {
                        // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
                        fullResponse = result.message || "";
                    } 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]; // Удаляем пользователя из памяти, если он отключен
                delete limiters[userId];
            }
        });
    }, 10 * 60 * 1000); // Очистка каждые 10 минут
    
    
    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');
    

    Изменения, внесенные в код:

    1. Удален код, связанный с rate-limiter-flexible и его проверки.
    2. Оставлены только ограничения, управляемые с помощью Bottleneck.

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

  2. Assistant

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

    1. Использование Cookies

    1. Уникальный идентификатор с использованием Cookies: Вместо того, чтобы полагаться на userId, отправляемый самим клиентом, вы можете использовать cookie для хранения уникального идентификатора пользователя. Это позволяет сохранять идентификатор между сессиями и не позволяет клиенту легко изменять его. При каждом новом подключении вы можете проверять, существует ли уже cookie с идентификатором, и обрабатывать его соответственно.
    ws.on('connection', (ws, req) => {
        const cookies = req.headers.cookie;
        let userId;
    
        // Попробуйте извлечь userId из cookie
        if (cookies) {
            const cookieArray = cookies.split('; ');
            const userIdCookie = cookieArray.find(cookie => cookie.startsWith('userId='));
            
            if (userIdCookie) {
                userId = userIdCookie.split('=')[1];
            }
        }
    
        // Если cookie нет, создайте новый userId и установите его в cookie
        if (!userId) {
            userId = generateUniqueUserId(); // Функция для генерации уникального идентификатора
            ws.send(`Set-Cookie: userId=${userId}; HttpOnly; Path=/;`);
        }
    
        // Дальше используйте userId как прежде...
    });
    

    2. Генерация Уникального Идентификатора на Сервере

    • Вместо того, чтобы генерировать userId на клиенте, вы можете создавать его на сервере и отправлять его клиенту после подключения. Это снизит вероятность подделки идентификатора.
    const crypto = require('crypto');
    
    function generateServerId() {
        return crypto.randomBytes(16).toString('hex'); // Генерация уникального идентификатора
    }
    
    // Использование в WebSocket
    ws.on('connection', (ws, req) => {
        const userId = generateServerId();
        // ... остальной код
    });
    

    3. Анонимизация с использованием IP-адресов

    • Можно использовать IP-адреса для отслеживания пользователей, но это потребует дополнительных мер, чтобы избежать блокировки целых регионов. Вы можете ограничить количество запросов с одного IP-адреса. Комбинируйте это с уникальными идентификаторами, чтобы создать более сложную систему ограничения.

    4. Наблюдение за Поведением Пользователей

    • Если вы собираетесь использовать анонимные идентификаторы, вы можете наблюдать за поведением пользователей. Например, вы можете вести учет количества запросов от каждого уникального идентификатора, а также о количестве запросов, поступающих с одного IP-адреса.

    5. Временные ограничительные меры

    • Используйте временные ограничения (например, временные блокировки на несколько минут при превышении лимита) для борьбы с злоупотреблениями. Способы реализации могут включать использование TTL (time-to-live) для хранения временных меток на сервере.

    Заключение

    Для борьбы с обходом ограничений на анонимном сайте рекомендуется сочетать несколько предложенных стратегий. Особенно полезно использование cookies или генерация уникальных идентификаторов на сервере, чтобы снизить вероятность создания поддельных идентификаторов. Таким образом, вы сможете уважать анонимность пользователей и одновременно сохранять контроль над частотой запросов.