Support workspaces

Amaurot.Processor/Clients/TofuClient.cs

@@ -8,30 +8,38 @@ internal static class TofuClient
 {
     private static readonly string TofuPath = Environment.GetEnvironmentVariable("TOFU_PATH")!;
 
-    private const string TofuArguments = "-input=false -no-color";
-
-    public static async Task<PlanOutput> TofuExecution(
-        ExecutionType executionType,
-        string directory
-    )
+    public static async Task<PlanOutput> TofuExecution(Execution execution)
     {
-        var tofu = Process.Start(
-            new ProcessStartInfo
+        var processStartInfo = new ProcessStartInfo
+        {
+            FileName = TofuPath,
+            WorkingDirectory = execution.Directory,
+            RedirectStandardOutput = true,
+        };
+
+        processStartInfo.ArgumentList.Add(execution.ExecutionType.ToString().ToLower());
+        processStartInfo.ArgumentList.Add("-input=false");
+        processStartInfo.ArgumentList.Add("-no-color");
+
+        var varFiles = execution.Workspace.VarFiles;
+
+        if (varFiles is not null)
+        {
+            foreach (var varFile in varFiles)
             {
-                FileName = TofuPath,
-                Arguments = $"{executionType.ToString().ToLower()} {TofuArguments}",
-                WorkingDirectory = directory,
-                RedirectStandardOutput = true,
+                processStartInfo.ArgumentList.Add($"-var-file={varFile}");
             }
-        );
+        }
+
+        var tofu = Process.Start(processStartInfo);
 
         await tofu!.WaitForExitAsync();
 
         var stdout = await tofu.StandardOutput.ReadToEndAsync();
 
         return new PlanOutput
         {
-            ExecutionType = executionType,
+            ExecutionType = execution.ExecutionType,
             ExecutionState = tofu.ExitCode is 0 or 2
                 ? CommitStatusState.Success
                 : CommitStatusState.Failure,

Amaurot.Processor/Models/OpenTofu/Execution.cs

@@ -0,0 +1,8 @@
+namespace Amaurot.Processor.Models.OpenTofu;
+
+internal class Execution
+{
+    public required ExecutionType ExecutionType { get; init; }
+    public required string Directory { get; init; }
+    public required Workspace Workspace { get; init; }
+}

Amaurot.Processor/Models/OpenTofu/Workspaces.cs

@@ -0,0 +1,11 @@
+namespace Amaurot.Processor.Models.OpenTofu;
+
+internal class Workspaces
+{
+    public required Dictionary<string, Workspace> Workspace { get; init; }
+}
+
+internal class Workspace
+{
+    public string[]? VarFiles { get; init; }
+}

Amaurot.Processor/Program.cs

@@ -1,4 +1,5 @@
 using System.IO.Compression;
+using System.Text.Json;
 using Amaurot.Common.Models;
 using Amaurot.Processor.Clients;
 using Amaurot.Processor.Models.GitHub.Commit;
@@ -96,50 +97,83 @@ await gitHubClient.CreateCommitStatus(
 
         ZipFile.ExtractToDirectory(zipball, tempDirectory.FullName);
 
-        var executionOutputs = new Dictionary<string, List<PlanOutput>>();
+        var executionOutputs = new Dictionary<string, Dictionary<string, List<PlanOutput>>>();
         var executionState = CommitStatusState.Success;
 
         foreach (var tfDirectory in tfDirectories)
         {
             var directory =
                 $"{tempDirectory.FullName}/{taskRequestBody.RepositoryOwner}-{taskRequestBody.RepositoryName}-{taskRequestBody.Sha}/{tfDirectory}";
 
-            var init = await TofuClient.TofuExecution(ExecutionType.Init, directory);
+            Workspaces workspaces;
 
-            executionOutputs.Add(tfDirectory, [init]);
-
-            if (init.ExecutionState != CommitStatusState.Success)
+            await using (var workspacesFile = File.OpenRead($"{directory}/amaurot.json"))
             {
-                executionState = CommitStatusState.Failure;
-                continue;
+                workspaces = (await JsonSerializer.DeserializeAsync<Workspaces>(workspacesFile))!;
             }
 
-            var plan = await TofuClient.TofuExecution(ExecutionType.Plan, directory);
-
-            executionOutputs[tfDirectory].Add(plan);
-
-            if (plan.ExecutionState != CommitStatusState.Success)
+            foreach (var workspace in workspaces.Workspace)
             {
-                executionState = CommitStatusState.Failure;
+                var executionOutput = new Dictionary<string, List<PlanOutput>>();
+
+                var init = await TofuClient.TofuExecution(
+                    new Execution
+                    {
+                        ExecutionType = ExecutionType.Init,
+                        Directory = directory,
+                        Workspace = workspace.Value,
+                    }
+                );
+
+                executionOutput.Add(workspace.Key, [init]);
+
+                if (init.ExecutionState != CommitStatusState.Success)
+                {
+                    executionState = CommitStatusState.Failure;
+                    continue;
+                }
+
+                var plan = await TofuClient.TofuExecution(
+                    new Execution
+                    {
+                        ExecutionType = ExecutionType.Plan,
+                        Directory = directory,
+                        Workspace = workspace.Value,
+                    }
+                );
+
+                executionOutput[workspace.Key].Add(plan);
+
+                if (plan.ExecutionState != CommitStatusState.Success)
+                {
+                    executionState = CommitStatusState.Failure;
+                }
+
+                executionOutputs.Add(tfDirectory, executionOutput);
             }
         }
 
         tempDirectory.Delete(true);
 
-        var comment = $"OpenTofu plan output for commit {taskRequestBody.Sha}:\n\n";
+        var comment = $"Amaurot plan output for commit {taskRequestBody.Sha}:\n\n" + "---\n";
 
         foreach (var directory in executionOutputs)
         {
-            comment += $"`{directory.Key}`:\n";
+            comment += $"* `{directory.Key}`\n";
 
-            foreach (var executionOutput in directory.Value)
+            foreach (var workspace in directory.Value)
             {
-                comment +=
-                    $"<details><summary>{executionOutput.ExecutionType.ToString()}:</summary>\n\n"
-                    + "```\n"
-                    + $"{executionOutput.ExecutionStdout}\n"
-                    + "```\n"
-                    + "</details>\n\n";
+                comment += $"  * {workspace.Key}\n";
+
+                foreach (var executionOutput in workspace.Value)
+                {
+                    comment +=
+                        $"    <details><summary>{executionOutput.ExecutionType.ToString()}</summary>\n\n"
+                        + "    ```\n"
+                        + $"    {executionOutput.ExecutionStdout}\n"
+                        + "    ```\n"
+                        + "    </details>\n";
+                }
             }
         }