@kapeta/local-cluster-service 0.5.5 → 0.5.7

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.5.7](https://github.com/kapetacom/local-cluster-service/compare/v0.5.6...v0.5.7) (2023-06-17)
+
+
+### Bug Fixes
+
+* Register non-docker processes correctly ([#32](https://github.com/kapetacom/local-cluster-service/issues/32)) ([a6e1693](https://github.com/kapetacom/local-cluster-service/commit/a6e1693c32df233f1a16dd406ac0008f07fb3a1d))
+
+## [0.5.6](https://github.com/kapetacom/local-cluster-service/compare/v0.5.5...v0.5.6) (2023-06-17)
+
+
+### Bug Fixes
+
+* Resolve operator versions from resources ([#31](https://github.com/kapetacom/local-cluster-service/issues/31)) ([dfd6471](https://github.com/kapetacom/local-cluster-service/commit/dfd647118ffdb5544d87743543152efd124d3310))
+
 ## [0.5.5](https://github.com/kapetacom/local-cluster-service/compare/v0.5.4...v0.5.5) (2023-06-16)
 
 

package/package.json

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

package/src/config/routes.js

@@ -129,7 +129,7 @@ router.get('/provides/:type', async (req, res) => {
  * assign port numbers to it etc.
  */
 router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
-    const operatorInfo = await operatorManager.getResourceInfo(
+    const operatorInfo = await operatorManager.getConsumerResourceInfo(
         req.kapeta.systemId,
         req.kapeta.instanceId,
         req.params.resourceType,

package/src/containerManager.js

@@ -136,8 +136,18 @@ class ContainerManager {
                     return;
                 }
             }
+
+            const imageTagList = (await this.docker().image.list())
+                .filter(image => !!image.data.RepoTags)
+                .map(image => image.data.RepoTags);
+            if (imageTagList.some((imageTags) => imageTags.indexOf(image) > -1)) {
+                console.log('Image found: %s', image);
+                return;
+            }
+            console.log('Image not found: %s', image);
         }
 
+        console.log('Pulling image: %s', image);
         await this.docker()
             .image.create(
                 {},
@@ -149,6 +159,8 @@ class ContainerManager {
             .then((stream) => promisifyStream(stream));
 
         IMAGE_PULL_CACHE[image] = Date.now();
+
+        console.log('Image pulled: %s', image);
     }
 
     toDockerMounts(mounts) {
@@ -193,12 +205,8 @@ class ContainerManager {
             kapeta: 'true',
         };
 
-        console.log('Pulling image: %s', image);
-
         await this.pull(image);
 
-        console.log('Image pulled: %s', image);
-
         const ExposedPorts = {};
 
         _.forEach(opts.ports, (portInfo, containerPort) => {
@@ -227,8 +235,10 @@ class ContainerManager {
         const dockerContainer = await this.startContainer({
             name: name,
             Image: image,
+            Hostname: name + '.kapeta',
             Labels,
             Cmd: opts.cmd,
+
             ExposedPorts,
             Env,
             HealthCheck,

package/src/instances/routes.js

@@ -99,7 +99,6 @@ router.use('/', (req, res, next) => {
 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(
@@ -109,7 +108,11 @@ router.put('/', async (req, res) => {
         if (oldInstance) {
             instance.pid = oldInstance.pid;
         }
+        instance.type = 'docker';
+    } else if (req.kapeta.environment === 'process') {
+        instance.type = 'process';
     }
+
     await instanceManager.registerInstance(
         req.kapeta.systemId,
         req.kapeta.instanceId,

package/src/operatorManager.js

@@ -6,6 +6,7 @@ const _ = require('lodash');
 const mkdirp = require('mkdirp');
 const Path = require('path');
 const md5 = require('md5');
+const {parseKapetaUri} = require("@kapeta/nodejs-utils");
 
 const KIND_OPERATOR = 'core/resource-type-operator';
 
@@ -38,31 +39,33 @@ class OperatorManager {
     /**
      * Get operator definition for resource type
      *
-     * @param resourceType
+     * @param {string} resourceType
+     * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType) {
+    getOperator(resourceType, version) {
         const operators = ClusterConfiguration.getDefinitions(KIND_OPERATOR);
 
         const operator = _.find(operators, (operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
-            operator.definition.metadata.name.toLowerCase() === resourceType.toLowerCase());
+            operator.definition.metadata.name.toLowerCase() === resourceType.toLowerCase() &&
+            operator.version === version);
 
         if (!operator) {
-            throw new Error('Unknown resource type: ' + resourceType);
+            throw new Error(`Unknown resource type: ${resourceType}:${version}`);
         }
 
         if (!operator.definition.spec ||
             !operator.definition.spec.local) {
-            throw new Error('Operator missing local definition: ' + resourceType);
+            throw new Error(`Operator missing local definition: ${resourceType}:${version}`);
         }
 
         return new Operator(operator.definition.spec.local);
     }
 
     /**
-     * Get information about a specific resource
+     * Get information about a specific consumed resource
      *
      * @param {string} systemId
      * @param {string} fromServiceId
@@ -71,14 +74,40 @@ class OperatorManager {
      * @param {string} name
      * @returns {Promise<{host: string, port: (*|string), type: *, protocol: *, credentials: *}>}
      */
-    async getResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
+    async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
 
-        const operator = this.getOperator(resourceType);
+        const plans = ClusterConfiguration.getDefinitions('core/plan');
 
-        const credentials = operator.getCredentials();
+        const planUri = parseKapetaUri(systemId);
+        const currentPlan = plans.find(plan => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
+        if (!currentPlan) {
+            throw new Error(`Unknown plan: ${systemId}`);
+        }
+
+        const currentInstance = currentPlan.definition.spec.blocks?.find(instance => instance.id === fromServiceId);
+        if (!currentInstance) {
+            throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
+        }
+
+        const blockUri = parseKapetaUri(currentInstance.block.ref);
+        const blockDefinition = ClusterConfiguration.getDefinitions().find(definition =>
+            definition.version === blockUri.version &&
+            definition.definition.metadata.name === blockUri.fullName
+        );
 
-        const container = await this.ensureResource(systemId, resourceType);
+        if (!blockDefinition) {
+            throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
+        }
+
+        const blockResource = blockDefinition.definition.spec?.consumers?.find(resource => resource.metadata.name === name);
+        if (!blockResource) {
+            throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
+        }
 
+        const kindUri = parseKapetaUri(blockResource.kind);
+        const operator = this.getOperator(resourceType, kindUri.version);
+        const credentials = operator.getCredentials();
+        const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
 
         if (!portInfo) {
@@ -102,12 +131,13 @@ class OperatorManager {
     /**
      * Ensure we have a running operator of given type
      *
-     * @param systemId
-     * @param resourceType
+     * @param {string} systemId
+     * @param {string} resourceType
+     * @param {string} version
      * @return {Promise<ContainerInfo>}
      */
-    async ensureResource(systemId, resourceType) {
-        const operator = this.getOperator(resourceType);
+    async ensureResource(systemId, resourceType, version) {
+        const operator = this.getOperator(resourceType, version);
 
         const operatorData = operator.getData();
 

package/src/utils/BlockInstanceRunner.js

@@ -250,6 +250,7 @@ class BlockInstanceRunner {
         container = await containerManager.startContainer({
             Image: dockerImage,
             name: containerName,
+            Hostname: containerName + '.kapeta',
             WorkingDir: workingDir,
             Labels: {
                 'instance': blockInstance.id
@@ -397,6 +398,7 @@ class BlockInstanceRunner {
             container = await containerManager.startContainer({
                 Image: dockerImage,
                 name: containerName,
+                Hostname: containerName + '.kapeta',
                 Labels: {
                     'instance': blockInstance.id
                 },
@@ -528,6 +530,7 @@ class BlockInstanceRunner {
             container = await containerManager.startContainer({
                 Image: dockerImage,
                 name: containerName,
+                Hostname: containerName + '.kapeta',
                 ExposedPorts,
                 HealthCheck,
                 HostConfig: {