Plato - lib/jenkins.js

"use strict";
import cron from "cron";
import jenkins from "./api/jenkins.js";
import job from "./api/job.js";
import Swaggy from "swaggy-jenkins";
import _url from "url";
import util from "./cli/util.js";
import view from "./api/view.js";
import fs from "fs";

function _authFail(result, cb) {
  cb(new Error("Authentication failed - incorrect username and/or password"));
}

function _authRequire(result, cb) {
  cb(
    new Error(
      "Jenkins requires authentication - please set username and password",
    ),
  );
}

/**
 * class Jenkins
 *
 * @param {String} url: Jenkins URL, fallback to JENKINS_URL environment variable, otherwise default to http://localhost:8080
 */
class Jenkins {
  constructor(url) {
    this.url = url || process.env.JENKINS_URL || "http://localhost:8080";

// base URL is needed for functionalities that operate against base Jenkins path
    // this is needed for retrieving Jenkins crumb where the URL might contain paths to folders,
    // but the the Jenkins crumb retrieval still needs to be executed against the base Jenkins path
    const parsedUrl = _url.parse(this.url);
    this.baseUrl = this.url.replace(parsedUrl.path, "");

const cert = process.env.JENKINS_CERT;
    const ca = process.env.JENKINS_CA;
    const key = process.env.JENKINS_KEY;
    this.opts = {
      handlers: {
        401: _authFail,
        403: _authRequire,
      },
    };

this.remoteAccessApi = new Swaggy.RemoteAccessApi();
    this.remoteAccessApi.apiClient.basePath = this.url;

// a new Swaggy.ApiClient must be created here in order
    // to force baseApi to not share the same ApiClient as
    // remoteAccessApi
    // this is necessary because baseApi uses a URL that could be
    // different to remoteAccessApi
    this.baseApi = new Swaggy.BaseApi(new Swaggy.ApiClient());
    this.baseApi.apiClient.basePath = this.baseUrl;

if (cert) {
      const key_path = key.split(":")[0];
      const passphrase = key.split(":")[1];
      this.opts.agentOptions = {
        passphrase: passphrase,
        secureProtocol: "TLSv1_method",
      };
      if (cert && fs.statSync(cert)) {
        this.opts.agentOptions.cert = fs.readFileSync(cert);
      }
      if (key_path && fs.statSync(key_path)) {
        this.opts.agentOptions.key = fs.readFileSync(key_path);
      }
      if (ca && fs.statSync(ca)) {
        this.opts.agentOptions.ca = fs.readFileSync(ca);
      }
    }
  }
}

/**
 * Add Jenkins crumb header to instance.
 * This is needed for Jenkins installations that have CSRF protection enabled.
 * New installations of Jenkins starting version 2.x enables CSRF protection by default.
 * https://wiki.jenkins-ci.org/display/JENKINS/CSRF+Protection
 *
 * @param {Function} cb: standard cb(err, result) callback
 */
function csrf(cb) {
  const self = this;

this.opts.headers = this.opts.headers || {};

function resultCb(err, data, response) {
    if (!err) {
      self.opts.headers[data.crumbRequestField] = data.crumb;
      self.opts.headers.jenkinsCrumb = data.crumb;
    }
    cb(err, data);
  }

this.crumb(resultCb);
}

/**
 * Summarise executor information from computers array.
 *
 * @param {Array} computers: computers array, part of Jenkins#computer result
 * @return executor summary object
 */
function executorSummary(computers) {
  const data = {};

computers.forEach(function (computer) {
    let idleCount = 0;
    let activeCount = 0;

data[computer.displayName] = { executors: [] };

computer.executors.forEach(function (executor) {
      data[computer.displayName].executors.push({
        idle: executor.idle,
        stuck: executor.likelyStuck,
        progress: executor.progress,
        name:
          !executor.idle && executor.currentExecutable.url
            ? executor.currentExecutable.url
                .replace(/.*\/job\//, "")
                .replace(/\/.*/, "")
            : undefined,
      });

if (executor.idle) {
        idleCount += 1;
      } else {
        activeCount += 1;
      }
    });

const summary = [];
    if (activeCount > 0) {
      summary.push(`${activeCount} active`);
    }
    if (idleCount > 0) {
      summary.push(`${idleCount} idle`);
    }

data[computer.displayName].summary = summary.join(", ");
  });

return data;
}

/**
 * Monitor Jenkins latest build status on a set interval.
 *
 * @param {Object} opts: optional
 * - job: Jenkins job name
 * - view: Jenkins view name
 * - schedule: cron scheduling definition in standard * * * * * * format, default: 0 * * * * * (every minute)
 * @param {Function} cb: standard cb(err, result) callback
 */
function monitor(opts, cb) {
  const self = this;

function singleJobResultCb(err, result) {
    if (!err) {
      result = util.statusByColor(result.color);
    }
    cb(err, result);
  }

// when there are multiple jobs, status is derived following these rules:
  // - fail if any job has Jenkins color red
  // - warn if any job has Jenkins color yellow but no red
  // - non-success (e.g. notbuilt) if any job has Jenkins color status but no red and yellow
  // - success only if all jobs are either blue or green
  function multiJobsResultCb(err, result) {
    if (!err) {
      let hasRed = false;
      let hasYellow = false;
      let hasNonSuccess = false;
      let hasSuccess = false;

let successColor;
      let nonSuccessColor;

result.jobs.forEach(function (job) {
        if (job.color === "red") {
          hasRed = true;
        }
        if (job.color === "yellow") {
          hasYellow = true;
        }
        if (["red", "yellow", "blue", "green"].indexOf(job.color) === -1) {
          hasNonSuccess = true;
          nonSuccessColor = job.color;
        }
        if (job.color === "blue" || job.color === "green") {
          hasSuccess = true;
          successColor = job.color;
        }
      });

let resultColor;
      if (hasRed) {
        resultColor = "red";
      } else if (hasYellow) {
        resultColor = "yellow";
      } else if (hasNonSuccess) {
        resultColor = nonSuccessColor;
      } else {
        resultColor = successColor;
      }

result = util.statusByColor(resultColor);
    }
    cb(err, result);
  }

_notify();
  new cron.CronJob(opts.schedule || "0 * * * * *", _notify).start();
}

Jenkins.prototype.csrf = csrf;
Jenkins.prototype.discover = jenkins.discover;
Jenkins.prototype.computer = jenkins.computer;
Jenkins.prototype.crumb = jenkins.crumb;
Jenkins.prototype.info = jenkins.info;
Jenkins.prototype.monitor = monitor;
Jenkins.prototype.parseFeed = jenkins.parseFeed;
Jenkins.prototype.queue = jenkins.queue;
Jenkins.prototype.version = jenkins.version;

Jenkins.prototype.createJob = job.create;
Jenkins.prototype.readJob = job.read;
Jenkins.prototype.readLatestJob = job.readLatest;
Jenkins.prototype.updateJob = job.update;
Jenkins.prototype.deleteJob = job.delete;
Jenkins.prototype.buildJob = job.build;
Jenkins.prototype.checkBuildStarted = job.checkStarted;
Jenkins.prototype.stopJob = job.stop;
Jenkins.prototype.streamJobConsole = job.streamConsole;
Jenkins.prototype.enableJob = job.enable;
Jenkins.prototype.disableJob = job.disable;
Jenkins.prototype.copyJob = job.copy;
Jenkins.prototype.fetchJobConfig = job.fetchConfig;
Jenkins.prototype.parseJobFeed = job.parseFeed;

Jenkins.prototype.createView = view.create;
Jenkins.prototype.readView = view.read;
Jenkins.prototype.updateView = view.update;
Jenkins.prototype.fetchViewConfig = view.fetchConfig;
Jenkins.prototype.parseViewFeed = view.parseFeed;

Jenkins.executorSummary = executorSummary;

export { Jenkins as default };

lib/jenkins.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC