switched to xunit

Management/Services/Actors/CanvasQueue.cs

@@ -0,0 +1,9 @@
+using Akka.Actor;
+
+using Management.Services.Canvas;
+
+public class CanvasQueue(IActorRef canvasQueueActor)
+{
+  private readonly IActorRef canvasQueueActor = canvasQueueActor;
+
+}

Management/Services/Actors/CanvasQueueActor.cs

@@ -0,0 +1,18 @@
+using Akka.Actor;
+
+using Microsoft.Extensions.DependencyInjection;
+
+public class CanvasQueueActor : ReceiveActor
+{
+  private readonly IServiceProvider serviceProvider;
+  private readonly IServiceScope scope;
+  private readonly ILogger<CanvasQueueActor> logger;
+
+  public CanvasQueueActor(IServiceProvider serviceProviderArg)
+  {
+    serviceProvider = serviceProviderArg;
+    scope = serviceProvider.CreateScope();
+    logger  = scope.ServiceProvider.GetRequiredService<ILogger<CanvasQueueActor>>();
+    
+  }
+}

Management/Services/Actors/LocalStorageActor.cs

@@ -0,0 +1,61 @@
+using Akka.Actor;
+
+using LocalModels;
+
+using Microsoft.Extensions.DependencyInjection;
+
+public class LocalStorageActor : ReceiveActor
+{
+  private readonly IServiceProvider serviceProvider;
+  private readonly IServiceScope scope;
+  private readonly ILogger<CanvasQueueActor> logger;
+  private readonly FileStorageManager storage;
+
+  private DateTime? cacheTime { get; set; } = null;
+  private IEnumerable<LocalCourse>? cachedCourses { get; set; } = null;
+  private readonly int cacheSeconds = 2;
+
+  public LocalStorageActor(IServiceProvider serviceProviderArg)
+  {
+    serviceProvider = serviceProviderArg;
+    scope = serviceProvider.CreateScope();
+    logger = scope.ServiceProvider.GetRequiredService<ILogger<CanvasQueueActor>>();
+    storage = scope.ServiceProvider.GetRequiredService<FileStorageManager>();
+
+    Receive<EmptyDirectoryAsk>(m =>
+    {
+      storage
+        .GetEmptyDirectories()
+        .PipeTo(Sender);
+    });
+
+    ReceiveAsync<SavedCoursesAsk>(async m =>
+    {
+      var secondsFromLastLoad = (DateTime.Now - cacheTime)?.Seconds;
+
+      if (cachedCourses != null && secondsFromLastLoad < cacheSeconds)
+      {
+        logger.LogInformation("returning cached courses from file");
+        Sender.Tell(cachedCourses);
+        return;
+      }
+
+      cachedCourses = await storage.LoadSavedCourses();
+      cacheTime = DateTime.Now;
+      Sender.Tell(cachedCourses);
+    });
+
+    ReceiveAsync<SaveCoursesRequest>(async m =>
+    {
+      cacheTime = null;
+      cachedCourses = null;
+      await storage.SaveCourseAsync(m.Course, m.PreviouslyStoredCourse);
+    });
+  }
+}
+
+public record EmptyDirectoryAsk();
+public record SavedCoursesAsk();
+
+public record SaveCoursesRequest(LocalCourse Course, LocalCourse? PreviouslyStoredCourse);
+public record SaveCoursesResponseSuccess();

Management/Services/Actors/LocalStorageCache.cs

@@ -0,0 +1,23 @@
+using Akka.Actor;
+
+using LocalModels;
+
+public class LocalStorageCache(IActorRef storageActor) : IFileStorageManager
+{
+  private readonly IActorRef storageActor = storageActor;
+
+  public async Task<IEnumerable<string>> GetEmptyDirectories()
+  {
+    return await storageActor.Ask<IEnumerable<string>>(new EmptyDirectoryAsk());
+  }
+
+  public async Task<IEnumerable<LocalCourse>> LoadSavedCourses()
+  {
+    return await storageActor.Ask<IEnumerable<LocalCourse>>(new SavedCoursesAsk());
+  }
+
+  public async Task SaveCourseAsync(LocalCourse course, LocalCourse? previouslyStoredCourse)
+  {
+    await storageActor.Ask<SaveCoursesResponseSuccess>(new SaveCoursesRequest(course, previouslyStoredCourse));
+  }
+}