run

type ActRunCtx struct {
	/**
	 * Reference to global run context.
	 */
	RunCtx *RunCtx

	/**
	 * Actfile where we found this act.
	 */
	ActFile *actfile.ActFile

	/**
	 * The act to run.
	 */
	Act *actfile.Act

	/**
	 * Prev context in the chain.
	 */
	PrevCtx *ActRunCtx

	/**
	 * This is the call id for the act.
	 */
	CallId string

	/**
	 * Indicates which stage is currently running.
	 */
	CurrentStage *actfile.ActExecStage

	/**
	 * List of cli flag values passed by the user.
	 */
	FlagVals map[string]string

	/**
	 * Cli arguments after extracting flags.
	 */
	Args []string

	/**
	 * Set of variables passed from parent acts.
	 */
	ParentVars map[string]string

	/**
	 * Act runtime vars.
	 */
	ActVars map[string]string

	/**
	 * Set of variables scoped to act execution.
	 */
	Vars map[string]string
}

type Info struct {
	/**
	 * Which running act going to receive an unique short hash
	 * id which going to be used to name the data folder for
	 * this act in the act data dir.
	 */
	Id string

	/**
	 * If this act was created from another act process then we
	 * going to store parent act id here. We do this because we
	 * need to update parent when the state of this act change.
	 */
	ParentActId string

	/**
	 * Name is a human friendly id assigned by the user when
	 * running the act. User can then use this name to stop
	 * o get logs for the act.
	 */
	NameId string

	/**
	 * This is the process group id of this act process.
	 */
	Pgid int

	/**
	 * This is the process id.
	 */
	Pid int

	/**
	 * This is the list of all command process group ids created
	 * by this act process. When we are running a sync act then
	 * at any given time this array going to have one and only one
	 * pgid (the pgid of currently running command). When running a
	 * parallel act then usually this array going to contain the
	 * pgids of all commands running in parallel.
	 */
	CmdPgids []int

	/**
	 * This is a list of ids of all act detached processes created
	 * by this act process.
	 */
	ChildActIds []string

	/**
	 * Flag to indicate we are killing the process.
	 */
	IsKilling bool
	// contains filtered or unexported fields
}

type LogWriter struct {
	Detached     bool
	LogToConsole bool
	// contains filtered or unexported fields
}

type RunCtx struct {
	/**
	 * Cli arguments passed by the user.
	 */
	Args []string

	/**
	 * This is the act ctx we going to execute.
	 */
	ActCtx *ActRunCtx

	/**
	 * This is the root actfile.
	 */
	ActFile *actfile.ActFile

	/**
	 * This is a set indicating which actfiles were already loaded.
	 */
	LoadedActFiles map[string]bool

	/**
	 * This are global variables to be used by all acts in the stack.
	 */
	Vars map[string]string

	/**
	 * Set of variables loaded from file.
	 */
	EnvFileVars map[string]string

	/**
	 * Act runtime variables.
	 */
	ActVars map[string]string

	/**
	 * This stack going to hold all acts run contexts we have
	 * active so far.
	 */
	ActCtxCallStack []*ActRunCtx

	/**
	 * Run context info as stored in act data dir.
	 */
	Info *Info

	/**
	 * Flag indicating if we are running the process as a
	 * daemon in the background.
	 */
	IsDaemon bool

	/**
	 * Flag indicating the state of the execution.
	 */
	State string

	/**
	 * Flag indicating we are finishing the execution.
	 */
	IsFinishing bool

	/**
	 * Log mode.
	 */
	Log string

	/**
	 * Flag indicating we should supress all logs.
	 */
	Quiet bool
}