codefresh 0.78.5 → 0.79.2

package/e2e/scenarios/environments.sh

@@ -0,0 +1 @@
+codefresh get environments

package/e2e/scenarios/helm-repo.sh

@@ -0,0 +1 @@
+codefresh get helm-repo

package/e2e/scenarios/images.sh

@@ -0,0 +1 @@
+codefresh get images

package/e2e/scenarios/pipeline-run.sh

@@ -0,0 +1,26 @@
+project=test-run
+pipeline="$project/test-run"
+pipeline_file="$SCRIPT_DIR/data/test-run.pip.yaml"
+
+existing_pipeline=`exists pipeline $pipeline`
+existing_project=`exists project $project`
+
+if [ -z "$existing_project" ]; then
+  echo "Project does not exist: $project"
+  echo "Creating project: $project"
+  codefresh create project $project
+else
+  echo "Project already exists: $project"
+fi
+
+if [ -z "$existing_pipeline" ]; then
+  echo "Pipeline does not exist: $pipeline"
+  echo "Creating pipeline: $pipeline"
+  codefresh create -f $pipeline_file
+else
+  echo "Pipeline already exists: $pipeline"
+fi
+
+codefresh run $pipeline
+codefresh delete pipeline $pipeline
+codefresh delete project $project

package/e2e/scenarios/pipelines.sh

@@ -0,0 +1,31 @@
+project='pipeline-crud'
+pipeline="$project/crud"
+pipeline_file="$SCRIPT_DIR/data/crud.pip.yaml"
+
+existing_project=`exists project $project`
+existing_pipeline=`exists pipeline $pipeline`
+
+if [ -z "$existing_project" ]; then
+  echo "Project does not exist: $project"
+  echo "Creating project: $project"
+  codefresh create project $project
+else
+  echo "Project already exists: $project"
+fi
+
+if [ -z "$existing_pipeline" ]; then
+  echo "Pipeline does not exist: $pipeline"
+  echo "Creating pipeline: $pipeline"
+  codefresh create -f $pipeline_file
+else
+  echo "Pipeline already exists: $pipeline"
+  codefresh delete pipeline $pipeline
+  codefresh create -f $pipeline_file
+fi
+
+codefresh get pipelines
+codefresh get pipeline $pipeline
+
+codefresh delete pipeline $pipeline
+codefresh delete project $project
+

package/e2e/scenarios/projects.sh

@@ -0,0 +1,17 @@
+project='project-crud'
+
+existing_project=`exists project $project`
+
+if [ -z "$existing_project" ]; then
+  echo "Project does not exist: $project"
+  echo "Creating project: $project"
+  codefresh create project $project
+else
+  echo "Project already exists: $project"
+  codefresh delete project $project
+  codefresh create project $project
+fi
+
+codefresh get projects
+codefresh get project $project
+codefresh delete project $project

package/e2e/scenarios/registry.sh

@@ -0,0 +1 @@
+codefresh get registry

package/e2e/scenarios/repository.sh

@@ -0,0 +1,2 @@
+codefresh get repository
+codefresh get repository -a

package/e2e/scenarios/runtime-environment.sh

@@ -0,0 +1 @@
+codefresh get runtime-environments

package/e2e/scenarios/step-types.sh

@@ -0,0 +1 @@
+codefresh get step-types

package/e2e/scenarios/system-runtime-environments.sh

@@ -0,0 +1 @@
+codefresh get system-runtime-environments

package/e2e/scenarios/teams.sh

@@ -0,0 +1 @@
+codefresh get teams

package/e2e/scenarios/tokens.sh

@@ -0,0 +1 @@
+codefresh get tokens

package/e2e/scenarios/triggers.sh

@@ -0,0 +1,3 @@
+codefresh get triggers
+codefresh get trigger-events
+codefresh get trigger-types

package/lib/interface/cli/commands/offline-logs/offload-to-file.cmd.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 const { MongoClient, ObjectId } = require("mongodb");
 const moment = require("moment");
 const Command = require("../../Command");
@@ -34,7 +35,7 @@ const offloadToFile = async function (
   }
   const cutoffDateId = objectIdFromDate(cutoffDateObj.toDate());
 
-  const minLog = await findMinLog(collectionObj, cutoffDateId, collection);
+  const minLog = await findMinLog(collectionObj, cutoffDateId);
 
   if (!minLog) {
     console.info(
@@ -61,25 +62,22 @@ const offloadToFile = async function (
     const lowerBoundId = objectIdFromDate(lowerBound.toDate());
     const upperBoundId = objectIdFromDate(upperBound.toDate());
 
-    const logsToArchive = await collectionObj
+    const logsCursor = await collectionObj
       .find({
         _id: {
           $gte: ObjectId(lowerBoundId),
           $lt: ObjectId(upperBoundId),
         },
-      })
-      .toArray();
+      });
 
-    if (logsToArchive.length > 0) {
-      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path);
+    await writeLogsToFile(upperBound, lowerBound, collection, logsCursor, path);
 
-      await collectionObj.deleteMany({
-        _id: {
-          $gte: ObjectId(lowerBoundId),
-          $lt: ObjectId(upperBoundId),
-        },
-      });
-    }
+    await collectionObj.deleteMany({
+      _id: {
+        $gte: ObjectId(lowerBoundId),
+        $lt: ObjectId(upperBoundId),
+      },
+    });
   }
 };
 
@@ -152,7 +150,7 @@ const command = new Command({
             path
           );
         } catch (e) {
-          console.log(e);
+          console.error(e);
           failedCollections.push(collection);
           errors.push(error);
         }

package/lib/interface/cli/commands/offline-logs/offload-to-file.spec.js

@@ -1,59 +1,116 @@
-const moment = require('moment')
+/* eslint-disable no-unused-vars */
+const moment = require('moment');
 const { writeLogsToFile, checkRemnant } = require('./utils');
-const fs = require('fs')
+const fs = require('fs');
 
 describe('offload-to-file', () => {
-  describe('writeLogsToFile', () => {
-    it('writes the input data to file', () => {
-      fs.writeFileSync = jest.fn((path, data) => {
-        return {path, data};
-      });
-      const upperBound = '2021-08-10';
-      const lowerBound = '2021-08-01';
-      const collection = 'logs';
-      const logsToArchive = [1, 2, 3, 4];
-      const expectedStr = JSON.stringify(logsToArchive)
-      const path = 'some/path';
-      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path);
-      expect(fs.writeFileSync.mock.calls.length).toBe(1);
-      expect(fs.writeFileSync.mock.calls[0][0]).toContain(path);
-      expect(fs.writeFileSync.mock.calls[0][1]).toBe(expectedStr);
-    });
-    it('creates the correct file name', () => {
-      fs.writeFileSync = jest.fn((path, data) => {
-        return {path, data};
-      });
-      const upperBound = '2021-08-10';
-      const lowerBound = '2021-08-01';
-      const collection = 'logs';
-      const logsToArchive = [1, 2, 3, 4];
-      const expectedPath = 'some/path/2021-08-01-2021-08-09-logs.json'
-      const path = 'some/path';
-      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path);
-      expect(fs.writeFileSync.mock.calls.length).toBe(1);
-      expect(fs.writeFileSync.mock.calls[0][0]).toBe(expectedPath);
-    });
-    it('checks leap year date calculation', () => {
-      fs.writeFileSync = jest.fn((path, data) => {
-        return {path, data};
-      });
-      const upperBound = '2020-03-01';
-      const lowerBound = '2020-02-01';
-      const collection = 'logs';
-      const logsToArchive = [1, 2, 3, 4];
-      const expectedPath = 'some/path/2020-02-01-2020-02-29-logs.json'
-      const path = 'some/path';
-      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path);
-      expect(fs.writeFileSync.mock.calls.length).toBe(1);
-      expect(fs.writeFileSync.mock.calls[0][0]).toBe(expectedPath);
+    describe('writeLogsToFile', () => {
+        it('writes the input data to file', async () => {
+            const upperBound = '2021-08-10';
+            const lowerBound = '2021-08-01';
+            const collection = 'logs';
+            const pathMock = 'some/path';
+            let writerResult = '';
+            const expectedWrite = '[\n{"key1":"val"},\n{"key2":"val"},\n{"key3":"val"},\n{"key4":"val"}\n]';
+            class LogsCursor {
+                constructor() {
+                    this.logs = [{ key1: 'val' }, { key2: 'val' }, { key3: 'val' }, { key4: 'val' }];
+                    this.pointer = 0;
+                    this.next = jest.fn(() => {
+                        let currentDoc = null;
+                        if (this.pointer < this.logs.length) {
+                            currentDoc = this.logs[this.pointer];
+                        }
+                        this.pointer += 1;
+                        return currentDoc;
+                    });
+                    this.isClosed = jest.fn(() => this.pointer > this.logs.length);
+                }
+            }
+            const writerMock = {
+                write: jest.fn((text) => {
+                    writerResult = `${writerResult}${text}`;
+                }),
+                close: jest.fn(),
+            };
+
+            fs.createWriteStream = jest.fn(path => writerMock);
+            await writeLogsToFile(upperBound, lowerBound, collection, new LogsCursor(), pathMock);
+            expect(fs.createWriteStream.mock.calls.length).toBe(1);
+            expect(fs.createWriteStream.mock.calls[0][0]).toContain(pathMock);
+            expect(writerMock.write.mock.calls.length).toBe(6);
+            expect(writerResult).toBe(expectedWrite);
+            expect(writerMock.close.mock.calls.length).toBe(1);
+        });
+        it('creates the correct file name', async () => {
+            const upperBound = '2021-08-10';
+            const lowerBound = '2021-08-01';
+            const collection = 'logs';
+            const expectedPath = 'some/path/2021-08-01-2021-08-09-logs.json';
+            const somePath = 'some/path';
+            class LogsCursor {
+                constructor() {
+                    this.logs = [{ key1: 'val' }, { key2: 'val' }, { key3: 'val' }, { key4: 'val' }];
+                    this.pointer = 0;
+                    this.next = jest.fn(() => {
+                        let currentDoc = null;
+                        if (this.pointer < this.logs.length) {
+                            currentDoc = this.logs[this.pointer];
+                        }
+                        this.pointer += 1;
+                        return currentDoc;
+                    });
+                    this.isClosed = jest.fn(() => this.pointer > this.logs.length);
+                }
+            }
+            const writerMock = {
+                write: jest.fn(text => text),
+                close: jest.fn(),
+            };
+
+            fs.createWriteStream = jest.fn(path => writerMock);
+            await writeLogsToFile(upperBound, lowerBound, collection, new LogsCursor(), somePath);
+            expect(fs.createWriteStream.mock.calls.length).toBe(1);
+            expect(fs.createWriteStream.mock.calls[0][0]).toBe(expectedPath);
+        });
+        it('checks leap year date calculation', async () => {
+            const upperBound = '2020-03-01';
+            const lowerBound = '2020-02-01';
+            const collection = 'logs';
+            const expectedPath = 'some/path/2020-02-01-2020-02-29-logs.json';
+            const somePath = 'some/path';
+            class LogsCursor {
+                constructor() {
+                    this.logs = [{ key1: 'val' }, { key2: 'val' }, { key3: 'val' }, { key4: 'val' }];
+                    this.pointer = 0;
+                    this.next = jest.fn(() => {
+                        let currentDoc = null;
+                        if (this.pointer < this.logs.length) {
+                            currentDoc = this.logs[this.pointer];
+                        }
+                        this.pointer += 1;
+                        return currentDoc;
+                    });
+                    this.isClosed = jest.fn(() => this.pointer > this.logs.length);
+                }
+            }
+            const writerMock = {
+                write: jest.fn(text => text),
+                close: jest.fn(),
+            };
+
+            fs.createWriteStream = jest.fn(path => writerMock);
+            await writeLogsToFile(upperBound, lowerBound, collection, new LogsCursor(), somePath);
+            expect(fs.createWriteStream.mock.calls.length).toBe(1);
+            expect(fs.createWriteStream.mock.calls[0][0]).toBe(expectedPath);
+        });
     });
-  });
-  describe('checkRemnant', () => {
-    it('checkes days remnant to make sure time range is not going off boundaries', () => {
-      const lowerBound = '2020-08-01';
-      const cutoffDateObj = moment('2020-08-01').add(1, 'days').startOf("day");
-      const result = checkRemnant(lowerBound, cutoffDateObj);
-      expect(result).toBe(1);
+    describe('checkRemnant', () => {
+        it('checkes days remnant to make sure time range is not going off boundaries', () => {
+            const lowerBound = '2020-08-01';
+            const cutoffDateObj = moment('2020-08-01').add(1, 'days').startOf('day');
+            const result = checkRemnant(lowerBound, cutoffDateObj);
+            expect(result).toBe(1);
+        });
     });
-  });
 });

package/lib/interface/cli/commands/offline-logs/utils.js

@@ -1,159 +1,164 @@
-const readline = require("readline");
-const moment = require("moment");
-const { ObjectId } = require("mongodb")
+/* eslint-disable no-await-in-loop */
+const readline = require('readline');
+const moment = require('moment');
+const { ObjectId } = require('mongodb');
 
-const { join } = require("path");
-const fs = require("fs");
+const { join } = require('path');
+const fs = require('fs');
 
-const defaultCollections = ["logs", "metadata"];
+const defaultCollections = ['logs', 'metadata'];
 
 // converts date to objectId for filter purposes
-const objectIdFromDate = function (date) {
-  return Math.floor(date.getTime() / 1000).toString(16) + "0000000000000000";
-};
+function objectIdFromDate(date) {
+    return `${Math.floor(date.getTime() / 1000).toString(16)}0000000000000000`;
+}
+
+function createRangeStr(lowerBound, upperBound, collection) {
+    const upperBoundDate = moment(upperBound).subtract(1, 'days');
+    const fileDateRange = `${moment(lowerBound).format('YYYY-MM-DD')}-${upperBoundDate.format('YYYY-MM-DD')}`;
+    return `${fileDateRange}-${collection}`;
+}
 
-const writeLogsToFile = function (
-  upperBound,
-  lowerBound,
-  collection,
-  logsToArchive,
-  path
+async function writeLogsToFile(
+    upperBound,
+    lowerBound,
+    collection,
+    logsCursor,
+    path,
 ) {
-  const fileName = `${createRangeStr(lowerBound, upperBound, collection)}.json`
-  const absPath = join(path, fileName);
-  const data = JSON.stringify(logsToArchive);
-  fs.writeFileSync(absPath, data);
-  console.info(`logs from collection '${collection}' were offloaded to '${absPath}'`)
-};
+    const fileName = `${createRangeStr(lowerBound, upperBound, collection)}.json`;
+    const absPath = join(path, fileName);
+    const stream = fs.createWriteStream(absPath);
+    let count = 0;
+    stream.write('[');
+
+    let comma = '';
+    while (!logsCursor.isClosed()) {
+        const doc = await logsCursor.next();
+        if (doc) {
+            const data = JSON.stringify(doc);
+            stream.write(`${comma}\n${data}`);
+            comma = ',';
+            count += 1;
+        } else {
+            break;
+        }
+    }
 
-const createRangeStr = function(lowerBound, upperBound, collection) {
-  const upperBoundDate = moment(upperBound).subtract(1, "days");
-  const fileDateRange = `${moment(lowerBound).format(
-    "YYYY-MM-DD"
-  )}-${upperBoundDate.format("YYYY-MM-DD")}`;
-  return `${fileDateRange}-${collection}`;
+    stream.write('\n]');
+    stream.close();
+
+    console.info(`${count} logs from collection '${collection}' were offloaded to '${absPath}'`);
 }
 
-const getMinDate = function(minLog) {
-  const minLogId = ObjectId(minLog._id)
-  return moment(
-    minLogId.getTimestamp()
-  ).startOf("day");
+function getMinDate(minLog) {
+    const minLogId = ObjectId(minLog._id);
+    return moment(minLogId.getTimestamp()).startOf('day');
 }
 
-const checkRemnant = function (lowerBound, cutoffDateObj) {
-  return Math.ceil(cutoffDateObj.diff(lowerBound, "days"));
-};
-///////////////////////////////////////////////////////////////
-const ensureIndex = async function (database, collection) {
-  const collectionObj = database.collection(collection);
-  const indexName = "accountId_1_jobId_1";
+function checkRemnant(lowerBound, cutoffDateObj) {
+    return Math.ceil(cutoffDateObj.diff(lowerBound, 'days'));
+}
 
-  const indexExist = await collectionObj.indexExists(indexName)
+async function ensureIndex(database, collection) {
+    const collectionObj = database.collection(collection);
+    const indexName = 'accountId_1_jobId_1';
 
-  if (indexExist) {
-    console.info(
-      `index '${indexName}' already exists in collection '${collection}'`
-    );
-    return;
-  }
+    const indexExist = await collectionObj.indexExists(indexName);
+
+    if (indexExist) {
+        console.info(`index '${indexName}' already exists in collection '${collection}'`);
+        return;
+    }
 
-  const documentsCount = await collectionObj.estimatedDocumentCount();
+    const documentsCount = await collectionObj.estimatedDocumentCount();
 
-  const queryStr = `There are approximately ${documentsCount} documents on collection '${collection}'. 
+    const queryStr = `There are approximately ${documentsCount} documents on collection '${collection}'. 
     do you want to create an index for it? (creating an index for a large collection may take a while, 
     but can improve performance on future read operations) [yes/no] `;
 
-  const userInput = await this.getUserInput(queryStr);
+    const userInput = await this.getUserInput(queryStr);
 
-  if (!userInput) {
-    console.info(`skipping collection '${collection}'`);
-    return;
-  }
+    if (!userInput) {
+        console.info(`skipping collection '${collection}'`);
+        return;
+    }
 
-  await collectionObj.createIndex(
-    { accountId: 1, jobId: 1 },
-    { background: true },
-  );
-  console.info(
-    `index '${indexName}' was created for collection '${collection}'`
-  );
-};
+    await collectionObj.createIndex(
+        { accountId: 1, jobId: 1 },
+        { background: true },
+    );
+    console.info(`index '${indexName}' was created for collection '${collection}'`);
+}
 
-const getUserInput = async function (queryStr) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  const questionAsync = (query) =>
-    new Promise((resolve) => rl.question(query, resolve));
-
-  try {
-    const userInput = (await questionAsync(queryStr)).toLowerCase();
-
-    switch (userInput) {
-      case "yes":
-      case "y":
-        return true;
-      case "no":
-      case "n":
-        return false;
-      default:
-        console.warn("invalid input");
-        return false;
+async function getUserInput(queryStr) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    const questionAsync = query =>
+        new Promise(resolve => rl.question(query, resolve));
+
+    try {
+        const userInput = (await questionAsync(queryStr)).toLowerCase();
+
+        switch (userInput) {
+            case 'yes':
+            case 'y':
+                return true;
+            case 'no':
+            case 'n':
+                return false;
+            default:
+                console.warn('invalid input');
+                return false;
+        }
+    } finally {
+        rl.close();
     }
-  } finally {
-    rl.close();
-  }
-};
+}
 
-const collectionExists = async function(dbObject, targetCollection) {
-  const collectionsObjectList = await dbObject.listCollections().toArray();
-  const collectionsList = collectionsObjectList.map((object) => {
-    return object.name;
-  })
-  return (collectionsList.indexOf(targetCollection) >= 0);
+async function collectionExists(dbObject, targetCollection) {
+    const collectionsObjectList = await dbObject.listCollections().toArray();
+    const collectionsList = collectionsObjectList.map(object => object.name);
+    return (collectionsList.indexOf(targetCollection) >= 0);
 }
 
-const findMinLog = async function(collectionObj, UpperBoundDateId, collection) {
-  const minLog = await collectionObj
-    .find({ _id: { $lt: ObjectId(UpperBoundDateId) } })
-    .sort({ _id: 1 })
-    .limit(1)
-    .toArray();
+async function findMinLog(collectionObj, UpperBoundDateId) {
+    const minLog = await collectionObj
+        .find({ _id: { $lt: ObjectId(UpperBoundDateId) } })
+        .sort({ _id: 1 })
+        .limit(1)
+        .toArray();
 
-  if (minLog.length === 0) {
-    return undefined;
-  }
+    if (minLog.length === 0) {
+        return undefined;
+    }
 
-  return minLog[0];
+    return minLog[0];
 }
 
-const checkCursorState = function (cursor, collection, targetCollection) {
-  if (!cursor.cursorState.killed) {
-    console.info(
-      `logs from '${collection}' were archived to '${targetCollection}'`
-    );
-    return;
-  } else {
-    throw new Error(
-      "Cursor error. Archiving operation may not be completed.\
-      The old logs were not deleted from the source collection."
-    );
-  }
+function checkCursorState(cursor, collection, targetCollection) {
+    if (!cursor.cursorState.killed) {
+        console.info(`logs from '${collection}' were archived to '${targetCollection}'`);
+    } else {
+        // eslint-disable-next-line no-multi-str
+        throw new Error('Cursor error. Archiving operation may not be completed.\
+        The old logs were not deleted from the source collection.');
+    }
 }
 
 module.exports = {
-  objectIdFromDate,
-  writeLogsToFile,
-  checkRemnant,
-  ensureIndex,
-  getUserInput,
-  collectionExists,
-  findMinLog,
-  checkCursorState,
-  createRangeStr,
-  getMinDate,
-  defaultCollections,
+    objectIdFromDate,
+    writeLogsToFile,
+    checkRemnant,
+    ensureIndex,
+    getUserInput,
+    collectionExists,
+    findMinLog,
+    checkCursorState,
+    createRangeStr,
+    getMinDate,
+    defaultCollections,
 };