805 lines
35 KiB
PHP
805 lines
35 KiB
PHP
<?php
|
|
|
|
namespace ServerManager\UI;
|
|
|
|
use PHPNative\Async\TaskManager;
|
|
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\Table;
|
|
use PHPNative\Ui\Widget\TextInput;
|
|
use ServerManager\Services\HetznerService;
|
|
use ServerManager\UI\LoadingIndicator;
|
|
|
|
class ServerListTab
|
|
{
|
|
private Container $tab;
|
|
private Table $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;
|
|
|
|
public function __construct(
|
|
string &$apiKey,
|
|
string &$privateKeyPath,
|
|
TabContainer $tabContainer,
|
|
Label $statusLabel,
|
|
) {
|
|
$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 py-2 bg-red-600 rounded hover:bg-red-700',
|
|
null,
|
|
'text-white',
|
|
);
|
|
$updateButton = new Button(
|
|
'Update ausgewählte',
|
|
'px-3 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
|
|
$this->table = new Table(style: ' flex-1');
|
|
$this->table->setColumns([
|
|
[
|
|
'key' => 'selected',
|
|
'title' => '',
|
|
'width' => 40,
|
|
'render' => [$this, 'renderSelectCell'],
|
|
],
|
|
['key' => 'id', 'title' => 'ID', 'width' => 100],
|
|
['key' => 'name', 'title' => 'Name'],
|
|
['key' => 'status', 'title' => 'Status', 'width' => 90],
|
|
['key' => 'type', 'title' => 'Typ', 'width' => 80],
|
|
['key' => 'ipv4', 'title' => 'IPv4', 'width' => 140],
|
|
['key' => 'docker_status', 'title' => 'Docker', 'width' => 80],
|
|
['key' => 'os_version', 'title' => 'Ubuntu', 'width' => 180],
|
|
[
|
|
'key' => 'needs_reboot',
|
|
'title' => 'Neustart',
|
|
'width' => 110,
|
|
'render' => [$this, 'renderNeedsRebootCell'],
|
|
],
|
|
[
|
|
'key' => 'updates_available',
|
|
'title' => 'Updates',
|
|
'width' => 130,
|
|
'render' => [$this, 'renderUpdatesCell'],
|
|
],
|
|
]);
|
|
|
|
// Load initial test data
|
|
$this->currentServerData = HetznerService::generateTestData();
|
|
$this->table->setData($this->currentServerData);
|
|
|
|
$leftSide->addComponent($this->table);
|
|
|
|
// Right side: Detail panel
|
|
$detailPanel = new Container('flex flex-col gap-3 w-120 bg-white border-2 border-gray-300 rounded p-4');
|
|
$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);
|
|
|
|
$this->tab->addComponent($leftSide);
|
|
$this->tab->addComponent($detailPanel);
|
|
|
|
// Setup event handlers
|
|
$this->setupEventHandlers($currentApiKey, $currentPrivateKeyPath, $rebootButton, $updateButton);
|
|
}
|
|
|
|
private function setupEventHandlers(
|
|
string &$currentApiKey,
|
|
string &$currentPrivateKeyPath,
|
|
Button $rebootButton,
|
|
Button $updateButton,
|
|
): 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']);
|
|
|
|
$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, true);
|
|
} 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), false);
|
|
}
|
|
});
|
|
|
|
// 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' => null,
|
|
'docker_error' => null,
|
|
'needs_reboot' => 'unbekannt',
|
|
'updates_available' => 'unbekannt',
|
|
'os_version' => 'unbekannt',
|
|
], $row), $result['servers']);
|
|
|
|
$serverListTab->table->setData($serverListTab->currentServerData, false);
|
|
$serverListTab->statusLabel->setText('Server geladen: ' . $result['count'] . ' gefunden');
|
|
|
|
// 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';
|
|
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' => null,
|
|
'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';
|
|
|
|
// Docker status for main application container
|
|
$output = $ssh->exec('docker inspect psc-web-1');
|
|
|
|
if (empty($output)) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => null,
|
|
'docker_error' => 'Leere Docker-Antwort',
|
|
'docker_status' => 'error',
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
];
|
|
}
|
|
|
|
$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',
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
];
|
|
}
|
|
|
|
return [
|
|
'index' => $index,
|
|
'docker' => $json,
|
|
'docker_error' => null,
|
|
'docker_status' => 'ok',
|
|
'needs_reboot' => $needsReboot,
|
|
'updates' => $updatesCount,
|
|
'os_version' => $osVersion,
|
|
];
|
|
} catch (\Throwable $e) {
|
|
return [
|
|
'index' => $index,
|
|
'docker' => null,
|
|
'docker_error' => 'SSH-Fehler: ' . $e->getMessage(),
|
|
'docker_status' => 'error',
|
|
'needs_reboot' => null,
|
|
'updates' => null,
|
|
'os_version' => null,
|
|
];
|
|
}
|
|
});
|
|
|
|
$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)) {
|
|
if (isset($dockerResult['docker'][0]['Config']['Env'])) {
|
|
$hosts = array_filter(
|
|
$dockerResult['docker'][0]['Config']['Env'],
|
|
function ($item) {
|
|
if (str_starts_with($item, 'LETSENCRYPT_HOST')) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
);
|
|
$domains = explode(
|
|
',',
|
|
substr(array_first($hosts), strlen('LETSENCRYPT_HOST=')),
|
|
);
|
|
|
|
$serverListTab->currentServerData[$i]['domains'] = $domains;
|
|
}
|
|
$serverListTab->currentServerData[$i]['docker'] = $dockerResult['docker'];
|
|
$serverListTab->table->setData($serverListTab->currentServerData, true);
|
|
}
|
|
|
|
// 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('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'];
|
|
}
|
|
});
|
|
|
|
$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->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);
|
|
} elseif (isset($result['error'])) {
|
|
$serverListTab->statusLabel->setText('Reboot Fehler bei ' . $name . ': ' . $result['error']);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// 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';
|
|
}
|
|
|
|
$serverListTab->table->setData($serverListTab->currentServerData, true);
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$serverListTab->statusLabel->setText('Updates ausgeführt für ' . $name);
|
|
} elseif (isset($result['error'])) {
|
|
$serverListTab->statusLabel->setText('Update Fehler bei ' . $name . ': ' . $result['error']);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
public function getContainer(): Container
|
|
{
|
|
return $this->tab;
|
|
}
|
|
|
|
public function getSftpButton(): Button
|
|
{
|
|
return $this->sftpButton;
|
|
}
|
|
|
|
public function renderNeedsRebootCell(array $rowData, int $rowIndex): Label
|
|
{
|
|
$value = (string) ($rowData['needs_reboot'] ?? '');
|
|
$normalized = strtolower(trim($value));
|
|
|
|
$baseStyle = 'px-4 border-r border-gray-300 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 border-r border-gray-300 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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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, true);
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
return $checkbox;
|
|
}
|
|
}
|