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.
2026-11-04 16:37:41 +03:30
1 parent 143d813949
commit 7ac8a5af62
@@ -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);
+            using var fileContent = new StreamContent(fileStream);
+            fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

-        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 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);

-        request.Content = formData;
-
-        using var response = await httpClient.SendAsync(request,HttpCompletionOption.ResponseHeadersRead, token);
-        
-        response.EnsureSuccessStatusCode();
+            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;
+        }
    }
 }
@@ -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
 {
@@ -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)
    {
-        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);
-        return filePath;
+        try
+        {
+            var fileName = Path.GetFileName(url.AbsoluteUri);
+            var filePath = Path.Combine(Path.GetTempPath(), fileName);
+
+            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)
    {
-        File.Delete(downloadPath);
+        try
+        {
+            File.Delete(downloadPath);
+            await Task.CompletedTask;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to delete asset {Path}", downloadPath);
+            throw;
+        }
    }
 }
@@ -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]);
    }
 }