Add support for Step Summary

src/Runner.Common/ExtensionManager.cs

@@ -60,6 +60,7 @@ private List<IExtension> LoadExtensions<T>() where T : class, IExtension
                 case "GitHub.Runner.Worker.IFileCommandExtension":
                     Add<T>(extensions, "GitHub.Runner.Worker.AddPathFileCommand, Runner.Worker");
                     Add<T>(extensions, "GitHub.Runner.Worker.SetEnvFileCommand, Runner.Worker");
+                    Add<T>(extensions, "GitHub.Runner.Worker.SetStepSummaryCommand, Runner.Worker");
                     break;
                 case "GitHub.Runner.Listener.Check.ICheckExtension":
                     Add<T>(extensions, "GitHub.Runner.Listener.Check.InternetCheck, Runner.Listener");

src/Runner.Worker/ActionCommandManager.cs

@@ -191,6 +191,11 @@ internal static bool EnhancedAnnotationsEnabled(IExecutionContext context)
         {
             return context.Global.Variables.GetBoolean("DistributedTask.EnhancedAnnotations") ?? false;
         }
+
+        internal static bool StepSummaryEnabled(IExecutionContext context)
+        {
+            return context.Global.Variables.GetBoolean("DistributedTask.UploadStepSummary") ?? false;
+        }
     }
 
     public interface IActionCommandExtension : IExtension

src/Runner.Worker/FileCommandManager.cs

@@ -259,4 +259,99 @@ private static string ReadLine(
             return text.Substring(originalIndex, lfIndex - originalIndex);
         }
     }
+
+    public sealed class SetStepSummaryCommand : RunnerService, IFileCommandExtension
+    {
+        public string ContextName => "step_summary";
+        public string FilePrefix => "step_summary_";
+
+        private const int AttachmentSizeLimit = 128 * 1024;
+
+        public Type ExtensionType => typeof(IFileCommandExtension);
+
+        public void ProcessCommand(IExecutionContext context, string filePath, ContainerInfo container)
+        {
+            if (ShouldUploadAttachment(context, filePath))
+            {
+                Trace.Info($"Submitting step summary content from file {filePath}, container: {container}");
+                var scrubbedFilePath = ScrubStepSummaryFileSecrets(filePath);
+
+                QueueStepSummaryUpload(context, scrubbedFilePath);
+            }
+        }
+
+        private bool ShouldUploadAttachment(IExecutionContext context, string filePath)
+        {
+            if (!ActionCommandManager.StepSummaryEnabled(context))
+            {
+                Trace.Info("Step Summary is disabled; skipping attachment upload");
+                return false;
+            }
+
+            if (String.IsNullOrEmpty(filePath))
+            {
+                Trace.Info("Step Summary path is empty; skipping attachment upload");
+                return false;
+            }
+
+            if (!File.Exists(filePath))
+            {
+                Trace.Info($"Step Summary file ({filePath}) does not exist; skipping attachment upload");
+                return false;
+            }
+
+            var fileSize = new FileInfo(filePath).Length;
+            if (fileSize == 0)
+            {
+                Trace.Info($"Step Summary file ({filePath}) is empty; skipping attachment upload");
+                return false;
+            }
+
+            if (fileSize > AttachmentSizeLimit)
+            {
+                context.Error($"$GITHUB_STEP_SUMMARY supports content up a size of {AttachmentSizeLimit/1024}k got {fileSize/1024}k");
+                Trace.Info($"Step Summary file ({filePath}) is too large ({fileSize} bytes); skipping attachment upload");
+                return false;
+
+            }
+
+            Trace.Info($"Step Summary file exists: {filePath} and has a file size of {fileSize} bytes");
+
+            return true;
+        }
+
+        private string ScrubStepSummaryFileSecrets(string filePath)
+        {
+            var scrubbedFilePath = filePath + "-scrubbed";
+
+            using (var streamReader = new StreamReader(filePath))
+            using (var streamWriter = new StreamWriter(scrubbedFilePath))
+            {
+                string line;
+                while ((line = streamReader.ReadLine()) != null)
+                {
+                    var maskedLine = HostContext.SecretMasker.MaskSecrets(line);
+                    streamWriter.WriteLine(maskedLine);
+                }
+            }
+
+            return scrubbedFilePath;
+        }
+
+        private void QueueStepSummaryUpload(IExecutionContext context, string filePath)
+        {
+            var stepID = context.Id;
+            var attachmentName = stepID.ToString();
+
+            Trace.Info($"Queueing file ({filePath}) for attachment upload ({attachmentName})");
+            try
+            {
+                context.QueueAttachFile(ChecksAttachmentType.StepSummary, attachmentName, filePath);
+            }
+            catch (Exception e)
+            {
+                Trace.Error($"Error while trying to enqueue file upload for file ({filePath}): {e}");
+            }
+        }
+    }
 }

src/Runner.Worker/GitHubContext.cs

@@ -34,6 +34,7 @@ public sealed class GitHubContext : DictionaryContextData, IEnvironmentContextDa
             "run_number",
             "server_url",
             "sha",
+            "step_summary",
             "workflow",
             "workspace",
         };

src/Sdk/DTWebApi/WebApi/TaskAttachment.cs

@@ -102,4 +102,10 @@ public class CoreAttachmentType
         public static readonly String FileAttachment = "DistributedTask.Core.FileAttachment";
         public static readonly String DiagnosticLog = "DistributedTask.Core.DiagnosticLog";
     }
+
+    [GenerateAllConstants]
+    public class ChecksAttachmentType
+    {
+        public static readonly String StepSummary = "Checks.Step.Summary";
+    }
 }

src/Test/L0/Worker/SetStepSummaryCommandL0.cs

@@ -0,0 +1,241 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Runtime.CompilerServices;
+using GitHub.Runner.Common.Util;
+using GitHub.Runner.Sdk;
+using GitHub.Runner.Worker;
+using Moq;
+using Xunit;
+using DTWebApi = GitHub.DistributedTask.WebApi;
+using GitHub.DistributedTask.WebApi;
+
+namespace GitHub.Runner.Common.Tests.Worker
+{
+    public sealed class SetStepSummaryCommandL0
+    {
+        private Mock<IExecutionContext> _executionContext;
+        private List<Tuple<DTWebApi.Issue, string>> _issues;
+        private Variables _variables;
+        private string _rootDirectory;
+        private SetStepSummaryCommand _setStepCommand;
+        private ITraceWriter _trace;
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_FeatureDisabled()
+        {
+            using (var hostContext = Setup(featureFlagState: "false"))
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "feature-off");
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_FileNull()
+        {
+            using (var hostContext = Setup())
+            {
+                _setStepCommand.ProcessCommand(_executionContext.Object, null, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_DirectoryNotFound()
+        {
+            using (var hostContext = Setup())
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "directory-not-found", "env");
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_FileNotFound()
+        {
+            using (var hostContext = Setup())
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "file-not-found");
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_EmptyFile()
+        {
+            using (var hostContext = Setup())
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "empty-file");
+                File.Create(stepSummaryFile).Dispose();
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_LargeFile()
+        {
+            using (var hostContext = Setup())
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "empty-file");
+                File.WriteAllBytes(stepSummaryFile, new byte[128 * 1024 + 1]);
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, It.IsAny<string>(), It.IsAny<string>()), Times.Never());
+                Assert.Equal(1, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_Simple()
+        {
+            using (var hostContext = Setup())
+            {
+                var stepSummaryFile = Path.Combine(_rootDirectory, "simple");
+                var content = new List<string>
+                {
+                    "# This is some markdown content",
+                    "",
+                    "## This is more markdown content",
+                };
+                WriteContent(stepSummaryFile, content);
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, _executionContext.Object.Id.ToString(), stepSummaryFile + "-scrubbed"), Times.Once());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void SetStepSummaryCommand_ScrubSecrets()
+        {
+            using (var hostContext = Setup())
+            {
+                // configure secretmasker to actually mask secrets
+                hostContext.SecretMasker.AddRegex("Password=.*");
+                hostContext.SecretMasker.AddRegex("ghs_.*");
+
+                var stepSummaryFile = Path.Combine(_rootDirectory, "simple");
+                var scrubbedFile = stepSummaryFile + "-scrubbed";
+                var content = new List<string>
+                {
+                    "# Password=ThisIsMySecretPassword!",
+                    "",
+                    "# GITHUB_TOKEN ghs_verysecuretoken",
+                };
+                WriteContent(stepSummaryFile, content);
+
+                _setStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
+
+                var scrubbedFileContents = File.ReadAllText(scrubbedFile);
+                Assert.DoesNotContain("ThisIsMySecretPassword!", scrubbedFileContents);
+                Assert.DoesNotContain("ghs_verysecuretoken", scrubbedFileContents);
+
+                _executionContext.Verify(e => e.QueueAttachFile(ChecksAttachmentType.StepSummary, _executionContext.Object.Id.ToString(), scrubbedFile), Times.Once());
+                Assert.Equal(0, _issues.Count);
+            }
+        }
+
+        private void WriteContent(
+            string path,
+            List<string> content,
+            string newline = null)
+        {
+            if (string.IsNullOrEmpty(newline))
+            {
+                newline = Environment.NewLine;
+            }
+
+            var encoding = new UTF8Encoding(true); // Emit BOM
+            var contentStr = string.Join(newline, content);
+            File.WriteAllText(path, contentStr, encoding);
+        }
+
+        private TestHostContext Setup([CallerMemberName] string name = "", string featureFlagState = "true")
+        {
+            _issues = new List<Tuple<DTWebApi.Issue, string>>();
+
+            var hostContext = new TestHostContext(this, name);
+
+            // Trace
+            _trace = hostContext.GetTrace();
+
+            _variables = new Variables(hostContext, new Dictionary<string, VariableValue>
+                {
+                    { "MySecretName", new VariableValue("My secret value", true) },
+                    { "DistributedTask.UploadStepSummary", featureFlagState },
+                });
+
+            // Directory for test data
+            var workDirectory = hostContext.GetDirectory(WellKnownDirectory.Work);
+            ArgUtil.NotNullOrEmpty(workDirectory, nameof(workDirectory));
+            Directory.CreateDirectory(workDirectory);
+            _rootDirectory = Path.Combine(workDirectory, nameof(SetStepSummaryCommandL0));
+            Directory.CreateDirectory(_rootDirectory);
+
+            // Execution context
+            _executionContext = new Mock<IExecutionContext>();
+            _executionContext.Setup(x => x.Global)
+                .Returns(new GlobalContext
+                {
+                    EnvironmentVariables = new Dictionary<string, string>(VarUtil.EnvironmentVariableKeyComparer),
+                    WriteDebug = true,
+                    Variables = _variables,
+                });
+            _executionContext.Setup(x => x.AddIssue(It.IsAny<DTWebApi.Issue>(), It.IsAny<string>()))
+                .Callback((DTWebApi.Issue issue, string logMessage) =>
+                {
+                    _issues.Add(new Tuple<DTWebApi.Issue, string>(issue, logMessage));
+                    var message = !string.IsNullOrEmpty(logMessage) ? logMessage : issue.Message;
+                    _trace.Info($"Issue '{issue.Type}': {message}");
+                });
+            _executionContext.Setup(x => x.Write(It.IsAny<string>(), It.IsAny<string>()))
+                .Callback((string tag, string message) =>
+                {
+                    _trace.Info($"{tag}{message}");
+                });
+
+            // SetStepSummaryCommand
+            _setStepCommand = new SetStepSummaryCommand();
+            _setStepCommand.Initialize(hostContext);
+
+            return hostContext;
+        }
+    }
+}