Limits process-manifests for a directory

* Also moves the generated bom to a cache location so that it can be accessed by future activities without any worries
* Also discovered that `DateTime` was being used instead of `DateTimeOffset` when triggering the `process-manifest` command
* Also discovered that `DateTime.Now` was being used instead of the "as of" time from the cached history point

Author: mscottford

Corgibytes.Freshli.Cli.Test/Functionality/BillOfMaterials/GenerateBillOfMaterialsActivityTest.cs

@@ -15,8 +15,9 @@ public class GenerateBillOfMaterialsActivityTest
     public void Handle()
     {
         // Arrange
+        var asOfDateTime = DateTimeOffset.Now;
         var javaAgentReader = new Mock<IAgentReader>();
-        javaAgentReader.Setup(mock => mock.ProcessManifest("/path/to/manifest", It.IsAny<DateTime>()))
+        javaAgentReader.Setup(mock => mock.ProcessManifest("/path/to/manifest", asOfDateTime))
             .Returns("/path/to/bill-of-materials");
 
         const string agentExecutablePath = "/path/to/agent";
@@ -25,10 +26,16 @@ public void Handle()
 
         var cacheManager = new Mock<ICacheManager>();
         var cacheDb = new Mock<ICacheDb>();
-        var historyStopPoint = new CachedHistoryStopPoint { LocalPath = "/path/to/repository" };
+        var historyStopPoint = new CachedHistoryStopPoint
+        {
+            LocalPath = "/path/to/repository",
+            AsOfDateTime = asOfDateTime
+        };
 
         var historyStopPointId = 29;
+
         cacheManager.Setup(mock => mock.GetCacheDb()).Returns(cacheDb.Object);
+
         cacheDb.Setup(mock => mock.RetrieveHistoryStopPoint(historyStopPointId)).Returns(historyStopPoint);
 
         var serviceProvider = new Mock<IServiceProvider>();
@@ -40,6 +47,10 @@ public void Handle()
 
         // Act
         var analysisId = Guid.NewGuid();
+
+        cacheManager.Setup(mock => mock.StoreBomInCache("/path/to/bill-of-materials", analysisId, asOfDateTime))
+            .Returns("/path/to/bom/in/cache");
+
         var activity =
             new GenerateBillOfMaterialsActivity(analysisId, agentExecutablePath, historyStopPointId,
                 "/path/to/manifest");
@@ -51,6 +62,6 @@ public void Handle()
                 appEvent.AgentExecutablePath == agentExecutablePath &&
                 appEvent.AnalysisId == analysisId &&
                 appEvent.HistoryStopPointId == historyStopPointId &&
-                appEvent.PathToBillOfMaterials == "/path/to/bill-of-materials")));
+                appEvent.PathToBillOfMaterials == "/path/to/bom/in/cache")));
     }
 }

Corgibytes.Freshli.Cli/Functionality/BillOfMaterials/GenerateBillOfMaterialsActivity.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.IO;
+using Corgibytes.Freshli.Cli.DataModel;
 using Corgibytes.Freshli.Cli.Functionality.Engine;
 using Corgibytes.Freshli.Cli.Services;
 using Microsoft.Extensions.DependencyInjection;
@@ -13,6 +15,8 @@ public class GenerateBillOfMaterialsActivity : IApplicationActivity
     public readonly int HistoryStopPointId;
     public readonly string ManifestPath;
 
+    private static readonly ConcurrentDictionary<string, object> s_lockPoints = new();
+
     public GenerateBillOfMaterialsActivity(Guid analysisId, string agentExecutablePath,
         int historyStopPointId, string manifestPath)
     {
@@ -29,13 +33,30 @@ public void Handle(IApplicationEventEngine eventClient)
 
         var cacheManager = eventClient.ServiceProvider.GetRequiredService<ICacheManager>();
         var cacheDb = cacheManager.GetCacheDb();
+
         var historyStopPoint = cacheDb.RetrieveHistoryStopPoint(HistoryStopPointId);
+        _ = historyStopPoint ?? throw new Exception($"Failed to retrieve history stop point {HistoryStopPointId}");
+
+        var historyPointPath = historyStopPoint.LocalPath;
+        var asOfDateTime = historyStopPoint.AsOfDateTime;
 
-        var asOfDateTime = DateTime.Now;
-        var pathToBillOfMaterials =
-            agentReader.ProcessManifest(Path.Combine(historyStopPoint?.LocalPath!, ManifestPath), asOfDateTime);
+        EnsureLockPointExists(historyPointPath);
+        lock (s_lockPoints[historyPointPath])
+        {
+            var fullManifestPath = Path.Combine(historyPointPath, ManifestPath);
+            var bomFilePath = agentReader.ProcessManifest(fullManifestPath, asOfDateTime);
+            var cachedBomFilePath = cacheManager.StoreBomInCache(bomFilePath, AnalysisId, asOfDateTime);
 
-        eventClient.Fire(new BillOfMaterialsGeneratedEvent(AnalysisId, HistoryStopPointId, pathToBillOfMaterials,
-            AgentExecutablePath));
+            eventClient.Fire(new BillOfMaterialsGeneratedEvent(
+                AnalysisId, HistoryStopPointId, cachedBomFilePath, AgentExecutablePath));
+        }
+    }
+
+    private void EnsureLockPointExists(string path)
+    {
+        if (!s_lockPoints.ContainsKey(path))
+        {
+            s_lockPoints[path] = new object();
+        }
     }
 }

Corgibytes.Freshli.Cli/Functionality/CacheManager.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Linq;
 using Corgibytes.Freshli.Cli.DataModel;
@@ -54,7 +55,7 @@ public bool Prepare()
         return true;
     }
 
-    public DirectoryInfo GetDirectoryInCache(string[] directoryStructure)
+    public DirectoryInfo GetDirectoryInCache(params string[] directoryStructure)
     {
         var cacheDir = new DirectoryInfo(_configuration.CacheDir);
         Prepare();
@@ -82,6 +83,18 @@ public DirectoryInfo GetDirectoryInCache(string[] directoryStructure)
         return focus;
     }
 
+    public string StoreBomInCache(string bomFilePath, Guid analysisId, DateTimeOffset asOfDateTime)
+    {
+        var bomFileInfo = new FileInfo(bomFilePath);
+
+        var bomCacheDirInfo = GetDirectoryInCache("boms", analysisId.ToString(), asOfDateTime.ToString("u"));
+        var cachedBomFilePath = Path.Combine(bomCacheDirInfo.FullName, bomFileInfo.Name);
+
+        File.Copy(bomFilePath, cachedBomFilePath);
+
+        return cachedBomFilePath;
+    }
+
     public bool Destroy()
     {
         var cacheDir = new DirectoryInfo(_configuration.CacheDir);

Corgibytes.Freshli.Cli/Functionality/ICacheManager.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 
 namespace Corgibytes.Freshli.Cli.Functionality;
@@ -7,7 +8,9 @@ public interface ICacheManager
     public bool ValidateCacheDirectory();
     public bool Prepare();
     public bool Destroy();
-    public DirectoryInfo GetDirectoryInCache(string[] directoryStructure);
+    public DirectoryInfo GetDirectoryInCache(params string[] directoryStructure);
+
+    public string StoreBomInCache(string pathToBom, Guid analysisId, DateTimeOffset asOfDateTime);
 
     public ICacheDb GetCacheDb();
 }

Corgibytes.Freshli.Cli/Services/AgentReader.cs

@@ -57,7 +57,7 @@ public List<string> DetectManifests(string projectPath)
         return manifests.IsEmpty() ? new List<string>() : manifests.TrimEnd('\n', '\r').Split("\n").ToList();
     }
 
-    public string ProcessManifest(string manifestPath, DateTime asOfDateTime)
+    public string ProcessManifest(string manifestPath, DateTimeOffset asOfDateTime)
     {
         var billOfMaterialsPath =
             _invoke.Command(AgentExecutablePath, $"process-manifest {manifestPath} {asOfDateTime:o}", ".");

Corgibytes.Freshli.Cli/Services/IAgentReader.cs

@@ -10,5 +10,5 @@ public interface IAgentReader
     public string AgentExecutablePath { get; }
     public List<Package> RetrieveReleaseHistory(PackageURL packageUrl);
     public List<string> DetectManifests(string projectPath);
-    public string ProcessManifest(string manifestPath, DateTime asOfDateTime);
+    public string ProcessManifest(string manifestPath, DateTimeOffset asOfDateTime);
 }