@platforma-sdk/workflow-tengo 2.8.0 → 2.8.2

package/dist/tengo/lib/exec.internal.lib.tengo

@@ -1,9 +1,8 @@
-/**
- * Internal 'exec' module library.
- *
- * NOT INTENDEND FOR USE OUTSIDE 'exec' MODULE.
- * May completely change API from release to release.
- */
+
+
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 json := import("json")
@@ -17,318 +16,307 @@ runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 python := import("@platforma-sdk/workflow-tengo:exec.python")
 R := import("@platforma-sdk/workflow-tengo:exec.R")
 
-// Variables, substituted in command arguments and environment variable values
 _ARG_VAR_PKG            := "{pkg}"  // abs path to software package
 _ARG_VAR_JAVA           := "{java}" // abs path to 'java' run environment
 _ARG_VAR_PYTHON         := "{python}" // abs path to 'python' run environment
 _ARG_VAR_R              := "{R}" // abs path to 'R' run environment runtime
 _ARG_VAR_R_VENV         := "{rVenv}" // abs path to 'R' portable virtual environment
 
-/**
- * Create new argument marking it as 'with' or 'without' variables inside.
- * The outcome of 'hasVariables' flag value is wether the value will be treated
- * by Platforma Backend on server side before being given to the actual command.
- */
+
+
+
+
 _newArg := func(hasVariables, value) {
-	return ll.toStrict({
-		hasVars: hasVariables,
-		value: value
-	})
+return ll.toStrict({
+hasVars: hasVariables,
+value: value
+})
 }
 
 _newRefVar := func(varName, refName, reference) {
-	return ll.toStrict({
-		varName: varName,
-		refName: refName,
-		reference: reference
-	})
+return ll.toStrict({
+varName: varName,
+refName: refName,
+reference: reference
+})
 }
 
 _installSoftware := func(registry, pkgName) {
-	archive := pkg.get(registry, pkgName).archive()
-	return pkg.install(archive).package()
+archive := pkg.get(registry, pkgName).archive()
+return pkg.install(archive).package()
 }
 
 _directCallOptions := func(runOptions) {
-	cmd := _newArg(false, runOptions.cmd)
-	args := []
-	envs := {}
+cmd := _newArg(false, runOptions.cmd)
+args := []
+envs := {}
 
-	for name, arg in runOptions.args {
-		args = append(args, _newArg(false, arg))
-	}
+for name, arg in runOptions.args {
+args = append(args, _newArg(false, arg))
+}
 
-	for name, val in runOptions.envs {
-		envs[name] = _newArg(false, val)
-	}
+for name, val in runOptions.envs {
+envs[name] = _newArg(false, val)
+}
 
-	return oop.inherit(runOptions, {
-		variables: [],
-		customPaths: [],
-		cmd: cmd,
-		args: args,
-		envs: envs
-	})
+return oop.inherit(runOptions, {
+variables: [],
+customPaths: [],
+cmd: cmd,
+args: args,
+envs: envs
+})
 }
 
 _loadJavaRunEnvironment := func(operationMode, descriptor) {
-	javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
-	javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
+javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
+javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
 
-	return ll.toStrict({
-		runEnvType: "java",
+return ll.toStrict({
+runEnvType: "java",
 
-		variables: [ javaRefVar ],
-		customPaths: [ _newArg(true, path.join(_ARG_VAR_JAVA, descriptor.runEnv.binDir)) ],
-		envs: {}
-	})
+variables: [ javaRefVar ],
+customPaths: [ _newArg(true, path.join(_ARG_VAR_JAVA, descriptor.runEnv.binDir)) ],
+envs: {}
+})
 }
 
 _loadPythonRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
-	venvBuilder := python.venvBuilder().
-		software(softPkg).
-		runEnvDescriptor(descriptor.runEnv).
-		dependencies(descriptor.dependencies)
+venvBuilder := python.venvBuilder().
+software(softPkg).
+runEnvDescriptor(descriptor.runEnv).
+dependencies(descriptor.dependencies)
 
-	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
-		venvBuilder.useToolset(descriptor.toolset)
-	}
+if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+venvBuilder.useToolset(descriptor.toolset)
+}
 
-	venv := venvBuilder.
-		cacheDays(7).
-		build().
-		venv()
+venv := venvBuilder.
+cacheDays(7).
+build().
+venv()
 
-	venvRoot := path.join(_ARG_VAR_PYTHON, "venv")
-	venvRefKey := softName + "/venv"
+venvRoot := path.join(_ARG_VAR_PYTHON, "venv")
+venvRefKey := softName + "/venv"
 
-	pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
+pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
 
-	return ll.toStrict({
-		runEnvType: "python",
+return ll.toStrict({
+runEnvType: "python",
 
-		variables: [ pythonRefVar ],
-		customPaths: [ _newArg(true, path.join(venvRoot, "bin")) ],
-		envs: {
-			"VIRTUAL_ENV": _newArg(true, venvRoot)
-		}
-	})
+variables: [ pythonRefVar ],
+customPaths: [ _newArg(true, path.join(venvRoot, "bin")) ],
+envs: {
+"VIRTUAL_ENV": _newArg(true, venvRoot)
+}
+})
 }
 
 _loadRRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
-	renvBuilder := R.rVenvBuilder().
-		operationMode(operationMode).
-		software(softPkg).
-		runEnvDescriptor(descriptor.runEnv).
-		dependencies(descriptor.dependencies)
-
-	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
-		renvBuilder.useToolset(descriptor.toolset)
-	}
+renvBuilder := R.rVenvBuilder().
+operationMode(operationMode).
+software(softPkg).
+runEnvDescriptor(descriptor.runEnv).
+dependencies(descriptor.dependencies)
+
+if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+renvBuilder.useToolset(descriptor.toolset)
+}
 
-	rRuntime := renvBuilder.
-		cacheDays(7).
-		build()
+rRuntime := renvBuilder.
+cacheDays(7).
+build()
 
-	rEnv := rRuntime.venv()
-	rPackage := rRuntime.R()
+rEnv := rRuntime.venv()
+rPackage := rRuntime.R()
 
-	rBinDir := path.join(_ARG_VAR_R, descriptor.runEnv.binDir)
+rBinDir := path.join(_ARG_VAR_R, descriptor.runEnv.binDir)
 
-	rRefKey := softName + "/R-runtime"
-	rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
+rRefKey := softName + "/R-runtime"
+rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
 
-	rEnvRefKey := softName + "/R-virtual-env"
-	rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
+rEnvRefKey := softName + "/R-virtual-env"
+rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
 
-	return ll.toStrict({
-		runEnvType: "R",
+return ll.toStrict({
+runEnvType: "R",
 
-		variables: [ rRefVar, rEnvRefVar ],
-		customPaths: [ _newArg(true, rBinDir) ],
-		envs: {
-			"R_HOME_DIR": _newArg(true, _ARG_VAR_R),
-			"RENV_PATHS_ROOT": _newArg(true, path.join(_ARG_VAR_R, "renv-root")),
-			"RENV_PATHS_RENV": _newArg(true, path.join(_ARG_VAR_R_VENV, "renv")),
-			"RENV_PATHS_LOCKFILE": _newArg(true, path.join(_ARG_VAR_PKG, descriptor.dependencies.lockFile)),
-			"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(false, "FALSE"),
-			"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(false, "FALSE")
-		}
-	})
+variables: [ rRefVar, rEnvRefVar ],
+customPaths: [ _newArg(true, rBinDir) ],
+envs: {
+"R_HOME_DIR": _newArg(true, _ARG_VAR_R),
+"RENV_PATHS_ROOT": _newArg(true, path.join(_ARG_VAR_R, "renv-root")),
+"RENV_PATHS_RENV": _newArg(true, path.join(_ARG_VAR_R_VENV, "renv")),
+"RENV_PATHS_LOCKFILE": _newArg(true, path.join(_ARG_VAR_PKG, descriptor.dependencies.lockFile)),
+"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(false, "FALSE"),
+"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(false, "FALSE")
+}
+})
 }
 
 
 _loadRunEnvironment := func(operationMode, descriptor, softName, softPackage) {
-	if descriptor.runEnv.type == "java" {
-		return _loadJavaRunEnvironment(operationMode, descriptor)
-	}
-	if descriptor.runEnv.type == "python" {
-		return _loadPythonRunEnvironment(operationMode, descriptor, softName, softPackage)
-	}
-	if descriptor.runEnv.type == "R" {
-		return _loadRRunEnvironment(operationMode, descriptor, softName, softPackage)
-	}
-
-	ll.panic("run environment type %q is not currently supported by workflow-sdk",	descriptor.runEnv.type)
-}
-
-/**
- * @param operationMode: 'remote' | 'dev-local'
- */
+if descriptor.runEnv.type == "java" {
+return _loadJavaRunEnvironment(operationMode, descriptor)
+}
+if descriptor.runEnv.type == "python" {
+return _loadPythonRunEnvironment(operationMode, descriptor, softName, softPackage)
+}
+if descriptor.runEnv.type == "R" {
+return _loadRRunEnvironment(operationMode, descriptor, softName, softPackage)
+}
+
+ll.panic("run environment type %q is not currently supported by workflow-sdk",	descriptor.runEnv.type)
+}
+
+
+
 _binPackageCallOptions := func(operationMode, runOptions, variables, descriptor, softPackage) {
-	customPaths := []
-	envs := ll.toStrict({})
-	args := []
-	runEnvType := "binary"
-
-	// Real command should be:
-	//   [<runEnv bin>] [<runEnv options>] [<entrypoint bin>] [<entrypoint options>] <cmd> <args>
-	if (maps.containsKey(descriptor, "runEnv")) {
-		runEnvInfo := _loadRunEnvironment(operationMode, descriptor, runOptions.software.name, softPackage)
-
-		runEnvType = runEnvInfo.runEnvType
-		if len(runEnvInfo.variables) > 0 {
-			variables = append(variables, runEnvInfo.variables...)
-		}
-		if len(runEnvInfo.customPaths) > 0 {
-			customPaths = append(customPaths, runEnvInfo.customPaths...)
-		}
-		if len(runEnvInfo.envs) > 0 {
-			for n, v in runEnvInfo.envs {
-				envs[n] = v
-			}
-		}
-	}
-
-	ll.assert(len(descriptor.cmd) != 0, "cannot render final command for software: empty 'cmd' in software descritor")
-
-	cmd := _newArg(true, descriptor.cmd[0])
-
-	for arg in splice(descriptor.cmd, 1) {
-		args = append(args, _newArg(true, arg))
-	}
-	for arg in runOptions.args {
-		args = append(args, _newArg(false, arg))
-	}
-
-	for name, val in runOptions.envs {
-		envs[name] = _newArg(false, val)
-	}
-
-	return oop.inherit(runOptions, {
-		runEnvType: runEnvType,
-		variables: variables,
-		customPaths: customPaths,
-		cmd: cmd,
-		args: args,
-		envs: envs
-	})
+customPaths := []
+envs := ll.toStrict({})
+args := []
+runEnvType := "binary"
+
+if (maps.containsKey(descriptor, "runEnv")) {
+runEnvInfo := _loadRunEnvironment(operationMode, descriptor, runOptions.software.name, softPackage)
+
+runEnvType = runEnvInfo.runEnvType
+if len(runEnvInfo.variables) > 0 {
+variables = append(variables, runEnvInfo.variables...)
+}
+if len(runEnvInfo.customPaths) > 0 {
+customPaths = append(customPaths, runEnvInfo.customPaths...)
+}
+if len(runEnvInfo.envs) > 0 {
+for n, v in runEnvInfo.envs {
+envs[n] = v
+}
+}
 }
 
-_devLocalPackageCallOptions := func(runOptions) {
-	software := runOptions.software
-	localDescriptor := software.descriptor.local
+ll.assert(len(descriptor.cmd) != 0, "cannot render final command for software: empty 'cmd' in software descritor")
 
-	softPackage := pkg.use({
-		hash: localDescriptor.hash,
-		path: localDescriptor.path,
-		descriptor: json.encode(ll.fromStrict(software.descriptor)),
-		origin: {
-			registry: "dev-local",
-			url: "file://" + localDescriptor.path,
-			packageName: software.descriptor.name
-		}
-	}).package()
+cmd := _newArg(true, descriptor.cmd[0])
 
-	variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+for arg in splice(descriptor.cmd, 1) {
+args = append(args, _newArg(true, arg))
+}
+for arg in runOptions.args {
+args = append(args, _newArg(false, arg))
+}
+
+for name, val in runOptions.envs {
+envs[name] = _newArg(false, val)
+}
 
-	return _binPackageCallOptions("dev-local", runOptions, variables, localDescriptor, softPackage)
+return oop.inherit(runOptions, {
+runEnvType: runEnvType,
+variables: variables,
+customPaths: customPaths,
+cmd: cmd,
+args: args,
+envs: envs
+})
+}
+
+_devLocalPackageCallOptions := func(runOptions) {
+software := runOptions.software
+localDescriptor := software.descriptor.local
+
+softPackage := pkg.use({
+hash: localDescriptor.hash,
+path: localDescriptor.path,
+descriptor: json.encode(ll.fromStrict(software.descriptor)),
+origin: {
+registry: "dev-local",
+url: "file://" + localDescriptor.path,
+packageName: software.descriptor.name
+}
+}).package()
+
+variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+
+return _binPackageCallOptions("dev-local", runOptions, variables, localDescriptor, softPackage)
 }
 
 _remotePackageCallOptions := func(runOptions) {
-	software := runOptions.software
-	binaryDescriptor := software.descriptor.binary
-	softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
+software := runOptions.software
+binaryDescriptor := software.descriptor.binary
+softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
 
-	variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
 
-	return _binPackageCallOptions("remote", runOptions, variables, binaryDescriptor, softPackage)
+return _binPackageCallOptions("remote", runOptions, variables, binaryDescriptor, softPackage)
 }
 
 binaryRunOptions := func(runOptions) {
-	if (is_undefined(ll.fromStrict(runOptions).software)) {
-		//
-		// Simple local command run, no software packages involved (backward compatibility)
-		//
-		return _directCallOptions(runOptions)
-	}
+if (is_undefined(ll.fromStrict(runOptions).software)) {
+return _directCallOptions(runOptions)
+}
 
-	software := runOptions.software
-	descriptor := software.descriptor
+software := runOptions.software
+descriptor := software.descriptor
 
-	if (maps.containsKey(descriptor, "local")) {
-		return _devLocalPackageCallOptions(runOptions)
-	}
+if (maps.containsKey(descriptor, "local")) {
+return _devLocalPackageCallOptions(runOptions)
+}
 
-	if (maps.containsKey(descriptor, "binary")) {
-		return _remotePackageCallOptions(runOptions)
-	}
+if (maps.containsKey(descriptor, "binary")) {
+return _remotePackageCallOptions(runOptions)
+}
 
-	ll.panic("Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor", software.name, software.version)
+ll.panic("Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor", software.name, software.version)
 }
 
 prepareCommandRun := func(wd, opts) {
-	runBuilder := runcmd.builder(wd)
+runBuilder := runcmd.builder(wd)
 
-	// Make installed packages to be available for the command run
-	for varInfo in opts.variables {
-		runBuilder.ref(varInfo.refName, varInfo.reference)
-		runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
-	}
+for varInfo in opts.variables {
+runBuilder.ref(varInfo.refName, varInfo.reference)
+runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
+}
 
-	// Patch command's PATH env variable
-	for p in opts.customPaths {
-		runBuilder.addToPath(p.value, p.hasVars)
-	}
+for p in opts.customPaths {
+runBuilder.addToPath(p.value, p.hasVars)
+}
 
-	// Configure environment variables required for correct command run environment setup
-	for name, value in opts.envs {
-		if value.hasVars {
-			runBuilder.envVar(name, value.value)
-		} else {
-			runBuilder.env(name, value.value)
-		}
-	}
+for name, value in opts.envs {
+if value.hasVars {
+runBuilder.envVar(name, value.value)
+} else {
+runBuilder.env(name, value.value)
+}
+}
 
-	return runBuilder
+return runBuilder
 }
 
 _activateRenv := func(wd, opts) {
-	activateRenv := prepareCommandRun(wd, opts)
-	activateRenv.
-		cmd("R").
-		arg("-e").arg("renv::activate()")
+activateRenv := prepareCommandRun(wd, opts)
+activateRenv.
+cmd("R").
+arg("-e").arg("renv::activate()")
 
-	activateRenvRun := activateRenv.build()
+activateRenvRun := activateRenv.build()
 
-	return activateRenvRun
+return activateRenvRun
 }
 
 prepareWDForRunEnvironment := func(wd, opts) {
-	if (!maps.containsKey(opts, "runEnvType")) {
-		return wd
-	}
+if (!maps.containsKey(opts, "runEnvType")) {
+return wd
+}
 
-	if (opts.runEnvType == "R") {
-		return _activateRenv(wd, opts).workdir
-	}
+if (opts.runEnvType == "R") {
+return _activateRenv(wd, opts).workdir
+}
 
-	return wd
+return wd
 }
 
 export {
-	binaryRunOptions			: binaryRunOptions,
+binaryRunOptions			: binaryRunOptions,
 
-	prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
-	prepareCommandRun			: prepareCommandRun
+prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
+prepareCommandRun			: prepareCommandRun
 }