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

fix(clients, docs): Lizenz-Antwortformat wiederherstellen, Packager absichern

Browse Source 
Regression aus dem vorigen Commit
- /api/license/v1/validate lieferte die Antwort im neuen status/error-Umschlag.
  Der Vertrag dieses Endpunkts ist aber bereits ausgerollt: das Feld "status"
  auf oberster Ebene trägt den Lizenzzustand (valid, revoked, expired ...).
  LicenseClient las dadurch "success" statt "valid" — jeder ausgelieferte
  Client hätte seine Lizenz für ungültig gehalten. Die Lizenz-Endpunkte
  antworten jetzt wieder ohne Umschlag (Http::raw).
  Gefunden durch Ausführen der projekteigenen Test-Suite gegen den Server.

Packager
- FTP-Zugangsdaten standen als Standardwerte im Quelltext und zusätzlich in
  packager.config.json und in der Integrationsanleitung. Alle drei Fundstellen
  bereinigt; die Konfigurationsdatei ist nicht mehr versioniert. Zugangsdaten
  kommen aus Datei, Umgebungsvariablen oder CLI-Argument, sonst bricht das
  Programm mit einer klaren Meldung ab.
- Das Veröffentlichen sendet jetzt ein Token (updateservice:publish) und nutzt
  den Endpunkt /api/updateservice/v1/publish.
- Fehler wurden von einem leeren catch verschluckt, und ohne Erfolgsfall wurde
  gar nichts ausgegeben. Das Werkzeug meldete am Ende immer Erfolg und lieferte
  Rückgabewert 0, selbst wenn FTP-Upload und API-Aufruf fehlgeschlagen waren.
  Jetzt ehrliche Meldungen und Rückgabewerte 0/1/2.
- packager.config.json wurde vom csproj nie ins Ausgabeverzeichnis kopiert,
  weshalb sie dort nie gefunden wurde und stets die hartkodierten Werte griffen.

UpdateClient
- IsVersionNewer entfernte die Vorabkennung, aber kein führendes "v". Damit
  scheiterte Version.TryParse bei "v1.4.2" und es wurde auf einen
  alphabetischen Vergleich zurückgefallen, in dem "v1.9.0" als neuer gilt als
  "v1.10.0" — derselbe Fehler wie zuvor serverseitig im SQL. Ersetzt durch
  einen vollständigen semantischen Vergleich, verifiziert mit 16 Testfällen.
- Der Rückfall auf die API lag in einem catch-Block, aber GetAsync wirft bei
  einem 404 keine Exception. Fehlte die statische latest.json, brach die
  Prüfung ab, statt die API zu befragen.

Dokumentation
- BUGTRACKER_INTEGRATION_GUIDE.md beschrieb denselben Workflow ein zweites Mal
  und war bereits auseinandergelaufen: Aufrufe ohne Token, alte Pfade, weder
  Claim/Lease noch Idempotenz. Ersetzt durch einen Verweis auf das gepflegte
  Agenten-Handbuch samt Übersicht der Änderungen.
- UPDATESERVICE_INTEGRATION_GUIDE.md um Token, Umgebungsvariablen und
  Rückgabewerte ergänzt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Deploymentcenter Bot
2026-08-07 16:27:02 +02:00
co-authored by Claude Opus 5
parent e7fbc85db4
commit a74c6fd990
10 changed files with 481 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client-dotnet/Deploymentcenter.Client/UpdateClient.cs
+114 -14
View File
@@ -59,22 +59,39 @@ namespace Deploymentcenter.Client
// Path pattern: https://domain/releases/{ProjectId}/{channel}/latest.json
string staticUrl = $"{cleanBaseUrl}/releases/{projectId}/{channel}/latest.json";
HttpResponseMessage response;
// 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 _httpClient.GetAsync(staticUrl, cancellationToken).ConfigureAwait(false);
}
catch
{
// Fallback check: Deploymentcenter API endpoint
// Path pattern: https://domain/api/updateservice/v1/check?product={projectId}&version={currentVersion}
string apiUrl = $"{cleanBaseUrl}/api/updateservice/v1/check?product={Uri.EscapeDataString(projectId)}&version={Uri.EscapeDataString(currentVersion)}";
response = null;
}
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)}";
response = await _httpClient.GetAsync(apiUrl, cancellationToken).ConfigureAwait(false);
}
if (!response.IsSuccessStatusCode)
{
result.Message = $"HTTP Error {response.StatusCode} during update check";
result.Message = $"Update-Pruefung fehlgeschlagen: HTTP {(int)response.StatusCode}";
return result;
}
@@ -214,24 +231,107 @@ namespace Deploymentcenter.Client
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.IsNullOrEmpty(remoteVer)) return false;
if (string.IsNullOrEmpty(currentVer)) return true;
if (string.IsNullOrWhiteSpace(remoteVer)) return false;
if (string.IsNullOrWhiteSpace(currentVer)) return true;
string CleanVer(string v)
return CompareVersions(remoteVer, currentVer) > 0;
}
/// <summary>
/// Vergleicht zwei Versionsangaben nach semantischer Ordnung.
/// Rueckgabe: negativ wenn a &lt; b, 0 bei Gleichstand, positiv wenn a &gt; 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 dash = v.IndexOf('-');
return dash > 0 ? v.Substring(0, dash) : v;
int partA = i < coreA.Count ? coreA[i] : 0;
int partB = i < coreB.Count ? coreB[i] : 0;
if (partA != partB)
{
return partA.CompareTo(partB);
}
}
if (Version.TryParse(CleanVer(currentVer), out var cVer) &&
Version.TryParse(CleanVer(remoteVer), out var rVer))
// 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++)
{
return rVer > cVer;
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 string.Compare(remoteVer, currentVer, StringComparison.OrdinalIgnoreCase) > 0;
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);
}
}
}