initial import for Open Source 🎉

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

@@ -0,0 +1,293 @@
+import { DockerfileServiceImpl, DockerfileInfoImpl } from './dockerfile.service.impl';
+import { DataFileService } from '../datafile/datafile.service';
+import Spy = jasmine.Spy;
+import { Mock } from 'ts-mocks';
+
+
+describe("DockerfileServiceImpl", () => {
+  var dockerfileServiceImpl: DockerfileServiceImpl;
+  var dataFileServiceMock: Mock<DataFileService>;
+  var dataFileService: DataFileService;
+  var configMock: any;
+  var fileReaderMock: Mock<FileReader>;
+
+  beforeEach(() => {
+    dataFileServiceMock = new Mock<DataFileService>();
+    dataFileService = dataFileServiceMock.Object;
+    configMock = jasmine.createSpyObj('configMock', ['getDomain']);
+    fileReaderMock = new Mock<FileReader>();
+    dockerfileServiceImpl = new DockerfileServiceImpl(dataFileService, configMock, () => fileReaderMock.Object);
+  });
+
+  describe("getDockerfile", () => {
+    var file: any;
+    var invalidArchiveFile: any[];
+    var validArchiveFile: any[];
+    var forDataSpy: Spy;
+
+    beforeEach(() => {
+      file = "FROM quay.io/coreos/nginx:latest";
+      validArchiveFile = [{name: 'Dockerfile', path: 'Dockerfile', toBlob: jasmine.createSpy('toBlobSpy').and.returnValue(file)}];
+      invalidArchiveFile = [{name: 'main.exe', path: 'main.exe', toBlob: jasmine.createSpy('toBlobSpy').and.returnValue("")}];
+
+      dataFileServiceMock.setup(mock => mock.readDataArrayAsPossibleArchive).is((buf, success, failure) => {
+        failure([]);
+      });
+
+      dataFileServiceMock.setup(mock => mock.arrayToString).is((buf, callback) => callback(""));
+
+      dataFileServiceMock.setup(mock => mock.blobToString).is((blob, callback) => callback(blob.toString()));
+
+      forDataSpy = spyOn(DockerfileInfoImpl, "forData").and.returnValue(new DockerfileInfoImpl(file, configMock));
+
+      fileReaderMock.setup(mock => mock.readAsArrayBuffer).is((blob: Blob) => {
+        fileReaderMock.Object.onload(<any>{target: {result: file}});
+      });
+    });
+
+    it("calls datafile service to read given file as possible archive file", (done) => {
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          expect((<Spy>fileReaderMock.Object.readAsArrayBuffer).calls.argsFor(0)[0]).toEqual(file);
+          expect(dataFileService.readDataArrayAsPossibleArchive).toHaveBeenCalled();
+          done();
+        })
+        .catch((error: string) => {
+          fail('Promise should be resolved');
+          done();
+        });
+    });
+
+    it("calls datafile service to convert file to string if given file is not an archive", (done) => {
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          expect((<Spy>dataFileService.arrayToString).calls.argsFor(0)[0]).toEqual(file);
+          done();
+        })
+        .catch((error: string) => {
+          fail('Promise should be resolved');
+          done();
+        });
+    });
+
+    it("returns rejected promise if given non-archive file that is not a valid Dockerfile", (done) => {
+      forDataSpy.and.returnValue(null);
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          fail("Promise should be rejected");
+          done();
+        })
+        .catch((error: string) => {
+          expect(error).toEqual('File chosen is not a valid Dockerfile');
+          done();
+        });
+    });
+
+    it("returns resolved promise with new DockerfileInfoImpl instance if given valid Dockerfile", (done) => {
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          expect(dockerfile).toBeDefined();
+          done();
+        })
+        .catch((error: string) => {
+          fail('Promise should be resolved');
+          done();
+        });
+    });
+
+    it("returns rejected promise if given archive file with no Dockerfile present in root directory", (done) => {
+      dataFileServiceMock.setup(mock => mock.readDataArrayAsPossibleArchive).is((buf, success, failure) => {
+        success(invalidArchiveFile);
+      });
+
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          fail('Promise should be rejected');
+          done();
+        })
+        .catch((error: string) => {
+          expect(error).toEqual('No Dockerfile found in root of archive');
+          done();
+        });
+    });
+
+    it("calls datafile service to convert blob to string if given file is an archive", (done) => {
+      dataFileServiceMock.setup(mock => mock.readDataArrayAsPossibleArchive).is((buf, success, failure) => {
+        success(validArchiveFile);
+      });
+
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          expect(validArchiveFile[0].toBlob).toHaveBeenCalled();
+          expect((<Spy>dataFileService.blobToString).calls.argsFor(0)[0]).toEqual(validArchiveFile[0].toBlob());
+          done();
+        })
+        .catch((error: string) => {
+          fail('Promise should be resolved');
+          done();
+        });
+    });
+
+    it("returns rejected promise if given archive file with invalid Dockerfile", (done) => {
+      forDataSpy.and.returnValue(null);
+      invalidArchiveFile[0].name = 'Dockerfile';
+      invalidArchiveFile[0].path = 'Dockerfile';
+      dataFileServiceMock.setup(mock => mock.readDataArrayAsPossibleArchive).is((buf, success, failure) => {
+        success(invalidArchiveFile);
+      });
+
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          fail('Promise should be rejected');
+          done();
+        })
+        .catch((error: string) => {
+          expect(error).toEqual('Dockerfile inside archive is not a valid Dockerfile');
+          done();
+        });
+    });
+
+    it("returns resolved promise of new DockerfileInfoImpl instance if given archive with valid Dockerfile", (done) => {
+      dataFileServiceMock.setup(mock => mock.readDataArrayAsPossibleArchive).is((buf, success, failure) => {
+        success(validArchiveFile);
+      });
+
+      dockerfileServiceImpl.getDockerfile(file)
+        .then((dockerfile: DockerfileInfoImpl) => {
+          expect(dockerfile).toBeDefined();
+          done();
+        })
+        .catch((error: string) => {
+          fail('Promise should be resolved');
+          done();
+        });
+    });
+  });
+});
+
+
+describe("DockerfileInfoImpl", () => {
+  var dockerfileInfoImpl: DockerfileInfoImpl;
+  var contents: string;
+  var configMock: any;
+
+  beforeEach(() => {
+    contents = "";
+    configMock = jasmine.createSpyObj('configMock', ['getDomain']);
+    dockerfileInfoImpl = new DockerfileInfoImpl(contents, configMock);
+  });
+
+  describe("forData", () => {
+
+    it("returns null if given contents do not contain a 'FROM' command", () => {
+      expect(DockerfileInfoImpl.forData(contents, configMock)).toBe(null);
+    });
+
+    it("returns a new DockerfileInfoImpl instance if given contents are valid", () => {
+      contents = "FROM quay.io/coreos/nginx";
+
+      expect(DockerfileInfoImpl.forData(contents, configMock) instanceof DockerfileInfoImpl).toBe(true);
+    });
+  });
+
+  describe("getRegistryBaseImage", () => {
+    var domain: string;
+    var baseImage: string;
+
+    beforeEach(() => {
+      domain = "quay.io";
+      baseImage = "coreos/nginx";
+
+      configMock.getDomain.and.returnValue(domain);
+    });
+
+    it("returns null if instance's contents do not contain a 'FROM' command", () => {
+      var getBaseImageSpy: Spy = spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue(null);
+
+      expect(dockerfileInfoImpl.getRegistryBaseImage()).toBe(null);
+      expect(getBaseImageSpy).toHaveBeenCalled();
+    });
+
+    it("returns null if the domain of the instance's config does not match that of the base image", () => {
+      configMock.getDomain.and.returnValue(domain);
+      spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue('host.com');
+
+      expect(dockerfileInfoImpl.getRegistryBaseImage()).toBe(null);
+      expect(configMock.getDomain).toHaveBeenCalled();
+    });
+
+    it("returns the registry base image", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue(`${domain}/${baseImage}`);
+
+      expect(dockerfileInfoImpl.getRegistryBaseImage()).toEqual(baseImage);
+    });
+  });
+
+  describe("getBaseImage", () => {
+    var host: string;
+    var port: number;
+    var tag: string;
+    var image: string;
+
+    beforeEach(() => {
+      host = 'quay.io';
+      port = 80;
+      tag = 'latest';
+      image = 'coreos/nginx';
+    });
+
+    it("returns null if instance's contents do not contain a 'FROM' command", () => {
+      var getBaseImageAndTagSpy: Spy = spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(null);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toBe(null);
+      expect(getBaseImageAndTagSpy).toHaveBeenCalled();
+    });
+
+    it("returns the image name if in the format 'someimage'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(image);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(image);
+    });
+
+    it("returns the image name if in the format 'someimage:tag'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${image}:${tag}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(image);
+    });
+
+    it("returns the host, port, and image name if in the format 'host:port/someimage'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${host}:${port}/${image}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(`${host}:${port}/${image}`);
+    });
+
+    it("returns the host, port, and image name if in the format 'host:port/someimage:tag'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${host}:${port}/${image}:${tag}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(`${host}:${port}/${image}`);
+    });
+  });
+
+  describe("getBaseImageAndTag", () => {
+
+    it("returns null if instance's contents do not contain a 'FROM' command", () => {
+      expect(dockerfileInfoImpl.getBaseImageAndTag()).toBe(null);
+    });
+
+    it("returns a string containing the base image and tag from the instance's contents", () => {
+      contents = "FROM quay.io/coreos/nginx";
+      dockerfileInfoImpl = new DockerfileInfoImpl(contents, configMock);
+      var baseImageAndTag: string = dockerfileInfoImpl.getBaseImageAndTag();
+
+      expect(baseImageAndTag).toEqual(contents.substring('FROM '.length, contents.length).trim());
+    });
+
+    it("handles the presence of newlines", () => {
+      contents = "FROM quay.io/coreos/nginx\nRUN echo $0";
+      dockerfileInfoImpl = new DockerfileInfoImpl(contents, configMock);
+      var baseImageAndTag: string = dockerfileInfoImpl.getBaseImageAndTag();
+
+      expect(baseImageAndTag).toEqual(contents.substring('FROM '.length, contents.indexOf('\n')).trim());
+    });
+  });
+});

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

@@ -0,0 +1,155 @@
+import { DockerfileService, DockerfileInfo } from './dockerfile.service';
+import { Injectable, Inject } from 'ng-metadata/core';
+import { DataFileService } from '../datafile/datafile.service';
+
+
+@Injectable(DockerfileService.name)
+export class DockerfileServiceImpl implements DockerfileService {
+
+  constructor(@Inject(DataFileService.name) private DataFileService: DataFileService,
+              @Inject('Config') private Config: any,
+              @Inject('fileReaderFactory') private fileReaderFactory: () => FileReader) {
+
+  }
+
+  public getDockerfile(file: any): Promise<DockerfileInfoImpl | string> {
+    return new Promise((resolve, reject) => {
+      var reader: FileReader = this.fileReaderFactory();
+      reader.onload = (event: any) => {
+        this.DataFileService.readDataArrayAsPossibleArchive(event.target.result,
+          (files: any[]) => {
+            if (files.length > 0) {
+              this.processFiles(files)
+                .then((dockerfileInfo: DockerfileInfoImpl) => resolve(dockerfileInfo))
+                .catch((error: string) => reject(error));
+            }
+            // Not an archive. Read directly as a single file.
+            else {
+              this.processFile(event.target.result)
+                .then((dockerfileInfo: DockerfileInfoImpl) => resolve(dockerfileInfo))
+                .catch((error: string) => reject(error));
+            }
+          },
+          () => {
+            // Not an archive. Read directly as a single file.
+            this.processFile(event.target.result)
+              .then((dockerfileInfo: DockerfileInfoImpl) => resolve(dockerfileInfo))
+              .catch((error: string) => reject(error));
+          });
+      };
+
+      reader.onerror = (event: any) => reject(event);
+      reader.readAsArrayBuffer(file);
+    });
+  }
+
+  private processFile(dataArray: any): Promise<DockerfileInfoImpl | string> {
+    return new Promise((resolve, reject) => {
+      this.DataFileService.arrayToString(dataArray, (contents: string) => {
+        var result: DockerfileInfoImpl | null = DockerfileInfoImpl.forData(contents, this.Config);
+        if (result == null) {
+          reject('File chosen is not a valid Dockerfile');
+        }
+        else {
+          resolve(result);
+        }
+      });
+    });
+  }
+
+  private processFiles(files: any[]): Promise<DockerfileInfoImpl | string> {
+    return new Promise((resolve, reject) => {
+      var found: boolean = false;
+      files.forEach((file) => {
+        if (file['path'] == 'Dockerfile' || file['path'] == '/Dockerfile') {
+          this.DataFileService.blobToString(file.toBlob(), (contents: string) => {
+            var result: DockerfileInfoImpl | null = DockerfileInfoImpl.forData(contents, this.Config);
+            if (result == null) {
+              reject('Dockerfile inside archive is not a valid Dockerfile');
+            }
+            else {
+              resolve(result);
+            }
+          });
+          found = true;
+        }
+      });
+
+      if (!found) {
+        reject('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(<number>this.config.getDomain().length + 1);
+  }
+
+  public getBaseImage(): string | null {
+    const 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
+    const lastIndex: number = imageAndTag.lastIndexOf(':');
+    if (lastIndex == -1) {
+      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).
+    const afterColon: string = imageAndTag.substring(lastIndex + 1);
+    if (afterColon.indexOf('/') != -1) {
+      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;
+  }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Service which provides helper methods for extracting information out from a Dockerfile
+ * or an archive containing a Dockerfile.
+ */
+export abstract class DockerfileService {
+
+  /**
+   * Retrieve Dockerfile from given file.
+   * @param file Dockerfile or archive file containing Dockerfile.
+   * @return promise Promise which resolves to new DockerfileInfo instance or rejects with error message.
+   */
+  public abstract getDockerfile(file: any): Promise<DockerfileInfo | string>;
+}
+
+
+/**
+ * Model representing information about a specific Dockerfile.
+ */
+export abstract class DockerfileInfo {
+
+  /**
+   * Extract the registry base image from the Dockerfile contents.
+   * @return registryBaseImage The registry base image.
+   */
+  public abstract getRegistryBaseImage(): string | null;
+
+  /**
+   * Extract the base image from the Dockerfile contents.
+   * @return baseImage The base image.
+   */
+  public abstract getBaseImage(): string | null;
+
+  /**
+   * Extract the base image and tag from the Dockerfile contents.
+   * @return baseImageAndTag The base image and tag.
+   */
+  public abstract getBaseImageAndTag(): string | null;
+}