caddy lables

ZerodepDockerHttpClient

How_To.md

@@ -0,0 +1,50 @@
+Для того чтобы найти и завершить процесс, занимающий определенный порт (в данном случае 8082), в большинстве операционных систем используются стандартные терминальные команды.
+
+Вот пошаговая инструкция для Linux/macOS и Windows.
+
+🐧 Linux и macOS
+Самый быстрый способ — использовать утилиту lsof или fuser.
+
+1. Поиск процесса
+   Выполните команду в терминале, чтобы узнать PID (идентификатор процесса):
+
+Bash
+sudo lsof -i :8082
+PID — это число в соответствующей колонке, которое нам понадобится.
+
+Или с помощью fuser:
+
+Bash
+sudo fuser 8082/tcp
+2. Завершение процесса
+   Используйте команду kill, подставив найденный PID:
+
+Bash
+kill -9 PID
+Примечание: Флаг -9 (SIGKILL) принудительно завершает процесс. Если вы хотите закрыть его «мягко», используйте kill PID без флага.
+
+Лайфхак (одной командой):
+Если нужно найти и сразу убить:
+
+Bash
+sudo kill -9 $(sudo lsof -t -i:8082)
+🪟 Windows
+В Windows это делается через командную строку (CMD) или PowerShell.
+
+1. Поиск процесса
+   Откройте терминал и введите:
+
+DOS
+```bash
+netstat -ano | findstr :8082
+```
+В последней колонке вы увидите PID. Например: 1234.
+
+2. Завершение процесса
+   Используйте команду taskkill:
+
+DOS
+```bash
+taskkill /PID 1234 /F
+```
+/F — принудительное завершение.

build.gradle

@@ -35,8 +35,8 @@ dependencies {
     implementation 'com.github.docker-java:docker-java-api:3.3.6'
     implementation 'com.github.docker-java:docker-java-core:3.3.6'
 
-    // Транспорт (HTTP Client 5) — именно он нужен для DockerConfig.java
-    implementation 'com.github.docker-java:docker-java-transport-httpclient5:3.3.6'
+    // Тот самый транспорт, который решит проблему с unix-сокетом
+    implementation 'com.github.docker-java:docker-java-transport-zerodep:3.4.0'
 
     // Spring Boot Starter для STOMP WebSockets
     implementation 'org.springframework.boot:spring-boot-starter-websocket'

jambotron-ui/src/app/helpers/custom-http-interceptor.ts

@@ -15,11 +15,9 @@ export class CustomHttpInterceptor implements HttpInterceptor {
     return next.handle(req)
       .pipe(tap((event: HttpEvent<any>) => {
         if (event instanceof HttpResponse) {
+          console.log('Interceptor увидел ответ:', event.url, 'status:', event.status, 'ok:', event.ok);
           this.spinnerService.hide();
         }
-      }, (error) => {
-        this.spinnerService.hide();
       }))
-      ;
   }
 }

jambotron-ui/src/app/modules/user-module/project-details.component/project-details.component.html

@@ -16,14 +16,103 @@
   <div class="containers-grid">
     @for (container of containers; track container.name) {
       <mat-card class="container-card">
-        <mat-card-content class="card-layout">
-          <div class="card-left">
-            <span class="c-name">{{ container.name }}</span>
-            <span class="c-image">{{ container.image }}</span>
+        <mat-card-content class="flex flex-col p-4">
+
+          <div class="card-layout flex w-full justify-between items-start gap-4">
+
+            <div class="card-left flex-1 min-w-0">
+              <span class="c-name block text-base font-bold text-gray-150 truncate" [title]="container.name">
+                {{ container.name }}
+              </span>
+              <span class="c-image block text-xs text-gray-500 font-mono mt-0.5 truncate" [title]="container.image">
+                {{ container.image }}
+              </span>
+
+              @if (containerStats.get(container.id); as stats) {
+                <div class="stats-row" style="font-size: 11px; color: #888; margin-top: 6px;">
+                  CPU: {{ stats.cpuUsage | number:'1.1-1' }}% | RAM: {{ stats.memoryPercent | number:'1.0-0' }}%
                 </div>
-          <div class="card-right">
+              }
+            </div>
+
+            <div class="card-right flex flex-col align-items-end justify-between items-end gap-2 shrink-0">
+              <div class="actions-row flex gap-1">
+                <button mat-icon-button (click)="toggleContainer(container)"
+                        [color]="container.state === 'running' ? 'warn' : 'primary'" class="!w-8 !h-8 !line-height-[32px]">
+                  <mat-icon class="!text-lg">{{ container.state === 'running' ? 'stop' : 'play_arrow' }}</mat-icon>
+                </button>
+                <button mat-icon-button (click)="restartContainer(container.id)" style="color: #ffbd2e;" class="!w-8 !h-8 !line-height-[32px]">
+                  <mat-icon class="!text-lg">refresh</mat-icon>
+                </button>
+              </div>
+
+              <div class="flex items-center gap-2 mt-1">
                 <div class="state-dot" [class.running]="container.state === 'running'"></div>
-            <span class="uptime">{{ container.status }}</span>
+                <span class="uptime text-xs text-gray-400 font-mono">{{ container.status }}</span>
+              </div>
+            </div>
+
+          </div>
+
+          <div class="w-full mt-4 block clear-both">
+            <div class="p-3 bg-gray-900/30 rounded-lg border border-gray-800 flex flex-col justify-center min-h-[64px]">
+
+              <div *ngIf="!editingDomains[container.id]" class="flex items-center justify-between gap-4 w-full">
+                <div class="flex flex-col gap-0.5">
+                  <span class="text-[10px] uppercase tracking-wider font-bold text-gray-500">Маршрутизация сети:</span>
+
+                  <ng-container *ngIf="getContainerDomain(container) as domain; else noDomain">
+                    <div class="flex items-center gap-2 mt-1">
+                      <a [href]="'https://' + domain" target="_blank" class="text-xs font-semibold text-blue-400 hover:text-blue-300 hover:underline flex items-center gap-1 font-mono">
+                        <mat-icon class="!w-3.5 !h-3.5 !text-sm text-blue-400 shrink-0">open_in_new</mat-icon>
+                        <span class="truncate max-w-[200px]">{{ domain }}</span>
+                      </a>
+                      <span class="text-[10px] text-gray-400 font-mono bg-gray-950 px-2 py-0.5 rounded border border-gray-850 shrink-0">
+          порт {{ getContainerPort(container) }}
+        </span>
+                    </div>
+                  </ng-container>
+
+                  <ng-template #noDomain>
+                    <span class="text-xs text-gray-600 italic mt-1">Локальный стек (нет публичного прокси)</span>
+                  </ng-template>
+                </div>
+
+                <button mat-icon-button (click)="startEditDomain(container)" class="!w-8 !h-8 text-gray-500 hover:text-blue-400 transition shrink-0" title="Изменить настройки Caddy">
+                  <mat-icon class="!text-lg">edit</mat-icon>
+                </button>
+              </div>
+
+              <div *ngIf="editingDomains[container.id]" class="w-full flex flex-col gap-2 pt-1">
+                <div class="flex items-center justify-between border-b border-gray-800 pb-2 mb-1">
+                  <span class="text-[10px] uppercase tracking-wider font-bold text-blue-400 flex items-center gap-1">
+                    <mat-icon class="!w-3.5 !h-3.5 !text-sm">router</mat-icon> Настройка шлюза шлюза
+                  </span>
+                  <div class="flex gap-2">
+                    <button mat-flat-button color="primary" (click)="saveDomainConfig(container)" class="!min-w-0 !px-3 !h-7 !line-height-[28px] !text-xs font-bold">
+                      OK
+                    </button>
+                    <button mat-button (click)="cancelEditDomain(container.id)" class="!min-w-0 !px-3 !h-7 !line-height-[28px] !text-xs !text-gray-400">
+                      Отмена
+                    </button>
+                  </div>
+                </div>
+
+                <div class="flex gap-3 w-full pt-1">
+                  <mat-form-field appearance="outline" class="flex-[2] !text-xs font-mono" subscriptSizing="dynamic">
+                    <mat-label>Поддомен</mat-label>
+                    <input matInput type="text" [(ngModel)]="tempSubdomain" placeholder="example" class="lowercase" />
+                    <span matSuffix class="text-gray-600 pr-1 text-[11px] font-mono pointer-events-none">.jambotron.com</span>
+                  </mat-form-field>
+
+                  <mat-form-field appearance="outline" class="flex-1 !text-xs font-mono" subscriptSizing="dynamic">
+                    <mat-label>Порт</mat-label>
+                    <input matInput type="number" [(ngModel)]="tempPort" placeholder="80" min="1" max="65535" />
+                  </mat-form-field>
+                </div>
+              </div>
+
+            </div>
           </div>
         </mat-card-content>
       </mat-card>

jambotron-ui/src/app/modules/user-module/project-details.component/project-details.component.scss

@@ -104,3 +104,19 @@
     overflow-y: auto;
   }
 }
+
+.mat-mdc-form-field {
+  width: 100%;
+  --mdc-outlined-text-field-container-shape: 6px;
+  --mdc-outlined-text-field-input-text-color: #e5e7eb;
+  --mdc-outlined-text-field-focus-input-text-color: #ffffff;
+  --mdc-outlined-text-field-label-text-color: #6b7280;
+  --mdc-outlined-text-field-focus-label-text-color: #3b82f6;
+  --mdc-outlined-text-field-outline-color: #1f2937;
+  --mdc-outlined-text-field-focus-outline-color: #2563eb;
+
+  .mat-mdc-text-field-wrapper {
+    background-color: rgba(3, 7, 18, 0.6) !important; // Глубокий тёмный фон bg-gray-950
+  }
+}
+

jambotron-ui/src/app/modules/user-module/project-details.component/project-details.component.ts

@@ -3,24 +3,36 @@ import { Component, OnInit, OnDestroy, ViewChild, ElementRef, AfterViewChecked }
 import { ActivatedRoute, Router } from '@angular/router';
 import { CommonModule } from '@angular/common';
 import { Subscription, timer, switchMap, catchError, of } from 'rxjs';
-import { ProjectService, Project, DockerContainer, ProjectDetailResponse } from '../../../services/project.service';
+import {
+  ProjectService,
+  Project,
+  DockerContainer,
+  ProjectDetailResponse,
+  ContainerStats
+} from '../../../services/project.service';
 import { MatIconModule } from '@angular/material/icon';
 import { MatButtonModule } from '@angular/material/button';
 import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
 import { MatDividerModule } from '@angular/material/divider';
 import { MatCard, MatCardContent } from '@angular/material/card';
+import {FormsModule} from '@angular/forms';
+import {MatInputModule} from '@angular/material/input';
+import {MatFormFieldModule} from '@angular/material/form-field';
 
 @Component({
   selector: 'app-project-details',
   standalone: true,
   imports: [
     CommonModule,
+    FormsModule,
     MatIconModule,
     MatButtonModule,
     MatProgressSpinnerModule,
     MatDividerModule,
     MatCard,
-    MatCardContent
+    MatCardContent,
+    MatFormFieldModule, // <-- Включаем в сборку созидания
+    MatInputModule      // <-- Включаем в сборку созидания
   ],
   templateUrl: './project-details.component.html',
   styleUrls: ['./project-details.component.scss']
@@ -66,23 +78,39 @@ export class ProjectDetailsComponent implements OnInit, OnDestroy, AfterViewChec
     });
   }
 
-  // Опитування стану контейнерів кожні 5 секунд
   private startMonitoring(id: string): void {
     this.pollingSub = timer(0, 5000).pipe(
       switchMap(() => this.projectService.getProjectContainers(id).pipe(
-        catchError(() => of([])) // У разі помилки повертаємо порожній список
+        catchError(() => of([]))
       ))
     ).subscribe({
       next: (data: DockerContainer[]) => {
+        const activeIds = data.map(c => c.id);
+
+        // Очистка подписок для исчезнувших контейнеров
+        this.statsSubs.forEach((sub, containerId) => {
+          if (!activeIds.includes(containerId)) {
+            sub.unsubscribe();
+            this.statsSubs.delete(containerId);
+            this.containerStats.delete(containerId);
+          }
+        });
+
         this.containers = data;
 
-        // Якщо з'явилися контейнери і ми ще не підключені до логів — підключаємося
+        // Инициация подписок для новых запущенных контейнеров
+        this.containers.forEach(container => {
+          if (container.state === 'running' && !this.statsSubs.has(container.id)) {
+            this.subscribeToContainerStats(container.id);
+          }
+        });
+
+        // Логика подключения к логам (сохранена)
         if (this.containers.length > 0 && !this.logSub) {
           const mainContainer = this.containers.find(c => c.state === 'running') || this.containers[0];
           this.connectLogs(mainContainer.id);
         }
-      },
-      error: (err) => console.error('Помилка моніторингу:', err)
+      }
     });
   }
 
@@ -111,6 +139,16 @@ export class ProjectDetailsComponent implements OnInit, OnDestroy, AfterViewChec
   deploy(): void {
     if (this.project) {
       this.loading = true;
+      this.logs = []; // Очищаем окно перед новым деплоем
+
+      // Подписываемся на системный поток деплоя
+      this.projectService.connectToDeployLogs(this.project.id).subscribe({
+        next: (line) => {
+          this.logs.push(line);
+          if (this.logs.length > 200) this.logs.shift();
+        }
+      });
+
       this.projectService.deployProject(this.project.id).subscribe({
         next: () => this.loading = false,
         error: () => this.loading = false
@@ -148,7 +186,12 @@ export class ProjectDetailsComponent implements OnInit, OnDestroy, AfterViewChec
   ngOnDestroy(): void {
     this.pollingSub?.unsubscribe();
     this.logSub?.unsubscribe();
-    this.projectService.disconnectLogs(); // Закриваємо з'єднання з брокером
+
+    // Очищаем все активные подписки на метрики контейнеров
+    this.statsSubs.forEach(sub => sub.unsubscribe());
+    this.statsSubs.clear();
+
+    this.projectService.disconnectLogs(); // Закрываем основное STOMP соединение
   }
 
   // Форматування для відображення кольорів у терміналі
@@ -167,4 +210,186 @@ export class ProjectDetailsComponent implements OnInit, OnDestroy, AfterViewChec
     }
     return formatted;
   }
+
+
+  containerStats: Map<string, ContainerStats> = new Map();
+  private statsSubs: Map<string, Subscription> = new Map();
+
+  // Новый метод для живых метрик
+  private subscribeToContainerStats(containerId: string): void {
+    const sub = this.projectService.connectToStats(containerId).subscribe({
+      next: (stats) => {
+        this.containerStats.set(containerId, stats);
+      },
+      error: (err) => console.error(`Stats error for ${containerId}:`, err)
+    });
+    this.statsSubs.set(containerId, sub);
+  }
+
+  // Переключение состояния (Start/Stop)
+  toggleContainer(container: DockerContainer): void {
+    if (!this.project) return;
+
+    const obs = container.state === 'running'
+      ? this.projectService.stopContainer(this.project.id, container.id)
+      : this.projectService.startContainer(this.project.id, container.id);
+
+    obs.subscribe({
+      next: () => console.log(`Статус контейнера ${container.id} изменен`),
+      error: (err) => console.error('Ошибка управления:', err)
+    });
+  }
+
+// Рестарт
+  restartContainer(containerId: string): void {
+    if (this.project) {
+      this.projectService.restartContainer(this.project.id, containerId).subscribe({
+        next: () => console.log(`Контейнер ${containerId} перезапущен`),
+        error: (err) => console.error('Ошибка рестарта:', err)
+      });
+    }
+  }
+// ==========================================
+  //  CADDY ROUTING & INLINE EDITING MANAGEMENT
+  // ==========================================
+
+  // Хранит состояние редактирования для каждого контейнера: { [containerId]: boolean }
+  editingDomains: { [key: string]: boolean } = {};
+
+  // Временные переменные для хранения ввода пользователя во время инлайн-редактирования
+  tempSubdomain: string = '';
+  tempPort: number = 80;
+
+  /**
+   * Безопасно извлекает имя сервиса (например, 'web') из имени Docker-контейнера.
+   * Проверяет префиксы как по ID, так и по Name проекта.
+   */
+  getServiceName(container: any): string | null {
+    if (!container) return null;
+
+    // 1. Идеальный путь созидания: берем стабильный ID из меток Docker
+    if (container.labels && container.labels['jambotron.service.id']) {
+      return container.labels['jambotron.service.id'];
+    }
+
+    // 2. Если меток нет, переходим к парсингу имени контейнера
+    const containerName = container.name || '';
+
+    // Проверяем базовый маркер нашей системы
+    if (!containerName.startsWith('jambotron-')) {
+      console.warn(`[Jambotron] Контейнер не принадлежит системе Jambotron: ${containerName}`);
+      return null;
+    }
+
+    // Отрезаем индекс реплики (-1, -2) и префикс "jambotron-"
+    let cleanName = containerName.replace(/-\d+$/, '').replace(/^jambotron-/, '');
+
+    // 3. Проверяем массив известных имен сервисов из YAML
+    const validServices: string[] = this.config?.serviceNames || [];
+    if (validServices.length > 0) {
+      const match = validServices.find((service: string) => cleanName.endsWith(service) || cleanName.includes(service));
+      if (match) return match;
+    }
+
+    // 4. Финальный пуленепробиваемый фоллбэк для старых контейнеров (вырезаем имя проекта)
+    // Для "test-web" -> cleanName = "test-web" -> parts = ['test', 'web'] -> возвращает "web"
+    // const parts = cleanName.split('-');
+    // if (parts.length >= 2) {
+    //   return parts.slice(1).join('-');
+    // }
+
+    
+    // Только если вообще ничего не получилось извлечь — выводим реальное предупреждение
+    if (!cleanName) {
+      console.warn(`[Jambotron] Не удалось определить имя сервиса для: ${containerName}`);
+      return null;
+    }
+
+    return cleanName;
+  }
+
+  /**
+   * Возвращает текущий сформированный домен для вывода в UI
+   */
+  getContainerDomain(container: any): string | null {
+    const serviceId = this.getServiceName(container);
+
+    if (!serviceId || !this.config?.serviceConfigs) return null;
+
+    // Ищем настройки в мапе по системному ID (например, srv-0)
+    const serviceConfig = this.config.serviceConfigs[serviceId];
+    return serviceConfig && serviceConfig.subdomain ? `${serviceConfig.subdomain}.jambotron.com` : null;
+  }
+
+  /**
+   * Возвращает порт сервиса из конфигурации MongoDB
+   */
+  getContainerPort(container: any): number {
+    const serviceId = this.getServiceName(container);
+    if (!serviceId || !this.config?.serviceConfigs) return 80;
+
+    // Ищем настройки в мапе по системному ID (например, srv-0)
+    const serviceConfig = this.config.serviceConfigs[serviceId];
+    return serviceConfig && serviceConfig.port ? serviceConfig.port : 80;
+  }
+
+  /**
+   * Активация режима редактирования.
+   */
+  startEditDomain(container: any) {
+    // ПЕРЕДАЕМ КОНТЕЙНЕР ЦЕЛИКОМ, а не container.name
+    const serviceName = this.getServiceName(container);
+    if (!serviceName) {
+      console.warn(`[Jambotron] Не удалось определить имя сервиса для:`, container);
+      return;
+    }
+
+    // Переключаем реактивный флаг видимости формы в шаблоне
+    this.editingDomains[container.id] = true;
+
+    // Подтягиваем текущие сохранённые значения из локального объекта конфигурации config
+    const currentConfig = this.config?.serviceConfigs?.[serviceName];
+    this.tempSubdomain = currentConfig?.subdomain || '';
+    this.tempPort = currentConfig?.port || 80;
+  }
+
+  /**
+   * Сохранение изменённого поддомена и порта в MongoDB базы данных
+   */
+  saveDomainConfig(container: any) {
+    // ПЕРЕДАЕМ КОНТЕЙНЕР ЦЕЛИКОМ, а не container.name
+    const serviceName = this.getServiceName(container);
+    if (!serviceName || !this.project?.id || !this.config) return;
+
+    if (!this.config.serviceConfigs) {
+      this.config.serviceConfigs = {};
+    }
+
+    const subdomainClean = this.tempSubdomain.trim().toLowerCase();
+
+    if (!subdomainClean) {
+      // Если поле очищено — удаляем проксирование
+      delete this.config.serviceConfigs[serviceName];
+    } else {
+      this.config.serviceConfigs[serviceName] = {
+        subdomain: subdomainClean,
+        port: this.tempPort || 80
+      };
+    }
+
+    // Отправка монолитного конфига на бэкенд
+    this.projectService.updateProjectConfig(this.project.id, this.config).subscribe({
+      next: () => {
+        this.editingDomains[container.id] = false;
+        console.log(`[Caddy] Маршрут для сервиса ${serviceName} успешно сохранён.`);
+      },
+      error: (err) => {
+        console.error('Ошибка обновления конфигурации проекта:', err);
+        alert(err.error?.message || 'Не удалось применить конфигурацию шлюза.');
+      }
+    });
+  }
+  cancelEditDomain(containerId: string) {
+    this.editingDomains[containerId] = false;
+  }
 }

jambotron-ui/src/app/services/project.service.ts

@@ -40,6 +40,29 @@ export interface ProjectDetailResponse {
   };
 }
 
+export interface ContainerStats {
+  containerId: string;
+  cpuUsage: number;
+  memoryUsage: number;
+  memoryLimit: number;
+  memoryPercent: number;
+}
+// Описание структуры конфигурации доменов созидания
+export interface ServiceSettings {
+  subdomain?: string;
+  port?: number;
+}
+
+export interface ProjectConfig {
+  id?: string;
+  projectId: string;
+  rawComposeContent: string;
+  serviceNames: string[];
+  serviceConfigs: { [key: string]: ServiceSettings };
+  version?: number;
+}
+
+
 @Injectable({
   providedIn: 'root'
 })
@@ -123,4 +146,64 @@ export class ProjectService {
   getProjectContainers(projectId: string): Observable<DockerContainer[]> {
     return this.http.get<DockerContainer[]>(`${this.baseUrl}/user/projects/${projectId}/containers`);
   }
+  // Добавь в project.service.ts
+  public connectToDeployLogs(projectId: string): Observable<string> {
+    const deploySubject = new Subject<string>();
+    const socket = new SockJS(`${this.baseUrl}/ws-jambotron`);
+
+    const client = new Client({
+      webSocketFactory: () => socket,
+      onConnect: () => {
+        // Подписываемся на системный топик деплоя
+        client.subscribe(`/topic/deploy/${projectId}`, (message: IMessage) => {
+          deploySubject.next(message.body);
+        });
+      }
+    });
+
+    client.activate();
+    return deploySubject.asObservable();
+  }
+
+  public connectToStats(containerId: string): Observable<ContainerStats> {
+    const statsSubject = new Subject<ContainerStats>();
+    const socket = new SockJS(`${this.baseUrl}/ws-jambotron`);
+    const client = new Client({
+      webSocketFactory: () => socket,
+      onConnect: () => {
+        client.subscribe(`/topic/stats/${containerId}`, (message) => {
+          statsSubject.next(JSON.parse(message.body));
+        });
+        // Сигнал к началу сбора
+        client.publish({ destination: '/app/start-stats', body: containerId });
+      }
+    });
+    client.activate();
+    return statsSubject.asObservable();
+  }
+
+  restartContainer(projectId: string, containerId: string): Observable<void> {
+    return this.http.post<void>(`${this.baseUrl}/user/projects/${projectId}/containers/${containerId}/restart`, {});
+  }
+
+  stopContainer(projectId: string, containerId: string): Observable<void> {
+    return this.http.post<void>(`${this.baseUrl}/user/projects/${projectId}/containers/${containerId}/stop`, {});
+  }
+
+  startContainer(projectId: string, containerId: string): Observable<void> {
+    return this.http.post<void>(`${this.baseUrl}/user/projects/${projectId}/containers/${containerId}/start`, {});
+  }
+
+  // Получить конфигурацию поддоменов из MongoDB
+  getProjectConfig(projectId: string): Observable<ProjectConfig> {
+    return this.http.get<ProjectConfig>(`${this.baseUrl}/user/projects/${projectId}/config`);
+  }
+
+  // Обновить конфигурацию (сохранить измененные домены и порты)
+  updateProjectConfig(projectId: string, config: ProjectConfig): Observable<string> {
+    return this.http.put(`${this.baseUrl}/user/projects/${projectId}/config`, config, {
+      responseType: 'text'
+    });
+  }
+
 }

src/main/java/com/jambotronGroup/jambotron/DTOs/ContainerStatsDTO.java

@@ -0,0 +1,18 @@
+package com.jambotronGroup.jambotron.DTOs;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ContainerStatsDTO {
+    private String containerId;
+    private double cpuUsage;      // Процент загрузки CPU
+    private long memoryUsage;     // Использование памяти в байтах
+    private long memoryLimit;     // Лимит памяти в байтах
+    private double memoryPercent; // Процент использования памяти
+}

src/main/java/com/jambotronGroup/jambotron/controllers/LogController.java

@@ -1,6 +1,9 @@
 package com.jambotronGroup.jambotron.controllers;
 
 import com.jambotronGroup.jambotron.console.DockerLogService;
+import com.jambotronGroup.jambotron.projects.DockerStatsService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.messaging.handler.annotation.MessageMapping;
 import org.springframework.stereotype.Controller;
 
@@ -9,8 +12,13 @@ public class LogController {
 
     private final DockerLogService dockerLogService;
 
-    public LogController(DockerLogService dockerLogService) {
+    private static final Logger _logger = LoggerFactory.getLogger(LogController.class);
+
+    private final DockerStatsService dockerStatsService;
+
+    public LogController(DockerLogService dockerLogService, DockerStatsService dockerStatsService) {
         this.dockerLogService = dockerLogService;
+        this.dockerStatsService = dockerStatsService;
     }
 
     // Когда клиент шлет сообщение на /app/start-logs
@@ -18,4 +26,10 @@ public class LogController {
     public void handleStartLogs(String containerId) {
         dockerLogService.streamLogs(containerId);
     }
+
+    @MessageMapping("/start-stats")
+    public void handleStartStats(String containerId) {
+        _logger.info("Начинаем сбор метрик для контейнера: {}", containerId);
+        dockerStatsService.startStreamingStats(containerId);
+    }
 }

src/main/java/com/jambotronGroup/jambotron/controllers/ProjectController.java

@@ -1,12 +1,13 @@
 package com.jambotronGroup.jambotron.controllers;
 
 import com.jambotronGroup.jambotron.model.Project;
-import com.jambotronGroup.jambotron.model.ProjectStatus;
+import com.jambotronGroup.jambotron.model.ProjectConfig;
 import com.jambotronGroup.jambotron.model.User;
 import com.jambotronGroup.jambotron.projects.ContainerStatus;
 import com.jambotronGroup.jambotron.projects.ProjectCreateRequest;
 import com.jambotronGroup.jambotron.projects.ProjectDetailResponse;
 import com.jambotronGroup.jambotron.projects.ProjectService;
+import com.jambotronGroup.jambotron.repository.ProjectConfigRepository;
 import com.jambotronGroup.jambotron.repository.UserRepository;
 import com.jambotronGroup.jambotron.security.AuthenticationFacade;
 import jakarta.validation.Valid;
@@ -15,7 +16,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.security.access.AccessDeniedException;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -29,181 +29,141 @@ public class ProjectController {
     private static final Logger _logger = LoggerFactory.getLogger(ProjectController.class);
 
     private final ProjectService projectService;
-
+    private final ProjectConfigRepository configRepository; // <-- Это то, что я чуть не забыла!
     private final UserRepository userRepository;
     private final AuthenticationFacade authenticationFacade;
 
-    //-------------------- Просмотр и Dashboard ----------------------------
+    // --- Просмотр списка и дашборд ---
 
-    /**
-     * Получение списка проектов текущего пользователя (Dashboard)[cite: 2, 3].
-     */
     @GetMapping("/user/projects")
     public ResponseEntity<List<Project>> getUserProjects() {
-        try {
         User user = getCurrentUser();
         List<Project> projects = projectService.findAllByOwnerId(user.getId());
-
-            if (projects.isEmpty()) {
-                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
-            }
-            return new ResponseEntity<>(projects, HttpStatus.OK);
-        } catch (Exception e) {
-            _logger.error("Error fetching user projects", e);
-            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
-        }
+        return projects.isEmpty() ? new ResponseEntity<>(HttpStatus.NO_CONTENT) : ResponseEntity.ok(projects);
     }
 
-    /**
-     * Детали проекта (Project + Config). Доступно владельцу или админу.
-     */
     @GetMapping("/user/projects/{id}/details")
     public ResponseEntity<ProjectDetailResponse> getProjectDetails(@PathVariable UUID id) {
-        try {
-            User user = getCurrentUser();
-            boolean isAdmin = checkIfAdmin(user);
-
-            // Метод сервиса сам проверит права владельца, если isAdmin = false
-            ProjectDetailResponse details = projectService.getProjectDetailsSecure(
-                    id,
-                    user.getId(),
-                    isAdmin
-            );
-
-            return new ResponseEntity<>(details, HttpStatus.OK);
-        } catch (AccessDeniedException e) {
-            return new ResponseEntity<>(HttpStatus.FORBIDDEN);
-        } catch (Exception e) {
-            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        }
-    }
-
-    //-------------------- Управление Жизненным Циклом (User & Admin) ----------------------------
-
-    /**
-     * Деплой проекта (Docker Compose Up). Доступно владельцу или админу[cite: 1, 4].
-     */
-    @PostMapping("/user/projects/{id}/deploy")
-    public ResponseEntity<String> deployProject(@PathVariable UUID id) {
-        // Получаем текущего пользователя (твой метод)
-        User user = getCurrentUser();
-
-        // Используем метод сервиса findById, а не репозиторий напрямую!
-        Project project = projectService.findById(id);
-
-        // Выполняем проверку безопасности (через String.valueOf, как мы выяснили)
-        if (checkIfAdmin(user) ||
-                String.valueOf(project.getUser().getId()).equals(String.valueOf(user.getId()))) {
-
-            // ВАЖНО: В твоем сервисе метод называется deployProject(Project project)
-            projectService.deployProject(project);
-            return ResponseEntity.ok("Процесс созидания запущен...");
-        }
-
-        return ResponseEntity.status(403).body("Access Denied");
-    }
-
-    /**
-     * Остановка проекта (Docker Compose Down). Доступно владельцу или админу[cite: 1, 4].
-     */
-    @PostMapping("/user/projects/{id}/stop")
-    public ResponseEntity<String> stopProject(@PathVariable UUID id) {
         User user = getCurrentUser();
         Project project = projectService.findById(id);
 
-        if (!checkIfAdmin(user) && !project.getUser().getId().equals(String.valueOf(user.getId()))) {
-            return new ResponseEntity<>("Access Denied", HttpStatus.FORBIDDEN);
+        if (!hasAccess(user, project)) return new ResponseEntity<>(HttpStatus.FORBIDDEN);
+
+        // Тянем конфиг из Mongo для детального отображения
+        ProjectConfig config = configRepository.findByProjectId(String.valueOf(id))
+                .orElseThrow(() -> new RuntimeException("Конфигурация созидания не найдена"));
+
+        return ResponseEntity.ok(new ProjectDetailResponse(project, config));
     }
 
-        projectService.stopProject(project);
-        project.setStatus(ProjectStatus.STOPPED);
-        projectService.save(project);
-
-        return ResponseEntity.ok("Project stopped: " + project.getName());
-    }
-
-    /**
-     * Удаление проекта (Очистка Docker + Файлы + БД). Доступно владельцу или админу[cite: 1, 2].
-     */
-    @DeleteMapping("/user/projects/{id}")
-    public ResponseEntity<String> deleteProject(@PathVariable UUID id) {
-        User user = getCurrentUser();
-        Project project = projectService.findById(id);
-
-        // Безопасная проверка владельца (уже ставшая стандартом для нашего "сосуда")
-        if (checkIfAdmin(user) ||
-                String.valueOf(project.getUser().getId()).equals(String.valueOf(user.getId()))) {
-
-            _logger.info("Начато полное удаление проекта: {}", id);
-            projectService.deleteProject(id); // Вызов того самого метода из ProjectService_2.java
-            return ResponseEntity.ok("Проект полностью удален из системы");
-        }
-
-        return ResponseEntity.status(403).body("Access Denied");
-    }
-
-    //-------------------- Администрирование PaaS ----------------------------
-
-    /**
-     * Список всех проектов системы для глобального мониторинга[cite: 2].
-     */
-    @GetMapping("/admin/projects/all")
-    public ResponseEntity<List<Project>> getAllProjectsForAdmin() {
-        User user = getCurrentUser();
-        if (!checkIfAdmin(user)) {
-            return new ResponseEntity<>(HttpStatus.FORBIDDEN);
-        }
-
-        List<Project> allProjects = projectService.findAllProjectsForAdmin();
-        return new ResponseEntity<>(allProjects, HttpStatus.OK);
-    }
-
-    //-------------------- Создание и Конфигурация ----------------------------
+    // --- Создание и обновление ---
 
     @PostMapping("/user/projects")
     public ResponseEntity<Project> create(@Valid @RequestBody ProjectCreateRequest request) {
-
         User user = getCurrentUser();
         Project newProject = projectService.createProject(request.name(), request.rawComposeContent(), user);
         return ResponseEntity.status(HttpStatus.CREATED).body(newProject);
     }
 
     @PutMapping("/user/projects/{id}/config")
-    public ResponseEntity<String> updateConfig(@PathVariable UUID id, @RequestBody String newContent) {
+    public ResponseEntity<String> updateConfig(@PathVariable UUID id, @RequestBody ProjectConfig newConfig) {
         User user = getCurrentUser();
         Project project = projectService.findById(id);
 
-        if (!checkIfAdmin(user) && !project.getUser().getId().equals(String.valueOf(user.getId()))) {
-            return new ResponseEntity<>("Access Denied", HttpStatus.FORBIDDEN);
+        if (!hasAccess(user, project)) return new ResponseEntity<>("Access Denied", HttpStatus.FORBIDDEN);
+
+        try {
+            // Передаем весь объект для валидации поддоменов
+            projectService.updateProjectConfig(id, newConfig);
+            return ResponseEntity.ok("Конфигурация обновлена.");
+        } catch (RuntimeException e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
+        }
     }
 
-        projectService.updateProjectConfig(id, newContent);
-        return ResponseEntity.ok("Configuration updated.");
+    // --- Управление всем проектом ---
+
+    @PostMapping("/user/projects/{id}/deploy")
+    public ResponseEntity<String> deployProject(@PathVariable UUID id) {
+        User user = getCurrentUser();
+        Project project = projectService.findById(id);
+
+        if (!hasAccess(user, project)) return ResponseEntity.status(403).body("Access Denied");
+
+        projectService.deployProject(project);
+        return ResponseEntity.ok("Процесс созидания запущен...");
     }
 
-    //-------------------- Вспомогательные методы ----------------------------
+    @PostMapping("/user/projects/{id}/stop")
+    public ResponseEntity<String> stopProject(@PathVariable UUID id) {
+        User user = getCurrentUser();
+        Project project = projectService.findById(id);
+        if (!hasAccess(user, project)) return new ResponseEntity<>(HttpStatus.FORBIDDEN);
 
-    private User getCurrentUser() {
-        return userRepository.findById(authenticationFacade.getUserDetails().getId())
-                .orElseThrow(() -> new RuntimeException("Current user not found"));
+        projectService.stopProject(project);
+        return ResponseEntity.ok("Проект остановлен.");
     }
 
-    private boolean checkIfAdmin(User user) {
-        return user.getRoles() != null && (user.getRoles().equals("ADMIN") || user.getRoles().equals("ROLE_ADMIN"));
+    @DeleteMapping("/user/projects/{id}")
+    public ResponseEntity<String> deleteProject(@PathVariable UUID id) {
+        User user = getCurrentUser();
+        Project project = projectService.findById(id);
+        if (!hasAccess(user, project)) return ResponseEntity.status(403).body("Access Denied");
+
+        projectService.deleteProject(id);
+        return ResponseEntity.ok("Проект удален.");
     }
 
+    // --- Управление отдельными контейнерами ---
+
     @GetMapping("/user/projects/{id}/containers")
     public ResponseEntity<List<ContainerStatus>> getContainers(@PathVariable UUID id) {
         User user = getCurrentUser();
         Project project = projectService.findById(id);
-
-        // Применяем нашу "золотую формулу" сравнения ID
-        if (checkIfAdmin(user) ||
-                String.valueOf(project.getUser().getId()).equals(String.valueOf(user.getId()))) {
+        if (!hasAccess(user, project)) return ResponseEntity.status(403).build();
 
         return ResponseEntity.ok(projectService.getProjectContainers(id));
     }
 
-        return ResponseEntity.status(403).build();
+    // Рестарт конкретного контейнера
+    @PostMapping("/user/projects/{projectId}/containers/{containerId}/restart")
+    public ResponseEntity<Void> restartContainer(
+            @PathVariable("projectId") UUID projectId,
+            @PathVariable("containerId") String containerId) {
+        projectService.restartContainer(projectId, containerId);
+        return ResponseEntity.ok().build();
+    }
+
+    // Остановка конкретного контейнера
+    @PostMapping("/user/projects/{projectId}/containers/{containerId}/stop")
+    public ResponseEntity<Void> stopContainer(
+            @PathVariable("projectId") UUID projectId,
+            @PathVariable("containerId") String containerId) {
+        projectService.stopContainer(projectId, containerId);
+        return ResponseEntity.ok().build();
+    }
+
+    // Запуск конкретного контейнера
+    @PostMapping("/user/projects/{projectId}/containers/{containerId}/start")
+    public ResponseEntity<Void> startContainer(
+            @PathVariable("projectId") UUID projectId,
+            @PathVariable("containerId") String containerId) {
+        projectService.startContainer(projectId, containerId);
+        return ResponseEntity.ok().build();
+    }
+
+    // --- Утилиты ---
+
+    private boolean hasAccess(User user, Project project) {
+        return checkIfAdmin(user) || String.valueOf(project.getUser().getId()).equals(String.valueOf(user.getId()));
+    }
+
+    private User getCurrentUser() {
+        return userRepository.findById(authenticationFacade.getUserDetails().getId())
+                .orElseThrow(() -> new RuntimeException("User not found"));
+    }
+
+    private boolean checkIfAdmin(User user) {
+        return user.getRoles() != null && user.getRoles().contains("ADMIN");
     }
 }

src/main/java/com/jambotronGroup/jambotron/dockerClient/DockerConfig.java

@@ -4,8 +4,9 @@ import com.github.dockerjava.api.DockerClient;
 import com.github.dockerjava.core.DefaultDockerClientConfig;
 import com.github.dockerjava.core.DockerClientConfig;
 import com.github.dockerjava.core.DockerClientImpl;
-import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;
+
 import com.github.dockerjava.transport.DockerHttpClient;
+import com.github.dockerjava.zerodep.ZerodepDockerHttpClient;
 import com.jambotronGroup.jambotron.controllers.FileBrowserTreeController;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -13,6 +14,8 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import java.net.URI;
+
 @Configuration
 public class DockerConfig {
 
@@ -23,23 +26,25 @@ public class DockerConfig {
 
     @Bean
     public DockerClient dockerClient() {
-        String hostToUse = dockerHost;
-        if (hostToUse.contains("2375") || hostToUse.equals("localhost")) {
-            hostToUse = "unix:///var/run/docker.sock";
-        }
+        // 1. Четко определяем путь. Если переменная пуста или кривая - ставим дефолт.
+        String hostPath = (dockerHost != null && !dockerHost.contains("2375"))
+                ? dockerHost
+                : "unix:///var/run/docker.sock";
+
+        // Создаем URI заранее, чтобы избежать ошибок парсинга в рантайме
+        java.net.URI dockerUri = java.net.URI.create(hostPath);
 
         DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
-                .withDockerHost(hostToUse)
+                .withDockerHost(hostPath)
                 .build();
 
-        // Явно задаем URI для транспорта, чтобы исключить localhost:2375
-        DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
-                .dockerHost(java.net.URI.create(hostToUse)) // Принудительный URI
-                .sslConfig(config.getSSLConfig())
-                .maxConnections(100)
+        // Zerodep напрямую работает с сокетом и не переключается на 2375
+        DockerHttpClient httpClient = new ZerodepDockerHttpClient.Builder()
+                .dockerHost(URI.create(dockerHost))
                 .build();
 
-        _logger.info("Fixed Docker Host for transport: {}", hostToUse);
+        _logger.info("FINAL ARCHITECTURE: Transport locked to {}", dockerUri);
+
         return DockerClientImpl.getInstance(config, httpClient);
     }
 }

src/main/java/com/jambotronGroup/jambotron/model/ContainerStats.java

@@ -0,0 +1,4 @@
+package com.jambotronGroup.jambotron.model;
+
+public class ContainerStats {
+}

src/main/java/com/jambotronGroup/jambotron/model/ProjectConfig.java

@@ -4,23 +4,38 @@ import lombok.*;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mongodb.core.mapping.Document;
 
+import java.util.List;
 import java.util.Map;
 
 @Document(collection = "project_configs")
-@Data // Генерирует геттеры, сеттеры, toString, equals, hashCode
-@Builder // Генерирует тот самый метод .builder()
-@NoArgsConstructor // Нужен для десериализации MongoDB
-@AllArgsConstructor // Нужен для работы @Builder
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class ProjectConfig {
 
     @Id
     private String id; // Внутренний ID Mongo
 
-    private String projectId; // UUID из нашей таблицы projects
+    private String projectId; // UUID из таблицы projects в Postgres
 
-    private String rawComposeContent; // Прямо текст твоего docker-compose.yaml
+    private String rawComposeContent; // Исходный текст docker-compose.yaml
 
-    private Map<String, String> envVariables; // Ключ-значение для переменных
+    private List<String> serviceNames; // Извлеченные имена сервисов для стабильного UI
 
-    private Integer version = 1; // Для отслеживания правок конфига
+    private Map<String, String> envVariables; // Переменные окружения
+
+    private Map<String, ServiceSettings> serviceConfigs; // Настройки поддоменов и портов для каждого контейнера
+
+    private Integer version = 1; // Версия конфига
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    // Класс настроек (ServiceSettings.java)
+    public static class ServiceSettings {
+        private String yamlServiceName; // "web-test" или "logger-test"
+        private String subdomain;       // "test-web"
+        private Integer port;           // 80
+    }
 }

src/main/java/com/jambotronGroup/jambotron/projects/DockerStatsService.java

@@ -0,0 +1,88 @@
+package com.jambotronGroup.jambotron.projects;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.async.ResultCallback;
+import com.github.dockerjava.api.model.CpuStatsConfig;
+import com.github.dockerjava.api.model.Statistics;
+import com.jambotronGroup.jambotron.DTOs.ContainerStatsDTO;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+@Service
+public class DockerStatsService {
+    private final DockerClient dockerClient;
+    private final SimpMessagingTemplate messagingTemplate;
+
+    public DockerStatsService(DockerClient dockerClient, SimpMessagingTemplate messagingTemplate) {
+        this.dockerClient = dockerClient;
+        this.messagingTemplate = messagingTemplate;
+    }
+
+    @Async
+    public void startStreamingStats(String containerId) {
+        dockerClient.statsCmd(containerId).exec(new ResultCallback.Adapter<Statistics>() {
+            @Override
+            public void onNext(Statistics stats) {
+                ContainerStatsDTO dto = calculate(containerId, stats);
+                messagingTemplate.convertAndSend("/topic/stats/" + containerId, dto);
+            }
+        });
+    }
+
+    private ContainerStatsDTO calculate(String id, Statistics stats) {
+        ContainerStatsDTO dto = new ContainerStatsDTO();
+        dto.setContainerId(id);
+
+        CpuStatsConfig cpu = stats.getCpuStats();
+        CpuStatsConfig preCpu = stats.getPreCpuStats();
+
+        // ЗАЩИТА: Проверяем наличие системных данных, чтобы избежать NullPointerException
+        if (cpu == null || preCpu == null ||
+                cpu.getSystemCpuUsage() == null || preCpu.getSystemCpuUsage() == null) {
+            dto.setCpuUsage(0.0);
+            return fillMemoryStats(dto, stats); // Память обычно доступна сразу
+        }
+
+        // 1. Считаем дельту использования процессора контейнером
+        long cpuUsageDelta = cpu.getCpuUsage().getTotalUsage() - preCpu.getCpuUsage().getTotalUsage();
+
+        // 2. Считаем дельту системного времени
+        long systemUsageDelta = cpu.getSystemCpuUsage() - preCpu.getSystemCpuUsage();
+
+        // 3. Определяем количество ядер
+        long onlineCpus = 0;
+        if (cpu.getCpuUsage().getPercpuUsage() != null) {
+            onlineCpus = cpu.getCpuUsage().getPercpuUsage().size();
+        }
+        if (onlineCpus == 0) {
+            onlineCpus = Runtime.getRuntime().availableProcessors();
+        }
+
+        // 4. Расчет процента с защитой от деления на ноль
+        if (systemUsageDelta > 0 && cpuUsageDelta > 0) {
+            double cpuPercent = ((double) cpuUsageDelta / systemUsageDelta) * onlineCpus * 100.0;
+            dto.setCpuUsage(cpuPercent);
+        } else {
+            dto.setCpuUsage(0.0);
+        }
+
+        return fillMemoryStats(dto, stats);
+    }
+
+    // Выносим расчет памяти для чистоты кода
+    private ContainerStatsDTO fillMemoryStats(ContainerStatsDTO dto, Statistics stats) {
+        if (stats.getMemoryStats() != null) {
+            long usage = stats.getMemoryStats().getUsage() != null ? stats.getMemoryStats().getUsage() : 0L;
+            long limit = stats.getMemoryStats().getLimit() != null ? stats.getMemoryStats().getLimit() : 0L;
+
+            dto.setMemoryUsage(usage);
+            dto.setMemoryLimit(limit);
+
+            if (limit > 0) {
+                dto.setMemoryPercent((double) usage / limit * 100.0);
+            }
+        }
+        return dto;
+    }
+}

src/main/java/com/jambotronGroup/jambotron/projects/ProjectDetailResponse.java

@@ -2,8 +2,39 @@ package com.jambotronGroup.jambotron.projects;
 
 import com.jambotronGroup.jambotron.model.Project;
 import com.jambotronGroup.jambotron.model.ProjectConfig;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 
-public record ProjectDetailResponse(
-        Project project,
-        ProjectConfig config
-) {}
+import java.util.List;
+import java.util.Map;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ProjectDetailResponse {
+    private Project project;
+    private ConfigDTO config;
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ConfigDTO {
+        private String projectId;
+        private String rawComposeContent;
+        private List<String> serviceNames; // Список сервисов для UI
+        private Map<String, ProjectConfig.ServiceSettings> serviceConfigs; // Поддомены и порты
+        private Map<String, String> envVariables;
+    }
+
+    public ProjectDetailResponse(Project project, ProjectConfig config) {
+        this.project = project;
+        this.config = new ConfigDTO(
+                config.getProjectId(),
+                config.getRawComposeContent(),
+                config.getServiceNames(), // Передаем извлеченные имена
+                config.getServiceConfigs(),
+                config.getEnvVariables()
+        );
+    }
+}

src/main/java/com/jambotronGroup/jambotron/projects/ProjectService.java

@@ -1,20 +1,18 @@
 package com.jambotronGroup.jambotron.projects;
 
 import com.jambotronGroup.jambotron.globalConstants.GlobalConstants;
-import com.jambotronGroup.jambotron.model.Project;
-import com.jambotronGroup.jambotron.model.ProjectConfig;
-import com.jambotronGroup.jambotron.model.ProjectStatus;
-import com.jambotronGroup.jambotron.model.User;
+import com.jambotronGroup.jambotron.model.*;
 import com.jambotronGroup.jambotron.repository.ProjectConfigRepository;
 import com.jambotronGroup.jambotron.repository.ProjectRepository;
 import jakarta.transaction.Transactional;
 import lombok.RequiredArgsConstructor;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.stereotype.Service;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -22,11 +20,9 @@ import java.io.InputStreamReader;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
 import java.util.stream.Collectors;
 
 @Service
@@ -34,151 +30,435 @@ import java.util.stream.Collectors;
 public class ProjectService {
 
     private final ProjectRepository projectRepository;
-
     private final ProjectConfigRepository configRepository;
-
+    private final SimpMessagingTemplate messagingTemplate;
 
     private static final Logger _logger = LoggerFactory.getLogger(ProjectService.class);
+    private static final DateTimeFormatter L_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    // --- Вспомогательные методы логирования ---
+
+    private void logToConsole(UUID projectId, String message) {
+        String timestamp = LocalDateTime.now().format(L_TIME_FORMATTER);
+        String formattedMessage = String.format("[%s] %s", timestamp, message);
+        _logger.info("[Project-{}]: {}", projectId, message);
+        messagingTemplate.convertAndSend("/topic/deploy/" + projectId, formattedMessage);
+    }
+
+    // --- Базовые операции CRUD ---
+
+    public Project save(Project project) {
+        return projectRepository.save(project);
+    }
 
     public Project findById(UUID id) {
         return projectRepository.findById(id)
                 .orElseThrow(() -> new RuntimeException("Project not found with id: " + id));
     }
 
-    /**
-     * Получение всех проектов пользователя (для Dashboard).
-     * Возвращает список проектов, принадлежащих конкретному владельцу.
-     */
     public List<Project> findAllByOwnerId(Long ownerId) {
-        _logger.info("Запрос списка проектов для пользователя: {}", ownerId);
         return projectRepository.findAllByUserId(ownerId);
     }
 
-    /**
-     * Получение всех проектов в системе (для Admin Panel).
-     * Позволяет администратору видеть состояние всех развернутых мощностей.
-     */
-    public List<Project> findAllProjectsForAdmin() {
-        _logger.info("Запрос всех проектов системы администратором");
-        return projectRepository.findAll();
-    }
-
-    /**
-     * Получение развернутой информации о проекте (Project + Config).
-     * Полезно для детального отображения в Dashboard.
-     */
-    public ProjectDetailResponse getProjectDetails(UUID projectId) {
-        Project project = findById(projectId);
-        ProjectConfig config = configRepository.findByProjectId(String.valueOf(projectId))
-                .orElseThrow(() -> new RuntimeException("Конфигурация не найдена"));
-
-        return new ProjectDetailResponse(project, config);
-    }
-
-    /**
-     * Безопасное получение деталей проекта.
-     * @param projectId ID проекта
-     * @param currentUserId ID пользователя, совершающего запрос
-     * @param isAdmin флаг, является ли пользователь администратором
-     */
-    public ProjectDetailResponse getProjectDetailsSecure(UUID projectId, Long currentUserId, boolean isAdmin) {
-        Project project = findById(projectId);
-
-        // ПРОВЕРКА БЕЗОПАСНОСТИ:
-        // Если пользователь не админ и не владелец проекта — доступ запрещен
-        if (!isAdmin && !Objects.equals(project.getUser().getId(), currentUserId)) {
-            _logger.warn("Security Alert: User {} tried to access project {} owned by {}",
-                    currentUserId, projectId, project.getUser().getId());
-            throw new AccessDeniedException("У вас нет прав для просмотра этого проекта");
-        }
-
-        ProjectConfig config = configRepository.findByProjectId(String.valueOf(projectId))
-                .orElseThrow(() -> new RuntimeException("Конфигурация не найдена"));
-
-        return new ProjectDetailResponse(project, config);
-    }
+    // --- Управление конфигурацией и создание ---
 
     @Transactional
     public Project createProject(String projectName, String rawComposeContent, User owner) {
         if (projectRepository.existsByNameAndUserId(projectName, owner.getId())) {
-            throw new ProjectAlreadyExistsException(
-                    "Проект с именем '" + projectName + "' уже существует у данного пользователя"
-            );
+            throw new RuntimeException("Проект с таким именем уже существует");
         }
 
-        _logger.info("Валидация пройдена. Создание проекта: {}", projectName);
-
         Project project = new Project();
         project.setName(projectName);
-
-
-
         project.setUser(owner);
         project.setStatus(ProjectStatus.CREATED);
         project = projectRepository.save(project);
 
-        UUID projectId = project.getId();
-
         try {
-            // Используем структуру из GlobalConstants для создания рабочей директории
-            Path projectDir = GlobalConstants.PATH_PROJECTS.resolve(projectId.toString());
+            Path projectDir = GlobalConstants.PATH_PROJECTS.resolve(project.getId().toString());
             Files.createDirectories(projectDir);
-
             project.setLocalPath(projectDir.toString());
-            projectRepository.save(project);
 
             ProjectConfig config = ProjectConfig.builder()
                     .projectId(String.valueOf(project.getId()))
                     .rawComposeContent(rawComposeContent)
+                    .serviceNames(extractServiceNames(rawComposeContent))
                     .build();
             configRepository.save(config);
 
-            return project;
+            return projectRepository.save(project);
         } catch (IOException e) {
-            _logger.error("FS Error during project creation: {}", projectId, e);
+            _logger.error("Ошибка при создании директории проекта", e);
             throw new RuntimeException("Ошибка инициализации хранилища");
         }
     }
 
-    /**
-     * Основной процесс деплоя.
-     * Метод не помечен @Transactional целиком, чтобы статус STARTING
-     * зафиксировался в БД до начала выполнения долгой команды docker compose.
-     */
-    public void deployProject(Project project) {
+    @Transactional
+    public void updateProjectConfig(UUID projectId, ProjectConfig newConfig) {
+        // 1. Поиск существующего проекта в Postgres
+        Project project = projectRepository.findById(projectId)
+                .orElseThrow(() -> new IllegalArgumentException("Проект не найден с ID: " + projectId));
 
-        _logger.info("invoke deployProject");
-        // 1. Устанавливаем промежуточный статус
-        updateStatusInNewTransaction(project.getId(), ProjectStatus.STARTING);
-        _logger.info("{}: chenget status to{}",project.getId(),project.getStatus());
+        // Находим или инициализируем корневую конфигурацию в MongoDB (ключ — String)
+        ProjectConfig existing = configRepository.findByProjectId(projectId.toString())
+                .orElseGet(() -> {
+                    ProjectConfig c = new ProjectConfig();
+                    c.setProjectId(projectId.toString());
+                    c.setServiceConfigs(new HashMap<>());
+                    return c;
+                });
+
+        // ПЕРВОПРИЧИНА ИСПРАВЛЕНА: Берем исходный YAML текст из прилетевшего конфига (newConfig)
+        String rawYaml = newConfig.getRawComposeContent();
+
+        // 2. Парсинг актуальных имен сервисов из docker-compose.yml
+        List<String> actualYamlNames = new ArrayList<>();
+        if (rawYaml != null && !rawYaml.isBlank()) {
             try {
-            // 2. Путь берем из сущности (он был инициализирован в createProject через GlobalConstants)
-            Path projectPath = Paths.get(project.getLocalPath());
-
-            // 3. Генерируем файлы конфигурации
-            prepareFiles(project, projectPath);
-            _logger.info("Ready to deploy project at: {}", projectPath);
-
-            // 4. Запускаем Docker Compose (блокирующая операция)
-            int exitCode = runComposeUp(projectPath,project.getId());
-
-            // 5. Финализируем статус на основе результата
-            if (exitCode == 0) {
-                updateStatusInNewTransaction(project.getId(), ProjectStatus.RUNNING);
-                _logger.info("Project {} is now RUNNING", project.getId());
-            } else {
-                updateStatusInNewTransaction(project.getId(), ProjectStatus.ERROR);
-                _logger.error("Docker Compose failed with exit code: {}", exitCode);
+                Yaml yaml = new Yaml();
+                Map<String, Object> obj = yaml.load(rawYaml);
+                if (obj != null && obj.get("services") instanceof Map) {
+                    Map<?, ?> servicesMap = (Map<?, ?>) obj.get("services");
+                    for (Object key : servicesMap.keySet()) {
+                        actualYamlNames.add(String.valueOf(key));
+                    }
                 }
             } catch (Exception e) {
-            _logger.error("Critical error during deploy: {}", e.getMessage());
-            updateStatusInNewTransaction(project.getId(), ProjectStatus.ERROR);
+                _logger.error("Ошибка парсинга docker-compose.yml для извлечения имен сервисов в проекте {}", projectId, e);
             }
         }
 
+        // 3. Умное сопоставление (маппинг) Service ID
+        Map<String, ProjectConfig.ServiceSettings> incomingConfigs = newConfig.getServiceConfigs();
+        Map<String, ProjectConfig.ServiceSettings> existingConfigs = existing.getServiceConfigs();
+
+        if (incomingConfigs == null) incomingConfigs = new HashMap<>();
+        if (existingConfigs == null) existingConfigs = new HashMap<>();
+
+        Map<String, ProjectConfig.ServiceSettings> alignedConfigs = new HashMap<>();
+
+        // Итерируемся по реальным сервисам из файла конфигурации
+        for (int i = 0; i < actualYamlNames.size(); i++) {
+            String yamlName = actualYamlNames.get(i);
+            final int currentIndex = i;
+
+            // Определяем стабильный системный ID (например, srv-0) на основе старой базы
+            String targetServiceId = existingConfigs.entrySet().stream()
+                    .filter(e -> yamlName.equals(e.getValue().getYamlServiceName()))
+                    .map(Map.Entry::getKey)
+                    .findFirst()
+                    .orElse(null);
+
+            if (targetServiceId == null) {
+                // Если в базе еще нет, проверяем, вдруг фронт привязал к srv-X
+                targetServiceId = incomingConfigs.entrySet().stream()
+                        .filter(e -> yamlName.equals(e.getValue().getYamlServiceName()))
+                        .map(Map.Entry::getKey)
+                        .findFirst()
+                        .orElse("srv-" + currentIndex);
+            }
+
+            // ИЩЕМ ИСТОЧНИК ДАННЫХ (Где лежат введенные пользователем порт и поддомен)
+            ProjectConfig.ServiceSettings userUiSettings = null;
+
+            // Стратегия А: Ищем по стабильному ID (srv-0)
+            ProjectConfig.ServiceSettings settingsBySubId = incomingConfigs.get(targetServiceId);
+            if (settingsBySubId != null && (settingsBySubId.getSubdomain() != null || settingsBySubId.getPort() != null)) {
+                userUiSettings = settingsBySubId;
+            }
+
+            // Стратегия Б: Ищем по полному YAML-имени как по ключу мапы (например, "web-test")
+            if (userUiSettings == null) {
+                ProjectConfig.ServiceSettings settingsByFullName = incomingConfigs.get(yamlName);
+                if (settingsByFullName != null && (settingsByFullName.getSubdomain() != null || settingsByFullName.getPort() != null)) {
+                    userUiSettings = settingsByFullName;
+                }
+            }
+
+            // Стратегия В (Решение для image_bb4570): Ищем частичное совпадение ключей мапы (фронт прислал ключ "web" для сервиса "web-test")
+            if (userUiSettings == null) {
+                userUiSettings = incomingConfigs.entrySet().stream()
+                        .filter(entry -> yamlName.startsWith(entry.getKey()) || entry.getKey().startsWith(yamlName))
+                        .map(Map.Entry::getValue)
+                        .filter(s -> s.getSubdomain() != null || s.getPort() != null)
+                        .findFirst()
+                        .orElse(null);
+            }
+
+            // Стратегия Г: Ищем по внутреннему полю yamlServiceName, если оно заполнено
+            if (userUiSettings == null) {
+                userUiSettings = incomingConfigs.values().stream()
+                        .filter(s -> yamlName.equals(s.getYamlServiceName()))
+                        .findFirst()
+                        .orElse(null);
+            }
+
+            // Создаем или извлекаем целевой объект настроек для базы
+            ProjectConfig.ServiceSettings finalSettings = existingConfigs.get(targetServiceId);
+            if (finalSettings == null) {
+                finalSettings = new ProjectConfig.ServiceSettings();
+            }
+
+            // НАКАТЫВАЕМ ДАННЫЕ: Если нашли донора из UI, забираем его конфигурацию порта и домена
+            if (userUiSettings != null) {
+                finalSettings.setSubdomain(userUiSettings.getSubdomain());
+                finalSettings.setPort(userUiSettings.getPort());
+            }
+
+            // Жестко гарантируем железную привязку к реальному имени контейнера
+            finalSettings.setYamlServiceName(yamlName);
+            alignedConfigs.put(targetServiceId, finalSettings);
+        }
+
+        // Сохраняем выровненную конфигурацию и метаданные в документ Mongo
+        existing.setServiceConfigs(alignedConfigs);
+        existing.setRawComposeContent(rawYaml);
+        existing.setServiceNames(actualYamlNames);
+
+        // Валидируем поддомены перед записью в репозиторий
+        validateSubdomains(existing);
+
+        // 4. Сохранение обновленного монолита в MongoDB
+        configRepository.save(existing);
+        _logger.info("[Jambotron] Конфигурация шлюза для проекта {} успешно синхронизирована.", projectId);
+    }
+
+    private void validateSubdomains(ProjectConfig config) {
+        if (config.getServiceConfigs() == null) return;
+        for (var entry : config.getServiceConfigs().values()) {
+            String sub = entry.getSubdomain();
+            if (sub != null && !sub.isEmpty()) {
+                if (!sub.matches("^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$")) {
+                    throw new RuntimeException("Некорректный формат поддомена (только латиница, цифры и дефис): " + sub);
+                }
+                // Проверка на занятость поддомена другими проектами
+                List<ProjectConfig> conflicts = configRepository.findAllByAnyServiceSubdomain(sub);
+                if (conflicts.stream().anyMatch(c -> !c.getProjectId().equals(config.getProjectId()))) {
+                    throw new RuntimeException("Поддомен '" + sub + "' уже занят!");
+                }
+            }
+        }
+    }
+
+    private List<String> extractServiceNames(String yamlContent) {
+        try {
+            Yaml yaml = new Yaml();
+            Map<String, Object> obj = yaml.load(yamlContent);
+            Map<String, Object> services = (Map<String, Object>) obj.get("services");
+            return services != null ? new ArrayList<>(services.keySet()) : List.of();
+        } catch (Exception e) { return List.of(); }
+    }
+
+    // --- Жизненный цикл (Deploy, Stop, Delete) ---
+
+    @Transactional
+    public void deployProject(Project project) {
+        UUID projectId = project.getId();
+        String projectIdStr = String.valueOf(projectId);
+        Path projectPath = Paths.get(project.getLocalPath());
+
+        logToConsole(projectId, "Инициация созидания окружения...");
+        updateStatusInNewTransaction(projectId, ProjectStatus.STARTING);
+
+        // 1. Извлекаем доменные настройки из MongoDB
+        ProjectConfig config = configRepository.findByProjectId(projectIdStr).orElse(null);
+
+        // 2. Внедряем метки Caddy в пользовательский docker-compose.yml
+        assert config != null;
+        String finalComposeContent = injectCaddyLabels(config.getRawComposeContent(), config);
+
+        logToConsole(projectId, finalComposeContent);
+        try {
+            Files.createDirectories(projectPath);
+
+            // Записываем модифицированный файл со всеми доменами
+            Files.writeString(projectPath.resolve("docker-compose.yml"), finalComposeContent);
+
+            logToConsole(projectId, "Конфигурация Caddy подготовлена. Запуск контейнеров...");
+
+            // Добавляем --force-recreate, чтобы Docker гарантированно применил новые labels!
+            ProcessBuilder pb = new ProcessBuilder("docker", "compose", "up", "-d", "--force-recreate", "--remove-orphans");
+            pb.directory(projectPath.toFile());
+            Process process = pb.start();
+
+            readProcessOutputAsync(projectIdStr, process);
+
+            int exitCode = process.waitFor();
+            if (exitCode == 0) {
+                project.setStatus(ProjectStatus.RUNNING);
+                logToConsole(projectId, "Все службы успешно запущены и подключены к шлюзу Caddy.");
+            } else {
+                project.setStatus(ProjectStatus.ERROR);
+                logToConsole(projectId, "Ошибка сборки стека. Код возврата: " + exitCode);
+            }
+        } catch (Exception e) {
+            project.setStatus(ProjectStatus.ERROR);
+            logToConsole(projectId, "Критическая ошибка: " + e.getMessage());
+        }
+        projectRepository.save(project);
+    }
+
     /**
-     * Вспомогательный метод для атомарного обновления статуса
+     * Обогащает исходный docker-compose.yml метками для Caddy reverse proxy
+     * на основе конфигурации проекта из MongoDB.
      */
+    public String injectCaddyLabels(String rawComposeContent, ProjectConfig config) {
+        if (config == null || config.getServiceConfigs() == null || config.getServiceConfigs().isEmpty()) {
+            return rawComposeContent;
+        }
+
+        try {
+            Yaml yaml = new Yaml();
+            Map<String, Object> composeMap = yaml.load(rawComposeContent);
+
+            Map<String, Object> services = (Map<String, Object>) composeMap.get("services");
+            if (services == null) {
+                return rawComposeContent;
+            }
+
+            // Перебираем конфигурации сервисов, сохраненные в MongoDB
+            config.getServiceConfigs().forEach((serviceKey, serviceSetting) -> {
+
+                // Умный поиск: ищем ключ в docker-compose.yml
+                String actualComposeKey = null;
+
+                // 1. Проверяем, может serviceKey — это прямое имя из YAML (web-test)
+                if (services.containsKey(serviceKey)) {
+                    actualComposeKey = serviceKey;
+                }
+                // 2. Или может это сохраненный yamlServiceName внутри настроек?
+                else if (serviceSetting.getYamlServiceName() != null && services.containsKey(serviceSetting.getYamlServiceName())) {
+                    actualComposeKey = serviceSetting.getYamlServiceName();
+                }
+                // 3. Резервный вариант: если прилетело урезанное "web", ищем частичное совпадение в YAML ("web-test" стартует с "web")
+                else {
+                    actualComposeKey = services.keySet().stream()
+                            .filter(k -> k.startsWith(serviceKey) || serviceKey.startsWith(k))
+                            .findFirst()
+                            .orElse(null);
+                }
+
+                // Если нашли точку соприкосновения и задан поддомен — инжектим метки Caddy
+                if (actualComposeKey != null && serviceSetting.getSubdomain() != null && !serviceSetting.getSubdomain().isEmpty()) {
+                    Map<String, Object> service = (Map<String, Object>) services.get(actualComposeKey);
+
+                    Map<String, String> labels = (Map<String, String>) service.get("labels");
+                    if (labels == null) {
+                        labels = new HashMap<>();
+                    }
+
+                    String domain = serviceSetting.getSubdomain() + ".jambotron.com";
+                    String internalPort = serviceSetting.getPort() != null ? serviceSetting.getPort().toString() : "80";
+
+                    labels.put("caddy", domain);
+                    labels.put("caddy.reverse_proxy", "{{upstreams " + internalPort + "}}");
+
+                    service.put("labels", labels);
+                }
+            });
+
+            DumperOptions options = new DumperOptions();
+            options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+            Yaml dumper = new Yaml(options);
+
+            return dumper.dump(composeMap);
+
+        } catch (Exception e) {
+            _logger.error("Ошибка при модификации YAML структуры для Caddy", e);
+            return rawComposeContent;
+        }
+    }
+
+    private void prepareEnhancedFiles(Project project, Path projectPath) throws IOException {
+        ProjectConfig config = configRepository.findByProjectId(String.valueOf(project.getId()))
+                .orElseThrow(() -> new RuntimeException("Config not found"));
+
+        if (!Files.exists(projectPath)) Files.createDirectories(projectPath);
+
+        Yaml yaml = new Yaml(getDumperOptions());
+        Map<String, Object> compose = yaml.load(config.getRawComposeContent());
+        Map<String, Object> services = (Map<String, Object>) compose.get("services");
+
+        if (services != null) {
+            services.forEach((name, obj) -> {
+                Map<String, Object> service = (Map<String, Object>) obj;
+                // Уникальное имя контейнера для изоляции
+                service.put("container_name", "jambotron-" + project.getId() + "-" + name);
+
+                // Инъекция меток Caddy для автоматического SSL и проксирования
+                if (config.getServiceConfigs() != null && config.getServiceConfigs().containsKey(name)) {
+                    var settings = config.getServiceConfigs().get(name);
+                    if (settings.getSubdomain() != null && !settings.getSubdomain().isEmpty()) {
+                        Map<String, String> labels = (Map<String, String>) service.getOrDefault("labels", new HashMap<String, String>());
+                        labels.put("caddy", settings.getSubdomain() + ".jambotron.com");
+                        labels.put("caddy.reverse_proxy", "{{upstreams " + settings.getPort() + "}}");
+                        service.put("labels", labels);
+                    }
+                }
+            });
+        }
+        Files.writeString(projectPath.resolve("docker-compose.yml"), yaml.dump(compose));
+    }
+
+    private DumperOptions getDumperOptions() {
+        DumperOptions options = new DumperOptions();
+        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        options.setPrettyFlow(true);
+        return options;
+    }
+
+    private int runComposeUp(Path projectPath, UUID projectId) {
+        ProcessBuilder pb = new ProcessBuilder("docker", "compose", "up", "-d", "--build");
+        pb.directory(projectPath.toFile());
+        pb.redirectErrorStream(true);
+        try {
+            Process process = pb.start();
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    messagingTemplate.convertAndSend("/topic/deploy/" + projectId, line);
+                }
+            }
+            return process.waitFor();
+        } catch (Exception e) { return -1; }
+    }
+
+    @Transactional
+    public void stopProject(Project project) {
+        UUID projectId = project.getId();
+        logToConsole(projectId, "Остановка служб...");
+        try {
+            ProcessBuilder pb = new ProcessBuilder("docker", "compose", "down");
+            pb.directory(Paths.get(project.getLocalPath()).toFile());
+            if (pb.start().waitFor() == 0) {
+                project.setStatus(ProjectStatus.STOPPED);
+                logToConsole(projectId, "Службы остановлены.");
+            }
+        } catch (Exception e) { logToConsole(projectId, "Ошибка: " + e.getMessage()); }
+        projectRepository.save(project);
+    }
+
+    @Transactional
+    public void deleteProject(UUID projectId) {
+        Project project = findById(projectId);
+        Path projectPath = Paths.get(project.getLocalPath());
+        logToConsole(projectId, "ПОЛНОЕ УДАЛЕНИЕ ресурсов...");
+        try {
+            ProcessBuilder pb = new ProcessBuilder("docker", "compose", "down", "-v", "--rmi", "all");
+            pb.directory(projectPath.toFile());
+            pb.start().waitFor();
+
+            if (Files.exists(projectPath)) {
+                try (var stream = Files.walk(projectPath)) {
+                    stream.sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(java.io.File::delete);
+                }
+            }
+            configRepository.deleteByProjectId(String.valueOf(projectId));
+            projectRepository.delete(project);
+            logToConsole(projectId, "Проект удален.");
+        } catch (Exception e) { logToConsole(projectId, "Ошибка: " + e.getMessage()); }
+    }
+
     @Transactional
     public void updateStatusInNewTransaction(UUID projectId, ProjectStatus status) {
         Project project = findById(projectId);
@@ -186,191 +466,118 @@ public class ProjectService {
         projectRepository.save(project);
     }
 
-    private void prepareFiles(Project project, Path projectPath) throws IOException {
-        ProjectConfig config = configRepository.findByProjectId(String.valueOf(project.getId()))
-                .orElseThrow(() -> new RuntimeException("Config not found"));
-
-        // Убеждаемся, что директория существует
-        if (!Files.exists(projectPath)) {
-            Files.createDirectories(projectPath);
-        }
-
-        // docker-compose.yml
-        Path composeFile = projectPath.resolve("docker-compose.yml");
-        Files.writeString(composeFile, config.getRawComposeContent());
-
-        // .env
-        if (config.getEnvVariables() != null && !config.getEnvVariables().isEmpty()) {
-            String envContent = config.getEnvVariables().entrySet().stream()
-                    .map(e -> e.getKey() + "=" + e.getValue())
-                    .collect(Collectors.joining("\n"));
-
-            Files.writeString(projectPath.resolve(".env"), envContent);
-            _logger.info(".env file generated for project: {}", project.getId());
-        }
-    }
-
-    private int runComposeUp(Path projectPath, UUID projectId) {
-        ProcessBuilder pb = new ProcessBuilder("docker", "compose", "up", "-d");
-        pb.directory(projectPath.toFile());
-        pb.redirectErrorStream(true);
+    /**
+     * Получение актуального списка ВСЕХ контейнеров для конкретного проекта.
+     * Добавлен флаг --all, чтобы показывать даже выключенные службы.
+     */
+    public List<ContainerStatus> getProjectContainers(UUID projectId) {
+        Project project = findById(projectId);
+        List<ContainerStatus> statuses = new ArrayList<>();
 
         try {
-            _logger.info("Запуск docker compose up для проекта: {}", projectId);
+            // Флаг --all заставляет docker compose вернуть информацию обо всех контейнерах стека
+            ProcessBuilder pb = new ProcessBuilder("docker", "compose", "ps", "--all", "--format", "json");
+            pb.directory(Paths.get(project.getLocalPath()).toFile());
             Process process = pb.start();
 
-            // 1. Читаем поток вывода в реальном времени
-            try (BufferedReader reader = new BufferedReader(
-                    new InputStreamReader(process.getInputStream()))) {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
                 String line;
                 while ((line = reader.readLine()) != null) {
-                    // Логируем в консоль сервера (из этого потока наш DockerLogsHandler
-                    // будет забирать данные для передачи в Angular)
-                    _logger.info("[Docker-{}]: {}", projectId, line);
+                    if (line.trim().isEmpty()) continue;
 
-                    // УДАЛЕНО: messagingTemplate.convertAndSend(...)
-                    // Теперь логи транслирует DockerLogsHandler напрямую из Docker-сокета.
+                    // Парсим строку вывода и собираем неизменяемый record
+                    statuses.add(new ContainerStatus(
+                            extractValue(line, "ID"),
+                            extractValue(line, "Name"),
+                            extractValue(line, "Image"),
+                            extractValue(line, "State"),
+                            extractValue(line, "Status")
+                    ));
                 }
             }
-
-            boolean finished = process.waitFor(5, TimeUnit.MINUTES);
-            // ... остальная логика завершения процесса ...
-            return process.exitValue();
-
-        } catch (IOException | InterruptedException e) {
-            _logger.error("Критическая ошибка при выполнении docker compose: {}", e.getMessage());
-            return -1;
-        }
-    }
-
-    @Transactional
-    public void stopProject(Project project) {
-        Path projectPath = Paths.get(project.getLocalPath());
-
-        _logger.info("Stopping project: {}", project.getId());
-
-        ProcessBuilder pb = new ProcessBuilder("docker", "compose", "down");
-        pb.directory(projectPath.toFile());
-        pb.inheritIO();
-
-        try {
-            Process process = pb.start();
-            int exitCode = process.waitFor();
-
-            if (exitCode == 0) {
-                project.setStatus(ProjectStatus.STOPPED);
-                _logger.info("Project {} stopped successfully.", project.getId());
-            } else {
-                project.setStatus(ProjectStatus.ERROR);
-                _logger.error("Failed to stop project. Exit code: {}", exitCode);
-            }
+            process.waitFor();
         } catch (Exception e) {
-            project.setStatus(ProjectStatus.ERROR);
-            _logger.error("Error during docker compose down", e);
-        } finally {
-            projectRepository.save(project);
-        }
-    }
-
-    @Transactional
-    public void save(Project project) {
-        projectRepository.save(project);
-    }
-
-    @Transactional
-    public void updateProjectConfig(UUID projectId, String newYaml) {
-        ProjectConfig config = configRepository.findByProjectId(String.valueOf(projectId))
-                .orElseThrow(() -> new RuntimeException("Config not found for project: " + projectId));
-        config.setRawComposeContent(newYaml);
-        configRepository.save(config);
-    }
-
-     @Transactional
-    public void deleteProject(UUID projectId) {
-        Project project = findById(projectId);
-        // Путь берем из проинициализированного поля localPath
-        Path projectPath = Paths.get(project.getLocalPath());
-
-        _logger.info("Запуск полного удаления проекта: {} (путь: {})", projectId, projectPath);
-
-        try {
-            // 1. Останавливаем и удаляем всё в Docker (контейнеры, сети и ТОМА)
-            // Флаг -v критически важен для очистки места
-            runCommand(projectPath, "docker", "compose", "down", "-v");
-
-            if (!Files.isWritable(projectPath)) {
-                throw new RuntimeException("Директория проекта доступна только для чтения. Удаление невозможно.");
-            }
-
-
-            // 2. Рекурсивно удаляем папку проекта в файловой системе
-            if (Files.exists(projectPath)) {
-                try (var stream = Files.walk(projectPath)) {
-                    stream.sorted(Comparator.reverseOrder()) // Сначала файлы, потом папки
-                            .map(Path::toFile)
-                            .forEach(file -> {
-                                if (!file.delete()) {
-                                    _logger.warn("Не удалось удалить файл: {}", file.getAbsolutePath());
-                                }
-                            });
-                }
-                _logger.info("Файловая система очищена для проекта: {}", projectId);
-            }
-
-            // 3. Удаляем данные из БД[cite: 1]
-            // Сначала конфиг (связанная сущность), потом сам проект
-            configRepository.deleteByProjectId(String.valueOf(projectId));
-            projectRepository.delete(project);
-
-            _logger.info("Проект {} успешно удален из системы", projectId);
-
-        } catch (Exception e) {
-            _logger.error("Критическая ошибка при удалении проекта {}: {}", projectId, e.getMessage());
-            throw new RuntimeException("Ошибка при полном удалении проекта", e);
+            _logger.error("Ошибка при получении статусов всех контейнеров для проекта {}", projectId, e);
         }
+        return statuses;
     }
 
     /**
-     * Универсальный метод для запуска быстрых команд Docker без чтения логов в реальном времени
+     * Перезапуск конкретного контейнера внутри проекта.
+     * Выполняет команду: docker compose restart <containerId>
      */
-    private void runCommand(Path directory, String... command) throws IOException, InterruptedException {
-        ProcessBuilder pb = new ProcessBuilder(command);
-        pb.directory(directory.toFile());
-        pb.inheritIO();
-        Process process = pb.start();
-        int exitCode = process.waitFor();
-        if (exitCode != 0) {
-            _logger.warn("Команда {} завершилась с кодом {}", String.join(" ", command), exitCode);
-        }
+    public void restartContainer(UUID projectId, String containerId) {
+        executeContainerAction(projectId, containerId, "restart", "перезапущен");
     }
 
-    public List<ContainerStatus> getProjectContainers(UUID projectId) {
-        Project project = findById(projectId);
-        Path projectPath = Paths.get(project.getLocalPath());
+    /**
+     * Остановка конкретного контейнера внутри проекта.
+     * Выполняет команду: docker compose stop <containerId>
+     */
+    public void stopContainer(UUID projectId, String containerId) {
+        executeContainerAction(projectId, containerId, "stop", "остановлен");
+    }
 
-        // Формат: ID | Service Name | Image | State | Status
-        ProcessBuilder pb = new ProcessBuilder(
-                "docker", "compose", "ps", "--format", "{{.ID}}|{{.Service}}|{{.Image}}|{{.State}}|{{.Status}}"
-        );
-        pb.directory(projectPath.toFile());
+    /**
+     * Запуск конкретного контейнера внутри проекта.
+     * Выполняет команду: docker compose start <containerId>
+     */
+    public void startContainer(UUID projectId, String containerId) {
+        executeContainerAction(projectId, containerId, "start", "запущен");
+    }
+
+    /**
+     * Унифицированный приватный метод для выполнения команд над контейнерами Docker Compose.
+     */
+    private void executeContainerAction(UUID projectId, String containerId, String action, String actionPastTense) {
+        String pIdStr = String.valueOf(projectId);
+
+        logToConsole(projectId, "Инициация операции [" + action + "] для контейнера ID: " + containerId);
 
         try {
+            // Вызываем напрямую docker stop/start/restart <id> без compose
+            ProcessBuilder pb = new ProcessBuilder("docker", action, containerId);
+
             Process process = pb.start();
-            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
-                return reader.lines()
-                        .map(line -> {
-                            String[] parts = line.split("\\|");
-                            if (parts.length >= 5) {
-                                return new ContainerStatus(parts[0], parts[1], parts[2], parts[3], parts[4]);
+            readProcessOutputAsync(pIdStr, process);
+
+            int exitCode = process.waitFor();
+            if (exitCode == 0) {
+                logToConsole(projectId, "Контейнер " + containerId + " успешно " + actionPastTense + ".");
+            } else {
+                logToConsole(projectId, "Ошибка операции [" + action + "]. Код возврата: " + exitCode);
             }
-                            return null;
-                        })
-                        .filter(Objects::nonNull)
-                        .collect(Collectors.toList());
+
+        } catch (IOException | InterruptedException e) {
+            _logger.error("Исключение при операции {} над контейнером {} в проекте {}", action, containerId, projectId, e);
+            logToConsole(projectId, "Критическая ошибка созидания: " + e.getMessage());
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private String extractValue(String line, String key) {
+        try {
+            String search = "\"" + key + "\":\"";
+            int start = line.indexOf(search);
+            if (start == -1) return "unknown";
+            start += search.length();
+            int end = line.indexOf("\"", start);
+            return line.substring(start, end);
+        } catch (Exception e) {
+            return "unknown";
+        }
+    }
+
+    private void readProcessOutputAsync(String projectIdStr, Process process) {
+        new Thread(() -> {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    logToConsole(UUID.fromString(projectIdStr), line);
                 }
             } catch (IOException e) {
-            _logger.error("Ошибка при получении списка контейнеров для проекта {}: {}", projectId, e.getMessage());
-            return List.of();
+                _logger.error("Ошибка асинхронного чтения логов процесса для проекта {}", projectIdStr, e);
             }
+        }).start();
     }
 }

src/main/java/com/jambotronGroup/jambotron/repository/ProjectConfigRepository.java

@@ -2,15 +2,24 @@ package com.jambotronGroup.jambotron.repository;
 
 import com.jambotronGroup.jambotron.model.ProjectConfig;
 import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Query;
 import org.springframework.stereotype.Repository;
+import java.util.List;
 import java.util.Optional;
 
 @Repository
 public interface ProjectConfigRepository extends MongoRepository<ProjectConfig, String> {
 
-    // Нам часто нужно будет доставать конфиг именно по ID проекта из Postgres
+    // Достаем конфиг по ID проекта из Postgres
     Optional<ProjectConfig> findByProjectId(String projectId);
 
     // Удаление конфига при удалении проекта
     void deleteByProjectId(String projectId);
+
+    /**
+     * Поиск всех конфигураций, где хотя бы у одного сервиса в Map совпадает subdomain.
+     * Используем dot-notation для поиска по значениям в Map (serviceConfigs.values.subdomain).
+     */
+    @Query("{ 'serviceConfigs.values.subdomain': ?0 }")
+    List<ProjectConfig> findAllByAnyServiceSubdomain(String subdomain);
 }