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/ForgejoService.cs

@@ -1,5 +1,4 @@
 using System.Net.Http.Headers;
-using System.Net.Http.Json;
 using System.Text;
 using System.Text.Json;
 using ForgejoReleaseSync.DTOs.Forgejo;
@@ -9,80 +8,87 @@ namespace ForgejoReleaseSync.Services;
 
 public class ForgejoService(HttpClient httpClient, AppConfig config, ILogger<ForgejoService> logger)
 {
-    public async Task<List<ForgejoReleaseResponseDto>> CreateReleaseAsync(string owner, string repo, string body, string name, string tagName, CancellationToken token = default)
+    public async Task<ForgejoReleaseResponseDto> CreateReleaseAsync(
+        string owner, string repo, string body, string name, string tagName, CancellationToken token = default)
     {
         try
         {
             var dto = new ForgejoCreateReleaseDto(body, false, false, name, false, tagName, "");
-        
             var json = JsonSerializer.Serialize(dto, AppJsonSerializerContext.Default.ForgejoCreateReleaseDto);
-            using var content = new StringContent(json, Encoding.UTF8, "application/json");
 
-            using var request = new HttpRequestMessage(HttpMethod.Post, new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases"));
-            request.Content = content;
-
-            request.Headers.Authorization =
-                new AuthenticationHeaderValue("token", config.ForgejoToken);
+            using var request = new HttpRequestMessage(
+                HttpMethod.Post,
+                new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases"));
+            request.Content = new StringContent(json, Encoding.UTF8, "application/json");
+            request.Headers.Authorization = new AuthenticationHeaderValue("token", config.ForgejoToken);
 
             using var response = await httpClient.SendAsync(request, token);
             response.EnsureSuccessStatusCode();
 
-            var responseStream = await response.Content.ReadAsStreamAsync(token);
-            var releases = await JsonSerializer.DeserializeAsync(responseStream,
-                AppJsonSerializerContext.Default.ListForgejoReleaseResponseDto, token);
-
-            return releases ?? [];
-            
+            await using var stream = await response.Content.ReadAsStreamAsync(token);
+            var created = await JsonSerializer.DeserializeAsync(
+                stream, AppJsonSerializerContext.Default.ForgejoReleaseResponseDto, token);
 
+            return created ?? throw new InvalidOperationException("Forgejo returned an empty release response");
         }
-        catch (Exception e)
+        catch (Exception ex)
         {
-            logger.LogError(e, "Failed to create forgejo release");
+            logger.LogError(ex, "Failed to create Forgejo release {Tag} for {Owner}/{Repo}", tagName, owner, repo);
             throw;
         }
-        
     }
 
-    public async Task<List<ForgejoReleaseResponseDto>> FetchRepoReleasesAsync(string owner, string repo, CancellationToken token = default)
+    public async Task<List<ForgejoReleaseResponseDto>> FetchRepoReleasesAsync(
+        string owner, string repo, CancellationToken token = default)
     {
         try
         {
-            var response = await httpClient.GetAsync(
-                new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases?per_page=3&page=1"));
-
+            using var response = await httpClient.GetAsync(
+                new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases?per_page=3&page=1"),
+                token);
             response.EnsureSuccessStatusCode();
 
-            var responseStream = await response.Content.ReadAsStreamAsync(token);
-            var releases = await JsonSerializer.DeserializeAsync(responseStream,
-                AppJsonSerializerContext.Default.ListForgejoReleaseResponseDto, token);
+            await using var stream = await response.Content.ReadAsStreamAsync(token);
+            var releases = await JsonSerializer.DeserializeAsync(
+                stream, AppJsonSerializerContext.Default.ListForgejoReleaseResponseDto, token);
 
             return releases ?? [];
         }
         catch (Exception ex)
         {
-            logger.LogError(ex, "Failed to fetch forgejo releases");
+            logger.LogError(ex, "Failed to fetch Forgejo releases for {Owner}/{Repo}", owner, repo);
             throw;
         }
     }
 
-    public async Task UploadReleaseAssetAsync(string owner, string repo, long releaseId, string filePath, CancellationToken token = default)
+    public async Task UploadReleaseAssetAsync(
+        string owner, string repo, long releaseId, string filePath, CancellationToken token = default)
     {
-        using var request = new HttpRequestMessage(HttpMethod.Post, new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases/{releaseId}/assets"));
+        try
+        {
+            await using var fileStream = new FileStream(
+                filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: true);
 
-        request.Headers.Authorization =
-            new AuthenticationHeaderValue("token", config.ForgejoToken);
-        
-        await using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
             using var fileContent = new StreamContent(fileStream);
             fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
 
             using var formData = new MultipartFormDataContent();
             formData.Add(fileContent, "attachment", Path.GetFileName(filePath));
 
+            using var request = new HttpRequestMessage(
+                HttpMethod.Post,
+                new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases/{releaseId}/assets"));
             request.Content = formData;
+            request.Headers.Authorization = new AuthenticationHeaderValue("token", config.ForgejoToken);
 
-        using var response = await httpClient.SendAsync(request,HttpCompletionOption.ResponseHeadersRead, token);
-        
+            using var response = await httpClient.SendAsync(
+                request, HttpCompletionOption.ResponseHeadersRead, token);
             response.EnsureSuccessStatusCode();
         }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to upload asset {Path} to {Owner}/{Repo}", filePath, owner, repo);
+            throw;
+        }
+    }
 }

Services/GithubService.cs

@@ -6,38 +6,35 @@ using Microsoft.Extensions.Logging;
 
 namespace ForgejoReleaseSync.Services;
 
-public class GithubService(
-    AppConfig config,
-    RepositoryConfig repoConfig,
-    HttpClient httpClient,
-    ILogger<GithubService> logger)
+public class GithubService(HttpClient httpClient, ILogger<GithubService> logger)
 {
-    public async Task<List<GithubReleaseResponseDto>> FetchRepoReleasesAsync(string owner, string repo)
+    public async Task<List<GithubReleaseResponseDto>> FetchRepoReleasesAsync(
+        string owner, string repo, CancellationToken token = default)
     {
         try
         {
-            var response = await httpClient.GetAsync(
-                new Uri($"https://api.github.com/repos/{owner}/{repo}/releases?per_page=3&page=1"));
-
+            using var response = await httpClient.GetAsync(
+                new Uri($"https://api.github.com/repos/{owner}/{repo}/releases?per_page=3&page=1"),
+                token);
             response.EnsureSuccessStatusCode();
 
-            var responseStream = await response.Content.ReadAsStreamAsync();
-            var releases = await JsonSerializer.DeserializeAsync(responseStream,
-                AppJsonSerializerContext.Default.ListGithubReleaseResponseDto);
+            await using var stream = await response.Content.ReadAsStreamAsync(token);
+            var releases = await JsonSerializer.DeserializeAsync(
+                stream, AppJsonSerializerContext.Default.ListGithubReleaseResponseDto, token);
 
             return releases ?? [];
         }
         catch (Exception ex)
         {
-            logger.LogError(ex, "Failed to fetch posts from Mastodon");
+            logger.LogError(ex, "Failed to fetch GitHub releases for {Owner}/{Repo}", owner, repo);
             throw;
         }
     }
 }
 
-// TODO: move this
 [JsonSerializable(typeof(List<GithubReleaseResponseDto>))]
 [JsonSerializable(typeof(ForgejoCreateReleaseDto))]
+[JsonSerializable(typeof(ForgejoReleaseResponseDto))]
 [JsonSerializable(typeof(List<ForgejoReleaseResponseDto>))]
 internal partial class AppJsonSerializerContext : JsonSerializerContext
 {

Services/ReleaseAssetDownloadService.cs

@@ -1,19 +1,41 @@
+using Microsoft.Extensions.Logging;
+
 namespace ForgejoReleaseSync.Services;
 
-public class ReleaseAssetDownloadService(HttpClient httpClient)
+public class ReleaseAssetDownloadService(HttpClient httpClient, ILogger<ReleaseAssetDownloadService> logger)
 {
-    public async Task<string> DownloadReleaseAssetAsync(Uri url)
+    public async Task<string> DownloadReleaseAssetAsync(Uri url, CancellationToken token = default)
+    {
+        try
         {
             var fileName = Path.GetFileName(url.AbsoluteUri);
             var filePath = Path.Combine(Path.GetTempPath(), fileName);
-        await using Stream resource = await httpClient.GetStreamAsync(url);
-        await using FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate);
-        await resource.CopyToAsync(fs, 8192);
+
+            await using var resource = await httpClient.GetStreamAsync(url, token);
+            await using var fs = new FileStream(
+                filePath, FileMode.Create, FileAccess.Write, FileShare.None, 8192, useAsync: true);
+            await resource.CopyToAsync(fs, token);
+
             return filePath;
         }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to download asset from {Url}", url);
+            throw;
+        }
+    }
 
-    public async Task DeleteReleaseAssetAsync(string downloadPath)
+    public async Task DeleteReleaseAssetAsync(string downloadPath, CancellationToken token = default)
+    {
+        try
         {
             File.Delete(downloadPath);
+            await Task.CompletedTask;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to delete asset {Path}", downloadPath);
+            throw;
+        }
     }
 }

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();
+            try
+            {
+                await SyncRepositoryAsync(repo, token);
+            }
+            catch (Exception ex)
+            {
+                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 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)
-            {
-                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;
-            }
-            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))
+        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(
-                    "Repo {Owner}/{Name}: release: {ReleaseName} has {ReleaseCount} assets with matching assets",
-                    repoOwner,
-                    repoName, 
-                lastRelease.Name,
-                acceptableAssets.Length);
+            "{Owner}/{Name}: release {Tag} has {Count} asset(s) to sync",
+            owner, name, githubRelease.TagName, assetsToSync.Length);
 
-            foreach (var acceptableAsset in acceptableAssets)
+        foreach (var asset in assetsToSync)
         {
-                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);
+            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]);
     }
 }