n8n-nodes-soar 0.1.15 → 0.1.18

package/dist/common/asset.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Asset: function() {
+        return Asset;
+    },
+    Basic: function() {
+        return Basic;
+    },
+    MissingPropertyError: function() {
+        return MissingPropertyError;
+    }
+});
+const _classtransformer = require("class-transformer");
+require("reflect-metadata");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class Basic {
+    constructor(){
+        _define_property(this, "ip", void 0);
+        _define_property(this, "domain", void 0);
+        _define_property(this, "port", void 0);
+        _define_property(this, "protocol", void 0);
+    }
+}
+class MissingPropertyError extends Error {
+    constructor(property, asset){
+        super(`Missing property: ${property} on ${JSON.stringify((0, _classtransformer.instanceToPlain)(asset))}`);
+    }
+}
+class Asset {
+    getDomain() {
+        if (!this.basic.domain) {
+            throw new MissingPropertyError("basic.domain", this);
+        }
+        return this.basic.domain;
+    }
+    getHost() {
+        if (!(this.basic.domain || this.basic.ip)) {
+            throw new MissingPropertyError("basic.host", this);
+        }
+        return this.basic.domain || this.basic.ip || "";
+    }
+    getPort() {
+        if (!this.basic.port) {
+            throw new MissingPropertyError("basic.port", this);
+        }
+        return this.basic.port;
+    }
+    getHostAndPort() {
+        return `${this.getHost()}:${this.getPort()}`;
+    }
+    clone(patch) {
+        return (0, _classtransformer.plainToInstance)(Asset, Object.assign({}, this, patch));
+    }
+    splitBySubdomains() {
+        if (this.subdomains?.length) {
+            return [
+                this,
+                ...this.subdomains.map((n)=>{
+                    return (0, _classtransformer.plainToInstance)(Asset, {
+                        basic: {
+                            host: n
+                        },
+                        metadata: this.metadata
+                    });
+                })
+            ];
+        } else {
+            return [
+                this
+            ];
+        }
+    }
+    splitByDnsRecords() {
+        if (this.dnsRecord && Object.keys(this.dnsRecord).length) {
+            return [
+                ...this.dnsRecord?.A ?? [],
+                ...this.dnsRecord?.AAAA ?? []
+            ].map((n)=>{
+                return (0, _classtransformer.plainToInstance)(Asset, {
+                    basic: {
+                        domain: this.basic.domain,
+                        ip: n
+                    },
+                    metadata: this.metadata
+                });
+            });
+        } else {
+            return [
+                this
+            ];
+        }
+    }
+    splitByPorts() {
+        if (this.ports?.length) {
+            return this.ports.map((n)=>{
+                return (0, _classtransformer.plainToInstance)(Asset, {
+                    basic: {
+                        domain: this.basic.domain,
+                        port: n.port,
+                        protocol: n.protocol
+                    },
+                    metadata: this.metadata
+                });
+            });
+        } else {
+            return [
+                this
+            ];
+        }
+    }
+    constructor(){
+        _define_property(this, "basic", new Basic());
+        _define_property(this, "subdomains", void 0);
+        _define_property(this, "dnsRecord", void 0);
+        _define_property(this, "ports", void 0);
+        _define_property(this, "metadata", void 0);
+        _define_property(this, "response", void 0);
+        _define_property(this, "success", false);
+    }
+}

package/dist/common/collector.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Collector", {
+    enumerable: true,
+    get: function() {
+        return Collector;
+    }
+});
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class Collector {
+    setExecutor(executor) {
+        this.executor = executor;
+    }
+    constructor(){
+        _define_property(this, "executor", void 0);
+    //
+    }
+}

package/dist/common/connectionType.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeConnectionType", {
+    enumerable: true,
+    get: function() {
+        return NodeConnectionType;
+    }
+});
+var NodeConnectionType;
+(function(NodeConnectionType) {
+    NodeConnectionType["Runner"] = "runner";
+    NodeConnectionType["Executor"] = "executor";
+})(NodeConnectionType || (NodeConnectionType = {}));

package/dist/common/executor/docker.executor.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DockerExecutor", {
+    enumerable: true,
+    get: function() {
+        return DockerExecutor;
+    }
+});
+const _stream = require("stream");
+const _dockerode = /*#__PURE__*/ _interop_require_default(require("dockerode"));
+const _n8nworkflow = require("n8n-workflow");
+const _executor = require("./executor");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class DockerExecutor extends _executor.Executor {
+    async __run(cmd, image, env) {
+        let stdout = "";
+        let stderr = "";
+        const outStream = new _stream.Writable({
+            write (chunk, encoding, done) {
+                stdout += chunk.toString();
+                done();
+            }
+        });
+        const errStream = new _stream.Writable({
+            write (chunk, encoding, done) {
+                stderr += chunk.toString();
+                done();
+            }
+        });
+        await this.docker.pull(image);
+        let container;
+        const containers = (await this.docker.listContainers({
+            filters: '{"label": ["managed-by=n8n-nodes-soar"]}'
+        })).filter((n)=>n.Image === image);
+        if (containers.length === 0) {
+            this.func.logger.info(`Boot new container for image ${image}`);
+            container = await this.docker.createContainer({
+                Image: image,
+                Cmd: [
+                    "sleep",
+                    "infinity"
+                ],
+                Labels: {
+                    "managed-by": "n8n-nodes-soar"
+                }
+            });
+            await container.start();
+        } else {
+            container = this.docker.getContainer(containers[0].Id);
+        }
+        this.func.logger.debug(`Running ${cmd.join(" ")}`);
+        const exec = await container.exec({
+            AttachStderr: true,
+            AttachStdout: true,
+            Env: Object.entries(env || {}).map(([key, value])=>`${key}=${value}`),
+            Tty: false,
+            Cmd: cmd
+        });
+        const pipe = await exec.start({});
+        this.docker.modem.demuxStream(pipe, outStream, errStream);
+        await new Promise((resolve)=>{
+            pipe.on("end", resolve);
+        });
+        if (stderr !== "") {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderr));
+        }
+        this.func.logger.debug(`Result ${stdout}`);
+        return JSON.parse(stdout);
+    }
+    constructor(credentials, func){
+        super(func);
+        _define_property(this, "docker", void 0);
+        if (credentials === undefined) {
+            throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("No credentials got returned!"));
+        }
+        this.docker = new _dockerode.default(credentials);
+    }
+}

package/dist/common/executor/executor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Executor", {
+    enumerable: true,
+    get: function() {
+        return Executor;
+    }
+});
+const _connectionType = require("../connectionType");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class Executor {
+    async run(cmd, image, env) {
+        const { index } = this.func.addInputData(_connectionType.NodeConnectionType.Executor, [
+            [
+                {
+                    json: {
+                        cmd,
+                        image,
+                        env
+                    }
+                }
+            ]
+        ]);
+        const resp = await this.__run(cmd, image, env);
+        this.func.addOutputData(_connectionType.NodeConnectionType.Executor, index, [
+            this.func.helpers.returnJsonArray(resp)
+        ]);
+        return resp;
+    }
+    constructor(func){
+        _define_property(this, "func", void 0);
+        this.func = func;
+    }
+}

package/dist/common/executor/k8s.executor.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "K8sExecutor", {
+    enumerable: true,
+    get: function() {
+        return K8sExecutor;
+    }
+});
+const _stream = require("stream");
+const _clientnode = /*#__PURE__*/ _interop_require_wildcard(require("@kubernetes/client-node"));
+const _n8nworkflow = require("n8n-workflow");
+const _executor = require("./executor");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class K8sExecutor extends _executor.Executor {
+    async __run(cmd, image, env) {
+        const kc = this.kubeConfig;
+        const k8sCoreApi = kc.makeApiClient(_clientnode.CoreV1Api);
+        const pods = (await k8sCoreApi.listNamespacedPod("default", undefined, undefined, undefined, undefined, "managed-by=n8n-nodes-soar")).body.items.filter((n)=>(n.status?.phase === "Running" || n.status?.phase === "Pending") && n.spec?.containers[0].image === image);
+        let pod = undefined;
+        const namespace = "default";
+        if (pods.length > 0) {
+            pod = pods[0];
+        } else {
+            const podName = `n8n-soar-pod-${Date.now()}`;
+            const podSpec = {
+                metadata: {
+                    name: podName,
+                    labels: {
+                        "managed-by": "n8n-nodes-soar"
+                    }
+                },
+                spec: {
+                    restartPolicy: "Always",
+                    containers: [
+                        {
+                            name: "main-container",
+                            image,
+                            imagePullPolicy: "Always",
+                            args: [
+                                "sleep",
+                                "infinity"
+                            ],
+                            lifecycle: {}
+                        }
+                    ]
+                }
+            };
+            this.func.logger.debug("Creating pod " + JSON.stringify(podSpec));
+            const resp = await k8sCoreApi.createNamespacedPod(namespace, podSpec);
+            pod = resp.body;
+        }
+        const name = pod.metadata?.name;
+        if (!name) {
+            throw new Error("Pod name not set!");
+        }
+        // if is in initial
+        if (pod.status?.phase === "Pending") {
+            while(true){
+                const pod = (await k8sCoreApi.readNamespacedPod(name, namespace)).body;
+                if (pod.status?.phase === "Running") {
+                    break;
+                }
+                await new Promise((resolve)=>setTimeout(resolve, 1000));
+            }
+        }
+        // exec into pod and get stdout/stderr
+        const exec = new _clientnode.Exec(kc);
+        const stdout = new _stream.Writable();
+        let stdoutString = "";
+        stdout._write = (chunk, encoding, next)=>{
+            stdoutString += chunk.toString();
+            next();
+        };
+        const stderr = new _stream.Writable();
+        let stderrString = "";
+        stderr._write = (chunk, encoding, next)=>{
+            stderrString += chunk.toString();
+            next();
+        };
+        this.func.logger.debug(`Running ${cmd.join(" ")}`);
+        await new Promise(async (resolve, reject)=>{
+            exec.exec(namespace, name, "main-container", [
+                "env",
+                ...Object.entries(env || {}).flatMap(([k, v])=>[
+                        "-e",
+                        `${k}=${v}`
+                    ]),
+                ...cmd
+            ], stdout, stderr, null, false, (s)=>{
+                switch(s.status){
+                    case "Failure":
+                        reject(s.message);
+                        break;
+                    case "Success":
+                        resolve(undefined);
+                        break;
+                }
+            }).catch(reject);
+        });
+        stderrString;
+        if (stderrString !== "") {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderrString));
+        }
+        this.func.logger.debug(`Result ${stdoutString}`);
+        return JSON.parse(stdoutString);
+    }
+    constructor(credentials, func){
+        super(func);
+        _define_property(this, "kubeConfig", void 0);
+        if (credentials === undefined) {
+            throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("No credentials got returned!"));
+        }
+        const kubeConfig = new _clientnode.KubeConfig();
+        switch(credentials.loadFrom){
+            case "automatic":
+                kubeConfig.loadFromDefault();
+                break;
+            case "file":
+                if (typeof credentials.filePath !== "string" || credentials.filePath === "") {
+                    throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("File path not set!"));
+                }
+                kubeConfig.loadFromFile(credentials.filePath);
+                break;
+            case "content":
+                if (typeof credentials.content !== "string" || credentials.content === "") {
+                    throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("Content not set!"));
+                }
+                kubeConfig.loadFromString(credentials.content);
+                break;
+            default:
+                throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("Load from value not set!"));
+        }
+        this.kubeConfig = kubeConfig;
+    }
+}

package/dist/common/runner/container.runner.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ContainerRunner: function() {
+        return ContainerRunner;
+    },
+    IMAGE: function() {
+        return IMAGE;
+    },
+    injectCommonProperties: function() {
+        return injectCommonProperties;
+    }
+});
+const _n8nworkflow = require("n8n-workflow");
+const _runner = require("./runner");
+const IMAGE = {
+    DEFAULT: "registry.yoshino-s.xyz/yoshino-s/soar-image:dev",
+    SCRIPT: "registry.yoshino-s.xyz/yoshino-s/soar-image/script:dev"
+};
+const injectCommonProperties = (p)=>{
+    return [
+        ...p,
+        {
+            displayName: "Advanced Config",
+            name: "advanced",
+            type: "fixedCollection",
+            default: {},
+            typeOptions: {
+                multipleValues: true
+            },
+            options: [
+                {
+                    name: "envs",
+                    displayName: "Envs",
+                    values: [
+                        {
+                            displayName: "Key",
+                            name: "key",
+                            type: "string",
+                            default: ""
+                        },
+                        {
+                            displayName: "Value",
+                            name: "value",
+                            type: "string",
+                            default: ""
+                        }
+                    ]
+                },
+                {
+                    name: "Files",
+                    displayName: "Files",
+                    values: [
+                        {
+                            displayName: "Name",
+                            name: "name",
+                            type: "string",
+                            default: ""
+                        },
+                        {
+                            displayName: "Content",
+                            name: "content",
+                            type: "string",
+                            default: ""
+                        }
+                    ]
+                },
+                {
+                    displayName: "Collect Files",
+                    name: "collectFiles",
+                    values: [
+                        {
+                            displayName: "Name",
+                            name: "name",
+                            type: "string",
+                            default: ""
+                        }
+                    ]
+                }
+            ]
+        }
+    ];
+};
+class ContainerRunner extends _runner.Runner {
+    collectGeneratedOptions(extraArgParameters) {
+        const cmdline = [];
+        for (const parameter of extraArgParameters){
+            const value = this.func.getNodeParameter(parameter, this.itemIndex, null);
+            if (!value) continue;
+            if (typeof value === "string") {
+                cmdline.push(parameter, value);
+            } else if (Array.isArray(value)) {
+                value.forEach((v)=>{
+                    if (typeof v === "string") {
+                        cmdline.push(v);
+                    } else {
+                        const { key, value } = v;
+                        if (value) {
+                            cmdline.push(key, value);
+                        } else {
+                            cmdline.push(key);
+                        }
+                    }
+                });
+            }
+        }
+        return cmdline;
+    }
+    options(assets) {
+        assets;
+        const options = {
+            envs: {},
+            files: {},
+            collectFiles: []
+        };
+        const _env = this.func.getNodeParameter("advanced.envs", this.itemIndex, []);
+        options.envs = Object.fromEntries(_env.map(({ key, value })=>[
+                key,
+                value
+            ]));
+        const _files = this.func.getNodeParameter("advanced.files", this.itemIndex, []);
+        options.files = Object.fromEntries(_files.map(({ name, content })=>[
+                name,
+                content
+            ]));
+        const _collectFiles = this.func.getNodeParameter("advanced.collectFiles", this.itemIndex, []);
+        options.collectFiles = _collectFiles.map(({ name })=>name);
+        return options;
+    }
+    async __run(collector, assets) {
+        if (collector.executor === undefined) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), "Executor is not set");
+        }
+        const options = this.options(assets);
+        const cmd = this.cmd(assets);
+        let cmdline = [
+            "/usr/local/bin/runner"
+        ];
+        if (options.files) {
+            for (const [key, value] of Object.entries(options.files)){
+                cmdline.push("--files", `${key}:${value}`);
+            }
+        }
+        if (options.collectFiles) {
+            for (const key of options.collectFiles){
+                cmdline.push("--collect-files", key);
+            }
+        }
+        if (options.ignoreStdout) {
+            cmdline.push("--ignore-stdout");
+        }
+        if (options.ignoreStderr) {
+            cmdline.push("--ignore-stderr");
+        }
+        cmdline.push("--");
+        cmdline = cmdline.concat(cmd);
+        const { stdout, stderr, error, files: resultFiles } = await collector.executor.run(cmdline, options.image ?? IMAGE.DEFAULT, options.envs);
+        if (error) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(error));
+        }
+        if (stderr) {
+            this.func.logger.warn(stderr);
+        }
+        return this.process(assets, stdout, resultFiles ?? {});
+    }
+}