refactoring DockerfileService

static/js/services/dockerfile/dockerfile.service.impl.ts

@@ -0,0 +1,147 @@
+import { DockerfileService, DockerfileInfo } from './dockerfile.service';
+import { Injectable } from 'angular-ts-decorators';
+
+
+@Injectable(DockerfileService.name)
+export class DockerfileServiceImpl implements DockerfileService {
+
+  constructor(private DataFileService: any, private Config: any) {
+    console.log(`=================== DockerfileServiceImpl ==========================`);
+  }
+
+  public getDockerfile(file: any,
+                       success: (dockerfile: DockerfileInfoImpl) => void,
+                       failure: (error: Event | string) => void): void {
+    var reader: FileReader = new FileReader();
+    reader.onload = (event: Event) => {
+      var dataArray: any = reader.result;
+      this.DataFileService.readDataArrayAsPossibleArchive(dataArray, (files) => {
+        this.processFiles(files, dataArray, success, failure);
+      }, () => {
+        // Not an archive. Read directly as a single file.
+        this.processFiles([], dataArray, success, failure);
+      });
+    };
+
+    reader.onerror = failure;
+    reader.readAsArrayBuffer(file);
+  }
+
+  public extractDockerfile(file: any): Promise<DockerfileInfoImpl | string> {
+    return new Promise((resolve, reject) => {
+      // TODO: Replace callbacks with promise
+    });
+  }
+
+  private processFiles(files: any,
+                       dataArray: any[],
+                       success: (dockerfile: DockerfileInfoImpl) => void,
+                       failure: (error: ErrorEvent | string) => void): void {
+    // The files array will be empty if the submitted file was not an archive. We therefore
+    // treat it as a single Dockerfile.
+    if (files.length == 0) {
+      this.DataFileService.arrayToString(dataArray, (contents: string) => {
+        var result = DockerfileInfoImpl.forData(contents, Object.assign({}, this.Config));
+        if (!result) {
+          failure('File chosen is not a valid Dockerfile');
+          return;
+        }
+
+        success(result);
+      });
+      return;
+    }
+
+    var found: boolean = false;
+    files.forEach((file) => {
+      if (file['name'] == 'Dockerfile') {
+        this.DataFileService.blobToString(file.toBlob(), (contents: string) => {
+          var result: DockerfileInfoImpl | null = DockerfileInfoImpl.forData(contents, Object.assign({}, this.Config));
+          if (result != null) {
+            failure('Dockerfile inside archive is not a valid Dockerfile');
+            return;
+          }
+
+          success(result);
+        });
+        found = true;
+      }
+    });
+
+    if (!found) {
+      failure('No Dockerfile found in root of archive');
+    }
+  }
+}
+
+
+export class DockerfileInfoImpl implements DockerfileInfo {
+
+  constructor(private contents: string, private config: any) {
+
+  }
+
+  public static forData(contents: string, config: any): DockerfileInfoImpl | null {
+    var dockerfileInfo: DockerfileInfoImpl = null;
+    if (contents.indexOf('FROM ') != -1) {
+      dockerfileInfo = new DockerfileInfoImpl(contents, config);
+    }
+
+    return dockerfileInfo;
+  }
+
+  public getRegistryBaseImage(): string | null {
+    var baseImage = this.getBaseImage();
+    if (!baseImage) {
+      return null;
+    }
+
+    if (baseImage.indexOf(this.config.getDomain() + '/') != 0) {
+      return null;
+    }
+
+    return baseImage.substring(this.config.getDomain().length + 1);
+  }
+
+  public getBaseImage(): string | null {
+    var imageAndTag = this.getBaseImageAndTag();
+    if (!imageAndTag) {
+      return null;
+    }
+
+    // Note, we have to handle a few different cases here:
+    // 1) someimage
+    // 2) someimage:tag
+    // 3) host:port/someimage
+    // 4) host:port/someimage:tag
+    var lastIndex = imageAndTag.lastIndexOf(':');
+    if (lastIndex < 0) {
+      return imageAndTag;
+    }
+
+    // Otherwise, check if there is a / in the portion after the split point. If so,
+    // then the latter is part of the path (and not a tag).
+    var afterColon = imageAndTag.substring(lastIndex + 1);
+    if (afterColon.indexOf('/') >= 0) {
+      return imageAndTag;
+    }
+
+    return imageAndTag.substring(0, lastIndex);
+  }
+
+  public getBaseImageAndTag(): string | null {
+    var baseImageAndTag: string = null;
+
+    const fromIndex: number = this.contents.indexOf('FROM ');
+    if (fromIndex != -1) {
+      var newlineIndex: number = this.contents.indexOf('\n', fromIndex);
+      if (newlineIndex == -1) {
+        newlineIndex = this.contents.length;
+      }
+
+      baseImageAndTag = this.contents.substring(fromIndex + 'FROM '.length, newlineIndex).trim();
+    }
+
+    return baseImageAndTag;
+  }
+}