act/pkg/runner/step.go

package runner

import (
	"context"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"regexp"
	"strings"

	"github.com/nektos/act/pkg/common"
	"github.com/nektos/act/pkg/container"
	"github.com/nektos/act/pkg/model"
	log "github.com/sirupsen/logrus"
)

func (rc *RunContext) newStepExecutor(step *model.Step) common.Executor {
	job := rc.Run.Job()
	containerSpec := new(model.ContainerSpec)
	containerSpec.Env = rc.StepEnv(step)
	containerSpec.Name = rc.createContainerName(step.ID)

	switch step.Type() {
	case model.StepTypeRun:
		if job.Container != nil {
			containerSpec.Image = job.Container.Image
			containerSpec.Ports = job.Container.Ports
			containerSpec.Volumes = job.Container.Volumes
			containerSpec.Options = job.Container.Options
		} else {
			containerSpec.Image = platformImage(job.RunsOn)
		}
		return common.NewPipelineExecutor(
			rc.setupShellCommand(containerSpec, step.Shell, step.Run),
			rc.pullImage(containerSpec),
			rc.runContainer(containerSpec),
		)

	case model.StepTypeUsesDockerURL:
		containerSpec.Image = strings.TrimPrefix(step.Uses, "docker://")
		containerSpec.Entrypoint = step.With["entrypoint"]
		containerSpec.Args = step.With["args"]
		return common.NewPipelineExecutor(
			rc.pullImage(containerSpec),
			rc.runContainer(containerSpec),
		)

	case model.StepTypeUsesActionLocal:
		containerSpec.Image = fmt.Sprintf("%s:%s", containerSpec.Name, "latest")
		return common.NewPipelineExecutor(
			rc.setupAction(containerSpec, filepath.Join(rc.Config.Workdir, step.Uses)),
			rc.pullImage(containerSpec),
			rc.runContainer(containerSpec),
		)
	case model.StepTypeUsesActionRemote:
		remoteAction := newRemoteAction(step.Uses)
		if remoteAction.Org == "actions" && remoteAction.Repo == "checkout" {
			return func(ctx context.Context) error {
				common.Logger(ctx).Debugf("Skipping actions/checkout")
				return nil
			}
		}
		cloneDir, err := ioutil.TempDir(rc.Tempdir, remoteAction.Repo)
		if err != nil {
			return common.NewErrorExecutor(err)
		}
		containerSpec.Image = fmt.Sprintf("%s:%s", remoteAction.Repo, remoteAction.Ref)
		return common.NewPipelineExecutor(
			common.NewGitCloneExecutor(common.NewGitCloneExecutorInput{
				URL: remoteAction.CloneURL(),
				Ref: remoteAction.Ref,
				Dir: cloneDir,
			}),
			rc.setupAction(containerSpec, filepath.Join(cloneDir, remoteAction.Path)),
			rc.pullImage(containerSpec),
			rc.runContainer(containerSpec),
		)
	}

	return common.NewErrorExecutor(fmt.Errorf("Unable to determine how to run job:%s step:%+v", rc.Run, step))
}

// StepEnv returns the env for a step
func (rc *RunContext) StepEnv(step *model.Step) map[string]string {
	env := make(map[string]string)
	env["HOME"] = "/github/home"
	env["GITHUB_WORKFLOW"] = rc.Run.Workflow.Name
	env["GITHUB_RUN_ID"] = "1"
	env["GITHUB_RUN_NUMBER"] = "1"
	env["GITHUB_ACTION"] = step.ID
	env["GITHUB_ACTOR"] = "nektos/act"

	repoPath := rc.Config.Workdir
	repo, err := common.FindGithubRepo(repoPath)
	if err != nil {
		log.Warningf("unable to get git repo: %v", err)
	} else {
		env["GITHUB_REPOSITORY"] = repo
	}
	env["GITHUB_EVENT_NAME"] = rc.Config.EventName
	env["GITHUB_EVENT_PATH"] = "/github/workflow/event.json"
	env["GITHUB_WORKSPACE"] = "/github/workspace"

	_, rev, err := common.FindGitRevision(repoPath)
	if err != nil {
		log.Warningf("unable to get git revision: %v", err)
	} else {
		env["GITHUB_SHA"] = rev
	}

	ref, err := common.FindGitRef(repoPath)
	if err != nil {
		log.Warningf("unable to get git ref: %v", err)
	} else {
		log.Infof("using github ref: %s", ref)
		env["GITHUB_REF"] = ref
	}
	job := rc.Run.Job()
	if job.Container != nil {
		return mergeMaps(rc.GetEnv(), job.Container.Env, step.GetEnv(), env)
	}
	return mergeMaps(rc.GetEnv(), step.GetEnv(), env)
}

func (rc *RunContext) setupShellCommand(containerSpec *model.ContainerSpec, shell string, run string) common.Executor {
	return func(ctx context.Context) error {
		shellCommand := ""

		switch shell {
		case "", "bash":
			shellCommand = "bash --noprofile --norc -eo pipefail {0}"
		case "pwsh":
			shellCommand = "pwsh -command \"& '{0}'\""
		case "python":
			shellCommand = "python {0}"
		case "sh":
			shellCommand = "sh -e -c {0}"
		case "cmd":
			shellCommand = "%ComSpec% /D /E:ON /V:OFF /S /C \"CALL \"{0}\"\""
		case "powershell":
			shellCommand = "powershell -command \"& '{0}'\""
		default:
			shellCommand = shell
		}

		tempScript, err := ioutil.TempFile(rc.Tempdir, ".temp-script-")
		if err != nil {
			return err
		}

		if _, err := tempScript.Write([]byte(run)); err != nil {
			return err
		}
		log.Debugf("Wrote command '%s' to '%s'", run, tempScript.Name())
		if err := tempScript.Close(); err != nil {
			return err
		}
		containerPath := fmt.Sprintf("/github/home/%s", filepath.Base(tempScript.Name()))
		containerSpec.Args = strings.Replace(shellCommand, "{0}", containerPath, 1)
		return nil
	}
}

func platformImage(platform string) string {
	switch platform {
	case "ubuntu-latest", "ubuntu-18.04":
		return "ubuntu:18.04"
	case "ubuntu-16.04":
		return "ubuntu:16.04"
	case "windows-latest", "windows-2019", "macos-latest", "macos-10.15":
		return ""
	default:
		return ""
	}
}

func (rc *RunContext) setupAction(containerSpec *model.ContainerSpec, actionDir string) common.Executor {
	return func(ctx context.Context) error {
		f, err := os.Open(filepath.Join(actionDir, "action.yml"))
		if os.IsNotExist(err) {
			f, err = os.Open(filepath.Join(actionDir, "action.yaml"))
			if err != nil {
				return err
			}
		} else if err != nil {
			return err
		}

		action, err := model.ReadAction(f)
		if err != nil {
			return err
		}

		for inputID, input := range action.Inputs {
			envKey := regexp.MustCompile("[^A-Z0-9-]").ReplaceAllString(strings.ToUpper(inputID), "_")
			envKey = fmt.Sprintf("INPUT_%s", envKey)
			if _, ok := containerSpec.Env[envKey]; !ok {
				containerSpec.Env[envKey] = input.Default
			}
		}

		switch action.Runs.Using {
		case model.ActionRunsUsingNode12:
			containerSpec.Image = "node:12-alpine"
			if strings.HasPrefix(actionDir, rc.Config.Workdir) {
				containerSpec.Args = fmt.Sprintf("node /github/workspace/%s/%s", strings.TrimPrefix(actionDir, rc.Config.Workdir), action.Runs.Main)
			} else if strings.HasPrefix(actionDir, rc.Tempdir) {
				containerSpec.Args = fmt.Sprintf("node /github/home/%s/%s", strings.TrimPrefix(actionDir, rc.Tempdir), action.Runs.Main)
			}
		case model.ActionRunsUsingDocker:
			if strings.HasPrefix(action.Runs.Image, "docker://") {
				containerSpec.Image = strings.TrimPrefix(action.Runs.Image, "docker://")
				containerSpec.Entrypoint = strings.Join(action.Runs.Entrypoint, " ")
				containerSpec.Args = strings.Join(action.Runs.Args, " ")
			} else {
				contextDir := filepath.Join(actionDir, action.Runs.Main)
				return container.NewDockerBuildExecutor(container.NewDockerBuildExecutorInput{
					ContextDir: contextDir,
					ImageTag:   containerSpec.Image,
				})(ctx)
			}
		}
		return nil
	}
}

type remoteAction struct {
	Org  string
	Repo string
	Path string
	Ref  string
}

func (ra *remoteAction) CloneURL() string {
	return fmt.Sprintf("https://github.com/%s/%s", ra.Org, ra.Repo)
}

func newRemoteAction(action string) *remoteAction {
	r := regexp.MustCompile(`^([^/@]+)/([^/@]+)(/([^@]*))?(@(.*))?$`)
	matches := r.FindStringSubmatch(action)

	ra := new(remoteAction)
	ra.Org = matches[1]
	ra.Repo = matches[2]
	ra.Path = ""
	ra.Ref = "master"
	if len(matches) >= 5 {
		ra.Path = matches[4]
	}
	if len(matches) >= 7 {
		ra.Ref = matches[6]
	}
	return ra
}