fix: fail to find local subworkflow of remote workflow

cmd/root.go

@@ -433,7 +433,7 @@ func newRunCommand(ctx context.Context, input *Input) func(*cobra.Command, []str
  matrixes := parseMatrix(input.matrix)
  log.Debugf("Evaluated matrix inclusions: %v", matrixes)
 
- planner, err := model.NewWorkflowPlanner(input.WorkflowsPath(), input.noWorkflowRecurse)
+ planner, err := model.NewWorkflowPlanner("", input.WorkflowsPath(), input.noWorkflowRecurse)
  if err != nil {
  return err
  }

pkg/artifacts/server_test.go

@@ -297,7 +297,7 @@ func runTestJobFile(ctx context.Context, t *testing.T, tjfi TestJobFileInfo) {
  runner, err := runner.New(runnerConfig)
  assert.Nil(t, err, tjfi.workflowPath)
 
- planner, err := model.NewWorkflowPlanner(fullWorkflowPath, true)
+ planner, err := model.NewWorkflowPlanner(workdir, tjfi.workflowPath, true)
  assert.Nil(t, err, fullWorkflowPath)
 
  plan, err := planner.PlanEvent(tjfi.eventName)

pkg/model/planner.go

@@ -58,7 +58,13 @@
 // NewWorkflowPlanner will load a specific workflow, all workflows from a directory or all workflows from a directory and its subdirectories
 //
 //nolint:gocyclo
-func NewWorkflowPlanner(path string, noWorkflowRecurse bool) (WorkflowPlanner, error) {
+func NewWorkflowPlanner(directory string, workflow string, noWorkflowRecurse bool) (WorkflowPlanner, error) {
+ path := ""
+ if directory == "" || workflow == "" {
+ path = directory + workflow
+ } else {
+ path = filepath.Join(directory, workflow)
+ }
  path, err := filepath.Abs(path)
  if err != nil {
  return nil, err
@@ -142,7 +148,7 @@
  _ = f.Close()
  return nil, fmt.Errorf("error occurring when resetting io pointer in '%s': %w", wf.workflowDirEntry.Name(), err)
  }
-
+ workflow.RepoPath = directory
  workflow.File = wf.workflowDirEntry.Name()
  if workflow.Name == "" {
  workflow.Name = wf.workflowDirEntry.Name()
@@ -162,30 +168,30 @@
  return wp, nil
 }
 
 func NewSingleWorkflowPlanner(name string, f io.Reader) (WorkflowPlanner, error) {
  wp := new(workflowPlanner)
 
  log.Debugf("Reading workflow %s", name)
  workflow, err := ReadWorkflow(f)
  if err != nil {
  if err == io.EOF {
  return nil, fmt.Errorf("unable to read workflow '%s': file is empty: %w", name, err)
  }
  return nil, fmt.Errorf("workflow is not valid. '%s': %w", name, err)
  }
  workflow.File = name
  if workflow.Name == "" {
  workflow.Name = name
  }
 
  err = validateJobName(workflow)
  if err != nil {
  return nil, err
  }
 
  wp.workflows = append(wp.workflows, workflow)
 
  return wp, nil
 }
 
 func validateJobName(workflow *Workflow) error {
@@ -203,34 +209,34 @@
 }
 
 // PlanEvent builds a new list of runs to execute in parallel for an event name
 func (wp *workflowPlanner) PlanEvent(eventName string) (*Plan, error) {
  plan := new(Plan)
  if len(wp.workflows) == 0 {
  log.Debug("no workflows found by planner")
  return plan, nil
  }
  var lastErr error
 
  for _, w := range wp.workflows {
  events := w.On()
  if len(events) == 0 {
  log.Debugf("no events found for workflow: %s", w.File)
  continue
  }
 
  for _, e := range events {
  if e == eventName {
  stages, err := createStages(w, w.GetJobIDs()...)
  if err != nil {
  log.Warn(err)
  lastErr = err
  } else {
  plan.mergeStages(stages)
  }
  }
  }
  }
  return plan, lastErr
 }
 
 // PlanJob builds a new run to execute in parallel for a job name
@@ -244,8 +250,8 @@
  for _, w := range wp.workflows {
  stages, err := createStages(w, jobName)
  if err != nil {
  log.Warn(err)
  lastErr = err
  } else {
  plan.mergeStages(stages)
  }
@@ -254,25 +260,25 @@
 }
 
 // PlanAll builds a new run to execute in parallel all
 func (wp *workflowPlanner) PlanAll() (*Plan, error) {
  plan := new(Plan)
  if len(wp.workflows) == 0 {
  log.Debug("no workflows found by planner")
  return plan, nil
  }
  var lastErr error
 
  for _, w := range wp.workflows {
  stages, err := createStages(w, w.GetJobIDs()...)
  if err != nil {
  log.Warn(err)
  lastErr = err
  } else {
  plan.mergeStages(stages)
  }
  }
 
  return plan, lastErr
 }
 
 // GetEvents gets all the events in the workflows file
@@ -377,7 +383,7 @@
  }
  }
  if len(stage.Runs) == 0 {
  return nil, fmt.Errorf("unable to build dependency graph for %s (%s)", w.Name, w.File)
  }
  stages = append(stages, stage)
  }

pkg/model/planner_test.go

@@ -30,8 +30,7 @@ func TestPlanner(t *testing.T) {
  workdir, err := filepath.Abs("testdata")
  assert.NoError(t, err, workdir)
  for _, table := range tables {
- fullWorkflowPath := filepath.Join(workdir, table.workflowPath)
- _, err = NewWorkflowPlanner(fullWorkflowPath, table.noWorkflowRecurse)
+ _, err = NewWorkflowPlanner(workdir, table.workflowPath, table.noWorkflowRecurse)
  if table.errorMessage == "" {
  assert.NoError(t, err, "WorkflowPlanner should exit without any error")
  } else {

pkg/model/workflow.go

@@ -15,6 +15,7 @@
 
 // Workflow is the structure of the files in .github/workflows
 type Workflow struct {
+ RepoPath string
  File string
  Name string `yaml:"name"`
  RawOn yaml.Node `yaml:"on"`
@@ -58,8 +59,8 @@
 func (w *Workflow) OnEvent(event string) interface{} {
  if w.RawOn.Kind == yaml.MappingNode {
  var val map[string]interface{}
  if !decodeNode(w.RawOn, &val) {
  return nil
  }
  return val[event]
  }
@@ -84,14 +85,14 @@
  }
 
  var val map[string]yaml.Node
  if !decodeNode(w.RawOn, &val) {
  return nil
  }
 
  var config WorkflowDispatch
  node := val["workflow_dispatch"]
  if !decodeNode(node, &config) {
  return nil
  }
 
  return &config
@@ -120,19 +121,19 @@
 
 func (w *Workflow) WorkflowCallConfig() *WorkflowCall {
  if w.RawOn.Kind != yaml.MappingNode {
  // The callers expect for "on: workflow_call" and "on: [ workflow_call ]" a non nil return value
  return &WorkflowCall{}
  }
 
  var val map[string]yaml.Node
  if !decodeNode(w.RawOn, &val) {
  return &WorkflowCall{}
  }
 
  var config WorkflowCall
  node := val["workflow_call"]
  if !decodeNode(node, &config) {
  return &WorkflowCall{}
  }
 
  return &config
@@ -215,8 +216,8 @@
  }
 
  var val string
  if !decodeNode(j.RawSecrets, &val) {
  return false
  }
 
  return val == "inherit"
@@ -228,8 +229,8 @@
  }
 
  var val map[string]string
  if !decodeNode(j.RawSecrets, &val) {
  return nil
  }
 
  return val
@@ -242,12 +243,12 @@
  case yaml.ScalarNode:
  val = new(ContainerSpec)
  if !decodeNode(j.RawContainer, &val.Image) {
  return nil
  }
  case yaml.MappingNode:
  val = new(ContainerSpec)
  if !decodeNode(j.RawContainer, val) {
  return nil
  }
  }
  return val
@@ -258,14 +259,14 @@
  switch j.RawNeeds.Kind {
  case yaml.ScalarNode:
  var val string
  if !decodeNode(j.RawNeeds, &val) {
  return nil
  }
  return []string{val}
  case yaml.SequenceNode:
  var val []string
  if !decodeNode(j.RawNeeds, &val) {
  return nil
  }
  return val
  }
@@ -282,8 +283,8 @@
  }
 
  if !decodeNode(j.RawRunsOn, &val) {
  return nil
  }
 
  labels := nodeAsStringSlice(val.Labels)
 
@@ -292,8 +293,8 @@
  }
 
  return labels
  default:
  return nodeAsStringSlice(j.RawRunsOn)
  }
 }
 
@@ -302,13 +303,13 @@
  case yaml.ScalarNode:
  var val string
  if !decodeNode(node, &val) {
  return nil
  }
  return []string{val}
  case yaml.SequenceNode:
  var val []string
  if !decodeNode(node, &val) {
  return nil
  }
  return val
  }
@@ -318,8 +319,8 @@
 func environment(yml yaml.Node) map[string]string {
  env := make(map[string]string)
  if yml.Kind == yaml.MappingNode {
  if !decodeNode(yml, &env) {
  return nil
  }
  }
  return env
@@ -335,7 +336,7 @@
  if j.Strategy.RawMatrix.Kind == yaml.MappingNode {
  var val map[string][]interface{}
  if !decodeNode(j.Strategy.RawMatrix, &val) {
  return nil
  }
  return val
  }
@@ -397,7 +398,7 @@
  excludes = append(excludes, e)
  } else {
  // We fail completely here because that's what GitHub does for non-existing matrix keys, fail on exclude, silent skip on include
  return nil, fmt.Errorf("the workflow is not valid. Matrix exclude key %q does not match any key within the matrix", k)
  }
  }
  }
@@ -441,7 +442,7 @@
  }
  } else {
  matrixes = append(matrixes, make(map[string]interface{}))
  log.Debugf("Empty Strategy, matrixes=%v", matrixes)
  }
  return matrixes, nil
 }
@@ -592,7 +593,7 @@
  case "sh":
  shellCommand = "sh -e {0}"
  case "cmd":
  shellCommand = "cmd /D /E:ON /V:OFF /S /C \"CALL \"{0}\"\""
  case "powershell":
  shellCommand = "powershell -command . '{0}'"
  default:
@@ -702,16 +703,16 @@
  return ids
 }
 
 var OnDecodeNodeError = func(node yaml.Node, out interface{}, err error) {
  log.Fatalf("Failed to decode node %v into %T: %v", node, out, err)
 }
 
 func decodeNode(node yaml.Node, out interface{}) bool {
  if err := node.Decode(out); err != nil {
  if OnDecodeNodeError != nil {
  OnDecodeNodeError(node, out, err)
  }
  return false
  }
  return true
 }

pkg/model/workflow_test.go

@@ -334,7 +334,7 @@ jobs:
 }
 
 func TestReadWorkflow_Strategy(t *testing.T) {
- w, err := NewWorkflowPlanner("testdata/strategy/push.yml", true)
+ w, err := NewWorkflowPlanner("testdata/strategy", "push.yml", true)
  assert.NoError(t, err)
 
  p, err := w.PlanJob("strategy-only-max-parallel")

pkg/runner/reusable_workflow.go

@@ -7,8 +7,8 @@
  "fmt"
  "io/fs"
  "os"
- "path"
  "regexp"
+ "strings"
  "sync"
 
  "github.com/nektos/act/pkg/common"
@@ -17,7 +17,13 @@
 )
 
 func newLocalReusableWorkflowExecutor(rc *RunContext) common.Executor {
- return newReusableWorkflowExecutor(rc, rc.Config.Workdir, rc.Run.Job().Uses)
+ job := rc.Run.Job()
+ if strings.Index(job.Uses, "./") == 0 {
+ // relative path
+ return newReusableWorkflowExecutor(rc, rc.Run.Workflow.RepoPath, job.Uses)
+ } else {
+ return newReusableWorkflowExecutor(rc, rc.Config.Workdir, job.Uses)
+ }
 }
 
 func newRemoteReusableWorkflowExecutor(rc *RunContext) common.Executor {
@@ -25,8 +31,8 @@
 
  remoteReusableWorkflow := newRemoteReusableWorkflow(uses)
  if remoteReusableWorkflow == nil {
  return common.NewErrorExecutor(fmt.Errorf("expected format {owner}/{repo}/.github/workflows/{filename}@{ref}. Actual '%s' Input string was not in a correct format", uses))
  }
 
  // uses with safe filename makes the target directory look something like this {owner}-{repo}-.github-workflows-{filename}@{ref}
  // instead we will just use {owner}-{repo}@{ref} as our target directory. This should also improve performance when we are using
@@ -35,8 +41,8 @@
  workflowDir := fmt.Sprintf("%s/%s", rc.ActionCacheDir(), safeFilename(filename))
 
  if rc.Config.ActionCache != nil {
  return newActionCacheReusableWorkflowExecutor(rc, filename, remoteReusableWorkflow)
  }
 
  return common.NewPipelineExecutor(
  newMutexExecutor(cloneIfRequired(rc, *remoteReusableWorkflow, workflowDir)),
@@ -44,38 +50,38 @@
  )
 }
 
 func newActionCacheReusableWorkflowExecutor(rc *RunContext, filename string, remoteReusableWorkflow *remoteReusableWorkflow) common.Executor {
  return func(ctx context.Context) error {
  ghctx := rc.getGithubContext(ctx)
  remoteReusableWorkflow.URL = ghctx.ServerURL
  sha, err := rc.Config.ActionCache.Fetch(ctx, filename, remoteReusableWorkflow.CloneURL(), remoteReusableWorkflow.Ref, ghctx.Token)
  if err != nil {
  return err
  }
  archive, err := rc.Config.ActionCache.GetTarArchive(ctx, filename, sha, fmt.Sprintf(".github/workflows/%s", remoteReusableWorkflow.Filename))
  if err != nil {
  return err
  }
  defer archive.Close()
  treader := tar.NewReader(archive)
  if _, err = treader.Next(); err != nil {
  return err
  }
  planner, err := model.NewSingleWorkflowPlanner(remoteReusableWorkflow.Filename, treader)
  if err != nil {
  return err
  }
  plan, err := planner.PlanEvent("workflow_call")
  if err != nil {
  return err
  }
 
  runner, err := NewReusableWorkflowRunner(rc)
  if err != nil {
  return err
  }
 
  return runner.NewPlanExecutor(plan)(ctx)
  }
 }
 
@@ -114,20 +120,20 @@
 
 func newReusableWorkflowExecutor(rc *RunContext, directory string, workflow string) common.Executor {
  return func(ctx context.Context) error {
- planner, err := model.NewWorkflowPlanner(path.Join(directory, workflow), true)
+ planner, err := model.NewWorkflowPlanner(directory, workflow, true)
  if err != nil {
  return err
  }
 
  plan, err := planner.PlanEvent("workflow_call")
  if err != nil {
  return err
  }
 
  runner, err := NewReusableWorkflowRunner(rc)
  if err != nil {
  return err
  }
 
  return runner.NewPlanExecutor(plan)(ctx)
  }
@@ -163,8 +169,8 @@
  r := regexp.MustCompile(`^([^/]+)/([^/]+)/.github/workflows/([^@]+)@(.*)$`)
  matches := r.FindStringSubmatch(uses)
  if len(matches) != 5 {
  return nil
  }
  return &remoteReusableWorkflow{
  Org: matches[1],
  Repo: matches[2],

pkg/runner/runner_test.go

@@ -50,7 +50,7 @@ func init() {
 }
 
 func TestNoWorkflowsFoundByPlanner(t *testing.T) {
- planner, err := model.NewWorkflowPlanner("res", true)
+ planner, err := model.NewWorkflowPlanner("res", "", true)
  assert.NoError(t, err)
 
  out := log.StandardLogger().Out
@@ -70,7 +70,7 @@ func TestNoWorkflowsFoundByPlanner(t *testing.T) {
 }
 
 func TestGraphMissingEvent(t *testing.T) {
- planner, err := model.NewWorkflowPlanner("testdata/issue-1595/no-event.yml", true)
+ planner, err := model.NewWorkflowPlanner("testdata/issue-1595", "no-event.yml", true)
  assert.NoError(t, err)
 
  out := log.StandardLogger().Out
@@ -88,7 +88,7 @@ func TestGraphMissingEvent(t *testing.T) {
 }
 
 func TestGraphMissingFirst(t *testing.T) {
- planner, err := model.NewWorkflowPlanner("testdata/issue-1595/no-first.yml", true)
+ planner, err := model.NewWorkflowPlanner("testdata/issue-1595", "no-first.yml", true)
  assert.NoError(t, err)
 
  plan, err := planner.PlanEvent("push")
@@ -98,7 +98,7 @@ func TestGraphMissingFirst(t *testing.T) {
 }
 
 func TestGraphWithMissing(t *testing.T) {
- planner, err := model.NewWorkflowPlanner("testdata/issue-1595/missing.yml", true)
+ planner, err := model.NewWorkflowPlanner("testdata/issue-1595", "missing.yml", true)
  assert.NoError(t, err)
 
  out := log.StandardLogger().Out
@@ -117,7 +117,7 @@ func TestGraphWithMissing(t *testing.T) {
 func TestGraphWithSomeMissing(t *testing.T) {
  log.SetLevel(log.DebugLevel)
 
- planner, err := model.NewWorkflowPlanner("testdata/issue-1595/", true)
+ planner, err := model.NewWorkflowPlanner("testdata/issue-1595", "", true)
  assert.NoError(t, err)
 
  out := log.StandardLogger().Out
@@ -135,7 +135,7 @@ func TestGraphWithSomeMissing(t *testing.T) {
 }
 
 func TestGraphEvent(t *testing.T) {
- planner, err := model.NewWorkflowPlanner("testdata/basic", true)
+ planner, err := model.NewWorkflowPlanner("testdata/basic", "", true)
  assert.NoError(t, err)
 
  plan, err := planner.PlanEvent("push")
@@ -192,7 +192,7 @@ func (j *TestJobFileInfo) runTest(ctx context.Context, t *testing.T, cfg *Config
  runner, err := New(runnerConfig)
  assert.Nil(t, err, j.workflowPath)
 
- planner, err := model.NewWorkflowPlanner(fullWorkflowPath, true)
+ planner, err := model.NewWorkflowPlanner(workdir, j.workflowPath, true)
  assert.Nil(t, err, fullWorkflowPath)
 
  plan, err := planner.PlanEvent(j.eventName)
@@ -242,6 +242,7 @@ func TestRunEvent(t *testing.T) {
  {workdir, "uses-workflow", "pull_request", "", platforms, map[string]string{"secret": "keep_it_private"}},
  {workdir, "uses-docker-url", "push", "", platforms, secrets},
  {workdir, "act-composite-env-test", "push", "", platforms, secrets},
+ {workdir, "issue-1875-uses-workflow-with-sub-workflow", "dispatch", "", platforms, secrets},
 
  // Eval
  {workdir, "evalmatrix", "push", "", platforms, secrets},

pkg/runner/testdata/issue-1875-uses-workflow-with-sub-workflow/caller-workflow.yml

@@ -0,0 +1,7 @@
+name: Call Reusable Workflow
+on:
+ push:
+
+jobs:
+ call-reusable-workflow-with-sub:
+ uses: wildsheepz/TestReusableWorkflow/.github/workflows/main.yaml@ubuntu_platform