@kapeta/local-cluster-service 0.0.76 → 0.1.1

package/src/instances/routes.js

@@ -100,6 +100,16 @@ router.put('/', async (req, res) => {
 
     let instance = JSON.parse(req.stringBody);
 
+    if (req.kapeta.environment === 'docker') {
+        //A bit hacky but we want to avoid overwriting the docker PID with a process PID
+        const oldInstance = instanceManager.getInstance(
+            req.kapeta.systemId,
+            req.kapeta.instanceId
+        );
+        if (oldInstance) {
+            instance.pid = oldInstance.pid;
+        }
+    }
     await instanceManager.registerInstance(
         req.kapeta.systemId,
         req.kapeta.instanceId,

package/src/networkManager.js

@@ -3,10 +3,10 @@ class NetworkManager {
 
     static toConnectionId(connection) {
         return [
-            connection.from.blockId,
-            connection.from.resourceName,
-            connection.to.blockId,
-            connection.to.resourceName
+            connection.provider.blockId,
+            connection.provider.resourceName,
+            connection.consumer.blockId,
+            connection.consumer.resourceName
         ].join('_');
     }
 
@@ -65,8 +65,8 @@ class NetworkManager {
         const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
 
         this._ensureConnection(systemId, traffic.connectionId).push(traffic);
-        this._ensureSource(systemId, connection.from.blockId).push(traffic);
-        this._ensureTarget(systemId, connection.to.blockId).push(traffic);
+        this._ensureSource(systemId, connection.provider.blockId).push(traffic);
+        this._ensureTarget(systemId, connection.consumer.blockId).push(traffic);
 
         return traffic;
     }

package/src/proxy/routes.js

@@ -34,11 +34,12 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
 
         const plan = await assetManager.getPlan(req.params.systemId);
 
+
         // We can find the connection by the consumer information alone since
         // only 1 provider can be connected to a consumer resource at a time
         const connection = _.find(plan.spec.connections, (connection) => {
-            return connection.to.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
-                connection.to.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase();
+            return connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
+                connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase();
         });
 
         if (!connection) {
@@ -47,7 +48,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         }
 
         const toBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
-            return blockInstance.id.toLowerCase() === connection.to.blockId.toLowerCase();
+            return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
         });
 
         if (!toBlockInstance) {
@@ -57,9 +58,9 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
 
         const toBlockAsset = await assetManager.getAsset(toBlockInstance.block.ref);
 
-        const toResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
+        const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
 
-        if (!toResource) {
+        if (!consumerResource) {
             res.status(401).send({error:`Block resource not found "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`});
             return;
         }
@@ -76,23 +77,23 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
          Note that this might not match the path the destination is expecting so we need to identify the method
          that is being called and identify the destination path from the connection.
          */
-        const consumerPath = req.originalUrl.substr(basePath.length - 1);
+        const consumerPath = req.originalUrl.substring(basePath.length - 1);
 
         const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
-            return blockInstance.id.toLowerCase() === connection.from.blockId.toLowerCase();
+            return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
         });
 
         if (!fromBlockInstance) {
-            res.status(401).send({error:`Block instance not found "${connection.from.blockId}`});
+            res.status(401).send({error:`Block instance not found "${connection.provider.blockId}`});
             return;
         }
 
         const fromBlockAsset = await assetManager.getAsset(fromBlockInstance.block.ref);
 
-        const fromResource = getResource(fromBlockAsset.data.spec.providers, connection.from.resourceName);
+        const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
 
-        if (!fromResource) {
-            res.status(401).send({error:`Block resource not found "${connection.from.blockId}::${connection.from.resourceName}`});
+        if (!providerResource) {
+            res.status(401).send({error:`Block resource not found "${connection.provider.blockId}::${connection.provider.resourceName}`});
             return;
         }
 
@@ -100,7 +101,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         //Get target address
         let address = await serviceManager.getProviderAddress(
             req.params.systemId,
-            connection.from.blockId,
+            connection.provider.blockId,
             req.params.type
         );
 
@@ -111,12 +112,13 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         typeHandler(req, res, {
             consumerPath,
             address,
-            toResource,
-            fromResource,
+            consumerResource,
+            providerResource,
             connection
         });
 
     } catch(err) {
+        console.warn("Failed to process proxy request", err);
         res.status(400).send({error: err.message});
     }
 

package/src/proxy/types/rest.js

@@ -35,7 +35,7 @@ function getRestMethodId(restResource, httpMethod, httpPath) {
  * @return {{consumerMethod: *, providerMethod: *}}
  */
 function resolveMethods(req, opts) {
-    const consumerMethodId = getRestMethodId(opts.toResource, req.method, opts.consumerPath);
+    const consumerMethodId = getRestMethodId(opts.consumerResource, req.method, opts.consumerPath);
 
     if (!consumerMethodId) {
         throw new Error(
@@ -43,7 +43,7 @@ function resolveMethods(req, opts) {
         );
     }
 
-    const consumerMethod = _.cloneDeep(opts.toResource.spec.methods[consumerMethodId]);
+    const consumerMethod = _.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
 
     if (!consumerMethod) {
         throw new Error(
@@ -61,11 +61,11 @@ function resolveMethods(req, opts) {
         throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
     }
 
-    const providerMethod = _.cloneDeep(opts.fromResource.spec.methods[providerMethodId]);
+    const providerMethod = _.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
 
     if (!providerMethod) {
         throw new Error(
-            `Provider method not found "${providerMethodId}" in resource "${opts.connection.from.blockId}::${opts.connection.from.resourceName}`
+            `Provider method not found "${providerMethodId}" in resource "${opts.connection.provider.blockId}::${opts.connection.provider.resourceName}`
         );
     }
 
@@ -106,8 +106,7 @@ module.exports = function proxyRestRequest(req, res, opts) {
     delete requestHeaders['host'];
     delete requestHeaders['origin'];
 
-
-    console.log('Route to provider: %s => %s', opts.consumerPath, opts.address + providerPath);
+    console.log('Proxy request to provider: %s => %s [rest]', opts.consumerPath, opts.address + providerPath);
 
     const reqOpts = {
         method: providerMethod.method || 'GET',

package/src/proxy/types/web.js

@@ -12,7 +12,7 @@ const socketManager = require('../../socketManager');
  */
 module.exports = function proxyRestRequest(req, res, opts) {
 
-    console.log('Route to provider: %s => %s', opts.consumerPath, opts.address);
+    console.log('Proxy request to provider: %s => %s [web]', opts.consumerPath, opts.address);
 
     const requestHeaders = _.clone(req.headers);
 
@@ -22,8 +22,8 @@ module.exports = function proxyRestRequest(req, res, opts) {
     delete requestHeaders['host'];
     delete requestHeaders['origin'];
 
-    const sourceBasePath = opts.fromResource.spec.path;
-    const targetBasePath = opts.toResource.spec.path;
+    const sourceBasePath = opts.providerResource.spec.path;
+    const targetBasePath = opts.consumerResource.spec.path;
     let path = opts.consumerPath;
     if (opts.consumerPath.startsWith(sourceBasePath)) {
         path = path.replace(sourceBasePath, targetBasePath);
@@ -37,8 +37,6 @@ module.exports = function proxyRestRequest(req, res, opts) {
         body: req.stringBody
     };
 
-    console.log('reqOpts', reqOpts);
-
     const traffic = networkManager.addRequest(
         req.params.systemId,
         opts.connection,

package/src/repositoryManager.js

@@ -166,7 +166,8 @@ class RepositoryManager {
             return null;
         }
 
-        const installedAsset = ClusterConfiguration.getDefinitions().find(d =>
+        const definitions = ClusterConfiguration.getDefinitions();
+        const installedAsset = definitions.find(d =>
                         d.definition.metadata.name === fullName &&
                         d.version === version);
 
@@ -179,18 +180,28 @@ class RepositoryManager {
             return;
         }
 
-        const assetVersion = await this._registryService.getVersion(fullName, version);
-        if (!assetVersion) {
-            this._cache[ref] = false;
-            return;
+        try {
+            const assetVersion = await this._registryService.getVersion(fullName, version);
+            if (!assetVersion) {
+                this._cache[ref] = false;
+                return;
+            }
+        } catch (e) {
+            console.warn(`Unable to resolve asset: ${ref}`, e);
+            if (installedAsset) {
+                return;
+            }
+            throw e;
         }
 
         this._cache[ref] = true;
         if (!installedAsset) {
+            console.log(`Auto-installing missing asset: ${ref}`);
             await this._install([ref]);
         } else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
+            console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
             await this._install(refs);
         }
 

package/src/serviceManager.js

@@ -73,7 +73,6 @@ class ServiceManager {
 
         const portTypeSection = service[portType];
 
-
         return portTypeSection.port;
     }
 

package/src/utils/BlockInstanceRunner.js

@@ -0,0 +1,435 @@
+const {spawn} = require('node:child_process');
+const FS = require('node:fs');
+const Path = require('node:path');
+const {Docker} = require('node-docker-api');
+const ClusterConfig = require("@kapeta/local-cluster-config");
+const {readYML} = require("./utils");
+const {parseKapetaUri} = require("@kapeta/nodejs-utils");
+const serviceManager = require("../serviceManager");
+const containerManager = require("../containerManager");
+const LogData = require("./LogData");
+const EventEmitter = require("events");
+const {execSync} = require("child_process");
+
+const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
+const KAPETA_SYSTEM_ID = "KAPETA_SYSTEM_ID";
+const KAPETA_BLOCK_REF = "KAPETA_BLOCK_REF";
+const KAPETA_INSTANCE_ID = "KAPETA_INSTANCE_ID";
+/**
+ * Needed when running local docker containers as part of plan
+ * @type {string[]}
+ */
+const DOCKER_ENV_VARS = [
+    `KAPETA_LOCAL_SERVER=0.0.0.0`,
+    `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
+    `KAPETA_ENVIRONMENT_TYPE=docker`,
+]
+
+function md5(data) {
+    return require('crypto').createHash('md5').update(data).digest("hex");
+}
+
+
+class BlockInstanceRunner {
+    /**
+     * @param {string} [planReference]
+     * @param {BlockInstanceInfo[]} [instances]
+     */
+    constructor(planReference) {
+        /**
+         *
+         * @type {string}
+         * @private
+         */
+        this._systemId = planReference ?? '';
+    }
+
+
+
+    /**
+     * Start a block
+     *
+     * @param {string} blockRef
+     * @param {string} instanceId
+     * @param {any} configuration
+     * @returns {Promise<ProcessInfo>}
+     */
+    async start(blockRef, instanceId, configuration) {
+        return this._execute({
+            ref: blockRef,
+            id: instanceId,
+            configuration
+        });
+    }
+
+    /**
+     *
+     * @param {BlockInstanceInfo} blockInstance
+     * @return {Promise<ProcessInfo>}
+     * @private
+     */
+    async _execute(blockInstance) {
+        const env = Object.assign({}, process.env);
+
+        if (this._systemId) {
+            env[KAPETA_SYSTEM_ID] = this._systemId;
+        }
+
+        if (blockInstance.ref) {
+            env[KAPETA_BLOCK_REF] = blockInstance.ref;
+        }
+
+        if (blockInstance.id) {
+            env[KAPETA_INSTANCE_ID] = blockInstance.id;
+        }
+
+        const blockUri = parseKapetaUri(blockInstance.ref);
+
+        if (!blockUri.version) {
+            blockUri.version = 'local';
+        }
+
+        const definition = ClusterConfig.getDefinitions().find(definitions => {
+            const ref = `${definitions.definition.metadata.name}:${definitions.version}`
+            return parseKapetaUri(ref).id === blockUri.id;
+        });
+
+        if (!definition) {
+            throw new Error(`Block definition not found: ${blockUri.id}`);
+        }
+
+        const kindUri = parseKapetaUri(definition.definition.kind);
+
+        const provider = ClusterConfig.getProviderDefinitions().find(provider => {
+            const ref = `${provider.definition.metadata.name}:${provider.version}`
+            return parseKapetaUri(ref).id === kindUri.id;
+        });
+
+        if (!provider) {
+            throw new Error(`Kind not found: ${kindUri.id}`);
+        }
+
+        /**
+         * @type {ProcessDetails}
+         */
+        let processDetails;
+
+        if (provider.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+            processDetails = await this._startOperatorProcess(blockInstance, blockUri, provider, env);
+        } else {
+            if (blockUri.version === 'local') {
+                processDetails = await this._startLocalProcess(blockInstance, blockUri, env);
+            } else {
+                processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
+            }
+        }
+
+        return {
+            ...blockInstance,
+            ...processDetails
+        };
+    }
+
+
+    /**
+     * Starts local process
+     * @param {BlockInstanceInfo} blockInstance
+     * @param {BlockInfo} blockInfo
+     * @param {EnvironmentVariables} env
+     * @return {ProcessDetails}
+     * @private
+     */
+    _startLocalProcess(blockInstance, blockInfo, env) {
+        const baseDir = ClusterConfig.getRepositoryAssetPath(
+            blockInfo.handle,
+            blockInfo.name,
+            blockInfo.version
+        );
+
+        if (!FS.existsSync(baseDir)) {
+            throw new Error(
+                `Local block not registered correctly - expected symlink here: ${baseDir}.\n` +
+                `Make sure you've run "blockctl registry link" in your local directory to connect it to Kapeta`
+            );
+        }
+
+        const startScript = Path.resolve(baseDir, 'scripts/start.sh');
+        if (!FS.existsSync(startScript)) {
+            throw new Error(
+                `Start script did not exist for local block.\n` +
+                `Expected runnable start script here: ${startScript}`
+            )
+        }
+
+        const logs = new LogData();
+        const childProcess = spawn(startScript, [], {
+            cwd: baseDir,
+            env,
+            detached: true,
+            stdio: [
+                'pipe', 'pipe', 'pipe'
+            ]
+        });
+
+        logs.addLog(`Starting block ${blockInstance.ref} using script ${startScript}`);
+        const outputEvents = new EventEmitter();
+        /**
+         *
+         * @type {ProcessDetails}
+         */
+        const out = {
+            type: 'local',
+            pid: childProcess.pid,
+            output: outputEvents,
+            stderr: childProcess.stderr,
+            logs: () => {
+                return logs.getLogs();
+            },
+            stop: () => {
+                childProcess.kill('SIGTERM');
+            }
+        };
+
+        childProcess.stdout.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        childProcess.stderr.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        childProcess.on('exit', (code) => {
+            logs.addLog(`Block ${blockInstance.ref} exited with code: ${code}`);
+            outputEvents.emit('exit', code);
+        });
+
+        return out;
+    }
+
+    async _handleContainer(container, logs , deleteOnExit = false) {
+        const logStream = await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: LogData.MAX_LINES
+        })
+
+        const outputEvents = new EventEmitter();
+        logStream.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        logStream.on('error', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        logStream.on('close', async () => {
+            const status = await container.status();
+            if (deleteOnExit) {
+                try {
+                    await container.delete()
+                } catch (e) {}
+            }
+            outputEvents.emit('exit', status.data?.State?.ExitCode ?? 0);
+        });
+        /**
+         *
+         * @type {ProcessDetails}
+         */
+        return {
+            type: 'docker',
+            pid: container.id,
+            output: outputEvents,
+            stop: async () => {
+                if (!container) {
+                    return;
+                }
+
+                try {
+                    await container.stop();
+                    if (deleteOnExit) {
+                        await container.delete();
+                    }
+                } catch (e) {}
+                container = null;
+            },
+            logs: () => {
+                return logs.getLogs();
+            }
+        };
+    }
+
+
+    /**
+     * Starts local process using docker
+     * @param {BlockInstanceInfo} blockInstance
+     * @param {BlockInfo} blockInfo
+     * @param {EnvironmentVariables} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
+    async _startDockerProcess(blockInstance, blockInfo, env) {
+        const {versionFile} = ClusterConfig.getRepositoryAssetInfoPath(
+            blockInfo.handle,
+            blockInfo.name,
+            blockInfo.version
+        );
+
+        const versionYml = versionFile;
+        if (!FS.existsSync(versionYml)) {
+            throw new Error(`Did not find version info at the expected path: ${versionYml}`);
+        }
+
+        const versionInfo = readYML(versionYml);
+
+        if (versionInfo?.artifact?.type !== 'docker') {
+            throw new Error(`Unsupported artifact type: ${versionInfo?.artifact?.type}`);
+        }
+        const dockerImage = versionInfo?.artifact?.details?.primary;
+        if (!dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
+        }
+
+        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const logs = new LogData();
+        let container = await containerManager.getContainerByName(containerName);
+
+        if (container) {
+            if (container.data.State === 'running') {
+                logs.addLog(`Found existing running container for block: ${containerName}`);
+            } else {
+                logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
+                await container.start();
+            }
+        } else {
+            logs.addLog(`Creating new container for block: ${containerName}`);
+            container = await containerManager.startContainer({
+                Image: dockerImage,
+                name: containerName,
+                Binds: [
+                    `${ClusterConfig.getKapetaBasedir()}:${ClusterConfig.getKapetaBasedir()}`
+                ],
+                Labels: {
+                    'instance': blockInstance.id
+                },
+                Env: [
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries(env).map(([key, value]) => `${key}=${value}`)
+                ]
+            });
+        }
+
+        return this._handleContainer(container, logs);
+    }
+
+    async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
+        const {assetFile} = ClusterConfig.getRepositoryAssetInfoPath(
+            blockUri.handle,
+            blockUri.name,
+            blockUri.version
+        );
+
+        const kapetaYmlPath = assetFile;
+        if (!FS.existsSync(kapetaYmlPath)) {
+            throw new Error(`Did not find kapeta.yml at the expected path: ${kapetaYmlPath}`);
+        }
+
+        const spec = providerDefinition.definition.spec;
+        const providerRef = `${providerDefinition.definition.metadata.name}:${providerDefinition.version}`;
+
+        if (!spec?.local?.image) {
+            throw new Error(`Provider did not have local image: ${providerRef}`);
+        }
+
+        const dockerImage = spec?.local?.image;
+
+        try {
+            await containerManager.pull(dockerImage);
+        } catch (e) {
+            console.warn('Failed to pull image. Continuing...', e);
+        }
+
+        const containerName = `kapeta-block-instance-${md5(blockInstance.id)}`;
+        const logs = new LogData();
+        let container = await containerManager.getContainerByName(containerName);
+
+        if (container) {
+            if (container.data.State === 'running') {
+                logs.addLog(`Found existing running container for block: ${containerName}`);
+            } else {
+                if (container.data.State?.ExitCode > 0) {
+                    logs.addLog(`Container exited with code: ${container.data.State.ExitCode}. Deleting...`);
+                    try {
+                        await container.delete()
+                    } catch (e) {}
+                    container = null;
+                } else {
+                    logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
+                    try {
+                        await container.start();
+                    } catch (e) {
+                        console.warn('Failed to start container. Deleting...', e);
+                        try {
+                            await container.delete()
+                        } catch (e) {}
+                        container = null;
+                    }
+                }
+            }
+        }
+
+        if (!container) {
+            const ExposedPorts = {};
+            const addonEnv = {};
+            const PortBindings = {};
+            const promises = Object.entries(spec.local.ports)
+                .map(async ([portType, value]) => {
+                    const dockerPort = `${value.port}/${value.type}`;
+                    ExposedPorts[dockerPort] = {};
+                    addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
+                    const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+                    PortBindings[dockerPort] = [
+                        {
+                            HostIp: "127.0.0.1", //No public
+                            HostPort: `${publicPort}`
+                        }
+                    ];
+                });
+
+            await Promise.all(promises);
+
+            logs.addLog(`Creating new container for block: ${containerName}`);
+            container = await containerManager.startContainer({
+                Image: dockerImage,
+                name: containerName,
+                ExposedPorts,
+                HostConfig: {
+                    Binds: [
+                        `${kapetaYmlPath}:/kapeta.yml:ro`,
+                        `${ClusterConfig.getKapetaBasedir()}:${ClusterConfig.getKapetaBasedir()}`
+                    ],
+                    PortBindings
+                },
+                Labels: {
+                    'instance': blockInstance.id
+                },
+                Env: [
+                    `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries({
+                        ...env,
+                        ...addonEnv
+                    }).map(([key, value]) => `${key}=${value}`)
+                ]
+            });
+        }
+
+        return this._handleContainer(container, logs, true);
+    }
+}
+
+module.exports = BlockInstanceRunner;