Renamed to gitlab-ci-local

Finished work on log output into working directory.

Author: firecow

.idea/gitlab-runner-local.iml renamed to .idea/gitlab-ci-local.iml

@@ -27,35 +27,35 @@ It lets you simulate a CI pipeline on your local machine.
       * [Features](#features)
       * [Unsupported tags, will be implemented in order](#unsupported-tags-will-be-implemented-in-order)
       * [Docker specfic tags. (Only shell working now)](#docker-specfic-tags-only-shell-working-now)
-      * [Gitlab CI only, will not be used by gitlab-local-pipeline](#gitlab-ci-only-will-not-be-used-by-gitlab-local-pipeline)
+      * [Gitlab CI only, will not be used by gitlab-ci-local](#gitlab-ci-only-will-not-be-used-by-gitlab-ci-local)
       * [Undecided](#undecided)
 
 # Installation
 ## Linux
 Download and put binary in `/usr/bin`
 
     $ sudo su `must be installed as root, if placed in /usr/bin/`
-    $ curl -L https://github.com/firecow/gitlab-local-pipeline/releases/latest/download/linux.gz | gunzip -c > /usr/bin/gitlab-local-pipeline
-    $ chmod +x /usr/bin/gitlab-local-pipeline
+    $ curl -L https://github.com/firecow/gitlab-ci-local/releases/latest/download/linux.gz | gunzip -c > /usr/bin/gitlab-ci-local
+    $ chmod +x /usr/bin/gitlab-ci-local
 
 ## Windows (Git bash)
 Install [gitbash](https://git-scm.com/downloads)
 
 Download and put binary in `C:\Program Files\Git\mingw64\bin`
 
-    $ curl -L https://github.com/firecow/gitlab-local-pipeline/releases/latest/download/win.gz | gunzip -c > /c/Program\ Files/Git/mingw64/bin/gitlab-local-pipeline.exe
+    $ curl -L https://github.com/firecow/gitlab-ci-local/releases/latest/download/win.gz | gunzip -c > /c/Program\ Files/Git/mingw64/bin/gitlab-ci-local.exe
 
 ## Macos
 TODO: Fill this
 
 # Usage
 ## Example
     $ cd /home/user/workspace/myproject
-    $ gitlab-local-pipeline
+    $ gitlab-ci-local
 
 ## Convinience
 ### Bash alias
-    $ echo "alias glp='gitlab-local-pipeline'" >> ~/.bashrc
+    $ echo "alias gcl='gitlab-ci-local'" >> ~/.bashrc
 ### Bash completion
 TODO: Fill this
 
@@ -106,7 +106,7 @@ Artifacts works right now, as along as you don't overwrite tracked files and as
 - services
 - image
 
-## Gitlab CI only, will not be used by gitlab-local-pipeline
+## Gitlab CI only, will not be used by gitlab-ci-local
 - cache
 - pages
 - resource_group

.idea/modules.xml

@@ -1,10 +1,10 @@
 {
-  "name": "gitlab-local-pipeline",
+  "name": "gitlab-ci-local",
   "main": "index.js",
   "scripts": {
-    "build-linux": "pkg dist/index.js -t node12-linux-x64 -o ./bin/linux/gitlab-local-pipeline && gzip -c bin/linux/gitlab-local-pipeline > bin/linux.gz",
-    "build-macos": "pkg dist/index.js -t node12-macos-x64 -o ./bin/macos/gitlab-local-pipeline && gzip -c bin/macos/gitlab-local-pipeline > bin/macos.gz",
-    "build-win": "pkg dist/index.js -t node12-win-x64 -o ./bin/win/gitlab-local-pipeline && gzip -c bin/win/gitlab-local-pipeline.exe > bin/win.gz",
+    "build-linux": "pkg dist/index.js -t node12-linux-x64 -o ./bin/linux/gitlab-ci-local && gzip -c bin/linux/gitlab-ci-local > bin/linux.gz",
+    "build-macos": "pkg dist/index.js -t node12-macos-x64 -o ./bin/macos/gitlab-ci-local && gzip -c bin/macos/gitlab-ci-local > bin/macos.gz",
+    "build-win": "pkg dist/index.js -t node12-win-x64 -o ./bin/win/gitlab-ci-local && gzip -c bin/win/gitlab-ci-local.exe > bin/win.gz",
     "build-all": "npm run build-linux && npm run build-macos && npm run build-win",
     "build": "tsc",
     "check-all": "npm run build && npm run --silent lint && npm audit --parseable && npm run ncu",

README.md

@@ -20,17 +20,6 @@ Array.prototype.first = function() {
     return this[0];
 };
 
-const makeid = (length: number): string => {
-    let result = "";
-    const characters = "abcdefghijklmnopqrstuvwxyz0123456789";
-    const charactersLength = characters.length;
-    for (let i = 0; i < length; i = i + 1) {
-        result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-
-    return result;
-};
-
 const argv = yargs.argv;
 const cwd = String(argv.cwd || process.cwd());
 const m: any = argv.m;
@@ -62,12 +51,12 @@ const runJobs = async () => {
         console.log(`=> ${c.yellow(`${stageName}`)} > ${c.blueBright(`${jobNames}`)} ${c.magentaBright("starting")}...`);
         for (const job of jobs) {
             if (job.isManual() && !manualArgs.includes(job.name)) {
-                console.log(`${c.blueBright(`${job.name}`)} skipped. when:manual`);
+                console.log(`${job.getJobNameString()} skipped. when:manual`);
                 continue;
             }
 
             if (job.isNever()) {
-                console.log(`${c.blueBright(`${job.name}`)} skipped. when:never`);
+                console.log(`${job.getJobNameString()} skipped. when:never`);
                 continue;
             }
 
@@ -117,18 +106,22 @@ process.on("uncaughtException", (err) => {
     console.log(err);
 });
 
+// Ensure gitlab-ci-local working directory and assets.
+const pipelinesStatePath = `${cwd}/.gitlab-ci-local/state.yml`;
+fs.ensureFileSync(pipelinesStatePath);
+let pipelinesState: any = yaml.safeLoad(fs.readFileSync(pipelinesStatePath, "utf8"));
+if (!pipelinesState) {
+    pipelinesState = {};
+}
+pipelinesState.pipelineId = pipelinesState.pipelineId !== undefined ? Number(pipelinesState.pipelineId) : 0;
+console.log(firstArg);
+if (["pipeline", "manual"].includes(firstArg)) {
+    pipelinesState.pipelineId += 1;
+}
+fs.writeFileSync(pipelinesStatePath, yaml.safeDump(pipelinesState), {});
+process.env.CI_PIPELINE_ID = pipelinesState.pipelineId;
+
 if (["pipeline", "manual"].includes(firstArg)) {
-    const pipelinesPath = `${cwd}/.gitlab-ci-local/pipelines.yml`;
-    const configPath = `${cwd}/.gitlab-ci-local/config.yml`;
-    fs.ensureFileSync(configPath);
-    fs.ensureFileSync(pipelinesPath);
-    let config: any = yaml.safeLoad(fs.readFileSync(pipelinesPath, "utf8"));
-    if (!config) {
-        config = {};
-    }
-    config.pipelineId = config.pipelineId !== undefined ? Number(config.pipelineId) + 1 : 0;
-    fs.writeFileSync(pipelinesPath, yaml.safeDump(config), {});
-    process.env.CI_PIPELINE_ID = config.pipelineId;
     runJobs().catch();
 } else if (firstArg === "exec") {
     runExecJobs().catch();

package-lock.json

@@ -2,6 +2,7 @@ import * as c from "ansi-colors";
 import * as deepExtend from "deep-extend";
 import * as fs from "fs-extra";
 import * as glob from "glob";
+import * as path from "path";
 import * as prettyHrtime from "pretty-hrtime";
 import * as shelljs from "shelljs";
 
@@ -17,24 +18,21 @@ if (process.env.EXEPATH) {
 
 export class Job {
     public readonly name: string;
-
     public readonly stage: string;
-    private readonly afterScripts: string[] = [];
 
+    private readonly afterScripts: string[] = [];
     private readonly allowFailure: boolean;
-
     private readonly beforeScripts: string[] = [];
-
     private readonly cwd: any;
     private readonly globals: any;
-
+    private readonly maxJobNameLength: number;
     private running = false;
     private readonly scripts: string[] = [];
-
     private readonly variables: { [key: string]: string };
     private readonly when: string;
 
-    public constructor(jobData: any, name: string, cwd: any, globals: any) {
+    public constructor(jobData: any, name: string, cwd: any, globals: any, maxJobNameLength: number) {
+        this.maxJobNameLength = maxJobNameLength;
         this.name = name;
         this.cwd = cwd;
         this.globals = globals;
@@ -67,6 +65,14 @@ export class Job {
         this.variables = jobData.variables || {};
     }
 
+    public getJobNameString() {
+        return `${c.blueBright(`${this.name.padEnd(this.maxJobNameLength + 1)}`)}`;
+    }
+
+    public getOutputFilesPath() {
+        return `${this.cwd}/.gitlab-ci-local/output/${this.getEnvs().CI_PIPELINE_ID}/${this.name}.log`;
+    }
+
     public isManual(): boolean {
         return this.when === "manual";
     }
@@ -76,10 +82,12 @@ export class Job {
     }
 
     public async start(): Promise<void> {
+        const jobNameStr = this.getJobNameString();
+
         this.running = true;
 
         if (this.scripts.length === 0) {
-            console.error(`${c.blueBright(`${this.name}`)} ${c.red("must have script specified")}`);
+            console.error(`${jobNameStr} ${c.red("must have script specified")}`);
             process.exit(1);
         }
 
@@ -131,11 +139,12 @@ export class Job {
     }
 
     private async exec(script: string): Promise<number> {
-        const outputFilePath = `${this.cwd}/.gitlab-ci-local/pipe_logs/${this.getEnvs().CI_PIPELINE_ID}/${this.name}.log`;
-        fs.ensureFileSync(outputFilePath);
-        fs.truncateSync(outputFilePath);
+        fs.ensureFileSync(this.getOutputFilesPath());
+        fs.truncateSync(this.getOutputFilesPath());
 
         return new Promise<any>((resolve, reject) => {
+            const jobNameStr = this.getJobNameString();
+            const outputFilesPath = this.getOutputFilesPath();
             const child = shelljs.exec(`${script}`, {
                 cwd: this.cwd,
                 env: this.getEnvs(),
@@ -145,17 +154,17 @@ export class Job {
             });
 
             child.on("error", (e) => {
-                reject(`${c.blueBright(`${this.name}`)} ${c.red(`error ${String(e)}`)}`);
+                reject(`${jobNameStr} ${c.red(`error ${String(e)}`)}`);
             });
 
             if (child.stdout) {
                 child.stdout.on("data", (buf) => {
-                    fs.appendFileSync(outputFilePath, `${buf}`);
+                    fs.appendFileSync(outputFilesPath, `${buf}`);
                 });
             }
             if (child.stderr) {
                 child.stderr.on("data", (buf) => {
-                    fs.appendFileSync(outputFilePath, `${c.red(`${buf}`)}`);
+                    fs.appendFileSync(outputFilesPath, `${c.red(`${buf}`)}`);
                 });
             }
 
@@ -168,15 +177,20 @@ export class Job {
     }
 
     private getExitedString(code: number, warning: boolean = false, prependString: string = "") {
-        const mistakeStr = warning ? c.yellowBright(`warning with code ${code}`) + prependString : c.red(`exited with code ${code}`) + prependString;
+        const seeLogStr = `See ${path.resolve(this.getOutputFilesPath())}`;
+        const jobNameStr = this.getJobNameString();
+        if (warning) {
+            return `${jobNameStr} ${c.yellowBright(`warning with code ${code}`)} ${prependString} ${seeLogStr}`;
+        }
 
-        return `${c.blueBright(`${this.name}`)} ${mistakeStr}`;
+        return `${jobNameStr} ${c.red(`exited with code ${code}`)} ${prependString} ${seeLogStr}`;
     }
 
     private getFinishedString(startTime: [number, number]) {
         const endTime = process.hrtime(startTime);
         const timeStr = prettyHrtime(endTime);
+        const jobNameStr = this.getJobNameString();
 
-        return `${c.blueBright(`${this.name}`)} ${c.magentaBright("finished")} in ${c.magenta(`${timeStr}`)}`;
+        return `${jobNameStr} ${c.magentaBright("finished")} in ${c.magenta(`${timeStr}`)}`;
     }
 }

package.json

@@ -8,53 +8,51 @@ import { Stage } from "./stage";
 
 export class Parser {
 
+    private static loadYaml(filePath: string): any {
+        const gitlabCiLocalYmlPath = `${filePath}`;
+        if (!fs.existsSync(gitlabCiLocalYmlPath)) {
+            return {};
+        }
+
+        return yaml.safeLoad(fs.readFileSync(`${filePath}`, "utf8"));
+    }
+
     private readonly illigalJobNames = [
         "include", "local_configuration", "image", "services",
         "stages", "pages", "types", "before_script", "default",
         "after_script", "variables", "cache", "include",
     ];
     private readonly jobs: Map<string, Job> = new Map();
+
+    private readonly maxJobNameLength: number = 0;
     private readonly stages: Map<string, Stage> = new Map();
 
     public constructor(cwd: any) {
-        // Fail if .gitlab-ci.yml missing
-        const gitlabCiYmlPath = `${cwd}/.gitlab-ci.yml`;
-        if (!fs.existsSync(gitlabCiYmlPath)) {
-            console.error(`Could not find ${gitlabCiYmlPath}`);
-            process.exit(1);
-        }
-
-        // Fail if .gitlab-ci.local.yml missing
-        const gitlabCiLocalYmlPath = `${cwd}/.gitlab-ci.local.yml`;
-        if (!fs.existsSync(gitlabCiLocalYmlPath)) {
-            console.error(`Could not find ${gitlabCiLocalYmlPath}`);
-            process.exit(1);
-        }
 
         const orderedVariables = [];
         const orderedYml = [];
 
-        // Parse .gitlab-ci.yml
-        orderedYml.push(yaml.safeLoad(fs.readFileSync(gitlabCiYmlPath, "utf8")));
-        if (!orderedYml.last()) { // Print if empty
+        // Add .gitlab-ci.yml
+        orderedYml.push(Parser.loadYaml(`${cwd}/.gitlab-ci.yml`));
+        if (!orderedYml.last()) { // Fail if empty
             console.error(`${cwd}/.gitlab-ci.yml is empty`);
             process.exit(1);
         }
         orderedVariables.push(orderedYml.last().variables);
 
-        // Parse .gitlab-ci.local.yml
-        orderedYml.push(yaml.safeLoad(fs.readFileSync(gitlabCiLocalYmlPath, "utf8")) || {});
+        // Add .gitlab-ci.yml
+        orderedYml.push(Parser.loadYaml(`${cwd}/.gitlab-ci-local.yml`));
         orderedVariables.push(orderedYml.last().variables || {});
 
-        // Parse yamls included by other ci files.
+        // Add included yaml's.
         orderedYml.unshift({});
         const includes = deepExtend.apply(this, orderedYml).include || [];
         for (const value of includes) {
             if (!value.local) {
                 continue;
             }
 
-            orderedYml.unshift(yaml.safeLoad(fs.readFileSync(`${cwd}/${value.local}`, "utf8")));
+            orderedYml.unshift(Parser.loadYaml(`${cwd}/${value.local}`));
             orderedVariables.unshift(orderedYml.first().variables || {});
         }
 
@@ -73,13 +71,21 @@ export class Parser {
             this.stages.set(value, new Stage(value));
         }
 
+        // Find longest job name
+        for (const key of Object.keys(gitlabData)) {
+            if (this.illigalJobNames.includes(key) || key[0] === ".") {
+                continue;
+            }
+            this.maxJobNameLength = Math.max(this.maxJobNameLength, key.length);
+        }
+
         // Generate jobs and put them into stages
         for (const [key, value] of Object.entries(gitlabData)) {
             if (this.illigalJobNames.includes(key) || key[0] === ".") {
                 continue;
             }
 
-            const job = new Job(value, key, cwd, gitlabData);
+            const job = new Job(value, key, cwd, gitlabData, this.maxJobNameLength);
             const stage = this.stages.get(job.stage);
             if (stage) {
                 stage.addJob(job);

src/index.ts

@@ -12,4 +12,4 @@ never_job:
   when: never
   stage: startup
   script:
-    - echo "I'm when:never i could have only been called by 'gitlab-local-pipeline exec never_job'"
+    - echo "I'm when:never i could have only been called by 'gitlab-ci-local exec never_job'"

src/job.ts

@@ -56,6 +56,7 @@ var_in_another_file:
 after_script_test:
   <<: *tags
   stage: last
+  needs: [var_in_another_file]
   script:
     - echo "Throwing an error"
     - exit 1
@@ -76,4 +77,4 @@ manual_job_invoked_from_cli:
   when: manual
   stage: last
   script:
-    - echo "I was invoked manually, because 'gitlab-local-pipeline manual manual_job_invoked_from_cli' was called"
+    - echo "I was invoked manually, because 'gitlab-ci-local manual manual_job_invoked_from_cli' was called"