gitlab-radiator 4.0.0 → 4.1.0

package/src/app.js

@@ -1,129 +1,85 @@
-"use strict";
+import {basicAuth} from './auth.js'
+import compression from 'compression'
+import {config} from './config.js'
+import express from 'express'
+import fs from 'fs'
+import {fetchOfflineRunners} from './gitlab/runners.js'
+import http from 'http'
+import path from 'path'
+import {serveLessAsCss} from './less.js'
+import {Server} from 'socket.io'
+import {update} from './gitlab/index.js'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _auth = require("./auth");
-var _compression = _interopRequireDefault(require("compression"));
-var _config = require("./config");
-var _express = _interopRequireDefault(require("express"));
-var _runners = require("./gitlab/runners");
-var _http = _interopRequireDefault(require("http"));
-var _path = _interopRequireDefault(require("path"));
-var _less = require("./less");
-var _socket = _interopRequireDefault(require("socket.io"));
-var _gitlab = require("./gitlab");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var app = (0, _express.default)();
-var httpServer = _http.default.Server(app);
-var socketIoServer = (0, _socket.default)(httpServer);
-if (process.env.NODE_ENV !== 'production') {
+const app = express()
+const httpServer = http.Server(app)
+const socketIoServer = new Server(httpServer)
+
+if (process.env.NODE_ENV !== 'production' && fs.existsSync('./src/dev-assets.js')) {
   // eslint-disable-next-line global-require
-  var _require = require('./dev-assets'),
-    bindDevAssets = _require.bindDevAssets;
-  bindDevAssets(app);
+  const {bindDevAssets} = await import('./dev-assets.js')
+  bindDevAssets(app)
 }
-app.disable('x-powered-by');
-app.get('/client.css', _less.serveLessAsCss);
-app.use(_express.default.static(_path.default.join(__dirname, '..', 'public')));
-app.use((0, _compression.default)());
-app.use((0, _auth.basicAuth)(_config.config.auth));
-httpServer.listen(_config.config.port, () => {
+
+app.disable('x-powered-by')
+app.get('/client.css', serveLessAsCss)
+app.use(express.static('public'))
+app.use(compression())
+app.use(basicAuth(config.auth))
+
+httpServer.listen(config.port, () => {
   // eslint-disable-next-line no-console
-  console.log("Listening on port *:".concat(_config.config.port));
-});
-var globalState = {
+  console.log(`Listening on port *:${config.port}`)
+})
+
+const globalState = {
   projects: null,
   error: null,
-  zoom: _config.config.zoom,
-  projectsOrder: _config.config.projectsOrder,
-  columns: _config.config.columns,
-  groupSuccessfulProjects: _config.config.groupSuccessfulProjects
-};
-socketIoServer.on('connection', socket => {
-  socket.emit('state', withDate(globalState));
-});
-function runUpdate() {
-  return _runUpdate.apply(this, arguments);
-}
-function _runUpdate() {
-  _runUpdate = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.prev = 0;
-          _context.next = 3;
-          return (0, _gitlab.update)(_config.config);
-        case 3:
-          globalState.projects = _context.sent;
-          _context.next = 6;
-          return errorIfRunnerOffline();
-        case 6:
-          globalState.error = _context.sent;
-          socketIoServer.emit('state', withDate(globalState));
-          _context.next = 15;
-          break;
-        case 10:
-          _context.prev = 10;
-          _context.t0 = _context["catch"](0);
-          // eslint-disable-next-line no-console
-          console.error(_context.t0.message);
-          globalState.error = "Failed to communicate with GitLab API: ".concat(_context.t0.message);
-          socketIoServer.emit('state', withDate(globalState));
-        case 15:
-          setTimeout(runUpdate, _config.config.interval);
-        case 16:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[0, 10]]);
-  }));
-  return _runUpdate.apply(this, arguments);
+  zoom: config.zoom,
+  projectsOrder: config.projectsOrder,
+  columns: config.columns,
+  groupSuccessfulProjects: config.groupSuccessfulProjects
 }
-function errorIfRunnerOffline() {
-  return _errorIfRunnerOffline.apply(this, arguments);
+
+socketIoServer.on('connection', (socket) => {
+  socket.emit('state', withDate(globalState))
+})
+
+async function runUpdate() {
+  try {
+    globalState.projects = await update(config)
+    globalState.error = await errorIfRunnerOffline()
+    socketIoServer.emit('state', withDate(globalState))
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error(error.message)
+    globalState.error = `Failed to communicate with GitLab API: ${error.message}`
+    socketIoServer.emit('state', withDate(globalState))
+  }
+  setTimeout(runUpdate, config.interval)
 }
-function _errorIfRunnerOffline() {
-  _errorIfRunnerOffline = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-    var offlineRunnersPerGitlab, _offlineRunnersPerGit, offline, totalCount, names, counts;
-    return _regenerator.default.wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          _context2.next = 2;
-          return Promise.all(_config.config.gitlabs.map(_runners.fetchOfflineRunners));
-        case 2:
-          offlineRunnersPerGitlab = _context2.sent;
-          _offlineRunnersPerGit = offlineRunnersPerGitlab.reduce((acc, runner) => {
-            return {
-              offline: acc.offline.concat(runner.offline),
-              totalCount: acc.totalCount + runner.totalCount
-            };
-          }, {
-            offline: [],
-            totalCount: 0
-          }), offline = _offlineRunnersPerGit.offline, totalCount = _offlineRunnersPerGit.totalCount;
-          if (!(offline.length > 0)) {
-            _context2.next = 8;
-            break;
-          }
-          names = offline.map(r => r.name).sort().join(', ');
-          counts = offline.length === totalCount ? 'All' : "".concat(offline.length, "/").concat(totalCount);
-          return _context2.abrupt("return", "".concat(counts, " runners offline: ").concat(names));
-        case 8:
-          return _context2.abrupt("return", null);
-        case 9:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return _errorIfRunnerOffline.apply(this, arguments);
+
+async function errorIfRunnerOffline() {
+  const offlineRunnersPerGitlab = await Promise.all(config.gitlabs.map(fetchOfflineRunners))
+  const {offline, totalCount} = offlineRunnersPerGitlab.reduce((acc, runner) => {
+    return {
+      offline: acc.offline.concat(runner.offline),
+      totalCount: acc.totalCount + runner.totalCount
+    }
+  }, {offline: [], totalCount: 0})
+
+  if (offline.length > 0) {
+    const names = offline.map(r => r.name).sort().join(', ')
+    const counts = offline.length === totalCount ? 'All' : `${offline.length}/${totalCount}`
+    return `${counts} runners offline: ${names}`
+  }
+  return null
 }
-runUpdate();
+
+runUpdate()
+
 function withDate(state) {
-  return _objectSpread(_objectSpread({}, state), {}, {
+  return {
+    ...state,
     now: Date.now()
-  });
-}
+  }
+}

package/src/auth.js

@@ -1,29 +1,21 @@
-"use strict";
+import authenticate from 'basic-auth'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.basicAuth = basicAuth;
-var _basicAuth = _interopRequireDefault(require("basic-auth"));
-function basicAuth(auth) {
+export function basicAuth(auth) {
   if (!auth || !auth.username || !auth.password) {
     // eslint-disable-next-line no-console
-    console.log('No authentication configured');
-    return (req, res, next) => next();
+    console.log('No authentication configured')
+    return (req, res, next) => next()
   }
 
   // eslint-disable-next-line no-console
-  console.log('HTTP basic auth enabled');
+  console.log('HTTP basic auth enabled')
   return (req, res, next) => {
-    var _ref = (0, _basicAuth.default)(req) || {},
-      name = _ref.name,
-      pass = _ref.pass;
+    const {name, pass} = authenticate(req) || {}
     if (auth.username === name && auth.password === pass) {
-      next();
+      next()
     } else {
-      res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"');
-      res.status(401).end();
+      res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"')
+      res.status(401).end()
     }
-  };
-}
+  }
+}

package/src/config.js

@@ -1,46 +1,43 @@
-"use strict";
+import assert from 'assert'
+import fs from 'fs'
+import os from 'os'
+import yaml from 'js-yaml'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.config = void 0;
-var _assert = _interopRequireDefault(require("assert"));
-var _fs = _interopRequireDefault(require("fs"));
-var _os = _interopRequireDefault(require("os"));
-var _jsYaml = _interopRequireDefault(require("js-yaml"));
-var configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml');
-var yamlContent = _fs.default.readFileSync(configFile, 'utf8');
-var config = exports.config = validate(_jsYaml.default.load(yamlContent));
-config.interval = Number(config.interval || 10) * 1000;
-config.port = Number(config.port || 3000);
-config.zoom = Number(config.zoom || 1.0);
-config.columns = Number(config.columns || 1);
-config.groupSuccessfulProjects = config.groupSuccessfulProjects || false;
-config.projectsOrder = config.projectsOrder || ['name'];
-config.gitlabs = config.gitlabs.map(gitlab => {
+const configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml')
+const yamlContent = fs.readFileSync(configFile, 'utf8')
+export const config = validate(yaml.load(yamlContent))
+
+config.interval = Number(config.interval || 10) * 1000
+config.port = Number(config.port || 3000)
+config.zoom = Number(config.zoom || 1.0)
+config.columns = Number(config.columns || 1)
+config.groupSuccessfulProjects = config.groupSuccessfulProjects || false
+config.projectsOrder = config.projectsOrder || ['name']
+config.gitlabs = config.gitlabs.map((gitlab) => {
   return {
     url: gitlab.url,
     ignoreArchived: gitlab.ignoreArchived === undefined ? true : gitlab.ignoreArchived,
     maxNonFailedJobsVisible: Number(gitlab.maxNonFailedJobsVisible || 999999),
-    ca: gitlab.caFile && _fs.default.existsSync(gitlab.caFile, 'utf-8') ? _fs.default.readFileSync(gitlab.caFile) : undefined,
+    ca: gitlab.caFile && fs.existsSync(gitlab.caFile, 'utf-8') ? fs.readFileSync(gitlab.caFile) : undefined,
     'access-token': gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN,
     projects: {
       excludePipelineStatus: (gitlab.projects || {}).excludePipelineStatus || [],
       include: (gitlab.projects || {}).include || '',
       exclude: (gitlab.projects || {}).exclude || ''
     }
-  };
-});
-config.colors = config.colors || {};
+  }
+})
+config.colors = config.colors || {}
+
 function expandTilde(path) {
-  return path.replace(/^~($|\/|\\)/, "".concat(_os.default.homedir(), "$1"));
+  return path.replace(/^~($|\/|\\)/, `${os.homedir()}$1`)
 }
+
 function validate(cfg) {
-  _assert.default.ok(cfg.gitlabs, 'Mandatory gitlab properties missing from configuration file');
-  cfg.gitlabs.forEach(gitlab => {
-    _assert.default.ok(gitlab.url, 'Mandatory gitlab url missing from configuration file');
-    _assert.default.ok(gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN, 'Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)');
-  });
-  return cfg;
-}
+  assert.ok(cfg.gitlabs, 'Mandatory gitlab properties missing from configuration file')
+  cfg.gitlabs.forEach((gitlab) => {
+    assert.ok(gitlab.url, 'Mandatory gitlab url missing from configuration file')
+    assert.ok(gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN, 'Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)')
+  })
+  return cfg
+}

package/src/gitlab/client.js

@@ -1,38 +1,27 @@
-"use strict";
+import axios from 'axios'
+import https from 'https'
+import url from 'url'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.gitlabRequest = gitlabRequest;
-var _axios = _interopRequireDefault(require("axios"));
-var _https = _interopRequireDefault(require("https"));
-var _url = _interopRequireDefault(require("url"));
-function gitlabRequest(path, params, gitlab) {
-  return lazyClient(gitlab).get(path, {
-    params
-  });
+export function gitlabRequest(path, params, gitlab) {
+  return lazyClient(gitlab).get(path, {params})
 }
-var clients = new Map();
+
+const clients = new Map()
+
 function lazyClient(gitlab) {
-  var gitlabUrl = gitlab.url;
+  const gitlabUrl = gitlab.url
   if (gitlabUrl === undefined) {
     // eslint-disable-next-line no-console
-    console.log('Got undefined url for ' + JSON.stringify(gitlab));
+    console.log('Got undefined url for ' + JSON.stringify(gitlab))
   }
   if (!clients.get(gitlabUrl)) {
-    var client = _axios.default.create({
-      baseURL: _url.default.resolve(gitlabUrl, '/api/v4/'),
-      headers: {
-        'PRIVATE-TOKEN': gitlab['access-token']
-      },
-      httpsAgent: new _https.default.Agent({
-        keepAlive: true,
-        ca: gitlab.ca
-      }),
-      timeout: 30 * 1000
-    });
-    clients.set(gitlabUrl, client);
+    const client = axios.create({
+        baseURL: url.resolve(gitlabUrl, '/api/v4/'),
+        headers: {'PRIVATE-TOKEN': gitlab['access-token']},
+        httpsAgent: new https.Agent({keepAlive: true, ca: gitlab.ca}),
+        timeout: 30 * 1000
+      })
+    clients.set(gitlabUrl, client)
   }
-  return clients.get(gitlabUrl);
-}
+  return clients.get(gitlabUrl)
+}

package/src/gitlab/index.js

@@ -1,138 +1,55 @@
-"use strict";
+import {fetchLatestPipelines} from './pipelines.js'
+import {fetchProjects} from './projects.js'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.update = update;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _pipelines = require("./pipelines");
-var _projects = require("./projects");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function update(_x) {
-  return _update.apply(this, arguments);
+export async function update(config) {
+  const projectsWithPipelines = await loadProjectsWithPipelines(config)
+  return projectsWithPipelines
+    .filter(project => project.pipelines.length > 0)
 }
-function _update() {
-  _update = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(config) {
-    var projectsWithPipelines;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.next = 2;
-          return loadProjectsWithPipelines(config);
-        case 2:
-          projectsWithPipelines = _context.sent;
-          return _context.abrupt("return", projectsWithPipelines.filter(project => project.pipelines.length > 0));
-        case 4:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _update.apply(this, arguments);
-}
-function loadProjectsWithPipelines(_x2) {
-  return _loadProjectsWithPipelines.apply(this, arguments);
-}
-function _loadProjectsWithPipelines() {
-  _loadProjectsWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(config) {
-    var allProjectsWithPipelines;
-    return _regenerator.default.wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
-        case 0:
-          allProjectsWithPipelines = [];
-          _context3.next = 3;
-          return Promise.all(config.gitlabs.map( /*#__PURE__*/function () {
-            var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
-              var projects, projectsWithPipelines;
-              return _regenerator.default.wrap(function _callee2$(_context2) {
-                while (1) switch (_context2.prev = _context2.next) {
-                  case 0:
-                    _context2.next = 2;
-                    return (0, _projects.fetchProjects)(gitlab);
-                  case 2:
-                    projects = _context2.sent;
-                    projects.forEach(project => {
-                      project.maxNonFailedJobsVisible = gitlab.maxNonFailedJobsVisible;
-                    });
-                    _context2.next = 6;
-                    return Promise.all(projects.map(project => projectWithPipelines(project, gitlab)));
-                  case 6:
-                    projectsWithPipelines = _context2.sent;
-                    allProjectsWithPipelines.push.apply(allProjectsWithPipelines, (0, _toConsumableArray2.default)(projectsWithPipelines));
-                  case 8:
-                  case "end":
-                    return _context2.stop();
-                }
-              }, _callee2);
-            }));
-            return function (_x5) {
-              return _ref3.apply(this, arguments);
-            };
-          }()));
-        case 3:
-          return _context3.abrupt("return", allProjectsWithPipelines);
-        case 4:
-        case "end":
-          return _context3.stop();
-      }
-    }, _callee3);
-  }));
-  return _loadProjectsWithPipelines.apply(this, arguments);
-}
-function projectWithPipelines(_x3, _x4) {
-  return _projectWithPipelines.apply(this, arguments);
+
+async function loadProjectsWithPipelines(config) {
+  const allProjectsWithPipelines = []
+  await Promise.all(config.gitlabs.map(async (gitlab) => {
+    const projects = (await fetchProjects(gitlab))
+      .map(project => ({
+        ...project,
+        maxNonFailedJobsVisible: gitlab.maxNonFailedJobsVisible
+      }))
+
+    for (const project of projects) {
+      allProjectsWithPipelines.push(await projectWithPipelines(project, gitlab))
+    }
+  }))
+  return allProjectsWithPipelines
 }
-function _projectWithPipelines() {
-  _projectWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(project, config) {
-    var pipelines, status;
-    return _regenerator.default.wrap(function _callee4$(_context4) {
-      while (1) switch (_context4.prev = _context4.next) {
-        case 0:
-          _context4.t0 = filterOutEmpty;
-          _context4.next = 3;
-          return (0, _pipelines.fetchLatestPipelines)(project.id, config);
-        case 3:
-          _context4.t1 = _context4.sent;
-          pipelines = (0, _context4.t0)(_context4.t1).filter(excludePipelineStatusFilter(config));
-          status = defaultBranchStatus(project, pipelines);
-          return _context4.abrupt("return", _objectSpread(_objectSpread({}, project), {}, {
-            pipelines,
-            status
-          }));
-        case 7:
-        case "end":
-          return _context4.stop();
-      }
-    }, _callee4);
-  }));
-  return _projectWithPipelines.apply(this, arguments);
+
+async function projectWithPipelines(project, config) {
+  const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, config))
+    .filter(excludePipelineStatusFilter(config))
+  const status = defaultBranchStatus(project, pipelines)
+  return {
+    ...project,
+    pipelines,
+    status
+  }
 }
+
 function defaultBranchStatus(project, pipelines) {
-  var _pipelines$filter$map = pipelines.filter(_ref => {
-      var ref = _ref.ref;
-      return ref === project.default_branch;
-    }).map(_ref2 => {
-      var status = _ref2.status;
-      return status;
-    }),
-    _pipelines$filter$map2 = (0, _slicedToArray2.default)(_pipelines$filter$map, 1),
-    head = _pipelines$filter$map2[0];
-  return head;
+  const [head] = pipelines
+    .filter(({ref}) => ref === project.default_branch)
+    .map(({status}) => status)
+  return head
 }
+
 function filterOutEmpty(pipelines) {
-  return pipelines.filter(pipeline => pipeline.stages);
+  return pipelines.filter(pipeline => pipeline.stages)
 }
+
 function excludePipelineStatusFilter(config) {
   return pipeline => {
     if (config.projects && config.projects.excludePipelineStatus) {
-      return !config.projects.excludePipelineStatus.includes(pipeline.status);
+      return !config.projects.excludePipelineStatus.includes(pipeline.status)
     }
-    return true;
-  };
-}
+    return true
+  }
+}