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

User: 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: когда возможна ситуация, что подключаются несколько пользователей с одним IP Assistant: итуации, когда несколько пользователей могут подключаться с одного и того же IP-адреса, могут возникать в различных сценариях. Вот несколько примеров:

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

    2. Мобильные сети: При использовании мобильных сетей несколько устройств могут подключаться к интернету через один и тот же базовый станцию (сторону 3G/4G/5G связи), и в этом случае также могут быть случаи, когда несколько пользователей получат один и тот же IP-адрес.

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

    4. Клиенты, использующие прокси-серверы: Подобно VPN, если несколько клиентов используют один и тот же прокси-сервер, они будут отправлять запросы к интернету с одного и того же IP.

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

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

    1. Защита от злоупотреблений: Ограничения по IP полезны для предотвращения злоупотреблений или атак, например, DDoS-атак (распределённые атаки на отказ в обслуживании) или других форм злоупотребления, когда один и тот же IP-адрес может отправить слишком много запросов за короткий промежуток времени. Это помогает поддерживать стабильность сервиса и предотвращать недостаток ресурсов.

    2. Управление трафиком: Если у вас есть ресурс, который может быть перегружен запросами (например, API или веб-приложение), ограничения по IP могут помочь в управлении трафиком и предотвратить перегрузку сервера.

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

    4. Наблюдение за пользователями: При анализе использования API или сервиса вы можете отслеживать, какие IP-адреса генерируют наибольшее количество запросов и принимать меры для их управления, если это необходимо.

    5. Безопасность: Ограничения по IP также могут помочь в плане безопасности, обеспечивая, что определенные действия или доступ к ресурсам доступны только из определенных доверенных IP-адресов.

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

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

  2. Assistant

    Установить эффективный лимит для защиты от злоупотреблений и атак, таких как DDoS, с учетом пользователей, подключающихся через общий IP-адрес, можно, следуя принципам, описанным ниже:

    Рекомендации по установлению лимитов:

    1. Анализ поведения:

      • Перед тем как устанавливать лимиты, проанализируйте типичное использование вашего сервиса. Знайте, сколько запросов обычно отправляет один пользователь за определенный период времени. Это позволит вам определить базовые уровни использования.
    2. Ограничение на уровне IP:

      • Начните с установления разумного лимита. Например, 10 – 30 запросов в минуту на IP-адрес. Это число может варьироваться в зависимости от вашего сервиса. Если пользователи отправляют более 30 запросов в минуту, это может быть подозрительно.
    3. Заблокировка:

      • Для IP-адресов, которые превышают лимит, можно установить блокировку на определенный период (например, 1-5 минут). Это предотвратит злоупотребления, но также нужно учитывать, что заблокированные IP могут затрагивать легитимных пользователей.
    4. Динамическое регулирование:

      • Реализуйте динамическое регулирование лимитов в зависимости от состояния сервиса. Если ваш сервис сталкивается с высоким трафиком или подозрительной активностью, вы можете временно снизить лимиты.
    5. Идентификация пользователей:

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

      • После превышения лимита отправляйте сообщения пользователям с разъяснением причин ограничения. Это поможет сохранить доверие и повысить понимание среди пользователей.
    7. Логи и мониторинг:

      • Ведите логи действий пользователей и реагируйте на аномалии. Наблюдайте за тем, как разные IP-адреса используют ваш сервис, чтобы получать информацию о типичном и подозрительном поведении.
    8. Распределенные системы:

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

    Пример возможной настройки:

    • 10 запросов в минуту на IP-адрес
    • 60 запросов за 10 минут (опция для временных увеличений в зависимости от инфраструктуры)
    • Блокировка на 5 минут при превышении лимита более чем 2 раза за 10 минут

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

    Итог:

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