@kapeta/local-cluster-service 0.0.73 → 0.0.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {

package/src/config/routes.js

@@ -143,12 +143,12 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
  * to handle clients for services that hasn't started yet.
  */
 router.get('/consumes/:resourceName/:type', (req, res) => {
-
     res.send(serviceManager.getConsumerAddress(
         req.kapeta.systemId,
         req.kapeta.instanceId,
         req.params.resourceName,
-        req.params.type
+        req.params.type,
+        req.kapeta.environment,
     ));
 });
 

package/src/instanceManager.js

@@ -8,6 +8,7 @@ const socketManager = require('./socketManager');
 const serviceManager = require('./serviceManager');
 const assetManager = require('./assetManager');
 const containerManager = require('./containerManager');
+const configManager = require("./configManager");
 
 const CHECK_INTERVAL = 10000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
@@ -314,6 +315,7 @@ class InstanceManager {
         const blockRef = blockInstance.block.ref;
 
         const blockAsset = await assetManager.getAsset(blockRef);
+        const instanceConfig = await configManager.getConfigForSection(planRef, instanceId);
 
         if (!blockAsset) {
             throw new Error('Block not found: ' + blockRef);
@@ -324,47 +326,85 @@ class InstanceManager {
         }
 
         await this.stopProcess(planRef, instanceId);
+        const type = blockAsset.version === 'local' ? 'local' : 'docker';
 
         const runner = new BlockInstanceRunner(planRef);
+
         const startTime = Date.now();
-        const process = await runner.start(blockRef, instanceId);
-        //emit stdout/stderr via sockets
-        process.output.on("data", (data) => {
-            const payload = {source: "stdout", level: "INFO", message: data.toString(), time: Date.now()};
-            this._emit(instanceId, EVENT_INSTANCE_LOG, payload);
-        });
+        try {
+            const process = await runner.start(blockRef, instanceId, instanceConfig);
+            //emit stdout/stderr via sockets
+            process.output.on("data", (data) => {
+                const payload = {
+                    source: "stdout",
+                    level: "INFO",
+                    message: data.toString(),
+                    time: Date.now()
+                };
+                this._emit(instanceId, EVENT_INSTANCE_LOG, payload);
+            });
 
-        process.output.on('exit', (exitCode) => {
-            const timeRunning = Date.now() - startTime;
-            const instance = this.getInstance(planRef, instanceId);
-            if (instance.status === STATUS_READY) {
-                //It's already been running
-                return;
-            }
+            process.output.on('exit', (exitCode) => {
+                const timeRunning = Date.now() - startTime;
+                const instance = this.getInstance(planRef, instanceId);
+                if (instance.status === STATUS_READY) {
+                    //It's already been running
+                    return;
+                }
 
-            if (exitCode === 143 ||
-                exitCode === 137) {
-                //Process got SIGTERM (143) or SIGKILL (137)
-                //TODO: Windows?
-                return;
-            }
+                if (exitCode === 143 ||
+                    exitCode === 137) {
+                    //Process got SIGTERM (143) or SIGKILL (137)
+                    //TODO: Windows?
+                    return;
+                }
 
-            if (exitCode !== 0 || timeRunning < MIN_TIME_RUNNING) {
-                this._emit(blockInstance.id, EVENT_INSTANCE_EXITED, {
-                    error: "Failed to start instance",
-                    status: EVENT_INSTANCE_EXITED,
-                    instanceId: blockInstance.id
-                })
-            }
-        });
+                if (exitCode !== 0 || timeRunning < MIN_TIME_RUNNING) {
+                    this._emit(blockInstance.id, EVENT_INSTANCE_EXITED, {
+                        error: "Failed to start instance",
+                        status: EVENT_INSTANCE_EXITED,
+                        instanceId: blockInstance.id
+                    });
+                }
+            });
 
-        await this.registerInstance(planRef, instanceId, {
-            type: process.type,
-            pid: process.pid,
-            health: null
-        });
+            await this.registerInstance(planRef, instanceId, {
+                type: process.type,
+                pid: process.pid,
+                health: null
+            });
+
+            return this._processes[planRef][instanceId] = process;
+        } catch (e) {
+            const logs = [
+                {
+                    source: "stdout",
+                    level: "ERROR",
+                    message: e.message,
+                    time: Date.now()
+                }
+            ]
+            await this.registerInstance(planRef, instanceId, {
+                type: 'local',
+                pid: null,
+                health: null
+            });
+
+            this._emit(instanceId, EVENT_INSTANCE_LOG, logs[0]);
+
+            this._emit(blockInstance.id, EVENT_INSTANCE_EXITED, {
+                error: `Failed to start instance: ${e.message}`,
+                status: EVENT_INSTANCE_EXITED,
+                instanceId: blockInstance.id
+            });
+
+            return this._processes[planRef][instanceId] = {
+                pid: -1,
+                type,
+                logs: () => logs
+            };
+        }
 
-        return this._processes[planRef][instanceId] = process;
     }
 
     /**

package/src/middleware/kapeta.js

@@ -4,11 +4,13 @@ module.exports = function kapeta(req, res, next) {
     let blockRef = req.headers['x-kapeta-block'];
     let systemId = req.headers['x-kapeta-system'];
     let instanceId = req.headers['x-kapeta-instance'];
+    let environment = req.headers['x-kapeta-environment'];
 
     req.kapeta = {
         blockRef,
         instanceId,
-        systemId
+        systemId,
+        environment
     };
 
     next();

package/src/proxy/routes.js

@@ -105,7 +105,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         );
 
         while(address.endsWith('/')) {
-            address = address.substr(0, address.length - 1);
+            address = address.substring(0, address.length - 1);
         }
 
         typeHandler(req, res, {

package/src/serviceManager.js

@@ -21,14 +21,20 @@ class ServiceManager {
         });
     }
 
-    _forLocal(port, path) {
+    _forLocal(port, path, environmentType) {
         if (!path) {
             path = '';
         }
-        const host = clusterService.getClusterServiceHost();
+        let host;
+        if (environmentType === 'docker') {
+            //We're inside a docker container, so we can use this special host name to access the host machine
+            host = 'host.docker.internal';
+        } else {
+            host = clusterService.getClusterServiceHost();
+        }
 
         if (path.startsWith('/')) {
-            path = path.substr(1);
+            path = path.substring(1);
         }
         return `http://${host}:${port}/${path}`;
     }
@@ -84,12 +90,13 @@ class ServiceManager {
      * @param {string} consumerInstanceId
      * @param {string} consumerResourceName
      * @param {string} portType
+     * @param {'docker'|'process'} environmentType
      * @return {string}
      */
-    getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType) {
+    getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
         const port = clusterService.getClusterServicePort();
         const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
-        return this._forLocal(port, path);
+        return this._forLocal(port, path, environmentType);
     }
 
     /**