feat: support offline mode

cmd/input.go

@@ -55,6 +55,7 @@ type Input struct {
 	replaceGheActionTokenWithGithubCom string
 	matrix                             []string
 	actionCachePath                    string
+	actionOfflineMode                  bool
 	logPrefixJobID                     bool
 	networkName                        string
 	useNewActionCache                  bool

cmd/root.go

@@ -97,6 +97,7 @@ func Execute(ctx context.Context, version string) {
 	rootCmd.PersistentFlags().StringVarP(&input.cacheServerAddr, "cache-server-addr", "", common.GetOutboundIP().String(), "Defines the address to which the cache server binds.")
 	rootCmd.PersistentFlags().Uint16VarP(&input.cacheServerPort, "cache-server-port", "", 0, "Defines the port where the artifact server listens. 0 means a randomly available port.")
 	rootCmd.PersistentFlags().StringVarP(&input.actionCachePath, "action-cache-path", "", filepath.Join(CacheHomeDir, "act"), "Defines the path where the actions get cached and host workspaces created.")
+	rootCmd.PersistentFlags().BoolVarP(&input.actionOfflineMode, "action-offline-mode", "", false, "If action contents exists, it will not be fetch and pull again. If turn on this,will turn off force pull")
 	rootCmd.PersistentFlags().StringVarP(&input.networkName, "network", "", "host", "Sets a docker network name. Defaults to host.")
 	rootCmd.PersistentFlags().BoolVarP(&input.useNewActionCache, "use-new-action-cache", "", false, "Enable using the new Action Cache for storing Actions locally")
 	rootCmd.SetArgs(args())
@@ -582,11 +583,12 @@ func newRunCommand(ctx context.Context, input *Input) func(*cobra.Command, []str
 			EventName:                          eventName,
 			EventPath:                          input.EventPath(),
 			DefaultBranch:                      defaultbranch,
-			ForcePull:                          input.forcePull,
+			ForcePull:                          !input.actionOfflineMode && input.forcePull,
 			ForceRebuild:                       input.forceRebuild,
 			ReuseContainers:                    input.reuseContainers,
 			Workdir:                            input.Workdir(),
 			ActionCacheDir:                     input.actionCachePath,
+			ActionOfflineMode:                  input.actionOfflineMode,
 			BindWorkdir:                        input.bindWorkdir,
 			LogOutput:                          !input.noOutput,
 			JSONLogger:                         input.jsonLogger,

pkg/common/git/git.go

@@ -64,7 +64,7 @@
 	)
 
 	if err != nil {
 		logger.WithError(err).Error("path", file, "not located inside a git repository")
 		return "", "", err
 	}
 
@@ -74,7 +74,7 @@
 	}
 
 	if head.Hash().IsZero() {
 		return "", "", fmt.Errorf("HEAD sha1 could not be resolved")
 	}
 
 	hash := head.Hash().String()
@@ -107,13 +107,13 @@
 	)
 
 	if err != nil {
 		return "", err
 	}
 
 	iter, err := repo.References()
 	if err != nil {
 		return "", err
 	}
 
 	// find the reference that matches the revision's has
 	err = iter.ForEach(func(r *plumbing.Reference) error {
@@ -146,7 +146,7 @@
 	})
 
 	if err != nil {
 		return "", err
 	}
 
 	// order matters here see above comment.
@@ -157,7 +157,7 @@
 		return refBranch, nil
 	}
 
 	return "", fmt.Errorf("failed to identify reference (tag/branch) for the checked-out revision '%s'", ref)
 }
 
 // FindGithubRepo get the repo
@@ -192,7 +192,7 @@
 	}
 
 	if len(remote.Config().URLs) < 1 {
 		return "", fmt.Errorf("remote '%s' exists but has no URL", remoteName)
 	}
 
 	return remote.Config().URLs[0], nil
@@ -221,10 +221,11 @@
 
 // NewGitCloneExecutorInput the input for the NewGitCloneExecutor
 type NewGitCloneExecutorInput struct {
-	URL   string
-	Ref   string
-	Dir   string
-	Token string
+	URL         string
+	Ref         string
+	Dir         string
+	Token       string
+	OfflineMode bool
 }
 
 // CloneIfRequired ...
@@ -302,12 +303,16 @@
 			return err
 		}
 
+		isOfflineMode := input.OfflineMode
+
 		// fetch latest changes
 		fetchOptions, pullOptions := gitOptions(input.Token)
 
-		err = r.Fetch(&fetchOptions)
-		if err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
-			return err
+		if !isOfflineMode {
+			err = r.Fetch(&fetchOptions)
+			if err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
+				return err
+			}
 		}
 
 		var hash *plumbing.Hash
@@ -367,9 +372,10 @@
 				return err
 			}
 		}
-
-		if err = w.Pull(&pullOptions); err != nil && err != git.NoErrAlreadyUpToDate {
-			logger.Debugf("Unable to pull %s: %v", refName, err)
+		if !isOfflineMode {
+			if err = w.Pull(&pullOptions); err != nil && err != git.NoErrAlreadyUpToDate {
+				logger.Debugf("Unable to pull %s: %v", refName, err)
+			}
 		}
 		logger.Debugf("Cloned %s to %s", input.URL, input.Dir)
 

pkg/runner/reusable_workflow.go

@@ -25,8 +25,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 +35,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 +44,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)
 	}
 }
 
@@ -102,10 +102,11 @@
 		func(ctx context.Context) error {
 			remoteReusableWorkflow.URL = rc.getGithubContext(ctx).ServerURL
 			return git.NewGitCloneExecutor(git.NewGitCloneExecutorInput{
-				URL:   remoteReusableWorkflow.CloneURL(),
-				Ref:   remoteReusableWorkflow.Ref,
-				Dir:   targetDirectory,
-				Token: rc.Config.Token,
+				URL:         remoteReusableWorkflow.CloneURL(),
+				Ref:         remoteReusableWorkflow.Ref,
+				Dir:         targetDirectory,
+				Token:       rc.Config.Token,
+				OfflineMode: rc.Config.ActionOfflineMode,
 			})(ctx)
 		},
 		nil,
@@ -116,18 +117,18 @@
 	return func(ctx context.Context) error {
 		planner, err := model.NewWorkflowPlanner(path.Join(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 +164,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.go

@@ -23,6 +23,7 @@
 	Actor                              string                       // the user that triggered the event
 	Workdir                            string                       // path to working directory
 	ActionCacheDir                     string                       // path used for caching action contents
+	ActionOfflineMode                  bool                         // when offline, use caching action contents
 	BindWorkdir                        bool                         // bind the workdir to the job container
 	EventName                          string                       // name of event to run
 	EventPath                          string                       // path to JSON file to use for event.json in containers
@@ -96,8 +97,8 @@
 		}
 		eventJSON, err := json.Marshal(eventMap)
 		if err != nil {
 			return nil, err
 		}
 		runner.eventJSON = string(eventJSON)
 	}
 	return runner, nil
@@ -155,7 +156,7 @@
 
 				var matrixes []map[string]interface{}
 				if m, err := job.GetMatrixes(); err != nil {
 					log.Errorf("Error while get job's matrix: %v", err)
 				} else {
 					log.Debugf("Job Matrices: %v", m)
 					log.Debugf("Runner Matrices: %v", runner.config.Matrix)
@@ -187,8 +188,8 @@
 						executor, err := rc.Executor()
 
 						if err != nil {
 							return err
 						}
 
 						return executor(common.WithJobErrorContainer(WithJobLogger(ctx, rc.Run.JobID, jobName, rc.Config, &rc.Masks, matrix)))
 					})
@@ -197,7 +198,7 @@
 			}
 			ncpu := runtime.NumCPU()
 			if 1 > ncpu {
 				ncpu = 1
 			}
 			log.Debugf("Detected CPUs: %d", ncpu)
 			return common.NewParallelExecutor(ncpu, pipeline...)(ctx)

pkg/runner/step_action_remote.go

@@ -64,52 +64,53 @@
 			}
 		}
 		if sar.RunContext.Config.ActionCache != nil {
 			cache := sar.RunContext.Config.ActionCache
 
 			var err error
 			sar.cacheDir = fmt.Sprintf("%s/%s", sar.remoteAction.Org, sar.remoteAction.Repo)
 			sar.resolvedSha, err = cache.Fetch(ctx, sar.cacheDir, sar.remoteAction.URL+"/"+sar.cacheDir, sar.remoteAction.Ref, github.Token)
 			if err != nil {
 				return err
 			}
 
 			remoteReader := func(ctx context.Context) actionYamlReader {
 				return func(filename string) (io.Reader, io.Closer, error) {
 					spath := filename
 					for i := 0; i < maxSymlinkDepth; i++ {
 						tars, err := cache.GetTarArchive(ctx, sar.cacheDir, sar.resolvedSha, spath)
 						if err != nil {
 							return nil, nil, os.ErrNotExist
 						}
 						treader := tar.NewReader(tars)
 						header, err := treader.Next()
 						if err != nil {
 							return nil, nil, os.ErrNotExist
 						}
 						if header.FileInfo().Mode()&os.ModeSymlink == os.ModeSymlink {
 							spath, err = symlinkJoin(spath, header.Linkname, ".")
 							if err != nil {
 								return nil, nil, err
 							}
 						} else {
 							return treader, tars, nil
 						}
 					}
 					return nil, nil, fmt.Errorf("max depth %d of symlinks exceeded while reading %s", maxSymlinkDepth, spath)
 				}
 			}
 
 			actionModel, err := sar.readAction(ctx, sar.Step, sar.resolvedSha, sar.remoteAction.Path, remoteReader(ctx), os.WriteFile)
 			sar.action = actionModel
 			return err
 		}
 
 		actionDir := fmt.Sprintf("%s/%s", sar.RunContext.ActionCacheDir(), safeFilename(sar.Step.Uses))
 		gitClone := stepActionRemoteNewCloneExecutor(git.NewGitCloneExecutorInput{
-			URL:   sar.remoteAction.CloneURL(),
-			Ref:   sar.remoteAction.Ref,
-			Dir:   actionDir,
-			Token: github.Token,
+			URL:         sar.remoteAction.CloneURL(),
+			Ref:         sar.remoteAction.Ref,
+			Dir:         actionDir,
+			Token:       github.Token,
+			OfflineMode: sar.RunContext.Config.ActionOfflineMode,
 		})
 		var ntErr common.Executor
 		if err := gitClone(ctx); err != nil {