1537 lines
68 KiB
PHP
1537 lines
68 KiB
PHP
<?php
|
|
|
|
namespace ServerManager\UI;
|
|
|
|
use PHPNative\Async\TaskManager;
|
|
use PHPNative\Framework\Settings;
|
|
use PHPNative\Tailwind\Data\Icon as IconName;
|
|
use PHPNative\Ui\Widget\Button;
|
|
use PHPNative\Ui\Widget\Checkbox;
|
|
use PHPNative\Ui\Widget\Container;
|
|
use PHPNative\Ui\Widget\Icon;
|
|
use PHPNative\Ui\Widget\Label;
|
|
use PHPNative\Ui\Widget\TabContainer;
|
|
use PHPNative\Ui\Widget\TextInput;
|
|
use PHPNative\Ui\Widget\VirtualListView;
|
|
use ServerManager\Services\HetznerService;
|
|
use ServerManager\UI\KanbanTab;
|
|
use ServerManager\UI\LoadingIndicator;
|
|
|
|
class ServerListTab
|
|
{
|
|
private Settings $settings;
|
|
private null|KanbanTab $kanbanTab;
|
|
private Container $tab;
|
|
private VirtualListView $table;
|
|
private TextInput $searchInput;
|
|
private Label $statusLabel;
|
|
private Button $refreshButton;
|
|
private Button $sftpButton;
|
|
private Button $sshTerminalButton;
|
|
|
|
public array $currentServerData = [];
|
|
public null|array $selectedServer = null;
|
|
|
|
private Label $detailId;
|
|
private Label $detailName;
|
|
private Label $detailStatus;
|
|
private Label $detailType;
|
|
private Label $detailIpv4;
|
|
private Container $detailDomainsContainer;
|
|
private LoadingIndicator $loadingIndicator;
|
|
private TextInput $serverApiKeyInput;
|
|
private Container $todoListContainer;
|
|
private TextInput $todoInput;
|
|
private array $currentServerTodos = [];
|
|
private null|int $currentServerId = null;
|
|
|
|
public function __construct(
|
|
string &$apiKey,
|
|
string &$privateKeyPath,
|
|
TabContainer $tabContainer,
|
|
Label $statusLabel,
|
|
Settings $settings,
|
|
null|KanbanTab $kanbanTab = null,
|
|
) {
|
|
$this->settings = $settings;
|
|
$this->kanbanTab = $kanbanTab;
|
|
$this->statusLabel = $statusLabel;
|
|
$currentApiKey = &$apiKey;
|
|
$currentPrivateKeyPath = &$privateKeyPath;
|
|
|
|
// Create main tab container
|
|
$this->tab = new Container('flex flex-row p-4 gap-4');
|
|
|
|
// Left side: Table with search and refresh
|
|
$leftSide = new Container('flex flex-col gap-2 flex-1');
|
|
|
|
// Header row with refresh button and loading indicator on the right
|
|
$headerRow = new Container('flex flex-row items-center gap-2');
|
|
|
|
// Refresh button
|
|
$this->refreshButton = new Button(
|
|
'Server aktualisieren',
|
|
'flex shadow-lg/50 flex-row gap-2 px-4 py-2 bg-blue-600 rounded hover:bg-blue-700',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$refreshIcon = new Icon(IconName::sync, 16, 'text-white');
|
|
$this->refreshButton->setIcon($refreshIcon);
|
|
$headerRow->addComponent($this->refreshButton);
|
|
|
|
// Bulk action buttons for selected servers
|
|
$rebootButton = new Button(
|
|
'Reboot ausgewählte',
|
|
'px-3 shadow-lg/50 py-2 bg-red-600 rounded hover:bg-red-700',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$updateButton = new Button(
|
|
'Update ausgewählte',
|
|
'px-3 shadow-lg/50 hover:shadow-red-600 py-2 bg-amber-600 rounded hover:bg-amber-700',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$headerRow->addComponent($rebootButton);
|
|
$headerRow->addComponent($updateButton);
|
|
|
|
// Loading indicator (top-right in the server tab header)
|
|
$this->loadingIndicator = new LoadingIndicator('ml-auto');
|
|
$headerRow->addComponent($this->loadingIndicator);
|
|
|
|
$leftSide->addComponent($headerRow);
|
|
|
|
// Search input
|
|
$this->searchInput = new TextInput(
|
|
'Suche...',
|
|
'w-full border border-gray-300 rounded px-3 py-2 bg-white text-black mb-2',
|
|
);
|
|
$leftSide->addComponent($this->searchInput);
|
|
|
|
// Table container with header and virtual list
|
|
$tableContainer = new Container('flex flex-col flex-1 border border-gray-300 rounded');
|
|
|
|
// Table header
|
|
$headerContainer = new Container('flex flex-row w-full bg-gray-200 border-b-2 border-gray-400');
|
|
$columns = [
|
|
[
|
|
'key' => 'selected',
|
|
'title' => '',
|
|
'width' => 40,
|
|
'render' => [$this, 'renderSelectCell'],
|
|
],
|
|
['key' => 'id', 'title' => 'ID', 'width' => 100],
|
|
[
|
|
'key' => 'tasks_indicator',
|
|
'title' => '',
|
|
'width' => 40,
|
|
'render' => [$this, 'renderTasksIndicatorCell'],
|
|
],
|
|
['key' => 'name', 'title' => 'Name'],
|
|
['key' => 'status', 'title' => 'Status', 'width' => 90],
|
|
['key' => 'type', 'title' => 'Typ', 'width' => 80],
|
|
['key' => 'ipv4', 'title' => 'IPv4', 'width' => 150],
|
|
[
|
|
'key' => 'docker_status',
|
|
'title' => 'Docker',
|
|
'width' => 50,
|
|
'render' => [$this, 'renderDockerStatusCell'],
|
|
],
|
|
[
|
|
'key' => 'docker_running',
|
|
'title' => 'R',
|
|
'width' => 50,
|
|
'render' => [$this, 'renderDockerRunningCell'],
|
|
],
|
|
[
|
|
'key' => 'os_version',
|
|
'title' => 'Ubuntu',
|
|
'width' => 180,
|
|
'render' => [$this, 'renderOsVersionCell'],
|
|
],
|
|
['key' => 'release', 'title' => 'Release', 'width' => 140],
|
|
[
|
|
'key' => 'root',
|
|
'title' => 'Root',
|
|
'width' => 50,
|
|
'render' => [$this, 'renderRootCell'],
|
|
],
|
|
[
|
|
'key' => 'data',
|
|
'title' => 'Data',
|
|
'width' => 50,
|
|
'render' => [$this, 'renderDataCell'],
|
|
],
|
|
[
|
|
'key' => 'needs_reboot',
|
|
'title' => 'Neustart',
|
|
'width' => 100,
|
|
'render' => [$this, 'renderNeedsRebootCell'],
|
|
],
|
|
[
|
|
'key' => 'updates_available',
|
|
'title' => 'Updates',
|
|
'width' => 100,
|
|
'render' => [$this, 'renderUpdatesCell'],
|
|
],
|
|
[
|
|
'key' => 'last_backup',
|
|
'title' => 'Letztes Backup',
|
|
'width' => 180,
|
|
'render' => [$this, 'renderLastBackupCell'],
|
|
],
|
|
];
|
|
|
|
// Build header cells
|
|
foreach ($columns as $column) {
|
|
$title = $column['title'] ?? '';
|
|
$width = $column['width'] ?? null;
|
|
|
|
$style = 'px-4 py-2 text-black font-bold border-r border-gray-300';
|
|
if ($width) {
|
|
$style .= ' w-' . ((int) ($width / 4));
|
|
} else {
|
|
$style .= ' flex-1';
|
|
}
|
|
|
|
$headerLabel = new Label($title, $style);
|
|
$headerContainer->addComponent($headerLabel);
|
|
}
|
|
$tableContainer->addComponent($headerContainer);
|
|
|
|
// Virtual List View (Performance-optimized)
|
|
$this->table = new VirtualListView('flex-1 bg-white');
|
|
$this->table->setColumns($columns);
|
|
|
|
// Load initial test data
|
|
$this->currentServerData = HetznerService::generateTestData();
|
|
$this->table->setData($this->currentServerData);
|
|
|
|
$tableContainer->addComponent($this->table);
|
|
$leftSide->addComponent($tableContainer);
|
|
|
|
// Right side: Detail panel
|
|
$detailPanel = new Container(
|
|
'flex flex-col gap-3 w-120 bg-white border-2 border-gray-300 rounded p-4 overflow-y-auto',
|
|
);
|
|
$detailTitle = new Label('Server Details', 'text-xl font-bold text-black mb-2');
|
|
$detailPanel->addComponent($detailTitle);
|
|
|
|
$this->detailId = new Label('-', 'text-sm text-gray-900 font-mono');
|
|
$this->detailName = new Label('-', 'text-lg font-semibold text-black');
|
|
$this->detailStatus = new Label('-', 'text-sm text-gray-700');
|
|
$this->detailType = new Label('-', 'text-sm text-gray-700');
|
|
$this->detailIpv4 = new Label('-', 'text-sm text-gray-700 font-mono');
|
|
|
|
$detailPanel->addComponent(new Label('ID:', 'text-xs text-gray-500'));
|
|
$detailPanel->addComponent($this->detailId);
|
|
$detailPanel->addComponent(new Label('Name:', 'text-xs text-gray-500 mt-2'));
|
|
$detailPanel->addComponent($this->detailName);
|
|
$detailPanel->addComponent(new Label('Status:', 'text-xs text-gray-500 mt-2'));
|
|
$detailPanel->addComponent($this->detailStatus);
|
|
$detailPanel->addComponent(new Label('Typ:', 'text-xs text-gray-500 mt-2'));
|
|
$detailPanel->addComponent($this->detailType);
|
|
$detailPanel->addComponent(new Label('IPv4:', 'text-xs text-gray-500 mt-2'));
|
|
$detailPanel->addComponent($this->detailIpv4);
|
|
|
|
// Domains list
|
|
$detailPanel->addComponent(new Label('Domains:', 'text-xs text-gray-500 mt-2'));
|
|
$this->detailDomainsContainer = new Container('flex flex-col gap-1');
|
|
$detailPanel->addComponent($this->detailDomainsContainer);
|
|
|
|
// SFTP Manager Button (handler will be set by SftpManagerTab)
|
|
$this->sftpButton = new Button(
|
|
'SFTP Manager öffnen',
|
|
'w-full rounded-md bg-blue-500 px-3 py-2 text-sm font-semibold shadow-lg shadow-blue-500/50 focus:outline-none flex flex-row gap-2',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$sftpIcon = new Icon(IconName::folder, 16, 'text-white');
|
|
$this->sftpButton->setIcon($sftpIcon);
|
|
|
|
$detailPanel->addComponent($this->sftpButton);
|
|
|
|
// SSH Terminal Button
|
|
$this->sshTerminalButton = new Button(
|
|
'SSH Terminal öffnen',
|
|
'w-full border border-gray-300 rounded px-3 py-2 flex shadow-lg/100 shadow-lime-300 flex-row gap-2 bg-lime-300 text-black mb-2',
|
|
null,
|
|
'text-black',
|
|
);
|
|
$sshTerminalIcon = new Icon(IconName::terminal, 16, 'text-black');
|
|
$this->sshTerminalButton->setIcon($sshTerminalIcon);
|
|
|
|
$serverListTab = $this;
|
|
$this->sshTerminalButton->setOnClick(function () use ($serverListTab, &$currentPrivateKeyPath) {
|
|
if ($serverListTab->selectedServer === null) {
|
|
$serverListTab->statusLabel->setText('Kein Server ausgewählt');
|
|
return;
|
|
}
|
|
|
|
if (empty($currentPrivateKeyPath) || !file_exists($currentPrivateKeyPath)) {
|
|
$serverListTab->statusLabel->setText('Private Key Pfad nicht konfiguriert');
|
|
return;
|
|
}
|
|
|
|
$host = $serverListTab->selectedServer['ipv4'];
|
|
$keyPath = escapeshellarg($currentPrivateKeyPath);
|
|
$sshCommand = "ssh -i {$keyPath} root@{$host}";
|
|
|
|
$terminals = [
|
|
'gnome-terminal -- ' . $sshCommand,
|
|
'konsole -e ' . $sshCommand,
|
|
'xterm -e ' . $sshCommand,
|
|
'x-terminal-emulator -e ' . $sshCommand,
|
|
];
|
|
|
|
$opened = false;
|
|
foreach ($terminals as $terminalCmd) {
|
|
exec($terminalCmd . ' > /dev/null 2>&1 &', $output, $returnCode);
|
|
if ($returnCode === 0) {
|
|
$opened = true;
|
|
$serverListTab->statusLabel->setText(
|
|
'SSH Terminal geöffnet für ' . $serverListTab->selectedServer['name'],
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$opened) {
|
|
$serverListTab->statusLabel->setText('Konnte kein Terminal öffnen. SSH Befehl: ' . $sshCommand);
|
|
}
|
|
});
|
|
|
|
$detailPanel->addComponent($this->sshTerminalButton);
|
|
|
|
// Per-server API key and TODOs
|
|
$detailPanel->addComponent(new Label('Server API Key:', 'text-xs text-gray-500 mt-2'));
|
|
$this->serverApiKeyInput = new TextInput(
|
|
'Server API Key',
|
|
'w-full border border-gray-300 rounded px-3 py-2 bg-white text-black',
|
|
);
|
|
$detailPanel->addComponent($this->serverApiKeyInput);
|
|
|
|
$saveServerSettingsButton = new Button(
|
|
'Server-Einstellungen speichern',
|
|
'mt-1 px-3 py-2 bg-green-600 rounded hover:bg-green-700',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$detailPanel->addComponent($saveServerSettingsButton);
|
|
|
|
$detailPanel->addComponent(new Label('Tasks für diesen Server:', 'text-xs text-gray-500 mt-3'));
|
|
$this->todoListContainer = new Container('flex flex-col gap-1');
|
|
$detailPanel->addComponent($this->todoListContainer);
|
|
|
|
$todoInputRow = new Container('flex flex-row gap-2 mt-1');
|
|
$this->todoInput = new TextInput(
|
|
'Neue Task...',
|
|
'flex-1 border border-gray-300 rounded px-3 py-2 bg-white text-black',
|
|
);
|
|
$addTodoButton = new Button('+', 'px-3 py-2 bg-blue-600 rounded hover:bg-blue-700', null, 'text-white');
|
|
$todoInputRow->addComponent($this->todoInput);
|
|
$todoInputRow->addComponent($addTodoButton);
|
|
$detailPanel->addComponent($todoInputRow);
|
|
|
|
$this->tab->addComponent($leftSide);
|
|
$this->tab->addComponent($detailPanel);
|
|
|
|
// Setup event handlers
|
|
$this->setupEventHandlers(
|
|
$currentApiKey,
|
|
$currentPrivateKeyPath,
|
|
$rebootButton,
|
|
$updateButton,
|
|
$saveServerSettingsButton,
|
|
$addTodoButton,
|
|
);
|
|
}
|
|
|
|
private function setupEventHandlers(
|
|
string &$currentApiKey,
|
|
string &$currentPrivateKeyPath,
|
|
Button $rebootButton,
|
|
Button $updateButton,
|
|
Button $saveServerSettingsButton,
|
|
Button $addTodoButton,
|
|
): void {
|
|
// Table row selection
|
|
$serverListTab = $this;
|
|
$this->table->setOnRowSelect(function ($index, $row) use ($serverListTab) {
|
|
if ($row) {
|
|
$serverListTab->statusLabel->setText("Server: {$row['name']} - {$row['status']} ({$row['ipv4']})");
|
|
|
|
$serverListTab->detailId->setText("#{$row['id']}");
|
|
$serverListTab->detailName->setText($row['name']);
|
|
$serverListTab->detailStatus->setText($row['status']);
|
|
$serverListTab->detailType->setText($row['type']);
|
|
$serverListTab->detailIpv4->setText($row['ipv4']);
|
|
|
|
// Load per-server settings (API key, todos)
|
|
$serverId = $row['id'] ?? null;
|
|
$serverListTab->currentServerId = is_numeric($serverId) ? ((int) $serverId) : null;
|
|
|
|
if ($serverListTab->currentServerId !== null) {
|
|
$settingsKeyBase = 'servers.' . $serverListTab->currentServerId;
|
|
$apiKey = $serverListTab->settings->get($settingsKeyBase . '.api_key', '');
|
|
|
|
$serverListTab->serverApiKeyInput->setValue($apiKey);
|
|
$serverListTab->loadServerTasks();
|
|
} else {
|
|
$serverListTab->serverApiKeyInput->setValue('');
|
|
$serverListTab->currentServerTodos = [];
|
|
$serverListTab->renderTodoList();
|
|
}
|
|
|
|
$domains = $row['domains'] ?? [];
|
|
$serverListTab->updateDomainDetails(is_array($domains) ? $domains : []);
|
|
|
|
$serverListTab->selectedServer = $row;
|
|
}
|
|
});
|
|
|
|
// Search functionality
|
|
$this->searchInput->setOnChange(function ($value) use ($serverListTab) {
|
|
$searchTerm = strtolower(trim($value));
|
|
|
|
if (empty($searchTerm)) {
|
|
$serverListTab->table->setData($serverListTab->currentServerData);
|
|
} else {
|
|
$filteredData = array_filter($serverListTab->currentServerData, function ($row) use ($searchTerm) {
|
|
return (
|
|
str_contains(strtolower($row['name']), $searchTerm) ||
|
|
count(array_filter($row['domains'], function ($item) use ($searchTerm) {
|
|
return str_contains(strtolower($item), $searchTerm);
|
|
}))
|
|
);
|
|
});
|
|
$serverListTab->table->setData(array_values($filteredData));
|
|
}
|
|
});
|
|
|
|
// Refresh button - use TaskManager directly so we can control the loading indicator
|
|
$this->refreshButton->setOnClick(function () use (&$currentApiKey, $serverListTab, &$currentPrivateKeyPath) {
|
|
$serverListTab->loadingIndicator->setLoading(true);
|
|
|
|
$task = TaskManager::getInstance()->runAsync(function () use (&$currentApiKey) {
|
|
try {
|
|
if (empty($currentApiKey)) {
|
|
return ['error' => 'Kein API-Key konfiguriert'];
|
|
}
|
|
|
|
$hetznerClient = new \LKDev\HetznerCloud\HetznerAPIClient($currentApiKey);
|
|
$servers = [];
|
|
|
|
foreach ($hetznerClient->servers()->all() as $server) {
|
|
$servers[] = [
|
|
'id' => $server->id,
|
|
'name' => $server->name,
|
|
'status' => $server->status,
|
|
'type' => $server->serverType->name,
|
|
'ipv4' => $server->publicNet->ipv4->ip,
|
|
'docker_status' => 'pending',
|
|
'domains' => [],
|
|
];
|
|
}
|
|
|
|
return [
|
|
'success' => true,
|
|
'servers' => $servers,
|
|
'count' => count($servers),
|
|
];
|
|
} catch (\Exception $e) {
|
|
return ['error' => 'Exception: ' . $e->getMessage()];
|
|
}
|
|
});
|
|
|
|
$task->onComplete(function ($result) use (&$serverListTab, &$currentPrivateKeyPath) {
|
|
if (is_array($result)) {
|
|
if (isset($result['error'])) {
|
|
$serverListTab->statusLabel->setText('Fehler: ' . $result['error']);
|
|
echo "Error: {$result['error']}\n";
|
|
} elseif (isset($result['success'], $result['servers'])) {
|
|
// Basisdaten setzen, Docker-Status initial auf "pending"
|
|
$serverListTab->currentServerData = array_map(static fn($row) => array_merge([
|
|
'docker_status' => 'pending',
|
|
'docker_running' => 'pending',
|
|
'docker' => null,
|
|
'docker_error' => null,
|
|
'needs_reboot' => 'unbekannt',
|
|
'updates_available' => 'unbekannt',
|
|
'os_version' => 'unbekannt',
|
|
'release' => 'unbekannt',
|
|
'root' => 'unbekannt',
|
|
'data' => 'unbekannt',
|
|
'last_backup' => 'unbekannt',
|
|
], $row), $result['servers']);
|
|
|
|
$serverListTab->table->setData($serverListTab->currentServerData);
|
|
$serverListTab->statusLabel->setText('Server geladen: ' . $result['count'] . ' gefunden');
|
|
|
|
// Kanban-Board aktualisieren, damit Servernamen in den Karten up-to-date sind
|
|
if ($serverListTab->kanbanTab !== null) {
|
|
$serverListTab->kanbanTab->refresh();
|
|
}
|
|
|
|
if (function_exists('desktop_notify')) {
|
|
desktop_notify(
|
|
'Serverliste aktualisiert',
|
|
'Es wurden ' . $result['count'] . ' Server geladen.',
|
|
['timeout' => 4000, 'urgency' => 'normal'],
|
|
);
|
|
}
|
|
|
|
// Danach: pro Server asynchron Docker-Infos und Systemstatus nachladen
|
|
foreach ($serverListTab->currentServerData as $index => $row) {
|
|
$ip = $row['ipv4'] ?? '';
|
|
|
|
if (empty($ip) || empty($currentPrivateKeyPath) || !file_exists($currentPrivateKeyPath)) {
|
|
$serverListTab->currentServerData[$index]['docker_error'] = 'Kein gültiger Private-Key oder IP';
|
|
$serverListTab->currentServerData[$index]['docker_status'] = 'error';
|
|
$serverListTab->currentServerData[$index]['docker_running'] = 'error';
|
|
continue;
|
|
}
|
|
|
|
$dockerTask = TaskManager::getInstance()->runAsync(function () use (
|
|
$ip,
|
|
$currentPrivateKeyPath,
|
|
$index,
|
|
) {
|
|
try {
|
|
$ssh = new \phpseclib3\Net\SSH2($ip);
|
|
$key = \phpseclib3\Crypt\PublicKeyLoader::loadPrivateKey(file_get_contents(
|
|
$currentPrivateKeyPath,
|
|
));
|
|
|
|
if (!$ssh->login('root', $key)) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => 'fetch usage',
|
|
'docker_error' => 'SSH Login fehlgeschlagen',
|
|
'docker_status' => 'error',
|
|
];
|
|
}
|
|
|
|
// Check if reboot is required (Ubuntu)
|
|
$rebootOutput = trim($ssh->exec(
|
|
'[ -f /var/run/reboot-required ] && echo yes || echo no',
|
|
));
|
|
$needsReboot = $rebootOutput === 'yes';
|
|
|
|
// Check number of available package updates (Ubuntu)
|
|
$updatesOutput = trim($ssh->exec(
|
|
'apt-get -s upgrade 2>/dev/null | grep -c "^Inst " || echo 0',
|
|
));
|
|
$updatesCount = is_numeric($updatesOutput) ? ((int) $updatesOutput) : 0;
|
|
|
|
// Read Ubuntu version (PRETTY_NAME from /etc/os-release)
|
|
$osOutput = trim($ssh->exec(
|
|
'grep "^PRETTY_NAME=" /etc/os-release 2>/dev/null | cut -d= -f2 | tr -d \'"\'',
|
|
));
|
|
$osVersion = $osOutput !== '' ? $osOutput : 'unbekannt';
|
|
|
|
// Last backup from borgmatic
|
|
$lastBackup = 'unbekannt';
|
|
$borgmaticOutput = trim($ssh->exec(
|
|
'borgmatic list --last 1 --json 2>/dev/null || echo ""',
|
|
));
|
|
if ($borgmaticOutput !== '') {
|
|
$borgmaticData = json_decode($borgmaticOutput, true);
|
|
if (
|
|
json_last_error() === JSON_ERROR_NONE &&
|
|
is_array($borgmaticData) &&
|
|
!empty($borgmaticData)
|
|
) {
|
|
// borgmatic list --json gibt ein Array von Repositories zurück
|
|
$firstRepo = reset($borgmaticData);
|
|
if (
|
|
is_array($firstRepo) &&
|
|
isset($firstRepo['archives']) &&
|
|
is_array($firstRepo['archives']) &&
|
|
!empty($firstRepo['archives'])
|
|
) {
|
|
$lastArchive = reset($firstRepo['archives']);
|
|
if (
|
|
is_array($lastArchive) &&
|
|
isset($lastArchive['time']) &&
|
|
is_string($lastArchive['time'])
|
|
) {
|
|
try {
|
|
$backupTime = new \DateTime($lastArchive['time']);
|
|
$lastBackup = $backupTime->format('d.m.Y H:i');
|
|
} catch (\Exception $e) {
|
|
$lastBackup = $lastArchive['time'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Disk usage for / and /data
|
|
$rootUsage = 'unbekannt';
|
|
$dfRoot = trim($ssh->exec('df -P / 2>/dev/null'));
|
|
if ($dfRoot !== '') {
|
|
$lines = preg_split('/\r\n|\r|\n/', $dfRoot);
|
|
if (count($lines) >= 2) {
|
|
$parts = preg_split('/\s+/', trim($lines[1]));
|
|
if (isset($parts[4]) && $parts[4] !== '') {
|
|
$rootUsage = $parts[4];
|
|
}
|
|
}
|
|
}
|
|
|
|
$dataUsage = 'unbekannt';
|
|
$dfData = trim($ssh->exec('df -P /data 2>/dev/null'));
|
|
if ($dfData !== '') {
|
|
$lines = preg_split('/\r\n|\r|\n/', $dfData);
|
|
if (count($lines) >= 2) {
|
|
$parts = preg_split('/\s+/', trim($lines[1]));
|
|
if (isset($parts[4]) && $parts[4] !== '') {
|
|
$dataUsage = $parts[4];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Docker status for main application container
|
|
$runningOutput = trim($ssh->exec(
|
|
"docker ps --filter status=running --format '{{.ID}}' | wc -l",
|
|
));
|
|
$runningCount = is_numeric($runningOutput) ? ((int) $runningOutput) : null;
|
|
|
|
$output = $ssh->exec('docker inspect psc-web-1');
|
|
if (empty($output)) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => null,
|
|
'docker_error' => 'Leere Docker-Antwort',
|
|
'docker_status' => 'error',
|
|
'docker_running' => $runningCount,
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
'root' => $rootUsage,
|
|
'data' => $dataUsage,
|
|
'last_backup' => $lastBackup,
|
|
];
|
|
}
|
|
|
|
$json = json_decode($output, true);
|
|
if (json_last_error() !== JSON_ERROR_NONE) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => null,
|
|
'docker_error' => 'Ungültige Docker-JSON-Antwort',
|
|
'docker_status' => 'error',
|
|
'docker_running' => $runningCount,
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
'root' => $rootUsage,
|
|
'data' => $dataUsage,
|
|
'last_backup' => $lastBackup,
|
|
];
|
|
}
|
|
|
|
$domains = [];
|
|
if (isset($json[0]['Config']['Env']) && is_array($json[0]['Config']['Env'])) {
|
|
$hosts = array_filter($json[0]['Config']['Env'], static function ($item) {
|
|
return is_string($item) && str_starts_with($item, 'LETSENCRYPT_HOST');
|
|
});
|
|
if (!empty($hosts)) {
|
|
$hostEntry = array_first($hosts);
|
|
$hostString = substr((string) $hostEntry, strlen('LETSENCRYPT_HOST='));
|
|
$domains = array_values(array_filter(
|
|
array_map('trim', explode(',', $hostString)),
|
|
static fn($d) => $d !== '',
|
|
));
|
|
}
|
|
}
|
|
|
|
$release = 'unbekannt';
|
|
if (!empty($domains)) {
|
|
$releaseDomain = $domains[0];
|
|
$releaseDomain = trim($releaseDomain);
|
|
if ($releaseDomain !== '') {
|
|
$url = $releaseDomain;
|
|
if (
|
|
!str_starts_with($url, 'http://') &&
|
|
!str_starts_with($url, 'https://')
|
|
) {
|
|
$url = 'https://' . $url;
|
|
}
|
|
$url = rtrim($url, '/') . '/apps/api/system/version';
|
|
|
|
try {
|
|
$context = stream_context_create([
|
|
'http' => [
|
|
'method' => 'GET',
|
|
'timeout' => 5,
|
|
],
|
|
]);
|
|
|
|
$response = file_get_contents($url, false, $context);
|
|
if ($response !== false) {
|
|
$data = json_decode($response, true);
|
|
if (json_last_error() === JSON_ERROR_NONE && is_array($data)) {
|
|
$releaseValue = null;
|
|
if (isset($data['version']) && is_string($data['version'])) {
|
|
$releaseValue = trim($data['version']);
|
|
} elseif (
|
|
isset($data['release']) &&
|
|
is_string($data['release'])
|
|
) {
|
|
$releaseValue = trim($data['release']);
|
|
}
|
|
|
|
$dateValue = null;
|
|
if (isset($data['datum']) && is_string($data['datum'])) {
|
|
$dateValue = trim($data['datum']);
|
|
}
|
|
|
|
if (
|
|
$releaseValue !== null &&
|
|
$dateValue !== null &&
|
|
$dateValue !== ''
|
|
) {
|
|
$release = $releaseValue . ' (' . $dateValue . ')';
|
|
} elseif ($releaseValue !== null) {
|
|
$release = $releaseValue;
|
|
} elseif ($dateValue !== null && $dateValue !== '') {
|
|
$release = $dateValue;
|
|
} else {
|
|
$release = 'unbekannt';
|
|
}
|
|
} else {
|
|
$release = 'Ungültig';
|
|
}
|
|
} else {
|
|
$release = 'Fehler';
|
|
}
|
|
} catch (\Throwable) {
|
|
$release = 'Fehler';
|
|
}
|
|
}
|
|
}
|
|
|
|
return [
|
|
'index' => $index,
|
|
'docker' => $json,
|
|
'docker_error' => null,
|
|
'docker_status' => 'ok',
|
|
'docker_running' => $runningCount,
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
'root' => $rootUsage,
|
|
'data' => $dataUsage,
|
|
'domains' => $domains,
|
|
'release' => $release,
|
|
'last_backup' => $lastBackup,
|
|
];
|
|
} catch (\Throwable $e) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => null,
|
|
'docker_error' => 'SSH-Fehler: ' . $e->getMessage(),
|
|
'docker_status' => 'error',
|
|
'docker_running' => null,
|
|
'needs_reboot' => null,
|
|
'updates' => null,
|
|
'os_version' => null,
|
|
'root' => 'unbekannt',
|
|
'data' => 'unbekannt',
|
|
'last_backup' => 'unbekannt',
|
|
];
|
|
}
|
|
});
|
|
|
|
$dockerTask->onComplete(function ($dockerResult) use (&$serverListTab) {
|
|
if (!is_array($dockerResult) || !isset($dockerResult['index'])) {
|
|
return;
|
|
}
|
|
|
|
$i = $dockerResult['index'];
|
|
if (!isset($serverListTab->currentServerData[$i])) {
|
|
return;
|
|
}
|
|
|
|
if (array_key_exists('docker', $dockerResult)) {
|
|
$serverListTab->currentServerData[$i]['docker'] = $dockerResult['docker'];
|
|
$searchTerm = $serverListTab->searchInput->getValue();
|
|
if (empty($searchTerm)) {
|
|
$serverListTab->table->setData($serverListTab->currentServerData);
|
|
} else {
|
|
$filteredData = array_filter(
|
|
$serverListTab->currentServerData,
|
|
function ($row) use ($searchTerm) {
|
|
return (
|
|
str_contains(strtolower($row['name']), $searchTerm) ||
|
|
count(array_filter($row['domains'], function ($item) use (
|
|
$searchTerm,
|
|
) {
|
|
return str_contains(strtolower($item), $searchTerm);
|
|
}))
|
|
);
|
|
},
|
|
);
|
|
$serverListTab->table->setData(array_values($filteredData));
|
|
}
|
|
}
|
|
|
|
if (array_key_exists('domains', $dockerResult)) {
|
|
$domains = $dockerResult['domains'];
|
|
if (!is_array($domains)) {
|
|
$domains = [];
|
|
}
|
|
$serverListTab->currentServerData[$i]['domains'] = $domains;
|
|
}
|
|
|
|
// Map system status into human-readable table fields
|
|
if (array_key_exists('needs_reboot', $dockerResult)) {
|
|
$needsReboot = $dockerResult['needs_reboot'];
|
|
if ($needsReboot === null) {
|
|
$serverListTab->currentServerData[$i]['needs_reboot'] = 'unbekannt';
|
|
} else {
|
|
$serverListTab->currentServerData[$i]['needs_reboot'] = $needsReboot
|
|
? 'ja'
|
|
: 'nein';
|
|
}
|
|
}
|
|
|
|
if (array_key_exists('updates', $dockerResult)) {
|
|
$updates = (int) ($dockerResult['updates'] ?? 0);
|
|
$serverListTab->currentServerData[$i]['updates_available'] = $updates > 0
|
|
? ('ja (' . $updates . ')')
|
|
: 'nein';
|
|
}
|
|
|
|
if (array_key_exists('os_version', $dockerResult)) {
|
|
$osVersion = $dockerResult['os_version'];
|
|
$serverListTab->currentServerData[$i]['os_version'] = $osVersion !== null
|
|
? $osVersion
|
|
: 'unbekannt';
|
|
}
|
|
|
|
if (array_key_exists('root', $dockerResult)) {
|
|
$rootUsage = $dockerResult['root'];
|
|
$serverListTab->currentServerData[$i]['root'] = $rootUsage !== null
|
|
? $rootUsage
|
|
: 'unbekannt';
|
|
}
|
|
|
|
if (array_key_exists('data', $dockerResult)) {
|
|
$dataUsage = $dockerResult['data'];
|
|
$serverListTab->currentServerData[$i]['data'] = $dataUsage !== null
|
|
? $dataUsage
|
|
: 'unbekannt';
|
|
}
|
|
|
|
if (array_key_exists('release', $dockerResult)) {
|
|
$release = $dockerResult['release'];
|
|
$serverListTab->currentServerData[$i]['release'] = $release !== null
|
|
? $release
|
|
: 'unbekannt';
|
|
}
|
|
|
|
if (array_key_exists('docker_error', $dockerResult)) {
|
|
$serverListTab->currentServerData[$i]['docker_error'] =
|
|
$dockerResult['docker_error'];
|
|
}
|
|
|
|
if (array_key_exists('docker_status', $dockerResult)) {
|
|
$serverListTab->currentServerData[$i]['docker_status'] =
|
|
$dockerResult['docker_status'];
|
|
}
|
|
|
|
if (array_key_exists('docker_running', $dockerResult)) {
|
|
$serverListTab->currentServerData[$i]['docker_running'] =
|
|
$dockerResult['docker_running'] !== null
|
|
? $dockerResult['docker_running']
|
|
: 'unbekannt';
|
|
}
|
|
|
|
if (array_key_exists('last_backup', $dockerResult)) {
|
|
$lastBackup = $dockerResult['last_backup'];
|
|
$serverListTab->currentServerData[$i]['last_backup'] = $lastBackup !== null
|
|
? $lastBackup
|
|
: 'unbekannt';
|
|
}
|
|
});
|
|
|
|
$dockerTask->onError(function ($error) use (&$serverListTab, $index) {
|
|
$errorMsg = is_object($error) && method_exists($error, 'getMessage')
|
|
? $error->getMessage()
|
|
: ((string) $error);
|
|
if (isset($serverListTab->currentServerData[$index])) {
|
|
$serverListTab->currentServerData[$index]['docker_error'] =
|
|
'Async Fehler: ' . $errorMsg;
|
|
$serverListTab->currentServerData[$index]['docker_running'] = 'error';
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
$serverListTab->loadingIndicator->setLoading(false);
|
|
});
|
|
|
|
$task->onError(function ($error) use (&$serverListTab) {
|
|
$errorMsg = is_object($error) && method_exists($error, 'getMessage')
|
|
? $error->getMessage()
|
|
: ((string) $error);
|
|
$serverListTab->statusLabel->setText('Async Fehler: ' . $errorMsg);
|
|
echo "Async error: {$errorMsg}\n";
|
|
|
|
$serverListTab->loadingIndicator->setLoading(false);
|
|
});
|
|
});
|
|
|
|
// Reboot selected servers
|
|
$rebootButton->setOnClick(function () use (&$currentPrivateKeyPath, $serverListTab) {
|
|
$selected = [];
|
|
foreach ($serverListTab->currentServerData as $index => $row) {
|
|
if (!empty($row['selected'])) {
|
|
$selected[] = ['index' => $index, 'row' => $row];
|
|
}
|
|
}
|
|
|
|
if (empty($selected)) {
|
|
$serverListTab->statusLabel->setText('Keine Server ausgewählt für Reboot');
|
|
return;
|
|
}
|
|
|
|
if (empty($currentPrivateKeyPath) || !file_exists($currentPrivateKeyPath)) {
|
|
$serverListTab->statusLabel->setText('Private Key Pfad nicht konfiguriert');
|
|
return;
|
|
}
|
|
|
|
foreach ($selected as $item) {
|
|
$row = $item['row'];
|
|
$ip = $row['ipv4'] ?? '';
|
|
$name = $row['name'] ?? $ip;
|
|
$index = $item['index'];
|
|
|
|
if (empty($ip)) {
|
|
continue;
|
|
}
|
|
|
|
$task = TaskManager::getInstance()->runAsync(function () use ($ip, $currentPrivateKeyPath, $index) {
|
|
try {
|
|
$ssh = new \phpseclib3\Net\SSH2($ip);
|
|
$key = \phpseclib3\Crypt\PublicKeyLoader::loadPrivateKey(file_get_contents(
|
|
$currentPrivateKeyPath,
|
|
));
|
|
|
|
if (!$ssh->login('root', $key)) {
|
|
return [
|
|
'index' => $index,
|
|
'success' => false,
|
|
'error' => 'SSH Login fehlgeschlagen',
|
|
];
|
|
}
|
|
|
|
$ssh->exec('reboot');
|
|
|
|
return [
|
|
'index' => $index,
|
|
'success' => true,
|
|
];
|
|
} catch (\Throwable $e) {
|
|
return [
|
|
'index' => $index,
|
|
'success' => false,
|
|
'error' => 'SSH-Fehler: ' . $e->getMessage(),
|
|
];
|
|
}
|
|
});
|
|
|
|
$task->onComplete(function ($result) use (&$serverListTab, $name) {
|
|
if (!is_array($result) || !array_key_exists('success', $result)) {
|
|
return;
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$serverListTab->statusLabel->setText('Reboot ausgelöst für ' . $name);
|
|
if (function_exists('desktop_notify')) {
|
|
desktop_notify('Reboot gestartet', 'Reboot ausgelöst für ' . $name, [
|
|
'timeout' => 4000,
|
|
'urgency' => 'normal',
|
|
]);
|
|
}
|
|
} elseif (isset($result['error'])) {
|
|
$serverListTab->statusLabel->setText('Reboot Fehler bei ' . $name . ': ' . $result['error']);
|
|
if (function_exists('desktop_notify')) {
|
|
desktop_notify('Reboot fehlgeschlagen', 'Fehler bei ' . $name . ': ' . $result['error'], [
|
|
'timeout' => 6000,
|
|
'urgency' => 'critical',
|
|
]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// Update selected servers
|
|
$updateButton->setOnClick(function () use (&$currentPrivateKeyPath, $serverListTab) {
|
|
$selected = [];
|
|
foreach ($serverListTab->currentServerData as $index => $row) {
|
|
if (!empty($row['selected'])) {
|
|
$selected[] = ['index' => $index, 'row' => $row];
|
|
}
|
|
}
|
|
|
|
if (empty($selected)) {
|
|
$serverListTab->statusLabel->setText('Keine Server ausgewählt für Updates');
|
|
return;
|
|
}
|
|
|
|
if (empty($currentPrivateKeyPath) || !file_exists($currentPrivateKeyPath)) {
|
|
$serverListTab->statusLabel->setText('Private Key Pfad nicht konfiguriert');
|
|
return;
|
|
}
|
|
|
|
foreach ($selected as $item) {
|
|
$row = $item['row'];
|
|
$ip = $row['ipv4'] ?? '';
|
|
$name = $row['name'] ?? $ip;
|
|
$index = $item['index'];
|
|
|
|
if (empty($ip)) {
|
|
continue;
|
|
}
|
|
|
|
$task = TaskManager::getInstance()->runAsync(function () use ($ip, $currentPrivateKeyPath, $index) {
|
|
try {
|
|
$ssh = new \phpseclib3\Net\SSH2($ip);
|
|
$key = \phpseclib3\Crypt\PublicKeyLoader::loadPrivateKey(file_get_contents(
|
|
$currentPrivateKeyPath,
|
|
));
|
|
|
|
if (!$ssh->login('root', $key)) {
|
|
return [
|
|
'index' => $index,
|
|
'success' => false,
|
|
'error' => 'SSH Login fehlgeschlagen',
|
|
];
|
|
}
|
|
|
|
// Run update & upgrade non-interactively and then output reboot + update status in one go
|
|
$statusOutput = trim($ssh->exec('apt-get update >/dev/null 2>&1 && ' .
|
|
'DEBIAN_FRONTEND=noninteractive apt-get -y upgrade >/dev/null 2>&1; ' .
|
|
'reboot_flag=$([ -f /var/run/reboot-required ] && echo yes || echo no); ' .
|
|
'updates=$(apt-get -s upgrade 2>/dev/null | grep -c "^Inst " || echo 0); ' .
|
|
'echo "$reboot_flag $updates"'));
|
|
|
|
$parts = preg_split('/\s+/', $statusOutput);
|
|
$rebootFlag = $parts[0] ?? 'no';
|
|
$updatesCount = isset($parts[1]) && is_numeric($parts[1]) ? ((int) $parts[1]) : 0;
|
|
$needsReboot = $rebootFlag === 'yes';
|
|
|
|
return [
|
|
'index' => $index,
|
|
'success' => true,
|
|
'updates' => $updatesCount,
|
|
'needs_reboot' => $needsReboot,
|
|
];
|
|
} catch (\Throwable $e) {
|
|
return [
|
|
'index' => $index,
|
|
'success' => false,
|
|
'error' => 'SSH-Fehler: ' . $e->getMessage(),
|
|
];
|
|
}
|
|
});
|
|
|
|
$task->onComplete(function ($result) use (&$serverListTab, $name) {
|
|
if (!is_array($result) || !array_key_exists('success', $result)) {
|
|
return;
|
|
}
|
|
|
|
$index = $result['index'] ?? null;
|
|
if ($index !== null && isset($serverListTab->currentServerData[$index])) {
|
|
if (isset($result['updates'])) {
|
|
$updates = (int) $result['updates'];
|
|
$serverListTab->currentServerData[$index]['updates_available'] = $updates > 0
|
|
? ('ja (' . $updates . ')')
|
|
: 'nein';
|
|
}
|
|
|
|
if (array_key_exists('needs_reboot', $result)) {
|
|
$needsReboot = (bool) $result['needs_reboot'];
|
|
$serverListTab->currentServerData[$index]['needs_reboot'] = $needsReboot ? 'ja' : 'nein';
|
|
}
|
|
$searchTerm = $serverListTab->searchInput->getValue();
|
|
if (empty($searchTerm)) {
|
|
$serverListTab->table->setData($serverListTab->currentServerData);
|
|
} else {
|
|
$filteredData = array_filter($serverListTab->currentServerData, function ($row) use (
|
|
$searchTerm,
|
|
) {
|
|
return (
|
|
str_contains(strtolower($row['name']), $searchTerm) ||
|
|
count(array_filter($row['domains'], function ($item) use ($searchTerm) {
|
|
return str_contains(strtolower($item), $searchTerm);
|
|
}))
|
|
);
|
|
});
|
|
$serverListTab->table->setData(array_values($filteredData));
|
|
}
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$serverListTab->statusLabel->setText('Updates ausgeführt für ' . $name);
|
|
if (function_exists('desktop_notify')) {
|
|
desktop_notify('Update erfolgreich', 'Updates ausgeführt für ' . $name, [
|
|
'timeout' => 5000,
|
|
'urgency' => 'normal',
|
|
]);
|
|
}
|
|
} elseif (isset($result['error'])) {
|
|
$serverListTab->statusLabel->setText('Update Fehler bei ' . $name . ': ' . $result['error']);
|
|
if (function_exists('desktop_notify')) {
|
|
desktop_notify('Update fehlgeschlagen', 'Fehler bei ' . $name . ': ' . $result['error'], [
|
|
'timeout' => 6000,
|
|
'urgency' => 'critical',
|
|
]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// Save per-server settings (API key + todos)
|
|
$saveServerSettingsButton->setOnClick(function () use ($serverListTab) {
|
|
if ($serverListTab->currentServerId === null) {
|
|
$serverListTab->statusLabel->setText('Kein Server für das Speichern ausgewählt');
|
|
return;
|
|
}
|
|
|
|
$settingsKeyBase = 'servers.' . $serverListTab->currentServerId;
|
|
$apiKey = trim($serverListTab->serverApiKeyInput->getValue());
|
|
|
|
$serverListTab->settings->set($settingsKeyBase . '.api_key', $apiKey);
|
|
$serverListTab->settings->save();
|
|
|
|
$serverListTab->statusLabel->setText('Server-Einstellungen gespeichert für Server #' .
|
|
$serverListTab->currentServerId);
|
|
});
|
|
|
|
// Add TODO for current server
|
|
$addTodoButton->setOnClick(function () use ($serverListTab) {
|
|
if ($serverListTab->currentServerId === null) {
|
|
$serverListTab->statusLabel->setText('Kein Server für TODO ausgewählt');
|
|
return;
|
|
}
|
|
|
|
$text = trim($serverListTab->todoInput->getValue());
|
|
if ($text === '') {
|
|
return;
|
|
}
|
|
|
|
// Add as Kanban task in board "neu"
|
|
$tasks = $serverListTab->settings->get('kanban.tasks', []);
|
|
if (!is_array($tasks)) {
|
|
$tasks = [];
|
|
}
|
|
|
|
$newTask = [
|
|
'id' => uniqid('task_', true),
|
|
'server_id' => $serverListTab->currentServerId,
|
|
'title' => $text,
|
|
'board' => 'neu',
|
|
];
|
|
|
|
$tasks[] = $newTask;
|
|
|
|
$serverListTab->settings->set('kanban.tasks', $tasks);
|
|
$serverListTab->settings->save();
|
|
|
|
$serverListTab->todoInput->setValue('');
|
|
$serverListTab->loadServerTasks();
|
|
|
|
if ($serverListTab->kanbanTab !== null) {
|
|
$serverListTab->kanbanTab->refresh();
|
|
}
|
|
});
|
|
}
|
|
|
|
public function getContainer(): Container
|
|
{
|
|
return $this->tab;
|
|
}
|
|
|
|
public function getSftpButton(): Button
|
|
{
|
|
return $this->sftpButton;
|
|
}
|
|
|
|
private static function fetchReleaseFromDomain(string $domain): string
|
|
{
|
|
$domain = trim($domain);
|
|
if ($domain === '') {
|
|
return 'unbekannt';
|
|
}
|
|
|
|
$url = $domain;
|
|
if (!str_starts_with($url, 'http://') && !str_starts_with($url, 'https://')) {
|
|
$url = 'https://' . $url;
|
|
}
|
|
|
|
$url = rtrim($url, '/') . '/apps/api/system/version';
|
|
try {
|
|
$context = stream_context_create([
|
|
'http' => [
|
|
'method' => 'GET',
|
|
'timeout' => 5,
|
|
],
|
|
]);
|
|
|
|
$response = file_get_contents($url, false, $context);
|
|
if ($response === false) {
|
|
return 'Fehler';
|
|
}
|
|
|
|
$data = json_decode($response, true);
|
|
if (json_last_error() !== JSON_ERROR_NONE || !is_array($data)) {
|
|
return 'Ungültig';
|
|
}
|
|
|
|
if (isset($data['version']) && is_string($data['version'])) {
|
|
return $data['version'];
|
|
}
|
|
|
|
if (isset($data['release']) && is_string($data['release'])) {
|
|
return $data['release'];
|
|
}
|
|
|
|
return 'unbekannt';
|
|
} catch (\Throwable $e) {
|
|
return 'Fehler';
|
|
}
|
|
}
|
|
|
|
public function renderNeedsRebootCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['needs_reboot'] ?? '');
|
|
$normalized = strtolower(trim($value));
|
|
|
|
$baseStyle = 'px-4 text-sm ';
|
|
|
|
if ($normalized === 'nein') {
|
|
$style = $baseStyle . 'text-green-600';
|
|
} elseif ($normalized === 'ja') {
|
|
$style = $baseStyle . 'text-red-600';
|
|
} else {
|
|
$style = $baseStyle . 'text-gray-600';
|
|
}
|
|
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
public function renderUpdatesCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['updates_available'] ?? '');
|
|
$normalized = strtolower(trim($value));
|
|
|
|
$baseStyle = 'px-4 text-sm ';
|
|
|
|
if ($normalized === 'nein' || $normalized === 'nein (0)') {
|
|
$style = $baseStyle . 'text-green-600';
|
|
} elseif (str_starts_with($normalized, 'ja')) {
|
|
$style = $baseStyle . 'text-red-600';
|
|
} else {
|
|
$style = $baseStyle . 'text-gray-600';
|
|
}
|
|
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
public function renderTasksIndicatorCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$serverId = $rowData['id'] ?? null;
|
|
$hasOpenTasks = false;
|
|
|
|
if ($serverId !== null) {
|
|
$tasks = $this->settings->get('kanban.tasks', []);
|
|
if (is_array($tasks)) {
|
|
$intServerId = (int) $serverId;
|
|
$doneBoard = (string) $this->settings->get('kanban.done_board', 'fertig');
|
|
foreach ($tasks as $task) {
|
|
if (((int) ($task['server_id'] ?? 0)) === $intServerId) {
|
|
$taskBoard = (string) ($task['board'] ?? 'neu');
|
|
if ($taskBoard !== $doneBoard) {
|
|
$hasOpenTasks = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$symbol = '●';
|
|
$baseStyle = 'px-2 text-center text-sm ';
|
|
$style = $baseStyle . ($hasOpenTasks ? 'text-red-500' : 'text-green-500');
|
|
|
|
return new Label($symbol, $style);
|
|
}
|
|
|
|
public function renderDockerStatusCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$status = (string) ($rowData['docker_status'] ?? '');
|
|
$hasError = strtolower(trim($status)) === 'error' || !empty($rowData['docker_error'] ?? null);
|
|
|
|
$baseStyle = 'px-4 text-sm ';
|
|
$style = $hasError ? ($baseStyle . 'text-red-600') : ($baseStyle . 'text-gray-800');
|
|
|
|
return new Label($status, $style);
|
|
}
|
|
|
|
public function renderDockerRunningCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = $rowData['docker_running'] ?? 'unbekannt';
|
|
$baseStyle = 'px-4 text-sm ';
|
|
|
|
$style = $baseStyle . 'text-gray-800';
|
|
$text = (string) $value;
|
|
|
|
if (is_numeric($value)) {
|
|
$count = (int) $value;
|
|
$text = (string) $count;
|
|
if ($count < 6) {
|
|
$style = $baseStyle . 'text-red-600';
|
|
}
|
|
} else {
|
|
$style = $baseStyle . 'text-gray-500 italic';
|
|
}
|
|
|
|
return new Label($text, $style);
|
|
}
|
|
|
|
public function renderOsVersionCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['os_version'] ?? '');
|
|
$normalized = strtolower(trim($value));
|
|
|
|
$baseStyle = 'px-4 text-sm ';
|
|
$style = $baseStyle . 'text-gray-800';
|
|
|
|
if (preg_match('/ubuntu\s+(\d+)\./i', $value, $matches)) {
|
|
$major = (int) ($matches[1] ?? 0);
|
|
if ($major > 0 && $major < 24) {
|
|
$style = $baseStyle . 'text-red-600';
|
|
}
|
|
}
|
|
|
|
if ($normalized === 'unbekannt') {
|
|
$style = $baseStyle . 'text-gray-500 italic';
|
|
}
|
|
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
public function renderRootCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['root'] ?? '');
|
|
return $this->renderDiskUsageCell($value);
|
|
}
|
|
|
|
public function renderDataCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['data'] ?? '');
|
|
return $this->renderDiskUsageCell($value);
|
|
}
|
|
|
|
private function renderDiskUsageCell(string $value): Label
|
|
{
|
|
$trimmed = trim($value);
|
|
$baseStyle = 'px-4 text-sm ';
|
|
|
|
$style = $baseStyle . 'text-gray-800';
|
|
|
|
if ($trimmed === '' || strtolower($trimmed) === 'unbekannt') {
|
|
$style = $baseStyle . 'text-gray-500 italic';
|
|
} else {
|
|
$numeric = $trimmed;
|
|
if (str_ends_with($numeric, '%')) {
|
|
$numeric = substr($numeric, 0, -1);
|
|
}
|
|
if (is_numeric($numeric) && ((int) $numeric) >= 90) {
|
|
$style = $baseStyle . 'text-red-600';
|
|
}
|
|
}
|
|
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
public function renderLastBackupCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['last_backup'] ?? 'unbekannt');
|
|
$normalized = strtolower(trim($value));
|
|
|
|
$baseStyle = 'px-4 text-sm ';
|
|
|
|
if ($normalized === 'unbekannt' || $normalized === '') {
|
|
$style = $baseStyle . 'text-gray-500 italic';
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
// Check if backup is older than 24 hours
|
|
try {
|
|
$backupTime = \DateTime::createFromFormat('d.m.Y H:i', $value);
|
|
if ($backupTime !== false) {
|
|
$now = new \DateTime();
|
|
$diff = $now->diff($backupTime);
|
|
$hoursAgo = ($diff->days * 24) + $diff->h;
|
|
|
|
if ($hoursAgo > 24) {
|
|
$style = $baseStyle . 'text-red-600';
|
|
} else {
|
|
$style = $baseStyle . 'text-green-600';
|
|
}
|
|
} else {
|
|
$style = $baseStyle . 'text-gray-800';
|
|
}
|
|
} catch (\Exception $e) {
|
|
$style = $baseStyle . 'text-gray-800';
|
|
}
|
|
|
|
return new Label($value, $style);
|
|
}
|
|
|
|
private function updateDomainDetails(array $domains): void
|
|
{
|
|
$this->detailDomainsContainer->clearChildren();
|
|
|
|
if (empty($domains)) {
|
|
$this->detailDomainsContainer->addComponent(new Label(
|
|
'Keine Domains gefunden',
|
|
'text-xs text-gray-500 italic',
|
|
));
|
|
return;
|
|
}
|
|
|
|
foreach ($domains as $domain) {
|
|
if (!is_string($domain) || trim($domain) === '') {
|
|
continue;
|
|
}
|
|
|
|
$domain = trim($domain);
|
|
$button = new Button($domain, 'text-sm text-blue-600 hover:text-blue-800 underline text-left');
|
|
|
|
$button->setOnClick(function () use ($domain) {
|
|
$url = $domain;
|
|
if (!str_starts_with($url, 'http://') && !str_starts_with($url, 'https://')) {
|
|
$url = 'https://' . $url;
|
|
}
|
|
|
|
// Versuche, die Domain im Standardbrowser zu öffnen (Linux-Umgebung)
|
|
$escapedUrl = escapeshellarg($url);
|
|
exec("xdg-open {$escapedUrl} > /dev/null 2>&1 &");
|
|
});
|
|
|
|
$this->detailDomainsContainer->addComponent($button);
|
|
}
|
|
}
|
|
|
|
private function renderTodoList(): void
|
|
{
|
|
$this->todoListContainer->clearChildren();
|
|
|
|
if (empty($this->currentServerTodos)) {
|
|
$this->todoListContainer->addComponent(new Label('Keine Tasks', 'text-xs text-gray-500 italic'));
|
|
return;
|
|
}
|
|
|
|
foreach ($this->currentServerTodos as $index => $task) {
|
|
$title = (string) ($task['title'] ?? '');
|
|
$board = (string) ($task['board'] ?? 'neu');
|
|
|
|
$row = new Container('flex flex-row items-center gap-2');
|
|
$row->addComponent(new Label('- ' . $title . ' [' . $board . ']', 'text-xs text-gray-800 flex-1'));
|
|
|
|
$removeButton = new Button(
|
|
'x',
|
|
'px-2 py-1 bg-red-500 rounded hover:bg-red-600',
|
|
null,
|
|
'text-white text-xs',
|
|
);
|
|
|
|
$serverListTab = $this;
|
|
$removeButton->setOnClick(function () use ($serverListTab, $task) {
|
|
$taskId = $task['id'] ?? null;
|
|
if ($taskId === null) {
|
|
return;
|
|
}
|
|
|
|
$tasks = $serverListTab->settings->get('kanban.tasks', []);
|
|
if (!is_array($tasks)) {
|
|
return;
|
|
}
|
|
|
|
$tasks = array_values(array_filter($tasks, static fn($t) => ($t['id'] ?? null) !== $taskId));
|
|
|
|
$serverListTab->settings->set('kanban.tasks', $tasks);
|
|
$serverListTab->settings->save();
|
|
$serverListTab->loadServerTasks();
|
|
|
|
if ($serverListTab->kanbanTab !== null) {
|
|
$serverListTab->kanbanTab->refresh();
|
|
}
|
|
});
|
|
|
|
$row->addComponent($removeButton);
|
|
$this->todoListContainer->addComponent($row);
|
|
}
|
|
}
|
|
|
|
public function renderSelectCell(array $rowData, int $rowIndex): Checkbox
|
|
{
|
|
$isChecked = (bool) ($rowData['selected'] ?? false);
|
|
$checkbox = new Checkbox('', $isChecked);
|
|
|
|
$serverListTab = $this;
|
|
$rowId = $rowData['id'] ?? null;
|
|
$checkbox->setOnChange(function (bool $checked) use (&$serverListTab, &$rowData, $rowId) {
|
|
if ($rowId === null) {
|
|
return;
|
|
}
|
|
|
|
foreach ($serverListTab->currentServerData as $index => $row) {
|
|
if (($row['id'] ?? null) === $rowId) {
|
|
$serverListTab->currentServerData[$index]['selected'] = $checked;
|
|
$serverListTab->table->setData($serverListTab->currentServerData);
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
return $checkbox;
|
|
}
|
|
|
|
private function loadServerTasks(): void
|
|
{
|
|
$this->currentServerTodos = [];
|
|
|
|
if ($this->currentServerId === null) {
|
|
$this->renderTodoList();
|
|
return;
|
|
}
|
|
|
|
$tasks = $this->settings->get('kanban.tasks', []);
|
|
if (!is_array($tasks)) {
|
|
$tasks = [];
|
|
}
|
|
|
|
$this->currentServerTodos = array_values(array_filter($tasks, function ($task) {
|
|
return ((int) ($task['server_id'] ?? 0)) === ((int) $this->currentServerId);
|
|
}));
|
|
|
|
$this->renderTodoList();
|
|
}
|
|
|
|
public function refreshCurrentServerTasks(): void
|
|
{
|
|
$this->loadServerTasks();
|
|
}
|
|
}
|