@kapeta/local-cluster-service 0.36.0 → 0.36.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.36.1](https://github.com/kapetacom/local-cluster-service/compare/v0.36.0...v0.36.1) (2024-02-07)
+
+
+### Bug Fixes
+
+* Ensure consistent naming for containers ([#124](https://github.com/kapetacom/local-cluster-service/issues/124)) ([f6041e7](https://github.com/kapetacom/local-cluster-service/commit/f6041e781797aa76a44dc9fb1f9f37c6d926a079))
+
 # [0.36.0](https://github.com/kapetacom/local-cluster-service/compare/v0.35.0...v0.36.0) (2024-02-06)
 
 

package/dist/cjs/src/utils/BlockInstanceRunner.d.ts

@@ -19,7 +19,10 @@ export declare class BlockInstanceRunner {
     private _startLocalProcess;
     private _startDockerProcess;
     private _startOperatorProcess;
-    private getDockerPortBindings;
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private getServiceBlockPortBindings;
     private ensureContainer;
     private _handleContainer;
 }

package/dist/cjs/src/utils/BlockInstanceRunner.js

@@ -41,16 +41,23 @@ async function getProvider(uri) {
     });
 }
 function resolvePortType(portType) {
-    if (serviceManager_1.HTTP_PORTS.includes(portType)) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
         return serviceManager_1.HTTP_PORT_TYPE;
     }
     return portType;
 }
 exports.resolvePortType = resolvePortType;
-function getProviderPorts(assetVersion, providerVersion) {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
     const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
         ?.map((provider) => {
-        return resolvePortType(provider.spec?.port?.type);
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
     })
         .filter((t) => !!t) ?? [];
     if (out.length === 0) {
@@ -113,7 +120,7 @@ class BlockInstanceRunner {
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -169,7 +176,7 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -241,7 +248,7 @@ class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -374,12 +381,15 @@ class BlockInstanceRunner {
         });
         return task.wait();
     }
-    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

package/dist/cjs/src/utils/utils.js

@@ -35,9 +35,9 @@ async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     }
     if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton) {
-        return `kapeta-instance-operator-${(0, md5_1.default)(systemId + blockType)}`;
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
     }
-    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
 function toPortInfo(port) {

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -19,7 +19,10 @@ export declare class BlockInstanceRunner {
     private _startLocalProcess;
     private _startDockerProcess;
     private _startOperatorProcess;
-    private getDockerPortBindings;
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private getServiceBlockPortBindings;
     private ensureContainer;
     private _handleContainer;
 }

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -41,16 +41,23 @@ async function getProvider(uri) {
     });
 }
 function resolvePortType(portType) {
-    if (serviceManager_1.HTTP_PORTS.includes(portType)) {
+    if (portType && serviceManager_1.HTTP_PORTS.includes(portType.toLowerCase())) {
         return serviceManager_1.HTTP_PORT_TYPE;
     }
     return portType;
 }
 exports.resolvePortType = resolvePortType;
-function getProviderPorts(assetVersion, providerVersion) {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion, providerVersion) {
     const out = assetVersion.definition?.spec?.providers
+        ?.filter((provider) => {
+        // We only support HTTP provider ports for now. Need to figure out how to handle other types
+        return serviceManager_1.HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+    })
         ?.map((provider) => {
-        return resolvePortType(provider.spec?.port?.type);
+        return resolvePortType(provider.spec?.port?.type?.toLowerCase());
     })
         .filter((t) => !!t) ?? [];
     if (out.length === 0) {
@@ -113,7 +120,7 @@ class BlockInstanceRunner {
         }
         else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
@@ -169,7 +176,7 @@ class BlockInstanceRunner {
         delete localContainer.HostConfig;
         delete localContainer.Labels;
         delete localContainer.Env;
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -241,7 +248,7 @@ class BlockInstanceRunner {
         if (!providerVersion) {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion);
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
@@ -374,12 +381,15 @@ class BlockInstanceRunner {
         });
         return task.wait();
     }
-    async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    async getServiceBlockPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();
         const ExposedPorts = {};
         const addonEnv = {};
         const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

package/dist/esm/src/utils/utils.js

@@ -35,9 +35,9 @@ async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     }
     if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton) {
-        return `kapeta-instance-operator-${(0, md5_1.default)(systemId + blockType)}`;
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
     }
-    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
 function toPortInfo(port) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.36.0",
+    "version": "0.36.1",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/utils/BlockInstanceRunner.ts

@@ -48,17 +48,24 @@ async function getProvider(uri: KapetaURI) {
 }
 
 export function resolvePortType(portType: string) {
-    if (HTTP_PORTS.includes(portType)) {
+    if (portType && HTTP_PORTS.includes(portType.toLowerCase())) {
         return HTTP_PORT_TYPE;
     }
     return portType;
 }
 
-function getProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
     const out =
         assetVersion.definition?.spec?.providers
+            ?.filter((provider: any) => {
+                // We only support HTTP provider ports for now. Need to figure out how to handle other types
+                return HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+            })
             ?.map((provider: any) => {
-                return resolvePortType(provider.spec?.port?.type);
+                return resolvePortType(provider.spec?.port?.type?.toLowerCase());
             })
             .filter((t: any) => !!t) ?? [];
 
@@ -137,7 +144,7 @@ export class BlockInstanceRunner {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         } else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
@@ -217,7 +224,7 @@ export class BlockInstanceRunner {
         delete localContainer.Labels;
         delete localContainer.Env;
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             providerVersion
@@ -317,7 +324,7 @@ export class BlockInstanceRunner {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             providerVersion
@@ -497,7 +504,10 @@ export class BlockInstanceRunner {
         return task.wait();
     }
 
-    private async getDockerPortBindings(
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private async getServiceBlockPortBindings(
         blockInstance: BlockProcessParams,
         assetVersion: DefinitionInfo,
         providerVersion: DefinitionInfo
@@ -507,7 +517,7 @@ export class BlockInstanceRunner {
         const addonEnv: StringMap = {};
         const PortBindings: AnyMap = {};
 
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

package/src/utils/utils.ts

@@ -11,7 +11,7 @@ import _ from 'lodash';
 import { AnyMap, PortInfo } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { definitionsManager } from '../definitionsManager';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { KIND_BLOCK_OPERATOR } from '../operatorManager';
 import { assetManager } from '../assetManager';
 
@@ -35,10 +35,10 @@ export async function getBlockInstanceContainerName(systemId: string, instanceId
         parseKapetaUri(typeDefinition.definition.kind).fullName === KIND_BLOCK_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton
     ) {
-        return `kapeta-instance-operator-${md5(systemId + blockType)}`;
+        return `kapeta-instance-operator-${md5(normalizeKapetaUri(systemId) + normalizeKapetaUri(blockType))}`;
     }
 
-    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
+    return `kapeta-block-instance-${md5(normalizeKapetaUri(systemId) + instanceId)}`;
 }
 
 export function toPortInfo(port: PortInfo) {