@gitpod/gitpod-protocol 0.1.5-wth-argo.0 → 0.1.5-yh-vmoptions-fork.1

package/src/encryption/encryption-engine.spec.ts

@@ -5,25 +5,26 @@
  */
 
 import { suite, test } from "mocha-typescript";
-import * as chai from 'chai';
-import * as path from 'path';
+import * as chai from "chai";
+import * as path from "path";
 import * as fs from "fs";
 
 import { EncryptionEngineImpl } from "./encryption-engine";
 
 const expect = chai.expect;
 
-@suite class TestEncryptionEngineImpl {
+@suite
+class TestEncryptionEngineImpl {
     // Created with openssl rand -rand /dev/urandom -out key -base64 32
-    protected get testkey () {
-        const keyFilePath = path.resolve(__dirname, '../../test/fixtures/encryption/testkey');
+    protected get testkey() {
+        const keyFilePath = path.resolve(__dirname, "../../test/fixtures/encryption/testkey");
         const keyBuffer = fs.readFileSync(keyFilePath);
         return keyBuffer.toString().trim();
-    };
+    }
 
     @test basicSymmetry() {
         const plaintext = "12345678901234567890";
-        const key = new Buffer(this.testkey, 'base64');
+        const key = new Buffer(this.testkey, "base64");
 
         const cut = new EncryptionEngineImpl();
         const encryptedData = cut.encrypt(plaintext, key);
@@ -33,4 +34,4 @@ const expect = chai.expect;
         expect(decryptedPlaintext).equals(plaintext);
     }
 }
-export const t = new TestEncryptionEngineImpl();
+export const t = new TestEncryptionEngineImpl();

package/src/encryption/encryption-engine.ts

@@ -4,20 +4,20 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as crypto from 'crypto';
-import { injectable } from 'inversify';
+import * as crypto from "crypto";
+import { injectable } from "inversify";
 
 export interface KeyParams {
-    iv: string
+    iv: string;
 }
 
 export interface EncryptedData {
     /** utf8 encoded string */
-    data: string,
-    keyParams: KeyParams
+    data: string;
+    keyParams: KeyParams;
 }
 
-export const EncryptionEngine = Symbol('EncryptionEngine');
+export const EncryptionEngine = Symbol("EncryptionEngine");
 export interface EncryptionEngine {
     /**
      * @param data utf8 encoded string
@@ -32,21 +32,21 @@ export interface EncryptionEngine {
  * - no salt, as we pass in a real key (no salting needed to turn a password into a key)
  * The implementation closely follows the exampes in https://nodejs.org/api/crypto.html.
  */
- @injectable()
+@injectable()
 export class EncryptionEngineImpl {
-    readonly algorithm = 'aes-256-cbc';
-    readonly enc = 'base64';
+    readonly algorithm = "aes-256-cbc";
+    readonly enc = "base64";
 
     encrypt(data: string, key: Buffer): EncryptedData {
         const iv = crypto.randomBytes(16);
         const cipher = crypto.createCipheriv(this.algorithm, key, iv);
-        const encrypted = cipher.update(new Buffer(data, 'utf8'));
+        const encrypted = cipher.update(new Buffer(data, "utf8"));
         const finalEncrypted = Buffer.concat([encrypted, cipher.final()]);
         return {
             data: finalEncrypted.toString(this.enc),
             keyParams: {
-                iv: iv.toString(this.enc)
-            }
+                iv: iv.toString(this.enc),
+            },
         };
     }
 
@@ -54,6 +54,6 @@ export class EncryptionEngineImpl {
         const decipher = crypto.createDecipheriv(this.algorithm, key, new Buffer(encryptedData.keyParams.iv, this.enc));
         let decrypted = decipher.update(new Buffer(encryptedData.data, this.enc));
         const finalDecrypted = Buffer.concat([decrypted, decipher.final()]);
-        return finalDecrypted.toString('utf8');
+        return finalDecrypted.toString("utf8");
     }
-}
+}

package/src/encryption/encryption-service.ts

@@ -9,12 +9,11 @@ import { injectable, inject } from "inversify";
 import { EncryptedData, EncryptionEngine } from "./encryption-engine";
 import { KeyProvider, KeyMetadata } from "./key-provider";
 
-
 export interface Encrypted<_T> extends EncryptedData {
-    keyMetadata: KeyMetadata
+    keyMetadata: KeyMetadata;
 }
 
-export const EncryptionService = Symbol('EncryptionService');
+export const EncryptionService = Symbol("EncryptionService");
 export interface EncryptionService {
     encrypt<T>(data: T): Encrypted<T>;
     decrypt<T>(encrypted: Encrypted<T>): T;
@@ -32,7 +31,7 @@ export class EncryptionServiceImpl implements EncryptionService {
         const encryptedData = this.engine.encrypt(dataStr, key.material);
         return {
             ...encryptedData,
-            keyMetadata: key.metadata
+            keyMetadata: key.metadata,
         };
     }
 
@@ -49,4 +48,4 @@ export class EncryptionServiceImpl implements EncryptionService {
     protected deserialize<T>(data: string): T {
         return JSON.parse(data) as T;
     }
-}
+}

package/src/encryption/key-provider.ts

@@ -7,16 +7,16 @@
 import { injectable, inject } from "inversify";
 
 export interface KeyMetadata {
-    name: string,
-    version: number
+    name: string;
+    version: number;
 }
 
 export interface Key {
-    metadata: KeyMetadata,
-    material: Buffer
+    metadata: KeyMetadata;
+    material: Buffer;
 }
 
-export const KeyProvider = Symbol('KeyProvider');
+export const KeyProvider = Symbol("KeyProvider");
 export interface KeyProvider {
     getPrimaryKey(): Key;
     getKeyFor(metadata: KeyMetadata): Key;
@@ -24,24 +24,21 @@ export interface KeyProvider {
 
 export type KeyConfig = KeyMetadata & {
     /** base64 encoded */
-    material: string,
-    primary?: boolean
-}
+    material: string;
+    primary?: boolean;
+};
 
-export const KeyProviderConfig = Symbol('KeyProviderConfig');
+export const KeyProviderConfig = Symbol("KeyProviderConfig");
 export interface KeyProviderConfig {
-    keys: KeyConfig[]
+    keys: KeyConfig[];
 }
 
 @injectable()
 export class KeyProviderImpl implements KeyProvider {
-
     static loadKeyConfigFromJsonString(configStr: string): KeyConfig[] {
         const keys = (JSON.parse(configStr) || []) as KeyConfig[];
-        if (!Array.isArray(keys)
-            || keys.length < 0
-            || 1 !== keys.reduce((p, k) => k.primary ? p + 1 : p, 0)) {
-            throw new Error('Invalid key config!');
+        if (!Array.isArray(keys) || keys.length < 0 || 1 !== keys.reduce((p, k) => (k.primary ? p + 1 : p), 0)) {
+            throw new Error("Invalid key config!");
         }
         return keys;
     }
@@ -49,13 +46,13 @@ export class KeyProviderImpl implements KeyProvider {
     constructor(@inject(KeyProviderConfig) protected readonly config: KeyProviderConfig) {}
 
     protected get keys() {
-        return this.config.keys
+        return this.config.keys;
     }
 
     getPrimaryKey(): Key {
         const primaryKey = this.keys.find((key) => !!key.primary);
         if (!primaryKey) {
-            throw new Error('No primary encryption key found!');
+            throw new Error("No primary encryption key found!");
         }
         return this.configToKey(primaryKey);
     }
@@ -72,9 +69,9 @@ export class KeyProviderImpl implements KeyProvider {
         return {
             metadata: {
                 name: config.name,
-                version: config.version
+                version: config.version,
             },
-            material: new Buffer(config.material, 'base64')
+            material: new Buffer(config.material, "base64"),
         };
     }
 }

package/src/env.ts

@@ -6,32 +6,10 @@
 
 import { injectable } from "inversify";
 
-const legacyStagenameTranslation: { [key: string]: KubeStage } = {
-    "production": "production",
-    "staging": "prodcopy",
-    "devstaging": "dev",
-    "dev": "dev"
-}
-
 @injectable()
 export abstract class AbstractComponentEnv {
-    readonly kubeStage: KubeStage = getEnvVarParsed('KUBE_STAGE', (kubeStage) => {
-        const stage = legacyStagenameTranslation[kubeStage];
-        if (!stage) {
-            throw new Error(`Environment variable invalid: KUBE_STAGE=${kubeStage}`);
-        }
-
-        return stage;
-    });
-    readonly kubeNamespace: string = getEnvVar('KUBE_NAMESPACE');
-    readonly version: string = getEnvVar('VERSION');
-
-    readonly installationLongname: string = getEnvVar("GITPOD_INSTALLATION_LONGNAME")
-    readonly installationShortname: string = getEnvVar("GITPOD_INSTALLATION_SHORTNAME")
 }
 
-export type KubeStage = 'production' | 'prodcopy' | 'staging' | 'dev';
-
 export function getEnvVar(name: string, defaultValue?: string): string {
     const value = process.env[name] || defaultValue;
     if (!value) {

package/src/gitpod-file-parser.spec.ts

@@ -4,19 +4,19 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { suite, test } from "mocha-typescript"
-import * as chai from "chai"
+import { suite, test } from "mocha-typescript";
+import * as chai from "chai";
 
-import { WorkspaceConfig } from './protocol';
-import { GitpodFileParser } from './gitpod-file-parser';
+import { WorkspaceConfig } from "./protocol";
+import { GitpodFileParser } from "./gitpod-file-parser";
 
-const expect = chai.expect
+const expect = chai.expect;
 
 const DEFAULT_IMAGE = "default-image";
 const DEFAULT_CONFIG = <WorkspaceConfig>{ image: DEFAULT_IMAGE };
 
-@suite class TestGitpodFileParser {
-
+@suite
+class TestGitpodFileParser {
     protected parser: GitpodFileParser;
 
     public before() {
@@ -24,107 +24,102 @@ const DEFAULT_CONFIG = <WorkspaceConfig>{ image: DEFAULT_IMAGE };
     }
 
     @test public testOnlyOnePort() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555`;
+        const content = `ports:\n` + `  - port: 5555`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testPortRange() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555\n` +
-            `  - port: 3000-3999`; // should be filtered out by default
+        const content = `ports:\n` + `  - port: 5555\n` + `  - port: 3000-3999`; // should be filtered out by default
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testPortRangeAccepted() {
-        const content =
-            `ports:\n` +
-            `  - port: 5555\n` +
-            `  - port: 3000-3999`; // should be included if explicitly supported
+        const content = `ports:\n` + `  - port: 5555\n` + `  - port: 3000-3999`; // should be included if explicitly supported
 
         const result = this.parser.parse(content, { acceptPortRanges: true }, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            ports: [{
-                port: 5555
-            }, {
-                port: '3000-3999'
-            }],
-            image: DEFAULT_IMAGE
+            ports: [
+                {
+                    port: 5555,
+                },
+                {
+                    port: "3000-3999",
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testSimpleTask() {
-        const content =
-            `tasks:\n` +
-            `  - command: yarn`;
+        const content = `tasks:\n` + `  - command: yarn`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            tasks: [{
-                command: "yarn"
-            }],
-            image: DEFAULT_IMAGE
+            tasks: [
+                {
+                    command: "yarn",
+                },
+            ],
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testSimpleImage() {
         const imageName = "my-test-org/my-test-image:some-tag";
-        const content =
-            `image: "${imageName}"\n`;
+        const content = `image: "${imageName}"\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
-            image: imageName
+            image: imageName,
         });
     }
 
     @test public testComplexImageWithoutContext() {
-        const dockerFileName = 'Dockerfile';
-        const content =
-            `image:\n  file: ${dockerFileName}\n`;
+        const dockerFileName = "Dockerfile";
+        const content = `image:\n  file: ${dockerFileName}\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
             image: {
-                file: dockerFileName
-            }
+                file: dockerFileName,
+            },
         });
     }
 
     @test public testComplexImageWithContext() {
-        const dockerFileName = 'Dockerfile';
-        const dockerContext = 'docker';
-        const content =
-            `image:\n  file: ${dockerFileName}\n  context: ${dockerContext}\n`;
+        const dockerFileName = "Dockerfile";
+        const dockerContext = "docker";
+        const content = `image:\n  file: ${dockerFileName}\n  context: ${dockerContext}\n`;
 
         const result = this.parser.parse(content);
         expect(result.config).to.deep.equal({
             image: {
                 file: dockerFileName,
-                context: dockerContext
-            }
+                context: dockerContext,
+            },
         });
     }
 
     @test public testGitconfig() {
-        const content =
-`
+        const content = `
 gitConfig:
     core.autocrlf: input
 `;
@@ -132,20 +127,19 @@ gitConfig:
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
             gitConfig: {
-                "core.autocrlf": "input"
+                "core.autocrlf": "input",
             },
-            image: DEFAULT_IMAGE
+            image: DEFAULT_IMAGE,
         });
     }
 
     @test public testBrokenConfig() {
-        const content =
-            `image: 42\n`;
+        const content = `image: 42\n`;
 
         const result = this.parser.parse(content, {}, DEFAULT_CONFIG);
         expect(result.config).to.deep.equal({
-            image: DEFAULT_IMAGE
+            image: DEFAULT_IMAGE,
         });
     }
 }
-module.exports = new TestGitpodFileParser()   // Only to circumvent no usage warning :-/
+module.exports = new TestGitpodFileParser(); // Only to circumvent no usage warning :-/

package/src/gitpod-file-parser.ts

@@ -7,40 +7,39 @@
 import { injectable } from "inversify";
 import * as yaml from "js-yaml";
 import * as Ajv from "ajv";
-import { log } from './util/logging';
+import { log } from "./util/logging";
 import { WorkspaceConfig, PortRangeConfig } from "./protocol";
 
-export type MaybeConfig = WorkspaceConfig | undefined
+export type MaybeConfig = WorkspaceConfig | undefined;
 
-const schema = require('../data/gitpod-schema.json');
+const schema = require("../data/gitpod-schema.json");
 const validate = new Ajv().compile(schema);
 const defaultParseOptions = {
     acceptPortRanges: false,
 };
 
 export interface ParseResult {
-    config: WorkspaceConfig
-    parsedConfig?: WorkspaceConfig
-    validationErrors?: string[]
+    config: WorkspaceConfig;
+    parsedConfig?: WorkspaceConfig;
+    validationErrors?: string[];
 }
 
 @injectable()
 export class GitpodFileParser {
-
     public parse(content: string, parseOptions = {}, defaultConfig: WorkspaceConfig = {}): ParseResult {
         const options = {
-           ...defaultParseOptions,
-           ...parseOptions,
+            ...defaultParseOptions,
+            ...parseOptions,
         };
         try {
             const parsedConfig = yaml.safeLoad(content) as any;
             validate(parsedConfig);
-            const validationErrors = validate.errors ? validate.errors.map( e => e.message || e.keyword ) : undefined;
+            const validationErrors = validate.errors ? validate.errors.map((e) => e.message || e.keyword) : undefined;
             if (validationErrors && validationErrors.length > 0) {
                 return {
                     config: defaultConfig,
                     parsedConfig,
-                    validationErrors
+                    validationErrors,
                 };
             }
             const overrides = {} as any;
@@ -49,17 +48,17 @@ export class GitpodFileParser {
             }
             return {
                 config: {
-                    ... defaultConfig,
-                    ... parsedConfig,
-                    ... overrides,
+                    ...defaultConfig,
+                    ...parsedConfig,
+                    ...overrides,
                 },
-                parsedConfig
+                parsedConfig,
             };
         } catch (err) {
-            log.error('Unparsable Gitpod configuration', err, { content });
+            log.error("Unparsable Gitpod configuration", err, { content });
             return {
                 config: defaultConfig,
-                validationErrors: ['Unparsable Gitpod configuration: ' + err.toString()]
+                validationErrors: ["Unparsable Gitpod configuration: " + err.toString()],
             };
         }
     }