Richard/Deploymentcenter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(setup): Erstinstallation ueber den Update-Agent, Installationskonto, Downloads

Browse Source 
Bisher gab es nur den Update-Weg: eine Anwendung musste bereits installiert und
eingerichtet sein, damit sich etwas aktualisieren liess. Die Erstinstallation
auf einem neuen System war Handarbeit - Paket kopieren, Konfiguration
abtippen, Token besorgen.

Setup-API (neu)
- POST /api/setup/v1/login tauscht Benutzername und Passwort gegen ein Token
  mit 30 Minuten Gueltigkeit und ausschliesslich setup:install. Es wird nicht
  mitgeschrieben und lebt im Installer nur im Speicher.
- GET /api/setup/v1/catalog zeigt nur, was zur Laufzeitkennung des anfragenden
  Systems passt. Ein Projekt mit ausschliesslich Windows-Paket taucht auf einem
  Linux-Rechner gar nicht erst auf.
- POST /api/setup/v1/token stellt das Dauertoken der Anwendung aus. Welche
  Rechte vergeben werden, entscheidet der Server; die Anfrage kann nur
  einschraenken. Sonst waere der Umweg ueber ein kurzlebiges Token wirkungslos.

Rollentrennung (Migration 012)
- dc_users bekommt role, disabled und last_login_at. Die Rolle "installer"
  darf sich ueber den Setup-Weg anmelden und nicht am WebUI. Die Zugangsdaten
  werden auf jedem Zielsystem eingetippt; mit einem Administratorkonto
  verteilte man damit den Zugang zu Tokens, Lizenzen und Monitoren auf jeden
  Rechner, auf dem je etwas installiert wurde.
- Auth::verifyCredentials() prueft sessionfrei, damit Setup- und WebUI-Login
  nicht zwei verschiedene Haertungsgrade haben (Drosselung, Timing-Angleichung,
  Rehash gelten fuer beide).
- Konten mit hinterlegtem TOTP-Geheimnis werden am Setup-Weg mit 501
  abgewiesen. Eine TOTP-Pruefung gibt es im Deploymentcenter noch nicht; sie
  stillschweigend zu uebergehen waere ein Rueckschritt.
- Benutzerverwaltung im WebUI - es gab bisher gar keine, nur den einen von
  install_db.php angelegten Admin. Das letzte aktive Administratorkonto laesst
  sich weder deaktivieren noch loeschen.

Installer
- update-agent --action install fuehrt durch Anmeldung, Auswahl,
  Zielverzeichnis, Installation und Einrichtung. Die Dateien kommen ueber
  denselben Pfad wie ein Update - mit Pruefsumme, Signatur, Staging und
  Rollback. Ein zweiter Download-Weg waere ein zweiter Ort fuer dieselben
  Fehler.
- --action configure holt die Einrichtung nachtraeglich.
- setup.json im Paket beschreibt die benoetigten Werte. Bewusst im Paket und
  nicht zentral: so ist sie mit der Anwendung versioniert.
- Gefragt wird nur, was uebrig bleibt: bereits gesetzt -> detect:... ->
  provision -> fragen. Platzhalter wie changeme oder <dein-wert> gelten dabei
  nicht als eingerichtet, sonst liefe die Anwendung mit der Vorlage los.
- SetupWriter erhaelt vorhandene Inhalte. Eine appsettings.json fuehrt neben
  den abgefragten Werten meist Logging und anderes; sie neu zu erzeugen waere
  bequemer und verloere das - bei einer Neuinstallation ohne Backup.
  int und bool landen als JSON-Typ, nicht als Zeichenkette.

Downloads
- scripts/build_installer.ps1 baut selbstenthaltende Einzeldateien fuer
  win-x64, linux-x64 und linux-arm64 (rund 34 MB, .NET-Laufzeit inbegriffen).
  Ohne NativeAOT und ohne Trimming: Spectre.Console loest ueber Reflexion auf
  und braeche sonst erst beim Anwender.
- scripts/upload_installer.py laedt sie nach /installer/. Getrennt von
  deploy.py, das client-dotnet bewusst ausklammert.
- Bereich "Installer" auf der UpdateService-Seite mit Groessen, Pruefsummen
  und den wget-Befehlen; die Angaben stammen aus installer.json statt aus fest
  eingetragenem Text.
- install.sh und install.ps1 laden, pruefen die Pruefsumme und legen ab -
  sie richten bewusst nichts selbst ein. Das Manifest wird BOM-frei
  geschrieben, sonst scheitert json_decode() daran.

Enthaelt ausserdem die bislang nicht committete Arbeit an den
RocketChat-Benachrichtigungen (Migrationen 010 und 011) sowie die Loesch- und
Editierfunktion des UpdateService; die betroffenen Dateien liessen sich nicht
getrennt stagen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Deploymentcenter Bot
2026-08-13 10:33:26 +02:00
co-authored by Claude Opus 5
parent 2388b5abe1
commit c8f3e78635
34 changed files with 4704 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client-dotnet/Deploymentcenter.Client/SetupWriter.cs
+286
View File
@@ -0,0 +1,286 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
namespace Deploymentcenter.Client
{
/// <summary>Ein zu schreibender Konfigurationswert.</summary>
public sealed class SetupValue
{
public SetupValue(string key, string value, string type = "string")
{
Key = key;
Value = value;
Type = type;
}
/// <summary>Schluessel, Ebenen durch Doppelpunkt getrennt.</summary>
public string Key { get; }
public string Value { get; }
/// <summary>string | secret | url | int | bool | enum</summary>
public string Type { get; }
}
/// <summary>
/// Schreibt ermittelte Werte in die Konfigurationsdateien der Anwendung.
///
/// Durchgaengiges Prinzip: <b>vorhandene Inhalte bleiben erhalten</b>. Eine
/// appsettings.json enthaelt neben den abgefragten Werten fast immer noch
/// Logging-Einstellungen, Feature-Schalter und anderes. Die Datei neu zu
/// erzeugen waere der bequemere Weg und wuerde all das verlieren - und
/// zwar genau bei einer Neuinstallation, bei der niemand ein Backup hat.
/// </summary>
public static class SetupWriter
{
/// <summary>
/// Schreibt Werte in eine JSON-Datei. Ebenen werden aus dem Schluessel
/// gebildet: "ConnectionStrings:Main" wird zu
/// { "ConnectionStrings": { "Main": ... } }.
/// </summary>
public static void WriteJson(string path, IEnumerable<SetupValue> values)
{
JsonObject root = LoadJsonObject(path);
foreach (var value in values)
{
string[] segments = SplitKey(value.Key);
if (segments.Length == 0)
continue;
JsonObject node = root;
// Bis zur vorletzten Ebene hinabsteigen und fehlende Objekte
// anlegen. Steht dort bereits ein Wert, der kein Objekt ist,
// wird er ersetzt - anders liesse sich der Schluessel nicht
// abbilden.
for (int i = 0; i < segments.Length - 1; i++)
{
string segment = segments[i];
if (node[segment] is JsonObject child)
{
node = child;
}
else
{
var created = new JsonObject();
node[segment] = created;
node = created;
}
}
node[segments[segments.Length - 1]] = ToJsonNode(value);
}
EnsureDirectory(path);
var options = new JsonSerializerOptions { WriteIndented = true };
File.WriteAllText(path, root.ToJsonString(options), new UTF8Encoding(false));
}
/// <summary>
/// Schreibt Werte in eine Datei im Stil von <c>.env</c>. Vorhandene
/// Zeilen werden aktualisiert, unbekannte Schluessel angehaengt;
/// Kommentare und Reihenfolge bleiben erhalten.
/// </summary>
public static void WriteEnv(string path, IEnumerable<SetupValue> values)
{
var pending = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var value in values)
{
pending[ToEnvKey(value.Key)] = value.Value;
}
var lines = new List<string>();
if (File.Exists(path))
{
lines.AddRange(File.ReadAllLines(path));
}
for (int i = 0; i < lines.Count; i++)
{
string line = lines[i];
string trimmed = line.TrimStart();
if (trimmed.Length == 0 || trimmed.StartsWith("#", StringComparison.Ordinal))
continue;
int equals = line.IndexOf('=');
if (equals <= 0)
continue;
string key = line.Substring(0, equals).Trim();
if (pending.TryGetValue(key, out string? replacement))
{
lines[i] = key + "=" + QuoteEnv(replacement);
pending.Remove(key);
}
}
foreach (var entry in pending)
{
lines.Add(entry.Key + "=" + QuoteEnv(entry.Value));
}
EnsureDirectory(path);
File.WriteAllLines(path, lines, new UTF8Encoding(false));
}
/// <summary>Schreibt in das Format, das zum Ziel passt.</summary>
public static void Write(string path, string format, IEnumerable<SetupValue> values)
{
if (string.Equals(format, "env", StringComparison.OrdinalIgnoreCase))
{
WriteEnv(path, values);
return;
}
WriteJson(path, values);
}
/// <summary>
/// Liest einen bereits vorhandenen Wert aus einer JSON-Datei, damit der
/// Installer nicht nach etwas fragt, das schon eingerichtet ist.
/// Liefert null, wenn die Datei fehlt oder der Schluessel nicht gesetzt ist.
/// </summary>
public static string? ReadExistingJson(string path, string key)
{
try
{
if (!File.Exists(path))
return null;
JsonNode? node = JsonNode.Parse(File.ReadAllText(path));
foreach (string segment in SplitKey(key))
{
if (node is not JsonObject obj)
return null;
node = obj[segment];
if (node == null)
return null;
}
if (node is JsonValue value)
{
return value.ToString();
}
return null;
}
catch
{
return null;
}
}
// ------------------------------------------------------------------
private static JsonObject LoadJsonObject(string path)
{
if (!File.Exists(path))
return new JsonObject();
try
{
string content = File.ReadAllText(path);
if (string.IsNullOrWhiteSpace(content))
return new JsonObject();
// Kommentare und nachgestellte Kommata sind in appsettings.json
// verbreitet, obwohl JSON sie nicht kennt.
var options = new JsonNodeOptions { PropertyNameCaseInsensitive = false };
var documentOptions = new JsonDocumentOptions
{
CommentHandling = JsonCommentHandling.Skip,
AllowTrailingCommas = true
};
JsonNode? parsed = JsonNode.Parse(content, options, documentOptions);
return parsed as JsonObject ?? new JsonObject();
}
catch (JsonException)
{
// Eine unlesbare Datei zu ueberschreiben hiesse, unbekannten
// Inhalt zu verwerfen. Stattdessen wird sie zur Seite gelegt.
string backup = path + ".unlesbar-" + DateTime.UtcNow.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture);
try { File.Copy(path, backup, overwrite: false); } catch { }
return new JsonObject();
}
}
private static JsonNode? ToJsonNode(SetupValue value)
{
switch ((value.Type ?? string.Empty).ToLowerInvariant())
{
case "int":
return long.TryParse(value.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out long number)
? JsonValue.Create(number)
: JsonValue.Create(value.Value);
case "bool":
return bool.TryParse(value.Value, out bool flag)
? JsonValue.Create(flag)
: JsonValue.Create(value.Value);
default:
return JsonValue.Create(value.Value);
}
}
private static string[] SplitKey(string key)
{
return (key ?? string.Empty)
.Split(new[] { ':', '.' }, StringSplitOptions.RemoveEmptyEntries);
}
/// <summary>
/// "ConnectionStrings:Main" wird zu CONNECTIONSTRINGS__MAIN - die
/// Schreibweise, die .NET fuer Umgebungsvariablen erwartet.
/// </summary>
private static string ToEnvKey(string key)
{
if (string.IsNullOrEmpty(key))
return key ?? string.Empty;
// Enthaelt der Schluessel bereits Unterstriche und keine Trenner,
// ist er vermutlich schon eine Umgebungsvariable.
if (key.IndexOf(':') < 0 && key.IndexOf('.') < 0)
return key;
return string.Join("__", SplitKey(key).Select(s => s.ToUpperInvariant()));
}
private static string QuoteEnv(string value)
{
if (value == null)
return string.Empty;
bool needsQuotes = value.Length == 0
|| value.IndexOfAny(new[] { ' ', '\t', '"', '\'', '#', '$' }) >= 0;
if (!needsQuotes)
return value;
return "\"" + value.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
}
private static void EnsureDirectory(string path)
{
string? dir = Path.GetDirectoryName(path);
if (!string.IsNullOrEmpty(dir))
{
Directory.CreateDirectory(dir);
}
}
}
}