Add plugin entity + plugin initialization

Author: kevinwang5658

codify-core/src/commands/plan/orchestrator.ts

@@ -1,13 +1,16 @@
 import { ConfigCompiler } from '../../config-compiler';
-import { PluginsManager } from '../../plugins/manager';
+import { PluginCollection } from '../../plugins/plugin-collection';
 
 export const PlanOrchestrator = {
   async run(rootDirectory: string): Promise<void> {
     const project = await ConfigCompiler.parseProject(rootDirectory);
 
-    const pluginsManager = new PluginsManager();
-    await pluginsManager.initializePlugins(project);
+    const pluginCollection = new PluginCollection();
+    await pluginCollection.initializePlugins(project);
 
+    const resourceDefinitions = await pluginCollection.getAllResourceDefinitions();
+    console.log(resourceDefinitions);
 
+    await pluginCollection.killPlugins();
   },
 };

codify-core/src/config-compiler/index.ts

@@ -6,7 +6,6 @@ import { ParsedModule, ParsedProject } from './parser/entities';
 import { ProjectConfig } from './parser/entities/project';
 import { JsonFileParser } from './parser/json/file-parser';
 
-
 export class ConfigCompiler {
 
   static readonly supportedParsers: Record<string, FileParser> = {
@@ -34,7 +33,7 @@ export class ConfigCompiler {
     const projectConfig = parsedProjectConfigs[0] as ProjectConfig;
     return new ParsedProject({
       coreModule: new ParsedModule({
-        configBlocks: configBlocks.flat(1),
+        configBlocks: configBlocks.filter((u) => u.configType !== ConfigBlockType.PROJECT),
       }),
       projectConfig,
     })

codify-core/src/config-compiler/parser/entities/project.ts

@@ -39,7 +39,11 @@ export class ProjectConfig implements ConfigBlock {
     if (this.validate(config)) {
       this.name = config.name;
       this.plugins = config.plugins;
+
+      return;
     }
+
+    throw new Error('Unable to parse project');
   }
 
   validate(config: unknown): config is RemoveMethods<ProjectConfig> {

codify-core/src/config-compiler/parser/entities/resource.ts

@@ -32,6 +32,8 @@ export class ResourceConfig implements ConfigBlock {
       this.type = type;
       this.name = name;
       this.parameters = params ?? {};
+
+      return;
     }
 
     throw new Error('Unable to parse resource config');
@@ -42,8 +44,8 @@ export class ResourceConfig implements ConfigBlock {
       throw new Error('Config is not an object');
     }
 
-    if (!validateStringEq(config.type, 'project')) {
-      throw new Error('Config is not of type project');
+    if (!validateStringEq(config.type, 'resource')) {
+      throw new Error('Config is not of type resource');
     }
 
     if (config.name && !validateNameString(config.name)) {

codify-core/src/plugins/entities/message.ts

@@ -0,0 +1,4 @@
+export interface PluginMessage {
+  cmd: string;
+  data?: unknown;
+}

codify-core/src/plugins/entities/plugin.ts

@@ -6,13 +6,15 @@ import { validateTypeArray, validateTypeRecordStringUnknown } from '../../utils/
 type ResourceName = string;
 
 export class Plugin {
+
+  // Plugin names should be globally unique
   name: string;
   directory: string;
 
   process: ChildProcess;
   resourceDefinitions?: Map<ResourceName, ResourceDefinition>;
 
-  constructor(name: string, directory: string, process: ChildProcess) {
+  constructor(directory: string, name: string, process: ChildProcess) {
     this.name = name;
     this.directory = directory;
     this.process = process;
@@ -22,22 +24,25 @@ export class Plugin {
     if (this.validate(definitions)) {
       const entries = definitions.map((u) => {
         const resourceDefinition = ResourceDefinition.fromJson(u);
-        return [resourceDefinition.name, resourceDefinition] as const;
+
+        // Append the plugin name to all resources to prevent conflicts across plugins
+        return [`${this.name}_${resourceDefinition.name}`, resourceDefinition] as const;
       })
 
       this.resourceDefinitions = new Map(entries);
+      return;
     }
 
     throw new Error('Unable to parse resource definition');
   }
 
   private validate(definitions: unknown): definitions is Array<Record<string, unknown>> {
     if (!validateTypeArray(definitions)) {
-      return false;
+      throw new Error('Definitions is not of type array')
     }
 
     if (!definitions.every((u) => validateTypeRecordStringUnknown(u))) {
-      return false;
+      throw new Error('Type definitions is not of Record<string, unknown>')
     }
 
     return true;

codify-core/src/plugins/ipc-bridge.ts

@@ -1,34 +1,79 @@
 import * as ChildProcess from 'node:child_process';
 
 import { config } from '../project-configs';
+import { validateTypeRecordStringUnknown } from '../utils/validator';
+import { PluginMessage } from './entities/message';
 import { Plugin } from './entities/plugin';
 
 export class PluginIpcBridge {
 
   static async initializePlugin(directory: string, name: string): Promise<Plugin> {
-    const childProcess = ChildProcess.fork(location + config.defaultPluginEntryPoint);
+    const childProcess = ChildProcess.fork(
+      directory + '/' + name + config.defaultPluginEntryPoint,
+      [],
+      { execArgv: ['-r', 'ts-node/register'], silent: true },
+    );
     const plugin = new Plugin(directory, name, childProcess);
+
+    childProcess.stdout!.on('data', (data) => {
+      console.log(data.toString());
+    });
+
+    childProcess.stderr!.on('data', (data) => {
+      console.log(data.toString());
+    })
+
     await this.initializeResourceDefinitions(plugin);
 
     return plugin;
   }
 
   static async initializeResourceDefinitions(plugin: Plugin): Promise<void> {
-    const resourceDefinitions = await this.sendMessageForResult(plugin, 'getResourceDefinitions');
+    const resourceDefinitions = await this.sendMessageForResult(plugin, { cmd: 'getResourceDefinitions' });
     plugin.setResourceDefinitions(resourceDefinitions);
   }
 
-  private static async sendMessageForResult(plugin: Plugin, rpcFunctionName: string): Promise<void> {
+  static killPlugin(plugin: Plugin): void {
+    plugin.process.kill();
+  }
+
+  private static async sendMessageForResult(plugin: Plugin, message: PluginMessage): Promise<unknown> {
     return new Promise((resolve, reject) => {
-      setTimeout(() => reject(new Error(`Plugin did respond in 10s to call: ${rpcFunctionName}`)), 10_000);
-      plugin.process.on(this.getResultFunctionName(rpcFunctionName), (message) => {
-        resolve(message);
-      });
+      const timer = setTimeout(() => {
+        plugin.process.kill();
+        reject(new Error(`Plugin did not respond in 10s to call: ${message.cmd}`))
+      }, 10_000);
 
-      plugin.process.send(rpcFunctionName);
+      const errorListener = (error: Buffer) => {
+        plugin.process.kill();
+        reject(error.toString());
+      }
+
+      const messageListener = (incomingMessage: unknown) => {
+        console.log(incomingMessage);
+
+        if (!validateTypeRecordStringUnknown(incomingMessage)) {
+          return reject(new Error(`Bad message from plugin ${plugin.name}. ${JSON.stringify(incomingMessage, null, 2)}`))
+        }
+
+        if (incomingMessage.cmd === this.getResultFunctionName(message.cmd)) {
+          clearTimeout(timer);
+          plugin.process.removeListener('message', messageListener);
+          plugin.process.removeListener('error', errorListener);
+          resolve(incomingMessage.data);
+        }
+      };
+
+      plugin.process.on('message', messageListener);
+      plugin.process.stderr!.on('data', errorListener);
+      plugin.process.send(message);
     });
   }
 
+  private sendMessage(plugin: Plugin, message: PluginMessage): void {
+    plugin.process.send(message);
+  }
+
   private static getResultFunctionName(rpcFunctionName: string): string {
     return rpcFunctionName + 'Result';
   }

codify-core/src/plugins/manager.ts

@@ -0,0 +1,63 @@
+import { ParsedProject } from '../config-compiler/parser/entities';
+import { ResourceDefinition } from '../entities/resource-definition';
+import { Plugin } from './entities/plugin';
+import { PluginIpcBridge } from './ipc-bridge';
+import { PluginResolver } from './resolver';
+
+type PluginName = string;
+
+const DEFAULT_PLUGINS = {
+  'default:homebrew': 'latest',
+  // 'default:node': 'latest',
+}
+
+export class PluginCollection {
+
+  private plugins: Map<PluginName, Plugin> = new Map();
+
+  async initializePlugins(project: ParsedProject): Promise<void> {
+    const pluginDefinitions = {
+      ...DEFAULT_PLUGINS,
+      ...project.projectConfig.plugins,
+    };
+
+    const pluginResolver = new PluginResolver();
+    const plugins = await Promise.all(Object.entries(pluginDefinitions).map(([name, version]) =>
+      pluginResolver.resolve(name, version)
+    ));
+
+    for (const u of plugins) {
+      this.plugins.set(u.name, u);
+    }
+  }
+
+  async getAllResourceDefinitions(): Promise<Map<string, ResourceDefinition>> {
+    const result = new Map<string, ResourceDefinition>();
+    for (const plugin of this.plugins.values()) {
+      const { resourceDefinitions } = plugin;
+      if (!resourceDefinitions) {
+        continue;
+      }
+
+      for (const [name, resourceDef] of resourceDefinitions) {
+        if (result.has(name)) {
+          throw new Error(`Resource definition conflict error. Two resource definitions have the same name
+            ${JSON.stringify(resourceDef, null, 2)}
+            ${JSON.stringify(result.get(name))}
+          `,)
+        }
+
+        result.set(name, resourceDef);
+      }
+    }
+
+    return result;
+  }
+
+  async killPlugins(): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      PluginIpcBridge.killPlugin(plugin);
+    }
+  }
+
+}

codify-core/src/plugins/plugin-collection.ts

@@ -3,7 +3,7 @@ import * as fs from 'node:fs/promises';
 import { Plugin } from './entities/plugin';
 import { PluginIpcBridge } from './ipc-bridge';
 
-const DEFAULT_PLUGIN_REGEX = /^default:(.*)/gi
+const DEFAULT_PLUGIN_REGEX = /(?<=default:).*$/g
 
 export class PluginResolver {
 
@@ -20,13 +20,13 @@ export class PluginResolver {
   private async resolveDefaultPlugin(name: string, _version: string): Promise<Plugin> {
     const pluginName = name.match(DEFAULT_PLUGIN_REGEX)![0]
 
-    const defaultPluginDir = '../../../';
-    const pluginDirFiles = await fs.readdir('../../../');
+    const defaultPluginDir = '../plugins';
+    const pluginDirFiles = await fs.readdir(defaultPluginDir);
     if (!pluginDirFiles.includes(pluginName)) {
       throw new Error(`Unable to find default plugin: ${name}`)
     }
 
-    return PluginIpcBridge.initializePlugin(defaultPluginDir, name);
+    return PluginIpcBridge.initializePlugin(defaultPluginDir, pluginName);
   }
 
 }