Merge branch 'master' into patch-1

Author: panekj

pkg/artifacts/arifacts_v4.go renamed to pkg/artifacts/artifacts_v4.go

@@ -21,7 +21,7 @@ func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(interface{}) error) error
 	// Force input to lowercase for case insensitive comparison
 	format := ActionRunsUsing(strings.ToLower(using))
 	switch format {
-	case ActionRunsUsingNode20, ActionRunsUsingNode16, ActionRunsUsingNode12, ActionRunsUsingDocker, ActionRunsUsingComposite:
+	case ActionRunsUsingNode24, ActionRunsUsingNode20, ActionRunsUsingNode16, ActionRunsUsingNode12, ActionRunsUsingDocker, ActionRunsUsingComposite:
 		*a = format
 	default:
 		return fmt.Errorf("The runs.using key in action.yml must be one of: %v, got %s", []string{
@@ -30,6 +30,7 @@ func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(interface{}) error) error
 			ActionRunsUsingNode12,
 			ActionRunsUsingNode16,
 			ActionRunsUsingNode20,
+			ActionRunsUsingNode24,
 		}, format)
 	}
 	return nil
@@ -42,12 +43,31 @@ const (
 	ActionRunsUsingNode16 = "node16"
 	// ActionRunsUsingNode20 for running with node20
 	ActionRunsUsingNode20 = "node20"
+	// ActionRunsUsingNode24 for running with node24
+	ActionRunsUsingNode24 = "node24"
 	// ActionRunsUsingDocker for running with docker
 	ActionRunsUsingDocker = "docker"
 	// ActionRunsUsingComposite for running composite
 	ActionRunsUsingComposite = "composite"
 )
 
+func (a ActionRunsUsing) IsNode() bool {
+	switch a {
+	case ActionRunsUsingNode12, ActionRunsUsingNode16, ActionRunsUsingNode20, ActionRunsUsingNode24:
+		return true
+	default:
+		return false
+	}
+}
+
+func (a ActionRunsUsing) IsDocker() bool {
+	return a == ActionRunsUsingDocker
+}
+
+func (a ActionRunsUsing) IsComposite() bool {
+	return a == ActionRunsUsingComposite
+}
+
 // ActionRuns are a field in Action
 type ActionRuns struct {
 	Using          ActionRunsUsing   `yaml:"using"`

pkg/model/action.go

@@ -390,8 +390,6 @@ func (j *Job) Matrix() map[string][]interface{} {
 
 // GetMatrixes returns the matrix cross product
 // It skips includes and hard fails excludes for non-existing keys
-//
-//nolint:gocyclo
 func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 	matrixes := make([]map[string]interface{}, 0)
 	if j.Strategy != nil {
@@ -406,31 +404,11 @@ func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
 				case []interface{}:
 					for _, i := range t {
 						i := i.(map[string]interface{})
-						extraInclude := true
-						for k := range i {
-							if _, ok := m[k]; ok {
-								includes = append(includes, i)
-								extraInclude = false
-								break
-							}
-						}
-						if extraInclude {
-							extraIncludes = append(extraIncludes, i)
-						}
+						includes = append(includes, i)
 					}
 				case interface{}:
 					v := v.(map[string]interface{})
-					extraInclude := true
-					for k := range v {
-						if _, ok := m[k]; ok {
-							includes = append(includes, v)
-							extraInclude = false
-							break
-						}
-					}
-					if extraInclude {
-						extraIncludes = append(extraIncludes, v)
-					}
+					includes = append(includes, v)
 				}
 			}
 			delete(m, "include")

pkg/model/workflow.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
 )
 
 func TestReadWorkflow_StringEvent(t *testing.T) {
@@ -367,10 +369,9 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, matrixes,
 		[]map[string]interface{}{
-			{"datacenter": "site-c", "node-version": "14.x", "site": "staging"},
-			{"datacenter": "site-c", "node-version": "16.x", "site": "staging"},
-			{"datacenter": "site-d", "node-version": "16.x", "site": "staging"},
-			{"php-version": 5.4},
+			{"datacenter": "site-c", "node-version": "14.x", "site": "staging", "php-version": 5.4},
+			{"datacenter": "site-c", "node-version": "16.x", "site": "staging", "php-version": 5.4},
+			{"datacenter": "site-d", "node-version": "16.x", "site": "staging", "php-version": 5.4},
 			{"datacenter": "site-a", "node-version": "10.x", "site": "prod"},
 			{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
 		},
@@ -394,6 +395,32 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	assert.Equal(t, job.Strategy.FailFast, false)
 }
 
+func TestMatrixOnlyIncludes(t *testing.T) {
+	matrix := map[string][]interface{}{
+		"include": []interface{}{
+			map[string]interface{}{"a": "1", "b": "2"},
+			map[string]interface{}{"a": "3", "b": "4"},
+		},
+	}
+	rN := yaml.Node{}
+	err := rN.Encode(matrix)
+	require.NoError(t, err, "encoding matrix should succeed")
+	job := &Job{
+		Strategy: &Strategy{
+			RawMatrix: rN,
+		},
+	}
+	assert.Equal(t, job.Matrix(), matrix)
+	matrixes, err := job.GetMatrixes()
+	require.NoError(t, err)
+	assert.Equal(t, matrixes,
+		[]map[string]interface{}{
+			{"a": "1", "b": "2"},
+			{"a": "3", "b": "4"},
+		},
+	)
+}
+
 func TestStep_ShellCommand(t *testing.T) {
 	tests := []struct {
 		shell         string

pkg/model/workflow_test.go

@@ -174,8 +174,9 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
 
 		logger.Debugf("type=%v actionDir=%s actionPath=%s workdir=%s actionCacheDir=%s actionName=%s containerActionDir=%s", stepModel.Type(), actionDir, actionPath, rc.Config.Workdir, rc.ActionCacheDir(), actionName, containerActionDir)
 
-		switch action.Runs.Using {
-		case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20:
+		x := action.Runs.Using
+		switch {
+		case x.IsNode():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
 			}
@@ -185,13 +186,13 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
 			rc.ApplyExtraPath(ctx, step.getEnv())
 
 			return rc.execJobContainer(containerArgs, *step.getEnv(), "", "")(ctx)
-		case model.ActionRunsUsingDocker:
+		case x.IsDocker():
 			if remoteAction == nil {
 				actionDir = ""
 				actionPath = containerActionDir
 			}
 			return execAsDocker(ctx, step, actionName, actionDir, actionPath, remoteAction == nil, "entrypoint")
-		case model.ActionRunsUsingComposite:
+		case x.IsComposite():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
 			}
@@ -203,6 +204,7 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
 				model.ActionRunsUsingNode12,
 				model.ActionRunsUsingNode16,
 				model.ActionRunsUsingNode20,
+				model.ActionRunsUsingNode24,
 				model.ActionRunsUsingComposite,
 			}, action.Runs.Using)
 		}
@@ -406,13 +408,18 @@ func newStepContainer(ctx context.Context, step step, image string, cmd []string
 
 	binds, mounts := rc.GetBindsAndMounts()
 	networkMode := fmt.Sprintf("container:%s", rc.jobContainerName())
+	var workdir string
 	if rc.IsHostEnv(ctx) {
 		networkMode = "default"
+		ext := container.LinuxContainerEnvironmentExtensions{}
+		workdir = ext.ToContainerPath(rc.Config.Workdir)
+	} else {
+		workdir = rc.JobContainer.ToContainerPath(rc.Config.Workdir)
 	}
 	stepContainer := container.NewContainer(&container.NewContainerInput{
 		Cmd:         cmd,
 		Entrypoint:  entrypoint,
-		WorkingDir:  rc.JobContainer.ToContainerPath(rc.Config.Workdir),
+		WorkingDir:  workdir,
 		Image:       image,
 		Username:    rc.Config.Secrets["DOCKER_USERNAME"],
 		Password:    rc.Config.Secrets["DOCKER_PASSWORD"],
@@ -499,12 +506,10 @@ func shouldRunPreStep(step actionStep) common.Conditional {
 func hasPreStep(step actionStep) common.Conditional {
 	return func(_ context.Context) bool {
 		action := step.getActionModel()
-		return (action.Runs.Using == model.ActionRunsUsingComposite) ||
-			((action.Runs.Using == model.ActionRunsUsingNode12 ||
-				action.Runs.Using == model.ActionRunsUsingNode16 ||
-				action.Runs.Using == model.ActionRunsUsingNode20) &&
+		return action.Runs.Using.IsComposite() ||
+			(action.Runs.Using.IsNode() &&
 				action.Runs.Pre != "") ||
-			(action.Runs.Using == model.ActionRunsUsingDocker &&
+			(action.Runs.Using.IsDocker() &&
 				action.Runs.PreEntrypoint != "")
 	}
 }
@@ -543,8 +548,9 @@ func runPreStep(step actionStep) common.Executor {
 
 		actionName, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
 
-		switch action.Runs.Using {
-		case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20:
+		x := action.Runs.Using
+		switch {
+		case x.IsNode():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
 			}
@@ -556,14 +562,14 @@ func runPreStep(step actionStep) common.Executor {
 
 			return rc.execJobContainer(containerArgs, *step.getEnv(), "", "")(ctx)
 
-		case model.ActionRunsUsingDocker:
+		case x.IsDocker():
 			if remoteAction == nil {
 				actionDir = ""
 				actionPath = containerActionDir
 			}
 			return execAsDocker(ctx, step, actionName, actionDir, actionPath, remoteAction == nil, "pre-entrypoint")
 
-		case model.ActionRunsUsingComposite:
+		case x.IsComposite():
 			if step.getCompositeSteps() == nil {
 				step.getCompositeRunContext(ctx)
 			}
@@ -607,12 +613,10 @@ func shouldRunPostStep(step actionStep) common.Conditional {
 func hasPostStep(step actionStep) common.Conditional {
 	return func(_ context.Context) bool {
 		action := step.getActionModel()
-		return (action.Runs.Using == model.ActionRunsUsingComposite) ||
-			((action.Runs.Using == model.ActionRunsUsingNode12 ||
-				action.Runs.Using == model.ActionRunsUsingNode16 ||
-				action.Runs.Using == model.ActionRunsUsingNode20) &&
+		return action.Runs.Using.IsComposite() ||
+			(action.Runs.Using.IsNode() &&
 				action.Runs.Post != "") ||
-			(action.Runs.Using == model.ActionRunsUsingDocker &&
+			(action.Runs.Using.IsDocker() &&
 				action.Runs.PostEntrypoint != "")
 	}
 }
@@ -648,9 +652,9 @@ func runPostStep(step actionStep) common.Executor {
 
 		actionName, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
 
-		switch action.Runs.Using {
-		case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20:
-
+		x := action.Runs.Using
+		switch {
+		case x.IsNode():
 			populateEnvsFromSavedState(step.getEnv(), step, rc)
 			populateEnvsFromInput(ctx, step.getEnv(), step.getActionModel(), rc)
 
@@ -661,14 +665,14 @@ func runPostStep(step actionStep) common.Executor {
 
 			return rc.execJobContainer(containerArgs, *step.getEnv(), "", "")(ctx)
 
-		case model.ActionRunsUsingDocker:
+		case x.IsDocker():
 			if remoteAction == nil {
 				actionDir = ""
 				actionPath = containerActionDir
 			}
 			return execAsDocker(ctx, step, actionName, actionDir, actionPath, remoteAction == nil, "post-entrypoint")
 
-		case model.ActionRunsUsingComposite:
+		case x.IsComposite():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
 			}

pkg/runner/action.go

@@ -139,6 +139,14 @@ func (rc *RunContext) GetBindsAndMounts() ([]string, map[string]string) {
 
 	ext := container.LinuxContainerEnvironmentExtensions{}
 
+	if hostEnv, ok := rc.JobContainer.(*container.HostEnvironment); ok {
+		mounts := map[string]string{}
+		// Permission issues?
+		// binds = append(binds, hostEnv.ToolCache+":/opt/hostedtoolcache")
+		binds = append(binds, hostEnv.GetActPath()+":"+ext.GetActPath())
+		binds = append(binds, hostEnv.ToContainerPath(rc.Config.Workdir)+":"+ext.ToContainerPath(rc.Config.Workdir))
+		return binds, mounts
+	}
 	mounts := map[string]string{
 		"act-toolcache": "/opt/hostedtoolcache",
 		name + "-env":   ext.GetActPath(),

pkg/runner/run_context.go

@@ -39,6 +39,7 @@ func init() {
 
 	platforms = map[string]string{
 		"ubuntu-latest": baseImage,
+		"self-hosted":   "-self-hosted",
 	}
 
 	if l := os.Getenv("ACT_TEST_LOG_LEVEL"); l != "" {
@@ -330,6 +331,9 @@ func TestRunEvent(t *testing.T) {
 
 		// local remote action overrides
 		{workdir, "local-remote-action-overrides", "push", "", platforms, secrets},
+
+		// docker action on host executor
+		{workdir, "docker-action-host-env", "push", "", platforms, secrets},
 	}
 
 	for _, table := range tables {

pkg/runner/runner_test.go

@@ -0,0 +1,13 @@
+FROM debian:bullseye-slim
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && apt-get clean
+
+# Copy the entrypoint script
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Set the entrypoint
+ENTRYPOINT ["/entrypoint.sh"]

pkg/runner/testdata/docker-action-host-env/action/Dockerfile

@@ -0,0 +1,12 @@
+name: "Hello World Docker Action"
+description: "A simple Docker action that prints Hello, World! and environment variables."
+inputs:
+  who-to-greet:
+    description: "Who to greet"
+    required: false
+    default: "World"
+runs:
+  using: "docker"
+  image: "Dockerfile"
+  args:
+    - ${{ inputs.who-to-greet }}

pkg/runner/testdata/docker-action-host-env/action/action.yml

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+# Print a greeting
+echo "Hello, $1!"
+
+# Print all environment variables
+echo "Environment Variables:"
+env
+
+ls -la "$PWD"
+ls -la "$PWD/docker-action-host-env"
+
+if [ -f "$PWD/docker-action-host-env/Dockerfile" ]; then
+  echo "Dockerfile exists in workspace."
+else
+  echo "Dockerfile does not exist in workspace."
+fi