@eclipse-che/che-devworkspace-generator 0.0.1-d7aefd7 → 0.0.1-ea73e8b

package/src/generate.ts

@@ -9,9 +9,11 @@
  ***********************************************************************/
 
 import {
+  V221Devfile,
+  V221DevfileMetadata,
   V1alpha2DevWorkspace,
+  V1alpha2DevWorkspaceMetadata,
   V1alpha2DevWorkspaceSpecContributions,
-  V1alpha2DevWorkspaceSpecTemplateComponents,
   V1alpha2DevWorkspaceTemplate,
   V1alpha2DevWorkspaceTemplateSpec,
 } from '@devfile/api';
@@ -21,30 +23,52 @@ import * as fs from 'fs-extra';
 import { DevfileContext } from './api/devfile-context';
 import { DevContainerComponentFinder } from './devfile/dev-container-component-finder';
 
+type DevfileLike = V221Devfile & {
+  metadata: V221DevfileMetadata & {
+    generateName?: string;
+  };
+};
+
 @injectable()
 export class Generate {
-  static readonly MERGE_CONTRIBUTION = 'controller.devfile.io/merge-contribution';
-
   @inject(DevContainerComponentFinder)
   private devContainerComponentFinder: DevContainerComponentFinder;
 
-  async generate(devfileContent: string, editorContent: string, outputFile: string): Promise<DevfileContext> {
-    const context = await this.generateContent(devfileContent, editorContent);
+  async generate(
+    devfileContent: string,
+    editorContent: string,
+    outputFile?: string,
+    injectDefaultComponent?: string,
+    defaultComponentImage?: string
+  ): Promise<DevfileContext> {
+    const context = await this.generateContent(
+      devfileContent,
+      editorContent,
+      injectDefaultComponent,
+      defaultComponentImage
+    );
 
     // write the result
-    // write templates and then DevWorkspace in a single file
-    const allContentArray = context.devWorkspaceTemplates.map(template => jsYaml.dump(template));
-    allContentArray.push(jsYaml.dump(context.devWorkspace));
+    if (outputFile) {
+      // write templates and then DevWorkspace in a single file
+      const allContentArray = context.devWorkspaceTemplates.map(template => jsYaml.dump(template));
+      allContentArray.push(jsYaml.dump(context.devWorkspace));
 
-    const generatedContent = allContentArray.join('---\n');
+      const generatedContent = allContentArray.join('---\n');
 
-    await fs.writeFile(outputFile, generatedContent, 'utf-8');
+      await fs.writeFile(outputFile, generatedContent, 'utf-8');
+    }
 
     console.log(`DevWorkspace ${context.devWorkspaceTemplates[0].metadata.name} was generated.`);
     return context;
   }
 
-  async generateContent(devfileContent: string, editorContent: string): Promise<DevfileContext> {
+  async generateContent(
+    devfileContent: string,
+    editorContent: string,
+    injectDefaultComponent?: string,
+    defaultComponentImage?: string
+  ): Promise<DevfileContext> {
     const devfile = jsYaml.load(devfileContent);
 
     // const originalDevfile = Object.assign({}, devfile);
@@ -55,7 +79,7 @@ export class Generate {
     const editorDevfile = jsYaml.load(editorContent);
 
     // transform it into a devWorkspace template
-    const metadata = editorDevfile.metadata;
+    const metadata = this.createDevWorkspaceMetadata(editorDevfile);
     // add sufix
     metadata.name = `${metadata.name}-${suffix}`;
     delete editorDevfile.metadata;
@@ -68,7 +92,7 @@ export class Generate {
     };
 
     // transform it into a devWorkspace
-    const devfileMetadata = devfile.metadata;
+    const devfileMetadata = this.createDevWorkspaceMetadata(devfile, true);
     const devfileCopy = Object.assign({}, devfile);
     delete devfileCopy.schemaVersion;
     delete devfileCopy.metadata;
@@ -84,6 +108,7 @@ export class Generate {
       metadata: devfileMetadata,
       spec: {
         started: true,
+        routingClass: 'che',
         template: devfileCopy,
         contributions: [editorSpecContribution],
       },
@@ -99,19 +124,28 @@ export class Generate {
       suffix,
     };
 
-    // grab container where to inject controller.devfile.io/merge-contribution attribute
-    let devContainer: V1alpha2DevWorkspaceSpecTemplateComponents = await this.devContainerComponentFinder.find(context);
-
-    // add attributes
-    let devContainerAttributes = devContainer.attributes;
-    if (!devContainerAttributes) {
-      devContainerAttributes = {};
-      devContainerAttributes[Generate.MERGE_CONTRIBUTION] = true;
-      devContainer.attributes = devContainerAttributes;
-    } else {
-      devContainerAttributes[Generate.MERGE_CONTRIBUTION] = true;
-    }
+    // find devContainer component, add a default one if not found
+    await this.devContainerComponentFinder.find(context, injectDefaultComponent, defaultComponentImage);
 
     return context;
   }
+
+  private createDevWorkspaceMetadata(devfile: DevfileLike, addDevfileContent = false): V1alpha2DevWorkspaceMetadata {
+    const devWorkspaceMetadata = {} as V1alpha2DevWorkspaceMetadata;
+    const devfileMetadata = devfile.metadata;
+
+    if (devfileMetadata.name) {
+      devWorkspaceMetadata.name = devfileMetadata.name;
+    }
+    if (devfileMetadata.generateName) {
+      devWorkspaceMetadata.generateName = devfileMetadata.generateName;
+    }
+    if (addDevfileContent) {
+      devWorkspaceMetadata.annotations = {
+        'che.eclipse.org/devfile': jsYaml.dump(devfile),
+      };
+    }
+
+    return devWorkspaceMetadata;
+  }
 }

package/src/github/github-resolver.ts

@@ -18,18 +18,20 @@ import { injectable } from 'inversify';
 export class GithubResolver {
   // eslint-disable-next-line max-len
   static readonly GITHUB_URL_PATTERN =
-    /^(?:http)(?:s)?(?:\:\/\/)github\.com\/(?<repoUser>[^\/]+)\/(?<repoName>[^\/]+)((\/)|(?:\/(blob|tree)\/(?<branchName>[^\/]+)(?:\/(?<subFolder>.*))?))?$/;
+    /^(?<scheme>https?):\/\/(?<host>github(\..+)?\.[^\/]+)\/(?<repoUser>[^\/]+)\/(?<repoName>[^\/]+)((\/)|\/(blob|tree)\/(?<branchName>[^\/]+)(?:\/(?<subFolder>.*))?)?$/;
 
   resolve(link: string): GithubUrl {
     const match = GithubResolver.GITHUB_URL_PATTERN.exec(link);
     if (!match) {
       throw new Error(`Invalid github URL: ${link}`);
     }
+    const scheme = this.getGroup(match, 'scheme');
+    const hostName = this.getGroup(match, 'host');
     const repoUser = this.getGroup(match, 'repoUser');
     const repoName = this.getGroup(match, 'repoName');
     const branchName = this.getGroup(match, 'branchName', 'HEAD');
     const subFolder = this.getGroup(match, 'subFolder');
-    return new GithubUrl(repoUser, repoName, branchName, subFolder);
+    return new GithubUrl(scheme, hostName, repoUser, repoName, branchName, subFolder);
   }
 
   getGroup(match: RegExpExecArray, groupName: string, defaultValue?: string) {

package/src/github/github-url.ts

@@ -12,10 +12,9 @@
  * Provides helper methods on top of github URL to get for example raw content of get relative links
  */
 export class GithubUrl {
-  // raw link
-  static readonly RAW_LINK = 'https://raw.githubusercontent.com';
-
   constructor(
+    private readonly scheme: string,
+    private readonly hostName: string,
     private readonly repoUser: string,
     private readonly repoName: string,
     private readonly branchName: string,
@@ -26,15 +25,16 @@ export class GithubUrl {
    * Provides the raw link to the given path based on the current repository information
    */
   getContentUrl(path: string): string {
-    return `${GithubUrl.RAW_LINK}/${this.repoUser}/${this.repoName}/${this.branchName}/${path}`;
+    const hostName = this.hostName === 'github.com' ? 'githubusercontent.com' : this.hostName;
+    return `${this.scheme}://raw.${hostName}/${this.repoUser}/${this.repoName}/${this.branchName}/${path}`;
   }
 
   getUrl(): string {
-    return `https://github.com/${this.repoUser}/${this.repoName}/tree/${this.branchName}/${this.subFolder}`;
+    return `${this.scheme}://${this.hostName}/${this.repoUser}/${this.repoName}/tree/${this.branchName}/${this.subFolder}`;
   }
 
   getCloneUrl(): string {
-    return `https://github.com/${this.repoUser}/${this.repoName}.git`;
+    return `${this.scheme}://${this.hostName}/${this.repoUser}/${this.repoName}.git`;
   }
 
   getRepoName(): string {

package/src/main.ts

@@ -20,58 +20,45 @@ import { V1alpha2DevWorkspaceSpecTemplate } from '@devfile/api';
 import { DevfileContext } from './api/devfile-context';
 
 export class Main {
-  protected async doStart(): Promise<DevfileContext> {
-    let devfilePath: string | undefined;
-    let devfileUrl: string | undefined;
-    let outputFile: string | undefined;
-    let editorPath: string | undefined;
-    let pluginRegistryUrl: string | undefined;
-    let editorEntry: string | undefined;
-    const projects: { name: string; location: string }[] = [];
+  /**
+   * Default constructor.
+   */
+  constructor() {
+    // no-op
+  }
+  // Generates a devfile context object based on params
+  public async generateDevfileContext(
+    params: {
+      devfilePath?: string;
+      devfileUrl?: string;
+      devfileContent?: string;
+      outputFile?: string;
+      editorPath?: string;
+      editorContent?: string;
+      editorEntry?: string;
+      pluginRegistryUrl?: string;
+      projects: { name: string; location: string }[];
+      injectDefaultComponent?: string;
+      defaultComponentImage?: string;
+    },
+    axiosInstance: axios.AxiosInstance
+  ): Promise<DevfileContext> {
+    if (!params.editorPath && !params.editorEntry && !params.editorContent) {
+      throw new Error('missing editorPath or editorEntry or editorContent');
+    }
+    if (!params.devfilePath && !params.devfileUrl && !params.devfileContent) {
+      throw new Error('missing devfilePath or devfileUrl or devfileContent');
+    }
 
-    const args = process.argv.slice(2);
-    args.forEach(arg => {
-      if (arg.startsWith('--devfile-path:')) {
-        devfilePath = arg.substring('--devfile-path:'.length);
-      }
-      if (arg.startsWith('--devfile-url:')) {
-        devfileUrl = arg.substring('--devfile-url:'.length);
-      }
-      if (arg.startsWith('--plugin-registry-url:')) {
-        pluginRegistryUrl = arg.substring('--plugin-registry-url:'.length);
-      }
-      if (arg.startsWith('--editor-entry:')) {
-        editorEntry = arg.substring('--editor-entry:'.length);
-      }
-      if (arg.startsWith('--editor-path:')) {
-        editorPath = arg.substring('--editor-path:'.length);
-      }
-      if (arg.startsWith('--output-file:')) {
-        outputFile = arg.substring('--output-file:'.length);
-      }
-      if (arg.startsWith('--project.')) {
-        const name = arg.substring('--project.'.length, arg.indexOf('='));
-        let location = arg.substring(arg.indexOf('=') + 1);
-        location = location.replace('{{_INTERNAL_URL_}}', '{{ INTERNAL_URL }}');
+    let pluginRegistryUrl: string;
 
-        projects.push({ name, location });
-      }
-    });
-    if (!editorPath && !editorEntry) {
-      throw new Error('missing --editor-path: or --editor-entry: parameter');
-    }
-    if (editorEntry && !pluginRegistryUrl) {
+    if (params.pluginRegistryUrl) {
+      pluginRegistryUrl = params.pluginRegistryUrl;
+    } else {
       pluginRegistryUrl = 'https://eclipse-che.github.io/che-plugin-registry/main/v3';
       console.log(`No plug-in registry url. Setting to ${pluginRegistryUrl}`);
     }
-    if (!devfilePath && !devfileUrl) {
-      throw new Error('missing --devfile-path: or --devfile-url: parameter');
-    }
-    if (!outputFile) {
-      throw new Error('missing --output-file: parameter');
-    }
 
-    const axiosInstance = axios.default;
     const inversifyBinbding = new InversifyBinding();
     const container = await inversifyBinbding.initBindings({
       pluginRegistryUrl,
@@ -83,9 +70,9 @@ export class Main {
     let editorContent;
 
     // gets the github URL
-    if (devfileUrl) {
+    if (params.devfileUrl) {
       const githubResolver = container.get(GithubResolver);
-      const githubUrl = githubResolver.resolve(devfileUrl);
+      const githubUrl = githubResolver.resolve(params.devfileUrl);
       // user devfile
       devfileContent = await container.get(UrlFetcher).fetchText(githubUrl.getContentUrl('devfile.yaml'));
 
@@ -107,23 +94,33 @@ export class Main {
       }
       // get back the content
       devfileContent = jsYaml.dump(devfileParsed);
+    } else if (params.devfilePath) {
+      devfileContent = await fs.readFile(params.devfilePath);
     } else {
-      devfileContent = await fs.readFile(devfilePath);
+      devfileContent = params.devfileContent;
     }
 
     // enhance projects
-    devfileContent = this.replaceIfExistingProjects(devfileContent, projects);
+    devfileContent = this.replaceIfExistingProjects(devfileContent, params.projects);
 
-    if (editorEntry) {
+    if (params.editorContent) {
+      editorContent = params.editorContent;
+    } else if (params.editorEntry) {
       // devfile of the editor
-      const editorDevfile = await container.get(PluginRegistryResolver).loadDevfilePlugin(editorEntry);
+      const editorDevfile = await container.get(PluginRegistryResolver).loadDevfilePlugin(params.editorEntry);
       editorContent = jsYaml.dump(editorDevfile);
     } else {
-      editorContent = await fs.readFile(editorPath);
+      editorContent = await fs.readFile(params.editorPath);
     }
 
     const generate = container.get(Generate);
-    return generate.generate(devfileContent, editorContent, outputFile);
+    return generate.generate(
+      devfileContent,
+      editorContent,
+      params.outputFile,
+      params.injectDefaultComponent,
+      params.defaultComponentImage
+    );
   }
 
   // Update project entry based on the projects passed as parameter
@@ -154,8 +151,75 @@ export class Main {
   }
 
   async start(): Promise<boolean> {
+    let devfilePath: string | undefined;
+    let devfileUrl: string | undefined;
+    let outputFile: string | undefined;
+    let editorPath: string | undefined;
+    let pluginRegistryUrl: string | undefined;
+    let editorEntry: string | undefined;
+    let injectDefaultComponent: string | undefined;
+    let defaultComponentImage: string | undefined;
+    const projects: { name: string; location: string }[] = [];
+
+    const args = process.argv.slice(2);
+    args.forEach(arg => {
+      if (arg.startsWith('--devfile-path:')) {
+        devfilePath = arg.substring('--devfile-path:'.length);
+      }
+      if (arg.startsWith('--devfile-url:')) {
+        devfileUrl = arg.substring('--devfile-url:'.length);
+      }
+      if (arg.startsWith('--plugin-registry-url:')) {
+        pluginRegistryUrl = arg.substring('--plugin-registry-url:'.length);
+      }
+      if (arg.startsWith('--editor-entry:')) {
+        editorEntry = arg.substring('--editor-entry:'.length);
+      }
+      if (arg.startsWith('--editor-path:')) {
+        editorPath = arg.substring('--editor-path:'.length);
+      }
+      if (arg.startsWith('--output-file:')) {
+        outputFile = arg.substring('--output-file:'.length);
+      }
+      if (arg.startsWith('--project.')) {
+        const name = arg.substring('--project.'.length, arg.indexOf('='));
+        let location = arg.substring(arg.indexOf('=') + 1);
+        location = location.replace('{{_INTERNAL_URL_}}', '{{ INTERNAL_URL }}');
+
+        projects.push({ name, location });
+      }
+      if (arg.startsWith('--injectDefaultComponent:')) {
+        injectDefaultComponent = arg.substring('--injectDefaultComponent:'.length);
+      }
+      if (arg.startsWith('--defaultComponentImage:')) {
+        defaultComponentImage = arg.substring('--defaultComponentImage:'.length);
+      }
+    });
+
     try {
-      await this.doStart();
+      if (!editorPath && !editorEntry) {
+        throw new Error('missing --editor-path: or --editor-entry: parameter');
+      }
+      if (!devfilePath && !devfileUrl) {
+        throw new Error('missing --devfile-path: or --devfile-url: parameter');
+      }
+      if (!outputFile) {
+        throw new Error('missing --output-file: parameter');
+      }
+      await this.generateDevfileContext(
+        {
+          devfilePath,
+          devfileUrl,
+          editorPath,
+          outputFile,
+          pluginRegistryUrl,
+          editorEntry,
+          projects,
+          injectDefaultComponent,
+          defaultComponentImage,
+        },
+        axios.default
+      );
       return true;
     } catch (error) {
       console.error('stack=' + error.stack);

package/src/plugin-registry/plugin-registry-resolver.ts

@@ -26,7 +26,7 @@ export class PluginRegistryResolver {
   @inject(UrlFetcher)
   private urlFetcher: UrlFetcher;
 
-  // FQN id (like eclipse/che-theia/next)
+  // FQN id (like che-incubator/che-code/next)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async loadDevfilePlugin(devfileId: string): Promise<any> {
     const devfileUrl = `${this.pluginRegistryUrl}/plugins/${devfileId}/devfile.yaml`;