github.com/ActiveState/cli@v0.0.0-20240508170324-6801f60cd051/internal/runners/exec/exec.go

package exec

import (
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	rtrunbit "github.com/ActiveState/cli/internal/runbits/runtime"
	"github.com/shirou/gopsutil/v3/process"

	"github.com/ActiveState/cli/internal/analytics"
	"github.com/ActiveState/cli/internal/constants"
	"github.com/ActiveState/cli/internal/errs"
	"github.com/ActiveState/cli/internal/fileutils"
	"github.com/ActiveState/cli/internal/hash"
	"github.com/ActiveState/cli/internal/language"
	"github.com/ActiveState/cli/internal/locale"
	"github.com/ActiveState/cli/internal/logging"
	"github.com/ActiveState/cli/internal/multilog"
	"github.com/ActiveState/cli/internal/osutils"
	"github.com/ActiveState/cli/internal/output"
	"github.com/ActiveState/cli/internal/primer"
	"github.com/ActiveState/cli/internal/runbits/rationalize"
	"github.com/ActiveState/cli/internal/scriptfile"
	"github.com/ActiveState/cli/internal/subshell"
	"github.com/ActiveState/cli/internal/virtualenvironment"
	"github.com/ActiveState/cli/pkg/platform/authentication"
	"github.com/ActiveState/cli/pkg/platform/model"
	"github.com/ActiveState/cli/pkg/platform/runtime"
	"github.com/ActiveState/cli/pkg/platform/runtime/executors"
	"github.com/ActiveState/cli/pkg/platform/runtime/target"
	"github.com/ActiveState/cli/pkg/project"
	"github.com/ActiveState/cli/pkg/projectfile"
)

type Configurable interface {
	projectfile.ConfigGetter
	GetBool(key string) bool
}

type Exec struct {
	subshell  subshell.SubShell
	proj      *project.Project
	auth      *authentication.Auth
	out       output.Outputer
	cfg       Configurable
	analytics analytics.Dispatcher
	svcModel  *model.SvcModel
}

type primeable interface {
	primer.Auther
	primer.Outputer
	primer.Subsheller
	primer.Projecter
	primer.Configurer
	primer.Analyticer
	primer.SvcModeler
}

type Params struct {
	Path string
}

func New(prime primeable) *Exec {
	return &Exec{
		prime.Subshell(),
		prime.Project(),
		prime.Auth(),
		prime.Output(),
		prime.Config(),
		prime.Analytics(),
		prime.SvcModel(),
	}
}

func NewParams() *Params {
	return &Params{}
}

func (s *Exec) Run(params *Params, args ...string) (rerr error) {
	var projectDir string
	var projectNamespace string

	if len(args) == 0 {
		return nil
	}

	trigger := target.NewExecTrigger(args[0])

	// Detect target and project dir
	// If the path passed resolves to a runtime dir (ie. has a runtime marker) then the project is not used
	var proj *project.Project
	var err error
	if params.Path != "" && runtime.IsRuntimeDir(params.Path) {
		projectDir = projectFromRuntimeDir(s.cfg, params.Path)
		proj, err = project.FromPath(projectDir)
		if err != nil {
			return locale.WrapInputError(err, "exec_no_project_at_path", "Could not find project file at {{.V0}}", projectDir)
		}
		projectNamespace = proj.NamespaceString()
	} else {
		proj = s.proj
		if params.Path != "" {
			var err error
			proj, err = project.FromPath(params.Path)
			if err != nil {
				return locale.WrapInputError(err, "exec_no_project_at_path", "Could not find project file at {{.V0}}", params.Path)
			}
		}
		if proj == nil {
			return rationalize.ErrNoProject
		}
		projectDir = filepath.Dir(proj.Source().Path())
		projectNamespace = proj.NamespaceString()
	}

	s.out.Notice(locale.Tr("operating_message", projectNamespace, projectDir))

	rt, err := rtrunbit.SolveAndUpdate(s.auth, s.out, s.analytics, proj, nil, trigger, s.svcModel, s.cfg, rtrunbit.OptMinimalUI)
	if err != nil {
		return locale.WrapError(err, "err_activate_runtime", "Could not initialize a runtime for this project.")
	}

	venv := virtualenvironment.New(rt)

	env, err := venv.GetEnv(true, false, projectDir, projectNamespace)
	if err != nil {
		return locale.WrapError(err, "err_exec_env", "Could not retrieve environment information for your runtime")
	}
	logging.Debug("Trying to exec %s on PATH=%s", args[0], env["PATH"])

	if err := handleRecursion(env, args); err != nil {
		return errs.Wrap(err, "Could not handle recursion")
	}

	exeTarget := args[0]
	if !fileutils.TargetExists(exeTarget) {
		rtDirs, err := rt.ExecutableDirs()
		if err != nil {
			return errs.Wrap(err, "Could not detect runtime executable paths")
		}

		RTPATH := strings.Join(rtDirs, string(os.PathListSeparator))

		// Report recursive execution of executor: The path for the executable should be different from the default bin dir
		exesOnPath := osutils.FilterExesOnPATH(args[0], RTPATH, func(exe string) bool {
			v, err := executors.IsExecutor(exe)
			if err != nil {
				logging.Error("Could not find out if executable is an executor: %s", errs.JoinMessage(err))
				return true // This usually means there's a permission issue, which means we likely don't own it
			}
			return !v
		})

		if len(exesOnPath) > 0 {
			exeTarget = exesOnPath[0]
		}
	}

	// Guard against invoking the executor from PATH (ie. by name alone)
	if os.Getenv(constants.ExecRecursionAllowEnvVarName) != "true" && filepath.Base(exeTarget) == exeTarget { // not a full path
		exe := osutils.FindExeInside(exeTarget, env["PATH"])
		if exe != exeTarget { // Found the exe name on our PATH
			isExec, err := executors.IsExecutor(exe)
			if err != nil {
				logging.Error("Could not find out if executable is an executor: %s", errs.JoinMessage(err))
			} else if isExec {
				// If the exe we resolve to is an executor then we have ourselves a recursive loop
				return locale.NewError("err_exec_recursion", "", constants.ForumsURL, constants.ExecRecursionAllowEnvVarName)
			}
		}
	}

	err = s.subshell.SetEnv(env)
	if err != nil {
		return locale.WrapError(err, "err_subshell_setenv")
	}

	lang := language.Bash
	scriptArgs := fmt.Sprintf(`%q "$@"`, exeTarget)
	if strings.Contains(s.subshell.Binary(), "cmd") {
		lang = language.PowerShell
		scriptArgs = fmt.Sprintf("& %q @args\nexit $LASTEXITCODE", exeTarget)
	}

	sf, err := scriptfile.New(lang, "state-exec", scriptArgs)
	if err != nil {
		return locale.WrapError(err, "err_exec_create_scriptfile", "Could not generate script")
	}
	defer sf.Clean()

	return s.subshell.Run(sf.Filename(), args[1:]...)
}

func projectFromRuntimeDir(cfg projectfile.ConfigGetter, runtimeDir string) string {
	projects := projectfile.GetProjectMapping(cfg)
	for _, paths := range projects {
		for _, p := range paths {
			targetBase := hash.ShortHash(p)
			if filepath.Base(runtimeDir) == targetBase {
				return p
			}
		}
	}

	return ""
}

func handleRecursion(env map[string]string, args []string) error {
	recursionReadable := []string{}
	recursionReadableFull := os.Getenv(constants.ExecRecursionEnvVarName)
	if recursionReadableFull == "" {
		recursionReadable = append(recursionReadable, getParentProcessArgs())
	} else {
		recursionReadable = strings.Split(recursionReadableFull, "\n")
	}
	recursionReadable = append(recursionReadable, filepath.Base(os.Args[0])+" "+strings.Join(os.Args[1:], " "))
	var recursionLvl int64
	lastLvl, err := strconv.ParseInt(os.Getenv(constants.ExecRecursionLevelEnvVarName), 10, 32)
	if err == nil {
		recursionLvl = lastLvl + 1
	}
	maxLevel, err := strconv.ParseInt(os.Getenv(constants.ExecRecursionMaxLevelEnvVarName), 10, 32)
	if err == nil || maxLevel == 0 {
		maxLevel = 10
	}
	if recursionLvl == 2 || recursionLvl == 10 || recursionLvl == 50 {
		multilog.Error("executor recursion detected: parent %s (%d): %s (lvl=%d)", getParentProcessArgs(), os.Getppid(), strings.Join(args, " "), recursionLvl)
	}
	if recursionLvl >= maxLevel {
		return locale.NewError("err_recursion_limit", "", strings.Join(recursionReadable, "\n"), constants.ExecRecursionMaxLevelEnvVarName)
	}

	env[constants.ExecRecursionLevelEnvVarName] = fmt.Sprintf("%d", recursionLvl)
	env[constants.ExecRecursionMaxLevelEnvVarName] = fmt.Sprintf("%d", maxLevel)
	env[constants.ExecRecursionEnvVarName] = strings.Join(recursionReadable, "\n")
	return nil
}

func getParentProcessArgs() string {
	p, err := process.NewProcess(int32(os.Getppid()))
	if err != nil {
		logging.Debug("Could not find parent process of executor: %v", err)
		return "unknown"
	}

	args, err := p.CmdlineSlice()
	if err != nil {
		logging.Debug("Could not retrieve command line arguments of executor's calling process: %v", err)
		return "unknown"
	}

	return strings.Join(args, " ")
}