chore(build): add local release command MONGOSH-530 (#667)

Author: rose-m

package.json

@@ -48,6 +48,7 @@
     "compile-exec": "npm run evergreen-release compile",
     "compile-all": "npm run compile-compass && npm run compile-exec",
     "evergreen-release": "cd packages/build && npm run evergreen-release --",
+    "release": "cd packages/build && npm run release --",
     "report-missing-help": "lerna run --stream --scope @mongosh/shell-api report-missing-help",
     "report-supported-api": "lerna run --stream --scope @mongosh/shell-api report-supported-api",
     "report-coverage": "nyc report --reporter=text --reporter=html && nyc check-coverage --lines=95",

packages/build/package.json

@@ -19,7 +19,8 @@
     "test-ci": "mocha -r \"../../scripts/import-expansions.js\" --timeout 30000 -r ts-node/register \"./src/**/*.spec.ts\"",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "check": "npm run lint",
-    "evergreen-release": "ts-node -r ../../scripts/import-expansions.js src/index.ts"
+    "evergreen-release": "ts-node -r ../../scripts/import-expansions.js src/index.ts",
+    "release": "ts-node src/index.ts trigger-release"
   },
   "license": "Apache-2.0",
   "publishConfig": {

packages/build/src/evergreen.spec.ts renamed to packages/build/src/evergreen/artifacts.spec.ts

@@ -3,9 +3,9 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import rimraf from 'rimraf';
 import { promisify } from 'util';
-import { downloadArtifactFromEvergreen } from './evergreen';
+import { downloadArtifactFromEvergreen } from './artifacts';
 
-describe('evergreen', () => {
+describe('evergreen artifacts', () => {
   describe('downloadArtifactFromEvergreen', () => {
     let tmpDir: string;
 

packages/build/src/evergreen.ts renamed to packages/build/src/evergreen/artifacts.ts

@@ -0,0 +1,3 @@
+
+export * from './artifacts';
+export * from './rest-api';

packages/build/src/evergreen/index.ts

@@ -0,0 +1,108 @@
+import { expect } from 'chai';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import sinon from 'sinon';
+import YAML from 'yaml';
+import { EvergreenApi, EvergreenTask } from './rest-api';
+
+describe('evergreen rest-api', () => {
+  describe('from user configuration', () => {
+    const configData = {
+      api_server_host: 'host',
+      user: 'user',
+      api_key: 'key'
+    };
+    const writeEvergreenConfiguration = async(content: string): Promise<string> => {
+      const configFile = path.join(os.tmpdir(), `evergreen-${new Date().getTime()}-${Math.random()}.yaml`);
+      await fs.writeFile(configFile, content, { encoding: 'utf-8' });
+      return configFile;
+    };
+
+    it('parses a configuration file correctly', async() => {
+      const configFile = await writeEvergreenConfiguration(YAML.stringify(configData));
+      const api = await EvergreenApi.fromUserConfiguration(configFile);
+      expect(api.apiBasepath).to.equal('host');
+      expect(api.apiUser).to.equal('user');
+      expect(api.apiKey).to.equal('key');
+    });
+
+    it('throws an error when the configuration file does not exist', async() => {
+      try {
+        await EvergreenApi.fromUserConfiguration('kasldjflasjk dfalsd jfsdfk');
+      } catch (e) {
+        expect(e.message).to.contain('Could not find local evergreen configuration');
+        return;
+      }
+      expect.fail('Expected error');
+    });
+
+    ['api_server_host', 'user', 'api_key'].forEach(key => {
+      it(`throws an error if ${key} is missing`, async() => {
+        const data: Record<string, string> = {
+          ...configData
+        };
+        delete data[key];
+        const configFile = await writeEvergreenConfiguration(YAML.stringify(data));
+        try {
+          await EvergreenApi.fromUserConfiguration(configFile);
+        } catch (e) {
+          expect(e.message).to.contain(key);
+        }
+      });
+    });
+  });
+
+  describe('getTasks', () => {
+    let fetch: sinon.SinonStub;
+    let api: EvergreenApi;
+
+    beforeEach(() => {
+      fetch = sinon.stub();
+      api = new EvergreenApi(
+        '//basePath/api', 'user', 'key', fetch as any
+      );
+    });
+
+    it('executes a proper GET', async() => {
+      const task: EvergreenTask = {
+        task_id: 'task_id',
+        version_id: 'version',
+        status: 'success',
+        display_name: 'Task',
+        build_variant: 'variant'
+      };
+      fetch.resolves({
+        status: 200,
+        json: sinon.stub().resolves([task])
+      });
+
+      const tasks = await api.getTasks('mongosh', 'sha');
+      expect(tasks).to.deep.equal([task]);
+      expect(fetch).to.have.been.calledWith(
+        '//basePath/api/rest/v2/projects/mongosh/revisions/sha/tasks',
+        {
+          headers: {
+            'Api-User': 'user',
+            'Api-Key': 'key'
+          }
+        }
+      );
+    });
+
+    it('fails if there is a non-200 response code', async() => {
+      fetch.resolves({
+        status: 404,
+        text: sinon.stub().resolves('ERR: Not found')
+      });
+
+      try {
+        await api.getTasks('mongosh', 'sha');
+      } catch (e) {
+        expect(e.message).to.equal('Unexpected response status: 404 - ERR: Not found');
+        return;
+      }
+      expect.fail('Expected error');
+    });
+  });
+});

packages/build/src/evergreen/rest-api.spec.ts

@@ -0,0 +1,76 @@
+/* eslint-disable camelcase */
+import { promises as fs, constants } from 'fs';
+import { default as fetchFn } from 'node-fetch';
+import os from 'os';
+import path from 'path';
+import YAML from 'yaml';
+
+export type EvergreenTaskStatus = 'undispatched' | 'scheduled' | 'started' | 'success' | 'failed' | 'aborted';
+
+// For full specification of all fields see: https://github.com/evergreen-ci/evergreen/wiki/REST-V2-Usage#objects
+export interface EvergreenTask {
+  task_id: string;
+  version_id: string;
+  display_name: string;
+  build_variant: string;
+  status: EvergreenTaskStatus;
+}
+
+export class EvergreenApi {
+  constructor(
+    public readonly apiBasepath: string,
+    public readonly apiUser: string,
+    public readonly apiKey: string,
+    private readonly fetch: typeof fetchFn = fetchFn
+  ) {}
+
+  public static async fromUserConfiguration(
+    pathToConfiguration = path.join(os.homedir(), '.evergreen.yml')
+  ): Promise<EvergreenApi> {
+    try {
+      await fs.access(pathToConfiguration, constants.R_OK);
+    } catch {
+      throw new Error(`Could not find local evergreen configuration: ${pathToConfiguration}. Ensure it exists and can be read.`);
+    }
+
+    const configuration = YAML.parse(await fs.readFile(pathToConfiguration, { encoding: 'utf-8' }));
+    ['api_server_host', 'user', 'api_key'].forEach(key => {
+      if (typeof configuration[key] !== 'string') {
+        throw new Error(`Evergreen configuration ${pathToConfiguration} misses required key ${key}`);
+      }
+    });
+    return new EvergreenApi(
+      configuration.api_server_host,
+      configuration.user,
+      configuration.api_key,
+    );
+  }
+
+  public async getTasks(
+    project: string,
+    commitSha: string
+  ): Promise<EvergreenTask[]> {
+    return await this.apiGET<EvergreenTask[]>(
+      `/projects/${project}/revisions/${commitSha}/tasks`
+    );
+  }
+
+  private async apiGET<T>(path: string): Promise<T> {
+    const response = await this.fetch(
+      `${this.apiBasepath}/rest/v2${path}`,
+      { headers: this.getApiHeaders() }
+    );
+
+    if (response.status >= 300) {
+      throw new Error(`Unexpected response status: ${response.status} - ${await response.text()}`);
+    }
+    return await response.json();
+  }
+
+  private getApiHeaders(): Record<string, string> {
+    return {
+      'Api-User': this.apiUser,
+      'Api-Key': this.apiKey,
+    };
+  }
+}

packages/build/src/evergreen/rest-api.ts

@@ -0,0 +1,3 @@
+
+export * from './spawn-sync';
+export * from './user-input';