@platforma-sdk/workflow-tengo 1.2.6

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

@@ -0,0 +1,296 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+workdir := import("@platforma-sdk/workflow-tengo:workdir")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+json := import("json")
+
+runEnvDescriptorScheme := {
+	registry: "string",
+	package: "string",
+	type: "string",
+	binDir: "string"
+}
+
+binaryDescriptorScheme := {
+	registry: "string",
+	package: "string",
+	cmd: ["string"],
+	runEnv: runEnvDescriptorScheme
+}
+
+localDescriptorScheme := {
+	hash: "string",
+	path: "string",
+	cmd: ["string"],
+	runEnv: runEnvDescriptorScheme
+}
+
+descriptorScheme := {
+	"isDev,omitempty": "bool",
+	"binary,omitempty": binaryDescriptorScheme,
+	"local,omitempty": localDescriptorScheme
+}
+
+softwareInfoScheme := {
+	"name": "string",
+	"version": "string",
+	"descriptor": descriptorScheme
+}
+
+META_KEY_DESCRIPTOR := "ctl/runner/package/descriptor"
+
+_RTYPE_PACKAGE_GET := { Name: "PackageGet", Version: "1" }
+_INPUT_PACKAGE_NAME := "packageName"
+_INPUT_REGISTRY := "registry"
+_OUTPUT_ARCHIVE := "archive"
+
+get := func(registryName, pkgName) {
+	res := smart.structBuilder(_RTYPE_PACKAGE_GET)
+
+	res.getField(_INPUT_REGISTRY).setRefOrJson(registryName)
+	res.getField(_INPUT_PACKAGE_NAME).setRefOrJson(pkgName)
+
+	self := undefined
+	self = oop.inherit(res, {
+		/**
+		 * Reference to the software package archive downloaded by 'get'
+		 *
+		 * @return archive: field - output field, where info on downloaded archive will appear
+		 */
+		archive: func() {
+			return res.outputs()[_OUTPUT_ARCHIVE]
+		}
+	})
+
+	return self
+}
+
+_RTYPE_PACKAGE_INSTALL := { Name: "PackageInstall", Version: "1" }
+_INPUT_ARCHIVE := "archive"
+_OUTPUT_PACKAGE := "package"
+
+install := func(archive) {
+	ll.assert(smart.isReference(archive),
+		"package.install: <archive> must be reference to package archive. It is usually obtained from package.get().archive")
+
+	res := smart.structBuilder(_RTYPE_PACKAGE_INSTALL)
+
+	res.getField(_INPUT_ARCHIVE).set(archive)
+
+	self := undefined
+	self = oop.inherit(res, {
+		/**
+		 * Reference to installed package
+		 *
+		 * @return package: smart.field - output field, where installed package will appear
+		 */
+		package: func() {
+			return res.getField(_OUTPUT_PACKAGE)
+		}
+	})
+
+	return self
+}
+
+_RTYPE_PACKAGE_USE := { Name: "PackageUse", Version: "1" }
+_INPUT_PACKAGE_USE_SETTINGS := "settings"
+
+_useSettingsSchema := {
+	hash: ["or", "bytes", "string"],
+	path: "string",
+	descriptor: "any",
+	origin: {
+		registry: "string",
+		url: "string",
+		packageName: "string"
+	}
+}
+
+use := func(settings) {
+	res := smart.structBuilder(_RTYPE_PACKAGE_USE)
+
+	validation.assertJsonSchema(settings, _useSettingsSchema, "package.use(<settings>): settings have invalid format")
+	settingsRes := smart.createJsonResource(settings)
+
+	res.getField(_INPUT_PACKAGE_USE_SETTINGS).set(settingsRes)
+
+	self := undefined
+	self = oop.inherit(res, {
+		/**
+		 * Reference to installed package
+		 *
+		 * @return package: field - output field, where installed package will appear
+		 */
+		package: func() {
+			return res.outputs()[_OUTPUT_PACKAGE]
+		}
+	})
+
+	return self
+}
+
+
+_RTYPE_PACKAGE_PUT_ASSET := { Name: "PackagePutAssetsToWD", Version: "1" }
+_INPUT_PACKAGE := "package"
+_INPUT_WD_IN := "workdirIn"
+_OUTPUT_WD_OUT := "workdirOut"
+
+/**
+ * Load assets and provide them as files or raw content.
+ *
+ * @param pkg: package - installed package (usually from package.install(<archive>))
+ *
+ * @return loader: assetsLoader - builder that provides requested files and content after load() call
+ */
+assetsLoader := func(pkg) {
+	ll.assert(smart.isReference(pkg),
+		"package.loadAssets: <pkg> must be reference to installed package. It is usually obtained from package.install().package")
+
+	filePaths := []
+	fileContentPaths := []
+
+	self := undefined
+
+	self = {
+		saveFile: func(path) {
+			validation.assertJsonSchema(path, "string", "package.assetsLoader.saveFile: <path> must be string")
+			filePaths = append(filePaths, path)
+
+			return self
+		},
+
+		saveFiles: func(paths) {
+			validation.assertJsonSchema(paths, ["string"], "package.assetsLoader.saveFiles: <paths> must be array of strings")
+			for p in paths {
+				self.saveFile(p)
+			}
+
+			return self
+		},
+
+		saveFileContent: func(path) {
+			validation.assertJsonSchema(path, "string", "package.assetsLoader.saveFileContent: <path> must be string")
+			fileContentPaths = append(fileContentPaths, path)
+			return self
+		},
+
+		saveFilesContent: func(paths) {
+			validation.assertJsonSchema(paths, ["string"], "package.assetsLoader.saveFilesContent: <paths> must be array of strings")
+			for p in paths {
+				self.saveFileContent(p)
+			}
+
+			return self
+		},
+
+		load: func() {
+			wd := workdir.create()
+
+			allPaths := sets.fromSlice(filePaths)
+			allPaths = sets.add(allPaths, fileContentPaths...)
+
+			res := smart.ephemeralBuilder(_RTYPE_PACKAGE_PUT_ASSET, json.encode({
+				paths: sets.toSlice(allPaths)
+			}))
+
+			res.getField(_INPUT_PACKAGE).set(pkg)
+			res.getField(_INPUT_WD_IN).set(wd)
+
+			wdAfter := res.getField(_OUTPUT_WD_OUT)
+
+			wdSaveBuilder := workdir.save(wdAfter)
+			for p in filePaths {
+				wdSaveBuilder.saveFile(p)
+			}
+			for p in fileContentPaths {
+				wdSaveBuilder.saveFileContent(p)
+			}
+			wdSave := wdSaveBuilder.build()
+
+			return {
+				files: wdSave.files,
+				filesContent: wdSave.filesContent,
+				progress: wdSave.progress,
+
+				/**
+				 * Retrieves selected asset file by its path (use saveFile() to provide asset as file)
+				 *
+				 * @param fileName: string
+				 * @return file: smart.field - a reference to the file resource.
+				 */
+				getFile: func(fileName) {
+					return wdSave.files.getFutureInputField(fileName)
+				},
+
+				/**
+				 * Retrieves selected asset data by its path (use saveFileContent() to provide asset's data)
+				 *
+				 * @param fileName: string
+				 * @return file: smart.field - a reference to the file resource.
+				 */
+				getFileContent: func(fileName) {
+					return wdSave.filesContent.getFutureInputField(fileName)
+				}
+			}
+		}
+	}
+
+	return ll.toStrict(self)
+}
+
+/**
+ * Load single asset by its path inside package, providing it as file.
+ *
+ * @param pkg: package - installed package (usually from package.install(<archive>))
+ * @param assetPath: string - path to asset inside package <pkg>
+ *
+ * @return file: singleAsset - object with reference to the file resource and progress report
+ */
+loadAssetFile := func(pkg, assetPath) {
+	assets := assetsLoader(pkg).
+		saveFile(assetPath).
+		load()
+
+	return {
+		file: assets.getFile(assetPath),
+		progress: assets.progress
+	}
+}
+
+/**
+ * Load single asset by its path inside package, providing its raw content.
+ *
+ * @param pkg: package - installed package (usually from package.install(<archive>))
+ * @param assetPath: string - path to asset inside package <pkg>
+ *
+ * @return content: singleAsset - object with reference to the asset content resource and progress report
+ */
+loadAssetContent := func(pkg, assetPath) {
+	assets := assetsLoader(pkg).
+		saveFileContent(assetPath).
+		load()
+
+	return {
+		content: assets.getFileContent(assetPath),
+		progress: assets.progress
+	}
+}
+
+
+export ll.toStrict({
+	softwareInfoScheme                 : softwareInfoScheme,
+	binaryDescriptorScheme             : binaryDescriptorScheme,
+	localDescriptorScheme              : localDescriptorScheme,
+	runEnvDescriptorScheme             : runEnvDescriptorScheme,
+
+	META_KEY_DESCRIPTOR                : META_KEY_DESCRIPTOR,
+
+	get                                : get,
+	install                            : install,
+	use                                : use,
+	assetsLoader                       : assetsLoader,
+	loadAssetFile                      : loadAssetFile,
+	loadAssetContent                   : loadAssetContent
+})

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

@@ -0,0 +1,275 @@
+/** A library that creates RunCommand resource. */
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+json := import("json")
+
+_RTYPE_RUN_COMMAND := { Name: "RunCommand/executor", Version: "1" }
+_RTYPE_RUN_COMMAND_CMD := { Name: "RunCommandCmd", Version: "1" }
+_RTYPE_RUN_COMMAND_ARGS := { Name: "RunCommandArgs", Version: "1" }
+_RTYPE_RUN_COMMAND_OPTIONS := { Name: "run-command/options", Version: "1" }
+_RTYPE_RUN_COMMAND_REFS := { Name: "RunCommandRefs", Version: "1" }
+
+/**
+ * Creates a simple argument for the command.
+ *
+ * @param argument: string - the argument to create.
+ */
+_createSimpleArg := func(argument) {
+	return {
+		type: "string",
+		value: argument
+	}
+}
+
+/**
+ * Creates 'variableRef' argument.
+ * @param argTpl: string - argument value in any form with variables inside (e.g. "file://{pkg}/some-file" or "o-{java}-o")
+ */
+_createVariableArg := func(argTpl) {
+	return {
+		type: "variableRef",
+		value: argTpl
+	}
+}
+
+/**
+ * Builder function for creating a RunCommand resource.
+ *
+ * @param workdir: string - the working directory for the command.
+ * @return builder - the builder object with methods for configuring and building the RunCommand resource.
+ */
+builder := func(workdir) {
+	res := smart.ephemeralBuilder(_RTYPE_RUN_COMMAND)
+	res.getField("workdirIn").set(workdir)
+
+	self := undefined
+
+	cmd := undefined
+	args := []
+	envs := {}
+	queue := ""
+	refs := {}
+
+	substRules := {}
+	hasPatternArgs := false
+	customPaths := []
+
+	stdout := "stdout.txt"
+	stderr := "stderr.txt"
+	nErrorLines := 200
+
+	self = ll.toStrict(oop.inherit(res, {
+		/**
+		 * Sets the command, e.g. /usr/bin/env or sh.
+		 *
+		 * @param commandName: string - the name of the command.
+		 */
+		cmd: func(commandName) {
+			cmd = _createSimpleArg(commandName)
+			return self
+		},
+
+		/**
+		 * Sets the command with variables inside to be rendered using rules
+		 * from .substitutionRules().
+		 *
+		 * @param commandTpl: string - string with '{varName}' substitutions to be replaced with
+		 *                             software paths. Replace rules are defined by .substitutionRule()
+		 *                             and .substitutionRules(),
+		 */
+		cmdVar: func(commandTpl) {
+			cmd = _createVariableArg(commandTpl)
+			hasPatternArgs = true
+			return self
+		},
+
+		/**
+		 * Adds an argument to the command.
+		 *
+		 * @param arg: string - the argument to add.
+		 */
+		arg: func(arg) {
+			args = append(args, _createSimpleArg(arg))
+			return self
+		},
+
+		/**
+		 * Adds an argument with variables inside to be rendered using rules
+		 * from .substitutionRules().
+		 *
+		 * @param argTpl: string - string with '{varName}' substitutions to be replaced with
+		 *                         software paths. Replace rules are defined by .substitutionRule()
+		 *                         and .substitutionRules(),
+		 */
+		argVar: func(argTpl) {
+			args = append(args, _createVariableArg(argTpl))
+			hasPatternArgs = true
+			return self
+		},
+
+		ref: func(refKey, ref) {
+			ll.assert(smart.isReference(ref),
+				"runcmd.builder().ref() must be a reference (valid field or resource)")
+
+			ll.assert(!maps.containsKey(refs, refKey),
+				"attempt to override existing reference %q", refKey)
+
+			refs[refKey] = ref
+			return self
+		},
+
+		/**
+		 * Sets an environment variable for the command.
+		 *
+		 * @param name: string - the name of the environment variable.
+		 * @param value: string - the value of the environment variable.
+		 */
+		env: func(name, value) {
+			envs[name] = value
+			return self
+		},
+
+		/**
+		 * Sets environment variable with substitution inside value, to be rendered
+		 * using rules from .substitutionRules().
+		 *
+		 * @param name: string - the name of the environment variable.
+		 * @param valueTpl: string - the value of the environment variable.
+		 */
+		envVar: func(name, valueTpl) {
+			envs[name] = _createVariableArg(valueTpl)
+			hasPatternArgs = true
+			return self
+		},
+
+		/*
+		 * Patch 'PATH' environment variable, adding software path to it.
+		 *
+		 * @param value: string - the value of the environment variable with variables to be replaced to software path.
+		 * @param hasVars: boolean - wether Platforma Backend should try to substitute variables inside <value> on server side
+		 */
+		addToPath: func(value, hasVars) {
+			if hasVars {
+				customPaths = append(customPaths, _createVariableArg(value))
+				hasPatternArgs = true
+			} else {
+				customPaths = append(customPaths, _createSimpleArg(value))
+			}
+			return self
+		},
+
+		/**
+		 * Define substitution variable for software args.
+		 *
+		 * @param varName: string - variable to be substituted in arg value ("var1" would be
+		 *                          substituted in place of {var1} of arg value)
+		 * @param refKey: string - key of ref (added with .ref()) that points to installed software.
+		 */
+		substitutionRule: func(varName, refKey) {
+			substRules[varName] = refKey
+			return self
+		},
+
+		/**
+		 * Batched .substitutionRule() call (add several rules in single call)
+		 *
+		 * @param rules: map[string]string - <var name> -> <ref key> pairs to be added to substitution rules.
+		 */
+		substitutionRules: func(rules) {
+			for k, v in rules {
+				substRules[k] = v
+			}
+			return self
+		},
+
+		/**
+		 * Sets the queue name for the command.
+		 *
+		 * @param queueName: string - the name of the queue.
+		 */
+		inQueue: func(queueName) {
+			queue = queueName
+			return self
+		},
+
+		/**
+		 * Sets the stdout file name for the command.
+		 *
+		 * @param fileName: string - the name of the stdout file.
+		 */
+		stdout: func(fileName) {
+			stdout = fileName
+			return self
+		},
+
+		/**
+		 * Sets the stderr file name for the command.
+		 *
+		 * @param fileName: string - the name of the stderr file.
+		 */
+		stderr: func(fileName) {
+			stderr = fileName
+			return self
+		},
+
+		/**
+		 * Sets the number of error lines for the command.
+		 *
+		 * @param number: int - the number of error lines.
+		 */
+		nErrorLines: func(number) {
+			nErrorLines = number
+			return self
+		},
+
+		/**
+		 * Builds the RunCommand resource.
+		 *
+		 * @return object - the built RunCommand resource.
+		 */
+		build: func() {
+			// TODO: add assertions about the state
+
+			ll.assert(!hasPatternArgs || len(substRules) != 0,
+				"found pattern argument, but no substitution rules were set")
+
+			refsRes := smart.createMapResourceWithType(_RTYPE_RUN_COMMAND_REFS, refs)
+			self.getField("refs").set(refsRes)
+
+			cmdRes := smart.createValueResource(_RTYPE_RUN_COMMAND_CMD, json.encode(cmd))
+			self.getField("cmd").set(cmdRes)
+
+			options := {
+				queueName: queue,
+				errorLines: nErrorLines,
+				redirectStdout: stdout,
+				redirectStderr: stderr,
+				env: envs,
+				additionalPaths: customPaths,
+				substitutions: substRules
+			}
+
+			optionsRes := smart.createValueResource(_RTYPE_RUN_COMMAND_OPTIONS, json.encode(options))
+			self.getField("options").set(optionsRes)
+
+			argsRes := smart.createValueResource(_RTYPE_RUN_COMMAND_ARGS, json.encode(args))
+			self.getField("args").set(argsRes)
+
+			res := ll.toStrict(oop.inherit(self.lockAndBuild(), {
+				"workdir": self.outputs().workdirOut,
+				"options": options
+			}))
+
+			return res
+		}
+	}))
+
+	return self
+}
+
+export ll.toStrict({
+	builder: builder
+})