Deploymentcenter BotandClaude Opus 5
1967b49ad7
Fuenf von sechs Befunden einer externen Integration. Der sechste - unsignierte Lizenzurteile - ist bestaetigt, aber bewusst nicht Teil dieses Commits. 1. Lizenzschluessel stand in der Kommandozeile Der Agent nahm --license-key nur als Argument und las keine Umgebungsvariablen. "ps" zeigt argv jedem Benutzer der Maschine - exakt die Begruendung, mit der UPGRADE.md §5 den Crontab-Weg verwirft. Damit nahm das SDK einen bereits geloesten Sicherheitsbefund zurueck. Der Agent liest jetzt DC_LICENSE_KEY, DC_DOWNLOAD_USER und DC_DOWNLOAD_PASSWORD, Umgebung vor Argument. LaunchUpdateAgent uebergibt den Schluessel nicht mehr als Argument, sondern setzt die Variable auf dem eigenen Prozess: das Kind erbt den Umgebungsblock, danach wird sie wieder entfernt. Das funktioniert auch mit UseShellExecute=true, wo sich ProcessStartInfo.Environment nicht setzen laesst. 2. --wait-timeout war nicht durchgereicht Der Agent kannte den Parameter, LaunchUpdateAgent hatte keinen dafuer - es galten fest 60 Sekunden. Eine Anwendung, die allein fuer host.StopAsync 30 Sekunden braucht, kommt damit gefaehrlich nah an die Grenze. Neu: waitTimeoutSeconds. Ausserdem ist im Quelltext und in der Doku jetzt festgehalten, dass exitCurrentApp:true ueber Environment.Exit(0) laeuft und damit finally-Bloecke und IHostApplicationLifetime uebergeht - bei offenem Zustand die falsche Wahl. 3. ILicensePrompt war tot Der Konstruktor nahm es entgegen, legte es in _prompt ab und benutzte es nirgends. Wer darauf eine headless-Story aufbaute, baute auf Sand. Neu: EnsureLicensedAsync() - zwischengespeicherten Schluessel nehmen, sonst fragen, pruefen, bei Ablehnung erneut fragen. allowPrompt:false lehnt ohne Cache ab, statt auf eine Eingabe zu warten, die im Dienst nie kommt. Ein voruebergehender Netzfehler fuehrt nicht zur erneuten Abfrage - der Schluessel ist ja nicht falsch. 4. Der Packager warnte nur Er bricht jetzt ab. Anlass war ein echter API-Schluessel in einem oeffentlich abrufbaren Paket - und die Warnung war damals ausgerechnet unterdrueckt, weil die Datei auf der preserve-Liste stand. Zwei Stufen: Dateiname (appsettings.Local.json, master.key, *.pfx, *.db, server_settings.xml) und Inhalt (gefuelltes Password=, sk-, ghp_, dc_master_, AKIA, private Schluessel). Die Inhaltspruefung findet auch Dateien mit unverdaechtigem Namen. Platzhalter loesen bewusst nicht aus: "sk-DEIN-SCHLUESSEL-HIER" haette sonst jede ausgelieferte Vorlage blockiert, und --allow-secrets waere nach einer Woche Gewohnheit. Beim Erproben zuerst genau in diese Falle gelaufen. 5. BuildInfo.targets war nur per Pfad-Import zu haben Die Anleitung empfahl einen <Import> ins Nachbar-Repository - das setzt voraus, dass beide Arbeitskopien nebeneinander liegen und in derselben Fassung stehen. Das Client-Projekt ist jetzt packbar und legt das Target unter build/ ins Paket, wo NuGet es selbst importiert. Ausserdem: Unauthorized wurde nur im statischen Zweig erkannt, im API-Zweig kam ein 401 als gewoehnlicher HTTP-Fehler an. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
600 lines
24 KiB
C#
600 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Deploymentcenter.Client.Models;
|
|
|
|
namespace Deploymentcenter.Client
|
|
{
|
|
public class UpdateCheckResult
|
|
{
|
|
public bool UpdateAvailable { get; set; }
|
|
public bool IsCritical { get; set; }
|
|
public VersionInfo? LatestRelease { get; set; }
|
|
public ReleaseManifest? FullManifest { get; set; }
|
|
public string Message { get; set; } = string.Empty;
|
|
public Exception? Error { get; set; }
|
|
|
|
/// <summary>
|
|
/// Die Release-Ablage hat die Zugangsdaten abgelehnt - typischerweise
|
|
/// eine abgelaufene oder widerrufene Lizenz. Bewusst von einem
|
|
/// gewoehnlichen Fehler unterschieden: Sonst sieht ein abgelaufener
|
|
/// Vertrag aus wie eine Netzwerkstoerung.
|
|
/// </summary>
|
|
public bool Unauthorized { get; set; }
|
|
}
|
|
|
|
public class IntegrityCheckResult
|
|
{
|
|
public bool IsValid { get; set; } = true;
|
|
public List<string> MissingFiles { get; } = new List<string>();
|
|
public List<string> CorruptedFiles { get; } = new List<string>();
|
|
public int TotalCheckedFiles { get; set; }
|
|
}
|
|
|
|
public class UpdateClient
|
|
{
|
|
private static readonly HttpClient SharedHttpClient = new HttpClient();
|
|
private readonly HttpClient _httpClient;
|
|
|
|
public UpdateClient(HttpClient? httpClient = null)
|
|
{
|
|
_httpClient = httpClient ?? SharedHttpClient;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks for update availability against LEMP static latest.json or Deploymentcenter API.
|
|
/// </summary>
|
|
/// <param name="platform">
|
|
/// Laufzeitkennung des Systems (z. B. "win-x64"). Ohne Angabe wird die
|
|
/// des laufenden Prozesses verwendet. Wird bewusst mitgeschickt: ohne
|
|
/// sie liefert der Server nur plattformunabhaengige Releases, damit ein
|
|
/// Client nie das Paket einer fremden Plattform angeboten bekommt.
|
|
/// </param>
|
|
public async Task<UpdateCheckResult> CheckForUpdateAsync(
|
|
string baseUrl,
|
|
string projectId,
|
|
string currentVersion,
|
|
string channel = "prod",
|
|
string? platform = null,
|
|
ReleaseCredentials? credentials = null,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var result = new UpdateCheckResult();
|
|
try
|
|
{
|
|
string cleanBaseUrl = baseUrl.TrimEnd('/');
|
|
string rid = PlatformId.Normalize(platform ?? PlatformId.Current);
|
|
|
|
// Primary check: LEMP static channel latest.json
|
|
// Plattformunabhaengige Releases liegen weiterhin unter dem
|
|
// alten Pfad ohne Zwischenebene, damit bereits ausgelieferte
|
|
// Anwendungen ihre Updates finden.
|
|
string staticUrl = $"{cleanBaseUrl}/releases/{projectId}/{channel}{PlatformId.PathSegment(rid)}/latest.json";
|
|
|
|
// Zuerst die statische latest.json, danach die API.
|
|
//
|
|
// Der Rueckfall auf die API war zuvor unerreichbar: er lag in
|
|
// einem catch, aber GetAsync wirft bei einem 404 keine Exception,
|
|
// sondern liefert eine Antwort mit Statuscode. Fehlte die
|
|
// latest.json, brach die Pruefung mit "HTTP Error NotFound" ab,
|
|
// statt die API zu befragen.
|
|
HttpResponseMessage? response = null;
|
|
|
|
try
|
|
{
|
|
response = await SendWithCredentialsAsync(staticUrl, credentials, cancellationToken)
|
|
.ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{
|
|
response = null;
|
|
}
|
|
|
|
// Ein 401 auf die statische Ablage ist etwas anderes als ein
|
|
// fehlendes Release: Die Lizenz traegt nicht mehr. Das ueber
|
|
// den API-Rueckfall zu verschlucken hiesse, den Anwender im
|
|
// Unklaren zu lassen, warum keine Updates mehr kommen.
|
|
if (response != null && response.StatusCode == HttpStatusCode.Unauthorized)
|
|
{
|
|
result.Unauthorized = true;
|
|
result.Message = ReleaseCredentials.DescribeUnauthorized(credentials);
|
|
response.Dispose();
|
|
return result;
|
|
}
|
|
|
|
if (response == null || !response.IsSuccessStatusCode)
|
|
{
|
|
response?.Dispose();
|
|
|
|
string apiUrl = $"{cleanBaseUrl}/api/updateservice/v1/check"
|
|
+ $"?product={Uri.EscapeDataString(projectId)}"
|
|
+ $"&version={Uri.EscapeDataString(currentVersion)}"
|
|
+ $"&channel={Uri.EscapeDataString(channel)}"
|
|
+ $"&platform={Uri.EscapeDataString(rid)}";
|
|
|
|
response = await _httpClient.GetAsync(apiUrl, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
// Auch der API-Zweig kann 401 liefern - etwa wenn die
|
|
// Lese-Endpunkte spaeter ebenfalls hinter den Zugangsschutz
|
|
// wandern. Zuvor wurde das nur auf dem statischen Weg erkannt
|
|
// und hier als gewoehnlicher HTTP-Fehler gemeldet.
|
|
if (response.StatusCode == HttpStatusCode.Unauthorized)
|
|
{
|
|
result.Unauthorized = true;
|
|
result.Message = ReleaseCredentials.DescribeUnauthorized(credentials);
|
|
return result;
|
|
}
|
|
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
result.Message = $"Update-Pruefung fehlgeschlagen: HTTP {(int)response.StatusCode}";
|
|
return result;
|
|
}
|
|
|
|
string json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
|
|
using var doc = JsonDocument.Parse(json);
|
|
var root = doc.RootElement;
|
|
|
|
// Handle static latest.json format
|
|
if (root.TryGetProperty("latest", out var latestProp) && latestProp.ValueKind == JsonValueKind.Object)
|
|
{
|
|
var manifest = JsonSerializer.Deserialize<ReleaseManifest>(json);
|
|
if (manifest?.Latest != null)
|
|
{
|
|
result.FullManifest = manifest;
|
|
result.LatestRelease = manifest.Latest;
|
|
|
|
if (IsVersionNewer(currentVersion, manifest.Latest.Version))
|
|
{
|
|
result.UpdateAvailable = true;
|
|
result.IsCritical = manifest.Latest.IsCritical;
|
|
result.Message = $"New release v{manifest.Latest.Version} available.";
|
|
}
|
|
else
|
|
{
|
|
result.Message = "Application is up to date.";
|
|
}
|
|
}
|
|
}
|
|
// Handle API response format
|
|
//
|
|
// Die API antwortet in snake_case und reicht die Release-Zeile
|
|
// aus updateservice_releases durch. Sie wird deshalb ueber
|
|
// ApiReleaseInfo gelesen und erst danach in das Modell
|
|
// uebersetzt, das Aufrufer kennen. Zuvor wurde direkt nach
|
|
// VersionInfo deserialisiert - dessen camelCase-Namen gehoeren
|
|
// aber zur statischen latest.json, sodass ausser "version"
|
|
// nichts ankam.
|
|
else if (root.TryGetProperty("update_available", out var availProp))
|
|
{
|
|
bool available = availProp.ValueKind == JsonValueKind.True
|
|
|| (availProp.ValueKind == JsonValueKind.Number && availProp.GetInt32() != 0);
|
|
|
|
result.UpdateAvailable = available;
|
|
|
|
if (root.TryGetProperty("latest_release", out var relProp)
|
|
&& relProp.ValueKind == JsonValueKind.Object)
|
|
{
|
|
var info = JsonSerializer.Deserialize<ApiReleaseInfo>(relProp.GetRawText());
|
|
result.LatestRelease = info?.ToVersionInfo();
|
|
}
|
|
|
|
// is_critical steht auf oberster Ebene der Antwort, nicht im
|
|
// Release-Objekt. Vorher wurde es aus dem deserialisierten
|
|
// Objekt gelesen und war damit immer false - ein kritisches
|
|
// Release wurde ueber diesen Weg nie als kritisch gemeldet.
|
|
if (root.TryGetProperty("is_critical", out var critProp))
|
|
{
|
|
result.IsCritical = ReadFlexibleBool(critProp);
|
|
}
|
|
else
|
|
{
|
|
result.IsCritical = result.LatestRelease?.IsCritical ?? false;
|
|
}
|
|
|
|
result.Message = available ? "Update available." : "Application is up to date.";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.Error = ex;
|
|
result.Message = $"Update check failed: {ex.Message}";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fuehrt eine GET-Anfrage aus und legt bei Bedarf die Zugangsdaten
|
|
/// der Release-Ablage an.
|
|
/// </summary>
|
|
private async Task<HttpResponseMessage> SendWithCredentialsAsync(
|
|
string url,
|
|
ReleaseCredentials? credentials,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Get, url);
|
|
ReleaseCredentials.Apply(request, credentials);
|
|
|
|
return await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Liest einen Wahrheitswert, der als Boolean, Zahl oder Zeichenkette
|
|
/// ankommen kann. MySQL liefert TINYINT(1), PHP gibt es je nach
|
|
/// PDO-Einstellung als 1 oder "1" weiter.
|
|
/// </summary>
|
|
private static bool ReadFlexibleBool(JsonElement element)
|
|
{
|
|
switch (element.ValueKind)
|
|
{
|
|
case JsonValueKind.True:
|
|
return true;
|
|
case JsonValueKind.Number:
|
|
return element.TryGetInt64(out long number) && number != 0;
|
|
case JsonValueKind.String:
|
|
string value = (element.GetString() ?? string.Empty).Trim();
|
|
if (bool.TryParse(value, out bool parsed)) return parsed;
|
|
return long.TryParse(value, out long numeric) && numeric != 0;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates local application integrity against manifest.json.
|
|
/// </summary>
|
|
public static IntegrityCheckResult VerifyIntegrity(string localAppDir, PackageManifest manifest)
|
|
{
|
|
var result = new IntegrityCheckResult();
|
|
if (manifest == null || manifest.Files == null || manifest.Files.Count == 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
foreach (var entry in manifest.Files)
|
|
{
|
|
result.TotalCheckedFiles++;
|
|
string fullPath = Path.Combine(localAppDir, entry.Path.Replace('/', Path.DirectorySeparatorChar));
|
|
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
result.IsValid = false;
|
|
result.MissingFiles.Add(entry.Path);
|
|
continue;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(entry.Sha256))
|
|
{
|
|
string computedHash = ComputeSha256(fullPath);
|
|
if (!string.Equals(computedHash, entry.Sha256, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
result.IsValid = false;
|
|
result.CorruptedFiles.Add(entry.Path);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dateiname des Agenten auf dieser Plattform.
|
|
///
|
|
/// Unter Linux und macOS traegt das Binary keine Endung. Ein fest auf
|
|
/// "update-agent.exe" verdrahteter Name wird dort nie gefunden, und die
|
|
/// Anwendung meldet stumm "kein Agent vorhanden".
|
|
/// </summary>
|
|
public static string AgentFileName =>
|
|
OperatingSystemHelpers.IsWindows() ? "update-agent.exe" : "update-agent";
|
|
|
|
/// <summary>
|
|
/// Sucht den Agenten. Ohne Verzeichnisangabe wird neben der laufenden
|
|
/// Anwendung gesucht.
|
|
/// </summary>
|
|
public static string? ResolveAgentPath(string? directory = null)
|
|
{
|
|
string dir = string.IsNullOrWhiteSpace(directory)
|
|
? AppDomain.CurrentDomain.BaseDirectory
|
|
: directory!;
|
|
|
|
string candidate = Path.Combine(dir, AgentFileName);
|
|
if (File.Exists(candidate))
|
|
return candidate;
|
|
|
|
// Ein Paket, das fuer die jeweils andere Plattform gebaut wurde,
|
|
// bringt den Agenten unter dem dortigen Namen mit. Lieber finden
|
|
// als daran scheitern.
|
|
foreach (string alternative in new[] { "update-agent", "update-agent.exe" })
|
|
{
|
|
string path = Path.Combine(dir, alternative);
|
|
if (File.Exists(path))
|
|
return path;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Startet den UpdateAgent und beendet auf Wunsch die laufende Anwendung.
|
|
/// </summary>
|
|
/// <param name="restartPath">
|
|
/// Anwendung, die der Agent nach dem Update wieder starten soll.
|
|
/// Wurde dieser Wert zuvor nie uebergeben - der Agent unterstuetzte
|
|
/// <c>--restart</c>, bekam es aber nie zu sehen, sodass die Anwendung
|
|
/// nach "Jetzt installieren" schlicht geschlossen blieb.
|
|
/// </param>
|
|
/// <param name="waitForCurrentProcess">
|
|
/// Uebergibt die eigene Prozesskennung, damit der Agent das Ende der
|
|
/// Anwendung abwartet, bevor er Dateien ersetzt. Ohne diesen Handschlag
|
|
/// kopiert er bei langsamem Herunterfahren ueber gesperrte Dateien.
|
|
/// </param>
|
|
public static bool LaunchUpdateAgent(
|
|
string agentPath,
|
|
string projectId,
|
|
string channel = "prod",
|
|
string action = "update",
|
|
string version = "latest",
|
|
string? targetDir = null,
|
|
bool exitCurrentApp = true,
|
|
string? restartPath = null,
|
|
string? currentVersion = null,
|
|
string? platform = null,
|
|
bool waitForCurrentProcess = true,
|
|
string? licenseKey = null,
|
|
int waitTimeoutSeconds = 60)
|
|
{
|
|
if (!File.Exists(agentPath))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
targetDir ??= AppDomain.CurrentDomain.BaseDirectory;
|
|
|
|
var args = new StringBuilder();
|
|
AppendArg(args, "--project", projectId);
|
|
AppendArg(args, "--channel", channel);
|
|
AppendArg(args, "--action", action);
|
|
AppendArg(args, "--version", version);
|
|
AppendArg(args, "--target-dir", targetDir);
|
|
AppendArg(args, "--platform", PlatformId.Normalize(platform ?? PlatformId.Current));
|
|
|
|
if (!string.IsNullOrWhiteSpace(currentVersion))
|
|
{
|
|
AppendArg(args, "--current-version", currentVersion!);
|
|
}
|
|
|
|
// Der Lizenzschluessel wird BEWUSST NICHT als Argument uebergeben.
|
|
//
|
|
// Was in argv steht, zeigt "ps" jedem Benutzer der Maschine. Aus
|
|
// genau diesem Grund verwirft UPGRADE.md §5 den Weg, den Shared
|
|
// Key im Crontab zu hinterlegen - fuer einen Lizenzschluessel
|
|
// gilt dasselbe.
|
|
//
|
|
// Stattdessen wird die Variable auf dem eigenen Prozess gesetzt;
|
|
// der Agent erbt den Umgebungsblock beim Start und liest sie dort.
|
|
// Das funktioniert auch mit UseShellExecute=true, wo sich
|
|
// ProcessStartInfo.Environment nicht setzen laesst.
|
|
bool licenseKeySet = false;
|
|
|
|
if (!string.IsNullOrWhiteSpace(licenseKey))
|
|
{
|
|
Environment.SetEnvironmentVariable("DC_LICENSE_KEY", licenseKey);
|
|
licenseKeySet = true;
|
|
}
|
|
|
|
if (waitForCurrentProcess)
|
|
{
|
|
AppendArg(args, "--wait-for-pid",
|
|
Process.GetCurrentProcess().Id.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
|
|
// Ohne diesen Wert galten fest 60 Sekunden. Eine Anwendung,
|
|
// die allein fuer host.StopAsync 30 Sekunden braucht, kommt
|
|
// damit gefaehrlich nah an die Grenze - und laeuft sie ab,
|
|
// bricht der Agent ab, statt ueber gesperrte Dateien zu
|
|
// schreiben. Sicher, aber eben auch kein Update.
|
|
AppendArg(args, "--wait-timeout",
|
|
Math.Max(5, waitTimeoutSeconds).ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
// Ohne ausdruecklichen Pfad die eigene ausfuehrbare Datei.
|
|
string? restart = restartPath;
|
|
if (string.IsNullOrWhiteSpace(restart))
|
|
{
|
|
restart = GetCurrentExecutablePath();
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(restart))
|
|
{
|
|
AppendArg(args, "--restart", restart!);
|
|
}
|
|
|
|
var startInfo = new ProcessStartInfo
|
|
{
|
|
FileName = agentPath,
|
|
Arguments = args.ToString().TrimEnd(),
|
|
WorkingDirectory = Path.GetDirectoryName(agentPath) ?? targetDir,
|
|
UseShellExecute = true
|
|
};
|
|
|
|
try
|
|
{
|
|
Process.Start(startInfo);
|
|
}
|
|
finally
|
|
{
|
|
// Nach dem Start wieder entfernen: Der Schluessel soll nur so
|
|
// lange im eigenen Umgebungsblock stehen, wie er zum Vererben
|
|
// gebraucht wird.
|
|
if (licenseKeySet)
|
|
{
|
|
Environment.SetEnvironmentVariable("DC_LICENSE_KEY", null);
|
|
}
|
|
}
|
|
|
|
if (exitCurrentApp)
|
|
{
|
|
// Environment.Exit beendet den Prozess sofort: laufende
|
|
// finally-Bloecke anderer Threads, IHostApplicationLifetime
|
|
// und Destruktoren kommen nicht mehr zum Zug. Fuer eine
|
|
// Anwendung mit offenem Zustand - Positionen, Transaktionen,
|
|
// ungeschriebene Puffer - ist das die falsche Wahl. Dort
|
|
// gehoert exitCurrentApp:false gesetzt und danach der eigene
|
|
// geordnete Weg gegangen; der Agent wartet ohnehin auf das
|
|
// Prozessende.
|
|
Environment.Exit(0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void AppendArg(StringBuilder builder, string name, string value)
|
|
{
|
|
builder.Append(name);
|
|
builder.Append(" \"");
|
|
// Ein abschliessender Backslash wuerde sonst das Anfuehrungszeichen
|
|
// maskieren und alle folgenden Argumente verschlucken - bei
|
|
// Windows-Pfaden wie C:\App\ ein realer Fall.
|
|
builder.Append(value.Replace("\"", "\\\"").TrimEnd('\\'));
|
|
builder.Append("\" ");
|
|
}
|
|
|
|
private static string? GetCurrentExecutablePath()
|
|
{
|
|
try
|
|
{
|
|
#if NET8_0_OR_GREATER
|
|
string? path = Environment.ProcessPath;
|
|
if (!string.IsNullOrWhiteSpace(path))
|
|
return path;
|
|
#endif
|
|
return Process.GetCurrentProcess().MainModule?.FileName;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static string ComputeSha256(string filePath)
|
|
{
|
|
using var sha256 = SHA256.Create();
|
|
using var stream = File.OpenRead(filePath);
|
|
byte[] hash = sha256.ComputeHash(stream);
|
|
return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prueft, ob <paramref name="remoteVer"/> neuer ist als <paramref name="currentVer"/>.
|
|
///
|
|
/// Die vorherige Fassung entfernte zwar die Vorabkennung, nicht aber ein
|
|
/// fuehrendes "v". Damit scheiterte Version.TryParse bei Angaben wie
|
|
/// "v1.4.2" und es wurde auf einen alphabetischen Vergleich
|
|
/// zurueckgefallen - dort gilt "v1.9.0" faelschlich als neuer als
|
|
/// "v1.10.0". Das entspricht dem Fehler, der serverseitig in der
|
|
/// SQL-Abfrage steckte.
|
|
/// </summary>
|
|
public static bool IsVersionNewer(string currentVer, string remoteVer)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(remoteVer)) return false;
|
|
if (string.IsNullOrWhiteSpace(currentVer)) return true;
|
|
|
|
return CompareVersions(remoteVer, currentVer) > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Vergleicht zwei Versionsangaben nach semantischer Ordnung.
|
|
/// Rueckgabe: negativ wenn a < b, 0 bei Gleichstand, positiv wenn a > b.
|
|
/// </summary>
|
|
public static int CompareVersions(string a, string b)
|
|
{
|
|
var (coreA, preA) = ParseVersion(a);
|
|
var (coreB, preB) = ParseVersion(b);
|
|
|
|
int length = Math.Max(coreA.Count, coreB.Count);
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
int partA = i < coreA.Count ? coreA[i] : 0;
|
|
int partB = i < coreB.Count ? coreB[i] : 0;
|
|
if (partA != partB)
|
|
{
|
|
return partA.CompareTo(partB);
|
|
}
|
|
}
|
|
|
|
// Eine Version ohne Vorabkennung rangiert ueber derselben mit:
|
|
// 1.0.0 ist neuer als 1.0.0-rc.1
|
|
bool emptyA = preA.Count == 0;
|
|
bool emptyB = preB.Count == 0;
|
|
if (emptyA && emptyB) return 0;
|
|
if (emptyA) return 1;
|
|
if (emptyB) return -1;
|
|
|
|
int preLength = Math.Max(preA.Count, preB.Count);
|
|
for (int i = 0; i < preLength; i++)
|
|
{
|
|
if (i >= preA.Count) return -1;
|
|
if (i >= preB.Count) return 1;
|
|
|
|
bool numericA = int.TryParse(preA[i], out int numA);
|
|
bool numericB = int.TryParse(preB[i], out int numB);
|
|
|
|
if (numericA && numericB)
|
|
{
|
|
if (numA != numB) return numA.CompareTo(numB);
|
|
continue;
|
|
}
|
|
|
|
// Rein numerische Bestandteile rangieren unter alphanumerischen.
|
|
if (numericA != numericB) return numericA ? -1 : 1;
|
|
|
|
int cmp = string.CompareOrdinal(preA[i], preB[i]);
|
|
if (cmp != 0) return cmp > 0 ? 1 : -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static (List<int> Core, List<string> Prerelease) ParseVersion(string version)
|
|
{
|
|
string value = (version ?? string.Empty).Trim().TrimStart('v', 'V');
|
|
|
|
// Build-Metadaten sind fuer die Rangfolge ohne Bedeutung.
|
|
int plus = value.IndexOf('+');
|
|
if (plus >= 0) value = value.Substring(0, plus);
|
|
|
|
var prerelease = new List<string>();
|
|
int dash = value.IndexOf('-');
|
|
if (dash >= 0)
|
|
{
|
|
string preString = value.Substring(dash + 1);
|
|
value = value.Substring(0, dash);
|
|
if (preString.Length > 0)
|
|
{
|
|
prerelease.AddRange(preString.Split('.'));
|
|
}
|
|
}
|
|
|
|
var core = new List<int>();
|
|
foreach (string part in value.Split('.'))
|
|
{
|
|
string digits = new string(part.Where(char.IsDigit).ToArray());
|
|
core.Add(digits.Length > 0 ? int.Parse(digits) : 0);
|
|
}
|
|
|
|
if (core.Count == 0) core.Add(0);
|
|
|
|
return (core, prerelease);
|
|
}
|
|
}
|
|
}
|