sh-edraft.de/actions
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added package cleanup

Browse Source
This commit is contained in:
Sven Heidemann
2026-02-15 02:58:44 +01:00
parent 1764ddcb2b
commit 8586a09cd0
10 changed files with 343 additions and 1797 deletions
Download Patch File Download Diff File Expand all files Collapse all files

323
sh.actions.package-cleanup/Service/PackageService.cs
View File

@@ -2,7 +2,7 @@ using sh.actions.package_cleanup.Models;
namespace sh.actions.package_cleanup.Service;
public class PackageService(IConfiguration configuration, IGiteaPackageService packageService) : IPackageService
public class PackageService(IGiteaPackageService packageService) : IPackageService
{
public async Task<List<GiteaPackage>> GetFilteredPackages()
{
@@ -12,301 +12,40 @@ public class PackageService(IConfiguration configuration, IGiteaPackageService p
public List<GiteaPackage> FilterPackagesToDelete(List<GiteaPackage> packages)
{
var packagesToDelete = new List<GiteaPackage>();
var versionMap = packages.ToDictionary(p => p.Version, p => SoftwareVersion.Parse(p.Version));
var versionsToKeep = new HashSet<string>();
// Group packages by versioning variant
var semanticVersionPackages = packages.Where(p => IsSemanticVersion(p.Version)).ToList();
var dateVersionPackages = packages.Where(p => IsDateVersion(p.Version)).ToList();
foreach (var package in packages
.Where(p => string.IsNullOrEmpty(versionMap[p.Version].Suffix))
.GroupBy(p => versionMap[p.Version].ToString())
.Select(g => g.OrderBy(p => p.Version.Length).First()))
{
versionsToKeep.Add(package.Version);
}
// Process each group with their respective variant logic
packagesToDelete.AddRange(FilterPackagesToDeleteBySemanticVersion(semanticVersionPackages));
packagesToDelete.AddRange(FilterPackagesToDeleteByDateVersion(dateVersionPackages));
var latestVersion = packages.FirstOrDefault(p => versionMap[p.Version].IsLatest);
if (latestVersion != null)
{
versionsToKeep.Add(latestVersion.Version);
}
return packagesToDelete;
}
var suffixedVersionsToKeep = packages
.Where(p => !string.IsNullOrEmpty(versionMap[p.Version].Suffix) &&
!(versionMap[p.Version].Major == 0 && versionMap[p.Version].Minor == 0 &&
versionMap[p.Version].Patch == 0))
.GroupBy(p => (versionMap[p.Version].Suffix, versionMap[p.Version].Major, versionMap[p.Version].Minor))
.SelectMany(g => g
.OrderByDescending(p => versionMap[p.Version].Patch)
.ThenByDescending(p => versionMap[p.Version].Build)
.Take(2)
.GroupBy(p => versionMap[p.Version].ToString())
.Select(group => group.OrderBy(p => p.Version.Length).First()));
private List<GiteaPackage> FilterPackagesToDeleteBySemanticVersion(List<GiteaPackage> packages)
{
var packagesToDelete = new List<GiteaPackage>();
foreach (var package in suffixedVersionsToKeep)
{
versionsToKeep.Add(package.Version);
}
// Group packages by release type
// Note: Dev releases must be checked before prerelease since -dev is a suffix
var devPackages = packages.Where(p => IsDevRelease(p.Version))
.OrderByDescending(p => ParseSemanticVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
var prereleasePackages = packages.Where(p => IsPrereleaseRelease(p.Version) && !IsDevRelease(p.Version))
.OrderByDescending(p => ParseSemanticVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
var prodPackages = packages.Where(p => IsProdRelease(p.Version))
.OrderByDescending(p => ParseSemanticVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
// Apply cleanup rules for each type
packagesToDelete.AddRange(FilterProdReleases(prodPackages));
packagesToDelete.AddRange(FilterPrereleaseReleases(prereleasePackages));
packagesToDelete.AddRange(FilterDevReleases(devPackages));
return packagesToDelete;
}
private List<GiteaPackage> FilterPackagesToDeleteByDateVersion(List<GiteaPackage> packages)
{
var packagesToDelete = new List<GiteaPackage>();
// Group packages by release type
// Note: Dev releases must be checked before prerelease since -dev is a suffix
var devPackages = packages.Where(p => IsDevRelease(p.Version))
.OrderByDescending(p => ParseDateVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
var prereleasePackages = packages.Where(p => IsPrereleaseRelease(p.Version) && !IsDevRelease(p.Version))
.OrderByDescending(p => ParseDateVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
var prodPackages = packages.Where(p => IsProdRelease(p.Version))
.OrderByDescending(p => ParseDateVersion(p.Version))
.ThenByDescending(p => p.CreatedAt)
.ToList();
// Apply cleanup rules for each type
packagesToDelete.AddRange(FilterProdReleasesDateVersion(prodPackages));
packagesToDelete.AddRange(FilterPrereleaseReleasesDateVersion(prereleasePackages));
packagesToDelete.AddRange(FilterDevReleasesDateVersion(devPackages));
return packagesToDelete;
}
// Prod release methods for semantic versioning
private List<GiteaPackage> FilterProdReleases(List<GiteaPackage> packages)
{
// Check if prod cleaning is enabled
if (!GetBoolConfigValue("CLEAN_PROD_VERSIONS", false))
return new List<GiteaPackage>();
// Get keep count
var keepCount = GetIntConfigValue("KEEP_PROD_VERSIONS", 5);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Prerelease methods for semantic versioning
private List<GiteaPackage> FilterPrereleaseReleases(List<GiteaPackage> packages)
{
// Get keep count
var keepCount = GetIntConfigValue("KEEP_PRERELEASE_VERSIONS", 3);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Dev release methods for semantic versioning
private List<GiteaPackage> FilterDevReleases(List<GiteaPackage> packages)
{
// Get keep count
var keepCount = GetIntConfigValue("KEEP_DEV_VERSIONS", 5);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Prod release methods for date-based versioning
private List<GiteaPackage> FilterProdReleasesDateVersion(List<GiteaPackage> packages)
{
// Check if prod cleaning is enabled
if (!GetBoolConfigValue("CLEAN_PROD_VERSIONS", false))
return new List<GiteaPackage>();
// Get keep count
var keepCount = GetIntConfigValue("KEEP_PROD_VERSIONS", 5);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Prerelease methods for date-based versioning
private List<GiteaPackage> FilterPrereleaseReleasesDateVersion(List<GiteaPackage> packages)
{
// Get keep count
var keepCount = GetIntConfigValue("KEEP_PRERELEASE_VERSIONS", 3);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Dev release methods for date-based versioning
private List<GiteaPackage> FilterDevReleasesDateVersion(List<GiteaPackage> packages)
{
// Get keep count
var keepCount = GetIntConfigValue("KEEP_DEV_VERSIONS", 5);
// If keepCount <= 0, keep all
if (keepCount <= 0)
return new List<GiteaPackage>();
// Packages are already sorted descending by version
// Keep top N, delete rest
return packages.Skip(keepCount).ToList();
}
// Helper methods to identify release types
private bool IsProdRelease(string version)
{
// Prod versions typically don't have pre-release identifiers (alpha, beta, rc, dev, etc.)
return !version.Contains("-", StringComparison.OrdinalIgnoreCase);
}
private bool IsPrereleaseRelease(string version)
{
// Prerelease versions contain identifiers like -alpha, -beta, -rc, -preview
// But NOT -dev, which is a separate release type
var lowerVersion = version.ToLowerInvariant();
return (lowerVersion.Contains("alpha") || lowerVersion.Contains("beta") ||
lowerVersion.Contains("rc") || lowerVersion.Contains("preview")) ||
lowerVersion.Contains("staging") && !lowerVersion.Contains("dev");
}
private bool IsDevRelease(string version)
{
// Dev versions contain identifiers like dev or similar
return version.ToLowerInvariant().Contains("dev");
}
// Helper methods to identify versioning variant
private bool IsSemanticVersion(string version)
{
// Semantic versioning: major.minor.micro.build with typically smaller numbers
// Examples: 1.2.3.4, 2.0.1.100
var versionPart = version.Split('-')[0];
var parts = versionPart.Split('.').Where(p => !string.IsNullOrEmpty(p)).ToArray();
if (parts.Length < 2 || parts.Length > 4)
return false;
// Try to parse all parts as numbers
if (!parts.All(p => int.TryParse(p, out var num)))
return false;
// Semantic versioning typically has smaller major version numbers (0-20 range)
if (int.TryParse(parts[0], out var major) && major > 100)
return false; // Likely a date version if first number > 100
return true;
}
private bool IsDateVersion(string version)
{
// Date-based versioning: year.month.day.build
// Examples: 2024.12.25.1, 2025.2.14.100
var versionPart = version.Split('-')[0];
var parts = versionPart.Split('.').Where(p => !string.IsNullOrEmpty(p)).ToArray();
if (parts.Length != 4)
return false;
// Try to parse all parts as numbers
if (!parts.All(p => int.TryParse(p, out var num)))
return false;
// Date version should have year > 1000 and < 3000
if (!int.TryParse(parts[0], out var year) || year < 1000 || year > 3000)
return false;
// Month should be 1-12
if (!int.TryParse(parts[1], out var month) || month < 1 || month > 12)
return false;
// Day should be 1-31
if (!int.TryParse(parts[2], out var day) || day < 1 || day > 31)
return false;
return true;
}
// Version parsing methods
private (int major, int minor, int micro, int build) ParseSemanticVersion(string version)
{
// Remove suffix if present (e.g., "-alpha", "-dev")
var versionPart = version.Split('-')[0];
var parts = versionPart.Split('.').Select(p => int.TryParse(p, out var num) ? num : 0).ToArray();
return (
parts.Length > 0 ? parts[0] : 0,
parts.Length > 1 ? parts[1] : 0,
parts.Length > 2 ? parts[2] : 0,
parts.Length > 3 ? parts[3] : 0
);
}
private (int year, int month, int day, int build) ParseDateVersion(string version)
{
// Remove suffix if present (e.g., "-alpha", "-dev")
var versionPart = version.Split('-')[0];
var parts = versionPart.Split('.').Select(p => int.TryParse(p, out var num) ? num : 0).ToArray();
return (
parts.Length > 0 ? parts[0] : 0,
parts.Length > 1 ? parts[1] : 0,
parts.Length > 2 ? parts[2] : 0,
parts.Length > 3 ? parts[3] : 0
);
}
// Configuration helper methods
private int GetIntConfigValue(string key, int defaultValue)
{
var value = configuration[key];
if (string.IsNullOrEmpty(value))
return defaultValue;
if (int.TryParse(value, out var result))
return result;
return defaultValue;
}
private bool GetBoolConfigValue(string key, bool defaultValue)
{
var value = configuration[key];
if (string.IsNullOrEmpty(value))
return defaultValue;
if (bool.TryParse(value, out var result))
return result;
// Handle common string representations
if (value.Equals("true", StringComparison.OrdinalIgnoreCase) ||
value.Equals("1", StringComparison.OrdinalIgnoreCase))
return true;
return defaultValue;
return packages.Where(p => !versionsToKeep.Contains(p.Version)).ToList();
}
}