@kapeta/local-cluster-service 0.17.0 → 0.18.0

package/src/operatorManager.ts

@@ -15,6 +15,7 @@ import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';
 
 export const KIND_OPERATOR = 'core/resource-type-operator';
+const KIND_PLAN = 'core/plan';
 
 class Operator {
     private readonly _data: DefinitionInfo;
@@ -57,8 +58,8 @@ class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType: string, version: string) {
-        const operators = definitionsManager.getDefinitions(KIND_OPERATOR);
+    async getOperator(resourceType: string, version: string) {
+        const operators = await definitionsManager.getDefinitions(KIND_OPERATOR);
 
         const operator: DefinitionInfo | undefined = operators.find(
             (operator) =>
@@ -92,7 +93,7 @@ class OperatorManager {
         environment?: EnvironmentType
     ): Promise<OperatorInfo> {
         systemId = normalizeKapetaUri(systemId);
-        const plans = definitionsManager.getDefinitions('core/plan');
+        const plans = await definitionsManager.getDefinitions(KIND_PLAN);
 
         const planUri = parseKapetaUri(systemId);
         const currentPlan = plans.find(
@@ -109,13 +110,7 @@ class OperatorManager {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
 
-        const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = definitionsManager
-            .getDefinitions()
-            .find(
-                (definition) =>
-                    definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName
-            );
+        const blockDefinition = await definitionsManager.getDefinition(currentInstance.block.ref);
 
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
@@ -129,7 +124,7 @@ class OperatorManager {
         }
 
         const kindUri = parseKapetaUri(blockResource.kind);
-        const operator = this.getOperator(resourceType, kindUri.version);
+        const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
@@ -164,7 +159,7 @@ class OperatorManager {
         systemId = normalizeKapetaUri(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = this.getOperator(resourceType, version);
+            const operator = await this.getOperator(resourceType, version);
 
             const operatorData = operator.getLocalData();
 

package/src/providerManager.ts

@@ -3,12 +3,14 @@ import FSExtra from 'fs-extra';
 import { definitionsManager } from './definitionsManager';
 import { cacheManager } from './cacheManager';
 import request from 'request';
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 
 const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 
 class ProviderManager {
-    getWebProviders() {
-        return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    async getWebProviders(): Promise<DefinitionInfo[]> {
+        const providers = await definitionsManager.getProviderDefinitions();
+        return providers.filter((providerDefinition) => providerDefinition.hasWeb);
     }
 
     async getProviderWebJS(handle: string, name: string, version: string, sourceMap: boolean = false) {
@@ -22,7 +24,8 @@ class ProviderManager {
             return FSExtra.readFile(file, 'utf8');
         }
 
-        const installedProvider = this.getWebProviders().find((providerDefinition) => {
+        const providers = await this.getWebProviders();
+        const installedProvider = providers.find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
 
@@ -63,22 +66,27 @@ class ProviderManager {
     }
 }
 
-const providerDefinitions = definitionsManager.getProviderDefinitions();
-
-if (providerDefinitions.length > 0) {
-    console.log('## Loaded the following providers ##');
-    providerDefinitions.forEach((providerDefinition) => {
-        console.log(
-            ' - %s[%s:%s]',
-            providerDefinition.definition.kind,
-            providerDefinition.definition.metadata.name,
-            providerDefinition.version
-        );
-        console.log('   from %s', providerDefinition.path);
+definitionsManager
+    .getProviderDefinitions()
+    .then((providerDefinitions) => {
+        if (providerDefinitions.length > 0) {
+            console.log('## Loaded the following providers ##');
+            providerDefinitions.forEach((providerDefinition) => {
+                console.log(
+                    ' - %s[%s:%s]',
+                    providerDefinition.definition.kind,
+                    providerDefinition.definition.metadata.name,
+                    providerDefinition.version
+                );
+                console.log('   from %s', providerDefinition.path);
+            });
+            console.log('##');
+        } else {
+            console.log('## No providers found ##');
+        }
+    })
+    .catch((e) => {
+        console.error('Failed to load providers', e);
     });
-    console.log('##');
-} else {
-    console.log('## No providers found ##');
-}
 
 export const providerManager = new ProviderManager();

package/src/repositoryManager.ts

@@ -58,19 +58,19 @@ class RepositoryManager {
         return this.watcher.clearSourceOfChangeFor(file);
     }
 
-    public ensureDefaultProviders(): void {
+    public async ensureDefaultProviders(): Promise<void> {
         socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+        const tasks = await this.scheduleInstallation(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
 
-    private _install(refs: string[]): Task[] {
+    private async scheduleInstallation(refs: string[]): Promise<Task[]> {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref: string) => {
             return async () => {
-                if (definitionsManager.exists(ref)) {
+                if (await definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
@@ -97,7 +97,7 @@ class RepositoryManager {
             }
             ref = normalizeKapetaUri(ref);
 
-            if (definitionsManager.exists(ref)) {
+            if (await definitionsManager.exists(ref)) {
                 continue;
             }
 
@@ -126,10 +126,7 @@ class RepositoryManager {
             return;
         }
 
-        const definitions = definitionsManager.getDefinitions();
-        const installedAsset = definitions.find(
-            (d) => d.definition.metadata.name === fullName && d.version === version
-        );
+        const installedAsset = await definitionsManager.getDefinition(`${fullName}:${version}`);
 
         let assetVersion;
         try {
@@ -147,12 +144,12 @@ class RepositoryManager {
 
         let tasks: Task[] | undefined = undefined;
         if (!installedAsset) {
-            tasks = this._install([ref]);
+            tasks = await this.scheduleInstallation([ref]);
         } else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep: Dependency) => dep.name);
             if (refs.length > 0) {
-                tasks = this._install(refs);
+                tasks = await this.scheduleInstallation(refs);
             }
         }
 

package/src/utils/BlockInstanceRunner.ts

@@ -25,8 +25,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 
-function getProvider(uri: KapetaURI) {
-    return definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri: KapetaURI) {
+    const providers = await definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return parseKapetaUri(ref).id === uri.id;
     });
@@ -87,10 +88,7 @@ export class BlockInstanceRunner {
             blockUri.version = 'local';
         }
 
-        const assetVersion = definitionsManager.getDefinitions().find((definitions) => {
-            const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return parseKapetaUri(ref).id === blockUri.id;
-        });
+        const assetVersion = await definitionsManager.getDefinition(blockUri.id);
 
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
@@ -98,7 +96,7 @@ export class BlockInstanceRunner {
 
         const kindUri = parseKapetaUri(assetVersion.definition.kind);
 
-        const providerVersion = getProvider(kindUri);
+        const providerVersion = await getProvider(kindUri);
 
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
@@ -150,7 +148,7 @@ export class BlockInstanceRunner {
 
         const kindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
 
-        const targetVersion = getProvider(kindUri);
+        const targetVersion = await getProvider(kindUri);
 
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);