get codeflows wip

Author: adamzip

src/ProductConstructionService/ProductConstructionService.Common/CodeflowHistoryManager.cs

@@ -8,7 +8,6 @@ namespace ProductConstructionService.Common;
 
 public interface ICodeflowHistoryManager
 {
-    void RefreshCodeflowHistory(string repo, string branch);
     Task<CodeflowHistoryResult> GetCodeflowHistory(Guid? subscriptionId);
     Task<CodeflowHistory?> FetchLatestCodeflowHistoryAsync(Guid? subscriptionId);
 }
@@ -32,7 +31,7 @@ public record CodeflowGraphCommit(
     DateTimeOffset CommitDate,
     string Author,
     string Description,
-    List<CodeflowGraphCommit> IncomingCodeflows);
+    CodeflowGraphCommit? IncomingCodeflow);
 
 public class CodeflowHistoryManager : ICodeflowHistoryManager
 {
@@ -47,60 +46,76 @@ public CodeflowHistoryManager(
         _remoteFactory = remoteFactory;
     }
 
-    public async void RefreshCodeflowHistory(string repo, string branch)
+    public async Task<CodeflowHistory?> GetCachedCodeflowHistoryAsync(Subscription subscription)
     {
-        //0. Fetch latest commit from local git repo if exists
-        //1. Fetch new parts from GitHub API
-        //2. Fetch old parts from disk
-        //3. Stitch them together
-        //4. Write contents to cache
-        await Task.CompletedTask;
+        string id = subscription.Id.ToString()!;
+        var cache = _redisCacheFactory.Create<CodeflowGraphCommit>(id);
+        return await cache.TryGetStateAsync();
     }
 
-    public async Task<CodeflowHistoryResult> GetCodeflowHistory(Subscription subscription, bool fetchLatest)
+    public async Task<CodeflowHistory?> GetCachedCodeflowHistoryAsync(
+        Subscription subscription,
+        string commitSha,
+        int commitFetchCount)
     {
-        //todo: implement this method
-    }
-
-    public async Task<CodeflowHistory?> GetCachedCodeflowHistoryAsync(Guid? subscriptionId)
-    {
-        string id = subscriptionId.ToString()!;
-
-        var cache = _redisCacheFactory.Create<CodeflowHistory>(id);
-
-        var cachedHistory = await cache.TryGetStateAsync();
-        return cachedHistory;
+        // todo this method returns the codeflow history starting from commitSha. 
+        // It only reads from redis and never modifies the cache
     }
-
-
-    public async Task<CodeflowHistory?> FetchLatestCodeflowHistoryAsync(Subscription subscription)
+    public async Task<CodeflowHistory?> FetchLatestCodeflowHistoryAsync(
+        Subscription subscription,
+        int commitFetchCount)
     {
+        //todo acquire lock on the redis Zset here
         var cachedCommits = await GetCachedCodeflowHistoryAsync(subscription.Id);
 
         var remote = await _remoteFactory.CreateRemoteAsync(subscription.TargetRepository);
 
+        latestCachedCommitSha = cachedCommits?.Commits.FirstOrDefault()?.CommitSha;
+
         var latestCommits = await remote.FetchNewerRepoCommitsAsync(
             subscription.TargetBranch,
             subscription.TargetBranch,
-            cachedCommits?.Commits.FirstOrDefault()?.CommitSha,
-            500);
+            latestCachedCommitSha,
+            commitFetchCount);
+
+        if (latestCommits.Count == commitFetchCount &&
+            latestCommits.LastOrDefault()?.CommitSha != latestCachedCommitSha)
+        {
+            // we have a gap in the history - throw away cache because we can't form a continuous history
+            cachedCommits = [];
+        }
+        else
+        {
+            latestCommits = latestCommits
+                .Where(commit => commit.CommitSha != latestCachedCommitSha)
+                .ToList();
+        }
 
         var latestCachedCodeflow = cachedCommits?.Commits.FirstOrDefault(
-            x => x.IncomingCodeflows.Count > 0);
+            commit => commit.IncomingCodeflows != null);
 
         var codeFlows = await FetchLatestIncomingCodeflows(
             subscription.TargetRepository,
             subscription.TargetBranch,
-            latestCachedCodeflow,
+            latestCommits,
             remote);
 
+        foreach (var commit in latestCommits)
+        {
+            string? sourceCommitSha = codeflows.GetCodeflowSourceCommit(commit.CommitSha);
+            commit.IncomingCodeflow = sourceCommitSha;
+        }
+
+        // todo cache fresh commits and release lock on the Zset
+        await CacheCommits(latestCommits);
+
         return null;
     }
 
-    private async Task<List<CodeflowGraphCommit>> FetchLatestIncomingCodeflows(
+    private async Task<GraphCodeflows> FetchLatestIncomingCodeflows(
         string repo,
         string branch,
-        CodeflowGraphCommit? latestCachedCommit,
+        List<CodeflowGraphCommit> latestCommits,
         IRemote? remote)
     {
         if (remote == null)
@@ -113,4 +128,36 @@ private async Task<List<CodeflowGraphCommit>> FetchLatestIncomingCodeflows(
         //todo: implement this method
         return null;
     }
+
+    private async Task CacheCommits(List<CodeflowGraphCommit> commits)
+    {
+        // Cache the commits as part of the subscription's redis ZSet of CodeflowGraphCommit objects
+        if (commits.Count == 0)
+        {
+            return;
+        }
+        var cache = _redisCacheFactory.Create<CodeflowGraphCommit>(subscription.Id.ToString()!);
+        await cache.SetStateAsync(new CodeflowHistory(commits, codeflows));
+
+    }
+}
+
+class GraphCodeflows
+{
+    // keys: target repo commits that have incoing codeflows
+    // values: commit SHAs of those codeflows in the source repo
+    public Dictionary<string, string> Codeflows { get; set; } = [];
+
+    /// <summary>
+    /// Returns the source commit of the codeflow if targetCommitSha is a target commit of a codeflow.
+    /// Otherwise, return null
+    /// </summary>
+    public string? GetCodeflowSourceCommit(string targetCommitSha)
+    {
+        if (Codeflows.TryGetValue(targetCommitSha, out var sourceCommit))
+        {
+            return sourceCommit;
+        }
+        return null;
+    }
 }