@kapeta/local-cluster-service 0.20.4 → 0.21.1

package/src/utils/BlockInstanceRunner.ts

@@ -1,8 +1,8 @@
 import FS from 'node:fs';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getBindHost, getBlockInstanceContainerName, normalizeKapetaUri, readYML } from './utils';
-import { KapetaURI, parseKapetaUri } from '@kapeta/nodejs-utils';
-import { serviceManager } from '../serviceManager';
+import { getBindHost, getBlockInstanceContainerName, readYML } from './utils';
+import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { DEFAULT_PORT_TYPE, serviceManager } from '../serviceManager';
 import {
     COMPOSE_LABEL_PROJECT,
     COMPOSE_LABEL_SERVICE,
@@ -39,14 +39,22 @@ async function getProvider(uri: KapetaURI) {
     });
 }
 
-function getProviderPorts(assetVersion: DefinitionInfo): string[] {
-    return (
+function getProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
+    const out =
         assetVersion.definition?.spec?.providers
             ?.map((provider: any) => {
                 return provider.spec?.port?.type;
             })
-            .filter((t: any) => !!t) ?? []
-    );
+            .filter((t: any) => !!t) ?? [];
+
+    if (out.length === 0) {
+        if (providerVersion.definition.spec?.defaultPort?.type) {
+            return [providerVersion.definition.spec?.defaultPort?.type];
+        }
+        return [DEFAULT_PORT_TYPE];
+    }
+
+    return out;
 }
 
 export class BlockInstanceRunner {
@@ -114,7 +122,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);
+            const portTypes = getProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
@@ -152,18 +160,26 @@ export class BlockInstanceRunner {
             throw new Error('Missing target kind in block definition');
         }
 
-        const kindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
+        const kindUri = parseKapetaUri(assetVersion.definition.kind);
+
+        const providerVersion = await getProvider(kindUri);
+
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+
+        const targetKindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
 
-        const targetVersion = await getProvider(kindUri);
+        const targetVersion = await getProvider(targetKindUri);
 
         if (!targetVersion) {
-            throw new Error(`Target not found: ${kindUri.id}`);
+            throw new Error(`Target not found: ${targetKindUri.id}`);
         }
 
         const localContainer = targetVersion.definition.spec.local;
 
         if (!localContainer) {
-            throw new Error(`Missing local container information from target: ${kindUri.id}`);
+            throw new Error(`Missing local container information from target: ${targetKindUri.id}`);
         }
 
         const dockerImage = localContainer.image;
@@ -184,13 +200,23 @@ export class BlockInstanceRunner {
         delete localContainer.Labels;
         delete localContainer.Env;
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+            blockInstance,
+            assetVersion,
+            providerVersion
+        );
 
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
+        const realLocalPath = FS.realpathSync(baseDir);
+
+        const Mounts = containerManager.toDockerMounts({
+            [workingDir]: toLocalBindVolume(realLocalPath)
+        });
+
         const systemUri = parseKapetaUri(this._systemId);
 
         return this.ensureContainer({
@@ -219,10 +245,10 @@ export class BlockInstanceRunner {
             HostConfig: {
                 ...customHostConfigs,
                 Binds: [
-                    `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${homeDir}/.kapeta`,
-                    `${toLocalBindVolume(baseDir)}:${workingDir}`,
+                    `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${homeDir}/.kapeta`
                 ],
                 PortBindings,
+                Mounts
             },
         });
     }
@@ -254,7 +280,19 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const kindUri = parseKapetaUri(assetVersion.definition.kind);
+
+        const providerVersion = await getProvider(kindUri);
+
+        if (!providerVersion) {
+            throw new Error(`Block type not found: ${kindUri.id}`);
+        }
+
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+            blockInstance,
+            assetVersion,
+            providerVersion
+        );
 
         const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
 
@@ -332,20 +370,19 @@ export class BlockInstanceRunner {
         const PortBindings: AnyMap = {};
         let HealthCheck = undefined;
         let Mounts: DockerMounts[] = [];
-        const promises = Object.entries(spec.local.ports as { [p: string]: { port: string; type: string } }).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: bindHost,
-                        HostPort: `${publicPort}`,
-                    },
-                ];
-            }
-        );
+        const localPorts = spec.local.ports as { [p: string]: { port: string; type: string } };
+        const promises = Object.entries(localPorts).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: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
 
         await Promise.all(promises);
 
@@ -406,13 +443,17 @@ export class BlockInstanceRunner {
         return out;
     }
 
-    private async getDockerPortBindings(blockInstance: BlockProcessParams, assetVersion: DefinitionInfo) {
+    private async getDockerPortBindings(
+        blockInstance: BlockProcessParams,
+        assetVersion: DefinitionInfo,
+        providerVersion: DefinitionInfo
+    ) {
         const bindHost = getBindHost();
         const ExposedPorts: AnyMap = {};
         const addonEnv: StringMap = {};
         const PortBindings: AnyMap = {};
 
-        const portTypes = getProviderPorts(assetVersion);
+        const portTypes = getProviderPorts(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

@@ -10,19 +10,6 @@ export function getBlockInstanceContainerName(systemId: string, instanceId: stri
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }
 
-export function normalizeKapetaUri(uri: string) {
-    if (!uri) {
-        return '';
-    }
-
-    const uriObj = parseKapetaUri(uri);
-    if (!uriObj.version) {
-        return `kapeta://${parseKapetaUri(uri).fullName}`;
-    }
-
-    return `kapeta://${parseKapetaUri(uri).id}`;
-}
-
 export function readYML(path: string) {
     const rawYaml = FS.readFileSync(path);
 

package/test/proxy/types/rest.test.ts

@@ -1,17 +1,17 @@
-import {getRestMethodId} from "../../../src/proxy/types/rest";
-import {Resource, ResourceMetadata} from '@kapeta/schemas';
+import { getRestMethodId } from '../../../src/proxy/types/rest';
+import { Resource, ResourceMetadata } from '@kapeta/schemas';
 
 describe('getRestMethodId', () => {
     it('should match @Query in url', () => {
         const restResource = new TestResource();
 
-        const restMethodId = getRestMethodId(restResource, "POST", "/names?name=Ib");
+        const restMethodId = getRestMethodId(restResource, 'POST', '/names?name=Ib');
         expect(restMethodId).toBeDefined();
-    })
+    });
 });
 
 class TestResource implements Resource {
-    kind = "";
+    kind = '';
     metadata = new TestResourceMetaData();
 
     get spec(): { [p: string]: any } {
@@ -19,31 +19,31 @@ class TestResource implements Resource {
             methods: [
                 {
                     responseType: {
-                        ref: "Name[]"
+                        ref: 'Name[]',
                     },
-                    method: "GET",
-                    path: "/names",
-                    arguments: {}
+                    method: 'GET',
+                    path: '/names',
+                    arguments: {},
                 },
                 {
                     responseType: {
-                        ref: "Name"
+                        ref: 'Name',
                     },
-                    method: "POST",
-                    path: "/names",
+                    method: 'POST',
+                    path: '/names',
                     arguments: {
                         name: {
-                            type: "string",
-                            transport: "QUERY"
-                        }
-                    }
-                }
-            ]
-        }
-    };
+                            type: 'string',
+                            transport: 'QUERY',
+                        },
+                    },
+                },
+            ],
+        };
+    }
 }
 
 class TestResourceMetaData implements ResourceMetadata {
     [property: string]: any;
-    name: string = "";
-}
+    name: string = '';
+}