Deploymentcenter Bot
087f4392a9
- .NET 10 Migration: Alle .NET-Projekte auf net10.0 umgestellt (#459) - Client-SDK: ResolveAgentPath bereinigt und DLL-Pruefung ergaenzt (#458) - Packager: Commit-Ermittlung aus publishDir / Assembly InformationalVersion (#456) - BuildInfo.targets: ExitCode-Abfang und Regex-Validierung gegen Git-Fehlertexte (#363) - UpdateService: Re-Publish erhaelt bestehende Manifeste und Werte (#457) - Bugtracker API: on_roadmap-Filter in manage?action=list durchgereicht (#349) - Watchdog API: project_slug-Filter in GET /status ergaenzt (#420) - UpdateService API: no_release_for_platform mit verfuegbaren Plattformen (#421) - Bugtracker Core: Fehler-Normalisierung gegen zersplitterte error_hashes (#419) - UpdateAgent: Kopfloser Installationsmodus via --answers (#89) - Installer & Agent: Automatische Selbstaktualisierung beim Start - Tooling: AGENTS.md, CLAUDE.md und Standalone-CLI scripts/dc.py hinzugefuegt
1075 lines
42 KiB
C#
1075 lines
42 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using Deploymentcenter.Client;
|
|
using Deploymentcenter.Client.Models;
|
|
using Spectre.Console;
|
|
|
|
namespace Deploymentcenter.UpdateAgent
|
|
{
|
|
/// <summary>
|
|
/// Erstinstallation einer Anwendung.
|
|
///
|
|
/// Der Ablauf ist bewusst so geschnitten, dass er den vorhandenen
|
|
/// Update-Weg wiederverwendet: erst kommen die Dateien ins Zielverzeichnis
|
|
/// (mit Pruefsumme, Signatur und Rollback wie bei jedem Update), danach
|
|
/// wird konfiguriert. Ein zweiter Download-Pfad waere ein zweiter Ort, an
|
|
/// dem dieselben Fehler wieder entstehen koennen.
|
|
///
|
|
/// Gefragt wird nur nach dem, was sich nicht anders ermitteln laesst -
|
|
/// siehe <see cref="ResolveFields"/>.
|
|
/// </summary>
|
|
internal static class Installation
|
|
{
|
|
private const string SetupFileName = "setup.json";
|
|
|
|
public static async Task<int> RunAsync(AgentOptions options, HttpClient http)
|
|
{
|
|
if (options.Unattended)
|
|
{
|
|
return await RunUnattendedAsync(options, http);
|
|
}
|
|
|
|
AnsiConsole.Write(
|
|
new FigletText("Installer")
|
|
.LeftJustified()
|
|
.Color(Color.DodgerBlue1));
|
|
|
|
// ----------------------------------------------------------
|
|
// 1. Anmeldung
|
|
// ----------------------------------------------------------
|
|
string baseUrl = AnsiConsole.Prompt(
|
|
new TextPrompt<string>("[bold]Deploymentcenter[/]:")
|
|
.DefaultValue(options.BaseUrl)
|
|
.Validate(value => value.StartsWith("http", StringComparison.OrdinalIgnoreCase)
|
|
? ValidationResult.Success()
|
|
: ValidationResult.Error("[red]Bitte eine vollstaendige Adresse angeben.[/]")));
|
|
|
|
options.BaseUrl = baseUrl.TrimEnd('/');
|
|
|
|
var client = new SetupClient(options.BaseUrl, http);
|
|
SetupSession session;
|
|
|
|
while (true)
|
|
{
|
|
string username = AnsiConsole.Prompt(new TextPrompt<string>("[bold]Benutzer[/]:"));
|
|
string password = AnsiConsole.Prompt(new TextPrompt<string>("[bold]Passwort[/]:").Secret());
|
|
|
|
try
|
|
{
|
|
session = await client.LoginAsync(username, password, Environment.MachineName);
|
|
|
|
// Dieselben Zugangsdaten oeffnen die Release-Ablage. Das
|
|
// Setup-Token taugt dafuer nicht: /releases/ liegt hinter
|
|
// HTTP-Basic-Auth und wird von Apache geprueft, nicht von
|
|
// der Anwendung. Bei einer Erstinstallation gibt es zudem
|
|
// noch keinen Lizenzschluessel.
|
|
options.Credentials = ReleaseCredentials.FromUser(username, password);
|
|
break;
|
|
}
|
|
catch (SetupException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{Markup.Escape(ex.Message)}[/]");
|
|
|
|
if (ex.Code == "locked_out" || ex.Code == "rate_limited")
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (!AnsiConsole.Confirm("Erneut versuchen?"))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
catch (HttpRequestException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Keine Verbindung zum Deploymentcenter: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
AnsiConsole.MarkupLine($"[green]Angemeldet.[/] [grey]Die Sitzung laeuft in "
|
|
+ $"{(int)session.Remaining.TotalMinutes} Minuten ab.[/]");
|
|
|
|
if (session.Role == "admin")
|
|
{
|
|
AnsiConsole.MarkupLine(
|
|
"[yellow]Hinweis: Das ist ein Administratorkonto. Fuer Zielsysteme ist ein Konto "
|
|
+ "der Rolle [bold]installer[/] gedacht - es kann sich nicht am WebUI anmelden.[/]");
|
|
}
|
|
|
|
// ----------------------------------------------------------
|
|
// 2. Auswahl
|
|
// ----------------------------------------------------------
|
|
List<CatalogEntry> catalog;
|
|
try
|
|
{
|
|
catalog = await client.GetCatalogAsync(options.Platform);
|
|
}
|
|
catch (SetupException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Katalog nicht abrufbar: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
|
|
if (catalog.Count == 0)
|
|
{
|
|
AnsiConsole.MarkupLine(
|
|
$"[yellow]Fuer die Plattform [bold]{Markup.Escape(options.Platform)}[/] ist nichts hinterlegt.[/]");
|
|
AnsiConsole.MarkupLine("[grey]Releases ohne Plattformangabe gelten als \"any\" und waeren hier "
|
|
+ "sichtbar. Moeglicherweise wurde nur fuer eine andere Plattform veroeffentlicht.[/]");
|
|
return 1;
|
|
}
|
|
|
|
var chosen = AnsiConsole.Prompt(
|
|
new SelectionPrompt<CatalogEntry>()
|
|
.Title("\n[bold]Welche Anwendung soll installiert werden?[/]")
|
|
.PageSize(12)
|
|
.UseConverter(entry =>
|
|
{
|
|
string versions = string.Join(", ",
|
|
entry.Channels.Select(c => $"{c.Channel} {c.Version}"));
|
|
return $"{Markup.Escape(entry.Name)} [grey]({Markup.Escape(versions)})[/]";
|
|
})
|
|
.AddChoices(catalog));
|
|
|
|
CatalogChannel channel = chosen.Channels.Count == 1
|
|
? chosen.Channels[0]
|
|
: AnsiConsole.Prompt(
|
|
new SelectionPrompt<CatalogChannel>()
|
|
.Title($"\n[bold]Welcher Kanal von {Markup.Escape(chosen.Name)}?[/]")
|
|
.UseConverter(c =>
|
|
{
|
|
string mark = c.Signed ? "" : " [yellow](unsigniert)[/]";
|
|
return $"{c.Channel} - v{c.Version}{mark}";
|
|
})
|
|
.AddChoices(chosen.Channels));
|
|
|
|
if (!channel.Signed)
|
|
{
|
|
AnsiConsole.MarkupLine("[yellow]Dieses Release ist nicht signiert - die Herkunft laesst sich "
|
|
+ "nicht pruefen.[/]");
|
|
if (options.RequireSignature)
|
|
{
|
|
AnsiConsole.MarkupLine("[red]Abbruch: --require-signature ist gesetzt.[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------
|
|
// 3. Zielverzeichnis
|
|
// ----------------------------------------------------------
|
|
string suggested = SuggestTargetDirectory(chosen.Slug);
|
|
|
|
string targetDir = AnsiConsole.Prompt(
|
|
new TextPrompt<string>("[bold]Zielverzeichnis[/]:").DefaultValue(suggested));
|
|
|
|
targetDir = Path.GetFullPath(targetDir);
|
|
|
|
if (Directory.Exists(targetDir) && Directory.GetFileSystemEntries(targetDir).Length > 0)
|
|
{
|
|
AnsiConsole.MarkupLine($"[yellow]{Markup.Escape(targetDir)} ist nicht leer.[/]");
|
|
if (!AnsiConsole.Confirm("Trotzdem dorthin installieren?", false))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
options.Project = chosen.Slug;
|
|
options.Channel = channel.Channel;
|
|
options.TargetDir = targetDir;
|
|
|
|
// ----------------------------------------------------------
|
|
// 4. Dateien uebertragen - ueber den regulaeren Update-Weg
|
|
// ----------------------------------------------------------
|
|
AnsiConsole.MarkupLine($"\n[bold]Installiere {Markup.Escape(chosen.Name)} v{channel.Version} "
|
|
+ $"nach {Markup.Escape(targetDir)}[/]\n");
|
|
|
|
int fileResult = await Program.DoUpdateOrRepair(options, channel.Version, null);
|
|
if (fileResult != 0)
|
|
{
|
|
return fileResult;
|
|
}
|
|
|
|
// ----------------------------------------------------------
|
|
// 5. Laeuft das hier ueberhaupt?
|
|
// ----------------------------------------------------------
|
|
// Erst jetzt zu pruefen hat einen Grund: was die Anwendung
|
|
// braucht, steht in ihrer runtimeconfig.json - und die liegt erst
|
|
// vor, wenn die Dateien da sind. Vorher waere jede Aussage
|
|
// geraten, und ein eigenstaendig veroeffentlichtes Paket bekaeme
|
|
// eine Warnung, die auf es nicht zutrifft.
|
|
var runtime = RuntimeCheck.Inspect(targetDir);
|
|
bool runtimeOk = RuntimeCheck.Report(runtime);
|
|
|
|
// ----------------------------------------------------------
|
|
// 6. Einrichten
|
|
// ----------------------------------------------------------
|
|
int configured = await ConfigureAsync(options, client, chosen.Slug, interactive: true);
|
|
if (configured != 0)
|
|
{
|
|
return configured;
|
|
}
|
|
|
|
// ----------------------------------------------------------
|
|
// 7. Ueberwachung dieser Maschine
|
|
// ----------------------------------------------------------
|
|
await Monitoring.OfferAsync(options, client, chosen.Slug, interactive: true);
|
|
|
|
// Zum Schluss noch einmal: zwischen der Meldung oben und dem Ende
|
|
// des Ablaufs liegen inzwischen Einrichtung und Ueberwachung, und
|
|
// eine fehlende Laufzeit ist das Einzige, was den Start dieser
|
|
// Anwendung sicher verhindert.
|
|
if (!runtimeOk)
|
|
{
|
|
AnsiConsole.WriteLine();
|
|
AnsiConsole.MarkupLine("[bold yellow]Nicht vergessen: ohne die fehlende .NET-Laufzeit startet "
|
|
+ "die Anwendung nicht.[/]");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nur die Einrichtung, ohne Dateien anzufassen. Nuetzlich, wenn die
|
|
/// Installation stand, die Konfiguration aber nachgeholt oder
|
|
/// korrigiert werden muss.
|
|
/// </summary>
|
|
public static async Task<int> ConfigureOnlyAsync(AgentOptions options, HttpClient http)
|
|
{
|
|
if (options.Unattended)
|
|
{
|
|
return await ConfigureUnattendedOnlyAsync(options, http);
|
|
}
|
|
|
|
string setupPath = Path.Combine(options.TargetDir, SetupFileName);
|
|
|
|
if (!File.Exists(setupPath))
|
|
{
|
|
AnsiConsole.MarkupLine($"[yellow]In {Markup.Escape(options.TargetDir)} liegt keine "
|
|
+ $"{SetupFileName} - es gibt nichts einzurichten.[/]");
|
|
return 0;
|
|
}
|
|
|
|
var client = new SetupClient(options.BaseUrl, http);
|
|
|
|
// Ein Token wird nur gebraucht, wenn die Beschreibung ein Feld mit
|
|
// source = provision enthaelt. Danach richtet sich, ob ueberhaupt
|
|
// nach Zugangsdaten gefragt wird.
|
|
var definition = ReadDefinition(setupPath);
|
|
if (definition == null)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
bool needsToken = definition.Fields.Any(f =>
|
|
string.Equals(f.Source, "provision", StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (needsToken)
|
|
{
|
|
AnsiConsole.MarkupLine("[grey]Fuer ein Anwendungstoken ist eine Anmeldung noetig.[/]");
|
|
|
|
string username = AnsiConsole.Prompt(new TextPrompt<string>("[bold]Benutzer[/]:"));
|
|
string password = AnsiConsole.Prompt(new TextPrompt<string>("[bold]Passwort[/]:").Secret());
|
|
|
|
try
|
|
{
|
|
await client.LoginAsync(username, password, Environment.MachineName);
|
|
options.Credentials = ReleaseCredentials.FromUser(username, password);
|
|
}
|
|
catch (SetupException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return await ConfigureAsync(options, client, options.Project, interactive: true);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
private static async Task<int> ConfigureAsync(
|
|
AgentOptions options,
|
|
SetupClient client,
|
|
string project,
|
|
bool interactive)
|
|
{
|
|
string setupPath = Path.Combine(options.TargetDir, SetupFileName);
|
|
|
|
if (!File.Exists(setupPath))
|
|
{
|
|
AnsiConsole.MarkupLine($"\n[green]Fertig.[/] [grey]Das Paket bringt keine {SetupFileName} mit, "
|
|
+ "es ist also nichts einzurichten.[/]");
|
|
return 0;
|
|
}
|
|
|
|
var definition = ReadDefinition(setupPath);
|
|
if (definition == null)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (definition.Schema > 1)
|
|
{
|
|
AnsiConsole.MarkupLine($"[yellow]Die {SetupFileName} verwendet Schema {definition.Schema}; "
|
|
+ "dieser Installer kennt Schema 1. Unbekannte Angaben werden uebergangen.[/]");
|
|
}
|
|
|
|
AnsiConsole.Write(new Rule("[bold]Einrichtung[/]").LeftJustified());
|
|
|
|
if (definition.Description.Length > 0)
|
|
{
|
|
AnsiConsole.MarkupLine($"[grey]{Markup.Escape(definition.Description)}[/]\n");
|
|
}
|
|
|
|
var resolved = await ResolveFields(definition, options, client, project, interactive);
|
|
if (resolved == null)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
// Werte den Zieldateien zuordnen und schreiben.
|
|
var targets = definition.Targets.Count > 0
|
|
? definition.Targets
|
|
: new List<SetupTarget> { new SetupTarget { File = "appsettings.json", Format = "json" } };
|
|
|
|
foreach (var target in targets)
|
|
{
|
|
var forTarget = resolved
|
|
.Where(pair => BelongsToTarget(pair.Field, target, targets))
|
|
// IsSecret ausdruecklich weiterreichen: ein per provision
|
|
// geholtes Token traegt oft den Typ "string", muss die
|
|
// Datei aber trotzdem auf den eigenen Benutzer beschraenken.
|
|
.Select(pair => new SetupValue(
|
|
pair.Field.Key, pair.Value, pair.Field.Type, pair.Field.IsSecret))
|
|
.ToList();
|
|
|
|
if (forTarget.Count == 0)
|
|
continue;
|
|
|
|
string path = SetupPaths.Resolve(target, options.TargetDir);
|
|
|
|
try
|
|
{
|
|
SetupWriter.Write(path, target.Format, forTarget);
|
|
|
|
// Den aufgeloesten Pfad ausgeben, nicht die Angabe aus der
|
|
// setup.json: Bei location=config entscheidet die Umgebung,
|
|
// und wer den Installer unter einem anderen Konto startet
|
|
// als den Dienst, muss das sehen koennen.
|
|
AnsiConsole.MarkupLine($"[green]Geschrieben:[/] {Markup.Escape(path)} "
|
|
+ $"[grey]({forTarget.Count} Wert(e))[/]");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{Markup.Escape(target.File)} konnte nicht geschrieben werden: "
|
|
+ $"{Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
AnsiConsole.MarkupLine("\n[bold green]Installation abgeschlossen.[/]");
|
|
AnsiConsole.MarkupLine($"[grey]Verzeichnis: {Markup.Escape(options.TargetDir)}[/]");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ermittelt jeden Wert und fragt nur nach dem, was uebrig bleibt.
|
|
///
|
|
/// Reihenfolge je Feld:
|
|
/// 1. bereits in der Zieldatei gesetzt -> uebernehmen, nicht fragen
|
|
/// 2. source = detect:... -> aus dem System ableiten
|
|
/// 3. source = provision -> Token beim Server holen
|
|
/// 4. sonst -> fragen, mit default vorbelegt
|
|
/// </summary>
|
|
private static async Task<List<(SetupField Field, string Value)>?> ResolveFields(
|
|
SetupDefinition definition,
|
|
AgentOptions options,
|
|
SetupClient client,
|
|
string project,
|
|
bool interactive)
|
|
{
|
|
var resolved = new List<(SetupField, string)>();
|
|
var targets = definition.Targets;
|
|
|
|
int answered = 0;
|
|
int automatic = 0;
|
|
int kept = 0;
|
|
|
|
foreach (var field in definition.Fields)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(field.Key))
|
|
continue;
|
|
|
|
// 1. Schon eingerichtet?
|
|
var target = FindTarget(field, targets);
|
|
if (target != null && string.Equals(target.Format, "json", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// Muss denselben Pfad ergeben wie beim Schreiben - sonst
|
|
// prueft der Installer eine andere Datei, als er anlegt.
|
|
string path = SetupPaths.Resolve(target, options.TargetDir);
|
|
|
|
string? existing = SetupWriter.ReadExistingJson(path, field.Key);
|
|
|
|
if (!string.IsNullOrWhiteSpace(existing) && !IsPlaceholder(existing!))
|
|
{
|
|
AnsiConsole.MarkupLine($"[grey]Bereits gesetzt:[/] {Markup.Escape(field.Key)}");
|
|
kept++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 2. Ableitbar?
|
|
string? detected = Detect(field.Source, options, project);
|
|
if (detected != null)
|
|
{
|
|
resolved.Add((field, detected));
|
|
AnsiConsole.MarkupLine($"[grey]Ermittelt:[/] {Markup.Escape(field.Key)} = {Markup.Escape(detected)}");
|
|
automatic++;
|
|
continue;
|
|
}
|
|
|
|
// 3. Token anfordern?
|
|
if (string.Equals(field.Source, "provision", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
try
|
|
{
|
|
var scopes = field.Scopes.Count > 0 ? field.Scopes : new List<string> { "watchdog:ping" };
|
|
string token = await client.RequestApplicationTokenAsync(
|
|
project, scopes, Environment.MachineName);
|
|
|
|
resolved.Add((field, token));
|
|
AnsiConsole.MarkupLine($"[grey]Token ausgestellt:[/] {Markup.Escape(field.Key)} "
|
|
+ $"[grey]({Markup.Escape(string.Join(", ", scopes))})[/]");
|
|
automatic++;
|
|
continue;
|
|
}
|
|
catch (SetupException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Token fuer {Markup.Escape(field.Key)} nicht erhalten: "
|
|
+ $"{Markup.Escape(ex.Message)}[/]");
|
|
|
|
if (field.Required)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 4. Fragen.
|
|
if (!interactive)
|
|
{
|
|
if (field.Default.Length > 0)
|
|
{
|
|
resolved.Add((field, field.Default));
|
|
continue;
|
|
}
|
|
|
|
if (field.Required)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Ohne Rueckfrage nicht ermittelbar: {Markup.Escape(field.Key)}[/]");
|
|
return null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
string? answer = Ask(field);
|
|
|
|
if (answer == null)
|
|
{
|
|
// Nicht ausgefuellt und nicht erforderlich.
|
|
continue;
|
|
}
|
|
|
|
resolved.Add((field, answer));
|
|
answered++;
|
|
}
|
|
|
|
AnsiConsole.MarkupLine($"\n[grey]{automatic} Wert(e) automatisch ermittelt, {kept} bereits "
|
|
+ $"vorhanden, {answered} abgefragt.[/]");
|
|
|
|
return resolved.Select(r => (r.Item1, r.Item2)).ToList();
|
|
}
|
|
|
|
private static string? Ask(SetupField field)
|
|
{
|
|
string label = field.Label.Length > 0 ? field.Label : field.Key;
|
|
|
|
if (field.Help.Length > 0)
|
|
{
|
|
AnsiConsole.MarkupLine($"[grey]{Markup.Escape(field.Help)}[/]");
|
|
}
|
|
|
|
// Auswahl aus festen Moeglichkeiten.
|
|
if (string.Equals(field.Type, "enum", StringComparison.OrdinalIgnoreCase) && field.Options.Count > 0)
|
|
{
|
|
return AnsiConsole.Prompt(
|
|
new SelectionPrompt<string>()
|
|
.Title($"[bold]{Markup.Escape(label)}[/]:")
|
|
.AddChoices(field.Options));
|
|
}
|
|
|
|
if (string.Equals(field.Type, "bool", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
bool preset = bool.TryParse(field.Default, out bool parsed) && parsed;
|
|
return AnsiConsole.Confirm($"[bold]{Markup.Escape(label)}[/]?", preset)
|
|
? "true"
|
|
: "false";
|
|
}
|
|
|
|
var prompt = new TextPrompt<string>($"[bold]{Markup.Escape(label)}[/]:");
|
|
|
|
if (field.IsSecret)
|
|
{
|
|
prompt.Secret();
|
|
}
|
|
|
|
if (field.Default.Length > 0)
|
|
{
|
|
prompt.DefaultValue(field.Default);
|
|
|
|
// Ein vorbelegtes Geheimnis darf nicht im Klartext erscheinen.
|
|
if (field.IsSecret)
|
|
{
|
|
prompt.HideDefaultValue();
|
|
}
|
|
}
|
|
else if (!field.Required)
|
|
{
|
|
prompt.AllowEmpty();
|
|
}
|
|
|
|
var validate = BuildValidator(field);
|
|
if (validate != null)
|
|
{
|
|
prompt.Validate(validate);
|
|
}
|
|
|
|
string answer = AnsiConsole.Prompt(prompt);
|
|
|
|
return answer.Length == 0 && !field.Required ? null : answer;
|
|
}
|
|
|
|
private static Func<string, ValidationResult>? BuildValidator(SetupField field)
|
|
{
|
|
Regex? pattern = null;
|
|
|
|
if (field.Validate.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
pattern = new Regex(field.Validate, RegexOptions.CultureInvariant);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
// Ein fehlerhafter Ausdruck in der setup.json darf die
|
|
// Installation nicht verhindern - dann wird eben nicht
|
|
// geprueft.
|
|
AnsiConsole.MarkupLine($"[yellow]Pruefmuster fuer {Markup.Escape(field.Key)} ist ungueltig "
|
|
+ "und wird uebergangen.[/]");
|
|
}
|
|
}
|
|
|
|
string type = (field.Type ?? "string").ToLowerInvariant();
|
|
|
|
if (pattern == null && type != "int" && type != "url")
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string message = field.ValidationMessage.Length > 0
|
|
? field.ValidationMessage
|
|
: "Die Eingabe passt nicht zum erwarteten Format.";
|
|
|
|
return value =>
|
|
{
|
|
if (value.Length == 0 && !field.Required)
|
|
{
|
|
return ValidationResult.Success();
|
|
}
|
|
|
|
if (type == "int" && !long.TryParse(value, out _))
|
|
{
|
|
return ValidationResult.Error("[red]Bitte eine ganze Zahl eingeben.[/]");
|
|
}
|
|
|
|
if (type == "url"
|
|
&& !Uri.TryCreate(value, UriKind.Absolute, out var uri))
|
|
{
|
|
return ValidationResult.Error("[red]Bitte eine vollstaendige Adresse eingeben.[/]");
|
|
}
|
|
|
|
if (pattern != null && !pattern.IsMatch(value))
|
|
{
|
|
return ValidationResult.Error($"[red]{Markup.Escape(message)}[/]");
|
|
}
|
|
|
|
return ValidationResult.Success();
|
|
};
|
|
}
|
|
|
|
/// <summary>Werte, die sich aus dem System selbst ergeben.</summary>
|
|
private static string? Detect(string source, AgentOptions options, string project)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(source)
|
|
|| !source.StartsWith("detect:", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string what = source.Substring("detect:".Length).Trim().ToLowerInvariant();
|
|
|
|
switch (what)
|
|
{
|
|
case "hostname": return SafeMachineName();
|
|
case "platform":
|
|
case "rid": return options.Platform;
|
|
case "installdir": return options.TargetDir;
|
|
case "project": return project;
|
|
case "baseurl": return options.BaseUrl;
|
|
case "username":
|
|
try { return Environment.UserName; } catch { return null; }
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static SetupTarget? FindTarget(SetupField field, List<SetupTarget> targets)
|
|
{
|
|
if (targets.Count == 0)
|
|
return null;
|
|
|
|
if (field.Target.Length == 0)
|
|
return targets[0];
|
|
|
|
return targets.FirstOrDefault(t =>
|
|
string.Equals(t.Id, field.Target, StringComparison.OrdinalIgnoreCase))
|
|
?? targets[0];
|
|
}
|
|
|
|
private static bool BelongsToTarget(SetupField field, SetupTarget target, List<SetupTarget> all)
|
|
{
|
|
var resolved = FindTarget(field, all);
|
|
return resolved != null && ReferenceEquals(resolved, target);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erkennt Platzhalter, die zwar in der Datei stehen, aber keinen
|
|
/// eingerichteten Wert darstellen. Ohne diese Pruefung wuerde eine
|
|
/// mitgelieferte Vorlage als "schon konfiguriert" gelten und die Frage
|
|
/// entfiele - die Anwendung liefe dann mit dem Platzhalter los.
|
|
/// </summary>
|
|
private static bool IsPlaceholder(string value)
|
|
{
|
|
string trimmed = value.Trim();
|
|
|
|
if (trimmed.Length == 0)
|
|
return true;
|
|
|
|
string[] markers =
|
|
{
|
|
"changeme", "change-me", "todo", "xxx", "placeholder", "vorlage",
|
|
"your-", "dein-", "<", "bitte-", "example.com", "beispiel"
|
|
};
|
|
|
|
string lower = trimmed.ToLowerInvariant();
|
|
return markers.Any(marker => lower.Contains(marker));
|
|
}
|
|
|
|
private static SetupDefinition? ReadDefinition(string path)
|
|
{
|
|
try
|
|
{
|
|
var definition = JsonSerializer.Deserialize<SetupDefinition>(File.ReadAllText(path));
|
|
|
|
if (definition == null)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{SetupFileName} ist leer oder unlesbar.[/]");
|
|
return null;
|
|
}
|
|
|
|
return definition;
|
|
}
|
|
catch (JsonException ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{SetupFileName} ist kein gueltiges JSON: {Markup.Escape(ex.Message)}[/]");
|
|
return null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]{SetupFileName} nicht lesbar: {Markup.Escape(ex.Message)}[/]");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static async Task<int> RunUnattendedAsync(AgentOptions options, HttpClient http)
|
|
{
|
|
string answersPath = options.AnswersPath!;
|
|
if (!File.Exists(answersPath))
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Antwortdatei nicht gefunden: {Markup.Escape(answersPath)}[/]");
|
|
return 1;
|
|
}
|
|
|
|
JsonDocument doc;
|
|
try
|
|
{
|
|
string json = await File.ReadAllTextAsync(answersPath);
|
|
doc = JsonDocument.Parse(json, new JsonDocumentOptions { AllowTrailingCommas = true, CommentHandling = JsonCommentHandling.Skip });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Fehler beim Lesen der Antwortdatei: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
|
|
using (doc)
|
|
{
|
|
var root = doc.RootElement;
|
|
if (root.ValueKind != JsonValueKind.Object)
|
|
{
|
|
AnsiConsole.MarkupLine("[red]Antwortdatei muss ein JSON-Objekt sein.[/]");
|
|
return 1;
|
|
}
|
|
|
|
string? baseUrl = GetStringProp(root, "base_url", "baseUrl");
|
|
if (!string.IsNullOrWhiteSpace(baseUrl))
|
|
{
|
|
options.BaseUrl = baseUrl.TrimEnd('/');
|
|
}
|
|
|
|
string? project = GetStringProp(root, "project", "product", "product_slug", "project_slug");
|
|
if (!string.IsNullOrWhiteSpace(project))
|
|
{
|
|
options.Project = project;
|
|
}
|
|
|
|
string? channel = GetStringProp(root, "channel");
|
|
if (!string.IsNullOrWhiteSpace(channel))
|
|
{
|
|
options.Channel = channel;
|
|
}
|
|
|
|
string? platform = GetStringProp(root, "platform", "rid");
|
|
if (!string.IsNullOrWhiteSpace(platform))
|
|
{
|
|
options.Platform = PlatformId.Normalize(platform);
|
|
}
|
|
|
|
string? targetDir = GetStringProp(root, "target_dir", "targetDir", "path");
|
|
if (!string.IsNullOrWhiteSpace(targetDir))
|
|
{
|
|
options.TargetDir = Path.GetFullPath(targetDir);
|
|
}
|
|
|
|
string? licenseKey = GetStringProp(root, "license_key", "licenseKey", "license");
|
|
if (!string.IsNullOrWhiteSpace(licenseKey))
|
|
{
|
|
options.Credentials = ReleaseCredentials.FromLicenseKey(licenseKey);
|
|
}
|
|
|
|
string version = GetStringProp(root, "version") ?? (options.Version != "latest" && !string.IsNullOrWhiteSpace(options.Version) ? options.Version : "latest");
|
|
|
|
var answersMap = ExtractAnswersMap(root);
|
|
|
|
if (string.IsNullOrWhiteSpace(options.Project))
|
|
{
|
|
AnsiConsole.MarkupLine("[red]Pflichtfeld 'project' fehlt in den Antworten.[/]");
|
|
return 1;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(options.TargetDir))
|
|
{
|
|
options.TargetDir = Path.GetFullPath(SuggestTargetDirectory(options.Project));
|
|
}
|
|
|
|
Directory.CreateDirectory(options.TargetDir);
|
|
|
|
AnsiConsole.MarkupLine($"[bold]Kopflose Installation:[/] {Markup.Escape(options.Project)} ({Markup.Escape(options.Channel)}) v{Markup.Escape(version)} -> {Markup.Escape(options.TargetDir)}");
|
|
|
|
int fileResult = await Program.DoUpdateOrRepair(options, version, null);
|
|
if (fileResult != 0)
|
|
{
|
|
return fileResult;
|
|
}
|
|
|
|
var runtime = RuntimeCheck.Inspect(options.TargetDir);
|
|
RuntimeCheck.Report(runtime);
|
|
|
|
var client = new SetupClient(options.BaseUrl, http);
|
|
int configResult = await ConfigureUnattendedAsync(options, client, options.Project, answersMap);
|
|
if (configResult != 0)
|
|
{
|
|
return configResult;
|
|
}
|
|
|
|
AnsiConsole.MarkupLine($"[green]Kopflose Installation von {Markup.Escape(options.Project)} erfolgreich abgeschlossen.[/]");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static async Task<int> ConfigureUnattendedOnlyAsync(AgentOptions options, HttpClient http)
|
|
{
|
|
string answersPath = options.AnswersPath!;
|
|
if (!File.Exists(answersPath))
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Antwortdatei nicht gefunden: {Markup.Escape(answersPath)}[/]");
|
|
return 1;
|
|
}
|
|
|
|
JsonDocument doc;
|
|
try
|
|
{
|
|
string json = await File.ReadAllTextAsync(answersPath);
|
|
doc = JsonDocument.Parse(json, new JsonDocumentOptions { AllowTrailingCommas = true, CommentHandling = JsonCommentHandling.Skip });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Fehler beim Lesen der Antwortdatei: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
|
|
using (doc)
|
|
{
|
|
var root = doc.RootElement;
|
|
if (root.ValueKind != JsonValueKind.Object)
|
|
{
|
|
AnsiConsole.MarkupLine("[red]Antwortdatei muss ein JSON-Objekt sein.[/]");
|
|
return 1;
|
|
}
|
|
|
|
string? targetDir = GetStringProp(root, "target_dir", "targetDir", "path");
|
|
if (!string.IsNullOrWhiteSpace(targetDir))
|
|
{
|
|
options.TargetDir = Path.GetFullPath(targetDir);
|
|
}
|
|
|
|
string? project = GetStringProp(root, "project", "product", "product_slug", "project_slug");
|
|
if (!string.IsNullOrWhiteSpace(project))
|
|
{
|
|
options.Project = project;
|
|
}
|
|
|
|
var answersMap = ExtractAnswersMap(root);
|
|
var client = new SetupClient(options.BaseUrl, http);
|
|
return await ConfigureUnattendedAsync(options, client, options.Project, answersMap);
|
|
}
|
|
}
|
|
|
|
private static async Task<int> ConfigureUnattendedAsync(
|
|
AgentOptions options,
|
|
SetupClient client,
|
|
string project,
|
|
Dictionary<string, string> answers)
|
|
{
|
|
string setupPath = Path.Combine(options.TargetDir, SetupFileName);
|
|
if (!File.Exists(setupPath))
|
|
{
|
|
AnsiConsole.MarkupLine($"[grey]Keine {SetupFileName} vorhanden - keine Konfiguration erforderlich.[/]");
|
|
return 0;
|
|
}
|
|
|
|
var definition = ReadDefinition(setupPath);
|
|
if (definition == null)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
var resolved = new List<(SetupField Field, string Value)>();
|
|
var targets = definition.Targets;
|
|
|
|
foreach (var field in definition.Fields)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(field.Key))
|
|
continue;
|
|
|
|
// 1. Schon eingerichtet?
|
|
var target = FindTarget(field, targets);
|
|
if (target != null && string.Equals(target.Format, "json", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
string path = SetupPaths.Resolve(target, options.TargetDir);
|
|
string? existing = SetupWriter.ReadExistingJson(path, field.Key);
|
|
if (!string.IsNullOrWhiteSpace(existing) && !IsPlaceholder(existing!))
|
|
{
|
|
AnsiConsole.MarkupLine($"[grey]Bereits gesetzt:[/] {Markup.Escape(field.Key)}");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 2. In answers angegeben?
|
|
if (answers.TryGetValue(field.Key, out string? val) && !string.IsNullOrWhiteSpace(val))
|
|
{
|
|
var validator = BuildValidator(field);
|
|
if (validator != null)
|
|
{
|
|
var res = validator(val);
|
|
if (!res.Successful)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Ungueltiger Wert fuer {Markup.Escape(field.Key)}: {res.Message}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
resolved.Add((field, val));
|
|
AnsiConsole.MarkupLine($"[green]Aus Antworten:[/] {Markup.Escape(field.Key)}");
|
|
continue;
|
|
}
|
|
|
|
// 3. Ableitbar?
|
|
string? detected = Detect(field.Source, options, project);
|
|
if (detected != null)
|
|
{
|
|
resolved.Add((field, detected));
|
|
AnsiConsole.MarkupLine($"[grey]Ermittelt:[/] {Markup.Escape(field.Key)} = {Markup.Escape(detected)}");
|
|
continue;
|
|
}
|
|
|
|
// 4. Token anfordern?
|
|
if (string.Equals(field.Source, "provision", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
try
|
|
{
|
|
var scopes = field.Scopes.Count > 0 ? field.Scopes : new List<string> { "watchdog:ping" };
|
|
string token = await client.RequestApplicationTokenAsync(project, scopes, Environment.MachineName);
|
|
resolved.Add((field, token));
|
|
AnsiConsole.MarkupLine($"[grey]Token ausgestellt:[/] {Markup.Escape(field.Key)}");
|
|
continue;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (field.Required)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Token fuer {Markup.Escape(field.Key)} konnte nicht bezogen werden: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 5. Default vorhanden?
|
|
if (!string.IsNullOrWhiteSpace(field.Default))
|
|
{
|
|
resolved.Add((field, field.Default));
|
|
AnsiConsole.MarkupLine($"[grey]Vorgabewert:[/] {Markup.Escape(field.Key)} = {Markup.Escape(field.Default)}");
|
|
continue;
|
|
}
|
|
|
|
// 6. Fehlt Pflichtfeld?
|
|
if (field.Required)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Pflichtfeld fehlt in der Antwortdatei: {Markup.Escape(field.Key)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
var writeTargets = definition.Targets.Count > 0
|
|
? definition.Targets
|
|
: new List<SetupTarget> { new SetupTarget { File = "appsettings.json", Format = "json" } };
|
|
|
|
foreach (var t in writeTargets)
|
|
{
|
|
var forTarget = resolved
|
|
.Where(pair => BelongsToTarget(pair.Field, t, writeTargets))
|
|
.Select(pair => new SetupValue(pair.Field.Key, pair.Value, pair.Field.Type, pair.Field.IsSecret))
|
|
.ToList();
|
|
|
|
if (forTarget.Count == 0)
|
|
continue;
|
|
|
|
string path = SetupPaths.Resolve(t, options.TargetDir);
|
|
try
|
|
{
|
|
SetupWriter.Write(path, t.Format, forTarget);
|
|
AnsiConsole.MarkupLine($"[green]Geschrieben:[/] {Markup.Escape(path)}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AnsiConsole.MarkupLine($"[red]Fehler beim Schreiben von {Markup.Escape(path)}: {Markup.Escape(ex.Message)}[/]");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static Dictionary<string, string> ExtractAnswersMap(JsonElement root)
|
|
{
|
|
var answersMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
if (root.TryGetProperty("answers", out var answersProp) && answersProp.ValueKind == JsonValueKind.Object)
|
|
{
|
|
foreach (var prop in answersProp.EnumerateObject())
|
|
{
|
|
answersMap[prop.Name] = prop.Value.GetString() ?? prop.Value.GetRawText();
|
|
}
|
|
}
|
|
if (root.TryGetProperty("fields", out var fieldsProp) && fieldsProp.ValueKind == JsonValueKind.Object)
|
|
{
|
|
foreach (var prop in fieldsProp.EnumerateObject())
|
|
{
|
|
answersMap[prop.Name] = prop.Value.GetString() ?? prop.Value.GetRawText();
|
|
}
|
|
}
|
|
|
|
foreach (var prop in root.EnumerateObject())
|
|
{
|
|
string name = prop.Name.ToLowerInvariant();
|
|
if (name is "base_url" or "baseurl" or "project" or "product" or "channel" or "platform" or "rid"
|
|
or "target_dir" or "targetdir" or "path" or "version" or "license_key" or "licensekey" or "license"
|
|
or "answers" or "fields")
|
|
{
|
|
continue;
|
|
}
|
|
if (!answersMap.ContainsKey(prop.Name))
|
|
{
|
|
answersMap[prop.Name] = prop.Value.GetString() ?? prop.Value.GetRawText();
|
|
}
|
|
}
|
|
|
|
return answersMap;
|
|
}
|
|
|
|
private static string? GetStringProp(JsonElement elem, params string[] names)
|
|
{
|
|
foreach (var name in names)
|
|
{
|
|
if (elem.TryGetProperty(name, out var prop) && prop.ValueKind == JsonValueKind.String)
|
|
{
|
|
return prop.GetString();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static string SuggestTargetDirectory(string slug)
|
|
{
|
|
if (OperatingSystemHelpers.IsWindows())
|
|
{
|
|
string programs = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
|
|
if (!string.IsNullOrWhiteSpace(programs))
|
|
{
|
|
return Path.Combine(programs, slug);
|
|
}
|
|
|
|
return Path.Combine(@"C:\Programme", slug);
|
|
}
|
|
|
|
return "/opt/" + slug;
|
|
}
|
|
|
|
private static string SafeMachineName()
|
|
{
|
|
try { return Environment.MachineName; } catch { return "unbekannt"; }
|
|
}
|
|
}
|
|
}
|