@kapeta/local-cluster-service 0.0.76 → 0.1.0

package/src/instanceManager.js

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 const request = require('request');
-
-const {BlockInstanceRunner} = require('@kapeta/local-cluster-executor');
+const EventEmitter = require("events");
+const BlockInstanceRunner = require('./utils/BlockInstanceRunner');
 
 const storageService = require('./storageService');
 const socketManager = require('./socketManager');
@@ -68,6 +68,10 @@ class InstanceManager {
 
             if (instance.status !== newStatus) {
                 instance.status = newStatus;
+                console.log(
+                    'Instance status changed: %s %s -> %s',
+                    instance.systemId, instance.instanceId, instance.status
+                )
                 this._emit(instance.systemId, EVENT_STATUS_CHANGED, instance);
                 changed = true;
             }
@@ -85,7 +89,11 @@ class InstanceManager {
 
         if (instance.type === 'docker') {
             const container = await containerManager.get(instance.pid);
-            return await container.isRunning()
+            if (!container) {
+                console.warn('Container not found: %s', instance.pid);
+                return false;
+            }
+            return await container.isRunning();
         }
 
         //Otherwise its just a normal process.
@@ -185,8 +193,12 @@ class InstanceManager {
         if (instance) {
             instance.status = STATUS_STARTING;
             instance.pid = info.pid;
-            instance.type = info.type;
-            instance.health = healthUrl;
+            if (info.type) {
+                instance.type = info.type;
+            }
+            if (healthUrl) {
+                instance.health = healthUrl;
+            }
             this._emit(systemId, EVENT_STATUS_CHANGED, instance);
         } else {
             instance = {
@@ -268,7 +280,9 @@ class InstanceManager {
         try {
             if (instance.type === 'docker') {
                 const container = await containerManager.get(instance.pid);
-                await container.stop();
+                if (container) {
+                    await container.stop();
+                }
                 return;
             }
             process.kill(instance.pid, 'SIGTERM');
@@ -383,7 +397,8 @@ class InstanceManager {
                     message: e.message,
                     time: Date.now()
                 }
-            ]
+            ];
+
             await this.registerInstance(planRef, instanceId, {
                 type: 'local',
                 pid: null,
@@ -401,7 +416,12 @@ class InstanceManager {
             return this._processes[planRef][instanceId] = {
                 pid: -1,
                 type,
-                logs: () => logs
+                logs: () => logs,
+                stop: () => Promise.resolve(),
+                ref: blockRef,
+                id: instanceId,
+                name: blockInstance.name,
+                output: new EventEmitter()
             };
         }
 
@@ -427,7 +447,11 @@ class InstanceManager {
         }
 
         if (this._processes[planRef][instanceId]) {
-            await this._processes[planRef][instanceId].stop();
+            try {
+                await this._processes[planRef][instanceId].stop();
+            } catch (e) {
+                console.error('Failed to stop process for instance: %s -> %s', planRef, instanceId, e);
+            }
             delete this._processes[planRef][instanceId];
         }
     }

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;
     }