Enhancement: added defaults shell and working-directory to composite

src/Runner.Worker/ActionManager.cs

@@ -1257,6 +1257,7 @@ public sealed class CompositeActionExecutionData : ActionExecutionData
         public List<Pipelines.ActionStep> Steps { get; set; }
         public Stack<Pipelines.ActionStep> PostSteps { get; set; }
         public MappingToken Outputs { get; set; }
+        public MappingToken CompositeDefaults { get; set; }
     }
 
     public abstract class ActionExecutionData

src/Runner.Worker/ActionManifestManager.cs

@@ -369,6 +369,7 @@ private ActionExecutionData ConvertRuns(
             var postEntrypointToken = default(StringToken);
             var postIfToken = default(StringToken);
             var steps = default(List<Pipelines.Step>);
+            var defaultsToken = default(MappingToken);
 
             foreach (var run in runsMapping)
             {
@@ -419,6 +420,9 @@ private ActionExecutionData ConvertRuns(
                         steps = PipelineTemplateConverter.ConvertToSteps(templateContext, stepsToken);
                         templateContext.Errors.Check();
                         break;
+                    case "defaults":
+                        defaultsToken = run.Value.AssertMapping("defaults");
+                        break;
                     default:
                         Trace.Info($"Ignore run property {runsKey}.");
                         break;
@@ -448,7 +452,7 @@ private ActionExecutionData ConvertRuns(
                         };
                     }
                 }
-                else if (string.Equals(usingToken.Value, "node12", StringComparison.OrdinalIgnoreCase)||
+                else if (string.Equals(usingToken.Value, "node12", StringComparison.OrdinalIgnoreCase) ||
                          string.Equals(usingToken.Value, "node16", StringComparison.OrdinalIgnoreCase))
                 {
                     if (string.IsNullOrEmpty(mainToken?.Value))
@@ -476,14 +480,41 @@ private ActionExecutionData ConvertRuns(
                     }
                     else
                     {
+                        var compositeActionsExecutionDataSteps = steps.Cast<Pipelines.ActionStep>().ToList();
+                        if (defaultsToken == null)
+                        {
+                            foreach (var step in compositeActionsExecutionDataSteps)
+                            {
+                                if (step.Reference.Type != Pipelines.ActionSourceType.Script)
+                                {
+                                    continue;
+                                }
+                                var mapping = step.Inputs.AssertMapping("inputs");
+                                var foundShell = false;
+                                foreach (var pair in mapping)
+                                {
+                                    // Expression key
+                                    if (pair.Key is StringToken && pair.Key.AssertString("inputs key").Value.Equals("shell"))
+                                    {
+                                        foundShell = true;
+                                        break;
+                                    }
+                                }
+                                if (!foundShell)
+                                {
+                                    throw new TemplateValidationException("Composite action must set the default shell, or the shell parameter in each step is required.");
+                                }
+                            }
+                        }
                         return new CompositeActionExecutionData()
                         {
-                            Steps = steps.Cast<Pipelines.ActionStep>().ToList(),
+                            Steps = compositeActionsExecutionDataSteps,
                             PreSteps = new List<Pipelines.ActionStep>(),
                             PostSteps = new Stack<Pipelines.ActionStep>(),
                             InitCondition = "always()",
                             CleanupCondition = "always()",
-                            Outputs = outputs
+                            Outputs = outputs,
+                            CompositeDefaults = defaultsToken,
                         };
                     }
                 }

src/Runner.Worker/GlobalContext.cs

@@ -17,6 +17,7 @@ public sealed class GlobalContext
         public PlanFeatures Features { get; set; }
         public IList<String> FileTable { get; set; }
         public IDictionary<String, IDictionary<String, String>> JobDefaults { get; set; }
+        public IDictionary<String, IDictionary<String, String>> CompositeDefaults { get; set; }
         public List<ActionsStepTelemetry> StepsTelemetry { get; set; }
         public List<StepResult> StepsResult { get; set; }
         public List<Annotation> JobAnnotations { get; set; }

src/Runner.Worker/Handlers/CompositeActionHandler.cs

@@ -92,6 +92,13 @@ public async Task RunAsync(ActionRunStage stage)
             }
             ExecutionContext.StepTelemetry.Type = "composite";
 
+            // save job defaults run to be restored after the composite run
+            IDictionary<string, string> jobDefaultsRun = new Dictionary<string, string>();
+            if (ExecutionContext.Global.JobDefaults.ContainsKey("run"))
+            {
+                jobDefaultsRun = ExecutionContext.Global.JobDefaults["run"];
+            }
+
             try
             {
                 // Inputs of the composite step
@@ -162,6 +169,26 @@ public async Task RunAsync(ActionRunStage stage)
                     embeddedSteps.Add(step);
                 }
 
+                ExecutionContext.Global.CompositeDefaults = new Dictionary<string, IDictionary<string, string>>(StringComparer.OrdinalIgnoreCase)
+                {
+                    ["run"] = new Dictionary<string, string>(),
+                };
+
+                if (Data.CompositeDefaults != null && Data.CompositeDefaults.Any(x => string.Equals(x.Key.AssertString("defaults key").Value, "run", StringComparison.OrdinalIgnoreCase)))
+                {
+                    var defaultsToken = Data.CompositeDefaults.First(x => string.Equals(x.Key.AssertString("defaults key").Value, "run", StringComparison.OrdinalIgnoreCase));
+                    var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
+                    var jobDefaults = templateEvaluator.EvaluateJobDefaultsRun(defaultsToken.Value, ExecutionContext.ExpressionValues, ExecutionContext.ExpressionFunctions);
+
+                    foreach (var pair in jobDefaults)
+                    {
+                        if (!string.IsNullOrEmpty(pair.Value))
+                        {
+                            ExecutionContext.Global.CompositeDefaults["run"][pair.Key] = pair.Value;
+                        }
+                    }
+                }
+
                 // Run embedded steps
                 await RunStepsAsync(embeddedSteps, stage);
 
@@ -177,6 +204,10 @@ public async Task RunAsync(ActionRunStage stage)
                 ExecutionContext.Error(ex);
                 ExecutionContext.Result = TaskResult.Failed;
             }
+            finally
+            {
+                ExecutionContext.Global.CompositeDefaults = new Dictionary<string, IDictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
+            }
         }
 
         private void ProcessOutputs()

src/Runner.Worker/Handlers/ScriptHandler.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -68,15 +68,25 @@ protected override void PrintActionDetails(ActionRunStage stage)
             bool validateShellOnHost = !(StepHost is ContainerStepHost);
             string prependPath = string.Join(Path.PathSeparator.ToString(), ExecutionContext.Global.PrependPath.Reverse<string>());
             string shell = null;
+
             if (!Inputs.TryGetValue("shell", out shell) || string.IsNullOrEmpty(shell))
             {
-                // TODO: figure out how defaults interact with template later
-                // for now, we won't check job.defaults if we are inside a template.
-                if (string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
+                if (ExecutionContext.Global.CompositeDefaults.TryGetValue("run", out var runCompositeDefaults))
+                {
+                    if (runCompositeDefaults.TryGetValue("shell", out shell))
+                    {
+                        ExecutionContext.Debug("Overwrite 'shell' base on composite defaults.");
+                    }
+                }
+                else if (ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
                 {
-                    runDefaults.TryGetValue("shell", out shell);
+                    if (runDefaults.TryGetValue("shell", out shell))
+                    {
+                        ExecutionContext.Debug("Overwrite 'shell' base on job defaults.");
+                    }
                 }
             }
+
             if (string.IsNullOrEmpty(shell))
             {
 #if OS_WINDOWS
@@ -156,7 +166,14 @@ public async Task RunAsync(ActionRunStage stage)
             if (!Inputs.TryGetValue("workingDirectory", out workingDirectory))
             {
                 // Don't use job level working directories for hooks
-                if (IsActionStep && string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
+                if (githubContext.ContainsKey("action_path") && ExecutionContext.Global.CompositeDefaults.TryGetValue("run", out var runCompositeDefaults))
+                {
+                    if (runCompositeDefaults.TryGetValue("working-directory", out workingDirectory))
+                    {
+                        ExecutionContext.Debug("Overwrite 'working-directory' base on composite defaults.");
+                    }
+                }
+                else if (IsActionStep && string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
                 {
                     if (runDefaults.TryGetValue("working-directory", out workingDirectory))
                     {
@@ -165,12 +182,23 @@ public async Task RunAsync(ActionRunStage stage)
                 }
             }
             var workspaceDir = githubContext["workspace"] as StringContextData;
+            if (githubContext.ContainsKey("action_path"))
+            {
+                workspaceDir = githubContext["action_path"] as StringContextData;
+            }
             workingDirectory = Path.Combine(workspaceDir, workingDirectory ?? string.Empty);
 
             string shell = null;
             if (!Inputs.TryGetValue("shell", out shell) || string.IsNullOrEmpty(shell))
             {
-                if (string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
+                if (githubContext.ContainsKey("action_path") && ExecutionContext.Global.CompositeDefaults.TryGetValue("run", out var runCompositeDefaults))
+                {
+                    if (runCompositeDefaults.TryGetValue("shell", out shell))
+                    {
+                        ExecutionContext.Debug("Overwrite 'shell' base on composite defaults.");
+                    }
+                }
+                else if (ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
                 {
                     if (runDefaults.TryGetValue("shell", out shell))
                     {

src/Runner.Worker/action_yaml.json

@@ -1,4 +1,4 @@
-{
+{
     "definitions": {
         "action-root": {
             "description": "Action file",
@@ -103,7 +103,11 @@
             "mapping": {
                 "properties": {
                     "using": "non-empty-string",
-                    "steps": "composite-steps"
+                    "steps": "composite-steps",
+                    "defaults": {
+                        "type": "composite-defaults",
+                        "required": false
+                    }
                 }
             }
         },
@@ -133,7 +137,7 @@
                     "working-directory": "string-steps-context",
                     "shell": {
                         "type": "string-steps-context",
-                        "required": true
+                        "required": false
                     }
                 }
             }
@@ -268,6 +272,35 @@
                 "loose-key-type": "non-empty-string",
                 "loose-value-type": "string"
             }
+        },
+        "composite-defaults": {
+          "mapping": {
+            "properties": {
+              "run": "composite-defaults-run"
+            }
+          }
+        },
+        "composite-defaults-run": {
+          "context": [
+            "inputs",
+            "github",
+            "strategy",
+            "matrix",
+            "needs",
+            "env"
+          ],
+          "mapping": {
+            "properties": {
+                "shell": {
+                    "type": "non-empty-string",
+                    "required": false
+                },
+                "working-directory": {
+                    "type": "non-empty-string",
+                    "required": false
+                }
+            }
+          }
         }
     }
 }