@platforma-sdk/workflow-tengo 1.2.6

package/README.md

@@ -0,0 +1,6 @@
+# Resources
+
+- [Tengo syntax](https://github.com/d5/tengo/blob/master/docs/tutorial.md)
+- [Tengo builtin functions](https://github.com/d5/tengo/blob/master/docs/builtins.md)
+- [Modules provided by the pl (`tx` and `plapi`)](https://github.com/milaboratory/pl/blob/main/controllers/templates/pkg/lang/interpreter_api_v1.go)
+

package/dist/tengo/lib/assets.lib.tengo

@@ -0,0 +1,64 @@
+/** API to retrieve assets packed with template code (like other templates). */
+
+plapi := import("plapi")
+json := import("json")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+
+/**
+ * Returns internal template identifier for loaded templates
+ *
+ * @param tplName: string - full name of a template, including namespace (package name).
+ * Local templates (within the same package) can omit namespace part and start the name with colon:
+ *  - "@company/package:someTemplateName"
+ *  - ":myLocalTemplate"
+ *
+ * @return template: smart.resource - resource of tengo template with given name.
+ */
+importTemplate := func(tplName) {
+	return smart.resource(plapi.getTemplateId(tplName))
+}
+
+/**
+ * Returns software description suitable for 'exec' operations.
+ *
+ * @param swName: string - full name of the software description, including namespace (package name).
+ * Local software definitions (within the same package) can omit namespace part and start the name with colon:
+ *  - "@company/package:some-oftware"
+ *  - ":my-local-software"
+ *
+ * @return softwareInfo: softwareInfo - structure with software info
+ */
+importSoftware := func(swName) {
+	sw := plapi.getSoftwareInfo(swName)
+	return ll.toStrict({
+		_type: "softwareDescriptor",
+
+		resource: smart.resource(sw.id),
+		name: sw.name,
+		version: sw.version,
+		blobRef: sw.blobRef,
+		descriptor: ll.toStrict(json.decode(sw.descriptor)) // raw sw.json data with software entrypoint descriptor
+	})
+}
+
+/**
+ * Checks if given item is a software info
+ *
+ * @param toCheck: any - item to check
+ *
+ * @return isSoftware: boolean - true for software info, loaded with importSoftware()
+ */
+isSoftwareInfo := func(toCheck) {
+	if !ll.isMap(toCheck) {
+		return false
+	}
+
+	return (ll.fromStrict(toCheck)._type) == "softwareDescriptor"
+}
+
+export ll.toStrict({
+	importTemplate: importTemplate,
+	importSoftware: importSoftware,
+	isSoftwareInfo: isSoftwareInfo
+})

package/dist/tengo/lib/constants.lib.tengo

@@ -0,0 +1,75 @@
+// constants
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+RTYPE_JSON                := { Name: "json/object",       Version: "1" }
+
+RTYPE_MAP                 := { Name: "std/map",           Version: "1" }
+// @TODO this should be deleted once we align on map type name
+RTYPE_MAP_ALT             := { Name: "StdMap",            Version: "1" }
+RTYPE_MAP_EPH             := { Name: "EphStdMap",         Version: "1" }
+
+RTYPE_BINARY_MAP          := { Name: "BinaryMap",         Version: "1" }
+RTYPE_BINARY_VALUE        := { Name: "BinaryValue",       Version: "1" }
+RTYPE_BLOB_MAP            := { Name: "BlobMap",           Version: "1" }
+
+RTYPE_CONTEXT             := { Name: "BContext",          Version: "1" }
+RTYPE_CONTEXT_END         := { Name: "BContextEnd",       Version: "1" }
+RTYPE_RENDER_TEMPLATE     := { Name: "RenderTemplate",    Version: "1" }
+RTYPE_RENDER_EPH_TEMPLATE := { Name: "EphRenderTemplate", Version: "1" }
+
+RTYPE_BOBJECT_SPEC        := { Name: "BObjectSpec",       Version: "1" }
+RTYPE_BRESOLVE_CHOICE     := { Name: "BResolveChoice",    Version: "1" }
+RTYPE_BRESOLVE_FIRST      := { Name: "BResolveSingle",    Version: "1" }
+RTYPE_BRESOLVE_NO_RESULT  := { Name: "BResolveSingleNoResult", Version: "1" }
+
+RTYPE_QUERY_RESULT        := { Name: "BQueryResult",      Version: "1" }
+
+RTYPE_OBJECT_SPEC         := { Name: "BObjectSpec",       Version: "1" }
+
+RTYPE_WORKDIR_CREATE      := { Name: "WorkdirCreate",     Version: "1" }
+RTYPE_WORKDIR_FILL        := { Name: "WorkdirFill",       Version: "1" }
+RTYPE_WORKDIR_FILL_RULES  := { Name: "WorkdirFill/rules", Version: "1" }
+RTYPE_WORKDIR_SAVE        := { Name: "WorkdirSave",       Version: "1" }
+RTYPE_WORKDIR_SAVE_RULES  := { Name: "WorkdirSave/rules", Version: "1" }
+
+/** Main resource type of representing a PL error */
+RTYPE_JSON_ERROR          := { Name: "json/resourceError", Version: "1"}
+
+FTYPE_OTW                 := "OTW" // Generic one-time writable field. The value of this field can be set only once.
+FTYPE_SERVICE             := "service"
+FTYPE_INPUT               := "input"
+FTYPE_OUTPUT              := "output"
+FTYPE_DYNAMIC             := "dynamic"
+
+export ll.toStrict({
+	FTYPE_OTW                   : FTYPE_OTW,
+	FTYPE_SERVICE               : FTYPE_SERVICE,
+	FTYPE_INPUT                 : FTYPE_INPUT,
+	FTYPE_OUTPUT                : FTYPE_OUTPUT,
+	FTYPE_DYNAMIC               : FTYPE_DYNAMIC,
+
+	RTYPE_BINARY_MAP            : RTYPE_BINARY_MAP,
+	RTYPE_BINARY_VALUE          : RTYPE_BINARY_VALUE,
+	RTYPE_BLOB_MAP              : RTYPE_BLOB_MAP,
+	RTYPE_BOBJECT_SPEC          : RTYPE_BOBJECT_SPEC,
+	RTYPE_BRESOLVE_CHOICE       : RTYPE_BRESOLVE_CHOICE,
+	RTYPE_BRESOLVE_FIRST        : RTYPE_BRESOLVE_FIRST,
+	RTYPE_BRESOLVE_NO_RESULT    : RTYPE_BRESOLVE_NO_RESULT,
+	RTYPE_CONTEXT               : RTYPE_CONTEXT,
+	RTYPE_CONTEXT_END           : RTYPE_CONTEXT_END,
+	RTYPE_JSON                  : RTYPE_JSON,
+	RTYPE_MAP                   : RTYPE_MAP,
+	RTYPE_MAP_ALT               : RTYPE_MAP_ALT,
+	RTYPE_MAP_EPH               : RTYPE_MAP_EPH,
+	RTYPE_QUERY_RESULT          : RTYPE_QUERY_RESULT,
+	RTYPE_OBJECT_SPEC           : RTYPE_OBJECT_SPEC,
+	RTYPE_RENDER_EPH_TEMPLATE   : RTYPE_RENDER_EPH_TEMPLATE,
+	RTYPE_RENDER_TEMPLATE       : RTYPE_RENDER_TEMPLATE,
+	RTYPE_WORKDIR_CREATE        : RTYPE_WORKDIR_CREATE,
+	RTYPE_WORKDIR_FILL          : RTYPE_WORKDIR_FILL,
+	RTYPE_WORKDIR_FILL_RULES    : RTYPE_WORKDIR_FILL_RULES,
+	RTYPE_WORKDIR_SAVE          : RTYPE_WORKDIR_SAVE,
+	RTYPE_WORKDIR_SAVE_RULES    : RTYPE_WORKDIR_SAVE_RULES,
+	RTYPE_JSON_ERROR            : RTYPE_JSON_ERROR
+})

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

@@ -0,0 +1,211 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+json := import("json")
+text := import("text")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+path := import("@platforma-sdk/workflow-tengo:path")
+pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
+
+// 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
+
+/**
+ * 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
+	})
+}
+
+_newRefVar := func(varName, refName, 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()
+}
+
+_directCallOptions := func(runOptions) {
+	cmd := _newArg(false, runOptions.cmd)
+	args := []
+	envs := {}
+
+	for name, 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, {
+		variables: [],
+		customPaths: [],
+		cmd: cmd,
+		args: args,
+		envs: envs
+	})
+}
+
+_loadJavaRunEnvironment := func(descriptor) {
+	javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
+	javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
+
+	return ll.toStrict({
+		variables: [ javaRefVar ],
+		customPaths: [ _newArg(true, path.join(_ARG_VAR_JAVA, descriptor.runEnv.binDir)) ],
+		envs: {}
+	})
+}
+
+_loadPythonRunEnvironment := func(descriptor, softName, softPkg) {
+	venvBuilder := runenv.pythonVenv().
+		software(softPkg).
+		runEnvDescriptor(descriptor.runEnv).
+		dependencies(descriptor.dependencies)
+
+	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+		venvBuilder.useToolset(descriptor.toolset)
+	}
+
+	venv := venvBuilder.build().venv()
+
+	venvRoot := path.join(_ARG_VAR_PYTHON, "venv")
+	venvRefKey := softName + "/venv"
+
+	pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
+
+	return ll.toStrict({
+		variables: [ pythonRefVar ],
+		customPaths: [ _newArg(true, path.join(venvRoot, "bin")) ],
+		envs: {
+			"VIRTUAL_ENV": _newArg(true, venvRoot)
+		}
+	})
+}
+
+_loadRunEnvironment := func(descriptor, softName, softPackage) {
+	if descriptor.runEnv.type == "java" {
+		return _loadJavaRunEnvironment(descriptor)
+	}
+	if descriptor.runEnv.type == "python" {
+		return _loadPythonRunEnvironment(descriptor, softName, softPackage)
+	}
+
+	ll.panic("run environment type %q is not currently supported by tengo-sdk",	descriptor.runEnv.type)
+}
+
+_binPackageCallOptions := func(runOptions, variables, descriptor, softPackage) {
+	customPaths := []
+	envs := ll.toStrict({})
+	args := []
+
+	// Real command shoule be:
+	//   [<runEnv bin>] [<runEnv options>] [<entrypoint bin>] [<entrypoint options>] <cmd> <args>
+	if (maps.containsKey(descriptor, "runEnv")) {
+		runEnvInfo := _loadRunEnvironment(descriptor, runOptions.software.name, softPackage)
+
+		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, {
+		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(runOptions, variables, localDescriptor, softPackage)
+}
+
+_remotePackageCallOptions := func(runOptions) {
+	software := runOptions.software
+	binaryDescriptor := software.descriptor.binary
+	softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
+
+	variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+
+	return _binPackageCallOptions(runOptions, variables, binaryDescriptor, softPackage)
+}
+
+binaryRunOptions := func(runOptions) {
+	if (is_undefined(runOptions.software)) {
+		//
+		// Simple local command run, no software pacakges involved (backward compatibility)
+		//
+		return _directCallOptions(runOptions)
+	}
+
+	software := runOptions.software
+	descriptor := software.descriptor
+
+	if (maps.containsKey(descriptor, "local")) {
+		return _devLocalPackageCallOptions(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)
+}
+
+export {
+	binaryRunOptions              : binaryRunOptions
+}