feat: enhance release synchronization with cancellation support, error handling, and logging

- Added `CancellationToken` support across SyncService, GithubService, ForgejoService, and ReleaseAssetDownloadService.
- Improved error handling with detailed logging for asset downloads, deletions, and API operations.
- Refactored SyncService for clearer repository and asset synchronization logic.
- Enhanced performance with async file streams and refined conditional checks.

Services/SyncService.cs

@@ -1,78 +1,117 @@
-using System.Security.Cryptography.X509Certificates;
 using System.Text.RegularExpressions;
+using ForgejoReleaseSync.DTOs;
+using ForgejoReleaseSync.DTOs.Forgejo;
 using Microsoft.Extensions.Logging;
 
 namespace ForgejoReleaseSync.Services;
 
 public class SyncService(
-    AppConfig config,
     RepositoryConfig repositoryConfig,
     GithubService githubService,
     ForgejoService forgejoService,
     ReleaseAssetDownloadService releaseAssetDownloadService,
     ILogger<SyncService> logger)
 {
-
-    public async Task Sync()
+    public async Task Sync(CancellationToken token = default)
     {
-        logger.LogInformation("Starting Sync Service");
-        logger.LogInformation($"loaded {repositoryConfig.Repositories.Count} repositories");
+        logger.LogInformation("Starting sync for {Count} repositories", repositoryConfig.Repositories.Count);
+
         foreach (var repo in repositoryConfig.Repositories)
         {
-            var repoOwner = repo.GithubUrl.Split('/')[^2]; 
-            var repoName = repo.GithubUrl.Split('/').Last();
-            
-            var includeRegex = new Regex(repo.IncludeAssetsRegex);
-            var excludeRegex = new Regex(repo.ExcludeAssetsRegex);
-            
-            var releases = await githubService.FetchRepoReleasesAsync(repoOwner, repoName);
-            
-            var lastRelease = releases.LastOrDefault(r => r.Prerelease == false);
-            if (lastRelease is null)
-                continue;
-            
-            var forgejoReleases = await forgejoService.FetchRepoReleasesAsync(repoOwner, repoName);
-            var lastForgejoRelease = forgejoReleases.LastOrDefault(r => r.Prerelease == false);
-
-            long releaseId; 
-            if (lastForgejoRelease is null || lastForgejoRelease.TagName != lastRelease.TagName)
+            try
             {
-                logger.LogInformation("Creating release {ReleaseName} for repo {Owner}/{Name}",
-                    lastRelease.Name,
-                    repoOwner,
-                    repoName);
-                var createReleaseRes = await forgejoService.CreateReleaseAsync(repoOwner, repoName, lastRelease.Body, lastRelease.Name, lastRelease.TagName);
-                releaseId = createReleaseRes.LastOrDefault().Id;
+                await SyncRepositoryAsync(repo, token);
             }
-            releaseId = lastForgejoRelease.Id;
-            
-            var acceptableAssets = lastRelease.Assets
-                .Where(asset =>
-                    includeRegex.IsMatch(asset.Name) &&
-                    !excludeRegex.IsMatch(asset.Name) && lastForgejoRelease.Assets.All(releaseAsset => releaseAsset.Name != asset.Name))
-                .ToArray();
-
-            logger.LogInformation(
-                    "Repo {Owner}/{Name}: release: {ReleaseName} has {ReleaseCount} assets with matching assets",
-                    repoOwner,
-                    repoName, 
-                lastRelease.Name,
-                acceptableAssets.Length);
-
-            foreach (var acceptableAsset in acceptableAssets)
+            catch (Exception ex)
             {
-                logger.LogInformation($"Downloading {acceptableAsset.Name}");
-                
-                var downloadPath = await releaseAssetDownloadService.DownloadReleaseAssetAsync(acceptableAsset.BrowserDownloadUrl);
-                
-                logger.LogInformation($"Downloaded {acceptableAsset.Name} to {downloadPath}");
-                
-                await forgejoService.UploadReleaseAssetAsync(repoOwner, repoName, releaseId, downloadPath);
-                
-                logger.LogInformation($"Uploaded {acceptableAsset.Name}");
-                
-                await releaseAssetDownloadService.DeleteReleaseAssetAsync(downloadPath);
+                logger.LogError(ex, "Failed to sync repository {Name}", repo.Name);
             }
         }
+
+        logger.LogInformation("Sync finished");
+    }
+
+    private async Task SyncRepositoryAsync(RepoSyncConfig repo, CancellationToken token)
+    {
+        var (owner, name) = ParseGithubUrl(repo.GithubUrl);
+
+        var githubReleases = await githubService.FetchRepoReleasesAsync(owner, name, token);
+        var githubRelease = githubReleases.LastOrDefault(r => !r.Prerelease);
+        if (githubRelease is null)
+        {
+            logger.LogWarning("{Owner}/{Name}: no GitHub release found, skipping", owner, name);
+            return;
+        }
+
+        var forgejoReleases = await forgejoService.FetchRepoReleasesAsync(owner, name, token);
+        var forgejoRelease = forgejoReleases.LastOrDefault(r => !r.Prerelease);
+
+        var releaseId = await ResolveReleaseIdAsync(owner, name, githubRelease, forgejoRelease, token);
+
+        var includeRegex = new Regex(repo.IncludeAssetsRegex);
+        var excludeRegex = new Regex(repo.ExcludeAssetsRegex);
+        var existingAssets = forgejoRelease?.Assets.Select(a => a.Name).ToHashSet(StringComparer.Ordinal) ?? [];
+
+        var assetsToSync = githubRelease.Assets
+            .Where(a => includeRegex.IsMatch(a.Name))
+            .Where(a => !excludeRegex.IsMatch(a.Name))
+            .Where(a => !existingAssets.Contains(a.Name))
+            .ToArray();
+
+        logger.LogInformation(
+            "{Owner}/{Name}: release {Tag} has {Count} asset(s) to sync",
+            owner, name, githubRelease.TagName, assetsToSync.Length);
+
+        foreach (var asset in assetsToSync)
+        {
+            await SyncAssetAsync(owner, name, releaseId, asset, token);
+        }
+    }
+
+    private async Task<long> ResolveReleaseIdAsync(
+        string owner,
+        string name,
+        GithubReleaseResponseDto githubRelease,
+        ForgejoReleaseResponseDto? forgejoRelease,
+        CancellationToken token)
+    {
+        if (forgejoRelease is not null && forgejoRelease.TagName == githubRelease.TagName)
+            return forgejoRelease.Id;
+
+        logger.LogInformation(
+            "{Owner}/{Name}: creating Forgejo release {Tag}",
+            owner, name, githubRelease.TagName);
+
+        var created = await forgejoService.CreateReleaseAsync(
+            owner, name, githubRelease.Body, githubRelease.Name, githubRelease.TagName, token);
+
+        return created.Id;
+    }
+
+    private async Task SyncAssetAsync(
+        string owner,
+        string name,
+        long releaseId,
+        Asset asset,
+        CancellationToken token)
+    {
+        logger.LogInformation("{Owner}/{Name}: downloading {Asset}", owner, name, asset.Name);
+        var path = await releaseAssetDownloadService.DownloadReleaseAssetAsync(asset.BrowserDownloadUrl, token);
+
+        try
+        {
+            logger.LogInformation("{Owner}/{Name}: uploading {Asset}", owner, name, asset.Name);
+            await forgejoService.UploadReleaseAssetAsync(owner, name, releaseId, path, token);
+        }
+        finally
+        {
+            await releaseAssetDownloadService.DeleteReleaseAssetAsync(path);
+        }
+    }
+
+    private static (string Owner, string Name) ParseGithubUrl(string url)
+    {
+        var parts = new Uri(url).AbsolutePath.Trim('/').Split('/');
+        return (parts[0], parts[1]);
     }
 }