@platforma-sdk/workflow-tengo 2.8.1 → 2.8.2

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

@@ -1,6 +1,5 @@
-/**
- * A builder for executing commands.
- */
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
@@ -21,719 +20,653 @@ _MEDIUM_QUEUE   := "medium"
 _LIGHT_QUEUE    := "light"
 _UI_TASKS_QUEUE := "ui-tasks"
 
-/**
- * Creates a new builder for constructing and executing commands.
- *
- * @return builder - a new builder instance.
- */
+
+
+
+
 builder := func() {
-	self := undefined
-
-	soft := undefined
-	cmd := undefined
-	args := []
-	entrypointSet := false
-
-	assertEntrypointNotSet := func() {
-		ll.assert(!entrypointSet,
-			"either a command with arguments or a software were already set.")
-	}
-
-	envs := {}
-	secrets := {} // { "env_name": "{secrets.secret_name}", ... }
-	queue := _HEAVY_QUEUE
-	cache := 0
-	nErrorLines := 200
-
-	// files to be added in workdir
-	filesToAdd := {}
-	// files to be created in the workdir with the content from resources
-	filesToWrite := {}
-	// directories to create in the workdir
-	dirsToCreate := {}
-
-	// files to save from the workdir
-	filesToSave := {}
-	// files which content to save from the workdir
-	filesContentToSave := {}
-	// file sets to save by regex
-	fileSetsToSave := {}
-	// file sets to save by regex (save file content)
-	fileSetsContentToSave := {}
-	// files to stream from the workdir
-	filesToStream := {}
-	// workdir processors
-	wdProcessors := {}
-
-	// assets to be extracted into workdir before execution
-	assetInfos := {}
-	assetDescriptors := {}
-	assetRules := {}
-	assetCache := {}
-
-	stdout := "stdout.txt"
-	stderr := "stderr.txt"
-
-	stdoutToValue := false
-	stderrToValue := false
-	stderrToStdout := false
-
-	self = ll.toStrict({
-		/**
-		 * Sets the command to be executed, e.g. /usr/bin/env or sh.
-		 *
-		 * @param commandName: string - the name of the command.
-		 */
-		cmd: func(commandName) {
-			assertEntrypointNotSet()
-
-			cmd = commandName
-			entrypointSet = true
-			return self
-		},
-
-		/**
-		 * Sets the software to be executed.
-		 *
-		 * @param software: softwareInfo - the software to execute.
-		 */
-		software: func(sw) {
-			assertEntrypointNotSet()
-			ll.assert(assets.isSoftwareInfo(sw),
-				"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from assets.importSoftware() here"
-			)
-
-			soft = sw
-			entrypointSet = true
-			return self
-		},
-
-		/**
-		 * Adds an argument to the command.
-		 *
-		 * @param arg: string - the argument to add.
-		 */
-		arg: func(arg) {
-			if is_undefined(arg) {
-				ll.panic("exec: arg can't be undefined")
-			}
-			args = append(args, arg)
-			return self
-		},
-
-		/**
-		 * Sets an environment variable.
-		 *
-		 * @param name: string - the name of the environment variable.
-		 * @param value: string - the value of the environment variable.
-		 */
-		env: func(name, value) {
-			validation.assertJsonSchema([name, value], ["string"])
-			envs[name] = value
-			return self
-		},
-
-		/**
-		 * Sets multiple environment variables.
-		 *
-		 * @param envMap: map[string]string - a map of environment variables.
-		 */
-		envMap: func(envMap) {
-			enum.each(envMap, self.env)
-			return self
-		},
-
-		/**
-		 * Set environment variable to value of given secret.
-		 *
-		 * @param secretName: string - name of secret to pass as environment variable.
-		 * @param envName: string - name of environment variable to set with value of secret.
-		 */
-		secret: func(secretName, envName) {
-			validation.assertJsonSchema([secretName, envName], ["string"])
-			secrets[envName] = "{secrets."+secretName+"}"
-			return self
-		},
-
-		/**
-		 * Execute command in the 'heavy' queue.
-		 */
-		inHeavyQueue: func() {
-			queue = _HEAVY_QUEUE
-			return self
-		},
-
-		/**
-		 * Execute command in the 'medium' queue.
-		 */
-		inMediumQueue: func() {
-			queue = _MEDIUM_QUEUE
-			return self
-		},
-
-		/**
-		 * Execute command in the 'light' queue.
-		 */
-		inLightQueue: func() {
-			queue = _LIGHT_QUEUE
-			return self
-		},
-
-		/**
-		 * Execute command in the 'ui-tasks' queue.
-		 */
-		inUiQueue: func() {
-			queue = _UI_TASKS_QUEUE
-			return self
-		},
-
-		/**
-		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
-		 * Sets the cache time.
-		 *
-		 * @param time: duration - the cache time from 'times' library.
-		 */
-		cache: func(time) {
-			ll.assert(
-				is_int(time),
-				"cache time must be an integer. " +
-					"Did you forget to import a standard tengo library 'times'?")
-			cache = time
-			return self
-		},
-
-		/**
-		 * Sets the cache time in milliseconds.
-		 *
-		 * @param millis: number
-		 */
-		cacheMillis: func(millis) {
-			ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
-			cache = millis * times.millisecond
-			return self
-		},
-
-		/**
-		 * Sets the cache time in seconds.
-		 *
-		 * @param seconds: number
-		 */
-		cacheSeconds: func(seconds) {
-			ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
-			cache = seconds * times.second
-			return self
-		},
-
-		/**
-		 * Sets the cache time in minutes.
-		 *
-		 * @param minutes: number
-		 */
-		cacheMinutes: func(minutes) {
-			ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
-			cache = minutes * times.minute
-			return self
-		},
-
-		/**
-		 * Sets the cache time in hours.
-		 *
-		 * @param hours: number
-		 */
-		cacheHours: func(hours) {
-			ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
-			cache = hours * times.hour
-			return self
-		},
-
-		/**
-		 * Sets the cache time in days
-		 *
-		 * @param days: number
-		 */
-		cacheDays: func(days) {
-			ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
-			cache = days * times.hour * 24
-			return self
-		},
-
-		/**
-		 * Sets the number of error lines to be captured.
-		 *
-		 * @param lines: number - the number of error lines.
-		 */
-		nErrorLines: func(lines) {
-			ll.assert(
-				is_int(lines) && lines >= 0,
-				"lines must be integer")
-
-			nErrorLines = lines
-			return self
-		},
-
-		/**
-		 * Adds files from given asset into working directory.
-		 *
-		 * @param asset: assetInfo - asset info loaded from assets.importAsset()
-		 * @param destinationDir: string - path inside working directory for files to be extracted from archive. Use "." for root of the workdir.
-		 * @param pathsInArchive: string[] - paths inside the archive to be extracted into destinationDir.
-		 *                                   Empty array means 'unpack full archive'.
-		 */
-		addAsset: func(asset, destinationDir, ...pathsInArchive) {
-			if (len(pathsInArchive) == 1 && is_array(pathsInArchive[0])) {
-				// support [<paths>] single argument
-				pathsInArchive = pathsInArchive[0]
-			}
-			if len(pathsInArchive) == 0 {
-				// default for 'no paths' is to extract all
-				pathsInArchive = []
-			}
-
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.addAsset: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			validation.assertJsonSchema(destinationDir, "string", "exec.builder.addAsset: <destinationDir> is not a string. It must be a path inside working directory")
-			validation.assertJsonSchema(pathsInArchive, ["string"], "exec.builder.addAsset: <pathsInArchive> must contain list of strings with paths inside archive")
-
-			assetIdKey := ll.idToString(asset._id)
-			if is_undefined(assetRules[assetIdKey]) {
-				assetInfos[assetIdKey] = asset.resource
-				assetDescriptors[assetIdKey] = ll.fromStrict(asset.descriptor)
-				assetRules[assetIdKey] = {}
-			}
-
-			if len(pathsInArchive) == 0 || is_undefined(assetRules[assetIdKey][destinationDir]) {
-				assetRules[assetIdKey][destinationDir] = []
-			}
-
-			if (len(pathsInArchive) > 0) {
-				assetRules[assetIdKey][destinationDir] = append(assetRules[assetIdKey][destinationDir], pathsInArchive...)
-			}
-
-			return self
-		},
-
-		/**
-		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
-		 * This allows to customize cache time on per-asset basis
-		 */
-		cacheAssetMillis: func (asset, millis) {
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.cacheAssetMillis: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			ll.assert(is_int(millis),
-				"exec.builder.cacheAssetMillis: asset cache time must be a number of milliseconds.")
-
-			assetIdKey := ll.idToString(asset._id)
-			assetCache[assetIdKey] = millis * times.millisecond
-
-			return self
-		},
-
-		/**
-		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
-		 * This allows to customize cache time on per-asset basis
-		 */
-		cacheAssetSeconds: func (asset, seconds) {
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.cacheAssetSeconds: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			ll.assert(is_int(seconds),
-				"exec.builder.cacheAssetSeconds: asset cache time must be a number of seconds.")
-
-			assetIdKey := ll.idToString(asset._id)
-			assetCache[assetIdKey] = seconds * times.second
-
-			return self
-		},
-
-		/**
-		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
-		 * This allows to customize cache time on per-asset basis
-		 */
-		cacheAssetMinutes: func (asset, minutes) {
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.cacheAssetMinutes: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			ll.assert(is_int(minutes),
-				"exec.builder.cacheAssetMinutes: asset cache time must be a number of minutes.")
-
-			assetIdKey := ll.idToString(asset._id)
-			assetCache[assetIdKey] = minutes * times.minute
-
-			return self
-		},
-
-		/**
-		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
-		 * This allows to customize cache time on per-asset basis
-		 */
-		cacheAssetHours: func (asset, hours) {
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			ll.assert(is_int(hours),
-				"exec.builder.cacheAssetHours: asset cache time must be a number of hours.")
-
-			assetIdKey := ll.idToString(asset._id)
-			assetCache[assetIdKey] = hours * times.hour
-
-			return self
-		},
-
-		/**
-		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
-		 * This allows to customize cache time on per-asset basis
-		 */
-		cacheAssetDays: func (asset, days) {
-			ll.assert(assets.isAssetInfo(asset),
-				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-			ll.assert(is_int(days),
-				"exec.builder.cacheAssetHours: asset cache time must be a number of days.")
-
-			assetIdKey := ll.idToString(asset._id)
-			assetCache[assetIdKey] = days * 24 * times.hour
-
-			return self
-		},
-
-		/**
-		 * Adds a file to the working directory
-		 *
-		 * @param fileName: string - the name of the input file.
-		 * @param file: reference - a resource id of the file or a field that points to it.
-		 */
-		addFile: func(fileName, file) {
-			fileName = path.canonize(fileName)
-			filesToAdd[fileName] = file
-			return self
-		},
-
-		/**
-		 * Adds multiple files to the working directory.
-		 *
-		 * @param filesMap: map[string]reference - a map of file names to files' references.
-		 */
-		addFiles: func(filesMap) {
-			enum.each(filesMap, self.addFile)
-			return self
-		},
-
-		/**
-		 * Writes a file with a given content.
-		 *
-		 * @param fileName: string - the name of the content.
-		 * @param data: bytes|reference - a primitive tengo value (map or array) or a reference to
-		 *        a resource from which data we create a file.
-		 */
-		writeFile: func(fileName, data) {
-			validation.assertJsonSchema(data, ["or",
-				"string",
-				"bytes",
-				validation.reference])
-
-			fileName = path.canonize(fileName)
-
-			filesToWrite[fileName] = data
-
-			return self
-		},
-
-		/**
-		 * Creates a directory.
-		 *
-		 * @param dir: string - the directory to create.
-		 */
-		mkDir: func(dir) {
-			dir = path.canonize(dir)
-			dirsToCreate = sets.add(dirsToCreate, dir)
-			return self
-		},
-
-		/**
-		 * Saves a file.
-		 *
-		 * @param fileName: string - the name of the output file.
-		 */
-		saveFile: func(fileName) {
-			fileName = path.canonize(fileName)
-			sets.add(filesToSave, fileName)
-			return self
-		},
-
-		/**
-		 * Saves a file's content to a value resource.
-		 *
-		 * @param fileName: string - the name of the output value.
-		 */
-		saveFileContent: func(fileName) {
-			fileName = path.canonize(fileName)
-			sets.add(filesContentToSave, fileName)
-			return self
-		},
-
-		/**
-		 * Saves files from the exec workdir using regex.
-		 *
-		 * @param name: string - a name to refer this file set in the outputs
-		 * @param regex: string - regex pattern
-		 */
-		saveFileSet: func(name, regex) {
-			fileSetsToSave[name] = regex
-			return self
-		},
-
-		/**
-		 * Run specified
-		 */
-		processWorkdir: func(name, tpl, tplArgs) {
-			wdProcessors[name] = {
-				tpl: tpl,
-				tplArgs: tplArgs
-			}
-			return self
-		},
-
-		/**
-		 * Saves files content from the exec workdir using regex.
-		 *
-		 * @param name: string - a name to refer this file set in the outputs
-		 * @param regex: string - regex pattern
-		 */
-		saveFileSetContent: func(name, regex) {
-			fileSetsContentToSave[name] = regex
-			return self
-		},
-
-		/**
-		 * A command to stream a file by a given file name.
-		 *
-		 * @param fileName: string - the name of the file to stream.
-		 */
-		streamFile: func(fileName) {
-			fileName = path.canonize(fileName)
-			sets.add(filesToStream, fileName)
-
-			return self
-		},
-
-		/**
-		 * Set stdout file name
-		 */
-		stdoutFileName: func(fileName) {
-			fileName = path.canonize(fileName)
-			stdout = fileName
-			return self
-		},
-
-		/**
-		 * Set stderr file name
-		 */
-		stderrFileName: func(fileName) {
-			fileName = path.canonize(fileName)
-			stderr = fileName
-			return self
-		},
-
-		/**
-		 * Sets stdout to be captured as a value resource.
-		 */
-		saveStdoutContent: func() {
-			stdoutToValue = true
-			return self
-		},
-
-		/**
-		 * Sets stderr to be captured as a value resource.
-		 */
-		saveStderrContent: func() {
-			stderrToValue = true
-			return self
-		},
-
-		/**
-		 * Redirects stderr output to stdout.
-		 */
-		printErrStreamToStdout: func() {
-			stderrToStdout = true
-			return self
-		},
-
-		/**
-		 * Executes the command.
-		 *
-		 * @return A map containing the execution results.
-		 */
-		run: func() {
-			if stderrToStdout {
-				stderr = stdout
-			}
-			sets.add(filesToStream, stdout)
-			sets.add(filesToStream, stderr)
-			sets.add(filesToSave, stdout)
-			sets.add(filesToSave, stderr)
-			if stdoutToValue {
-				sets.add(filesContentToSave, stdout)
-			}
-			if stderrToValue {
-				sets.add(filesContentToSave, stderr)
-			}
-
-			// We don't want these values to be encoded as JSON's since
-			// values are pure bytes.
-			// Thus, we create a resource with a custom type here manually.
-			filesToWriteRefs := maps.mapValues(filesToWrite, func(v) {
-				if smart.isReference(v) { return v }
-				return smart.createValueResource(constants.RTYPE_BINARY_VALUE, v)
-			})
-
-			ll.assert(entrypointSet,
-				"incomplete command: cmd() or software() must be provided to exec.builder")
-
-			execInputs := {
-				filesToAdd: smart.createMapResource(filesToAdd),
-				filesToWrite: smart.createMapResource(filesToWriteRefs),
-				dirsToCreate: slices.fromSet(dirsToCreate),
-				runOptions: {
-					cmd: cmd,
-					args: args,
-					envs: envs,
-					secrets: secrets,
-					queue: queue,
-					stdout: stdout,
-					stderr: stderr,
-					nErrorLines: nErrorLines
-				},
-				filesToSave: slices.fromSet(filesToSave),
-				filesContentToSave: slices.fromSet(filesContentToSave),
-				fileSetsToSave: fileSetsToSave,
-				fileSetsContentToSave: fileSetsContentToSave,
-				filesToStream: slices.fromSet(filesToStream),
-				wdProcessors: wdProcessors,
-				assets: smart.createMapResource(assetInfos),
-				assetDescriptors: assetDescriptors,
-				assetRules: assetRules,
-				assetCache: assetCache
-			}
-
-			if !is_undefined(soft) {
-				execInputs.softwareInfo = soft.resource
-				execInputs.runOptions.software = {
-					name: soft.name,
-					version: soft.version,
-					descriptor: ll.fromStrict(soft.descriptor)
-				}
-			}
-
-			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.exec"), execInputs)
-
-			self := undefined
-			self = ll.toStrict(oop.inherit(tpl, {
-				/**
-				 * Retrieves a file.
-				 *
-				 * @param fileName: string
-				 * @return field - a reference to the file resource.
-				 */
-				getFile: func(fileName) {
-					return tpl.output("files", cache).getFutureInputField(fileName)
-				},
-
-				/**
-				 * Retrieves the content of a file.
-				 *
-				 * @param fileName: string
-				 * @return field - a reference to the file content resource.
-				 */
-				getFileContent: func(fileName) {
-					return tpl.output("filesContent", cache).getFutureInputField(fileName)
-				},
-
-				/**
-				 * Retrieves a file stream.
-				 *
-				 * @param fileName: string
-				 * @return field - a reference to the file stream resource.
-				 */
-				getFileStream: func(fileName) {
-					return tpl.output("fileStreams", cache).getFutureInputField(fileName, true)
-				},
-
-				/**
-				 * Retrieves a file set resource.
-				 *
-				 * @param fileSetName: string - name of a file set
-				 * @return field - a reference to the map resource with files
-				 */
-				getFileSet: func(fileSetName) {
-					return tpl.output("fileSets", cache).getFutureInputField(fileSetName)
-				},
-
-				/**
-				 * Retrieves a file set content resource.
-				 *
-				 * @param fileSetName: string - name of a file set
-				 * @return field - a reference to the map resource with files
-				 */
-				getFileSetContent: func(fileSetName) {
-					return tpl.output("fileSetsContent", cache).getFutureInputField(fileSetName)
-				},
-
-				getProcessorResult: func(procName) {
-					return tpl.output("wdProcessors", cache).getFutureInputField(procName)
-				},
-
-				/**
-				 * Retrieves the stdout stream.
-				 */
-				getStdoutStream: func() {
-					return self.getFileStream(stdout)
-				},
-
-				/**
-				 * Retrieves the stderr stream.
-				 */
-				getStderrStream: func() {
-					return self.getFileStream(stderr)
-				},
-
-				/**
-				 * Retrieves the stdout file.
-				 */
-				getStdoutFile: func() {
-					return self.getFile(stdout)
-				},
-
-				/**
-				 * Retrieves the stderr file.
-				 */
-				getStderrFile: func() {
-					return self.getFile(stderr)
-				},
-
-				/**
-				 * Retrieves the content of the stdout file.
-				 */
-				getStdoutFileContent: func() {
-					if stdoutToValue {
-						return self.getFileContent(stdout)
-					}
-					ll.panic("stdout was not saved as a content")
-				},
-
-				/**
-				 * Retrieves the content of the stderr file.
-				 */
-				getStderrFileContent: func() {
-					if stderrToValue {
-						return self.getFileContent(stderr)
-					}
-					ll.panic("stderr was not saved as a content")
-				}
-			}))
-
-			return self
-		}
-	})
-
-	return self
+self := undefined
+
+soft := undefined
+cmd := undefined
+args := []
+entrypointSet := false
+
+assertEntrypointNotSet := func() {
+ll.assert(!entrypointSet,
+"either a command with arguments or a software were already set.")
+}
+
+envs := {}
+secrets := {} // { "env_name": "{secrets.secret_name}", ... }
+queue := _HEAVY_QUEUE
+cache := 0
+nErrorLines := 200
+
+filesToAdd := {}
+filesToWrite := {}
+dirsToCreate := {}
+
+filesToSave := {}
+filesContentToSave := {}
+fileSetsToSave := {}
+fileSetsContentToSave := {}
+filesToStream := {}
+wdProcessors := {}
+
+assetInfos := {}
+assetDescriptors := {}
+assetRules := {}
+assetCache := {}
+
+stdout := "stdout.txt"
+stderr := "stderr.txt"
+
+stdoutToValue := false
+stderrToValue := false
+stderrToStdout := false
+
+self = ll.toStrict({
+
+
+
+
+cmd: func(commandName) {
+assertEntrypointNotSet()
+
+cmd = commandName
+entrypointSet = true
+return self
+},
+
+
+
+
+
+software: func(sw) {
+assertEntrypointNotSet()
+ll.assert(assets.isSoftwareInfo(sw),
+"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from assets.importSoftware() here"
+)
+
+soft = sw
+entrypointSet = true
+return self
+},
+
+
+
+
+
+arg: func(arg) {
+if is_undefined(arg) {
+ll.panic("exec: arg can't be undefined")
+}
+args = append(args, arg)
+return self
+},
+
+
+
+
+
+
+env: func(name, value) {
+validation.assertJsonSchema([name, value], ["string"])
+envs[name] = value
+return self
+},
+
+
+
+
+
+envMap: func(envMap) {
+enum.each(envMap, self.env)
+return self
+},
+
+
+
+
+
+
+secret: func(secretName, envName) {
+validation.assertJsonSchema([secretName, envName], ["string"])
+secrets[envName] = "{secrets."+secretName+"}"
+return self
+},
+
+
+
+inHeavyQueue: func() {
+queue = _HEAVY_QUEUE
+return self
+},
+
+
+
+inMediumQueue: func() {
+queue = _MEDIUM_QUEUE
+return self
+},
+
+
+
+inLightQueue: func() {
+queue = _LIGHT_QUEUE
+return self
+},
+
+
+
+inUiQueue: func() {
+queue = _UI_TASKS_QUEUE
+return self
+},
+
+
+
+
+
+
+cache: func(time) {
+ll.assert(
+is_int(time),
+"cache time must be an integer. " +
+"Did you forget to import a standard tengo library 'times'?")
+cache = time
+return self
+},
+
+
+
+
+
+cacheMillis: func(millis) {
+ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
+cache = millis * times.millisecond
+return self
+},
+
+
+
+
+
+cacheSeconds: func(seconds) {
+ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
+cache = seconds * times.second
+return self
+},
+
+
+
+
+
+cacheMinutes: func(minutes) {
+ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
+cache = minutes * times.minute
+return self
+},
+
+
+
+
+
+cacheHours: func(hours) {
+ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
+cache = hours * times.hour
+return self
+},
+
+
+
+
+
+cacheDays: func(days) {
+ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
+cache = days * times.hour * 24
+return self
+},
+
+
+
+
+
+nErrorLines: func(lines) {
+ll.assert(
+is_int(lines) && lines >= 0,
+"lines must be integer")
+
+nErrorLines = lines
+return self
+},
+
+
+
+
+
+
+
+
+addAsset: func(asset, destinationDir, ...pathsInArchive) {
+if (len(pathsInArchive) == 1 && is_array(pathsInArchive[0])) {
+pathsInArchive = pathsInArchive[0]
+}
+if len(pathsInArchive) == 0 {
+pathsInArchive = []
+}
+
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.addAsset: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+validation.assertJsonSchema(destinationDir, "string", "exec.builder.addAsset: <destinationDir> is not a string. It must be a path inside working directory")
+validation.assertJsonSchema(pathsInArchive, ["string"], "exec.builder.addAsset: <pathsInArchive> must contain list of strings with paths inside archive")
+
+assetIdKey := ll.idToString(asset._id)
+if is_undefined(assetRules[assetIdKey]) {
+assetInfos[assetIdKey] = asset.resource
+assetDescriptors[assetIdKey] = ll.fromStrict(asset.descriptor)
+assetRules[assetIdKey] = {}
+}
+
+if len(pathsInArchive) == 0 || is_undefined(assetRules[assetIdKey][destinationDir]) {
+assetRules[assetIdKey][destinationDir] = []
+}
+
+if (len(pathsInArchive) > 0) {
+assetRules[assetIdKey][destinationDir] = append(assetRules[assetIdKey][destinationDir], pathsInArchive...)
+}
+
+return self
+},
+
+
+
+
+cacheAssetMillis: func (asset, millis) {
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.cacheAssetMillis: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+ll.assert(is_int(millis),
+"exec.builder.cacheAssetMillis: asset cache time must be a number of milliseconds.")
+
+assetIdKey := ll.idToString(asset._id)
+assetCache[assetIdKey] = millis * times.millisecond
+
+return self
+},
+
+
+
+
+cacheAssetSeconds: func (asset, seconds) {
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.cacheAssetSeconds: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+ll.assert(is_int(seconds),
+"exec.builder.cacheAssetSeconds: asset cache time must be a number of seconds.")
+
+assetIdKey := ll.idToString(asset._id)
+assetCache[assetIdKey] = seconds * times.second
+
+return self
+},
+
+
+
+
+cacheAssetMinutes: func (asset, minutes) {
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.cacheAssetMinutes: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+ll.assert(is_int(minutes),
+"exec.builder.cacheAssetMinutes: asset cache time must be a number of minutes.")
+
+assetIdKey := ll.idToString(asset._id)
+assetCache[assetIdKey] = minutes * times.minute
+
+return self
+},
+
+
+
+
+cacheAssetHours: func (asset, hours) {
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+ll.assert(is_int(hours),
+"exec.builder.cacheAssetHours: asset cache time must be a number of hours.")
+
+assetIdKey := ll.idToString(asset._id)
+assetCache[assetIdKey] = hours * times.hour
+
+return self
+},
+
+
+
+
+cacheAssetDays: func (asset, days) {
+ll.assert(assets.isAssetInfo(asset),
+"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+ll.assert(is_int(days),
+"exec.builder.cacheAssetHours: asset cache time must be a number of days.")
+
+assetIdKey := ll.idToString(asset._id)
+assetCache[assetIdKey] = days * 24 * times.hour
+
+return self
+},
+
+
+
+
+
+
+addFile: func(fileName, file) {
+fileName = path.canonize(fileName)
+filesToAdd[fileName] = file
+return self
+},
+
+
+
+
+
+addFiles: func(filesMap) {
+enum.each(filesMap, self.addFile)
+return self
+},
+
+
+
+
+
+
+
+writeFile: func(fileName, data) {
+validation.assertJsonSchema(data, ["or",
+"string",
+"bytes",
+validation.reference])
+
+fileName = path.canonize(fileName)
+
+filesToWrite[fileName] = data
+
+return self
+},
+
+
+
+
+
+mkDir: func(dir) {
+dir = path.canonize(dir)
+dirsToCreate = sets.add(dirsToCreate, dir)
+return self
+},
+
+
+
+
+
+saveFile: func(fileName) {
+fileName = path.canonize(fileName)
+sets.add(filesToSave, fileName)
+return self
+},
+
+
+
+
+
+saveFileContent: func(fileName) {
+fileName = path.canonize(fileName)
+sets.add(filesContentToSave, fileName)
+return self
+},
+
+
+
+
+
+
+saveFileSet: func(name, regex) {
+fileSetsToSave[name] = regex
+return self
+},
+
+
+
+processWorkdir: func(name, tpl, tplArgs) {
+wdProcessors[name] = {
+tpl: tpl,
+tplArgs: tplArgs
+}
+return self
+},
+
+
+
+
+
+
+saveFileSetContent: func(name, regex) {
+fileSetsContentToSave[name] = regex
+return self
+},
+
+
+
+
+
+streamFile: func(fileName) {
+fileName = path.canonize(fileName)
+sets.add(filesToStream, fileName)
+
+return self
+},
+
+
+
+stdoutFileName: func(fileName) {
+fileName = path.canonize(fileName)
+stdout = fileName
+return self
+},
+
+
+
+stderrFileName: func(fileName) {
+fileName = path.canonize(fileName)
+stderr = fileName
+return self
+},
+
+
+
+saveStdoutContent: func() {
+stdoutToValue = true
+return self
+},
+
+
+
+saveStderrContent: func() {
+stderrToValue = true
+return self
+},
+
+
+
+printErrStreamToStdout: func() {
+stderrToStdout = true
+return self
+},
+
+
+
+
+
+run: func() {
+if stderrToStdout {
+stderr = stdout
+}
+sets.add(filesToStream, stdout)
+sets.add(filesToStream, stderr)
+sets.add(filesToSave, stdout)
+sets.add(filesToSave, stderr)
+if stdoutToValue {
+sets.add(filesContentToSave, stdout)
+}
+if stderrToValue {
+sets.add(filesContentToSave, stderr)
+}
+
+filesToWriteRefs := maps.mapValues(filesToWrite, func(v) {
+if smart.isReference(v) { return v }
+return smart.createValueResource(constants.RTYPE_BINARY_VALUE, v)
+})
+
+ll.assert(entrypointSet,
+"incomplete command: cmd() or software() must be provided to exec.builder")
+
+execInputs := {
+filesToAdd: smart.createMapResource(filesToAdd),
+filesToWrite: smart.createMapResource(filesToWriteRefs),
+dirsToCreate: slices.fromSet(dirsToCreate),
+runOptions: {
+cmd: cmd,
+args: args,
+envs: envs,
+secrets: secrets,
+queue: queue,
+stdout: stdout,
+stderr: stderr,
+nErrorLines: nErrorLines
+},
+filesToSave: slices.fromSet(filesToSave),
+filesContentToSave: slices.fromSet(filesContentToSave),
+fileSetsToSave: fileSetsToSave,
+fileSetsContentToSave: fileSetsContentToSave,
+filesToStream: slices.fromSet(filesToStream),
+wdProcessors: wdProcessors,
+assets: smart.createMapResource(assetInfos),
+assetDescriptors: assetDescriptors,
+assetRules: assetRules,
+assetCache: assetCache
+}
+
+if !is_undefined(soft) {
+execInputs.softwareInfo = soft.resource
+execInputs.runOptions.software = {
+name: soft.name,
+version: soft.version,
+descriptor: ll.fromStrict(soft.descriptor)
+}
+}
+
+tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.exec"), execInputs)
+
+self := undefined
+self = ll.toStrict(oop.inherit(tpl, {
+
+
+
+
+
+getFile: func(fileName) {
+return tpl.output("files", cache).getFutureInputField(fileName)
+},
+
+
+
+
+
+
+getFileContent: func(fileName) {
+return tpl.output("filesContent", cache).getFutureInputField(fileName)
+},
+
+
+
+
+
+
+getFileStream: func(fileName) {
+return tpl.output("fileStreams", cache).getFutureInputField(fileName, true)
+},
+
+
+
+
+
+
+getFileSet: func(fileSetName) {
+return tpl.output("fileSets", cache).getFutureInputField(fileSetName)
+},
+
+
+
+
+
+
+getFileSetContent: func(fileSetName) {
+return tpl.output("fileSetsContent", cache).getFutureInputField(fileSetName)
+},
+
+getProcessorResult: func(procName) {
+return tpl.output("wdProcessors", cache).getFutureInputField(procName)
+},
+
+
+
+getStdoutStream: func() {
+return self.getFileStream(stdout)
+},
+
+
+
+getStderrStream: func() {
+return self.getFileStream(stderr)
+},
+
+
+
+getStdoutFile: func() {
+return self.getFile(stdout)
+},
+
+
+
+getStderrFile: func() {
+return self.getFile(stderr)
+},
+
+
+
+getStdoutFileContent: func() {
+if stdoutToValue {
+return self.getFileContent(stdout)
+}
+ll.panic("stdout was not saved as a content")
+},
+
+
+
+getStderrFileContent: func() {
+if stderrToValue {
+return self.getFileContent(stderr)
+}
+ll.panic("stderr was not saved as a content")
+}
+}))
+
+return self
+}
+})
+
+return self
 }
 
 export ll.toStrict({
-	builder: builder
+builder: builder
 })