ваше сообщение коммита

2025-09-30 16:41:15 +03:00
parent 7be6ab3655
commit 1b387a6d5d
14 changed files with 570 additions and 469 deletions
--- a/frontend/src/components/deployment/DeploymentWizard.vue
+++ b/frontend/src/components/deployment/DeploymentWizard.vue
@@ -310,14 +310,31 @@ const startDeployment = async () => {

 // Автозапуск деплоя при появлении компонента
 onMounted(() => {
+  console.log('🔧 [DeploymentWizard] onMounted вызван');
+  console.log('🔧 [DeploymentWizard] deploymentStatus.value:', deploymentStatus.value);
+  console.log('🔧 [DeploymentWizard] logs.value.length:', logs.value.length);
+  console.log('🔧 [DeploymentWizard] props:', props);
+  console.log('🔧 [DeploymentWizard] isDeploying.value:', isDeploying.value);
+  
+  // Добавляем тестовый лог сразу
+  addLog('🔧 [DeploymentWizard] Компонент смонтирован', 'info');
+  
  if (deploymentStatus.value === 'not_started') {
+    console.log('🔧 [DeploymentWizard] Запускаем автоматический деплой');
    addLog('🚀 Автоматически запускаем деплой...', 'info');
    startDeployment();
+  } else {
+    console.log('🔧 [DeploymentWizard] Деплой уже запущен, статус:', deploymentStatus.value);
  }
 });

 // Следим за новыми логами и скроллим вниз
-watch(logs, () => {
+watch(logs, (newLogs, oldLogs) => {
+  console.log('📝 [DeploymentWizard] Логи изменились:', { 
+    newLength: newLogs.length, 
+    oldLength: oldLogs?.length || 0,
+    lastLog: newLogs[newLogs.length - 1]
+  });
  scrollToBottom();
 }, { deep: true });

--- a/frontend/src/composables/useDeploymentWebSocket.js
+++ b/frontend/src/composables/useDeploymentWebSocket.js
@@ -33,11 +33,13 @@ export function useDeploymentWebSocket() {
  // Добавить лог
  const addLog = (message, type = 'info') => {
    const timestamp = new Date().toLocaleTimeString();
+    console.log('📝 [DeploymentWebSocket] Добавляем лог:', { timestamp, message, type });
    logs.value.push({
      timestamp,
      message,
      type
    });
+    console.log('📝 [DeploymentWebSocket] Всего логов:', logs.value.length);
  };
  
  // Очистить логи
@@ -48,8 +50,52 @@ export function useDeploymentWebSocket() {
  // Обработчик WebSocket сообщений
  const handleDeploymentUpdate = (data) => {
    console.log('🔄 [DeploymentWebSocket] Получено обновление:', data);
+    
+    // Проверяем, что data существует и имеет type
+    if (!data || !data.type) {
+      console.warn('🔄 [DeploymentWebSocket] Получены некорректные данные:', data);
+      return;
+    }
+    
    console.log('🔄 [DeploymentWebSocket] Текущий deploymentId:', deploymentId.value);
    console.log('🔄 [DeploymentWebSocket] deploymentId из данных:', data.deploymentId);
+    console.log('🔄 [DeploymentWebSocket] Тип сообщения:', data.type);
+    console.log('🔄 [DeploymentWebSocket] Есть ли log:', !!data.log);
+    
+    // Обрабатываем deployment_update сообщения
+    if (data.type === 'deployment_update' && data.data) {
+      const updateData = data.data;
+      console.log('🔄 [DeploymentWebSocket] Обрабатываем deployment_update:', updateData);
+      console.log('🔄 [DeploymentWebSocket] updateData.deploymentId:', updateData.deploymentId);
+      console.log('🔄 [DeploymentWebSocket] Текущий deploymentId:', deploymentId.value);
+      
+      // Проверяем, что это наш деплой
+      if (updateData.deploymentId && updateData.deploymentId !== deploymentId.value) {
+        console.log('🔄 [DeploymentWebSocket] Игнорируем - не наш deploymentId');
+        return;
+      }
+      
+      // Добавляем output как лог
+      if (updateData.output) {
+        console.log('🔄 [DeploymentWebSocket] Добавляем output как лог:', updateData.output);
+        addLog(updateData.output, 'info');
+      }
+      
+      // Обновляем статус и прогресс
+      if (updateData.status) deploymentStatus.value = updateData.status;
+      if (updateData.progress !== undefined) progress.value = updateData.progress;
+      if (updateData.message) currentStage.value = updateData.message;
+      if (updateData.result) deploymentResult.value = updateData.result;
+      
+      return;
+    }
+    
+    // Всегда обрабатываем логи, даже если deploymentId не совпадает
+    if (data.type === 'deployment_log' && data.log) {
+      console.log('🔄 [DeploymentWebSocket] Добавляем лог:', data.log.message);
+      addLog(data.log.message, data.log.type || 'info');
+      return;
+    }
    
    if (data.deploymentId !== deploymentId.value) {
      console.log('🔄 [DeploymentWebSocket] Игнорируем обновление - не наш deploymentId');
@@ -58,8 +104,31 @@ export function useDeploymentWebSocket() {
    
    switch (data.type) {
      case 'deployment_log':
-        if (data.log) {
-          addLog(data.log.message, data.log.type || 'info');
+        // Уже обработано выше, пропускаем
+        break;
+        
+      case 'deployment_update':
+        // Обработка deployment_update сообщений
+        if (data.data) {
+          const updateData = data.data;
+          if (updateData.stage) currentStage.value = updateData.stage;
+          if (updateData.progress !== undefined) progress.value = updateData.progress;
+          if (updateData.status) deploymentStatus.value = updateData.status;
+          if (updateData.result) deploymentResult.value = updateData.result;
+          if (updateData.error) error.value = updateData.error;
+          if (updateData.output) {
+            addLog(updateData.output, 'info');
+          }
+          if (updateData.message) {
+            addLog(updateData.message, 'info');
+          }
+          if (updateData.status === 'completed') {
+            isDeploying.value = false;
+            addLog('🎉 Деплой успешно завершен!', 'success');
+          } else if (updateData.status === 'failed') {
+            isDeploying.value = false;
+            addLog('💥 Деплой завершился с ошибкой!', 'error');
+          }
        }
        break;
        
@@ -98,15 +167,23 @@ export function useDeploymentWebSocket() {
  };

  // Подключаемся к WebSocket сразу при инициализации
+  console.log('🔌 [DeploymentWebSocket] Инициализация WebSocket...');
+  console.log('🔌 [DeploymentWebSocket] wsClient:', !!wsClient);
+  console.log('🔌 [DeploymentWebSocket] wsClient.subscribe:', typeof wsClient?.subscribe);
+  
  wsClient.connect();
  if (wsClient && typeof wsClient.subscribe === 'function') {
    wsClient.subscribe('deployment_update', handleDeploymentUpdate);
    console.log('🔌 [DeploymentWebSocket] Подключились к WebSocket при инициализации');
+  } else {
+    console.warn('🔌 [DeploymentWebSocket] WebSocket не доступен!');
  }
  
  // Начать отслеживание деплоя
  const startDeploymentTracking = (id) => {
    console.log('🎯 [DeploymentWebSocket] Начинаем отслеживание деплоя:', id);
+    console.log('🎯 [DeploymentWebSocket] WebSocket подключен:', !!wsClient);
+    console.log('🎯 [DeploymentWebSocket] Обработчики deployment_update:', wsClient?.handlers?.deployment_update?.length || 0);
    
    deploymentId.value = id;
    deploymentStatus.value = 'in_progress';
@@ -114,6 +191,13 @@ export function useDeploymentWebSocket() {
    clearLogs();
    
    // WebSocket уже подключен при инициализации
+    // Подписываемся на DLE адрес для получения логов деплоя
+    if (wsClient && typeof wsClient.subscribeToDeployment === 'function') {
+      // Используем временный DLE адрес для подписки на логи
+      const tempDleAddress = '0x0000000000000000000000000000000000000000';
+      wsClient.subscribeToDeployment(tempDleAddress);
+      console.log('🎯 [DeploymentWebSocket] Подписались на DLE адрес:', tempDleAddress);
+    }
    
    addLog('🔌 Подключено к WebSocket для получения обновлений деплоя', 'info');
  };
--- a/frontend/src/utils/websocket.js
+++ b/frontend/src/utils/websocket.js
@@ -22,15 +22,31 @@ class WebSocketClient {
    this.reconnectDelay = 1000;
    this.listeners = new Map();
    this.isConnected = false;
+    this.heartbeatInterval = null;
+    this.heartbeatTimeout = 30000; // 30 секунд
  }

  connect() {
+    // Если уже подключены, не создаем новое соединение
+    if (this.isConnected && this.ws && this.ws.readyState === WebSocket.OPEN) {
+      console.log('[WebSocket] Уже подключены, пропускаем');
+      return;
+    }
+
+    // Закрываем предыдущее соединение если есть
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
    try {
      // В Docker окружении используем Vite прокси для WebSocket
      // Используем относительный путь, чтобы Vite прокси мог перенаправить запрос на backend
      const wsUrl = window.location.protocol === 'https:' 
        ? 'wss://' + window.location.host + '/ws'
        : 'ws://' + window.location.host + '/ws';
+      
+      console.log('[WebSocket] Подключаемся к:', wsUrl);
      this.ws = new WebSocket(wsUrl);
      
      this.ws.onopen = () => {
@@ -38,6 +54,9 @@ class WebSocketClient {
        this.isConnected = true;
        this.reconnectAttempts = 0;
        
+        // Запускаем heartbeat
+        this.startHeartbeat();
+        
        // Уведомляем о подключении
        this.emit('connected');
      };
@@ -46,6 +65,12 @@ class WebSocketClient {
        try {
          const data = JSON.parse(event.data);
          
+          // Обрабатываем pong сообщения для heartbeat
+          if (data.type === 'pong') {
+            console.log('[WebSocket] Получен pong, соединение активно');
+            return;
+          }
+          
          // Логируем все deployment_update сообщения для отладки
          if (data.type === 'deployment_update') {
            console.log('[WebSocket] Получено deployment_update:', data);
@@ -56,10 +81,14 @@ class WebSocketClient {
          if (this.listeners.has(data.type)) {
            console.log(`[WebSocket] Вызываем обработчики для типа: ${data.type}, количество: ${this.listeners.get(data.type).length}`);
            this.listeners.get(data.type).forEach(callback => {
-              callback(data.data);
+              // Передаем весь объект data, а не только data.data
+              callback(data);
            });
          } else {
-            console.log(`[WebSocket] Нет обработчиков для типа: ${data.type}`);
+            // Не логируем сообщения о деплое, они обрабатываются в других компонентах
+            if (!data.type?.startsWith('deployment_') && !data.type?.startsWith('module_') && data.type !== 'subscribed' && data.type !== 'pong') {
+              console.log(`[WebSocket] Нет обработчиков для типа: ${data.type}`);
+            }
          }
        } catch (error) {
          console.error('[WebSocket] Ошибка парсинга сообщения:', error);
@@ -86,17 +115,50 @@ class WebSocketClient {
  scheduleReconnect() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
-      console.log(`[WebSocket] Попытка переподключения ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
+      console.log(`[WebSocket] Попытка переподключения ${this.reconnectAttempts}/${this.maxReconnectAttempts} через ${this.reconnectDelay * this.reconnectAttempts}мс`);
      
      setTimeout(() => {
-        this.connect();
+        if (!this.isConnected) {
+          this.connect();
+        }
      }, this.reconnectDelay * this.reconnectAttempts);
    } else {
      console.error('[WebSocket] Превышено максимальное количество попыток переподключения');
+      // Сбрасываем счетчик через 30 секунд для повторных попыток
+      setTimeout(() => {
+        this.reconnectAttempts = 0;
+        console.log('[WebSocket] Сброс счетчика переподключений, можно попробовать снова');
+      }, 30000);
+    }
+  }
+
+  startHeartbeat() {
+    // Очищаем предыдущий интервал
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+    
+    // Отправляем ping каждые 30 секунд
+    this.heartbeatInterval = setInterval(() => {
+      if (this.isConnected && this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.send('ping', { timestamp: Date.now() });
+      } else {
+        console.log('[WebSocket] Соединение потеряно, переподключаемся...');
+        this.isConnected = false;
+        this.scheduleReconnect();
+      }
+    }, this.heartbeatTimeout);
+  }
+
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
    }
  }

  disconnect() {
+    this.stopHeartbeat();
    if (this.ws) {
      this.ws.close();
      this.ws = null;
--- a/frontend/src/views/smartcontracts/ModulesView.vue
+++ b/frontend/src/views/smartcontracts/ModulesView.vue
@@ -24,9 +24,9 @@
        <div class="header-content">
          <div class="title-section">
            <h1>Модули DLE</h1>
-            <div class="websocket-status" :class="{ connected: isModulesWSConnected }" title="WebSocket соединение для обновления модулей">
-              <i class="fas fa-circle" :class="isModulesWSConnected ? 'fa-solid' : 'fa-light'"></i>
-              <span>{{ isModulesWSConnected ? 'Подключено' : 'Отключено' }}</span>
+            <div class="websocket-status" :class="{ connected: isWSConnected }" title="WebSocket соединение для обновления модулей">
+              <i class="fas fa-circle" :class="isWSConnected ? 'fa-solid' : 'fa-light'"></i>
+              <span>{{ isWSConnected ? 'Подключено' : 'Отключено' }}</span>
            </div>
          </div>
          <p v-if="selectedDle">{{ selectedDle.name }} ({{ selectedDle.symbol }}) - {{ selectedDle.dleAddress }}</p>
@@ -734,6 +734,7 @@ import {
  getDeploymentStatus
 } from '../../services/modulesService.js';
 import api from '../../api/axios';
+import wsClient from '../../utils/websocket';

 // Определяем props
 const props = defineProps({
@@ -783,14 +784,9 @@ const deploymentStep = ref(0);
 const progressPercentage = ref(0);
 const deploymentLogs = ref([]);

-// WebSocket соединение
-const deploymentWS = ref(null);
+// WebSocket соединение (используем глобальный wsClient)
 const isWSConnected = ref(false);

-// WebSocket для обновления модулей
-const modulesWS = ref(null);
-const isModulesWSConnected = ref(false);
-
 // Debounce для предотвращения частых вызовов loadModules
 let loadModulesTimeout = null;

@@ -1039,62 +1035,54 @@ function formatDate(dateString) {

 // Функции для работы с WebSocket
 function connectWebSocket() {
-  if (deploymentWS.value && deploymentWS.value.readyState === WebSocket.OPEN) {
-    return;
+  // Используем глобальный wsClient
+  wsClient.connect();
+  isWSConnected.value = wsClient.isConnected;
+  
+  // Подписываемся на события модулей
+  wsClient.subscribe('subscribed', handleWebSocketMessage);
+  wsClient.subscribe('deployment_started', handleWebSocketMessage);
+  wsClient.subscribe('deployment_status', handleWebSocketMessage);
+  wsClient.subscribe('deployment_log', handleWebSocketMessage);
+  wsClient.subscribe('deployment_finished', handleWebSocketMessage);
+  wsClient.subscribe('error', handleWebSocketMessage);
+  wsClient.subscribe('modules_updated', handleWebSocketMessage);
+  wsClient.subscribe('module_verified', handleWebSocketMessage);
+  wsClient.subscribe('module_deployment_error', handleWebSocketMessage);
+  
+  // Подписываемся на деплой для текущего DLE
+  if (dleAddress.value) {
+    console.log('[ModulesView] Подписываемся на DLE:', dleAddress.value);
+    wsClient.ws.send(JSON.stringify({
+      type: 'subscribe',
+      dleAddress: dleAddress.value
+    }));
+  } else {
+    console.warn('[ModulesView] dleAddress не найден для подписки');
  }
-
-  const wsUrl = `ws://localhost:8000/ws`;
-  deploymentWS.value = new WebSocket(wsUrl);
-
-  deploymentWS.value.onopen = () => {
-    console.log('[ModulesView] WebSocket соединение установлено');
-    isWSConnected.value = true;
-    
-    // Подписываемся на деплой для текущего DLE
-    if (dleAddress.value) {
-      deploymentWS.value.send(JSON.stringify({
-        type: 'subscribe',
-        dleAddress: dleAddress.value
-      }));
-    }
-  };
-
-  deploymentWS.value.onmessage = (event) => {
-    try {
-      const data = JSON.parse(event.data);
-      handleWebSocketMessage(data);
-    } catch (error) {
-      console.error('[ModulesView] Ошибка парсинга WebSocket сообщения:', error);
-    }
-  };
-
-  deploymentWS.value.onclose = () => {
-    console.log('[ModulesView] WebSocket соединение закрыто');
-    isWSConnected.value = false;
-    
-    // Переподключаемся через 3 секунды
-    setTimeout(() => {
-      if (showDeploymentModal.value) {
-        connectWebSocket();
-      }
-    }, 3000);
-  };
-
-  deploymentWS.value.onerror = (error) => {
-    console.error('[ModulesView] Ошибка WebSocket:', error);
-    isWSConnected.value = false;
-  };
 }

 function handleWebSocketMessage(data) {
  console.log('[ModulesView] WebSocket сообщение:', data);
  
+  // Проверяем, что data существует и имеет type
+  if (!data || !data.type) {
+    console.warn('[ModulesView] Получены некорректные данные WebSocket:', data);
+    return;
+  }
+  
+  console.log('[ModulesView] Тип сообщения:', data.type);
+  console.log('[ModulesView] DLE адрес в сообщении:', data.dleAddress);
+  console.log('[ModulesView] Текущий DLE адрес:', dleAddress.value);
+  
  switch (data.type) {
    case 'subscribed':
      addLog('info', `Подписка на деплой активирована для DLE: ${data.dleAddress}`);
      break;
      
    case 'deployment_started':
+      console.log('[ModulesView] Показываем модалку деплоя');
+      showDeploymentModal.value = true;
      deploymentStep.value = 1;
      progressPercentage.value = 10;
      moduleDeploymentStatus.value = 'starting';
@@ -1107,6 +1095,7 @@ function handleWebSocketMessage(data) {
      break;
      
    case 'deployment_log':
+      console.log('[ModulesView] Получен лог деплоя:', data.log);
      addLog(data.log.type, data.log.message);
      break;
      
@@ -1131,6 +1120,31 @@ function handleWebSocketMessage(data) {
    case 'error':
      addLog('error', data.message);
      break;
+      
+    // Обработка сообщений модулей
+    case 'modules_updated':
+      // Автоматически обновляем список модулей
+      console.log('[ModulesView] Получено уведомление об обновлении модулей');
+      loadModulesDebounced();
+      break;
+      
+    case 'module_verified':
+      console.log('[ModulesView] Модуль верифицирован:', data);
+      addLog('success', `Модуль ${data.moduleType} верифицирован в сети ${data.network}`);
+      break;
+      
+    case 'module_deployment_error':
+      console.log('[ModulesView] Ошибка деплоя модуля:', data);
+      addLog('error', `Ошибка деплоя модуля ${data.moduleType}: ${data.error}`);
+      break;
+      
+    default:
+      console.log('[ModulesView] Неизвестный тип сообщения:', data.type, data);
+      // Для неизвестных типов просто логируем
+      if (data.log) {
+        addLog(data.log.type || 'info', data.log.message);
+      }
+      break;
  }
 }

@@ -1150,103 +1164,22 @@ function updateDeploymentProgress(data) {
 }

 function disconnectWebSocket() {
-  if (deploymentWS.value) {
-    deploymentWS.value.close();
-    deploymentWS.value = null;
-    isWSConnected.value = false;
-  }
-}
-
-// Функции для работы с WebSocket модулей
-function connectModulesWebSocket() {
-  if (modulesWS.value && modulesWS.value.readyState === WebSocket.OPEN) {
-      return;
-    }
-
-  const wsUrl = `ws://localhost:8000/ws`;
-  modulesWS.value = new WebSocket(wsUrl);
-
-  modulesWS.value.onopen = () => {
-    console.log('[ModulesView] WebSocket модулей соединение установлено');
-    isModulesWSConnected.value = true;
-    
-    // Подписываемся на обновления модулей для текущего DLE
-    if (dleAddress.value) {
-      modulesWS.value.send(JSON.stringify({
-        type: 'subscribe',
-        dleAddress: dleAddress.value
-      }));
-    }
-  };
-
-  modulesWS.value.onmessage = (event) => {
-    try {
-      const data = JSON.parse(event.data);
-      handleModulesWebSocketMessage(data);
-  } catch (error) {
-      console.error('[ModulesView] Ошибка парсинга WebSocket сообщения модулей:', error);
-    }
-  };
-
-  modulesWS.value.onclose = () => {
-    console.log('[ModulesView] WebSocket модулей соединение закрыто');
-    isModulesWSConnected.value = false;
-    
-    // Переподключаемся через 5 секунд
-    setTimeout(() => {
-      connectModulesWebSocket();
-    }, 5000);
-  };
-
-  modulesWS.value.onerror = (error) => {
-    console.error('[ModulesView] Ошибка WebSocket модулей:', error);
-    isModulesWSConnected.value = false;
-  };
-}
-
-function handleModulesWebSocketMessage(data) {
-  console.log('[ModulesView] WebSocket модулей сообщение:', data);
+  // Отписываемся от всех событий модулей
+  wsClient.unsubscribe('subscribed', handleWebSocketMessage);
+  wsClient.unsubscribe('deployment_started', handleWebSocketMessage);
+  wsClient.unsubscribe('deployment_status', handleWebSocketMessage);
+  wsClient.unsubscribe('deployment_log', handleWebSocketMessage);
+  wsClient.unsubscribe('deployment_finished', handleWebSocketMessage);
+  wsClient.unsubscribe('error', handleWebSocketMessage);
+  wsClient.unsubscribe('modules_updated', handleWebSocketMessage);
+  wsClient.unsubscribe('module_verified', handleWebSocketMessage);
+  wsClient.unsubscribe('module_deployment_error', handleWebSocketMessage);
  
-  // Обрабатываем deployment_log в модульном WebSocket
-  if (data.type === 'deployment_log') {
-    addLog(data.log.type, data.log.message);
-    return;
-  }
-  
-  // Обрабатываем только сообщения, связанные с модулями, не с деплоем
-  if (data.type && data.type.startsWith('deployment_')) {
-    console.log('[ModulesView] Пропускаем сообщение о деплое в модульном WebSocket');
-    return;
-  }
-  
-  switch (data.type) {
-    case 'modules_updated':
-      // Автоматически обновляем список модулей
-      console.log('[ModulesView] Получено уведомление об обновлении модулей');
-      loadModulesDebounced();
-      break;
-      
-    case 'module_verified':
-      // Обновляем статус верификации конкретного модуля
-      console.log(`[ModulesView] Модуль ${data.moduleType} верифицирован`);
-      loadModulesDebounced();
-      break;
-      
-    case 'module_status_changed':
-      // Обновляем статус модуля
-      console.log(`[ModulesView] Статус модуля ${data.moduleType} изменен`);
-      loadModulesDebounced();
-      break;
-  }
+  isWSConnected.value = false;
 }

-function disconnectModulesWebSocket() {
-  if (modulesWS.value) {
-    modulesWS.value.close();
-    modulesWS.value = null;
-    isModulesWSConnected.value = false;
-  }
-}
+
+

 // Функции для работы с модальным окном
 function openDeploymentModal(moduleType) {
@@ -1356,14 +1289,13 @@ onMounted(() => {
  loadDleData();
  loadModules(); // Первоначальная загрузка без debounce
  
-  // Подключаемся к WebSocket для обновления модулей
-  connectModulesWebSocket();
+  // Подключаемся к WebSocket (объединенное соединение)
+  connectWebSocket();
 });

 onUnmounted(() => {
  // Отключаем WebSocket при размонтировании компонента
  disconnectWebSocket();
-  disconnectModulesWebSocket();
 });
 </script>